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     /* In real windows the whole function is protected by an exception handler
 251      * that returns ERROR_INVALID_PARAMETER on faulty parameters
 252      * We currently just check for NULL.
 253      */
 254     if (!dst || !src) {
 255         SetLastError(ERROR_INVALID_PARAMETER);
 256         return 0;
 257     }
 258     strcpy( dst, src );
 259     return dst;
 260 }
 261
 262
 263 /***********************************************************************
 264  *           lstrcpy32W   (KERNEL32.609)
 265  */
 266 LPWSTR WINAPI lstrcpy32W( LPWSTR dst, LPCWSTR src )
 267 {
 268     register LPWSTR p = dst;
 269     TRACE(string,"strcpy L%s\n", debugstr_w (src));
 270     /* In real windows the whole function is protected by an exception handler
 271      * that returns ERROR_INVALID_PARAMETER on faulty parameters
 272      * We currently just check for NULL.
 273      */
 274     if (!dst || !src) {
 275         SetLastError(ERROR_INVALID_PARAMETER);
 276         return 0;
 277     }
 278     while ((*p++ = *src++));
 279     return dst;
 280 }
 281
 282
 283 /***********************************************************************
 284  *           lstrcpyn16   (KERNEL.353)
 285  */
 286 SEGPTR WINAPI lstrcpyn16( SEGPTR dst, LPCSTR src, INT16 n )
 287 {
 288     lstrcpyn32A( (LPSTR)PTR_SEG_TO_LIN(dst), src, n );
 289     return dst;
 290 }
 291
 292
 293 /***********************************************************************
 294  *           lstrcpyn32A   (KERNEL32.611)
 295  * Note: this function differs from the UNIX strncpy, it _always_ writes
 296  * a terminating \0
 297  */
 298 LPSTR WINAPI lstrcpyn32A( LPSTR dst, LPCSTR src, INT32 n )
 299 {
 300     LPSTR p = dst;
 301     TRACE(string,"strcpyn %s for %d chars\n",
 302                    debugstr_an (src,n), n);
 303     /* In real windows the whole function is protected by an exception handler
 304      * that returns ERROR_INVALID_PARAMETER on faulty parameters
 305      * We currently just check for NULL.
 306      */
 307     if (!dst || !src) {
 308         SetLastError(ERROR_INVALID_PARAMETER);
 309         return 0;
 310     }
 311     while ((n-- > 1) && *src) *p++ = *src++;
 312     if (n >= 0) *p = 0;
 313     return dst;
 314 }
 315
 316
 317 /***********************************************************************
 318  *           lstrcpyn32W   (KERNEL32.612)
 319  * Note: this function differs from the UNIX strncpy, it _always_ writes
 320  * a terminating \0
 321  */
 322 LPWSTR WINAPI lstrcpyn32W( LPWSTR dst, LPCWSTR src, INT32 n )
 323 {
 324     LPWSTR p = dst;
 325     TRACE(string,"strcpyn L%s for %d chars\n",
 326                    debugstr_wn (src,n), n);
 327     /* In real windows the whole function is protected by an exception handler
 328      * that returns ERROR_INVALID_PARAMETER on faulty parameters
 329      * We currently just check for NULL.
 330      */
 331     if (!dst || !src) {
 332         SetLastError(ERROR_INVALID_PARAMETER);
 333         return 0;
 334     }
 335     while ((n-- > 1) && *src) *p++ = *src++;
 336     if (n >= 0) *p = 0;
 337     return dst;
 338 }
 339
 340
 341 /***********************************************************************
 342  *           lstrlen16   (KERNEL.90)
 343  */
 344 INT16 WINAPI lstrlen16( LPCSTR str )
 345 {
 346     return (INT16)lstrlen32A( str );
 347 }
 348
 349
 350 /***********************************************************************
 351  *           lstrlen32A   (KERNEL32.614)
 352  */
 353 INT32 WINAPI lstrlen32A( LPCSTR str )
 354 {
 355     /* looks weird, but win3.1 KERNEL got a GeneralProtection handler
 356      * in lstrlen() ... we check only for NULL pointer reference.
 357      * - Marcus Meissner
 358      */
 359     TRACE(string,"strlen %s\n", debugstr_a (str));
 360     if (!str) return 0;
 361     return (INT32)strlen(str);
 362 }
 363
 364
 365 /***********************************************************************
 366  *           lstrlen32W   (KERNEL32.615)
 367  */
 368 INT32 WINAPI lstrlen32W( LPCWSTR str )
 369 {
 370     INT32 len = 0;
 371     TRACE(string,"strlen L%s\n", debugstr_w (str));
 372     if (!str) return 0;
 373     while (*str++) len++;
 374     return len;
 375 }
 376
 377
 378 /***********************************************************************
 379  *           lstrncmp32A   (Not a Windows API)
 380  */
 381 INT32 WINAPI lstrncmp32A( LPCSTR str1, LPCSTR str2, INT32 n )
 382 {
 383     TRACE(string,"strncmp %s and %s for %d chars\n",
 384                    debugstr_an (str1, n), debugstr_an (str2, n), n);
 385     return (INT32)strncmp( str1, str2, n );
 386 }
 387
 388
 389 /***********************************************************************
 390  *           lstrncmp32W   (Not a Windows API)
 391  */
 392 INT32 WINAPI lstrncmp32W( LPCWSTR str1, LPCWSTR str2, INT32 n )
 393 {
 394     TRACE(string,"strncmp L%s and L%s for %d chars\n",
 395                    debugstr_wn (str1, n), debugstr_wn (str2, n), n);
 396     if (!n) return 0;
 397     while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
 398     return (INT32)(*str1 - *str2);
 399 }
 400
 401
 402 /***********************************************************************
 403  *           lstrncmpi32A   (Not a Windows API)
 404  */
 405 INT32 WINAPI lstrncmpi32A( LPCSTR str1, LPCSTR str2, INT32 n )
 406 {
 407     INT32 res;
 408
 409     TRACE(string,"strncmpi %s and %s for %d chars\n",
 410                    debugstr_an (str1, n), debugstr_an (str2, n), n);
 411     if (!n) return 0;
 412     while ((--n > 0) && *str1)
 413       if ( (res = toupper(*str1++) - toupper(*str2++)) ) return res;
 414
 415     return toupper(*str1) - toupper(*str2);
 416 }
 417
 418
 419 /***********************************************************************
 420  *           lstrncmpi32W   (Not a Windows API)
 421  */
 422 INT32 WINAPI lstrncmpi32W( LPCWSTR str1, LPCWSTR str2, INT32 n )
 423 {
 424     INT32 res;
 425
 426     TRACE(string,"strncmpi L%s and L%s for %d chars\n",
 427                    debugstr_wn (str1, n), debugstr_wn (str2, n), n);
 428     if (!n) return 0;
 429     while ((--n > 0) && *str1)
 430     {
 431         if ((res = towupper(*str1) - towupper(*str2)) != 0) return res;
 432         str1++;
 433         str2++;
 434     }
 435     return towupper(*str1) - towupper(*str2);
 436 }
 437
 438
 439 /***********************************************************************
 440  *           lstrcpyAtoW   (Not a Windows API)
 441  */
 442 LPWSTR WINAPI lstrcpyAtoW( LPWSTR dst, LPCSTR src )
 443 {
 444     register LPWSTR p = dst;
 445
 446     TRACE(string,"%s\n",src);
 447
 448     while ((*p++ = (WCHAR)(unsigned char)*src++));
 449     return dst;
 450 }
 451
 452
 453 /***********************************************************************
 454  *           lstrcpyWtoA   (Not a Windows API)
 455  */
 456 LPSTR WINAPI lstrcpyWtoA( LPSTR dst, LPCWSTR src )
 457 {
 458     register LPSTR p = dst;
 459
 460     TRACE(string,"L%s\n",debugstr_w(src));
 461
 462     while ((*p++ = (CHAR)*src++));
 463     return dst;
 464 }
 465
 466
 467 /***********************************************************************
 468  *           lstrcpynAtoW   (Not a Windows API)
 469  * Note: this function differs from the UNIX strncpy, it _always_ writes
 470  * a terminating \0
 471  */
 472 LPWSTR WINAPI lstrcpynAtoW( LPWSTR dst, LPCSTR src, INT32 n )
 473 {
 474     LPWSTR p = dst;
 475
 476     TRACE(string,"%s %i\n",src, n);
 477
 478     while ((n-- > 1) && *src) *p++ = (WCHAR)(unsigned char)*src++;
 479     if (n >= 0) *p = 0;
 480     return dst;
 481 }
 482
 483
 484 /***********************************************************************
 485  *           lstrcpynWtoA   (Not a Windows API)
 486  * Note: this function differs from the UNIX strncpy, it _always_ writes
 487  * a terminating \0
 488  */
 489 LPSTR WINAPI lstrcpynWtoA( LPSTR dst, LPCWSTR src, INT32 n )
 490 {
 491     LPSTR p = dst;
 492
 493     TRACE(string,"L%s %i\n",debugstr_w(src), n);
 494
 495     while ((n-- > 1) && *src) *p++ = (CHAR)*src++;
 496     if (n >= 0) *p = 0;
 497     return dst;
 498 }
 499
 500 /***********************************************************************
 501  *           UnicodeToAnsi   (KERNEL.434)
 502  */
 503 INT16 WINAPI UnicodeToAnsi( LPCWSTR src, LPSTR dst, INT16 codepage )
 504 {
 505     if ( codepage != -1 )
 506         FIXME( string, "codepage %d not supported\n", codepage );
 507
 508     lstrcpyWtoA( dst, src );
 509
 510     return (INT16)lstrlen32A( dst );
 511 }
 512
 513
 514 /***********************************************************************
 515  *           Copy   (GDI.250)
 516  */
 517 void WINAPI Copy( LPVOID src, LPVOID dst, WORD size )
 518 {
 519     memcpy( dst, src, size );
 520 }
 521
 522
 523 /***********************************************************************
 524  *           RtlFillMemory   (KERNEL32.441)
 525  */
 526 VOID WINAPI RtlFillMemory( LPVOID ptr, UINT32 len, UINT32 fill )
 527 {
 528     memset( ptr, fill, len );
 529 }
 530
 531
 532 /***********************************************************************
 533  *           RtlMoveMemory   (KERNEL32.442)
 534  */
 535 VOID WINAPI RtlMoveMemory( LPVOID dst, LPCVOID src, UINT32 len )
 536 {
 537     memmove( dst, src, len );
 538 }
 539
 540
 541 /***********************************************************************
 542  *           RtlZeroMemory   (KERNEL32.444)
 543  */
 544 VOID WINAPI RtlZeroMemory( LPVOID ptr, UINT32 len )
 545 {
 546     memset( ptr, 0, len );
 547 }
 548
 549
 550 /***********************************************************************
 551  *           AnsiToOem16   (KEYBOARD.5)
 552  */
 553 INT16 WINAPI AnsiToOem16( LPCSTR s, LPSTR d )
 554 {
 555     CharToOem32A( s, d );
 556     return -1;
 557 }
 558
 559
 560 /***********************************************************************
 561  *           OemToAnsi16   (KEYBOARD.6)
 562  */
 563 INT16 WINAPI OemToAnsi16( LPCSTR s, LPSTR d )
 564 {
 565     OemToChar32A( s, d );
 566     return -1;
 567 }
 568
 569
 570 /***********************************************************************
 571  *           AnsiToOemBuff16   (KEYBOARD.134)
 572  */
 573 void WINAPI AnsiToOemBuff16( LPCSTR s, LPSTR d, UINT16 len )
 574 {
 575     CharToOemBuff32A( s, d, len ? len : 65536 );
 576 }
 577
 578
 579 /***********************************************************************
 580  *           OemToAnsiBuff16   (KEYBOARD.135)
 581  */
 582 void WINAPI OemToAnsiBuff16( LPCSTR s, LPSTR d, UINT16 len )
 583 {
 584     OemToCharBuff32A( s, d, len ? len : 65536 );
 585 }
 586
 587
 588 /***********************************************************************
 589  *           CharToOem32A   (USER32.37)
 590  */
 591 BOOL32 WINAPI CharToOem32A( LPCSTR s, LPSTR d )
 592 {
 593     LPSTR oldd = d;
 594     if (!s || !d) return TRUE;
 595     TRACE(string,"CharToOem %s\n", debugstr_a (s));
 596     while ((*d++ = ANSI_TO_OEM(*s++)));
 597     TRACE(string,"       to %s\n", debugstr_a (oldd));
 598     return TRUE;
 599 }
 600
 601
 602 /***********************************************************************
 603  *           CharToOemBuff32A   (USER32.38)
 604  */
 605 BOOL32 WINAPI CharToOemBuff32A( LPCSTR s, LPSTR d, DWORD len )
 606 {
 607     while (len--) *d++ = ANSI_TO_OEM(*s++);
 608     return TRUE;
 609 }
 610
 611
 612 /***********************************************************************
 613  *           CharToOemBuff32W   (USER32.39)
 614  */
 615 BOOL32 WINAPI CharToOemBuff32W( LPCWSTR s, LPSTR d, DWORD len )
 616 {
 617     while (len--) *d++ = ANSI_TO_OEM(*s++);
 618     return TRUE;
 619 }
 620
 621
 622 /***********************************************************************
 623  *           CharToOem32W   (USER32.40)
 624  */
 625 BOOL32 WINAPI CharToOem32W( LPCWSTR s, LPSTR d )
 626 {
 627     LPSTR oldd = d;
 628     if (!s || !d) return TRUE;
 629     TRACE(string,"CharToOem L%s\n", debugstr_w (s));
 630     while ((*d++ = ANSI_TO_OEM(*s++)));
 631     TRACE(string,"       to %s\n", debugstr_a (oldd));
 632     return TRUE;
 633 }
 634
 635
 636 /***********************************************************************
 637  *           OemToChar32A   (USER32.402)
 638  */
 639 BOOL32 WINAPI OemToChar32A( LPCSTR s, LPSTR d )
 640 {
 641     LPSTR oldd = d;
 642     TRACE(string,"OemToChar %s\n", debugstr_a (s));
 643     while ((*d++ = OEM_TO_ANSI(*s++)));
 644     TRACE(string,"       to %s\n", debugstr_a (oldd));
 645     return TRUE;
 646 }
 647
 648
 649 /***********************************************************************
 650  *           OemToCharBuff32A   (USER32.403)
 651  */
 652 BOOL32 WINAPI OemToCharBuff32A( LPCSTR s, LPSTR d, DWORD len )
 653 {
 654     TRACE(string,"OemToCharBuff %s\n", debugstr_an (s, len));
 655     while (len--) *d++ = OEM_TO_ANSI(*s++);
 656     return TRUE;
 657 }
 658
 659
 660 /***********************************************************************
 661  *           OemToCharBuff32W   (USER32.404)
 662  */
 663 BOOL32 WINAPI OemToCharBuff32W( LPCSTR s, LPWSTR d, DWORD len )
 664 {
 665     TRACE(string,"OemToCharBuff %s\n", debugstr_an (s, len));
 666     while (len--) *d++ = (WCHAR)OEM_TO_ANSI(*s++);
 667     return TRUE;
 668 }
 669
 670
 671 /***********************************************************************
 672  *           OemToChar32W   (USER32.405)
 673  */
 674 BOOL32 WINAPI OemToChar32W( LPCSTR s, LPWSTR d )
 675 {
 676     while ((*d++ = (WCHAR)OEM_TO_ANSI(*s++)));
 677     return TRUE;
 678 }
 679
 680 /***********************************************************************
 681  *  WideCharToLocal (Not a Windows API)
 682  *  similar lstrcpyWtoA, should handle codepages properly
 683  *
 684  *  RETURNS
 685  *    strlen of the destination string
 686  */
 687
 688 INT32 WINAPI WideCharToLocal32(
 689     LPSTR pLocal,
 690                 LPWSTR pWide,
 691                 INT32 dwChars)
 692 { *pLocal = 0;
 693   TRACE(string,"(%p, %s, %i)\n",        pLocal, debugstr_w(pWide),dwChars);
 694   WideCharToMultiByte(CP_ACP,0,pWide,-1,pLocal,dwChars,NULL,NULL);
 695   return strlen(pLocal);
 696 }
 697 /***********************************************************************
 698  *  LocalToWideChar (Not a Windows API)
 699  *  similar lstrcpyAtoW, should handle codepages properly
 700  *
 701  *  RETURNS
 702  *    strlen of the destination string
 703  */
 704 INT32 WINAPI LocalToWideChar32(
 705     LPWSTR pWide,
 706                 LPSTR pLocal,
 707                 INT32 dwChars)
 708 { *pWide = 0;
 709   TRACE(string,"(%p, %s, %i)\n",pWide,  pLocal, dwChars);
 710         MultiByteToWideChar(CP_ACP,0,pLocal,-1,pWide,dwChars);
 711   return lstrlen32W(pWide);
 712 }
 713
 714
 715 /***********************************************************************
 716  *           lstrrchr   (Not a Windows API)
 717  *
 718  * This is the implementation meant to be invoked form within
 719  * COMCTL32_StrRChrA and shell32(TODO)...
 720  *
 721  * Return a pointer to the last occurence of wMatch in lpStart
 722  * not looking further than lpEnd...
 723  */
 724 LPSTR WINAPI lstrrchr( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch )
 725 {
 726   LPCSTR lpGotIt = NULL;
 727
 728   TRACE(string,"(%s, %s)\n", lpStart, lpEnd);
 729
 730   if (!lpEnd) lpEnd = lpStart + strlen(lpStart);
 731
 732   for(; lpStart < lpEnd; lpStart = CharNext32A(lpStart))
 733     if (!ChrCmpA( GET_WORD(lpStart), wMatch))
 734       lpGotIt = lpStart;
 735
 736   return ((LPSTR)lpGotIt);
 737 }
 738
 739 /***********************************************************************
 740  *           lstrrchrw    (Not a Windows API)
 741  *
 742  * This is the implementation meant to be invoked form within
 743  * COMCTL32_StrRChrW and shell32(TODO)...
 744  *
 745  * Return a pointer to the last occurence of wMatch in lpStart
 746  * not looking further than lpEnd...
 747  */
 748 LPWSTR WINAPI lstrrchrw( LPCWSTR lpStart, LPCWSTR lpEnd, WORD wMatch )
 749 {
 750   LPCWSTR lpGotIt = NULL;
 751
 752   TRACE(string,"(%p, %p, %c)\n", lpStart,      lpEnd, wMatch);
 753   if (!lpEnd) lpEnd = lpStart + lstrlen32W(lpStart);
 754
 755   for(; lpStart < lpEnd; lpStart = CharNext32W(lpStart))
 756     if (!ChrCmpW( GET_WORD(lpStart), wMatch))
 757       lpGotIt = lpStart;
 758
 759   return (LPWSTR)lpGotIt;
 760 }
 761
 762 /***********************************************************************
 763  *           strstrw   (Not a Windows API)
 764  *
 765  * This is the implementation meant to be invoked form within
 766  * COMCTL32_StrStrW and shell32(TODO)...
 767  *
 768  */
 769 LPWSTR WINAPI strstrw( LPCWSTR lpFirst, LPCWSTR lpSrch) {
 770   UINT32 uSrchLen  = (UINT32)lstrlen32W(lpSrch);
 771   WORD wMatchBeg   = *(WORD*)lpSrch;
 772
 773   TRACE(string,"(%p, %p)\n", lpFirst,  lpSrch);
 774
 775   for(;
 776     ((lpFirst=CRTDLL_wcschr(lpFirst, wMatchBeg))!=0) &&
 777       lstrncmp32W(lpFirst, lpSrch, uSrchLen);
 778     lpFirst++) {
 779       continue;
 780   }
 781   return (LPWSTR)lpFirst;
 782 }
 783
 784
 785 /***********************************************************************
 786  *           ChrCmpA
 787  * This fuction returns FALSE if both words match, TRUE otherwise...
 788  */
 789 static BOOL32 ChrCmpA( WORD word1, WORD word2) {
 790   if (LOBYTE(word1) == LOBYTE(word2)) {
 791     if (IsDBCSLeadByte32(LOBYTE(word1))) {
 792       return (word1 != word2);
 793     }
 794     return FALSE;
 795   }
 796   return TRUE;
 797 }
 798
 799 /***********************************************************************
 800  *           ChrCmpW
 801  * This fuction returns FALSE if both words match, TRUE otherwise...
 802  */
 803 static BOOL32 ChrCmpW( WORD word1, WORD word2) {
 804   return (word1 != word2);
 805 }
 806
 807