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