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 "ldt.h"
  12
  13 static const BYTE STRING_Oem2Ansi[256] =
  14 "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\244"
  15 "\020\021\022\023\266\247\026\027\030\031\032\033\034\035\036\037"
  16 "\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
  17 "\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
  18 "\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
  19 "\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
  20 "\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
  21 "\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
  22 "\307\374\351\342\344\340\345\347\352\353\350\357\356\354\304\305"
  23 "\311\346\306\364\366\362\373\371\377\326\334\242\243\245\120\203"
  24 "\341\355\363\372\361\321\252\272\277\137\254\275\274\241\253\273"
  25 "\137\137\137\246\246\246\246\053\053\246\246\053\053\053\053\053"
  26 "\053\055\055\053\055\053\246\246\053\053\055\055\246\055\053\055"
  27 "\055\055\055\053\053\053\053\053\053\053\053\137\137\246\137\137"
  28 "\137\337\137\266\137\137\265\137\137\137\137\137\137\137\137\137"
  29 "\137\261\137\137\137\137\367\137\260\225\267\137\156\262\137\137";
  30
  31 static const BYTE STRING_Ansi2Oem[256] =
  32 "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017"
  33 "\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
  34 "\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
  35 "\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
  36 "\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
  37 "\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
  38 "\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
  39 "\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
  40 "\200\201\054\237\054\137\375\374\210\045\123\074\117\215\216\217"
  41 "\220\140\047\042\042\371\055\137\230\231\163\076\157\235\236\131"
  42 "\040\255\233\234\017\235\335\025\042\143\246\256\252\055\162\137"
  43 "\370\361\375\063\047\346\024\372\054\061\247\257\254\253\137\250"
  44 "\101\101\101\101\216\217\222\200\105\220\105\105\111\111\111\111"
  45 "\104\245\117\117\117\117\231\170\117\125\125\125\232\131\137\341"
  46 "\205\240\203\141\204\206\221\207\212\202\210\211\215\241\214\213"
  47 "\144\244\225\242\223\157\224\366\157\227\243\226\201\171\137\230";
  48
  49 #define OEM_TO_ANSI(ch) (STRING_Oem2Ansi[(unsigned char)(ch)])
  50 #define ANSI_TO_OEM(ch) (STRING_Ansi2Oem[(unsigned char)(ch)])
  51
  52
  53 /***********************************************************************
  54  *           hmemcpy   (KERNEL.348)
  55  */
  56 void hmemcpy( LPVOID dst, LPCVOID src, LONG count )
  57 {
  58     memcpy( dst, src, count );
  59 }
  60
  61
  62 /***********************************************************************
  63  *           lstrcat16   (KERNEL.89)
  64  */
  65 SEGPTR lstrcat16( SEGPTR dst, SEGPTR src )
  66 {
  67     lstrcat32A( (LPSTR)PTR_SEG_TO_LIN(dst), (LPCSTR)PTR_SEG_TO_LIN(src) );
  68     return dst;
  69 }
  70
  71
  72 /***********************************************************************
  73  *           lstrcat32A   (KERNEL32.599)
  74  */
  75 LPSTR lstrcat32A( LPSTR dst, LPCSTR src )
  76 {
  77     strcat( dst, src );
  78     return dst;
  79 }
  80
  81
  82 /***********************************************************************
  83  *           lstrcat32W   (KERNEL32.600)
  84  */
  85 LPWSTR lstrcat32W( LPWSTR dst, LPCWSTR src )
  86 {
  87     register LPWSTR p = dst;
  88     while (*p) p++;
  89     while ((*p++ = *src++));
  90     return dst;
  91 }
  92
  93
  94 /***********************************************************************
  95  *           lstrcatn16   (KERNEL.352)
  96  */
  97 SEGPTR lstrcatn16( SEGPTR dst, SEGPTR src, INT16 n )
  98 {
  99     lstrcatn32A( (LPSTR)PTR_SEG_TO_LIN(dst), (LPCSTR)PTR_SEG_TO_LIN(src), n );
 100     return dst;
 101 }
 102
 103
 104 /***********************************************************************
 105  *           lstrcatn32A   (Not a Windows API)
 106  */
 107 LPSTR lstrcatn32A( LPSTR dst, LPCSTR src, INT32 n )
 108 {
 109     register LPSTR p = dst;
 110     while (*p) p++;
 111     if ((n -= (INT32)(p - dst)) <= 0) return dst;
 112     lstrcpyn32A( p, src, n );
 113     return dst;
 114 }
 115
 116
 117 /***********************************************************************
 118  *           lstrcatn32W   (Not a Windows API)
 119  */
 120 LPWSTR lstrcatn32W( LPWSTR dst, LPCWSTR src, INT32 n )
 121 {
 122     register LPWSTR p = dst;
 123     while (*p) p++;
 124     if ((n -= (INT32)(p - dst)) <= 0) return dst;
 125     lstrcpyn32W( p, src, n );
 126     return dst;
 127 }
 128
 129
 130 /***********************************************************************
 131  *           lstrcmp16   (USER.430)
 132  */
 133 INT16 lstrcmp16( LPCSTR str1, LPCSTR str2 )
 134 {
 135     return (INT16)lstrcmp32A( str1, str2 );
 136 }
 137
 138
 139 /***********************************************************************
 140  *           lstrcmp32A   (KERNEL.602)
 141  */
 142 INT32 lstrcmp32A( LPCSTR str1, LPCSTR str2 )
 143 {
 144     return (INT32)strcmp( str1, str2 );
 145 }
 146
 147
 148 /***********************************************************************
 149  *           lstrcmp32W   (KERNEL.603)
 150  */
 151 INT32 lstrcmp32W( LPCWSTR str1, LPCWSTR str2 )
 152 {
 153     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
 154     return (INT32)(*str1 - *str2);
 155 }
 156
 157
 158 /***********************************************************************
 159  *           lstrcmpi16   (USER.471)
 160  */
 161 INT16 lstrcmpi16( LPCSTR str1, LPCSTR str2 )
 162 {
 163     return (INT16)lstrcmpi32A( str1, str2 );
 164 }
 165
 166
 167 /***********************************************************************
 168  *           lstrcmpi32A   (KERNEL32.605)
 169  */
 170 INT32 lstrcmpi32A( LPCSTR str1, LPCSTR str2 )
 171 {
 172     INT32 res;
 173
 174     while (*str1)
 175     {
 176         if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
 177         str1++;
 178         str2++;
 179     }
 180     return toupper(*str1) - toupper(*str2);
 181 }
 182
 183
 184 /***********************************************************************
 185  *           lstrcmpi32W   (KERNEL32.606)
 186  */
 187 INT32 lstrcmpi32W( LPCWSTR str1, LPCWSTR str2 )
 188 {
 189     INT32 res;
 190
 191     while (*str1)
 192     {
 193         /* FIXME: Unicode */
 194         if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
 195         str1++;
 196         str2++;
 197     }
 198     return toupper(*str1) - toupper(*str2);
 199 }
 200
 201
 202 /***********************************************************************
 203  *           lstrcpy16   (KERNEL.88)
 204  */
 205 SEGPTR lstrcpy16( SEGPTR dst, SEGPTR src )
 206 {
 207     lstrcpy32A( (LPSTR)PTR_SEG_TO_LIN(dst), (LPCSTR)PTR_SEG_TO_LIN(src) );
 208     return dst;
 209 }
 210
 211
 212 /***********************************************************************
 213  *           lstrcpy32A   (KERNEL32.608)
 214  */
 215 LPSTR lstrcpy32A( LPSTR dst, LPCSTR src )
 216 {
 217     if (!src || !dst) return NULL;
 218     strcpy( dst, src );
 219     return dst;
 220 }
 221
 222
 223 /***********************************************************************
 224  *           lstrcpy32W   (KERNEL32.609)
 225  */
 226 LPWSTR lstrcpy32W( LPWSTR dst, LPCWSTR src )
 227 {
 228     register LPWSTR p = dst;
 229     while ((*p++ = *src++));
 230     return dst;
 231 }
 232
 233
 234 /***********************************************************************
 235  *           lstrcpyn16   (KERNEL.353)
 236  */
 237 SEGPTR lstrcpyn16( SEGPTR dst, SEGPTR src, INT16 n )
 238 {
 239     lstrcpyn32A( (LPSTR)PTR_SEG_TO_LIN(dst), (LPCSTR)PTR_SEG_TO_LIN(src), n );
 240     return dst;
 241 }
 242
 243
 244 /***********************************************************************
 245  *           lstrcpyn32A   (KERNEL32.611)
 246  */
 247 LPSTR lstrcpyn32A( LPSTR dst, LPCSTR src, INT32 n )
 248 {
 249     LPSTR p = dst;
 250     while ((n-- > 1) && *src) *p++ = *src++;
 251     *p = 0;
 252     return dst;
 253 }
 254
 255
 256 /***********************************************************************
 257  *           lstrcpyn32W   (KERNEL32.612)
 258  */
 259 LPWSTR lstrcpyn32W( LPWSTR dst, LPCWSTR src, INT32 n )
 260 {
 261     LPWSTR p = dst;
 262     while ((n-- > 1) && *src) *p++ = *src++;
 263     *p = 0;
 264     return dst;
 265 }
 266
 267
 268 /***********************************************************************
 269  *           lstrlen16   (KERNEL.90)
 270  */
 271 INT16 lstrlen16( LPCSTR str )
 272 {
 273     return (INT16)lstrlen32A( str );
 274 }
 275
 276
 277 /***********************************************************************
 278  *           lstrlen32A   (KERNEL32.614)
 279  */
 280 INT32 lstrlen32A( LPCSTR str )
 281 {
 282     /* looks weird, but win3.1 KERNEL got a GeneralProtection handler
 283      * in lstrlen() ... we check only for NULL pointer reference.
 284      * - Marcus Meissner
 285      */
 286     if (!str) return 0;
 287     return (INT32)strlen(str);
 288 }
 289
 290
 291 /***********************************************************************
 292  *           lstrlen32W   (KERNEL32.615)
 293  */
 294 INT32 lstrlen32W( LPCWSTR str )
 295 {
 296     INT32 len = 0;
 297     if (!str) return 0;
 298     while (*str++) len++;
 299     return len;
 300 }
 301
 302
 303 /***********************************************************************
 304  *           lstrncmp32A   (Not a Windows API)
 305  */
 306 INT32 lstrncmp32A( LPCSTR str1, LPCSTR str2, INT32 n )
 307 {
 308     return (INT32)strncmp( str1, str2, n );
 309 }
 310
 311
 312 /***********************************************************************
 313  *           lstrncmp32W   (Not a Windows API)
 314  */
 315 INT32 lstrncmp32W( LPCWSTR str1, LPCWSTR str2, INT32 n )
 316 {
 317     if (!n) return 0;
 318     while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
 319     return (INT32)(*str1 - *str2);
 320 }
 321
 322
 323 /***********************************************************************
 324  *           lstrncmpi32A   (Not a Windows API)
 325  */
 326 INT32 lstrncmpi32A( LPCSTR str1, LPCSTR str2, INT32 n )
 327 {
 328     INT32 res;
 329
 330     if (!n) return 0;
 331     while ((--n > 0) && *str1)
 332       if ( (res = toupper(*str1++) - toupper(*str2++)) ) return res;
 333
 334     return toupper(*str1) - toupper(*str2);
 335 }
 336
 337
 338 /***********************************************************************
 339  *           lstrncmpi32W   (Not a Windows API)
 340  */
 341 INT32 lstrncmpi32W( LPCWSTR str1, LPCWSTR str2, INT32 n )
 342 {
 343     INT32 res;
 344
 345     if (!n) return 0;
 346     while ((--n > 0) && *str1)
 347     {
 348         /* FIXME: Unicode */
 349         if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
 350         str1++;
 351         str2++;
 352     }
 353     return toupper(*str1) - toupper(*str2);
 354 }
 355
 356
 357 /***********************************************************************
 358  *           lstrcpyAtoW   (Not a Windows API)
 359  */
 360 LPWSTR lstrcpyAtoW( LPWSTR dst, LPCSTR src )
 361 {
 362     register LPWSTR p = dst;
 363     while ((*p++ = (WCHAR)(unsigned char)*src++));
 364     return dst;
 365 }
 366
 367
 368 /***********************************************************************
 369  *           lstrcpyWtoA   (Not a Windows API)
 370  */
 371 LPSTR lstrcpyWtoA( LPSTR dst, LPCWSTR src )
 372 {
 373     register LPSTR p = dst;
 374     while ((*p++ = (CHAR)*src++));
 375     return dst;
 376 }
 377
 378
 379 /***********************************************************************
 380  *           lstrcpynAtoW   (Not a Windows API)
 381  */
 382 LPWSTR lstrcpynAtoW( LPWSTR dst, LPCSTR src, INT32 n )
 383 {
 384     LPWSTR p = dst;
 385     while ((n-- > 1) && *src) *p++ = (WCHAR)(unsigned char)*src++;
 386     *p = 0;
 387     return dst;
 388 }
 389
 390
 391 /***********************************************************************
 392  *           lstrcpynWtoA   (Not a Windows API)
 393  */
 394 LPSTR lstrcpynWtoA( LPSTR dst, LPCWSTR src, INT32 n )
 395 {
 396     LPSTR p = dst;
 397     while ((n-- > 1) && *src) *p++ = (CHAR)*src++;
 398     *p = 0;
 399     return dst;
 400 }
 401
 402
 403 /***********************************************************************
 404  *           RtlFillMemory   (KERNEL32.441)
 405  */
 406 VOID RtlFillMemory( LPVOID ptr, UINT32 len, UINT32 fill )
 407 {
 408     memset( ptr, fill, len );
 409 }
 410
 411
 412 /***********************************************************************
 413  *           RtlMoveMemory   (KERNEL32.442)
 414  */
 415 VOID RtlMoveMemory( LPVOID dst, LPCVOID src, UINT32 len )
 416 {
 417     memmove( dst, src, len );
 418 }
 419
 420
 421 /***********************************************************************
 422  *           RtlZeroMemory   (KERNEL32.444)
 423  */
 424 VOID RtlZeroMemory( LPVOID ptr, UINT32 len )
 425 {
 426     memset( ptr, 0, len );
 427 }
 428
 429
 430 /***********************************************************************
 431  *           AnsiToOem16   (KEYBOARD.5)
 432  */
 433 INT16 AnsiToOem16( LPCSTR s, LPSTR d )
 434 {
 435     CharToOem32A( s, d );
 436     return -1;
 437 }
 438
 439
 440 /***********************************************************************
 441  *           OemToAnsi16   (KEYBOARD.6)
 442  */
 443 INT16 OemToAnsi16( LPCSTR s, LPSTR d )
 444 {
 445     OemToChar32A( s, d );
 446     return -1;
 447 }
 448
 449
 450 /***********************************************************************
 451  *           AnsiToOemBuff16   (KEYBOARD.134)
 452  */
 453 void AnsiToOemBuff16( LPCSTR s, LPSTR d, UINT16 len )
 454 {
 455     CharToOemBuff32A( s, d, len ? len : 65536 );
 456 }
 457
 458
 459 /***********************************************************************
 460  *           OemToAnsiBuff16   (KEYBOARD.135)
 461  */
 462 void OemToAnsiBuff16( LPCSTR s, LPSTR d, UINT16 len )
 463 {
 464     OemToCharBuff32A( s, d, len ? len : 65536 );
 465 }
 466
 467
 468 /***********************************************************************
 469  *           CharToOem32A   (USER32.36)
 470  */
 471 BOOL32 CharToOem32A( LPCSTR s, LPSTR d )
 472 {
 473     if (!s || !d) return TRUE;
 474     while ((*d++ = ANSI_TO_OEM(*s++)));
 475     return TRUE;
 476 }
 477
 478
 479 /***********************************************************************
 480  *           CharToOemBuff32A   (USER32.37)
 481  */
 482 BOOL32 CharToOemBuff32A( LPCSTR s, LPSTR d, DWORD len )
 483 {
 484     while (len--) *d++ = ANSI_TO_OEM(*s++);
 485     return TRUE;
 486 }
 487
 488
 489 /***********************************************************************
 490  *           CharToOemBuff32W   (USER32.38)
 491  */
 492 BOOL32 CharToOemBuff32W( LPCWSTR s, LPSTR d, DWORD len )
 493 {
 494     while (len--) *d++ = ANSI_TO_OEM(*s++);
 495     return TRUE;
 496 }
 497
 498
 499 /***********************************************************************
 500  *           CharToOem32W   (USER32.39)
 501  */
 502 BOOL32 CharToOem32W( LPCWSTR s, LPSTR d )
 503 {
 504     while ((*d++ = ANSI_TO_OEM(*s++)));
 505     return TRUE;
 506 }
 507
 508
 509 /***********************************************************************
 510  *           OemToChar32A   (USER32.401)
 511  */
 512 BOOL32 OemToChar32A( LPCSTR s, LPSTR d )
 513 {
 514     while ((*d++ = OEM_TO_ANSI(*s++)));
 515     return TRUE;
 516 }
 517
 518
 519 /***********************************************************************
 520  *           OemToCharBuff32A   (USER32.402)
 521  */
 522 BOOL32 OemToCharBuff32A( LPCSTR s, LPSTR d, DWORD len )
 523 {
 524     while (len--) *d++ = OEM_TO_ANSI(*s++);
 525     return TRUE;
 526 }
 527
 528
 529 /***********************************************************************
 530  *           OemToCharBuff32W   (USER32.403)
 531  */
 532 BOOL32 OemToCharBuff32W( LPCSTR s, LPWSTR d, DWORD len )
 533 {
 534     while (len--) *d++ = (WCHAR)OEM_TO_ANSI(*s++);
 535     return TRUE;
 536 }
 537
 538
 539 /***********************************************************************
 540  *           OemToChar32W   (USER32.404)
 541  */
 542 BOOL32 OemToChar32W( LPCSTR s, LPWSTR d )
 543 {
 544     while ((*d++ = (WCHAR)OEM_TO_ANSI(*s++)));
 545     return TRUE;
 546 }