memory/string.c

   1 /*
   2  * String functions
   3  *
   4  * Copyright 1993 Yngvi Sigurjonsson
   5  * Copyright 1996 Alexandre Julliard
   6  */
   7
   8 #include <ctype.h>
   9 #include <string.h>
  10 #include "windows.h"
  11 #include "winerror.h"
  12 #include "ldt.h"
  13 #include "debug.h"
  14 #include "winnls.h"
  15
  16 static const BYTE STRING_Oem2Ansi[256] =
  17 "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\244"
  18 "\020\021\022\023\266\247\026\027\030\031\032\033\034\035\036\037"
  19 "\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
  20 "\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
  21 "\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
  22 "\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
  23 "\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
  24 "\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
  25 "\307\374\351\342\344\340\345\347\352\353\350\357\356\354\304\305"
  26 "\311\346\306\364\366\362\373\371\377\326\334\242\243\245\120\203"
  27 "\341\355\363\372\361\321\252\272\277\137\254\275\274\241\253\273"
  28 "\137\137\137\246\246\246\246\053\053\246\246\053\053\053\053\053"
  29 "\053\055\055\053\055\053\246\246\053\053\055\055\246\055\053\055"
  30 "\055\055\055\053\053\053\053\053\053\053\053\137\137\246\137\137"
  31 "\137\337\137\266\137\137\265\137\137\137\137\137\137\137\137\137"
  32 "\137\261\137\137\137\137\367\137\260\225\267\137\156\262\137\137";
  33
  34 static const BYTE STRING_Ansi2Oem[256] =
  35 "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017"
  36 "\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
  37 "\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
  38 "\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
  39 "\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
  40 "\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
  41 "\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
  42 "\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
  43 "\200\201\054\237\054\137\375\374\210\045\123\074\117\215\216\217"
  44 "\220\140\047\042\042\371\055\137\230\231\163\076\157\235\236\131"
  45 "\040\255\233\234\017\235\335\025\042\143\246\256\252\055\162\137"
  46 "\370\361\375\063\047\346\024\372\054\061\247\257\254\253\137\250"
  47 "\101\101\101\101\216\217\222\200\105\220\105\105\111\111\111\111"
  48 "\104\245\117\117\117\117\231\170\117\125\125\125\232\131\137\341"
  49 "\205\240\203\141\204\206\221\207\212\202\210\211\215\241\214\213"
  50 "\144\244\225\242\223\157\224\366\157\227\243\226\201\171\137\230";
  51
  52 #define OEM_TO_ANSI(ch) (STRING_Oem2Ansi[(unsigned char)(ch)])
  53 #define ANSI_TO_OEM(ch) (STRING_Ansi2Oem[(unsigned char)(ch)])
  54
  55 /* Internaly used by strchr family functions */
  56 static BOOL32 ChrCmpA( WORD word1, WORD word2);
  57 static BOOL32 ChrCmpW( WORD word1, WORD word2);
  58
  59 extern LPWSTR __cdecl CRTDLL_wcschr(LPCWSTR str,WCHAR xchar);
  60
  61
  62 /***********************************************************************
  63  *           hmemcpy   (KERNEL.348)
  64  */
  65 void WINAPI hmemcpy( LPVOID dst, LPCVOID src, LONG count )
  66 {
  67     memcpy( dst, src, count );
  68 }
  69
  70
  71 /***********************************************************************
  72  *           lstrcat16   (KERNEL.89)
  73  */
  74 SEGPTR WINAPI lstrcat16( SEGPTR dst, LPCSTR src )
  75 {
  76     lstrcat32A( (LPSTR)PTR_SEG_TO_LIN(dst), src );
  77     return dst;
  78 }
  79
  80
  81 /***********************************************************************
  82  *           lstrcat32A   (KERNEL32.599)
  83  */
  84 LPSTR WINAPI lstrcat32A( LPSTR dst, LPCSTR src )
  85 {
  86     TRACE(string,"Append %s to %s\n",
  87                    debugstr_a (src), debugstr_a (dst));
  88     /* Windows does not check for NULL pointers here, so we don't either */
  89     strcat( dst, src );
  90     return dst;
  91 }
  92
  93
  94 /***********************************************************************
  95  *           lstrcat32W   (KERNEL32.600)
  96  */
  97 LPWSTR WINAPI lstrcat32W( LPWSTR dst, LPCWSTR src )
  98 {
  99     register LPWSTR p = dst;
 100     TRACE(string,"Append L%s to L%s\n",
 101                    debugstr_w (src), debugstr_w (dst));
 102     /* Windows does not check for NULL pointers here, so we don't either */
 103     while (*p) p++;
 104     while ((*p++ = *src++));
 105     return dst;
 106 }
 107
 108
 109 /***********************************************************************
 110  *           lstrcatn16   (KERNEL.352)
 111  */
 112 SEGPTR WINAPI lstrcatn16( SEGPTR dst, LPCSTR src, INT16 n )
 113 {
 114     lstrcatn32A( (LPSTR)PTR_SEG_TO_LIN(dst), src, n );
 115     return dst;
 116 }
 117
 118
 119 /***********************************************************************
 120  *           lstrcatn32A   (Not a Windows API)
 121  */
 122 LPSTR WINAPI lstrcatn32A( LPSTR dst, LPCSTR src, INT32 n )
 123 {
 124     register LPSTR p = dst;
 125     TRACE(string,"strcatn add %d chars from %s to %s\n",
 126                    n, debugstr_an (src, n), debugstr_a (dst));
 127     while (*p) p++;
 128     if ((n -= (INT32)(p - dst)) <= 0) return dst;
 129     lstrcpyn32A( p, src, n );
 130     return dst;
 131 }
 132
 133
 134 /***********************************************************************
 135  *           lstrcatn32W   (Not a Windows API)
 136  */
 137 LPWSTR WINAPI lstrcatn32W( LPWSTR dst, LPCWSTR src, INT32 n )
 138 {
 139     register LPWSTR p = dst;
 140     TRACE(string,"strcatn add %d chars from L%s to L%s\n",
 141                    n, debugstr_wn (src, n), debugstr_w (dst));
 142     while (*p) p++;
 143     if ((n -= (INT32)(p - dst)) <= 0) return dst;
 144     lstrcpyn32W( p, src, n );
 145     return dst;
 146 }
 147
 148
 149 /***********************************************************************
 150  *           lstrcmp16   (USER.430)
 151  */
 152 INT16 WINAPI lstrcmp16( LPCSTR str1, LPCSTR str2 )
 153 {
 154     return (INT16)strcmp( str1, str2 );
 155 }
 156
 157
 158 /***********************************************************************
 159  *           lstrcmp32A   (KERNEL.602)
 160  */
 161 INT32 WINAPI lstrcmp32A( LPCSTR str1, LPCSTR str2 )
 162 {
 163     return CompareString32A(LOCALE_SYSTEM_DEFAULT,0,str1,-1,str2,-1) - 2 ;
 164 }
 165
 166
 167 /***********************************************************************
 168  *           lstrcmp32W   (KERNEL.603)
 169  * FIXME : should call CompareString32W, when it is implemented.
 170  *    This implementation is not "word sort", as it should.
 171  */
 172 INT32 WINAPI lstrcmp32W( LPCWSTR str1, LPCWSTR str2 )
 173 {
 174     TRACE(string,"L%s and L%s\n",
 175                    debugstr_w (str1), debugstr_w (str2));
 176     if (!str1 || !str2) {
 177         SetLastError(ERROR_INVALID_PARAMETER);
 178         return 0;
 179     }
 180     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
 181     return (INT32)(*str1 - *str2);
 182 }
 183
 184
 185 /***********************************************************************
 186  *           lstrcmpi16   (USER.471)
 187  */
 188 INT16 WINAPI lstrcmpi16( LPCSTR str1, LPCSTR str2 )
 189 {
 190     return (INT16)lstrcmpi32A( str1, str2 );
 191 }
 192
 193
 194 /***********************************************************************
 195  *           lstrcmpi32A   (KERNEL32.605)
 196  */
 197 INT32 WINAPI lstrcmpi32A( LPCSTR str1, LPCSTR str2 )
 198 {    TRACE(string,"strcmpi %s and %s\n",
 199                    debugstr_a (str1), debugstr_a (str2));
 200     return CompareString32A(LOCALE_SYSTEM_DEFAULT,NORM_IGNORECASE,str1,-1,str2,-1)-2;
 201 }
 202
 203
 204 /***********************************************************************
 205  *           lstrcmpi32W   (KERNEL32.606)
 206  */
 207 INT32 WINAPI lstrcmpi32W( LPCWSTR str1, LPCWSTR str2 )
 208 {
 209     INT32 res;
 210
 211 #if 0
 212     /* Too much!  (From registry loading.)  */
 213     TRACE(string,"strcmpi L%s and L%s\n",
 214                    debugstr_w (str1), debugstr_w (str2));
 215 #endif
 216     if (!str1 || !str2) {
 217         SetLastError(ERROR_INVALID_PARAMETER);
 218         return 0;
 219     }
 220     while (*str1)
 221     {
 222         if ((*str1<0x100 ) && (*str2<0x100)) {
 223             if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
 224         } else {
 225             if ((res = towupper(*str1) - towupper(*str2)) != 0) return res;
 226         }
 227         str1++;
 228         str2++;
 229     }
 230     return towupper(*str1) - towupper(*str2);
 231 }
 232
 233
 234 /***********************************************************************
 235  *           lstrcpy16   (KERNEL.88)
 236  */
 237 SEGPTR WINAPI lstrcpy16( SEGPTR dst, LPCSTR src )
 238 {
 239     lstrcpy32A( (LPSTR)PTR_SEG_TO_LIN(dst), src );
 240     return dst;
 241 }
 242
 243
 244 /***********************************************************************
 245  *           lstrcpy32A   (KERNEL32.608)
 246  */
 247 LPSTR WINAPI lstrcpy32A( LPSTR dst, LPCSTR src )
 248 {
 249     TRACE(string,"strcpy %s\n", debugstr_a (src));
 250     /* Windows does not check for NULL pointers here, so we don't either */
 251     strcpy( dst, src );
 252     return dst;
 253 }
 254
 255
 256 /***********************************************************************
 257  *           lstrcpy32W   (KERNEL32.609)
 258  */
 259 LPWSTR WINAPI lstrcpy32W( LPWSTR dst, LPCWSTR src )
 260 {
 261     register LPWSTR p = dst;
 262     TRACE(string,"strcpy L%s\n", debugstr_w (src));
 263     /* Windows does not check for NULL pointers here, so we don't either */
 264     while ((*p++ = *src++));
 265     return dst;
 266 }
 267
 268
 269 /***********************************************************************
 270  *           lstrcpyn16   (KERNEL.353)
 271  */
 272 SEGPTR WINAPI lstrcpyn16( SEGPTR dst, LPCSTR src, INT16 n )
 273 {
 274     lstrcpyn32A( (LPSTR)PTR_SEG_TO_LIN(dst), src, n );
 275     return dst;
 276 }
 277
 278
 279 /***********************************************************************
 280  *           lstrcpyn32A   (KERNEL32.611)
 281  * Note: this function differs from the UNIX strncpy, it _always_ writes
 282  * a terminating \0
 283  */
 284 LPSTR WINAPI lstrcpyn32A( LPSTR dst, LPCSTR src, INT32 n )
 285 {
 286     LPSTR p = dst;
 287     TRACE(string,"strcpyn %s for %d chars\n",
 288                    debugstr_an (src,n), n);
 289     /* Windows does not check for NULL pointers here, so we don't either */
 290     while ((n-- > 1) && *src) *p++ = *src++;
 291     if (n >= 0) *p = 0;
 292     return dst;
 293 }
 294
 295
 296 /***********************************************************************
 297  *           lstrcpyn32W   (KERNEL32.612)
 298  * Note: this function differs from the UNIX strncpy, it _always_ writes
 299  * a terminating \0
 300  */
 301 LPWSTR WINAPI lstrcpyn32W( LPWSTR dst, LPCWSTR src, INT32 n )
 302 {
 303     LPWSTR p = dst;
 304     TRACE(string,"strcpyn L%s for %d chars\n",
 305                    debugstr_wn (src,n), n);
 306     /* Windows does not check for NULL pointers here, so we don't either */
 307     while ((n-- > 1) && *src) *p++ = *src++;
 308     if (n >= 0) *p = 0;
 309     return dst;
 310 }
 311
 312
 313 /***********************************************************************
 314  *           lstrlen16   (KERNEL.90)
 315  */
 316 INT16 WINAPI lstrlen16( LPCSTR str )
 317 {
 318     return (INT16)lstrlen32A( str );
 319 }
 320
 321
 322 /***********************************************************************
 323  *           lstrlen32A   (KERNEL32.614)
 324  */
 325 INT32 WINAPI lstrlen32A( LPCSTR str )
 326 {
 327     /* looks weird, but win3.1 KERNEL got a GeneralProtection handler
 328      * in lstrlen() ... we check only for NULL pointer reference.
 329      * - Marcus Meissner
 330      */
 331     TRACE(string,"strlen %s\n", debugstr_a (str));
 332     if (!str) return 0;
 333     return (INT32)strlen(str);
 334 }
 335
 336
 337 /***********************************************************************
 338  *           lstrlen32W   (KERNEL32.615)
 339  */
 340 INT32 WINAPI lstrlen32W( LPCWSTR str )
 341 {
 342     INT32 len = 0;
 343     TRACE(string,"strlen L%s\n", debugstr_w (str));
 344     if (!str) return 0;
 345     while (*str++) len++;
 346     return len;
 347 }
 348
 349
 350 /***********************************************************************
 351  *           lstrncmp32A   (Not a Windows API)
 352  */
 353 INT32 WINAPI lstrncmp32A( LPCSTR str1, LPCSTR str2, INT32 n )
 354 {
 355     TRACE(string,"strncmp %s and %s for %d chars\n",
 356                    debugstr_an (str1, n), debugstr_an (str2, n), n);
 357     return (INT32)strncmp( str1, str2, n );
 358 }
 359
 360
 361 /***********************************************************************
 362  *           lstrncmp32W   (Not a Windows API)
 363  */
 364 INT32 WINAPI lstrncmp32W( LPCWSTR str1, LPCWSTR str2, INT32 n )
 365 {
 366     TRACE(string,"strncmp L%s and L%s for %d chars\n",
 367                    debugstr_wn (str1, n), debugstr_wn (str2, n), n);
 368     if (!n) return 0;
 369     while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
 370     return (INT32)(*str1 - *str2);
 371 }
 372
 373
 374 /***********************************************************************
 375  *           lstrncmpi32A   (Not a Windows API)
 376  */
 377 INT32 WINAPI lstrncmpi32A( LPCSTR str1, LPCSTR str2, INT32 n )
 378 {
 379     INT32 res;
 380
 381     TRACE(string,"strncmpi %s and %s for %d chars\n",
 382                    debugstr_an (str1, n), debugstr_an (str2, n), n);
 383     if (!n) return 0;
 384     while ((--n > 0) && *str1)
 385       if ( (res = toupper(*str1++) - toupper(*str2++)) ) return res;
 386
 387     return toupper(*str1) - toupper(*str2);
 388 }
 389
 390
 391 /***********************************************************************
 392  *           lstrncmpi32W   (Not a Windows API)
 393  */
 394 INT32 WINAPI lstrncmpi32W( LPCWSTR str1, LPCWSTR str2, INT32 n )
 395 {
 396     INT32 res;
 397
 398     TRACE(string,"strncmpi L%s and L%s for %d chars\n",
 399                    debugstr_wn (str1, n), debugstr_wn (str2, n), n);
 400     if (!n) return 0;
 401     while ((--n > 0) && *str1)
 402     {
 403         if ((res = towupper(*str1) - towupper(*str2)) != 0) return res;
 404         str1++;
 405         str2++;
 406     }
 407     return towupper(*str1) - towupper(*str2);
 408 }
 409
 410
 411 /***********************************************************************
 412  *           lstrcpyAtoW   (Not a Windows API)
 413  */
 414 LPWSTR WINAPI lstrcpyAtoW( LPWSTR dst, LPCSTR src )
 415 {
 416     register LPWSTR p = dst;
 417
 418     TRACE(string,"%s\n",src);
 419
 420     while ((*p++ = (WCHAR)(unsigned char)*src++));
 421     return dst;
 422 }
 423
 424
 425 /***********************************************************************
 426  *           lstrcpyWtoA   (Not a Windows API)
 427  */
 428 LPSTR WINAPI lstrcpyWtoA( LPSTR dst, LPCWSTR src )
 429 {
 430     register LPSTR p = dst;
 431
 432     TRACE(string,"L%s\n",debugstr_w(src));
 433
 434     while ((*p++ = (CHAR)*src++));
 435     return dst;
 436 }
 437
 438
 439 /***********************************************************************
 440  *           lstrcpynAtoW   (Not a Windows API)
 441  * Note: this function differs from the UNIX strncpy, it _always_ writes
 442  * a terminating \0
 443  */
 444 LPWSTR WINAPI lstrcpynAtoW( LPWSTR dst, LPCSTR src, INT32 n )
 445 {
 446     LPWSTR p = dst;
 447
 448     TRACE(string,"%s %i\n",src, n);
 449
 450     while ((n-- > 1) && *src) *p++ = (WCHAR)(unsigned char)*src++;
 451     if (n >= 0) *p = 0;
 452     return dst;
 453 }
 454
 455
 456 /***********************************************************************
 457  *           lstrcpynWtoA   (Not a Windows API)
 458  * Note: this function differs from the UNIX strncpy, it _always_ writes
 459  * a terminating \0
 460  */
 461 LPSTR WINAPI lstrcpynWtoA( LPSTR dst, LPCWSTR src, INT32 n )
 462 {
 463     LPSTR p = dst;
 464
 465     TRACE(string,"L%s %i\n",debugstr_w(src), n);
 466
 467     while ((n-- > 1) && *src) *p++ = (CHAR)*src++;
 468     if (n >= 0) *p = 0;
 469     return dst;
 470 }
 471
 472
 473 /***********************************************************************
 474  *           Copy   (GDI.250)
 475  */
 476 void WINAPI Copy( LPVOID src, LPVOID dst, WORD size )
 477 {
 478     memcpy( dst, src, size );
 479 }
 480
 481
 482 /***********************************************************************
 483  *           RtlFillMemory   (KERNEL32.441)
 484  */
 485 VOID WINAPI RtlFillMemory( LPVOID ptr, UINT32 len, UINT32 fill )
 486 {
 487     memset( ptr, fill, len );
 488 }
 489
 490
 491 /***********************************************************************
 492  *           RtlMoveMemory   (KERNEL32.442)
 493  */
 494 VOID WINAPI RtlMoveMemory( LPVOID dst, LPCVOID src, UINT32 len )
 495 {
 496     memmove( dst, src, len );
 497 }
 498
 499
 500 /***********************************************************************
 501  *           RtlZeroMemory   (KERNEL32.444)
 502  */
 503 VOID WINAPI RtlZeroMemory( LPVOID ptr, UINT32 len )
 504 {
 505     memset( ptr, 0, len );
 506 }
 507
 508
 509 /***********************************************************************
 510  *           AnsiToOem16   (KEYBOARD.5)
 511  */
 512 INT16 WINAPI AnsiToOem16( LPCSTR s, LPSTR d )
 513 {
 514     CharToOem32A( s, d );
 515     return -1;
 516 }
 517
 518
 519 /***********************************************************************
 520  *           OemToAnsi16   (KEYBOARD.6)
 521  */
 522 INT16 WINAPI OemToAnsi16( LPCSTR s, LPSTR d )
 523 {
 524     OemToChar32A( s, d );
 525     return -1;
 526 }
 527
 528
 529 /***********************************************************************
 530  *           AnsiToOemBuff16   (KEYBOARD.134)
 531  */
 532 void WINAPI AnsiToOemBuff16( LPCSTR s, LPSTR d, UINT16 len )
 533 {
 534     CharToOemBuff32A( s, d, len ? len : 65536 );
 535 }
 536
 537
 538 /***********************************************************************
 539  *           OemToAnsiBuff16   (KEYBOARD.135)
 540  */
 541 void WINAPI OemToAnsiBuff16( LPCSTR s, LPSTR d, UINT16 len )
 542 {
 543     OemToCharBuff32A( s, d, len ? len : 65536 );
 544 }
 545
 546
 547 /***********************************************************************
 548  *           CharToOem32A   (USER32.37)
 549  */
 550 BOOL32 WINAPI CharToOem32A( LPCSTR s, LPSTR d )
 551 {
 552     LPSTR oldd = d;
 553     if (!s || !d) return TRUE;
 554     TRACE(string,"CharToOem %s\n", debugstr_a (s));
 555     while ((*d++ = ANSI_TO_OEM(*s++)));
 556     TRACE(string,"       to %s\n", debugstr_a (oldd));
 557     return TRUE;
 558 }
 559
 560
 561 /***********************************************************************
 562  *           CharToOemBuff32A   (USER32.38)
 563  */
 564 BOOL32 WINAPI CharToOemBuff32A( LPCSTR s, LPSTR d, DWORD len )
 565 {
 566     while (len--) *d++ = ANSI_TO_OEM(*s++);
 567     return TRUE;
 568 }
 569
 570
 571 /***********************************************************************
 572  *           CharToOemBuff32W   (USER32.39)
 573  */
 574 BOOL32 WINAPI CharToOemBuff32W( LPCWSTR s, LPSTR d, DWORD len )
 575 {
 576     while (len--) *d++ = ANSI_TO_OEM(*s++);
 577     return TRUE;
 578 }
 579
 580
 581 /***********************************************************************
 582  *           CharToOem32W   (USER32.40)
 583  */
 584 BOOL32 WINAPI CharToOem32W( LPCWSTR s, LPSTR d )
 585 {
 586     LPSTR oldd = d;
 587     if (!s || !d) return TRUE;
 588     TRACE(string,"CharToOem L%s\n", debugstr_w (s));
 589     while ((*d++ = ANSI_TO_OEM(*s++)));
 590     TRACE(string,"       to %s\n", debugstr_a (oldd));
 591     return TRUE;
 592 }
 593
 594
 595 /***********************************************************************
 596  *           OemToChar32A   (USER32.402)
 597  */
 598 BOOL32 WINAPI OemToChar32A( LPCSTR s, LPSTR d )
 599 {
 600     LPSTR oldd = d;
 601     TRACE(string,"OemToChar %s\n", debugstr_a (s));
 602     while ((*d++ = OEM_TO_ANSI(*s++)));
 603     TRACE(string,"       to %s\n", debugstr_a (oldd));
 604     return TRUE;
 605 }
 606
 607
 608 /***********************************************************************
 609  *           OemToCharBuff32A   (USER32.403)
 610  */
 611 BOOL32 WINAPI OemToCharBuff32A( LPCSTR s, LPSTR d, DWORD len )
 612 {
 613     TRACE(string,"OemToCharBuff %s\n", debugstr_an (s, len));
 614     while (len--) *d++ = OEM_TO_ANSI(*s++);
 615     return TRUE;
 616 }
 617
 618
 619 /***********************************************************************
 620  *           OemToCharBuff32W   (USER32.404)
 621  */
 622 BOOL32 WINAPI OemToCharBuff32W( LPCSTR s, LPWSTR d, DWORD len )
 623 {
 624     TRACE(string,"OemToCharBuff %s\n", debugstr_an (s, len));
 625     while (len--) *d++ = (WCHAR)OEM_TO_ANSI(*s++);
 626     return TRUE;
 627 }
 628
 629
 630 /***********************************************************************
 631  *           OemToChar32W   (USER32.405)
 632  */
 633 BOOL32 WINAPI OemToChar32W( LPCSTR s, LPWSTR d )
 634 {
 635     while ((*d++ = (WCHAR)OEM_TO_ANSI(*s++)));
 636     return TRUE;
 637 }
 638
 639 /***********************************************************************
 640  *  WideCharToLocal (Not a Windows API)
 641  *  similar lstrcpyWtoA, should handle codepages properly
 642  *
 643  *  RETURNS
 644  *    strlen of the destination string
 645  */
 646
 647 INT32 WINAPI WideCharToLocal32(
 648     LPSTR pLocal,
 649                 LPWSTR pWide,
 650                 INT32 dwChars)
 651 { *pLocal = 0;
 652   TRACE(string,"(%p, %s, %i)\n",        pLocal, debugstr_w(pWide),dwChars);
 653   WideCharToMultiByte(CP_ACP,0,pWide,-1,pLocal,dwChars,NULL,NULL);
 654   return strlen(pLocal);
 655 }
 656 /***********************************************************************
 657  *  LocalToWideChar (Not a Windows API)
 658  *  similar lstrcpyAtoW, should handle codepages properly
 659  *
 660  *  RETURNS
 661  *    strlen of the destination string
 662  */
 663 INT32 WINAPI LocalToWideChar32(
 664     LPWSTR pWide,
 665                 LPSTR pLocal,
 666                 INT32 dwChars)
 667 { *pWide = 0;
 668   TRACE(string,"(%p, %s, %i)\n",pWide,  pLocal, dwChars);
 669         MultiByteToWideChar(CP_ACP,0,pLocal,-1,pWide,dwChars);
 670   return lstrlen32W(pWide);
 671 }
 672
 673
 674 /***********************************************************************
 675  *           lstrrchr   (Not a Windows API)
 676  *
 677  * This is the implementation meant to be invoked form within
 678  * COMCTL32_StrRChrA and shell32(TODO)...
 679  *
 680  * Return a pointer to the last occurence of wMatch in lpStart
 681  * not looking further than lpEnd...
 682  */
 683 LPSTR WINAPI lstrrchr( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch )
 684 {
 685   LPCSTR lpGotIt = NULL;
 686
 687   TRACE(string,"(%s, %s)\n", lpStart, lpEnd);
 688
 689   if (!lpEnd) lpEnd = lpStart + strlen(lpStart);
 690
 691   for(; lpStart < lpEnd; lpStart = CharNext32A(lpStart))
 692     if (!ChrCmpA( GET_WORD(lpStart), wMatch))
 693       lpGotIt = lpStart;
 694
 695   return ((LPSTR)lpGotIt);
 696 }
 697
 698 /***********************************************************************
 699  *           lstrrchrw    (Not a Windows API)
 700  *
 701  * This is the implementation meant to be invoked form within
 702  * COMCTL32_StrRChrW and shell32(TODO)...
 703  *
 704  * Return a pointer to the last occurence of wMatch in lpStart
 705  * not looking further than lpEnd...
 706  */
 707 LPWSTR WINAPI lstrrchrw( LPCWSTR lpStart, LPCWSTR lpEnd, WORD wMatch )
 708 {
 709   LPCWSTR lpGotIt = NULL;
 710
 711   TRACE(string,"(%p, %p, %c)\n", lpStart,      lpEnd, wMatch);
 712   if (!lpEnd) lpEnd = lpStart + lstrlen32W(lpStart);
 713
 714   for(; lpStart < lpEnd; lpStart = CharNext32W(lpStart))
 715     if (!ChrCmpW( GET_WORD(lpStart), wMatch))
 716       lpGotIt = lpStart;
 717
 718   return (LPWSTR)lpGotIt;
 719 }
 720
 721 /***********************************************************************
 722  *           strstrw   (Not a Windows API)
 723  *
 724  * This is the implementation meant to be invoked form within
 725  * COMCTL32_StrStrW and shell32(TODO)...
 726  *
 727  */
 728 LPWSTR WINAPI strstrw( LPCWSTR lpFirst, LPCWSTR lpSrch) {
 729   UINT32 uSrchLen  = (UINT32)lstrlen32W(lpSrch);
 730   WORD wMatchBeg   = *(WORD*)lpSrch;
 731
 732   TRACE(string,"(%p, %p)\n", lpFirst,  lpSrch);
 733
 734   for(;
 735     ((lpFirst=CRTDLL_wcschr(lpFirst, wMatchBeg))!=0) &&
 736       lstrncmp32W(lpFirst, lpSrch, uSrchLen);
 737     lpFirst++) {
 738       continue;
 739   }
 740   return (LPWSTR)lpFirst;
 741 }
 742
 743
 744 /***********************************************************************
 745  *           ChrCmpA
 746  * This fuction returns FALSE if both words match, TRUE otherwise...
 747  */
 748 static BOOL32 ChrCmpA( WORD word1, WORD word2) {
 749   if (LOBYTE(word1) == LOBYTE(word2)) {
 750     if (IsDBCSLeadByte32(LOBYTE(word1))) {
 751       return (word1 != word2);
 752     }
 753     return FALSE;
 754   }
 755   return TRUE;
 756 }
 757
 758 /***********************************************************************
 759  *           ChrCmpW
 760  * This fuction returns FALSE if both words match, TRUE otherwise...
 761  */
 762 static BOOL32 ChrCmpW( WORD word1, WORD word2) {
 763   return (word1 != word2);
 764 }
 765
 766