00001
00005 #define DKUTIL_C_STRING_C
00006 #include "dkcString.h"
00007 #include "dkcStdio.h"
00008 #include "dkcOSIndependent.h"
00009 #include <limits.h>
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 static const BYTE SJIS1_S1 = 0x81;
00027 static const BYTE SJIS1_E1 = 0x9f;
00028 static const BYTE SJIS1_S2 = 0xe0;
00029 static const BYTE SJIS1_E2 = 0xf5;
00030
00031
00032 static const BYTE SJIS2_S1 = 0x40;
00033 static const BYTE SJIS2_E1 = 0x7e;
00034 static const BYTE SJIS2_S2 = 0x80;
00035 static const BYTE SJIS2_E2 = 0xfc;
00036
00037
00038
00039
00040 BOOL dkcIsSJIS1(BYTE c)
00041 {
00042
00043
00044
00045
00046
00047
00048
00049 return ((c ^= 0x20) && (c >= (SJIS1_S1 ^ 0x20) && c <= (SJIS1_E2 ^ 0x20)));
00050 }
00051
00052 BOOL dkcIsSJIS2(BYTE c)
00053 {
00054
00055
00056
00057 return (c >= SJIS2_S1 && c <= SJIS2_E1) || (c >= SJIS2_S2 && c <= SJIS2_E2);
00058 }
00059
00060 BOOL dkcIsSpace(BYTE c)
00061 {
00062 return (c=='\0' || c==0x0a || c==0x0d || c==' ' || c=='\t');
00063 }
00064
00065 const char *dkcGetSpaceSeparator(){
00066 static const char temp[]={
00067 '\0',0x0a,0x0d,' ','\t'
00068 };
00069 return temp;
00070 }
00071
00072
00073 int WINAPI dkcSJIS_StrChrSearch(const char *s, char c)
00074 {
00075
00076 int i;
00077 for(i = 0; ; i++){
00078 if(s[i] == c) return i;
00079 if(s[i] == '\0') break;
00080 if(dkcmIsSJIS1(s[i]) && dkcmIsSJIS2(s[i + 1])) i++;
00081 }
00082 return -1;
00083 }
00084
00085
00086 int WINAPI dkcSJIS_StrChrSearchLast(const char *s, char c)
00087 {
00088 int nLast = -1,i;
00089
00090 for(i = 0; ; i++){
00091 if(s[i] == c) nLast = i;
00092 if(s[i] == '\0') break;
00093 if(dkcmIsSJIS1(s[i]) && dkcmIsSJIS2(s[i + 1])) i++;
00094 }
00095 return nLast;
00096 }
00097
00098 int WINAPI dkcSJIS_StrChrSearchTail(const char *s,size_t len,char c){
00099 int i;
00100 for(i=len;i > 0;i--){
00101 if(dkcmIsSJIS1(s[i - 1]) && dkcmIsSJIS2(s[i]) )
00102 {
00103 i--;
00104 continue;
00105 }
00106 if(s[i] == c) return i;
00107 }
00108
00109 if(! (dkcmIsSJIS1(s[i]) && dkcmIsSJIS2(s[i + 1]) ))
00110 {
00111 if(c==s[i]){
00112 return 0;
00113 }
00114 }
00115 return -1;
00116 }
00117
00118 int WINAPI dkcSJIS_StrChrSearchInStr(const char *s,const char *c)
00119 {
00120
00121 size_t i,j;
00122 size_t len = strlen(c);
00123 for(i = 0; ; i++){
00124 if(s[i] == '\0') break;
00125 if(dkcmIsSJIS1(s[i]) && dkcmIsSJIS2(s[i + 1])){
00126 i++;
00127 continue;
00128 }
00129 for(j=0;j<len;j++){
00130 if(s[i] == c[j]) return i;
00131 }
00132 }
00133 return -1;
00134 }
00135
00136 int WINAPI dkcSJIS_StrChrSearchInStrLast(const char *s, const char *c)
00137 {
00138 int nLast = -1;
00139 size_t i,j;
00140 size_t len = strlen(c);
00141
00142 for(i = 0; ; i++){
00143 if(s[i] == '\0') break;
00144 if(dkcmIsSJIS1(s[i]) && dkcmIsSJIS2(s[i + 1])){
00145 i++;
00146 continue;
00147 }
00148 for(j=0;j<len;j++){
00149 if(s[i] == c[j]) nLast = i;
00150 }
00151 }
00152 return nLast;
00153 }
00154
00155 int WINAPI dkcSJIS_SearchPathSep(const char *s)
00156 {
00157 const char *target = dkcGetPathSep();
00158 return dkcSJIS_StrChrSearchInStr(s,target);
00159 }
00160
00161 int WINAPI dkcSJIS_SearchPathSepLast(const char *s)
00162 {
00163 const char *target = dkcGetPathSep();
00164 return dkcSJIS_StrChrSearchInStrLast(s,target);
00165 }
00166
00167
00168 int WINAPI dkcStrStr(const char *dest,const char *src)
00169 {
00170 char *p = strstr(dest,src);
00171 if(NULL==p) return -1;
00172 if((size_t)p - (size_t)dest > INT_MAX){
00173 return -2;
00174 }
00175 return (int)(p - dest);
00176
00177
00178
00179
00180 }
00181
00182 static int dkcBMStrStrLogic(const char *text,const char *pattern)
00183 {
00184 int i, j, k, len;
00185 int skip[UCHAR_MAX + 1];
00186 unsigned char c, tail;
00187
00188 len = strlen((char *)pattern);
00189 if (len == 0) return -1;
00190 tail = pattern[len - 1];
00191 if (len == 1) {
00192 for (i = 0; text[i] != '\0'; i++)
00193 if (text[i] == tail) return i;
00194 } else {
00195 for (i = 0; i <= UCHAR_MAX; i++) skip[i] = len;
00196 for (i = 0; i < len - 1; i++)
00197 skip[pattern[i]] = len - 1 - i;
00198
00199 while ((c = text[i]) != '\0') {
00200
00201
00202
00203
00204 if (c == tail) {
00205 j = len - 1; k = i;
00206 while (pattern[--j] == text[--k])
00207 if (j == 0) return k;
00208 }
00209 i += skip[c];
00210 }
00211 }
00212 return -1;
00213 }
00214
00215
00216 int WINAPI dkcBMStrStr(const char *dest,const char *src)
00217 {
00218 return dkcBMStrStrLogic(dest,src);
00219 }
00220
00221
00222
00223
00224
00225 DKC_STRING * WINAPI dkcAllocString(size_t size){
00226 DKC_STRING *p;
00227
00228
00229
00230 p = (DKC_STRING *)dkcAllocate(sizeof(DKC_STRING));
00231 if(NULL==p) return NULL;
00232
00233 p->mStream = dkcAllocMemoryStream(size + 1);
00234 if(NULL==p->mStream) goto Error;
00235
00236 p->mByteSize = 0;
00237
00238 return p;
00239 Error:
00240 dkcFree((void **)&p);
00241 return NULL;
00242 }
00243
00244 int WINAPI dkcFreeString(DKC_STRING **ptr){
00245
00246 if(NULL==ptr || NULL==*ptr || NULL==(*ptr)->mStream){return edk_ArgumentException;}
00247 dkcFreeMemoryStream(&(*ptr)->mStream);
00248 return dkcFree((void **)ptr);
00249 }
00250
00251
00252 int WINAPI dkcStringCopy(DKC_STRING *ptr,const char *str,size_t size)
00253 {
00254 dkcmNOT_ASSERT(NULL==ptr || NULL==ptr->mStream || 0==size);
00255
00256 if(DKUTIL_FAILED(dkcMemoryStreamSeek(ptr->mStream,0,edkcMemoryStreamSeekSet))){
00257 return edk_FAILED;
00258 }
00259
00260 dkcMemoryStreamClear(ptr->mStream);
00261
00262 if(DKUTIL_FAILED(dkcMemoryStreamDynamicWrite(ptr->mStream,str,
00263 size + 1)))
00264 {
00265 return edk_FAILED;
00266 }
00267
00268 ptr->mByteSize = size;
00269
00270 return edk_SUCCEEDED;
00271 }
00272
00273 int WINAPI dkcStringConcatenate(DKC_STRING *ptr,const char *str,size_t size){
00274 dkcmNOT_ASSERT(NULL==ptr || NULL==ptr->mStream || 0==size);
00275
00276 if(0 != ptr->mByteSize){
00277 ptr->mStream->mNowOffset --;
00278 }
00279 if(DKUTIL_FAILED(dkcMemoryStreamDynamicWrite(ptr->mStream,str,size + 1)))
00280 {
00281 return edk_FAILED;
00282 }
00283
00284 ptr->mByteSize += size;
00285
00286 return edk_SUCCEEDED;
00287 }
00288
00289 int WINAPI dkcStringInsert(DKC_STRING *ptr,size_t point,const char *str,size_t size)
00290 {
00291 size_t tpo;
00292 char *tp;
00293
00294
00295
00296
00297 dkcmNOT_ASSERT(NULL==ptr || NULL==ptr->mStream);
00298 if(0==size){
00299 return edk_Not_Satisfactory;
00300 }
00301
00302
00303
00304
00305
00306
00307
00308 {
00309 tpo = dkcMemoryStreamGetSeekPoint(ptr->mStream);
00310 if(point > tpo)
00311 {
00312 return edk_ArgumentException;
00313 }
00314
00315 dkcStringConcatenate(ptr,str,size);
00316
00317 tp = (char *)ptr->mStream->mBuffer;
00318
00319
00320 tpo = dkcMemoryStreamGetSeekPoint(ptr->mStream);
00321
00322
00323 dkc_stream_swap(&tp[point],tpo - point - 1,tpo - point - size - 1);
00324
00325 }
00326 return edk_SUCCEEDED;
00327
00328
00329
00330
00331
00332 }
00333
00334 int WINAPI dkcStringErase(DKC_STRING *ptr,size_t point,size_t len)
00335 {
00336 char *tp;
00337 size_t size;
00338 int r;
00339
00340 tp = (char *)ptr->mStream->mBuffer;
00341 size = ptr->mStream->mNowOffset;
00342 if(point + len >= size){
00343 len = size - len;
00344 dkcMemoryStreamSeek(ptr->mStream,len,edkcMemoryStreamSeekSet);
00345
00346 return edk_Not_Satisfactory;
00347 }
00348 else
00349 {
00350 dkc_stream_swap(&tp[point],size - point - 1,len);
00351
00352 ptr->mByteSize -= len;
00353
00354 ptr->mStream->mBuffer[ptr->mByteSize] = '\0';
00355
00356
00357 r = dkcMemoryStreamSeek(ptr->mStream,size - len,edkcMemoryStreamSeekSet);
00358 }
00359 return r;
00360 }
00361
00362 int WINAPI dkcStringReplace(DKC_STRING *ptr,size_t begin_,size_t end_,
00363 const char *str,size_t size)
00364 {
00365
00366 dkcStringErase(ptr,begin_,end_ - begin_);
00367 return dkcStringInsert(ptr,begin_,str,size);
00368 }
00369
00370
00371
00372 size_t dkcStringSize(const DKC_STRING *ptr){
00373 return ptr->mByteSize;
00374 }
00375
00376 size_t dkcStringNum(const DKC_STRING *ptr){
00377 return ptr->mByteSize;
00378 }
00379
00380 const char * WINAPI dkcStringPointer(const DKC_STRING *ptr){
00381
00382 return (const char *)ptr->mStream->mBuffer;
00383 }
00384
00385 int WINAPI dkcStringGetBuffer(const DKC_STRING *ptr,char *buffer,size_t buffsize)
00386 {
00387 int r;
00388 size_t num;
00389 if(NULL==ptr) return edk_FAILED;
00390 num = dkcStringNum(ptr);
00391 r = dkc_memcpy(buffer,buffsize,ptr->mStream->mBuffer,ptr->mStream->mNowOffset);
00392 if(DKUTIL_FAILED(r)) return r;
00393
00394 return r;
00395
00396 }
00397 #if 0
00398
00399 int WINAPI dkcStringSerialize(const DKC_STRING *ptr,DKC_SERIALIZE *se)
00400 {
00401 int id = edkcSerializeIDString;
00402 dkcmNOT_ASSERT(NULL==ptr);
00403 dkcSerializeWrite(se,&id,sizeof(id));
00404 dkcMemoryStreamSerialize(ptr->mStream,se);
00405 return dkcSerializeWrite(se,ptr,sizeof(DKC_STRING));
00406 }
00407
00408 DKC_STRING* WINAPI dkcAllocStringDeserialize(DKC_DESERIALIZE *se)
00409 {
00410 DKC_STRING *p;
00411 DKC_STRING t;
00412 DKC_MEMORYSTREAM *mem;
00413 size_t read;
00414 int id;
00415
00416 dkcDeserializeRead(se,&id,sizeof(id),&read);
00417 if(id != edkcSerializeIDString)
00418 {
00419 return NULL;
00420 }
00421
00422 mem = dkcAllocMemoryStreamDeserialize(se);
00423 if(NULL==mem){
00424 return NULL;
00425 }
00426
00427 dkcDeserializeRead(se,&t,sizeof(t),&read);
00428
00429 p = dkcAllocString(0);
00430 if(NULL==p){
00431 return NULL;
00432 }
00433
00434 dkcFreeMemoryStream(&p->mStream);
00435 p->mByteSize = t.mByteSize;
00436 p->mStream = mem;
00437
00438
00439
00440 return p;
00441
00442 }
00443
00444 #endif