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 "debugstr.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
  56 /***********************************************************************
  57  *           hmemcpy   (KERNEL.348)
  58  */
  59 void WINAPI hmemcpy( LPVOID dst, LPCVOID src, LONG count )
  60 {
  61     memcpy( dst, src, count );
  62 }
  63
  64
  65 /***********************************************************************
  66  *           lstrcat16   (KERNEL.89)
  67  */
  68 SEGPTR WINAPI lstrcat16( SEGPTR dst, LPCSTR src )
  69 {
  70     lstrcat32A( (LPSTR)PTR_SEG_TO_LIN(dst), src );
  71     return dst;
  72 }
  73
  74
  75 /***********************************************************************
  76  *           lstrcat32A   (KERNEL32.599)
  77  */
  78 LPSTR WINAPI lstrcat32A( LPSTR dst, LPCSTR src )
  79 {
  80     dprintf_info(string,"strcat: Append %s to %s\n",
  81                    debugstr_a (src), debugstr_a (dst));
  82     /* Windows does not check for NULL pointers here, so we don't either */
  83     strcat( dst, src );
  84     return dst;
  85 }
  86
  87
  88 /***********************************************************************
  89  *           lstrcat32W   (KERNEL32.600)
  90  */
  91 LPWSTR WINAPI lstrcat32W( LPWSTR dst, LPCWSTR src )
  92 {
  93     register LPWSTR p = dst;
  94     dprintf_info(string,"strcat: Append L%s to L%s\n",
  95                    debugstr_w (src), debugstr_w (dst));
  96     /* Windows does not check for NULL pointers here, so we don't either */
  97     while (*p) p++;
  98     while ((*p++ = *src++));
  99     return dst;
 100 }
 101
 102
 103 /***********************************************************************
 104  *           lstrcatn16   (KERNEL.352)
 105  */
 106 SEGPTR WINAPI lstrcatn16( SEGPTR dst, LPCSTR src, INT16 n )
 107 {
 108     lstrcatn32A( (LPSTR)PTR_SEG_TO_LIN(dst), src, n );
 109     return dst;
 110 }
 111
 112
 113 /***********************************************************************
 114  *           lstrcatn32A   (Not a Windows API)
 115  */
 116 LPSTR WINAPI lstrcatn32A( LPSTR dst, LPCSTR src, INT32 n )
 117 {
 118     register LPSTR p = dst;
 119     dprintf_info(string,"strcatn add %d chars from %s to %s\n",
 120                    n, debugstr_an (src, n), debugstr_a (dst));
 121     while (*p) p++;
 122     if ((n -= (INT32)(p - dst)) <= 0) return dst;
 123     lstrcpyn32A( p, src, n );
 124     return dst;
 125 }
 126
 127
 128 /***********************************************************************
 129  *           lstrcatn32W   (Not a Windows API)
 130  */
 131 LPWSTR WINAPI lstrcatn32W( LPWSTR dst, LPCWSTR src, INT32 n )
 132 {
 133     register LPWSTR p = dst;
 134     dprintf_info(string,"strcatn add %d chars from L%s to L%s\n",
 135                    n, debugstr_wn (src, n), debugstr_w (dst));
 136     while (*p) p++;
 137     if ((n -= (INT32)(p - dst)) <= 0) return dst;
 138     lstrcpyn32W( p, src, n );
 139     return dst;
 140 }
 141
 142
 143 /***********************************************************************
 144  *           lstrcmp16   (USER.430)
 145  */
 146 INT16 WINAPI lstrcmp16( LPCSTR str1, LPCSTR str2 )
 147 {
 148     return (INT16)lstrcmp32A( str1, str2 );
 149 }
 150
 151
 152 /***********************************************************************
 153  *           lstrcmp32A   (KERNEL.602)
 154  */
 155 INT32 WINAPI lstrcmp32A( LPCSTR str1, LPCSTR str2 )
 156 {
 157     dprintf_info(string,"strcmp: %s and %s\n",
 158                    debugstr_a (str1), debugstr_a (str2));
 159     /* Win95 KERNEL32.DLL does it that way. Hands off! */
 160     if (!str1 || !str2) {
 161         SetLastError(ERROR_INVALID_PARAMETER);
 162         return 0;
 163     }
 164     return (INT32)strcmp( str1, str2 );
 165 }
 166
 167
 168 /***********************************************************************
 169  *           lstrcmp32W   (KERNEL.603)
 170  */
 171 INT32 WINAPI lstrcmp32W( LPCWSTR str1, LPCWSTR str2 )
 172 {
 173     dprintf_info(string,"strcmp: L%s and L%s\n",
 174                    debugstr_w (str1), debugstr_w (str2));
 175     if (!str1 || !str2) {
 176         SetLastError(ERROR_INVALID_PARAMETER);
 177         return 0;
 178     }
 179     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
 180     return (INT32)(*str1 - *str2);
 181 }
 182
 183
 184 /***********************************************************************
 185  *           lstrcmpi16   (USER.471)
 186  */
 187 INT16 WINAPI lstrcmpi16( LPCSTR str1, LPCSTR str2 )
 188 {
 189     return (INT16)lstrcmpi32A( str1, str2 );
 190 }
 191
 192
 193 /***********************************************************************
 194  *           lstrcmpi32A   (KERNEL32.605)
 195  */
 196 INT32 WINAPI lstrcmpi32A( LPCSTR str1, LPCSTR str2 )
 197 {
 198     INT32 res;
 199
 200     dprintf_info(string,"strcmpi %s and %s\n",
 201                    debugstr_a (str1), debugstr_a (str2));
 202     if (!str1 || !str2) {
 203         SetLastError(ERROR_INVALID_PARAMETER);
 204         return 0;
 205     }
 206     while (*str1)
 207     {
 208         if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
 209         str1++;
 210         str2++;
 211     }
 212     return toupper(*str1) - toupper(*str2);
 213 }
 214
 215
 216 /***********************************************************************
 217  *           lstrcmpi32W   (KERNEL32.606)
 218  */
 219 INT32 WINAPI lstrcmpi32W( LPCWSTR str1, LPCWSTR str2 )
 220 {
 221     INT32 res;
 222
 223 #if 0
 224     /* Too much!  (From registry loading.)  */
 225     dprintf_info(string,"strcmpi L%s and L%s\n",
 226                    debugstr_w (str1), debugstr_w (str2));
 227 #endif
 228     if (!str1 || !str2) {
 229         SetLastError(ERROR_INVALID_PARAMETER);
 230         return 0;
 231     }
 232     while (*str1)
 233     {
 234         /* FIXME: Unicode */
 235         if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
 236         str1++;
 237         str2++;
 238     }
 239     return toupper(*str1) - toupper(*str2);
 240 }
 241
 242
 243 /***********************************************************************
 244  *           lstrcpy16   (KERNEL.88)
 245  */
 246 SEGPTR WINAPI lstrcpy16( SEGPTR dst, LPCSTR src )
 247 {
 248     lstrcpy32A( (LPSTR)PTR_SEG_TO_LIN(dst), src );
 249     return dst;
 250 }
 251
 252
 253 /***********************************************************************
 254  *           lstrcpy32A   (KERNEL32.608)
 255  */
 256 LPSTR WINAPI lstrcpy32A( LPSTR dst, LPCSTR src )
 257 {
 258     dprintf_info(string,"strcpy %s\n", debugstr_a (src));
 259     /* Windows does not check for NULL pointers here, so we don't either */
 260     strcpy( dst, src );
 261     return dst;
 262 }
 263
 264
 265 /***********************************************************************
 266  *           lstrcpy32W   (KERNEL32.609)
 267  */
 268 LPWSTR WINAPI lstrcpy32W( LPWSTR dst, LPCWSTR src )
 269 {
 270     register LPWSTR p = dst;
 271     dprintf_info(string,"strcpy L%s\n", debugstr_w (src));
 272     /* Windows does not check for NULL pointers here, so we don't either */
 273     while ((*p++ = *src++));
 274     return dst;
 275 }
 276
 277
 278 /***********************************************************************
 279  *           lstrcpyn16   (KERNEL.353)
 280  */
 281 SEGPTR WINAPI lstrcpyn16( SEGPTR dst, LPCSTR src, INT16 n )
 282 {
 283     lstrcpyn32A( (LPSTR)PTR_SEG_TO_LIN(dst), src, n );
 284     return dst;
 285 }
 286
 287
 288 /***********************************************************************
 289  *           lstrcpyn32A   (KERNEL32.611)
 290  */
 291 LPSTR WINAPI lstrcpyn32A( LPSTR dst, LPCSTR src, INT32 n )
 292 {
 293     LPSTR p = dst;
 294     dprintf_info(string,"strcpyn %s for %d chars\n",
 295                    debugstr_an (src,n), n);
 296     /* Windows does not check for NULL pointers here, so we don't either */
 297     while ((n-- > 1) && *src) *p++ = *src++;
 298     if (n >= 0) *p = 0;
 299     return dst;
 300 }
 301
 302
 303 /***********************************************************************
 304  *           lstrcpyn32W   (KERNEL32.612)
 305  */
 306 LPWSTR WINAPI lstrcpyn32W( LPWSTR dst, LPCWSTR src, INT32 n )
 307 {
 308     LPWSTR p = dst;
 309     dprintf_info(string,"strcpyn L%s for %d chars\n",
 310                    debugstr_wn (src,n), n);
 311     /* Windows does not check for NULL pointers here, so we don't either */
 312     while ((n-- > 1) && *src) *p++ = *src++;
 313     if (n >= 0) *p = 0;
 314     return dst;
 315 }
 316
 317
 318 /***********************************************************************
 319  *           lstrlen16   (KERNEL.90)
 320  */
 321 INT16 WINAPI lstrlen16( LPCSTR str )
 322 {
 323     return (INT16)lstrlen32A( str );
 324 }
 325
 326
 327 /***********************************************************************
 328  *           lstrlen32A   (KERNEL32.614)
 329  */
 330 INT32 WINAPI lstrlen32A( LPCSTR str )
 331 {
 332     /* looks weird, but win3.1 KERNEL got a GeneralProtection handler
 333      * in lstrlen() ... we check only for NULL pointer reference.
 334      * - Marcus Meissner
 335      */
 336     dprintf_info(string,"strlen %s\n", debugstr_a (str));
 337     if (!str) return 0;
 338     return (INT32)strlen(str);
 339 }
 340
 341
 342 /***********************************************************************
 343  *           lstrlen32W   (KERNEL32.615)
 344  */
 345 INT32 WINAPI lstrlen32W( LPCWSTR str )
 346 {
 347     INT32 len = 0;
 348     dprintf_info(string,"strlen L%s\n", debugstr_w (str));
 349     if (!str) return 0;
 350     while (*str++) len++;
 351     return len;
 352 }
 353
 354
 355 /***********************************************************************
 356  *           lstrncmp32A   (Not a Windows API)
 357  */
 358 INT32 WINAPI lstrncmp32A( LPCSTR str1, LPCSTR str2, INT32 n )
 359 {
 360     dprintf_info(string,"strncmp %s and %s for %d chars\n",
 361                    debugstr_an (str1, n), debugstr_an (str2, n), n);
 362     return (INT32)strncmp( str1, str2, n );
 363 }
 364
 365
 366 /***********************************************************************
 367  *           lstrncmp32W   (Not a Windows API)
 368  */
 369 INT32 WINAPI lstrncmp32W( LPCWSTR str1, LPCWSTR str2, INT32 n )
 370 {
 371     dprintf_info(string,"strncmp L%s and L%s for %d chars\n",
 372                    debugstr_wn (str1, n), debugstr_wn (str2, n), n);
 373     if (!n) return 0;
 374     while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
 375     return (INT32)(*str1 - *str2);
 376 }
 377
 378
 379 /***********************************************************************
 380  *           lstrncmpi32A   (Not a Windows API)
 381  */
 382 INT32 WINAPI lstrncmpi32A( LPCSTR str1, LPCSTR str2, INT32 n )
 383 {
 384     INT32 res;
 385
 386     dprintf_info(string,"strncmpi %s and %s for %d chars\n",
 387                    debugstr_an (str1, n), debugstr_an (str2, n), n);
 388     if (!n) return 0;
 389     while ((--n > 0) && *str1)
 390       if ( (res = toupper(*str1++) - toupper(*str2++)) ) return res;
 391
 392     return toupper(*str1) - toupper(*str2);
 393 }
 394
 395
 396 /***********************************************************************
 397  *           lstrncmpi32W   (Not a Windows API)
 398  */
 399 INT32 WINAPI lstrncmpi32W( LPCWSTR str1, LPCWSTR str2, INT32 n )
 400 {
 401     INT32 res;
 402
 403     dprintf_info(string,"strncmpi L%s and L%s for %d chars\n",
 404                    debugstr_wn (str1, n), debugstr_wn (str2, n), n);
 405     if (!n) return 0;
 406     while ((--n > 0) && *str1)
 407     {
 408         /* FIXME: Unicode */
 409         if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
 410         str1++;
 411         str2++;
 412     }
 413     return toupper(*str1) - toupper(*str2);
 414 }
 415
 416
 417 /***********************************************************************
 418  *           lstrcpyAtoW   (Not a Windows API)
 419  */
 420 LPWSTR WINAPI lstrcpyAtoW( LPWSTR dst, LPCSTR src )
 421 {
 422     register LPWSTR p = dst;
 423     while ((*p++ = (WCHAR)(unsigned char)*src++));
 424     return dst;
 425 }
 426
 427
 428 /***********************************************************************
 429  *           lstrcpyWtoA   (Not a Windows API)
 430  */
 431 LPSTR WINAPI lstrcpyWtoA( LPSTR dst, LPCWSTR src )
 432 {
 433     register LPSTR p = dst;
 434     while ((*p++ = (CHAR)*src++));
 435     return dst;
 436 }
 437
 438
 439 /***********************************************************************
 440  *           lstrcpynAtoW   (Not a Windows API)
 441  */
 442 LPWSTR WINAPI lstrcpynAtoW( LPWSTR dst, LPCSTR src, INT32 n )
 443 {
 444     LPWSTR p = dst;
 445     while ((n-- > 1) && *src) *p++ = (WCHAR)(unsigned char)*src++;
 446     if (n >= 0) *p = 0;
 447     return dst;
 448 }
 449
 450
 451 /***********************************************************************
 452  *           lstrcpynWtoA   (Not a Windows API)
 453  */
 454 LPSTR WINAPI lstrcpynWtoA( LPSTR dst, LPCWSTR src, INT32 n )
 455 {
 456     LPSTR p = dst;
 457     while ((n-- > 1) && *src) *p++ = (CHAR)*src++;
 458     if (n >= 0) *p = 0;
 459     return dst;
 460 }
 461
 462
 463 /***********************************************************************
 464  *           Copy   (GDI.250)
 465  */
 466 void WINAPI Copy( LPVOID src, LPVOID dst, WORD size )
 467 {
 468     memcpy( dst, src, size );
 469 }
 470
 471
 472 /***********************************************************************
 473  *           RtlFillMemory   (KERNEL32.441)
 474  */
 475 VOID WINAPI RtlFillMemory( LPVOID ptr, UINT32 len, UINT32 fill )
 476 {
 477     memset( ptr, fill, len );
 478 }
 479
 480
 481 /***********************************************************************
 482  *           RtlMoveMemory   (KERNEL32.442)
 483  */
 484 VOID WINAPI RtlMoveMemory( LPVOID dst, LPCVOID src, UINT32 len )
 485 {
 486     memmove( dst, src, len );
 487 }
 488
 489
 490 /***********************************************************************
 491  *           RtlZeroMemory   (KERNEL32.444)
 492  */
 493 VOID WINAPI RtlZeroMemory( LPVOID ptr, UINT32 len )
 494 {
 495     memset( ptr, 0, len );
 496 }
 497
 498
 499 /***********************************************************************
 500  *           AnsiToOem16   (KEYBOARD.5)
 501  */
 502 INT16 WINAPI AnsiToOem16( LPCSTR s, LPSTR d )
 503 {
 504     CharToOem32A( s, d );
 505     return -1;
 506 }
 507
 508
 509 /***********************************************************************
 510  *           OemToAnsi16   (KEYBOARD.6)
 511  */
 512 INT16 WINAPI OemToAnsi16( LPCSTR s, LPSTR d )
 513 {
 514     OemToChar32A( s, d );
 515     return -1;
 516 }
 517
 518
 519 /***********************************************************************
 520  *           AnsiToOemBuff16   (KEYBOARD.134)
 521  */
 522 void WINAPI AnsiToOemBuff16( LPCSTR s, LPSTR d, UINT16 len )
 523 {
 524     CharToOemBuff32A( s, d, len ? len : 65536 );
 525 }
 526
 527
 528 /***********************************************************************
 529  *           OemToAnsiBuff16   (KEYBOARD.135)
 530  */
 531 void WINAPI OemToAnsiBuff16( LPCSTR s, LPSTR d, UINT16 len )
 532 {
 533     OemToCharBuff32A( s, d, len ? len : 65536 );
 534 }
 535
 536
 537 /***********************************************************************
 538  *           CharToOem32A   (USER32.36)
 539  */
 540 BOOL32 WINAPI CharToOem32A( LPCSTR s, LPSTR d )
 541 {
 542     LPSTR oldd = d;
 543     if (!s || !d) return TRUE;
 544     dprintf_info(string,"CharToOem %s\n", debugstr_a (s));
 545     while ((*d++ = ANSI_TO_OEM(*s++)));
 546     dprintf_info(string,"       to %s\n", debugstr_a (oldd));
 547     return TRUE;
 548 }
 549
 550
 551 /***********************************************************************
 552  *           CharToOemBuff32A   (USER32.37)
 553  */
 554 BOOL32 WINAPI CharToOemBuff32A( LPCSTR s, LPSTR d, DWORD len )
 555 {
 556     while (len--) *d++ = ANSI_TO_OEM(*s++);
 557     return TRUE;
 558 }
 559
 560
 561 /***********************************************************************
 562  *           CharToOemBuff32W   (USER32.38)
 563  */
 564 BOOL32 WINAPI CharToOemBuff32W( LPCWSTR s, LPSTR d, DWORD len )
 565 {
 566     while (len--) *d++ = ANSI_TO_OEM(*s++);
 567     return TRUE;
 568 }
 569
 570
 571 /***********************************************************************
 572  *           CharToOem32W   (USER32.39)
 573  */
 574 BOOL32 WINAPI CharToOem32W( LPCWSTR s, LPSTR d )
 575 {
 576     LPSTR oldd = d;
 577     if (!s || !d) return TRUE;
 578     dprintf_info(string,"CharToOem L%s\n", debugstr_w (s));
 579     while ((*d++ = ANSI_TO_OEM(*s++)));
 580     dprintf_info(string,"       to %s\n", debugstr_a (oldd));
 581     return TRUE;
 582 }
 583
 584
 585 /***********************************************************************
 586  *           OemToChar32A   (USER32.401)
 587  */
 588 BOOL32 WINAPI OemToChar32A( LPCSTR s, LPSTR d )
 589 {
 590     LPSTR oldd = d;
 591     dprintf_info(string,"OemToChar %s\n", debugstr_a (s));
 592     while ((*d++ = OEM_TO_ANSI(*s++)));
 593     dprintf_info(string,"       to %s\n", debugstr_a (oldd));
 594     return TRUE;
 595 }
 596
 597
 598 /***********************************************************************
 599  *           OemToCharBuff32A   (USER32.402)
 600  */
 601 BOOL32 WINAPI OemToCharBuff32A( LPCSTR s, LPSTR d, DWORD len )
 602 {
 603     dprintf_info(string,"OemToCharBuff %s\n", debugstr_an (s, len));
 604     while (len--) *d++ = OEM_TO_ANSI(*s++);
 605     return TRUE;
 606 }
 607
 608
 609 /***********************************************************************
 610  *           OemToCharBuff32W   (USER32.403)
 611  */
 612 BOOL32 WINAPI OemToCharBuff32W( LPCSTR s, LPWSTR d, DWORD len )
 613 {
 614     dprintf_info(string,"OemToCharBuff %s\n", debugstr_an (s, len));
 615     while (len--) *d++ = (WCHAR)OEM_TO_ANSI(*s++);
 616     return TRUE;
 617 }
 618
 619
 620 /***********************************************************************
 621  *           OemToChar32W   (USER32.404)
 622  */
 623 BOOL32 WINAPI OemToChar32W( LPCSTR s, LPWSTR d )
 624 {
 625     while ((*d++ = (WCHAR)OEM_TO_ANSI(*s++)));
 626     return TRUE;
 627 }