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