dlls/msvcrt/mbcs.c

   1 /*
   2  * msvcrt.dll mbcs functions
   3  *
   4  * Copyright 1999 Alexandre Julliard
   5  * Copyright 2000 Jon Griffths
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * FIXME
  22  * Not currently binary compatible with win32. MSVCRT_mbctype must be
  23  * populated correctly and the ismb* functions should reference it.
  24  */
  25
  26 #include <stdio.h>
  27
  28 #include "msvcrt.h"
  29 #include "wine/unicode.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  33
  34 unsigned char MSVCRT_mbctype[257] = { 0 };
  35
  36 /* It seems that the data about valid trail bytes is not available from kernel32
  37  * so we have to store is here. The format is the same as for lead bytes in CPINFO */
  38 struct cp_extra_info_t
  39 {
  40     int cp;
  41     BYTE TrailBytes[MAX_LEADBYTES];
  42 };
  43
  44 static struct cp_extra_info_t g_cpextrainfo[] =
  45 {
  46     {932, {0x40, 0x7e, 0x80, 0xfc, 0, 0}},
  47     {936, {0x40, 0xfe, 0, 0}},
  48     {949, {0x41, 0xfe, 0, 0}},
  49     {950, {0x40, 0x7e, 0xa1, 0xfe, 0, 0}},
  50     {1361, {0x31, 0x7e, 0x81, 0xfe, 0, 0}},
  51     {20932, {1, 255, 0, 0}},  /* seems to give different results on different systems */
  52     {0, {1, 255, 0, 0}}       /* match all with FIXME */
  53 };
  54
  55 /* Maps cp932 single byte character to multi byte character */
  56 static const unsigned char mbbtombc_932[] = {
  57   0x40,0x49,0x68,0x94,0x90,0x93,0x95,0x66,0x69,0x6a,0x96,0x7b,0x43,0x7c,0x44,0x5e,
  58   0x4f,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x46,0x47,0x83,0x81,0x84,0x48,
  59   0x97,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,
  60   0x6f,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x6d,0x8f,0x6e,0x4f,0x76,
  61   0x77,0x78,0x79,0x6d,0x8f,0x6e,0x4f,0x51,0x65,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
  62   0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,0x95,0x50,
  63        0x42,0x75,0x76,0x41,0x45,0x92,0x40,0x42,0x44,0x46,0x48,0x83,0x85,0x87,0x62,
  64   0x5b,0x41,0x43,0x45,0x47,0x49,0x4a,0x4c,0x4e,0x50,0x52,0x54,0x56,0x58,0x5a,0x5c,
  65   0x5e,0x60,0x63,0x65,0x67,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x71,0x74,0x77,0x7a,0x7d,
  66   0x7e,0x80,0x81,0x82,0x84,0x86,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8f,0x93,0x4a,0x4b };
  67
  68 /* Maps multibyte cp932 punctuation marks to single byte equivalents */
  69 static const unsigned char mbctombb_932_punct[] = {
  70   0x20,0xa4,0xa1,0x2c,0x2e,0xa5,0x3a,0x3b,0x3f,0x21,0xde,0xdf,0x00,0x00,0x00,0x5e,
  71   0x7e,0x5f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x00,0x00,0x2f,0x00,
  72   0x00,0x00,0x7c,0x00,0x00,0x60,0x27,0x00,0x22,0x28,0x29,0x00,0x00,0x5b,0x5d,0x7b,
  73   0x7d,0x00,0x00,0x00,0x00,0xa2,0xa3,0x00,0x00,0x00,0x00,0x2b,0x2d,0x00,0x00,0x00,
  74   0x00,0x3d,0x00,0x3c,0x3e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5c,
  75   0x24,0x00,0x00,0x25,0x23,0x26,0x2a,0x40};
  76
  77 /* Maps multibyte cp932 hiragana/katakana to single-byte equivalents */
  78 static const unsigned char mbctombb_932_kana[] = {
  79   0xa7,0xb1,0xa8,0xb2,0xa9,0xb3,0xaa,0xb4,0xab,0xb5,0xb6,0xb6,0xb7,0xb7,0xb8,0xb8,
  80   0xb9,0xb9,0xba,0xba,0xbb,0xbb,0xbc,0xbc,0xbd,0xbd,0xbe,0xbe,0xbf,0xbf,0xc0,0xc0,
  81   0xc1,0xc1,0xaf,0xc2,0xc2,0xc3,0xc3,0xc4,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xca,
  82   0xca,0xcb,0xcb,0xcb,0xcc,0xcc,0xcc,0xcd,0xcd,0xcd,0xce,0xce,0xce,0xcf,0xd0,0xd1,
  83   0xd2,0xd3,0xac,0xd4,0xad,0xd5,0xae,0xd6,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdc,0xb2,
  84   0xb4,0xa6,0xdd,0xb3,0xb6,0xb9};
  85
  86 static MSVCRT_wchar_t msvcrt_mbc_to_wc(unsigned int ch)
  87 {
  88   MSVCRT_wchar_t chW;
  89   char mbch[2];
  90   int n_chars;
  91
  92   if (ch <= 0xff) {
  93     mbch[0] = ch;
  94     n_chars = 1;
  95   } else {
  96     mbch[0] = (ch >> 8) & 0xff;
  97     mbch[1] = ch & 0xff;
  98     n_chars = 2;
  99   }
 100   if (!MultiByteToWideChar(get_mbcinfo()->mbcodepage, 0, mbch, n_chars, &chW, 1))
 101   {
 102     WARN("MultiByteToWideChar failed on %x\n", ch);
 103     return 0;
 104   }
 105   return chW;
 106 }
 107
 108 static inline MSVCRT_size_t u_strlen( const unsigned char *str )
 109 {
 110   return strlen( (const char*) str );
 111 }
 112
 113 static inline unsigned char* u_strncat( unsigned char* dst, const unsigned char* src, MSVCRT_size_t len )
 114 {
 115   return (unsigned char*)strncat( (char*)dst, (const char*)src, len);
 116 }
 117
 118 static inline int u_strcmp( const unsigned char *s1, const unsigned char *s2 )
 119 {
 120   return strcmp( (const char*)s1, (const char*)s2 );
 121 }
 122
 123 static inline int u_strcasecmp( const unsigned char *s1, const unsigned char *s2 )
 124 {
 125   return strcasecmp( (const char*)s1, (const char*)s2 );
 126 }
 127
 128 static inline int u_strncmp( const unsigned char *s1, const unsigned char *s2, MSVCRT_size_t len )
 129 {
 130   return strncmp( (const char*)s1, (const char*)s2, len );
 131 }
 132
 133 static inline int u_strncasecmp( const unsigned char *s1, const unsigned char *s2, MSVCRT_size_t len )
 134 {
 135   return strncasecmp( (const char*)s1, (const char*)s2, len );
 136 }
 137
 138 static inline unsigned char *u_strchr( const unsigned char *s, unsigned char x )
 139 {
 140   return (unsigned char*) strchr( (const char*)s, x );
 141 }
 142
 143 static inline unsigned char *u_strrchr( const unsigned char *s, unsigned char x )
 144 {
 145   return (unsigned char*) strrchr( (const char*)s, x );
 146 }
 147
 148 static inline unsigned char *u__strset( unsigned char *s, unsigned char c )
 149 {
 150   return (unsigned char*) _strset( (char*)s, c);
 151 }
 152
 153 static inline unsigned char *u__strnset( unsigned char *s, unsigned char c, MSVCRT_size_t len )
 154 {
 155   return (unsigned char*) MSVCRT__strnset( (char*)s, c, len );
 156 }
 157
 158 static inline MSVCRT_size_t u_strcspn( const unsigned char *s, const unsigned char *rej )
 159 {
 160   return strcspn( (const char *)s, (const char*)rej );
 161 }
 162
 163 /*********************************************************************
 164  *              __p__mbctype (MSVCRT.@)
 165  */
 166 unsigned char* CDECL __p__mbctype(void)
 167 {
 168   return get_mbcinfo()->mbctype;
 169 }
 170
 171 /*********************************************************************
 172  *              __p___mb_cur_max(MSVCRT.@)
 173  */
 174 int* CDECL __p___mb_cur_max(void)
 175 {
 176   return &get_locinfo()->mb_cur_max;
 177 }
 178
 179 /*********************************************************************
 180  *              ___mb_cur_max_func(MSVCRT.@)
 181  */
 182 int CDECL MSVCRT____mb_cur_max_func(void)
 183 {
 184   return get_locinfo()->mb_cur_max;
 185 }
 186
 187 /*********************************************************************
 188  *              ___mb_cur_max_l_func  (MSVCR80.@)
 189  */
 190 int* CDECL ___mb_cur_max_l_func(MSVCRT__locale_t locale)
 191 {
 192   MSVCRT_pthreadlocinfo locinfo;
 193
 194   if(!locale)
 195     locinfo = get_locinfo();
 196   else
 197     locinfo = locale->locinfo;
 198
 199   return &locinfo->mb_cur_max;
 200 }
 201
 202 /*********************************************************************
 203  * INTERNAL: _setmbcp_l
 204  */
 205 int _setmbcp_l(int cp, LCID lcid, MSVCRT_pthreadmbcinfo mbcinfo)
 206 {
 207   const char format[] = ".%d";
 208
 209   int newcp;
 210   CPINFO cpi;
 211   BYTE *bytes;
 212   WORD chartypes[256];
 213   char bufA[256];
 214   WCHAR bufW[256];
 215   int charcount;
 216   int ret;
 217   int i;
 218
 219   if(!mbcinfo)
 220       mbcinfo = get_mbcinfo();
 221
 222   switch (cp)
 223   {
 224     case _MB_CP_ANSI:
 225       newcp = GetACP();
 226       break;
 227     case _MB_CP_OEM:
 228       newcp = GetOEMCP();
 229       break;
 230     case _MB_CP_LOCALE:
 231       newcp = get_locinfo()->lc_codepage;
 232       if(newcp)
 233           break;
 234       /* fall through (C locale) */
 235     case _MB_CP_SBCS:
 236       newcp = 20127;   /* ASCII */
 237       break;
 238     default:
 239       newcp = cp;
 240       break;
 241   }
 242
 243   if(lcid == -1) {
 244     sprintf(bufA, format, newcp);
 245     mbcinfo->mblcid = MSVCRT_locale_to_LCID(bufA, NULL);
 246   } else {
 247     mbcinfo->mblcid = lcid;
 248   }
 249
 250   if(mbcinfo->mblcid == -1)
 251   {
 252     WARN("Can't assign LCID to codepage (%d)\n", mbcinfo->mblcid);
 253     mbcinfo->mblcid = 0;
 254   }
 255
 256   if (!GetCPInfo(newcp, &cpi))
 257   {
 258     WARN("Codepage %d not found\n", newcp);
 259     *MSVCRT__errno() = MSVCRT_EINVAL;
 260     return -1;
 261   }
 262
 263   /* setup the _mbctype */
 264   memset(mbcinfo->mbctype, 0, sizeof(unsigned char[257]));
 265   memset(mbcinfo->mbcasemap, 0, sizeof(unsigned char[256]));
 266
 267   bytes = cpi.LeadByte;
 268   while (bytes[0] || bytes[1])
 269   {
 270     for (i = bytes[0]; i <= bytes[1]; i++)
 271       mbcinfo->mbctype[i + 1] |= _M1;
 272     bytes += 2;
 273   }
 274
 275   if (cpi.MaxCharSize > 1)
 276   {
 277     /* trail bytes not available through kernel32 but stored in a structure in msvcrt */
 278     struct cp_extra_info_t *cpextra = g_cpextrainfo;
 279
 280     mbcinfo->ismbcodepage = 1;
 281     while (TRUE)
 282     {
 283       if (cpextra->cp == 0 || cpextra->cp == newcp)
 284       {
 285         if (cpextra->cp == 0)
 286           FIXME("trail bytes data not available for DBCS codepage %d - assuming all bytes\n", newcp);
 287
 288         bytes = cpextra->TrailBytes;
 289         while (bytes[0] || bytes[1])
 290         {
 291           for (i = bytes[0]; i <= bytes[1]; i++)
 292             mbcinfo->mbctype[i + 1] |= _M2;
 293           bytes += 2;
 294         }
 295         break;
 296       }
 297       cpextra++;
 298     }
 299   }
 300   else
 301     mbcinfo->ismbcodepage = 0;
 302
 303   /* we can't use GetStringTypeA directly because we don't have a locale - only a code page
 304    */
 305   charcount = 0;
 306   for (i = 0; i < 256; i++)
 307     if (!(mbcinfo->mbctype[i + 1] & _M1))
 308       bufA[charcount++] = i;
 309
 310   ret = MultiByteToWideChar(newcp, 0, bufA, charcount, bufW, charcount);
 311   if (ret != charcount)
 312     ERR("MultiByteToWideChar of chars failed for cp %d, ret=%d (exp %d), error=%d\n", newcp, ret, charcount, GetLastError());
 313
 314   GetStringTypeW(CT_CTYPE1, bufW, charcount, chartypes);
 315
 316   charcount = 0;
 317   for (i = 0; i < 256; i++)
 318     if (!(mbcinfo->mbctype[i + 1] & _M1))
 319     {
 320       if (chartypes[charcount] & C1_UPPER)
 321       {
 322         mbcinfo->mbctype[i + 1] |= _SBUP;
 323         bufW[charcount] = tolowerW(bufW[charcount]);
 324       }
 325       else if (chartypes[charcount] & C1_LOWER)
 326       {
 327         mbcinfo->mbctype[i + 1] |= _SBLOW;
 328         bufW[charcount] = toupperW(bufW[charcount]);
 329       }
 330       charcount++;
 331     }
 332
 333   ret = WideCharToMultiByte(newcp, 0, bufW, charcount, bufA, charcount, NULL, NULL);
 334   if (ret != charcount)
 335     ERR("WideCharToMultiByte failed for cp %d, ret=%d (exp %d), error=%d\n", newcp, ret, charcount, GetLastError());
 336
 337   charcount = 0;
 338   for (i = 0; i < 256; i++)
 339   {
 340     if(!(mbcinfo->mbctype[i + 1] & _M1))
 341     {
 342       if(mbcinfo->mbctype[i] & (C1_UPPER|C1_LOWER))
 343         mbcinfo->mbcasemap[i] = bufA[charcount];
 344       charcount++;
 345     }
 346   }
 347
 348   if (newcp == 932)   /* CP932 only - set _MP and _MS */
 349   {
 350     /* On Windows it's possible to calculate the _MP and _MS from CT_CTYPE1
 351      * and CT_CTYPE3. But as of Wine 0.9.43 we return wrong values what makes
 352      * it hard. As this is set only for codepage 932 we hardcode it what gives
 353      * also faster execution.
 354      */
 355     for (i = 161; i <= 165; i++)
 356       mbcinfo->mbctype[i + 1] |= _MP;
 357     for (i = 166; i <= 223; i++)
 358       mbcinfo->mbctype[i + 1] |= _MS;
 359   }
 360
 361   mbcinfo->mbcodepage = newcp;
 362   if(MSVCRT_locale && mbcinfo == MSVCRT_locale->mbcinfo)
 363     memcpy(MSVCRT_mbctype, MSVCRT_locale->mbcinfo->mbctype, sizeof(MSVCRT_mbctype));
 364
 365   return 0;
 366 }
 367
 368 /*********************************************************************
 369  *              _setmbcp (MSVCRT.@)
 370  */
 371 int CDECL _setmbcp(int cp)
 372 {
 373     return _setmbcp_l(cp, -1, NULL);
 374 }
 375
 376 /*********************************************************************
 377  *              _getmbcp (MSVCRT.@)
 378  */
 379 int CDECL _getmbcp(void)
 380 {
 381   return get_mbcinfo()->mbcodepage;
 382 }
 383
 384 /*********************************************************************
 385  *              _mbsnextc(MSVCRT.@)
 386  */
 387 unsigned int CDECL _mbsnextc(const unsigned char* str)
 388 {
 389   if(_ismbblead(*str))
 390     return *str << 8 | str[1];
 391   return *str;
 392 }
 393
 394 /*********************************************************************
 395  *              _mbctolower(MSVCRT.@)
 396  */
 397 unsigned int CDECL _mbctolower(unsigned int c)
 398 {
 399     if (_ismbblead(c))
 400     {
 401       FIXME("Handle MBC chars\n");
 402       return c;
 403     }
 404     return tolower(c); /* ASCII CP or SB char */
 405 }
 406
 407 /*********************************************************************
 408  *              _mbctoupper(MSVCRT.@)
 409  */
 410 unsigned int CDECL _mbctoupper(unsigned int c)
 411 {
 412     if (_ismbblead(c))
 413     {
 414       FIXME("Handle MBC chars\n");
 415       return c;
 416     }
 417     return toupper(c); /* ASCII CP or SB char */
 418 }
 419
 420 /*********************************************************************
 421  *              _mbctombb (MSVCRT.@)
 422  */
 423 unsigned int CDECL _mbctombb(unsigned int c)
 424 {
 425     unsigned int value;
 426
 427     if(get_mbcinfo()->mbcodepage == 932)
 428     {
 429         if(c >= 0x829f && c <= 0x82f1)    /* Hiragana */
 430             return mbctombb_932_kana[c - 0x829f];
 431         if(c >= 0x8340 && c <= 0x8396 && c != 0x837f)    /* Katakana */
 432             return mbctombb_932_kana[c - 0x8340 - (c >= 0x837f ? 1 : 0)];
 433         if(c >= 0x8140 && c <= 0x8197)    /* Punctuation */
 434         {
 435             value = mbctombb_932_punct[c - 0x8140];
 436             return value ? value : c;
 437         }
 438         if((c >= 0x824f && c <= 0x8258) || /* Fullwidth digits */
 439            (c >= 0x8260 && c <= 0x8279))   /* Fullwidth capitals letters */
 440             return c - 0x821f;
 441         if(c >= 0x8281 && c <= 0x829a)     /* Fullwidth small letters */
 442             return c - 0x8220;
 443         /* all other cases return c */
 444     }
 445     return c;
 446 }
 447
 448 /*********************************************************************
 449  *              _mbcjistojms(MSVCRT.@)
 450  *
 451  *              Converts a jis character to sjis.
 452  *              Based on description from
 453  *              http://www.slayers.ne.jp/~oouchi/code/jistosjis.html
 454  */
 455 unsigned int CDECL _mbcjistojms(unsigned int c)
 456 {
 457   /* Conversion takes place only when codepage is 932.
 458      In all other cases, c is returned unchanged */
 459   if(get_mbcinfo()->mbcodepage == 932)
 460   {
 461     if(HIBYTE(c) >= 0x21 && HIBYTE(c) <= 0x7e &&
 462        LOBYTE(c) >= 0x21 && LOBYTE(c) <= 0x7e)
 463     {
 464       if(HIBYTE(c) % 2)
 465         c += 0x1f;
 466       else
 467         c += 0x7d;
 468
 469       if(LOBYTE(c) >= 0x7F)
 470         c += 0x1;
 471
 472       c = (((HIBYTE(c) - 0x21)/2 + 0x81) << 8) | LOBYTE(c);
 473
 474       if(HIBYTE(c) > 0x9f)
 475         c += 0x4000;
 476     }
 477     else
 478       return 0; /* Codepage is 932, but c can't be converted */
 479   }
 480
 481   return c;
 482 }
 483
 484 /*********************************************************************
 485  *              _mbcjmstojis(MSVCRT.@)
 486  *
 487  *              Converts a sjis character to jis.
 488  */
 489 unsigned int CDECL _mbcjmstojis(unsigned int c)
 490 {
 491   /* Conversion takes place only when codepage is 932.
 492      In all other cases, c is returned unchanged */
 493   if(get_mbcinfo()->mbcodepage == 932)
 494   {
 495     if(_ismbclegal(c) && HIBYTE(c) < 0xf0)
 496     {
 497       if(HIBYTE(c) >= 0xe0)
 498         c -= 0x4000;
 499
 500       c = (((HIBYTE(c) - 0x81)*2 + 0x21) << 8) | LOBYTE(c);
 501
 502       if(LOBYTE(c) > 0x7f)
 503         c -= 0x1;
 504
 505       if(LOBYTE(c) > 0x9d)
 506         c += 0x83;
 507       else
 508         c -= 0x1f;
 509     }
 510     else
 511       return 0; /* Codepage is 932, but c can't be converted */
 512   }
 513
 514   return c;
 515 }
 516
 517 /*********************************************************************
 518  *              _mbsdec(MSVCRT.@)
 519  */
 520 unsigned char* CDECL _mbsdec(const unsigned char* start, const unsigned char* cur)
 521 {
 522   if(get_mbcinfo()->ismbcodepage)
 523     return (unsigned char *)(_ismbstrail(start,cur-1) ? cur - 2 : cur -1);
 524
 525   return (unsigned char *)cur - 1; /* ASCII CP or SB char */
 526 }
 527
 528 /*********************************************************************
 529  *              _mbclen(MSVCRT.@)
 530  */
 531 unsigned int CDECL _mbclen(const unsigned char* str)
 532 {
 533   return _ismbblead(*str) ? 2 : 1;
 534 }
 535
 536 /*********************************************************************
 537  *              _mbsinc(MSVCRT.@)
 538  */
 539 unsigned char* CDECL _mbsinc(const unsigned char* str)
 540 {
 541   return (unsigned char *)(str + _mbclen(str));
 542 }
 543
 544 /*********************************************************************
 545  *              _mbsninc(MSVCRT.@)
 546  */
 547 unsigned char* CDECL _mbsninc(const unsigned char* str, MSVCRT_size_t num)
 548 {
 549   if(!str)
 550     return NULL;
 551
 552   while (num > 0 && *str)
 553   {
 554     if (_ismbblead(*str))
 555     {
 556       if (!*(str+1))
 557          break;
 558       str++;
 559     }
 560     str++;
 561     num--;
 562   }
 563
 564   return (unsigned char*)str;
 565 }
 566
 567 /*********************************************************************
 568  *              _mbslen(MSVCRT.@)
 569  */
 570 MSVCRT_size_t CDECL _mbslen(const unsigned char* str)
 571 {
 572   MSVCRT_size_t len = 0;
 573   while(*str)
 574   {
 575     if (_ismbblead(*str))
 576     {
 577       str++;
 578       if (!*str)  /* count only full chars */
 579         break;
 580     }
 581     str++;
 582     len++;
 583   }
 584   return len;
 585 }
 586
 587 /*********************************************************************
 588  *              _mbccpy(MSVCRT.@)
 589  */
 590 void CDECL _mbccpy(unsigned char* dest, const unsigned char* src)
 591 {
 592   *dest = *src;
 593   if(_ismbblead(*src))
 594     *++dest = *++src; /* MB char */
 595 }
 596
 597 /*********************************************************************
 598  *              _mbsncpy(MSVCRT.@)
 599  * REMARKS
 600  *  The parameter n is the number or characters to copy, not the size of
 601  *  the buffer. Use _mbsnbcpy for a function analogical to strncpy
 602  */
 603 unsigned char* CDECL _mbsncpy(unsigned char* dst, const unsigned char* src, MSVCRT_size_t n)
 604 {
 605   unsigned char* ret = dst;
 606   if(!n)
 607     return dst;
 608   if (get_mbcinfo()->ismbcodepage)
 609   {
 610     while (*src && n)
 611     {
 612       n--;
 613       if (_ismbblead(*src))
 614       {
 615         if (!*(src+1))
 616         {
 617             *dst++ = 0;
 618             *dst++ = 0;
 619             break;
 620         }
 621
 622         *dst++ = *src++;
 623       }
 624
 625       *dst++ = *src++;
 626     }
 627   }
 628   else
 629   {
 630     while (n)
 631     {
 632         n--;
 633         if (!(*dst++ = *src++)) break;
 634     }
 635   }
 636   while (n--) *dst++ = 0;
 637   return ret;
 638 }
 639
 640 /*********************************************************************
 641  *              _mbsnbcpy_s_l(MSVCRT.@)
 642  * REMARKS
 643  * Unlike _mbsnbcpy this function does not pad the rest of the dest
 644  * string with 0
 645  */
 646 int CDECL _mbsnbcpy_s_l(unsigned char* dst, MSVCRT_size_t size,
 647         const unsigned char* src, MSVCRT_size_t n, MSVCRT__locale_t locale)
 648 {
 649     MSVCRT_size_t pos = 0;
 650
 651     if(!dst || size == 0)
 652         return MSVCRT_EINVAL;
 653     if(!src)
 654     {
 655         dst[0] = '\0';
 656         return MSVCRT_EINVAL;
 657     }
 658     if(!n)
 659         return 0;
 660
 661     if((locale ? locale->mbcinfo : get_mbcinfo())->ismbcodepage)
 662     {
 663         int is_lead = 0;
 664         while (*src && n)
 665         {
 666             if(pos == size)
 667             {
 668                 dst[0] = '\0';
 669                 return MSVCRT_ERANGE;
 670             }
 671             is_lead = (!is_lead && _ismbblead(*src));
 672             n--;
 673             dst[pos++] = *src++;
 674         }
 675
 676         if (is_lead) /* if string ends with a lead, remove it */
 677             dst[pos - 1] = 0;
 678     }
 679     else
 680     {
 681         while (n)
 682         {
 683             n--;
 684             if(pos == size)
 685             {
 686                 dst[0] = '\0';
 687                 return MSVCRT_ERANGE;
 688             }
 689
 690             if(!(*src)) break;
 691             dst[pos++] = *src++;
 692         }
 693     }
 694
 695     if(pos < size)
 696         dst[pos] = '\0';
 697     else
 698     {
 699         dst[0] = '\0';
 700         return MSVCRT_ERANGE;
 701     }
 702
 703     return 0;
 704 }
 705
 706 /*********************************************************************
 707  *              _mbsnbcpy_s(MSVCRT.@)
 708  */
 709 int CDECL _mbsnbcpy_s(unsigned char* dst, MSVCRT_size_t size, const unsigned char* src, MSVCRT_size_t n)
 710 {
 711     return _mbsnbcpy_s_l(dst, size, src, n, NULL);
 712 }
 713
 714 /*********************************************************************
 715  *              _mbscpy_s_l(MSVCRT.@)
 716  */
 717 int CDECL _mbscpy_s_l(unsigned char *dst, MSVCRT_size_t size,
 718         const unsigned char *src, MSVCRT__locale_t locale)
 719 {
 720     return _mbsnbcpy_s_l(dst, size, src, -1, locale);
 721 }
 722
 723 /*********************************************************************
 724  *              _mbscpy_s(MSVCRT.@)
 725  */
 726 int CDECL _mbscpy_s(unsigned char *dst, MSVCRT_size_t size, const unsigned char *src)
 727 {
 728     return _mbscpy_s_l(dst, size, src, NULL);
 729 }
 730
 731 /*********************************************************************
 732  *              _mbsnbcpy(MSVCRT.@)
 733  * REMARKS
 734  *  Like strncpy this function doesn't enforce the string to be
 735  *  NUL-terminated
 736  */
 737 unsigned char* CDECL _mbsnbcpy(unsigned char* dst, const unsigned char* src, MSVCRT_size_t n)
 738 {
 739   unsigned char* ret = dst;
 740   if(!n)
 741     return dst;
 742   if(get_mbcinfo()->ismbcodepage)
 743   {
 744     int is_lead = 0;
 745     while (*src && n)
 746     {
 747       is_lead = (!is_lead && _ismbblead(*src));
 748       n--;
 749       *dst++ = *src++;
 750     }
 751
 752     if (is_lead) /* if string ends with a lead, remove it */
 753         *(dst - 1) = 0;
 754   }
 755   else
 756   {
 757     while (n)
 758     {
 759         n--;
 760         if (!(*dst++ = *src++)) break;
 761     }
 762   }
 763   while (n--) *dst++ = 0;
 764   return ret;
 765 }
 766
 767 /*********************************************************************
 768  *              _mbscmp(MSVCRT.@)
 769  */
 770 int CDECL _mbscmp(const unsigned char* str, const unsigned char* cmp)
 771 {
 772   if(get_mbcinfo()->ismbcodepage)
 773   {
 774     unsigned int strc, cmpc;
 775     do {
 776       if(!*str)
 777         return *cmp ? -1 : 0;
 778       if(!*cmp)
 779         return 1;
 780       strc = _mbsnextc(str);
 781       cmpc = _mbsnextc(cmp);
 782       if(strc != cmpc)
 783         return strc < cmpc ? -1 : 1;
 784       str +=(strc > 255) ? 2 : 1;
 785       cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
 786     } while(1);
 787   }
 788   return u_strcmp(str, cmp); /* ASCII CP */
 789 }
 790
 791 /*********************************************************************
 792  *              _mbsnbicoll_l(MSVCRT.@)
 793  */
 794 int CDECL _mbsnbicoll_l(const unsigned char *str1, const unsigned char *str2, MSVCRT_size_t len, MSVCRT__locale_t locale)
 795 {
 796     MSVCRT_pthreadmbcinfo mbcinfo;
 797
 798     if(!locale)
 799         mbcinfo = get_mbcinfo();
 800     else
 801         mbcinfo = locale->mbcinfo;
 802
 803     if(!mbcinfo->ismbcodepage)
 804         return MSVCRT__strnicoll_l((const char*)str1, (const char*)str2, len, locale);
 805     return CompareStringA(mbcinfo->mblcid, NORM_IGNORECASE, (const char*)str1, len, (const char*)str2, len)-CSTR_EQUAL;
 806 }
 807
 808 /*********************************************************************
 809  *              _mbsicoll_l(MSVCRT.@)
 810  */
 811 int CDECL _mbsicoll_l(const unsigned char *str1, const unsigned char *str2, MSVCRT__locale_t locale)
 812 {
 813     return _mbsnbicoll_l(str1, str2, -1, locale);
 814 }
 815
 816 /*********************************************************************
 817  *              _mbsnbicoll(MSVCRT.@)
 818  */
 819 int CDECL _mbsnbicoll(const unsigned char *str1, const unsigned char *str2, MSVCRT_size_t len)
 820 {
 821     return _mbsnbicoll_l(str1, str2, len, NULL);
 822 }
 823
 824 /*********************************************************************
 825  *              _mbsicoll(MSVCRT.@)
 826  */
 827 int CDECL _mbsicoll(const unsigned char* str, const unsigned char* cmp)
 828 {
 829     return _mbsnbicoll_l(str, cmp, -1, NULL);
 830 }
 831
 832 /*********************************************************************
 833  *              _mbsnbcoll_l(MSVCRT.@)
 834  */
 835 int CDECL _mbsnbcoll_l(const unsigned char *str1, const unsigned char *str2, MSVCRT_size_t len, MSVCRT__locale_t locale)
 836 {
 837     MSVCRT_pthreadmbcinfo mbcinfo;
 838
 839     if(!locale)
 840         mbcinfo = get_mbcinfo();
 841     else
 842         mbcinfo = locale->mbcinfo;
 843
 844     if(!mbcinfo->ismbcodepage)
 845         return MSVCRT__strncoll_l((const char*)str1, (const char*)str2, len, locale);
 846     return CompareStringA(mbcinfo->mblcid, 0, (const char*)str1, len, (const char*)str2, len)-CSTR_EQUAL;
 847 }
 848
 849 /*********************************************************************
 850  *              _mbscoll_l(MSVCRT.@)
 851  */
 852 int CDECL _mbscoll_l(const unsigned char *str1, const unsigned char *str2, MSVCRT__locale_t locale)
 853 {
 854     return _mbsnbcoll_l(str1, str2, -1, locale);
 855 }
 856
 857 /*********************************************************************
 858  *              _mbsnbcoll(MSVCRT.@)
 859  */
 860 int CDECL _mbsnbcoll(const unsigned char *str1, const unsigned char *str2, MSVCRT_size_t len)
 861 {
 862     return _mbsnbcoll_l(str1, str2, len, NULL);
 863 }
 864
 865 /*********************************************************************
 866  *              _mbscoll(MSVCRT.@)
 867  */
 868 int CDECL _mbscoll(const unsigned char* str, const unsigned char* cmp)
 869 {
 870     return _mbsnbcoll_l(str, cmp, -1, NULL);
 871 }
 872
 873 /*********************************************************************
 874  *              _mbsicmp(MSVCRT.@)
 875  */
 876 int CDECL _mbsicmp(const unsigned char* str, const unsigned char* cmp)
 877 {
 878   if(get_mbcinfo()->ismbcodepage)
 879   {
 880     unsigned int strc, cmpc;
 881     do {
 882       if(!*str)
 883         return *cmp ? -1 : 0;
 884       if(!*cmp)
 885         return 1;
 886       strc = _mbctolower(_mbsnextc(str));
 887       cmpc = _mbctolower(_mbsnextc(cmp));
 888       if(strc != cmpc)
 889         return strc < cmpc ? -1 : 1;
 890       str +=(strc > 255) ? 2 : 1;
 891       cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
 892     } while(1);
 893   }
 894   return u_strcasecmp(str, cmp); /* ASCII CP */
 895 }
 896
 897 /*********************************************************************
 898  *              _mbsncmp(MSVCRT.@)
 899  */
 900 int CDECL _mbsncmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 901 {
 902   if(!len)
 903     return 0;
 904
 905   if(get_mbcinfo()->ismbcodepage)
 906   {
 907     unsigned int strc, cmpc;
 908     while(len--)
 909     {
 910       int inc;
 911       if(!*str)
 912         return *cmp ? -1 : 0;
 913       if(!*cmp)
 914         return 1;
 915       strc = _mbsnextc(str);
 916       cmpc = _mbsnextc(cmp);
 917       if(strc != cmpc)
 918         return strc < cmpc ? -1 : 1;
 919       inc=(strc > 255) ? 2 : 1; /* Equal, use same increment */
 920       str += inc;
 921       cmp += inc;
 922     }
 923     return 0; /* Matched len chars */
 924   }
 925   return u_strncmp(str, cmp, len); /* ASCII CP */
 926 }
 927
 928 /*********************************************************************
 929  *              _mbsnbcmp(MSVCRT.@)
 930  */
 931 int CDECL _mbsnbcmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 932 {
 933   if (!len)
 934     return 0;
 935   if(get_mbcinfo()->ismbcodepage)
 936   {
 937     unsigned int strc, cmpc;
 938     while (len)
 939     {
 940       int clen;
 941       if(!*str)
 942         return *cmp ? -1 : 0;
 943       if(!*cmp)
 944         return 1;
 945       if (_ismbblead(*str))
 946       {
 947         strc=(len>=2)?_mbsnextc(str):0;
 948         clen=2;
 949       }
 950       else
 951       {
 952         strc=*str;
 953         clen=1;
 954       }
 955       if (_ismbblead(*cmp))
 956         cmpc=(len>=2)?_mbsnextc(cmp):0;
 957       else
 958         cmpc=*cmp;
 959       if(strc != cmpc)
 960         return strc < cmpc ? -1 : 1;
 961       len -= clen;
 962       str += clen;
 963       cmp += clen;
 964     }
 965     return 0; /* Matched len chars */
 966   }
 967   return u_strncmp(str,cmp,len);
 968 }
 969
 970 /*********************************************************************
 971  *              _mbsnicmp(MSVCRT.@)
 972  *
 973  * Compare two multibyte strings case insensitively to 'len' characters.
 974  */
 975 int CDECL _mbsnicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 976 {
 977   /* FIXME: No tolower() for mb strings yet */
 978   if(get_mbcinfo()->ismbcodepage)
 979   {
 980     unsigned int strc, cmpc;
 981     while(len--)
 982     {
 983       if(!*str)
 984         return *cmp ? -1 : 0;
 985       if(!*cmp)
 986         return 1;
 987       strc = _mbctolower(_mbsnextc(str));
 988       cmpc = _mbctolower(_mbsnextc(cmp));
 989       if(strc != cmpc)
 990         return strc < cmpc ? -1 : 1;
 991       str +=(strc > 255) ? 2 : 1;
 992       cmp +=(strc > 255) ? 2 : 1; /* Equal, use same increment */
 993     }
 994     return 0; /* Matched len chars */
 995   }
 996   return u_strncasecmp(str, cmp, len); /* ASCII CP */
 997 }
 998
 999 /*********************************************************************
1000  *              _mbsnbicmp(MSVCRT.@)
1001  */
1002 int CDECL _mbsnbicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
1003 {
1004   if (!len)
1005     return 0;
1006   if(get_mbcinfo()->ismbcodepage)
1007   {
1008     unsigned int strc, cmpc;
1009     while (len)
1010     {
1011       int clen;
1012       if(!*str)
1013         return *cmp ? -1 : 0;
1014       if(!*cmp)
1015         return 1;
1016       if (_ismbblead(*str))
1017       {
1018         strc=(len>=2)?_mbsnextc(str):0;
1019         clen=2;
1020       }
1021       else
1022       {
1023         strc=*str;
1024         clen=1;
1025       }
1026       if (_ismbblead(*cmp))
1027         cmpc=(len>=2)?_mbsnextc(cmp):0;
1028       else
1029         cmpc=*cmp;
1030       strc = _mbctolower(strc);
1031       cmpc = _mbctolower(cmpc);
1032       if(strc != cmpc)
1033         return strc < cmpc ? -1 : 1;
1034       len -= clen;
1035       str += clen;
1036       cmp += clen;
1037     }
1038     return 0; /* Matched len bytes */
1039   }
1040   return u_strncasecmp(str,cmp,len);
1041 }
1042
1043 /*********************************************************************
1044  *              _mbscat (MSVCRT.@)
1045  */
1046 unsigned char * CDECL _mbscat( unsigned char *dst, const unsigned char *src )
1047 {
1048     strcat( (char *)dst, (const char *)src );
1049     return dst;
1050 }
1051
1052 /*********************************************************************
1053  *              _mbscpy (MSVCRT.@)
1054  */
1055 unsigned char* CDECL _mbscpy( unsigned char *dst, const unsigned char *src )
1056 {
1057     strcpy( (char *)dst, (const char *)src );
1058     return dst;
1059 }
1060
1061 /*********************************************************************
1062  *              _mbsstr (MSVCRT.@)
1063  */
1064 unsigned char * CDECL _mbsstr(const unsigned char *haystack, const unsigned char *needle)
1065 {
1066     return (unsigned char *)strstr( (const char *)haystack, (const char *)needle );
1067 }
1068
1069 /*********************************************************************
1070  *              _mbschr(MSVCRT.@)
1071  *
1072  * Find a multibyte character in a multibyte string.
1073  */
1074 unsigned char* CDECL _mbschr(const unsigned char* s, unsigned int x)
1075 {
1076   if(get_mbcinfo()->ismbcodepage)
1077   {
1078     unsigned int c;
1079     while (1)
1080     {
1081       c = _mbsnextc(s);
1082       if (c == x)
1083         return (unsigned char*)s;
1084       if (!c)
1085         return NULL;
1086       s += c > 255 ? 2 : 1;
1087     }
1088   }
1089   return u_strchr(s, x); /* ASCII CP */
1090 }
1091
1092 /*********************************************************************
1093  *              _mbsrchr(MSVCRT.@)
1094  */
1095 unsigned char* CDECL _mbsrchr(const unsigned char* s, unsigned int x)
1096 {
1097   if(get_mbcinfo()->ismbcodepage)
1098   {
1099     unsigned int c;
1100     unsigned char* match=NULL;
1101     if(!s)
1102       return NULL;
1103     while (1) {
1104       c = _mbsnextc(s);
1105       if (c == x)
1106         match=(unsigned char*)s;
1107       if (!c)
1108         return match;
1109       s +=(c > 255) ? 2 : 1;
1110     }
1111   }
1112   return u_strrchr(s, x);
1113 }
1114
1115 /*********************************************************************
1116  *              _mbstok_s_l(MSVCRT.@)
1117  */
1118 unsigned char* CDECL _mbstok_s_l(unsigned char *str, const unsigned char *delim,
1119         unsigned char **ctx, MSVCRT__locale_t locale)
1120 {
1121     MSVCRT_pthreadmbcinfo mbcinfo;
1122     unsigned int c;
1123
1124     if(!MSVCRT_CHECK_PMT(delim != NULL)) return NULL;
1125     if(!MSVCRT_CHECK_PMT(ctx != NULL)) return NULL;
1126     if(!MSVCRT_CHECK_PMT(str || *ctx)) return NULL;
1127
1128     if(locale)
1129         mbcinfo = locale->mbcinfo;
1130     else
1131         mbcinfo = get_mbcinfo();
1132
1133     if(!mbcinfo->ismbcodepage)
1134         return (unsigned char*)MSVCRT_strtok_s((char*)str, (const char*)delim, (char**)ctx);
1135
1136     if(!str)
1137         str = *ctx;
1138
1139     while((c=_mbsnextc(str)) && _mbschr(delim, c))
1140         str += c>255 ? 2 : 1;
1141     if(!*str)
1142         return NULL;
1143
1144     *ctx = str + (c>255 ? 2 : 1);
1145     while((c=_mbsnextc(*ctx)) && !_mbschr(delim, c))
1146         *ctx += c>255 ? 2 : 1;
1147     if (**ctx) {
1148         *(*ctx)++ = 0;
1149         if(c > 255)
1150             *(*ctx)++ = 0;
1151     }
1152
1153     return str;
1154 }
1155
1156
1157 /*********************************************************************
1158  *              _mbstok_s(MSVCRT.@)
1159  */
1160 unsigned char* CDECL _mbstok_s(unsigned char *str,
1161         const unsigned char *delim, unsigned char **ctx)
1162 {
1163     return _mbstok_s_l(str, delim, ctx, NULL);
1164 }
1165
1166 /*********************************************************************
1167  *              _mbstok_l(MSVCRT.@)
1168  */
1169 unsigned char* CDECL _mbstok_l(unsigned char *str,
1170         const unsigned char *delim, MSVCRT__locale_t locale)
1171 {
1172     return _mbstok_s_l(str, delim, &msvcrt_get_thread_data()->mbstok_next, locale);
1173 }
1174
1175 /*********************************************************************
1176  *              _mbstok(MSVCRT.@)
1177  */
1178 unsigned char* CDECL _mbstok(unsigned char *str, const unsigned char *delim)
1179 {
1180     thread_data_t *data = msvcrt_get_thread_data();
1181
1182 #if _MSVCR_VER == 0
1183     if(!str && !data->mbstok_next)
1184         return NULL;
1185 #endif
1186
1187     return _mbstok_s_l(str, delim, &data->mbstok_next, NULL);
1188 }
1189
1190 /*********************************************************************
1191  *              _mbbtombc(MSVCRT.@)
1192  */
1193 unsigned int CDECL _mbbtombc(unsigned int c)
1194 {
1195   if(get_mbcinfo()->mbcodepage == 932)
1196   {
1197     if(c >= 0x20 && c <= 0x7e) {
1198       if((c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) || (c >= 0x30 && c <= 0x39))
1199         return mbbtombc_932[c - 0x20] | 0x8200;
1200       else
1201         return mbbtombc_932[c - 0x20] | 0x8100;
1202     }
1203     else if(c >= 0xa1 && c <= 0xdf) {
1204       if(c >= 0xa6 && c <= 0xdd && c != 0xb0)
1205         return mbbtombc_932[c - 0xa1 + 0x5f] | 0x8300;
1206       else
1207         return mbbtombc_932[c - 0xa1 + 0x5f] | 0x8100;
1208     }
1209   }
1210   return c;  /* not Japanese or no MB char */
1211 }
1212
1213 /*********************************************************************
1214  *              _mbbtype(MSVCRT.@)
1215  */
1216 int CDECL _mbbtype(unsigned char c, int type)
1217 {
1218     if (type == 1)
1219     {
1220         if ((c >= 0x20 && c <= 0x7e) || (c >= 0xa1 && c <= 0xdf))
1221             return _MBC_SINGLE;
1222         else if ((c >= 0x40 && c <= 0x7e) || (c >= 0x80 && c <= 0xfc))
1223             return _MBC_TRAIL;
1224         else
1225             return _MBC_ILLEGAL;
1226     }
1227     else
1228     {
1229         if ((c >= 0x20 && c <= 0x7e) || (c >= 0xa1 && c <= 0xdf))
1230             return _MBC_SINGLE;
1231         else if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfc))
1232             return _MBC_LEAD;
1233         else
1234             return _MBC_ILLEGAL;
1235     }
1236 }
1237
1238 /*********************************************************************
1239  *              _ismbbkana(MSVCRT.@)
1240  */
1241 int CDECL _ismbbkana(unsigned int c)
1242 {
1243   /* FIXME: use lc_ctype when supported, not lc_all */
1244   if(get_mbcinfo()->mbcodepage == 932)
1245   {
1246     /* Japanese/Katakana, CP 932 */
1247     return (c >= 0xa1 && c <= 0xdf);
1248   }
1249   return 0;
1250 }
1251
1252 /*********************************************************************
1253  *              _ismbcdigit(MSVCRT.@)
1254  */
1255 int CDECL _ismbcdigit(unsigned int ch)
1256 {
1257     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1258     return (get_char_typeW( wch ) & C1_DIGIT);
1259 }
1260
1261 /*********************************************************************
1262  *              _ismbcgraph(MSVCRT.@)
1263  */
1264 int CDECL _ismbcgraph(unsigned int ch)
1265 {
1266     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1267     return (get_char_typeW( wch ) & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA));
1268 }
1269
1270 /*********************************************************************
1271  *              _ismbcalpha (MSVCRT.@)
1272  */
1273 int CDECL _ismbcalpha(unsigned int ch)
1274 {
1275     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1276     return (get_char_typeW( wch ) & C1_ALPHA);
1277 }
1278
1279 /*********************************************************************
1280  *              _ismbclower (MSVCRT.@)
1281  */
1282 int CDECL _ismbclower(unsigned int ch)
1283 {
1284     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1285     return (get_char_typeW( wch ) & C1_UPPER);
1286 }
1287
1288 /*********************************************************************
1289  *              _ismbcupper (MSVCRT.@)
1290  */
1291 int CDECL _ismbcupper(unsigned int ch)
1292 {
1293     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1294     return (get_char_typeW( wch ) & C1_LOWER);
1295 }
1296
1297 /*********************************************************************
1298  *              _ismbcsymbol(MSVCRT.@)
1299  */
1300 int CDECL _ismbcsymbol(unsigned int ch)
1301 {
1302     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1303     WORD ctype;
1304     if (!GetStringTypeW(CT_CTYPE3, &wch, 1, &ctype))
1305     {
1306         WARN("GetStringTypeW failed on %x\n", ch);
1307         return 0;
1308     }
1309     return ((ctype & C3_SYMBOL) != 0);
1310 }
1311
1312 /*********************************************************************
1313  *              _ismbcalnum (MSVCRT.@)
1314  */
1315 int CDECL _ismbcalnum(unsigned int ch)
1316 {
1317     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1318     return (get_char_typeW( wch ) & (C1_ALPHA | C1_DIGIT));
1319 }
1320
1321 /*********************************************************************
1322  *              _ismbcspace (MSVCRT.@)
1323  */
1324 int CDECL _ismbcspace(unsigned int ch)
1325 {
1326     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1327     return (get_char_typeW( wch ) & C1_SPACE);
1328 }
1329
1330 /*********************************************************************
1331  *              _ismbcprint (MSVCRT.@)
1332  */
1333 int CDECL _ismbcprint(unsigned int ch)
1334 {
1335     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1336     return (get_char_typeW( wch ) & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA | C1_SPACE));
1337 }
1338
1339 /*********************************************************************
1340  *              _ismbcpunct(MSVCRT.@)
1341  */
1342 int CDECL _ismbcpunct(unsigned int ch)
1343 {
1344     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1345     return (get_char_typeW( wch ) & C1_PUNCT);
1346 }
1347
1348 /*********************************************************************
1349  *              _ismbchira(MSVCRT.@)
1350  */
1351 int CDECL _ismbchira(unsigned int c)
1352 {
1353   /* FIXME: use lc_ctype when supported, not lc_all */
1354   if(get_mbcinfo()->mbcodepage == 932)
1355   {
1356     /* Japanese/Hiragana, CP 932 */
1357     return (c >= 0x829f && c <= 0x82f1);
1358   }
1359   return 0;
1360 }
1361
1362 /*********************************************************************
1363  *              _ismbckata(MSVCRT.@)
1364  */
1365 int CDECL _ismbckata(unsigned int c)
1366 {
1367   /* FIXME: use lc_ctype when supported, not lc_all */
1368   if(get_mbcinfo()->mbcodepage == 932)
1369   {
1370     if(c < 256)
1371       return _ismbbkana(c);
1372     /* Japanese/Katakana, CP 932 */
1373     return (c >= 0x8340 && c <= 0x8396 && c != 0x837f);
1374   }
1375   return 0;
1376 }
1377
1378 /*********************************************************************
1379  *              _ismbblead(MSVCRT.@)
1380  */
1381 int CDECL _ismbblead(unsigned int c)
1382 {
1383   return (get_mbcinfo()->mbctype[(c&0xff) + 1] & _M1) != 0;
1384 }
1385
1386
1387 /*********************************************************************
1388  *              _ismbbtrail(MSVCRT.@)
1389  */
1390 int CDECL _ismbbtrail(unsigned int c)
1391 {
1392   return (get_mbcinfo()->mbctype[(c&0xff) + 1] & _M2) != 0;
1393 }
1394
1395 /*********************************************************************
1396  *              _ismbclegal(MSVCRT.@)
1397  */
1398 int CDECL _ismbclegal(unsigned int c)
1399 {
1400     return _ismbblead(HIBYTE(c)) && _ismbbtrail(LOBYTE(c));
1401 }
1402
1403 /*********************************************************************
1404  *              _ismbslead(MSVCRT.@)
1405  */
1406 int CDECL _ismbslead(const unsigned char* start, const unsigned char* str)
1407 {
1408   int lead = 0;
1409
1410   if(!get_mbcinfo()->ismbcodepage)
1411     return 0;
1412
1413   /* Lead bytes can also be trail bytes so we need to analyse the string
1414    */
1415   while (start <= str)
1416   {
1417     if (!*start)
1418       return 0;
1419     lead = !lead && _ismbblead(*start);
1420     start++;
1421   }
1422
1423   return lead ? -1 : 0;
1424 }
1425
1426 /*********************************************************************
1427  *              _ismbstrail(MSVCRT.@)
1428  */
1429 int CDECL _ismbstrail(const unsigned char* start, const unsigned char* str)
1430 {
1431   /* Note: this function doesn't check _ismbbtrail */
1432   if ((str > start) && _ismbslead(start, str-1))
1433     return -1;
1434   else
1435     return 0;
1436 }
1437
1438 /*********************************************************************
1439  *              _mbsbtype (MSVCRT.@)
1440  */
1441 int CDECL _mbsbtype(const unsigned char *str, MSVCRT_size_t count)
1442 {
1443   int lead = 0;
1444   const unsigned char *end = str + count;
1445
1446   /* Lead bytes can also be trail bytes so we need to analyse the string.
1447    * Also we must return _MBC_ILLEGAL for chars past the end of the string
1448    */
1449   while (str < end) /* Note: we skip the last byte - will check after the loop */
1450   {
1451     if (!*str)
1452       return _MBC_ILLEGAL;
1453     lead = get_mbcinfo()->ismbcodepage && !lead && _ismbblead(*str);
1454     str++;
1455   }
1456
1457   if (lead)
1458     if (_ismbbtrail(*str))
1459       return _MBC_TRAIL;
1460     else
1461       return _MBC_ILLEGAL;
1462   else
1463     if (_ismbblead(*str))
1464       return _MBC_LEAD;
1465     else
1466       return _MBC_SINGLE;
1467 }
1468
1469 /*********************************************************************
1470  *              _mbsset(MSVCRT.@)
1471  */
1472 unsigned char* CDECL _mbsset(unsigned char* str, unsigned int c)
1473 {
1474   unsigned char* ret = str;
1475
1476   if(!get_mbcinfo()->ismbcodepage || c < 256)
1477     return u__strset(str, c); /* ASCII CP or SB char */
1478
1479   c &= 0xffff; /* Strip high bits */
1480
1481   while(str[0] && str[1])
1482   {
1483     *str++ = c >> 8;
1484     *str++ = c & 0xff;
1485   }
1486   if(str[0])
1487     str[0] = '\0'; /* FIXME: OK to shorten? */
1488
1489   return ret;
1490 }
1491
1492 /*********************************************************************
1493  *              _mbsnbset(MSVCRT.@)
1494  */
1495 unsigned char* CDECL _mbsnbset(unsigned char *str, unsigned int c, MSVCRT_size_t len)
1496 {
1497     unsigned char *ret = str;
1498
1499     if(!len)
1500         return ret;
1501
1502     if(!get_mbcinfo()->ismbcodepage || c < 256)
1503         return u__strnset(str, c, len); /* ASCII CP or SB char */
1504
1505     c &= 0xffff; /* Strip high bits */
1506
1507     while(str[0] && str[1] && (len > 1))
1508     {
1509         *str++ = c >> 8;
1510         len--;
1511         *str++ = c & 0xff;
1512         len--;
1513     }
1514     if(len && str[0]) {
1515         /* as per msdn pad with a blank character */
1516         str[0] = ' ';
1517     }
1518
1519     return ret;
1520 }
1521
1522 /*********************************************************************
1523  *              _mbsnset(MSVCRT.@)
1524  */
1525 unsigned char* CDECL _mbsnset(unsigned char* str, unsigned int c, MSVCRT_size_t len)
1526 {
1527   unsigned char *ret = str;
1528
1529   if(!len)
1530     return ret;
1531
1532   if(!get_mbcinfo()->ismbcodepage || c < 256)
1533     return u__strnset(str, c, len); /* ASCII CP or SB char */
1534
1535   c &= 0xffff; /* Strip high bits */
1536
1537   while(str[0] && str[1] && len--)
1538   {
1539     *str++ = c >> 8;
1540     *str++ = c & 0xff;
1541   }
1542   if(len && str[0])
1543     str[0] = '\0'; /* FIXME: OK to shorten? */
1544
1545   return ret;
1546 }
1547
1548 /*********************************************************************
1549  *              _mbsnccnt(MSVCRT.@)
1550  * 'c' is for 'character'.
1551  */
1552 MSVCRT_size_t CDECL _mbsnccnt(const unsigned char* str, MSVCRT_size_t len)
1553 {
1554   MSVCRT_size_t ret;
1555   if(get_mbcinfo()->ismbcodepage)
1556   {
1557     ret=0;
1558     while(*str && len-- > 0)
1559     {
1560       if(_ismbblead(*str))
1561       {
1562         if (!len)
1563           break;
1564         len--;
1565         str++;
1566       }
1567       str++;
1568       ret++;
1569     }
1570     return ret;
1571   }
1572   ret=u_strlen(str);
1573   return min(ret, len); /* ASCII CP */
1574 }
1575
1576 /*********************************************************************
1577  *              _mbsnbcnt(MSVCRT.@)
1578  * 'b' is for byte count.
1579  */
1580 MSVCRT_size_t CDECL _mbsnbcnt(const unsigned char* str, MSVCRT_size_t len)
1581 {
1582   MSVCRT_size_t ret;
1583   if(get_mbcinfo()->ismbcodepage)
1584   {
1585     const unsigned char* xstr = str;
1586     while(*xstr && len-- > 0)
1587     {
1588       if (_ismbblead(*xstr++))
1589         xstr++;
1590     }
1591     return xstr-str;
1592   }
1593   ret=u_strlen(str);
1594   return min(ret, len); /* ASCII CP */
1595 }
1596
1597 /*********************************************************************
1598  *              _mbsnbcat(MSVCRT.@)
1599  */
1600 unsigned char* CDECL _mbsnbcat(unsigned char* dst, const unsigned char* src, MSVCRT_size_t len)
1601 {
1602     if(get_mbcinfo()->ismbcodepage)
1603     {
1604         unsigned char *res = dst;
1605         while (*dst) {
1606             if (_ismbblead(*dst++)) {
1607                 if (*dst) {
1608                     dst++;
1609                 } else {
1610                     /* as per msdn overwrite the lead byte in front of '\0' */
1611                     dst--;
1612                     break;
1613                 }
1614             }
1615         }
1616         while (*src && len--) *dst++ = *src++;
1617         *dst = '\0';
1618         return res;
1619     }
1620     return u_strncat(dst, src, len); /* ASCII CP */
1621 }
1622
1623 int CDECL _mbsnbcat_s(unsigned char *dst, MSVCRT_size_t size, const unsigned char *src, MSVCRT_size_t len)
1624 {
1625     unsigned char *ptr = dst;
1626     MSVCRT_size_t i;
1627
1628     if (!dst && !size && !src && !len)
1629         return 0;
1630
1631     if (!dst || !size || !src)
1632     {
1633         if (dst && size)
1634             *dst = '\0';
1635
1636         *MSVCRT__errno() = MSVCRT_EINVAL;
1637         return MSVCRT_EINVAL;
1638     }
1639
1640     /* Find the null terminator of the destination buffer. */
1641     while (size && *ptr)
1642         size--, ptr++;
1643
1644     if (!size)
1645     {
1646         *dst = '\0';
1647         *MSVCRT__errno() = MSVCRT_EINVAL;
1648         return MSVCRT_EINVAL;
1649     }
1650
1651     /* If necessary, check that the character preceding the null terminator is
1652      * a lead byte and move the pointer back by one for later overwrite. */
1653     if (ptr != dst && get_mbcinfo()->ismbcodepage && _ismbblead(*(ptr - 1)))
1654         size++, ptr--;
1655
1656     for (i = 0; *src && i < len; i++)
1657     {
1658         *ptr++ = *src++;
1659         size--;
1660
1661         if (!size)
1662         {
1663             *dst = '\0';
1664             *MSVCRT__errno() = MSVCRT_ERANGE;
1665             return MSVCRT_ERANGE;
1666         }
1667     }
1668
1669     *ptr = '\0';
1670     return 0;
1671 }
1672
1673 /*********************************************************************
1674  *              _mbsncat(MSVCRT.@)
1675  */
1676 unsigned char* CDECL _mbsncat(unsigned char* dst, const unsigned char* src, MSVCRT_size_t len)
1677 {
1678   if(get_mbcinfo()->ismbcodepage)
1679   {
1680     unsigned char *res = dst;
1681     while (*dst)
1682     {
1683       if (_ismbblead(*dst++))
1684         dst++;
1685     }
1686     while (*src && len--)
1687     {
1688       *dst++ = *src;
1689       if(_ismbblead(*src++))
1690         *dst++ = *src++;
1691     }
1692     *dst = '\0';
1693     return res;
1694   }
1695   return u_strncat(dst, src, len); /* ASCII CP */
1696 }
1697
1698
1699 /*********************************************************************
1700  *              _mbslwr(MSVCRT.@)
1701  */
1702 unsigned char* CDECL _mbslwr(unsigned char* s)
1703 {
1704   unsigned char *ret = s;
1705   if (!s)
1706     return NULL;
1707   if (get_mbcinfo()->ismbcodepage)
1708   {
1709     unsigned int c;
1710     while (*s)
1711     {
1712       c = _mbctolower(_mbsnextc(s));
1713       /* Note that I assume that the size of the character is unchanged */
1714       if (c > 255)
1715       {
1716           *s++=(c>>8);
1717           c=c & 0xff;
1718       }
1719       *s++=c;
1720     }
1721   }
1722   else for ( ; *s; s++) *s = tolower(*s);
1723   return ret;
1724 }
1725
1726
1727 /*********************************************************************
1728  *              _mbslwr_s(MSVCRT.@)
1729  */
1730 int CDECL _mbslwr_s(unsigned char* s, MSVCRT_size_t len)
1731 {
1732   if (!s && !len)
1733   {
1734     return 0;
1735   }
1736   else if (!s || !len)
1737   {
1738     *MSVCRT__errno() = MSVCRT_EINVAL;
1739     return MSVCRT_EINVAL;
1740   }
1741   if (get_mbcinfo()->ismbcodepage)
1742   {
1743     unsigned int c;
1744     for ( ; *s && len > 0; len--)
1745     {
1746       c = _mbctolower(_mbsnextc(s));
1747       /* Note that I assume that the size of the character is unchanged */
1748       if (c > 255)
1749       {
1750           *s++=(c>>8);
1751           c=c & 0xff;
1752       }
1753       *s++=c;
1754     }
1755   }
1756   else for ( ; *s && len > 0; s++, len--) *s = tolower(*s);
1757   if (*s)
1758   {
1759     *s = '\0';
1760     *MSVCRT__errno() = MSVCRT_EINVAL;
1761     return MSVCRT_EINVAL;
1762   }
1763   return 0;
1764 }
1765
1766
1767 /*********************************************************************
1768  *              _mbsupr(MSVCRT.@)
1769  */
1770 unsigned char* CDECL _mbsupr(unsigned char* s)
1771 {
1772   unsigned char *ret = s;
1773   if (!s)
1774     return NULL;
1775   if (get_mbcinfo()->ismbcodepage)
1776   {
1777     unsigned int c;
1778     while (*s)
1779     {
1780       c = _mbctoupper(_mbsnextc(s));
1781       /* Note that I assume that the size of the character is unchanged */
1782       if (c > 255)
1783       {
1784           *s++=(c>>8);
1785           c=c & 0xff;
1786       }
1787       *s++=c;
1788     }
1789   }
1790   else for ( ; *s; s++) *s = toupper(*s);
1791   return ret;
1792 }
1793
1794
1795 /*********************************************************************
1796  *              _mbsupr_s(MSVCRT.@)
1797  */
1798 int CDECL _mbsupr_s(unsigned char* s, MSVCRT_size_t len)
1799 {
1800   if (!s && !len)
1801   {
1802     return 0;
1803   }
1804   else if (!s || !len)
1805   {
1806     *MSVCRT__errno() = MSVCRT_EINVAL;
1807     return MSVCRT_EINVAL;
1808   }
1809   if (get_mbcinfo()->ismbcodepage)
1810   {
1811     unsigned int c;
1812     for ( ; *s && len > 0; len--)
1813     {
1814       c = _mbctoupper(_mbsnextc(s));
1815       /* Note that I assume that the size of the character is unchanged */
1816       if (c > 255)
1817       {
1818           *s++=(c>>8);
1819           c=c & 0xff;
1820       }
1821       *s++=c;
1822     }
1823   }
1824   else for ( ; *s && len > 0; s++, len--) *s = toupper(*s);
1825   if (*s)
1826   {
1827     *s = '\0';
1828     *MSVCRT__errno() = MSVCRT_EINVAL;
1829     return MSVCRT_EINVAL;
1830   }
1831   return 0;
1832 }
1833
1834
1835 /*********************************************************************
1836  *              _mbsspn (MSVCRT.@)
1837  */
1838 MSVCRT_size_t CDECL _mbsspn(const unsigned char* string, const unsigned char* set)
1839 {
1840     const unsigned char *p, *q;
1841
1842     for (p = string; *p; p++)
1843     {
1844         if (_ismbblead(*p))
1845         {
1846             for (q = set; *q; q++)
1847             {
1848                 if (!q[1])
1849                     break;
1850                 if ((*p == *q) &&  (p[1] == q[1]))
1851                     break;
1852                 q++;
1853             }
1854             if (!q[0] || !q[1]) break;
1855         }
1856         else
1857         {
1858             for (q = set; *q; q++)
1859                 if (*p == *q)
1860                     break;
1861             if (!*q) break;
1862         }
1863     }
1864     return p - string;
1865 }
1866
1867 /*********************************************************************
1868  *              _mbsspnp (MSVCRT.@)
1869  */
1870 unsigned char* CDECL _mbsspnp(const unsigned char* string, const unsigned char* set)
1871 {
1872     const unsigned char *p, *q;
1873
1874     for (p = string; *p; p++)
1875     {
1876         if (_ismbblead(*p))
1877         {
1878             for (q = set; *q; q++)
1879             {
1880                 if (!q[1])
1881                     break;
1882                 if ((*p == *q) &&  (p[1] == q[1]))
1883                     break;
1884                 q++;
1885             }
1886             if (!q[0] || !q[1]) break;
1887         }
1888         else
1889         {
1890             for (q = set; *q; q++)
1891                 if (*p == *q)
1892                     break;
1893             if (!*q) break;
1894         }
1895     }
1896     if (*p == '\0')
1897         return NULL;
1898     return (unsigned char *)p;
1899 }
1900
1901 /*********************************************************************
1902  *              _mbscspn(MSVCRT.@)
1903  */
1904 MSVCRT_size_t CDECL _mbscspn(const unsigned char* str, const unsigned char* cmp)
1905 {
1906   if (get_mbcinfo()->ismbcodepage)
1907     FIXME("don't handle double character case\n");
1908   return u_strcspn(str, cmp);
1909 }
1910
1911 /*********************************************************************
1912  *              _mbsrev (MSVCRT.@)
1913  */
1914 unsigned char* CDECL _mbsrev(unsigned char* str)
1915 {
1916     int i, len = _mbslen(str);
1917     unsigned char *p, *temp=MSVCRT_malloc(len*2);
1918
1919     if(!temp)
1920         return str;
1921
1922     /* unpack multibyte string to temp buffer */
1923     p=str;
1924     for(i=0; i<len; i++)
1925     {
1926         if (_ismbblead(*p))
1927         {
1928             temp[i*2]=*p++;
1929             temp[i*2+1]=*p++;
1930         }
1931         else
1932         {
1933             temp[i*2]=*p++;
1934             temp[i*2+1]=0;
1935         }
1936     }
1937
1938     /* repack it in the reverse order */
1939     p=str;
1940     for(i=len-1; i>=0; i--)
1941     {
1942         if(_ismbblead(temp[i*2]))
1943         {
1944             *p++=temp[i*2];
1945             *p++=temp[i*2+1];
1946         }
1947         else
1948         {
1949             *p++=temp[i*2];
1950         }
1951     }
1952
1953     MSVCRT_free(temp);
1954
1955     return str;
1956 }
1957
1958 /*********************************************************************
1959  *              _mbspbrk (MSVCRT.@)
1960  */
1961 unsigned char* CDECL _mbspbrk(const unsigned char* str, const unsigned char* accept)
1962 {
1963     const unsigned char* p;
1964
1965     while(*str)
1966     {
1967         for(p = accept; *p; p += (_ismbblead(*p)?2:1) )
1968         {
1969             if (*p == *str)
1970                 if( !_ismbblead(*p) || ( *(p+1) == *(str+1) ) )
1971                      return (unsigned char*)str;
1972         }
1973         str += (_ismbblead(*str)?2:1);
1974     }
1975     return NULL;
1976 }
1977
1978
1979 /*
1980  * Functions depending on locale codepage
1981  */
1982
1983 /*********************************************************************
1984  *              mblen(MSVCRT.@)
1985  * REMARKS
1986  *  Unlike most of the multibyte string functions this function uses
1987  *  the locale codepage, not the codepage set by _setmbcp
1988  */
1989 int CDECL MSVCRT_mblen(const char* str, MSVCRT_size_t size)
1990 {
1991   if (str && *str && size)
1992   {
1993     if(get_locinfo()->mb_cur_max == 1)
1994       return 1; /* ASCII CP */
1995
1996     return !MSVCRT_isleadbyte((unsigned char)*str) ? 1 : (size>1 ? 2 : -1);
1997   }
1998   return 0;
1999 }
2000
2001 /*********************************************************************
2002  *              mbrlen(MSVCRT.@)
2003  */
2004 MSVCRT_size_t CDECL MSVCRT_mbrlen(const char *str, MSVCRT_size_t len, MSVCRT_mbstate_t *state)
2005 {
2006     MSVCRT_mbstate_t s = (state ? *state : 0);
2007     MSVCRT_size_t ret;
2008
2009     if(!len || !str || !*str)
2010         return 0;
2011
2012     if(get_locinfo()->mb_cur_max == 1) {
2013         return 1;
2014     }else if(!s && MSVCRT_isleadbyte((unsigned char)*str)) {
2015         if(len == 1) {
2016             s = (unsigned char)*str;
2017             ret = -2;
2018         }else {
2019             ret = 2;
2020         }
2021     }else if(!s) {
2022         ret = 1;
2023     }else {
2024         s = 0;
2025         ret = 2;
2026     }
2027
2028     if(state)
2029         *state = s;
2030     return ret;
2031 }
2032
2033 /*********************************************************************
2034  *              _mbstrlen_l(MSVCRT.@)
2035  */
2036 MSVCRT_size_t CDECL _mbstrlen_l(const char* str, MSVCRT__locale_t locale)
2037 {
2038     MSVCRT_pthreadlocinfo locinfo;
2039
2040     if(!locale)
2041         locinfo = get_locinfo();
2042     else
2043         locinfo = locale->locinfo;
2044
2045     if(locinfo->mb_cur_max > 1) {
2046         MSVCRT_size_t len;
2047         len = MultiByteToWideChar(locinfo->lc_codepage, MB_ERR_INVALID_CHARS,
2048                                   str, -1, NULL, 0);
2049         if (!len) {
2050             *MSVCRT__errno() = MSVCRT_EILSEQ;
2051             return -1;
2052         }
2053         return len - 1;
2054     }
2055
2056     return strlen(str);
2057 }
2058
2059 /*********************************************************************
2060  *              _mbstrlen(MSVCRT.@)
2061  */
2062 MSVCRT_size_t CDECL _mbstrlen(const char* str)
2063 {
2064     return _mbstrlen_l(str, NULL);
2065 }
2066
2067 /*********************************************************************
2068  *              _mbtowc_l(MSVCRT.@)
2069  */
2070 int CDECL MSVCRT_mbtowc_l(MSVCRT_wchar_t *dst, const char* str, MSVCRT_size_t n, MSVCRT__locale_t locale)
2071 {
2072     MSVCRT_pthreadlocinfo locinfo;
2073     MSVCRT_wchar_t tmpdst = '\0';
2074
2075     if(!locale)
2076         locinfo = get_locinfo();
2077     else
2078         locinfo = locale->locinfo;
2079
2080     if(n <= 0 || !str)
2081         return 0;
2082     if(!locinfo->lc_codepage)
2083         tmpdst = (unsigned char)*str;
2084     else if(!MultiByteToWideChar(locinfo->lc_codepage, 0, str, n, &tmpdst, 1))
2085         return -1;
2086     if(dst)
2087         *dst = tmpdst;
2088     /* return the number of bytes from src that have been used */
2089     if(!*str)
2090         return 0;
2091     if(n >= 2 && MSVCRT__isleadbyte_l((unsigned char)*str, locale) && str[1])
2092         return 2;
2093     return 1;
2094 }
2095
2096 /*********************************************************************
2097  *              mbtowc(MSVCRT.@)
2098  */
2099 int CDECL MSVCRT_mbtowc(MSVCRT_wchar_t *dst, const char* str, MSVCRT_size_t n)
2100 {
2101     return MSVCRT_mbtowc_l(dst, str, n, NULL);
2102 }
2103
2104 /*********************************************************************
2105  *              mbrtowc(MSVCRT.@)
2106  */
2107 MSVCRT_size_t CDECL MSVCRT_mbrtowc(MSVCRT_wchar_t *dst, const char *str,
2108         MSVCRT_size_t n, MSVCRT_mbstate_t *state)
2109 {
2110     MSVCRT_pthreadlocinfo locinfo = get_locinfo();
2111     MSVCRT_mbstate_t s = (state ? *state : 0);
2112     char tmpstr[2];
2113     int len = 0;
2114
2115     if(dst)
2116         *dst = 0;
2117
2118     if(!n || !str || !*str)
2119         return 0;
2120
2121     if(locinfo->mb_cur_max == 1) {
2122         tmpstr[len++] = *str;
2123     }else if(!s && MSVCRT_isleadbyte((unsigned char)*str)) {
2124         if(n == 1) {
2125             s = (unsigned char)*str;
2126             len = -2;
2127         }else {
2128             tmpstr[0] = str[0];
2129             tmpstr[1] = str[1];
2130             len = 2;
2131         }
2132     }else if(!s) {
2133         tmpstr[len++] = *str;
2134     }else {
2135         tmpstr[0] = s;
2136         tmpstr[1] = *str;
2137         len = 2;
2138         s = 0;
2139     }
2140
2141     if(len > 0) {
2142         if(!MultiByteToWideChar(locinfo->lc_codepage, 0, tmpstr, len, dst, dst ? 1 : 0))
2143             len = -1;
2144     }
2145
2146     if(state)
2147         *state = s;
2148     return len;
2149 }
2150
2151 /*********************************************************************
2152  *              _mbstowcs_l(MSVCRT.@)
2153  */
2154 MSVCRT_size_t CDECL MSVCRT__mbstowcs_l(MSVCRT_wchar_t *wcstr, const char *mbstr,
2155         MSVCRT_size_t count, MSVCRT__locale_t locale)
2156 {
2157     MSVCRT_pthreadlocinfo locinfo;
2158     MSVCRT_size_t i, size;
2159
2160     if(!mbstr) {
2161         *MSVCRT__errno() = MSVCRT_EINVAL;
2162         return -1;
2163     }
2164
2165     if(!locale)
2166         locinfo = get_locinfo();
2167     else
2168         locinfo = locale->locinfo;
2169
2170     /* Ignore count parameter */
2171     if(!wcstr)
2172         return MultiByteToWideChar(locinfo->lc_codepage, 0, mbstr, -1, NULL, 0)-1;
2173
2174     for(i=0, size=0; i<count; i++) {
2175         if(mbstr[size] == '\0')
2176             break;
2177
2178         size += (MSVCRT__isleadbyte_l((unsigned char)mbstr[size], locale) ? 2 : 1);
2179     }
2180
2181     size = MultiByteToWideChar(locinfo->lc_codepage, 0,
2182             mbstr, size, wcstr, count);
2183
2184     if(size<count && wcstr)
2185         wcstr[size] = '\0';
2186
2187     return size;
2188 }
2189
2190 /*********************************************************************
2191  *              mbstowcs(MSVCRT.@)
2192  */
2193 MSVCRT_size_t CDECL MSVCRT_mbstowcs(MSVCRT_wchar_t *wcstr,
2194         const char *mbstr, MSVCRT_size_t count)
2195 {
2196     return MSVCRT__mbstowcs_l(wcstr, mbstr, count, NULL);
2197 }
2198
2199 /*********************************************************************
2200  *              _mbstowcs_s_l(MSVCRT.@)
2201  */
2202 int CDECL MSVCRT__mbstowcs_s_l(MSVCRT_size_t *ret, MSVCRT_wchar_t *wcstr,
2203         MSVCRT_size_t size, const char *mbstr,
2204         MSVCRT_size_t count, MSVCRT__locale_t locale)
2205 {
2206     MSVCRT_size_t conv;
2207
2208     if(!wcstr && !size) {
2209         conv = MSVCRT__mbstowcs_l(NULL, mbstr, 0, locale);
2210         if(ret)
2211             *ret = conv+1;
2212         return 0;
2213     }
2214
2215     if (!MSVCRT_CHECK_PMT(wcstr != NULL)) return MSVCRT_EINVAL;
2216     if (!MSVCRT_CHECK_PMT(mbstr != NULL)) {
2217         if(size) wcstr[0] = '\0';
2218         return MSVCRT_EINVAL;
2219     }
2220
2221     if(count==MSVCRT__TRUNCATE || size<count)
2222         conv = size;
2223     else
2224         conv = count;
2225
2226     conv = MSVCRT__mbstowcs_l(wcstr, mbstr, conv, locale);
2227     if(conv<size)
2228         wcstr[conv++] = '\0';
2229     else if(conv==size && (count==MSVCRT__TRUNCATE || wcstr[conv-1]=='\0'))
2230         wcstr[conv-1] = '\0';
2231     else {
2232         MSVCRT_INVALID_PMT("wcstr[size] is too small", MSVCRT_ERANGE);
2233         if(size)
2234             wcstr[0] = '\0';
2235         return MSVCRT_ERANGE;
2236     }
2237
2238     if(ret)
2239         *ret = conv;
2240     return 0;
2241 }
2242
2243 /*********************************************************************
2244  *              mbstowcs_s(MSVCRT.@)
2245  */
2246 int CDECL MSVCRT__mbstowcs_s(MSVCRT_size_t *ret, MSVCRT_wchar_t *wcstr,
2247         MSVCRT_size_t size, const char *mbstr, MSVCRT_size_t count)
2248 {
2249     return MSVCRT__mbstowcs_s_l(ret, wcstr, size, mbstr, count, NULL);
2250 }
2251
2252 /*********************************************************************
2253  *              mbsrtowcs(MSVCRT.@)
2254  */
2255 MSVCRT_size_t CDECL MSVCRT_mbsrtowcs(MSVCRT_wchar_t *wcstr,
2256         const char **pmbstr, MSVCRT_size_t count, MSVCRT_mbstate_t *state)
2257 {
2258     MSVCRT_mbstate_t s = (state ? *state : 0);
2259     MSVCRT_wchar_t tmpdst;
2260     MSVCRT_size_t ret = 0;
2261
2262     if(!MSVCRT_CHECK_PMT(pmbstr != NULL))
2263         return -1;
2264
2265     while(!wcstr || count>ret) {
2266         int ch_len = MSVCRT_mbrtowc(&tmpdst, *pmbstr, 2, &s);
2267         if(wcstr)
2268             wcstr[ret] = tmpdst;
2269
2270         if(ch_len < 0) {
2271             return -1;
2272         }else if(ch_len == 0) {
2273             *pmbstr = NULL;
2274             return ret;
2275         }
2276
2277         *pmbstr += ch_len;
2278         ret++;
2279     }
2280
2281     return ret;
2282 }