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
  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     TRACE(string,"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     TRACE(string,"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     TRACE(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     TRACE(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)strcmp( str1, str2 );
 149 }
 150
 151
 152 /***********************************************************************
 153  *           lstrcmp32A   (KERNEL.602)
 154  */
 155 INT32 WINAPI lstrcmp32A( LPCSTR str1, LPCSTR str2 )
 156 {
 157     return CompareString32A(LOCALE_SYSTEM_DEFAULT,0,str1,-1,str2,-1) - 2 ;
 158 }
 159
 160
 161 /***********************************************************************
 162  *           lstrcmp32W   (KERNEL.603)
 163  * FIXME : should call CompareString32W, when it is implemented.
 164  *    This implementation is not "word sort", as it should.
 165  */
 166 INT32 WINAPI lstrcmp32W( LPCWSTR str1, LPCWSTR str2 )
 167 {
 168     TRACE(string,"L%s and L%s\n",
 169                    debugstr_w (str1), debugstr_w (str2));
 170     if (!str1 || !str2) {
 171         SetLastError(ERROR_INVALID_PARAMETER);
 172         return 0;
 173     }
 174     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
 175     return (INT32)(*str1 - *str2);
 176 }
 177
 178
 179 /***********************************************************************
 180  *           lstrcmpi16   (USER.471)
 181  */
 182 INT16 WINAPI lstrcmpi16( LPCSTR str1, LPCSTR str2 )
 183 {
 184     return (INT16)lstrcmpi32A( str1, str2 );
 185 }
 186
 187
 188 /***********************************************************************
 189  *           lstrcmpi32A   (KERNEL32.605)
 190  */
 191 INT32 WINAPI lstrcmpi32A( LPCSTR str1, LPCSTR str2 )
 192 {    TRACE(string,"strcmpi %s and %s\n",
 193                    debugstr_a (str1), debugstr_a (str2));
 194     return CompareString32A(LOCALE_SYSTEM_DEFAULT,NORM_IGNORECASE,str1,-1,str2,-1)-2;
 195 }
 196
 197
 198 /***********************************************************************
 199  *           lstrcmpi32W   (KERNEL32.606)
 200  */
 201 INT32 WINAPI lstrcmpi32W( LPCWSTR str1, LPCWSTR str2 )
 202 {
 203     INT32 res;
 204
 205 #if 0
 206     /* Too much!  (From registry loading.)  */
 207     TRACE(string,"strcmpi L%s and L%s\n",
 208                    debugstr_w (str1), debugstr_w (str2));
 209 #endif
 210     if (!str1 || !str2) {
 211         SetLastError(ERROR_INVALID_PARAMETER);
 212         return 0;
 213     }
 214     while (*str1)
 215     {
 216         if ((res = towupper(*str1) - towupper(*str2)) != 0) return res;
 217         str1++;
 218         str2++;
 219     }
 220     return towupper(*str1) - towupper(*str2);
 221 }
 222
 223
 224 /***********************************************************************
 225  *           lstrcpy16   (KERNEL.88)
 226  */
 227 SEGPTR WINAPI lstrcpy16( SEGPTR dst, LPCSTR src )
 228 {
 229     lstrcpy32A( (LPSTR)PTR_SEG_TO_LIN(dst), src );
 230     return dst;
 231 }
 232
 233
 234 /***********************************************************************
 235  *           lstrcpy32A   (KERNEL32.608)
 236  */
 237 LPSTR WINAPI lstrcpy32A( LPSTR dst, LPCSTR src )
 238 {
 239     TRACE(string,"strcpy %s\n", debugstr_a (src));
 240     /* Windows does not check for NULL pointers here, so we don't either */
 241     strcpy( dst, src );
 242     return dst;
 243 }
 244
 245
 246 /***********************************************************************
 247  *           lstrcpy32W   (KERNEL32.609)
 248  */
 249 LPWSTR WINAPI lstrcpy32W( LPWSTR dst, LPCWSTR src )
 250 {
 251     register LPWSTR p = dst;
 252     TRACE(string,"strcpy L%s\n", debugstr_w (src));
 253     /* Windows does not check for NULL pointers here, so we don't either */
 254     while ((*p++ = *src++));
 255     return dst;
 256 }
 257
 258
 259 /***********************************************************************
 260  *           lstrcpyn16   (KERNEL.353)
 261  */
 262 SEGPTR WINAPI lstrcpyn16( SEGPTR dst, LPCSTR src, INT16 n )
 263 {
 264     lstrcpyn32A( (LPSTR)PTR_SEG_TO_LIN(dst), src, n );
 265     return dst;
 266 }
 267
 268
 269 /***********************************************************************
 270  *           lstrcpyn32A   (KERNEL32.611)
 271  * Note: this function differs from the UNIX strncpy, it _always_ writes
 272  * a terminating \0
 273  */
 274 LPSTR WINAPI lstrcpyn32A( LPSTR dst, LPCSTR src, INT32 n )
 275 {
 276     LPSTR p = dst;
 277     TRACE(string,"strcpyn %s for %d chars\n",
 278                    debugstr_an (src,n), n);
 279     /* Windows does not check for NULL pointers here, so we don't either */
 280     while ((n-- > 1) && *src) *p++ = *src++;
 281     if (n >= 0) *p = 0;
 282     return dst;
 283 }
 284
 285
 286 /***********************************************************************
 287  *           lstrcpyn32W   (KERNEL32.612)
 288  * Note: this function differs from the UNIX strncpy, it _always_ writes
 289  * a terminating \0
 290  */
 291 LPWSTR WINAPI lstrcpyn32W( LPWSTR dst, LPCWSTR src, INT32 n )
 292 {
 293     LPWSTR p = dst;
 294     TRACE(string,"strcpyn L%s for %d chars\n",
 295                    debugstr_wn (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  *           lstrlen16   (KERNEL.90)
 305  */
 306 INT16 WINAPI lstrlen16( LPCSTR str )
 307 {
 308     return (INT16)lstrlen32A( str );
 309 }
 310
 311
 312 /***********************************************************************
 313  *           lstrlen32A   (KERNEL32.614)
 314  */
 315 INT32 WINAPI lstrlen32A( LPCSTR str )
 316 {
 317     /* looks weird, but win3.1 KERNEL got a GeneralProtection handler
 318      * in lstrlen() ... we check only for NULL pointer reference.
 319      * - Marcus Meissner
 320      */
 321     TRACE(string,"strlen %s\n", debugstr_a (str));
 322     if (!str) return 0;
 323     return (INT32)strlen(str);
 324 }
 325
 326
 327 /***********************************************************************
 328  *           lstrlen32W   (KERNEL32.615)
 329  */
 330 INT32 WINAPI lstrlen32W( LPCWSTR str )
 331 {
 332     INT32 len = 0;
 333     TRACE(string,"strlen L%s\n", debugstr_w (str));
 334     if (!str) return 0;
 335     while (*str++) len++;
 336     return len;
 337 }
 338
 339
 340 /***********************************************************************
 341  *           lstrncmp32A   (Not a Windows API)
 342  */
 343 INT32 WINAPI lstrncmp32A( LPCSTR str1, LPCSTR str2, INT32 n )
 344 {
 345     TRACE(string,"strncmp %s and %s for %d chars\n",
 346                    debugstr_an (str1, n), debugstr_an (str2, n), n);
 347     return (INT32)strncmp( str1, str2, n );
 348 }
 349
 350
 351 /***********************************************************************
 352  *           lstrncmp32W   (Not a Windows API)
 353  */
 354 INT32 WINAPI lstrncmp32W( LPCWSTR str1, LPCWSTR str2, INT32 n )
 355 {
 356     TRACE(string,"strncmp L%s and L%s for %d chars\n",
 357                    debugstr_wn (str1, n), debugstr_wn (str2, n), n);
 358     if (!n) return 0;
 359     while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
 360     return (INT32)(*str1 - *str2);
 361 }
 362
 363
 364 /***********************************************************************
 365  *           lstrncmpi32A   (Not a Windows API)
 366  */
 367 INT32 WINAPI lstrncmpi32A( LPCSTR str1, LPCSTR str2, INT32 n )
 368 {
 369     INT32 res;
 370
 371     TRACE(string,"strncmpi %s and %s for %d chars\n",
 372                    debugstr_an (str1, n), debugstr_an (str2, n), n);
 373     if (!n) return 0;
 374     while ((--n > 0) && *str1)
 375       if ( (res = toupper(*str1++) - toupper(*str2++)) ) return res;
 376
 377     return toupper(*str1) - toupper(*str2);
 378 }
 379
 380
 381 /***********************************************************************
 382  *           lstrncmpi32W   (Not a Windows API)
 383  */
 384 INT32 WINAPI lstrncmpi32W( LPCWSTR str1, LPCWSTR str2, INT32 n )
 385 {
 386     INT32 res;
 387
 388     TRACE(string,"strncmpi L%s and L%s for %d chars\n",
 389                    debugstr_wn (str1, n), debugstr_wn (str2, n), n);
 390     if (!n) return 0;
 391     while ((--n > 0) && *str1)
 392     {
 393         if ((res = towupper(*str1) - towupper(*str2)) != 0) return res;
 394         str1++;
 395         str2++;
 396     }
 397     return towupper(*str1) - towupper(*str2);
 398 }
 399
 400
 401 /***********************************************************************
 402  *           lstrcpyAtoW   (Not a Windows API)
 403  */
 404 LPWSTR WINAPI lstrcpyAtoW( LPWSTR dst, LPCSTR src )
 405 {
 406     register LPWSTR p = dst;
 407     while ((*p++ = (WCHAR)(unsigned char)*src++));
 408     return dst;
 409 }
 410
 411
 412 /***********************************************************************
 413  *           lstrcpyWtoA   (Not a Windows API)
 414  */
 415 LPSTR WINAPI lstrcpyWtoA( LPSTR dst, LPCWSTR src )
 416 {
 417     register LPSTR p = dst;
 418     while ((*p++ = (CHAR)*src++));
 419     return dst;
 420 }
 421
 422
 423 /***********************************************************************
 424  *           lstrcpynAtoW   (Not a Windows API)
 425  * Note: this function differs from the UNIX strncpy, it _always_ writes
 426  * a terminating \0
 427  */
 428 LPWSTR WINAPI lstrcpynAtoW( LPWSTR dst, LPCSTR src, INT32 n )
 429 {
 430     LPWSTR p = dst;
 431     while ((n-- > 1) && *src) *p++ = (WCHAR)(unsigned char)*src++;
 432     if (n >= 0) *p = 0;
 433     return dst;
 434 }
 435
 436
 437 /***********************************************************************
 438  *           lstrcpynWtoA   (Not a Windows API)
 439  * Note: this function differs from the UNIX strncpy, it _always_ writes
 440  * a terminating \0
 441  */
 442 LPSTR WINAPI lstrcpynWtoA( LPSTR dst, LPCWSTR src, INT32 n )
 443 {
 444     LPSTR p = dst;
 445     while ((n-- > 1) && *src) *p++ = (CHAR)*src++;
 446     if (n >= 0) *p = 0;
 447     return dst;
 448 }
 449
 450
 451 /***********************************************************************
 452  *           Copy   (GDI.250)
 453  */
 454 void WINAPI Copy( LPVOID src, LPVOID dst, WORD size )
 455 {
 456     memcpy( dst, src, size );
 457 }
 458
 459
 460 /***********************************************************************
 461  *           RtlFillMemory   (KERNEL32.441)
 462  */
 463 VOID WINAPI RtlFillMemory( LPVOID ptr, UINT32 len, UINT32 fill )
 464 {
 465     memset( ptr, fill, len );
 466 }
 467
 468
 469 /***********************************************************************
 470  *           RtlMoveMemory   (KERNEL32.442)
 471  */
 472 VOID WINAPI RtlMoveMemory( LPVOID dst, LPCVOID src, UINT32 len )
 473 {
 474     memmove( dst, src, len );
 475 }
 476
 477
 478 /***********************************************************************
 479  *           RtlZeroMemory   (KERNEL32.444)
 480  */
 481 VOID WINAPI RtlZeroMemory( LPVOID ptr, UINT32 len )
 482 {
 483     memset( ptr, 0, len );
 484 }
 485
 486
 487 /***********************************************************************
 488  *           AnsiToOem16   (KEYBOARD.5)
 489  */
 490 INT16 WINAPI AnsiToOem16( LPCSTR s, LPSTR d )
 491 {
 492     CharToOem32A( s, d );
 493     return -1;
 494 }
 495
 496
 497 /***********************************************************************
 498  *           OemToAnsi16   (KEYBOARD.6)
 499  */
 500 INT16 WINAPI OemToAnsi16( LPCSTR s, LPSTR d )
 501 {
 502     OemToChar32A( s, d );
 503     return -1;
 504 }
 505
 506
 507 /***********************************************************************
 508  *           AnsiToOemBuff16   (KEYBOARD.134)
 509  */
 510 void WINAPI AnsiToOemBuff16( LPCSTR s, LPSTR d, UINT16 len )
 511 {
 512     CharToOemBuff32A( s, d, len ? len : 65536 );
 513 }
 514
 515
 516 /***********************************************************************
 517  *           OemToAnsiBuff16   (KEYBOARD.135)
 518  */
 519 void WINAPI OemToAnsiBuff16( LPCSTR s, LPSTR d, UINT16 len )
 520 {
 521     OemToCharBuff32A( s, d, len ? len : 65536 );
 522 }
 523
 524
 525 /***********************************************************************
 526  *           CharToOem32A   (USER32.37)
 527  */
 528 BOOL32 WINAPI CharToOem32A( LPCSTR s, LPSTR d )
 529 {
 530     LPSTR oldd = d;
 531     if (!s || !d) return TRUE;
 532     TRACE(string,"CharToOem %s\n", debugstr_a (s));
 533     while ((*d++ = ANSI_TO_OEM(*s++)));
 534     TRACE(string,"       to %s\n", debugstr_a (oldd));
 535     return TRUE;
 536 }
 537
 538
 539 /***********************************************************************
 540  *           CharToOemBuff32A   (USER32.38)
 541  */
 542 BOOL32 WINAPI CharToOemBuff32A( LPCSTR s, LPSTR d, DWORD len )
 543 {
 544     while (len--) *d++ = ANSI_TO_OEM(*s++);
 545     return TRUE;
 546 }
 547
 548
 549 /***********************************************************************
 550  *           CharToOemBuff32W   (USER32.39)
 551  */
 552 BOOL32 WINAPI CharToOemBuff32W( LPCWSTR s, LPSTR d, DWORD len )
 553 {
 554     while (len--) *d++ = ANSI_TO_OEM(*s++);
 555     return TRUE;
 556 }
 557
 558
 559 /***********************************************************************
 560  *           CharToOem32W   (USER32.40)
 561  */
 562 BOOL32 WINAPI CharToOem32W( LPCWSTR s, LPSTR d )
 563 {
 564     LPSTR oldd = d;
 565     if (!s || !d) return TRUE;
 566     TRACE(string,"CharToOem L%s\n", debugstr_w (s));
 567     while ((*d++ = ANSI_TO_OEM(*s++)));
 568     TRACE(string,"       to %s\n", debugstr_a (oldd));
 569     return TRUE;
 570 }
 571
 572
 573 /***********************************************************************
 574  *           OemToChar32A   (USER32.402)
 575  */
 576 BOOL32 WINAPI OemToChar32A( LPCSTR s, LPSTR d )
 577 {
 578     LPSTR oldd = d;
 579     TRACE(string,"OemToChar %s\n", debugstr_a (s));
 580     while ((*d++ = OEM_TO_ANSI(*s++)));
 581     TRACE(string,"       to %s\n", debugstr_a (oldd));
 582     return TRUE;
 583 }
 584
 585
 586 /***********************************************************************
 587  *           OemToCharBuff32A   (USER32.403)
 588  */
 589 BOOL32 WINAPI OemToCharBuff32A( LPCSTR s, LPSTR d, DWORD len )
 590 {
 591     TRACE(string,"OemToCharBuff %s\n", debugstr_an (s, len));
 592     while (len--) *d++ = OEM_TO_ANSI(*s++);
 593     return TRUE;
 594 }
 595
 596
 597 /***********************************************************************
 598  *           OemToCharBuff32W   (USER32.404)
 599  */
 600 BOOL32 WINAPI OemToCharBuff32W( LPCSTR s, LPWSTR d, DWORD len )
 601 {
 602     TRACE(string,"OemToCharBuff %s\n", debugstr_an (s, len));
 603     while (len--) *d++ = (WCHAR)OEM_TO_ANSI(*s++);
 604     return TRUE;
 605 }
 606
 607
 608 /***********************************************************************
 609  *           OemToChar32W   (USER32.405)
 610  */
 611 BOOL32 WINAPI OemToChar32W( LPCSTR s, LPWSTR d )
 612 {
 613     while ((*d++ = (WCHAR)OEM_TO_ANSI(*s++)));
 614     return TRUE;
 615 }
 616
 617 /***********************************************************************
 618  *  WideCharToLocal (Not a Windows API)
 619  *  similar lstrcpyWtoA, should handle codepages properly
 620  *
 621  *  RETURNS
 622  *    strlen of the destination string
 623  */
 624
 625 INT32 WINAPI WideCharToLocal32(
 626     LPSTR pLocal,
 627                 LPWSTR pWide,
 628                 INT32 dwChars)
 629 { *pLocal = 0;
 630   TRACE(string,"(%p, %s, %li)\n",       pLocal, debugstr_w(pWide),dwChars);
 631   WideCharToMultiByte(CP_ACP,0,pWide,-1,pLocal,dwChars,NULL,NULL);
 632   return strlen(pLocal);
 633 }
 634 /***********************************************************************
 635  *  LocalToWideChar (Not a Windows API)
 636  *  similar lstrcpyAtoW, should handle codepages properly
 637  *
 638  *  RETURNS
 639  *    strlen of the destination string
 640  */
 641 INT32 WINAPI LocalToWideChar32(
 642     LPWSTR pWide,
 643                 LPSTR pLocal,
 644                 INT32 dwChars)
 645 { *pWide = 0;
 646   TRACE(string,"(%p, %s, %li)\n",pWide, pLocal, dwChars);
 647         MultiByteToWideChar(CP_ACP,0,pLocal,-1,pWide,dwChars);
 648   return lstrlen32W(pWide);
 649 }