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 #include <limits.h>
  28
  29 #include "msvcrt.h"
  30 #include "wine/unicode.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  34
  35 unsigned char MSVCRT_mbctype[257] = { 0 };
  36
  37 /* It seems that the data about valid trail bytes is not available from kernel32
  38  * so we have to store is here. The format is the same as for lead bytes in CPINFO */
  39 struct cp_extra_info_t
  40 {
  41     int cp;
  42     BYTE TrailBytes[MAX_LEADBYTES];
  43 };
  44
  45 static struct cp_extra_info_t g_cpextrainfo[] =
  46 {
  47     {932, {0x40, 0x7e, 0x80, 0xfc, 0, 0}},
  48     {936, {0x40, 0xfe, 0, 0}},
  49     {949, {0x41, 0xfe, 0, 0}},
  50     {950, {0x40, 0x7e, 0xa1, 0xfe, 0, 0}},
  51     {1361, {0x31, 0x7e, 0x81, 0xfe, 0, 0}},
  52     {20932, {1, 255, 0, 0}},  /* seems to give different results on different systems */
  53     {0, {1, 255, 0, 0}}       /* match all with FIXME */
  54 };
  55
  56 /* Maps cp932 single byte character to multi byte character */
  57 static const unsigned char mbbtombc_932[] = {
  58   0x40,0x49,0x68,0x94,0x90,0x93,0x95,0x66,0x69,0x6a,0x96,0x7b,0x43,0x7c,0x44,0x5e,
  59   0x4f,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x46,0x47,0x83,0x81,0x84,0x48,
  60   0x97,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,
  61   0x6f,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x6d,0x8f,0x6e,0x4f,0x76,
  62   0x77,0x78,0x79,0x6d,0x8f,0x6e,0x4f,0x51,0x65,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
  63   0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,0x95,0x50,
  64        0x42,0x75,0x76,0x41,0x45,0x92,0x40,0x42,0x44,0x46,0x48,0x83,0x85,0x87,0x62,
  65   0x5b,0x41,0x43,0x45,0x47,0x49,0x4a,0x4c,0x4e,0x50,0x52,0x54,0x56,0x58,0x5a,0x5c,
  66   0x5e,0x60,0x63,0x65,0x67,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x71,0x74,0x77,0x7a,0x7d,
  67   0x7e,0x80,0x81,0x82,0x84,0x86,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8f,0x93,0x4a,0x4b };
  68
  69 /* Maps multibyte cp932 punctuation marks to single byte equivalents */
  70 static const unsigned char mbctombb_932_punct[] = {
  71   0x20,0xa4,0xa1,0x2c,0x2e,0xa5,0x3a,0x3b,0x3f,0x21,0xde,0xdf,0x00,0x00,0x00,0x5e,
  72   0x7e,0x5f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x00,0x00,0x2f,0x00,
  73   0x00,0x00,0x7c,0x00,0x00,0x60,0x27,0x00,0x22,0x28,0x29,0x00,0x00,0x5b,0x5d,0x7b,
  74   0x7d,0x00,0x00,0x00,0x00,0xa2,0xa3,0x00,0x00,0x00,0x00,0x2b,0x2d,0x00,0x00,0x00,
  75   0x00,0x3d,0x00,0x3c,0x3e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5c,
  76   0x24,0x00,0x00,0x25,0x23,0x26,0x2a,0x40};
  77
  78 /* Maps multibyte cp932 hiragana/katakana to single-byte equivalents */
  79 static const unsigned char mbctombb_932_kana[] = {
  80   0xa7,0xb1,0xa8,0xb2,0xa9,0xb3,0xaa,0xb4,0xab,0xb5,0xb6,0xb6,0xb7,0xb7,0xb8,0xb8,
  81   0xb9,0xb9,0xba,0xba,0xbb,0xbb,0xbc,0xbc,0xbd,0xbd,0xbe,0xbe,0xbf,0xbf,0xc0,0xc0,
  82   0xc1,0xc1,0xaf,0xc2,0xc2,0xc3,0xc3,0xc4,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xca,
  83   0xca,0xcb,0xcb,0xcb,0xcc,0xcc,0xcc,0xcd,0xcd,0xcd,0xce,0xce,0xce,0xcf,0xd0,0xd1,
  84   0xd2,0xd3,0xac,0xd4,0xad,0xd5,0xae,0xd6,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdc,0xb2,
  85   0xb4,0xa6,0xdd,0xb3,0xb6,0xb9};
  86
  87 static MSVCRT_wchar_t msvcrt_mbc_to_wc(unsigned int ch)
  88 {
  89   MSVCRT_wchar_t chW;
  90   char mbch[2];
  91   int n_chars;
  92
  93   if (ch <= 0xff) {
  94     mbch[0] = ch;
  95     n_chars = 1;
  96   } else {
  97     mbch[0] = (ch >> 8) & 0xff;
  98     mbch[1] = ch & 0xff;
  99     n_chars = 2;
 100   }
 101   if (!MultiByteToWideChar(get_mbcinfo()->mbcodepage, 0, mbch, n_chars, &chW, 1))
 102   {
 103     WARN("MultiByteToWideChar failed on %x\n", ch);
 104     return 0;
 105   }
 106   return chW;
 107 }
 108
 109 static inline MSVCRT_size_t u_strlen( const unsigned char *str )
 110 {
 111   return strlen( (const char*) str );
 112 }
 113
 114 static inline unsigned char* u_strncat( unsigned char* dst, const unsigned char* src, MSVCRT_size_t len )
 115 {
 116   return (unsigned char*)strncat( (char*)dst, (const char*)src, len);
 117 }
 118
 119 static inline int u_strcmp( const unsigned char *s1, const unsigned char *s2 )
 120 {
 121   return strcmp( (const char*)s1, (const char*)s2 );
 122 }
 123
 124 static inline int u_strcasecmp( const unsigned char *s1, const unsigned char *s2 )
 125 {
 126   return strcasecmp( (const char*)s1, (const char*)s2 );
 127 }
 128
 129 static inline int u_strncmp( const unsigned char *s1, const unsigned char *s2, MSVCRT_size_t len )
 130 {
 131   return strncmp( (const char*)s1, (const char*)s2, len );
 132 }
 133
 134 static inline int u_strncasecmp( const unsigned char *s1, const unsigned char *s2, MSVCRT_size_t len )
 135 {
 136   return strncasecmp( (const char*)s1, (const char*)s2, len );
 137 }
 138
 139 static inline unsigned char *u_strchr( const unsigned char *s, unsigned char x )
 140 {
 141   return (unsigned char*) strchr( (const char*)s, x );
 142 }
 143
 144 static inline unsigned char *u_strrchr( const unsigned char *s, unsigned char x )
 145 {
 146   return (unsigned char*) strrchr( (const char*)s, x );
 147 }
 148
 149 static inline unsigned char *u__strset( unsigned char *s, unsigned char c )
 150 {
 151   return (unsigned char*) _strset( (char*)s, c);
 152 }
 153
 154 static inline unsigned char *u__strnset( unsigned char *s, unsigned char c, MSVCRT_size_t len )
 155 {
 156   return (unsigned char*) MSVCRT__strnset( (char*)s, c, len );
 157 }
 158
 159 static inline MSVCRT_size_t u_strcspn( const unsigned char *s, const unsigned char *rej )
 160 {
 161   return strcspn( (const char *)s, (const char*)rej );
 162 }
 163
 164 /*********************************************************************
 165  *              __p__mbctype (MSVCRT.@)
 166  */
 167 unsigned char* CDECL __p__mbctype(void)
 168 {
 169   return get_mbcinfo()->mbctype;
 170 }
 171
 172 /*********************************************************************
 173  *              __p___mb_cur_max(MSVCRT.@)
 174  */
 175 int* CDECL __p___mb_cur_max(void)
 176 {
 177   return &get_locinfo()->mb_cur_max;
 178 }
 179
 180 /*********************************************************************
 181  *              ___mb_cur_max_func(MSVCRT.@)
 182  */
 183 int CDECL MSVCRT____mb_cur_max_func(void)
 184 {
 185   return get_locinfo()->mb_cur_max;
 186 }
 187
 188 #if _MSVCR_VER>=80
 189 /*********************************************************************
 190  *              ___mb_cur_max_l_func  (MSVCR80.@)
 191  */
 192 int* CDECL ___mb_cur_max_l_func(MSVCRT__locale_t locale)
 193 {
 194   MSVCRT_pthreadlocinfo locinfo;
 195
 196   if(!locale)
 197     locinfo = get_locinfo();
 198   else
 199     locinfo = locale->locinfo;
 200
 201   return &locinfo->mb_cur_max;
 202 }
 203 #endif
 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, 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(start >= cur)
 526     return NULL;
 527
 528   if(get_mbcinfo()->ismbcodepage)
 529     return (unsigned char *)(_ismbstrail(start,cur-1) ? cur - 2 : cur -1);
 530
 531   return (unsigned char *)cur - 1; /* ASCII CP or SB char */
 532 }
 533
 534 /*********************************************************************
 535  *              _mbclen(MSVCRT.@)
 536  */
 537 unsigned int CDECL _mbclen(const unsigned char* str)
 538 {
 539   return _ismbblead(*str) ? 2 : 1;
 540 }
 541
 542 /*********************************************************************
 543  *              _mbsinc(MSVCRT.@)
 544  */
 545 unsigned char* CDECL _mbsinc(const unsigned char* str)
 546 {
 547   return (unsigned char *)(str + _mbclen(str));
 548 }
 549
 550 /*********************************************************************
 551  *              _mbsninc(MSVCRT.@)
 552  */
 553 unsigned char* CDECL _mbsninc(const unsigned char* str, MSVCRT_size_t num)
 554 {
 555   if(!str)
 556     return NULL;
 557
 558   while (num > 0 && *str)
 559   {
 560     if (_ismbblead(*str))
 561     {
 562       if (!*(str+1))
 563          break;
 564       str++;
 565     }
 566     str++;
 567     num--;
 568   }
 569
 570   return (unsigned char*)str;
 571 }
 572
 573 /*********************************************************************
 574  *              _mbsnlen_l(MSVCRT.@)
 575  */
 576 MSVCRT_size_t CDECL _mbsnlen_l(const unsigned char *str,
 577         MSVCRT_size_t maxsize, MSVCRT__locale_t locale)
 578 {
 579     MSVCRT_pthreadmbcinfo mbcinfo;
 580     MSVCRT_size_t i = 0, len = 0;
 581
 582     if(!locale)
 583         mbcinfo = get_mbcinfo();
 584     else
 585         mbcinfo = locale->mbcinfo;
 586
 587     if(!mbcinfo->ismbcodepage)
 588         return MSVCRT_strnlen((const char*)str, maxsize);
 589
 590     while(i<maxsize && str[i])
 591     {
 592         if (_ismbblead_l(str[i], locale))
 593         {
 594             i++;
 595             if (!str[i])  /* count only full chars */
 596                 break;
 597         }
 598         i++;
 599         len++;
 600     }
 601     return i < maxsize ? len : maxsize;
 602 }
 603
 604 /*********************************************************************
 605  *              _mbslen(MSVCRT.@)
 606  */
 607 MSVCRT_size_t CDECL _mbslen(const unsigned char* str)
 608 {
 609     return _mbsnlen_l(str, -1, NULL);
 610 }
 611
 612 /*********************************************************************
 613  *              _mbslen_l(MSVCRT.@)
 614  */
 615 MSVCRT_size_t CDECL _mbslen_l(const unsigned char* str, MSVCRT__locale_t locale)
 616 {
 617     return _mbsnlen_l(str, -1, locale);
 618 }
 619
 620 /*********************************************************************
 621  *              _mbsnlen(MSVCRT.@)
 622  */
 623 MSVCRT_size_t CDECL _mbsnlen(const unsigned char* str, MSVCRT_size_t maxsize)
 624 {
 625     return _mbsnlen_l(str, maxsize, NULL);
 626 }
 627
 628 /*********************************************************************
 629  *              _mbccpy_s_l(MSVCRT.@)
 630  */
 631 int CDECL _mbccpy_s_l(unsigned char* dest, MSVCRT_size_t maxsize,
 632         int *copied, const unsigned char* src, MSVCRT__locale_t locale)
 633 {
 634     if(copied) *copied = 0;
 635     if(!MSVCRT_CHECK_PMT(dest != NULL && maxsize >= 1)) return MSVCRT_EINVAL;
 636     dest[0] = 0;
 637     if(!MSVCRT_CHECK_PMT(src != NULL)) return MSVCRT_EINVAL;
 638
 639     if(_ismbblead_l(*src, locale)) {
 640         if(!src[1]) {
 641             if(copied) *copied = 1;
 642             *MSVCRT__errno() = MSVCRT_EILSEQ;
 643             return MSVCRT_EILSEQ;
 644         }
 645
 646         if(maxsize < 2) {
 647             MSVCRT_INVALID_PMT("dst buffer is too small", MSVCRT_ERANGE);
 648             return MSVCRT_ERANGE;
 649         }
 650
 651         *dest++ = *src++;
 652         *dest = *src;
 653         if(copied) *copied = 2;
 654     }else {
 655         *dest = *src;
 656         if(copied) *copied = 1;
 657     }
 658
 659     return 0;
 660 }
 661
 662 /*********************************************************************
 663  *              _mbccpy(MSVCRT.@)
 664  */
 665 void CDECL _mbccpy(unsigned char* dest, const unsigned char* src)
 666 {
 667     _mbccpy_s_l(dest, 2, NULL, src, NULL);
 668 }
 669
 670 /*********************************************************************
 671  *              _mbccpy_l(MSVCRT.@)
 672  */
 673 void CDECL _mbccpy_l(unsigned char* dest, const unsigned char* src,
 674         MSVCRT__locale_t locale)
 675 {
 676     _mbccpy_s_l(dest, 2, NULL, src, locale);
 677 }
 678
 679 /*********************************************************************
 680  *              _mbccpy_s(MSVCRT.@)
 681  */
 682 int CDECL _mbccpy_s(unsigned char* dest, MSVCRT_size_t maxsize,
 683         int *copied, const unsigned char* src)
 684 {
 685     return _mbccpy_s_l(dest, maxsize, copied, src, NULL);
 686 }
 687
 688 /*********************************************************************
 689  *              _mbsncpy(MSVCRT.@)
 690  * REMARKS
 691  *  The parameter n is the number or characters to copy, not the size of
 692  *  the buffer. Use _mbsnbcpy for a function analogical to strncpy
 693  */
 694 unsigned char* CDECL _mbsncpy(unsigned char* dst, const unsigned char* src, MSVCRT_size_t n)
 695 {
 696   unsigned char* ret = dst;
 697   if(!n)
 698     return dst;
 699   if (get_mbcinfo()->ismbcodepage)
 700   {
 701     while (*src && n)
 702     {
 703       n--;
 704       if (_ismbblead(*src))
 705       {
 706         if (!*(src+1))
 707         {
 708             *dst++ = 0;
 709             *dst++ = 0;
 710             break;
 711         }
 712
 713         *dst++ = *src++;
 714       }
 715
 716       *dst++ = *src++;
 717     }
 718   }
 719   else
 720   {
 721     while (n)
 722     {
 723         n--;
 724         if (!(*dst++ = *src++)) break;
 725     }
 726   }
 727   while (n--) *dst++ = 0;
 728   return ret;
 729 }
 730
 731 /*********************************************************************
 732  *              _mbsnbcpy_s_l(MSVCRT.@)
 733  * REMARKS
 734  * Unlike _mbsnbcpy this function does not pad the rest of the dest
 735  * string with 0
 736  */
 737 int CDECL _mbsnbcpy_s_l(unsigned char* dst, MSVCRT_size_t size,
 738         const unsigned char* src, MSVCRT_size_t n, MSVCRT__locale_t locale)
 739 {
 740     MSVCRT_size_t pos = 0;
 741
 742     if(!dst || size == 0)
 743         return MSVCRT_EINVAL;
 744     if(!src)
 745     {
 746         dst[0] = '\0';
 747         return MSVCRT_EINVAL;
 748     }
 749     if(!n)
 750         return 0;
 751
 752     if((locale ? locale->mbcinfo : get_mbcinfo())->ismbcodepage)
 753     {
 754         BOOL is_lead = FALSE;
 755         while (*src && n)
 756         {
 757             if(pos == size)
 758             {
 759                 dst[0] = '\0';
 760                 return MSVCRT_ERANGE;
 761             }
 762             is_lead = (!is_lead && _ismbblead(*src));
 763             n--;
 764             dst[pos++] = *src++;
 765         }
 766
 767         if (is_lead) /* if string ends with a lead, remove it */
 768             dst[pos - 1] = 0;
 769     }
 770     else
 771     {
 772         while (n)
 773         {
 774             n--;
 775             if(pos == size)
 776             {
 777                 dst[0] = '\0';
 778                 return MSVCRT_ERANGE;
 779             }
 780
 781             if(!(*src)) break;
 782             dst[pos++] = *src++;
 783         }
 784     }
 785
 786     if(pos < size)
 787         dst[pos] = '\0';
 788     else
 789     {
 790         dst[0] = '\0';
 791         return MSVCRT_ERANGE;
 792     }
 793
 794     return 0;
 795 }
 796
 797 /*********************************************************************
 798  *              _mbsnbcpy_s(MSVCRT.@)
 799  */
 800 int CDECL _mbsnbcpy_s(unsigned char* dst, MSVCRT_size_t size, const unsigned char* src, MSVCRT_size_t n)
 801 {
 802     return _mbsnbcpy_s_l(dst, size, src, n, NULL);
 803 }
 804
 805 /*********************************************************************
 806  *              _mbscpy_s_l(MSVCRT.@)
 807  */
 808 int CDECL _mbscpy_s_l(unsigned char *dst, MSVCRT_size_t size,
 809         const unsigned char *src, MSVCRT__locale_t locale)
 810 {
 811     return _mbsnbcpy_s_l(dst, size, src, -1, locale);
 812 }
 813
 814 /*********************************************************************
 815  *              _mbscpy_s(MSVCRT.@)
 816  */
 817 int CDECL _mbscpy_s(unsigned char *dst, MSVCRT_size_t size, const unsigned char *src)
 818 {
 819     return _mbscpy_s_l(dst, size, src, NULL);
 820 }
 821
 822 /*********************************************************************
 823  *              _mbsnbcpy(MSVCRT.@)
 824  * REMARKS
 825  *  Like strncpy this function doesn't enforce the string to be
 826  *  NUL-terminated
 827  */
 828 unsigned char* CDECL _mbsnbcpy(unsigned char* dst, const unsigned char* src, MSVCRT_size_t n)
 829 {
 830   unsigned char* ret = dst;
 831   if(!n)
 832     return dst;
 833   if(get_mbcinfo()->ismbcodepage)
 834   {
 835     BOOL is_lead = FALSE;
 836     while (*src && n)
 837     {
 838       is_lead = (!is_lead && _ismbblead(*src));
 839       n--;
 840       *dst++ = *src++;
 841     }
 842
 843     if (is_lead) /* if string ends with a lead, remove it */
 844         *(dst - 1) = 0;
 845   }
 846   else
 847   {
 848     while (n)
 849     {
 850         n--;
 851         if (!(*dst++ = *src++)) break;
 852     }
 853   }
 854   while (n--) *dst++ = 0;
 855   return ret;
 856 }
 857
 858 /*********************************************************************
 859  *              _mbscmp(MSVCRT.@)
 860  */
 861 int CDECL _mbscmp(const unsigned char* str, const unsigned char* cmp)
 862 {
 863   if (!str || !cmp) return INT_MAX;
 864
 865   if(get_mbcinfo()->ismbcodepage)
 866   {
 867     unsigned int strc, cmpc;
 868     do {
 869       if(!*str)
 870         return *cmp ? -1 : 0;
 871       if(!*cmp)
 872         return 1;
 873       strc = _mbsnextc(str);
 874       cmpc = _mbsnextc(cmp);
 875       if(strc != cmpc)
 876         return strc < cmpc ? -1 : 1;
 877       str +=(strc > 255) ? 2 : 1;
 878       cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
 879     } while(1);
 880   }
 881   return u_strcmp(str, cmp); /* ASCII CP */
 882 }
 883
 884 /*********************************************************************
 885  *              _mbsnbicoll_l(MSVCRT.@)
 886  */
 887 int CDECL _mbsnbicoll_l(const unsigned char *str1, const unsigned char *str2, MSVCRT_size_t len, MSVCRT__locale_t locale)
 888 {
 889     MSVCRT_pthreadmbcinfo mbcinfo;
 890
 891     if(!locale)
 892         mbcinfo = get_mbcinfo();
 893     else
 894         mbcinfo = locale->mbcinfo;
 895
 896     if(!mbcinfo->ismbcodepage)
 897         return MSVCRT__strnicoll_l((const char*)str1, (const char*)str2, len, locale);
 898     return CompareStringA(mbcinfo->mblcid, NORM_IGNORECASE, (const char*)str1, len, (const char*)str2, len)-CSTR_EQUAL;
 899 }
 900
 901 /*********************************************************************
 902  *              _mbsicoll_l(MSVCRT.@)
 903  */
 904 int CDECL _mbsicoll_l(const unsigned char *str1, const unsigned char *str2, MSVCRT__locale_t locale)
 905 {
 906     return _mbsnbicoll_l(str1, str2, -1, locale);
 907 }
 908
 909 /*********************************************************************
 910  *              _mbsnbicoll(MSVCRT.@)
 911  */
 912 int CDECL _mbsnbicoll(const unsigned char *str1, const unsigned char *str2, MSVCRT_size_t len)
 913 {
 914     return _mbsnbicoll_l(str1, str2, len, NULL);
 915 }
 916
 917 /*********************************************************************
 918  *              _mbsicoll(MSVCRT.@)
 919  */
 920 int CDECL _mbsicoll(const unsigned char* str, const unsigned char* cmp)
 921 {
 922 #if _MSVCR_VER>=60 && _MSVCR_VER<=71
 923     return CompareStringA(get_mbcinfo()->mblcid, NORM_IGNORECASE,
 924             (const char*)str, -1, (const char*)cmp, -1)-CSTR_EQUAL;
 925 #else
 926     return _mbsnbicoll_l(str, cmp, -1, NULL);
 927 #endif
 928 }
 929
 930 /*********************************************************************
 931  *              _mbsnbcoll_l(MSVCRT.@)
 932  */
 933 int CDECL _mbsnbcoll_l(const unsigned char *str1, const unsigned char *str2, MSVCRT_size_t len, MSVCRT__locale_t locale)
 934 {
 935     MSVCRT_pthreadmbcinfo mbcinfo;
 936
 937     if(!locale)
 938         mbcinfo = get_mbcinfo();
 939     else
 940         mbcinfo = locale->mbcinfo;
 941
 942     if(!mbcinfo->ismbcodepage)
 943         return MSVCRT__strncoll_l((const char*)str1, (const char*)str2, len, locale);
 944     return CompareStringA(mbcinfo->mblcid, 0, (const char*)str1, len, (const char*)str2, len)-CSTR_EQUAL;
 945 }
 946
 947 /*********************************************************************
 948  *              _mbscoll_l(MSVCRT.@)
 949  */
 950 int CDECL _mbscoll_l(const unsigned char *str1, const unsigned char *str2, MSVCRT__locale_t locale)
 951 {
 952     return _mbsnbcoll_l(str1, str2, -1, locale);
 953 }
 954
 955 /*********************************************************************
 956  *              _mbsnbcoll(MSVCRT.@)
 957  */
 958 int CDECL _mbsnbcoll(const unsigned char *str1, const unsigned char *str2, MSVCRT_size_t len)
 959 {
 960     return _mbsnbcoll_l(str1, str2, len, NULL);
 961 }
 962
 963 /*********************************************************************
 964  *              _mbscoll(MSVCRT.@)
 965  */
 966 int CDECL _mbscoll(const unsigned char* str, const unsigned char* cmp)
 967 {
 968 #if _MSVCR_VER>=60 && _MSVCR_VER<=71
 969     return CompareStringA(get_mbcinfo()->mblcid, 0,
 970             (const char*)str, -1, (const char*)cmp, -1)-CSTR_EQUAL;
 971 #else
 972     return _mbsnbcoll_l(str, cmp, -1, NULL);
 973 #endif
 974 }
 975
 976 /*********************************************************************
 977  *              _mbsicmp(MSVCRT.@)
 978  */
 979 int CDECL _mbsicmp(const unsigned char* str, const unsigned char* cmp)
 980 {
 981   if(get_mbcinfo()->ismbcodepage)
 982   {
 983     unsigned int strc, cmpc;
 984     do {
 985       if(!*str)
 986         return *cmp ? -1 : 0;
 987       if(!*cmp)
 988         return 1;
 989       strc = _mbctolower(_mbsnextc(str));
 990       cmpc = _mbctolower(_mbsnextc(cmp));
 991       if(strc != cmpc)
 992         return strc < cmpc ? -1 : 1;
 993       str +=(strc > 255) ? 2 : 1;
 994       cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
 995     } while(1);
 996   }
 997   return u_strcasecmp(str, cmp); /* ASCII CP */
 998 }
 999
1000 /*********************************************************************
1001  *              _mbsncmp(MSVCRT.@)
1002  */
1003 int CDECL _mbsncmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
1004 {
1005   if(!len)
1006     return 0;
1007
1008   if(get_mbcinfo()->ismbcodepage)
1009   {
1010     unsigned int strc, cmpc;
1011     while(len--)
1012     {
1013       int inc;
1014       if(!*str)
1015         return *cmp ? -1 : 0;
1016       if(!*cmp)
1017         return 1;
1018       strc = _mbsnextc(str);
1019       cmpc = _mbsnextc(cmp);
1020       if(strc != cmpc)
1021         return strc < cmpc ? -1 : 1;
1022       inc=(strc > 255) ? 2 : 1; /* Equal, use same increment */
1023       str += inc;
1024       cmp += inc;
1025     }
1026     return 0; /* Matched len chars */
1027   }
1028   return u_strncmp(str, cmp, len); /* ASCII CP */
1029 }
1030
1031 /*********************************************************************
1032  *              _mbsnbcmp(MSVCRT.@)
1033  */
1034 int CDECL _mbsnbcmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
1035 {
1036   if (!len)
1037     return 0;
1038   if(get_mbcinfo()->ismbcodepage)
1039   {
1040     unsigned int strc, cmpc;
1041     while (len)
1042     {
1043       int clen;
1044       if(!*str)
1045         return *cmp ? -1 : 0;
1046       if(!*cmp)
1047         return 1;
1048       if (_ismbblead(*str))
1049       {
1050         strc=(len>=2)?_mbsnextc(str):0;
1051         clen=2;
1052       }
1053       else
1054       {
1055         strc=*str;
1056         clen=1;
1057       }
1058       if (_ismbblead(*cmp))
1059         cmpc=(len>=2)?_mbsnextc(cmp):0;
1060       else
1061         cmpc=*cmp;
1062       if(strc != cmpc)
1063         return strc < cmpc ? -1 : 1;
1064       len -= clen;
1065       str += clen;
1066       cmp += clen;
1067     }
1068     return 0; /* Matched len chars */
1069   }
1070   return u_strncmp(str,cmp,len);
1071 }
1072
1073 /*********************************************************************
1074  *              _mbsnicmp(MSVCRT.@)
1075  *
1076  * Compare two multibyte strings case insensitively to 'len' characters.
1077  */
1078 int CDECL _mbsnicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
1079 {
1080   /* FIXME: No tolower() for mb strings yet */
1081   if(get_mbcinfo()->ismbcodepage)
1082   {
1083     unsigned int strc, cmpc;
1084     while(len--)
1085     {
1086       if(!*str)
1087         return *cmp ? -1 : 0;
1088       if(!*cmp)
1089         return 1;
1090       strc = _mbctolower(_mbsnextc(str));
1091       cmpc = _mbctolower(_mbsnextc(cmp));
1092       if(strc != cmpc)
1093         return strc < cmpc ? -1 : 1;
1094       str +=(strc > 255) ? 2 : 1;
1095       cmp +=(strc > 255) ? 2 : 1; /* Equal, use same increment */
1096     }
1097     return 0; /* Matched len chars */
1098   }
1099   return u_strncasecmp(str, cmp, len); /* ASCII CP */
1100 }
1101
1102 /*********************************************************************
1103  *              _mbsnbicmp(MSVCRT.@)
1104  */
1105 int CDECL _mbsnbicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
1106 {
1107   if (!len)
1108     return 0;
1109   if(get_mbcinfo()->ismbcodepage)
1110   {
1111     unsigned int strc, cmpc;
1112     while (len)
1113     {
1114       int clen;
1115       if(!*str)
1116         return *cmp ? -1 : 0;
1117       if(!*cmp)
1118         return 1;
1119       if (_ismbblead(*str))
1120       {
1121         strc=(len>=2)?_mbsnextc(str):0;
1122         clen=2;
1123       }
1124       else
1125       {
1126         strc=*str;
1127         clen=1;
1128       }
1129       if (_ismbblead(*cmp))
1130         cmpc=(len>=2)?_mbsnextc(cmp):0;
1131       else
1132         cmpc=*cmp;
1133       strc = _mbctolower(strc);
1134       cmpc = _mbctolower(cmpc);
1135       if(strc != cmpc)
1136         return strc < cmpc ? -1 : 1;
1137       len -= clen;
1138       str += clen;
1139       cmp += clen;
1140     }
1141     return 0; /* Matched len bytes */
1142   }
1143   return u_strncasecmp(str,cmp,len);
1144 }
1145
1146 /*********************************************************************
1147  *              _mbscat (MSVCRT.@)
1148  */
1149 unsigned char * CDECL _mbscat( unsigned char *dst, const unsigned char *src )
1150 {
1151     strcat( (char *)dst, (const char *)src );
1152     return dst;
1153 }
1154
1155 /*********************************************************************
1156  *              _mbscat_s_l (MSVCRT.@)
1157  */
1158 int CDECL _mbscat_s_l( unsigned char *dst, MSVCRT_size_t size,
1159         const unsigned char *src, MSVCRT__locale_t locale )
1160 {
1161     MSVCRT_size_t i, j;
1162     int ret = 0;
1163
1164     if(!MSVCRT_CHECK_PMT(dst != NULL)) return MSVCRT_EINVAL;
1165     if(!MSVCRT_CHECK_PMT(src != NULL)) return MSVCRT_EINVAL;
1166
1167     for(i=0; i<size; i++)
1168         if(!dst[i]) break;
1169     if(i == size) {
1170         MSVCRT_INVALID_PMT("dst is not NULL-terminated", MSVCRT_EINVAL);
1171         if(size) dst[0] = 0;
1172         return MSVCRT_EINVAL;
1173     }
1174
1175     if(i && _ismbblead_l(dst[i-1], locale)) {
1176         ret = MSVCRT_EILSEQ;
1177         i--;
1178     }
1179
1180     for(j=0; src[j] && i+j<size; j++)
1181         dst[i+j] = src[j];
1182     if(i+j == size) {
1183         MSVCRT_INVALID_PMT("dst buffer is too small", MSVCRT_ERANGE);
1184         dst[0] = 0;
1185         return MSVCRT_ERANGE;
1186     }
1187
1188     if(j && _ismbblead_l(src[j-1], locale)) {
1189         ret = MSVCRT_EILSEQ;
1190         j--;
1191     }
1192
1193     dst[i+j] = 0;
1194     return ret;
1195 }
1196
1197 /*********************************************************************
1198  *              _mbscat_s (MSVCRT.@)
1199  */
1200 int CDECL _mbscat_s( unsigned char *dst, MSVCRT_size_t size, const unsigned char *src )
1201 {
1202     return _mbscat_s_l(dst, size, src, NULL);
1203 }
1204
1205 /*********************************************************************
1206  *              _mbscpy (MSVCRT.@)
1207  */
1208 unsigned char* CDECL _mbscpy( unsigned char *dst, const unsigned char *src )
1209 {
1210     strcpy( (char *)dst, (const char *)src );
1211     return dst;
1212 }
1213
1214 /*********************************************************************
1215  *              _mbsstr (MSVCRT.@)
1216  */
1217 unsigned char * CDECL _mbsstr(const unsigned char *haystack, const unsigned char *needle)
1218 {
1219     return (unsigned char *)strstr( (const char *)haystack, (const char *)needle );
1220 }
1221
1222 /*********************************************************************
1223  *              _mbschr(MSVCRT.@)
1224  *
1225  * Find a multibyte character in a multibyte string.
1226  */
1227 unsigned char* CDECL _mbschr(const unsigned char* s, unsigned int x)
1228 {
1229   if(get_mbcinfo()->ismbcodepage)
1230   {
1231     unsigned int c;
1232     while (1)
1233     {
1234       c = _mbsnextc(s);
1235       if (c == x)
1236         return (unsigned char*)s;
1237       if (!c)
1238         return NULL;
1239       s += c > 255 ? 2 : 1;
1240     }
1241   }
1242   return u_strchr(s, x); /* ASCII CP */
1243 }
1244
1245 /*********************************************************************
1246  *              _mbsrchr(MSVCRT.@)
1247  */
1248 unsigned char* CDECL _mbsrchr(const unsigned char* s, unsigned int x)
1249 {
1250   if(get_mbcinfo()->ismbcodepage)
1251   {
1252     unsigned int c;
1253     unsigned char* match=NULL;
1254     if(!s)
1255       return NULL;
1256     while (1) {
1257       c = _mbsnextc(s);
1258       if (c == x)
1259         match=(unsigned char*)s;
1260       if (!c)
1261         return match;
1262       s +=(c > 255) ? 2 : 1;
1263     }
1264   }
1265   return u_strrchr(s, x);
1266 }
1267
1268 /*********************************************************************
1269  *              _mbstok_s_l(MSVCRT.@)
1270  */
1271 unsigned char* CDECL _mbstok_s_l(unsigned char *str, const unsigned char *delim,
1272         unsigned char **ctx, MSVCRT__locale_t locale)
1273 {
1274     MSVCRT_pthreadmbcinfo mbcinfo;
1275     unsigned int c;
1276
1277     if(!MSVCRT_CHECK_PMT(delim != NULL)) return NULL;
1278     if(!MSVCRT_CHECK_PMT(ctx != NULL)) return NULL;
1279     if(!MSVCRT_CHECK_PMT(str || *ctx)) return NULL;
1280
1281     if(locale)
1282         mbcinfo = locale->mbcinfo;
1283     else
1284         mbcinfo = get_mbcinfo();
1285
1286     if(!mbcinfo->ismbcodepage)
1287         return (unsigned char*)MSVCRT_strtok_s((char*)str, (const char*)delim, (char**)ctx);
1288
1289     if(!str)
1290         str = *ctx;
1291
1292     while((c=_mbsnextc(str)) && _mbschr(delim, c))
1293         str += c>255 ? 2 : 1;
1294     if(!*str)
1295     {
1296         *ctx = str;
1297         return NULL;
1298     }
1299
1300     *ctx = str + (c>255 ? 2 : 1);
1301     while((c=_mbsnextc(*ctx)) && !_mbschr(delim, c))
1302         *ctx += c>255 ? 2 : 1;
1303     if (**ctx) {
1304         *(*ctx)++ = 0;
1305         if(c > 255)
1306             *(*ctx)++ = 0;
1307     }
1308
1309     return str;
1310 }
1311
1312
1313 /*********************************************************************
1314  *              _mbstok_s(MSVCRT.@)
1315  */
1316 unsigned char* CDECL _mbstok_s(unsigned char *str,
1317         const unsigned char *delim, unsigned char **ctx)
1318 {
1319     return _mbstok_s_l(str, delim, ctx, NULL);
1320 }
1321
1322 /*********************************************************************
1323  *              _mbstok_l(MSVCRT.@)
1324  */
1325 unsigned char* CDECL _mbstok_l(unsigned char *str,
1326         const unsigned char *delim, MSVCRT__locale_t locale)
1327 {
1328     return _mbstok_s_l(str, delim, &msvcrt_get_thread_data()->mbstok_next, locale);
1329 }
1330
1331 /*********************************************************************
1332  *              _mbstok(MSVCRT.@)
1333  */
1334 unsigned char* CDECL _mbstok(unsigned char *str, const unsigned char *delim)
1335 {
1336     thread_data_t *data = msvcrt_get_thread_data();
1337
1338 #if _MSVCR_VER == 0
1339     if(!str && !data->mbstok_next)
1340         return NULL;
1341 #endif
1342
1343     return _mbstok_s_l(str, delim, &data->mbstok_next, NULL);
1344 }
1345
1346 /*********************************************************************
1347  *              _mbbtombc(MSVCRT.@)
1348  */
1349 unsigned int CDECL _mbbtombc(unsigned int c)
1350 {
1351   if(get_mbcinfo()->mbcodepage == 932)
1352   {
1353     if(c >= 0x20 && c <= 0x7e) {
1354       if((c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) || (c >= 0x30 && c <= 0x39))
1355         return mbbtombc_932[c - 0x20] | 0x8200;
1356       else
1357         return mbbtombc_932[c - 0x20] | 0x8100;
1358     }
1359     else if(c >= 0xa1 && c <= 0xdf) {
1360       if(c >= 0xa6 && c <= 0xdd && c != 0xb0)
1361         return mbbtombc_932[c - 0xa1 + 0x5f] | 0x8300;
1362       else
1363         return mbbtombc_932[c - 0xa1 + 0x5f] | 0x8100;
1364     }
1365   }
1366   return c;  /* not Japanese or no MB char */
1367 }
1368
1369 /*********************************************************************
1370  *              _mbbtype(MSVCRT.@)
1371  */
1372 int CDECL _mbbtype(unsigned char c, int type)
1373 {
1374     if (type == 1)
1375     {
1376         if ((c >= 0x20 && c <= 0x7e) || (c >= 0xa1 && c <= 0xdf))
1377             return _MBC_SINGLE;
1378         else if ((c >= 0x40 && c <= 0x7e) || (c >= 0x80 && c <= 0xfc))
1379             return _MBC_TRAIL;
1380         else
1381             return _MBC_ILLEGAL;
1382     }
1383     else
1384     {
1385         if ((c >= 0x20 && c <= 0x7e) || (c >= 0xa1 && c <= 0xdf))
1386             return _MBC_SINGLE;
1387         else if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfc))
1388             return _MBC_LEAD;
1389         else
1390             return _MBC_ILLEGAL;
1391     }
1392 }
1393
1394 /*********************************************************************
1395  *              _ismbbkana(MSVCRT.@)
1396  */
1397 int CDECL _ismbbkana(unsigned int c)
1398 {
1399   /* FIXME: use lc_ctype when supported, not lc_all */
1400   if(get_mbcinfo()->mbcodepage == 932)
1401   {
1402     /* Japanese/Katakana, CP 932 */
1403     return (c >= 0xa1 && c <= 0xdf);
1404   }
1405   return 0;
1406 }
1407
1408 /*********************************************************************
1409  *              _ismbcdigit(MSVCRT.@)
1410  */
1411 int CDECL _ismbcdigit(unsigned int ch)
1412 {
1413     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1414     return (get_char_typeW( wch ) & C1_DIGIT);
1415 }
1416
1417 /*********************************************************************
1418  *              _ismbcgraph(MSVCRT.@)
1419  */
1420 int CDECL _ismbcgraph(unsigned int ch)
1421 {
1422     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1423     return (get_char_typeW( wch ) & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA));
1424 }
1425
1426 /*********************************************************************
1427  *              _ismbcalpha (MSVCRT.@)
1428  */
1429 int CDECL _ismbcalpha(unsigned int ch)
1430 {
1431     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1432     return (get_char_typeW( wch ) & C1_ALPHA);
1433 }
1434
1435 /*********************************************************************
1436  *              _ismbclower (MSVCRT.@)
1437  */
1438 int CDECL _ismbclower(unsigned int ch)
1439 {
1440     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1441     return (get_char_typeW( wch ) & C1_UPPER);
1442 }
1443
1444 /*********************************************************************
1445  *              _ismbcupper (MSVCRT.@)
1446  */
1447 int CDECL _ismbcupper(unsigned int ch)
1448 {
1449     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1450     return (get_char_typeW( wch ) & C1_LOWER);
1451 }
1452
1453 /*********************************************************************
1454  *              _ismbcsymbol(MSVCRT.@)
1455  */
1456 int CDECL _ismbcsymbol(unsigned int ch)
1457 {
1458     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1459     WORD ctype;
1460     if (!GetStringTypeW(CT_CTYPE3, &wch, 1, &ctype))
1461     {
1462         WARN("GetStringTypeW failed on %x\n", ch);
1463         return 0;
1464     }
1465     return ((ctype & C3_SYMBOL) != 0);
1466 }
1467
1468 /*********************************************************************
1469  *              _ismbcalnum (MSVCRT.@)
1470  */
1471 int CDECL _ismbcalnum(unsigned int ch)
1472 {
1473     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1474     return (get_char_typeW( wch ) & (C1_ALPHA | C1_DIGIT));
1475 }
1476
1477 /*********************************************************************
1478  *              _ismbcspace (MSVCRT.@)
1479  */
1480 int CDECL _ismbcspace(unsigned int ch)
1481 {
1482     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1483     return (get_char_typeW( wch ) & C1_SPACE);
1484 }
1485
1486 /*********************************************************************
1487  *              _ismbcprint (MSVCRT.@)
1488  */
1489 int CDECL _ismbcprint(unsigned int ch)
1490 {
1491     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1492     return (get_char_typeW( wch ) & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA | C1_SPACE));
1493 }
1494
1495 /*********************************************************************
1496  *              _ismbcpunct(MSVCRT.@)
1497  */
1498 int CDECL _ismbcpunct(unsigned int ch)
1499 {
1500     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1501     return (get_char_typeW( wch ) & C1_PUNCT);
1502 }
1503
1504 /*********************************************************************
1505  *              _ismbchira(MSVCRT.@)
1506  */
1507 int CDECL _ismbchira(unsigned int c)
1508 {
1509   if(get_mbcinfo()->mbcodepage == 932)
1510   {
1511     /* Japanese/Hiragana, CP 932 */
1512     return (c >= 0x829f && c <= 0x82f1);
1513   }
1514   return 0;
1515 }
1516
1517 /*********************************************************************
1518  *              _ismbckata(MSVCRT.@)
1519  */
1520 int CDECL _ismbckata(unsigned int c)
1521 {
1522   if(get_mbcinfo()->mbcodepage == 932)
1523   {
1524     /* Japanese/Katakana, CP 932 */
1525     return (c >= 0x8340 && c <= 0x8396 && c != 0x837f);
1526   }
1527   return 0;
1528 }
1529
1530
1531 /*********************************************************************
1532  *              _ismbblead_l(MSVCRT.@)
1533  */
1534 int CDECL _ismbblead_l(unsigned int c, MSVCRT__locale_t locale)
1535 {
1536     MSVCRT_pthreadmbcinfo mbcinfo;
1537
1538     if(!locale)
1539         mbcinfo = get_mbcinfo();
1540     else
1541         mbcinfo = locale->mbcinfo;
1542
1543     return (mbcinfo->mbctype[(c&0xff) + 1] & _M1) != 0;
1544 }
1545
1546 /*********************************************************************
1547  *              _ismbblead(MSVCRT.@)
1548  */
1549 int CDECL _ismbblead(unsigned int c)
1550 {
1551     return _ismbblead_l(c, NULL);
1552 }
1553
1554 /*********************************************************************
1555  *              _ismbbtrail_l(MSVCRT.@)
1556  */
1557 int CDECL _ismbbtrail_l(unsigned int c, MSVCRT__locale_t locale)
1558 {
1559     MSVCRT_pthreadmbcinfo mbcinfo;
1560
1561     if(!locale)
1562         mbcinfo = get_mbcinfo();
1563     else
1564         mbcinfo = locale->mbcinfo;
1565
1566     return (mbcinfo->mbctype[(c&0xff) + 1] & _M2) != 0;
1567 }
1568
1569 /*********************************************************************
1570  *              _ismbbtrail(MSVCRT.@)
1571  */
1572 int CDECL _ismbbtrail(unsigned int c)
1573 {
1574     return _ismbbtrail_l(c, NULL);
1575 }
1576
1577 /*********************************************************************
1578  *              _ismbclegal_l(MSVCRT.@)
1579  */
1580 int CDECL _ismbclegal_l(unsigned int c, MSVCRT__locale_t locale)
1581 {
1582     return _ismbblead_l(HIBYTE(c), locale) && _ismbbtrail_l(LOBYTE(c), locale);
1583 }
1584
1585 /*********************************************************************
1586  *              _ismbclegal(MSVCRT.@)
1587  */
1588 int CDECL _ismbclegal(unsigned int c)
1589 {
1590     return _ismbclegal_l(c, NULL);
1591 }
1592
1593 /*********************************************************************
1594  *              _ismbslead(MSVCRT.@)
1595  */
1596 int CDECL _ismbslead(const unsigned char* start, const unsigned char* str)
1597 {
1598   int lead = 0;
1599
1600   if(!get_mbcinfo()->ismbcodepage)
1601     return 0;
1602
1603   /* Lead bytes can also be trail bytes so we need to analyse the string
1604    */
1605   while (start <= str)
1606   {
1607     if (!*start)
1608       return 0;
1609     lead = !lead && _ismbblead(*start);
1610     start++;
1611   }
1612
1613   return lead ? -1 : 0;
1614 }
1615
1616 /*********************************************************************
1617  *              _ismbstrail(MSVCRT.@)
1618  */
1619 int CDECL _ismbstrail(const unsigned char* start, const unsigned char* str)
1620 {
1621   /* Note: this function doesn't check _ismbbtrail */
1622   if ((str > start) && _ismbslead(start, str-1))
1623     return -1;
1624   else
1625     return 0;
1626 }
1627
1628 /*********************************************************************
1629  *              _mbsbtype (MSVCRT.@)
1630  */
1631 int CDECL _mbsbtype(const unsigned char *str, MSVCRT_size_t count)
1632 {
1633   int lead = 0;
1634   const unsigned char *end = str + count;
1635
1636   /* Lead bytes can also be trail bytes so we need to analyse the string.
1637    * Also we must return _MBC_ILLEGAL for chars past the end of the string
1638    */
1639   while (str < end) /* Note: we skip the last byte - will check after the loop */
1640   {
1641     if (!*str)
1642       return _MBC_ILLEGAL;
1643     lead = get_mbcinfo()->ismbcodepage && !lead && _ismbblead(*str);
1644     str++;
1645   }
1646
1647   if (lead)
1648     if (_ismbbtrail(*str))
1649       return _MBC_TRAIL;
1650     else
1651       return _MBC_ILLEGAL;
1652   else
1653     if (_ismbblead(*str))
1654       return _MBC_LEAD;
1655     else
1656       return _MBC_SINGLE;
1657 }
1658
1659 /*********************************************************************
1660  *              _mbsset(MSVCRT.@)
1661  */
1662 unsigned char* CDECL _mbsset(unsigned char* str, unsigned int c)
1663 {
1664   unsigned char* ret = str;
1665
1666   if(!get_mbcinfo()->ismbcodepage || c < 256)
1667     return u__strset(str, c); /* ASCII CP or SB char */
1668
1669   c &= 0xffff; /* Strip high bits */
1670
1671   while(str[0] && str[1])
1672   {
1673     *str++ = c >> 8;
1674     *str++ = c & 0xff;
1675   }
1676   if(str[0])
1677     str[0] = '\0'; /* FIXME: OK to shorten? */
1678
1679   return ret;
1680 }
1681
1682 /*********************************************************************
1683  *              _mbsnbset(MSVCRT.@)
1684  */
1685 unsigned char* CDECL _mbsnbset(unsigned char *str, unsigned int c, MSVCRT_size_t len)
1686 {
1687     unsigned char *ret = str;
1688
1689     if(!len)
1690         return ret;
1691
1692     if(!get_mbcinfo()->ismbcodepage || c < 256)
1693         return u__strnset(str, c, len); /* ASCII CP or SB char */
1694
1695     c &= 0xffff; /* Strip high bits */
1696
1697     while(str[0] && str[1] && (len > 1))
1698     {
1699         *str++ = c >> 8;
1700         len--;
1701         *str++ = c & 0xff;
1702         len--;
1703     }
1704     if(len && str[0]) {
1705         /* as per msdn pad with a blank character */
1706         str[0] = ' ';
1707     }
1708
1709     return ret;
1710 }
1711
1712 /*********************************************************************
1713  *              _mbsnset(MSVCRT.@)
1714  */
1715 unsigned char* CDECL _mbsnset(unsigned char* str, unsigned int c, MSVCRT_size_t len)
1716 {
1717   unsigned char *ret = str;
1718
1719   if(!len)
1720     return ret;
1721
1722   if(!get_mbcinfo()->ismbcodepage || c < 256)
1723     return u__strnset(str, c, len); /* ASCII CP or SB char */
1724
1725   c &= 0xffff; /* Strip high bits */
1726
1727   while(str[0] && str[1] && len--)
1728   {
1729     *str++ = c >> 8;
1730     *str++ = c & 0xff;
1731   }
1732   if(len && str[0])
1733     str[0] = '\0'; /* FIXME: OK to shorten? */
1734
1735   return ret;
1736 }
1737
1738 /*********************************************************************
1739  *              _mbsnccnt(MSVCRT.@)
1740  * 'c' is for 'character'.
1741  */
1742 MSVCRT_size_t CDECL _mbsnccnt(const unsigned char* str, MSVCRT_size_t len)
1743 {
1744   MSVCRT_size_t ret;
1745   if(get_mbcinfo()->ismbcodepage)
1746   {
1747     ret=0;
1748     while(*str && len-- > 0)
1749     {
1750       if(_ismbblead(*str))
1751       {
1752         if (!len)
1753           break;
1754         len--;
1755         str++;
1756       }
1757       str++;
1758       ret++;
1759     }
1760     return ret;
1761   }
1762   ret=u_strlen(str);
1763   return min(ret, len); /* ASCII CP */
1764 }
1765
1766 /*********************************************************************
1767  *              _mbsnbcnt(MSVCRT.@)
1768  * 'b' is for byte count.
1769  */
1770 MSVCRT_size_t CDECL _mbsnbcnt(const unsigned char* str, MSVCRT_size_t len)
1771 {
1772   MSVCRT_size_t ret;
1773   if(get_mbcinfo()->ismbcodepage)
1774   {
1775     const unsigned char* xstr = str;
1776     while(*xstr && len-- > 0)
1777     {
1778       if (_ismbblead(*xstr++))
1779         xstr++;
1780     }
1781     return xstr-str;
1782   }
1783   ret=u_strlen(str);
1784   return min(ret, len); /* ASCII CP */
1785 }
1786
1787 /*********************************************************************
1788  *              _mbsnbcat(MSVCRT.@)
1789  */
1790 unsigned char* CDECL _mbsnbcat(unsigned char* dst, const unsigned char* src, MSVCRT_size_t len)
1791 {
1792     if(get_mbcinfo()->ismbcodepage)
1793     {
1794         unsigned char *res = dst;
1795         while (*dst) {
1796             if (_ismbblead(*dst++)) {
1797                 if (*dst) {
1798                     dst++;
1799                 } else {
1800                     /* as per msdn overwrite the lead byte in front of '\0' */
1801                     dst--;
1802                     break;
1803                 }
1804             }
1805         }
1806         while (*src && len--) *dst++ = *src++;
1807         *dst = '\0';
1808         return res;
1809     }
1810     return u_strncat(dst, src, len); /* ASCII CP */
1811 }
1812
1813 int CDECL _mbsnbcat_s(unsigned char *dst, MSVCRT_size_t size, const unsigned char *src, MSVCRT_size_t len)
1814 {
1815     unsigned char *ptr = dst;
1816     MSVCRT_size_t i;
1817
1818     if (!dst && !size && !src && !len)
1819         return 0;
1820
1821     if (!dst || !size || !src)
1822     {
1823         if (dst && size)
1824             *dst = '\0';
1825
1826         *MSVCRT__errno() = MSVCRT_EINVAL;
1827         return MSVCRT_EINVAL;
1828     }
1829
1830     /* Find the null terminator of the destination buffer. */
1831     while (size && *ptr)
1832         size--, ptr++;
1833
1834     if (!size)
1835     {
1836         *dst = '\0';
1837         *MSVCRT__errno() = MSVCRT_EINVAL;
1838         return MSVCRT_EINVAL;
1839     }
1840
1841     /* If necessary, check that the character preceding the null terminator is
1842      * a lead byte and move the pointer back by one for later overwrite. */
1843     if (ptr != dst && get_mbcinfo()->ismbcodepage && _ismbblead(*(ptr - 1)))
1844         size++, ptr--;
1845
1846     for (i = 0; *src && i < len; i++)
1847     {
1848         *ptr++ = *src++;
1849         size--;
1850
1851         if (!size)
1852         {
1853             *dst = '\0';
1854             *MSVCRT__errno() = MSVCRT_ERANGE;
1855             return MSVCRT_ERANGE;
1856         }
1857     }
1858
1859     *ptr = '\0';
1860     return 0;
1861 }
1862
1863 /*********************************************************************
1864  *              _mbsncat(MSVCRT.@)
1865  */
1866 unsigned char* CDECL _mbsncat(unsigned char* dst, const unsigned char* src, MSVCRT_size_t len)
1867 {
1868   if(get_mbcinfo()->ismbcodepage)
1869   {
1870     unsigned char *res = dst;
1871     while (*dst)
1872     {
1873       if (_ismbblead(*dst++))
1874         dst++;
1875     }
1876     while (*src && len--)
1877     {
1878       *dst++ = *src;
1879       if(_ismbblead(*src++))
1880         *dst++ = *src++;
1881     }
1882     *dst = '\0';
1883     return res;
1884   }
1885   return u_strncat(dst, src, len); /* ASCII CP */
1886 }
1887
1888
1889 /*********************************************************************
1890  *              _mbslwr(MSVCRT.@)
1891  */
1892 unsigned char* CDECL _mbslwr(unsigned char* s)
1893 {
1894   unsigned char *ret = s;
1895   if (!s)
1896     return NULL;
1897   if (get_mbcinfo()->ismbcodepage)
1898   {
1899     unsigned int c;
1900     while (*s)
1901     {
1902       c = _mbctolower(_mbsnextc(s));
1903       /* Note that I assume that the size of the character is unchanged */
1904       if (c > 255)
1905       {
1906           *s++=(c>>8);
1907           c=c & 0xff;
1908       }
1909       *s++=c;
1910     }
1911   }
1912   else for ( ; *s; s++) *s = tolower(*s);
1913   return ret;
1914 }
1915
1916
1917 /*********************************************************************
1918  *              _mbslwr_s(MSVCRT.@)
1919  */
1920 int CDECL _mbslwr_s(unsigned char* s, MSVCRT_size_t len)
1921 {
1922   if (!s && !len)
1923   {
1924     return 0;
1925   }
1926   else if (!s || !len)
1927   {
1928     *MSVCRT__errno() = MSVCRT_EINVAL;
1929     return MSVCRT_EINVAL;
1930   }
1931   if (get_mbcinfo()->ismbcodepage)
1932   {
1933     unsigned int c;
1934     for ( ; *s && len > 0; len--)
1935     {
1936       c = _mbctolower(_mbsnextc(s));
1937       /* Note that I assume that the size of the character is unchanged */
1938       if (c > 255)
1939       {
1940           *s++=(c>>8);
1941           c=c & 0xff;
1942       }
1943       *s++=c;
1944     }
1945   }
1946   else for ( ; *s && len > 0; s++, len--) *s = tolower(*s);
1947   if (*s)
1948   {
1949     *s = '\0';
1950     *MSVCRT__errno() = MSVCRT_EINVAL;
1951     return MSVCRT_EINVAL;
1952   }
1953   return 0;
1954 }
1955
1956
1957 /*********************************************************************
1958  *              _mbsupr(MSVCRT.@)
1959  */
1960 unsigned char* CDECL _mbsupr(unsigned char* s)
1961 {
1962   unsigned char *ret = s;
1963   if (!s)
1964     return NULL;
1965   if (get_mbcinfo()->ismbcodepage)
1966   {
1967     unsigned int c;
1968     while (*s)
1969     {
1970       c = _mbctoupper(_mbsnextc(s));
1971       /* Note that I assume that the size of the character is unchanged */
1972       if (c > 255)
1973       {
1974           *s++=(c>>8);
1975           c=c & 0xff;
1976       }
1977       *s++=c;
1978     }
1979   }
1980   else for ( ; *s; s++) *s = toupper(*s);
1981   return ret;
1982 }
1983
1984
1985 /*********************************************************************
1986  *              _mbsupr_s(MSVCRT.@)
1987  */
1988 int CDECL _mbsupr_s(unsigned char* s, MSVCRT_size_t len)
1989 {
1990   if (!s && !len)
1991   {
1992     return 0;
1993   }
1994   else if (!s || !len)
1995   {
1996     *MSVCRT__errno() = MSVCRT_EINVAL;
1997     return MSVCRT_EINVAL;
1998   }
1999   if (get_mbcinfo()->ismbcodepage)
2000   {
2001     unsigned int c;
2002     for ( ; *s && len > 0; len--)
2003     {
2004       c = _mbctoupper(_mbsnextc(s));
2005       /* Note that I assume that the size of the character is unchanged */
2006       if (c > 255)
2007       {
2008           *s++=(c>>8);
2009           c=c & 0xff;
2010       }
2011       *s++=c;
2012     }
2013   }
2014   else for ( ; *s && len > 0; s++, len--) *s = toupper(*s);
2015   if (*s)
2016   {
2017     *s = '\0';
2018     *MSVCRT__errno() = MSVCRT_EINVAL;
2019     return MSVCRT_EINVAL;
2020   }
2021   return 0;
2022 }
2023
2024
2025 /*********************************************************************
2026  *              _mbsspn (MSVCRT.@)
2027  */
2028 MSVCRT_size_t CDECL _mbsspn(const unsigned char* string, const unsigned char* set)
2029 {
2030     const unsigned char *p, *q;
2031
2032     for (p = string; *p; p++)
2033     {
2034         if (_ismbblead(*p))
2035         {
2036             for (q = set; *q; q += 2)
2037             {
2038                 if (!q[1])
2039                     break;
2040                 if ((*p == *q) &&  (p[1] == q[1]))
2041                     break;
2042             }
2043             if (!q[0] || !q[1]) break;
2044         }
2045         else
2046         {
2047             for (q = set; *q; q++)
2048                 if (*p == *q)
2049                     break;
2050             if (!*q) break;
2051         }
2052     }
2053     return p - string;
2054 }
2055
2056 /*********************************************************************
2057  *              _mbsspnp (MSVCRT.@)
2058  */
2059 unsigned char* CDECL _mbsspnp(const unsigned char* string, const unsigned char* set)
2060 {
2061     const unsigned char *p, *q;
2062
2063     for (p = string; *p; p++)
2064     {
2065         if (_ismbblead(*p))
2066         {
2067             for (q = set; *q; q += 2)
2068             {
2069                 if (!q[1])
2070                     break;
2071                 if ((*p == *q) &&  (p[1] == q[1]))
2072                     break;
2073             }
2074             if (!q[0] || !q[1]) break;
2075         }
2076         else
2077         {
2078             for (q = set; *q; q++)
2079                 if (*p == *q)
2080                     break;
2081             if (!*q) break;
2082         }
2083     }
2084     if (*p == '\0')
2085         return NULL;
2086     return (unsigned char *)p;
2087 }
2088
2089 /*********************************************************************
2090  *              _mbscspn(MSVCRT.@)
2091  */
2092 MSVCRT_size_t CDECL _mbscspn(const unsigned char* str, const unsigned char* cmp)
2093 {
2094   if (get_mbcinfo()->ismbcodepage)
2095     FIXME("don't handle double character case\n");
2096   return u_strcspn(str, cmp);
2097 }
2098
2099 /*********************************************************************
2100  *              _mbsrev (MSVCRT.@)
2101  */
2102 unsigned char* CDECL _mbsrev(unsigned char* str)
2103 {
2104     int i, len = _mbslen(str);
2105     unsigned char *p, *temp=MSVCRT_malloc(len*2);
2106
2107     if(!temp)
2108         return str;
2109
2110     /* unpack multibyte string to temp buffer */
2111     p=str;
2112     for(i=0; i<len; i++)
2113     {
2114         if (_ismbblead(*p))
2115         {
2116             temp[i*2]=*p++;
2117             temp[i*2+1]=*p++;
2118         }
2119         else
2120         {
2121             temp[i*2]=*p++;
2122             temp[i*2+1]=0;
2123         }
2124     }
2125
2126     /* repack it in the reverse order */
2127     p=str;
2128     for(i=len-1; i>=0; i--)
2129     {
2130         if(_ismbblead(temp[i*2]))
2131         {
2132             *p++=temp[i*2];
2133             *p++=temp[i*2+1];
2134         }
2135         else
2136         {
2137             *p++=temp[i*2];
2138         }
2139     }
2140
2141     MSVCRT_free(temp);
2142
2143     return str;
2144 }
2145
2146 /*********************************************************************
2147  *              _mbspbrk (MSVCRT.@)
2148  */
2149 unsigned char* CDECL _mbspbrk(const unsigned char* str, const unsigned char* accept)
2150 {
2151     const unsigned char* p;
2152
2153     while(*str)
2154     {
2155         for(p = accept; *p; p += (_ismbblead(*p)?2:1) )
2156         {
2157             if (*p == *str)
2158                 if( !_ismbblead(*p) || ( *(p+1) == *(str+1) ) )
2159                      return (unsigned char*)str;
2160         }
2161         str += (_ismbblead(*str)?2:1);
2162     }
2163     return NULL;
2164 }
2165
2166
2167 /*
2168  * Functions depending on locale codepage
2169  */
2170
2171 /*********************************************************************
2172  *              mblen(MSVCRT.@)
2173  * REMARKS
2174  *  Unlike most of the multibyte string functions this function uses
2175  *  the locale codepage, not the codepage set by _setmbcp
2176  */
2177 int CDECL MSVCRT_mblen(const char* str, MSVCRT_size_t size)
2178 {
2179   if (str && *str && size)
2180   {
2181     if(get_locinfo()->mb_cur_max == 1)
2182       return 1; /* ASCII CP */
2183
2184     return !MSVCRT_isleadbyte((unsigned char)*str) ? 1 : (size>1 ? 2 : -1);
2185   }
2186   return 0;
2187 }
2188
2189 /*********************************************************************
2190  *              mbrlen(MSVCRT.@)
2191  */
2192 MSVCRT_size_t CDECL MSVCRT_mbrlen(const char *str, MSVCRT_size_t len, MSVCRT_mbstate_t *state)
2193 {
2194     MSVCRT_mbstate_t s = (state ? *state : 0);
2195     MSVCRT_size_t ret;
2196
2197     if(!len || !str || !*str)
2198         return 0;
2199
2200     if(get_locinfo()->mb_cur_max == 1) {
2201         return 1;
2202     }else if(!s && MSVCRT_isleadbyte((unsigned char)*str)) {
2203         if(len == 1) {
2204             s = (unsigned char)*str;
2205             ret = -2;
2206         }else {
2207             ret = 2;
2208         }
2209     }else if(!s) {
2210         ret = 1;
2211     }else {
2212         s = 0;
2213         ret = 2;
2214     }
2215
2216     if(state)
2217         *state = s;
2218     return ret;
2219 }
2220
2221 /*********************************************************************
2222  *              _mbstrlen_l(MSVCRT.@)
2223  */
2224 MSVCRT_size_t CDECL _mbstrlen_l(const char* str, MSVCRT__locale_t locale)
2225 {
2226     MSVCRT_pthreadlocinfo locinfo;
2227
2228     if(!locale)
2229         locinfo = get_locinfo();
2230     else
2231         locinfo = locale->locinfo;
2232
2233     if(locinfo->mb_cur_max > 1) {
2234         MSVCRT_size_t len;
2235         len = MultiByteToWideChar(locinfo->lc_codepage, MB_ERR_INVALID_CHARS,
2236                                   str, -1, NULL, 0);
2237         if (!len) {
2238             *MSVCRT__errno() = MSVCRT_EILSEQ;
2239             return -1;
2240         }
2241         return len - 1;
2242     }
2243
2244     return strlen(str);
2245 }
2246
2247 /*********************************************************************
2248  *              _mbstrlen(MSVCRT.@)
2249  */
2250 MSVCRT_size_t CDECL _mbstrlen(const char* str)
2251 {
2252     return _mbstrlen_l(str, NULL);
2253 }
2254
2255 /*********************************************************************
2256  *              _mbtowc_l(MSVCRT.@)
2257  */
2258 int CDECL MSVCRT_mbtowc_l(MSVCRT_wchar_t *dst, const char* str, MSVCRT_size_t n, MSVCRT__locale_t locale)
2259 {
2260     MSVCRT_pthreadlocinfo locinfo;
2261     MSVCRT_wchar_t tmpdst = '\0';
2262
2263     if(!locale)
2264         locinfo = get_locinfo();
2265     else
2266         locinfo = locale->locinfo;
2267
2268     if(n <= 0 || !str)
2269         return 0;
2270
2271     if(!*str) {
2272         if(dst) *dst = 0;
2273         return 0;
2274     }
2275
2276     if(!locinfo->lc_codepage) {
2277         if(dst) *dst = (unsigned char)*str;
2278         return 1;
2279     }
2280     if(n>=2 && MSVCRT__isleadbyte_l((unsigned char)*str, locale)) {
2281         if(!MultiByteToWideChar(locinfo->lc_codepage, 0, str, 2, &tmpdst, 1))
2282             return -1;
2283         if(dst) *dst = tmpdst;
2284         return 2;
2285     }
2286     if(!MultiByteToWideChar(locinfo->lc_codepage, 0, str, 1, &tmpdst, 1))
2287         return -1;
2288     if(dst) *dst = tmpdst;
2289     return 1;
2290 }
2291
2292 /*********************************************************************
2293  *              mbtowc(MSVCRT.@)
2294  */
2295 int CDECL MSVCRT_mbtowc(MSVCRT_wchar_t *dst, const char* str, MSVCRT_size_t n)
2296 {
2297     return MSVCRT_mbtowc_l(dst, str, n, NULL);
2298 }
2299
2300 /*********************************************************************
2301  *              mbrtowc(MSVCRT.@)
2302  */
2303 MSVCRT_size_t CDECL MSVCRT_mbrtowc(MSVCRT_wchar_t *dst, const char *str,
2304         MSVCRT_size_t n, MSVCRT_mbstate_t *state)
2305 {
2306     MSVCRT_pthreadlocinfo locinfo = get_locinfo();
2307     MSVCRT_mbstate_t s = (state ? *state : 0);
2308     char tmpstr[2];
2309     int len = 0;
2310
2311     if(dst)
2312         *dst = 0;
2313
2314     if(!n || !str || !*str)
2315         return 0;
2316
2317     if(locinfo->mb_cur_max == 1) {
2318         tmpstr[len++] = *str;
2319     }else if(!s && MSVCRT_isleadbyte((unsigned char)*str)) {
2320         if(n == 1) {
2321             s = (unsigned char)*str;
2322             len = -2;
2323         }else {
2324             tmpstr[0] = str[0];
2325             tmpstr[1] = str[1];
2326             len = 2;
2327         }
2328     }else if(!s) {
2329         tmpstr[len++] = *str;
2330     }else {
2331         tmpstr[0] = s;
2332         tmpstr[1] = *str;
2333         len = 2;
2334         s = 0;
2335     }
2336
2337     if(len > 0) {
2338         if(!MultiByteToWideChar(locinfo->lc_codepage, 0, tmpstr, len, dst, dst ? 1 : 0))
2339             len = -1;
2340     }
2341
2342     if(state)
2343         *state = s;
2344     return len;
2345 }
2346
2347 /*********************************************************************
2348  *              _mbstowcs_l(MSVCRT.@)
2349  */
2350 MSVCRT_size_t CDECL MSVCRT__mbstowcs_l(MSVCRT_wchar_t *wcstr, const char *mbstr,
2351         MSVCRT_size_t count, MSVCRT__locale_t locale)
2352 {
2353     MSVCRT_pthreadlocinfo locinfo;
2354     MSVCRT_size_t i, size;
2355
2356     if(!mbstr) {
2357         *MSVCRT__errno() = MSVCRT_EINVAL;
2358         return -1;
2359     }
2360
2361     if(!locale)
2362         locinfo = get_locinfo();
2363     else
2364         locinfo = locale->locinfo;
2365
2366     if(!locinfo->lc_codepage) {
2367         if(!wcstr)
2368             return strlen(mbstr);
2369
2370         for(i=0; i<count; i++) {
2371             wcstr[i] = (unsigned char)mbstr[i];
2372             if(!wcstr[i]) break;
2373         }
2374         return i;
2375     }
2376
2377     /* Ignore count parameter */
2378     if(!wcstr)
2379         return MultiByteToWideChar(locinfo->lc_codepage, 0, mbstr, -1, NULL, 0)-1;
2380
2381     for(i=0, size=0; i<count; i++) {
2382         if(mbstr[size] == '\0')
2383             break;
2384
2385         size += (MSVCRT__isleadbyte_l((unsigned char)mbstr[size], locale) ? 2 : 1);
2386     }
2387
2388     if(size) {
2389         size = MultiByteToWideChar(locinfo->lc_codepage, 0,
2390                                    mbstr, size, wcstr, count);
2391         if(!size) {
2392             if(count) wcstr[0] = '\0';
2393             *MSVCRT__errno() = MSVCRT_EILSEQ;
2394             return -1;
2395         }
2396     }
2397
2398     if(size<count && wcstr)
2399         wcstr[size] = '\0';
2400
2401     return size;
2402 }
2403
2404 /*********************************************************************
2405  *              mbstowcs(MSVCRT.@)
2406  */
2407 MSVCRT_size_t CDECL MSVCRT_mbstowcs(MSVCRT_wchar_t *wcstr,
2408         const char *mbstr, MSVCRT_size_t count)
2409 {
2410     return MSVCRT__mbstowcs_l(wcstr, mbstr, count, NULL);
2411 }
2412
2413 /*********************************************************************
2414  *              _mbstowcs_s_l(MSVCRT.@)
2415  */
2416 int CDECL MSVCRT__mbstowcs_s_l(MSVCRT_size_t *ret, MSVCRT_wchar_t *wcstr,
2417         MSVCRT_size_t size, const char *mbstr,
2418         MSVCRT_size_t count, MSVCRT__locale_t locale)
2419 {
2420     MSVCRT_size_t conv;
2421
2422     if(!wcstr && !size) {
2423         conv = MSVCRT__mbstowcs_l(NULL, mbstr, 0, locale);
2424         if(ret)
2425             *ret = conv+1;
2426         return 0;
2427     }
2428
2429     if (!MSVCRT_CHECK_PMT(wcstr != NULL)) return MSVCRT_EINVAL;
2430     if (!MSVCRT_CHECK_PMT(mbstr != NULL)) {
2431         if(size) wcstr[0] = '\0';
2432         return MSVCRT_EINVAL;
2433     }
2434
2435     if(count==MSVCRT__TRUNCATE || size<count)
2436         conv = size;
2437     else
2438         conv = count;
2439
2440     conv = MSVCRT__mbstowcs_l(wcstr, mbstr, conv, locale);
2441     if(conv<size)
2442         wcstr[conv++] = '\0';
2443     else if(conv==size && (count==MSVCRT__TRUNCATE || wcstr[conv-1]=='\0'))
2444         wcstr[conv-1] = '\0';
2445     else {
2446         MSVCRT_INVALID_PMT("wcstr[size] is too small", MSVCRT_ERANGE);
2447         if(size)
2448             wcstr[0] = '\0';
2449         return MSVCRT_ERANGE;
2450     }
2451
2452     if(ret)
2453         *ret = conv;
2454     return 0;
2455 }
2456
2457 /*********************************************************************
2458  *              mbstowcs_s(MSVCRT.@)
2459  */
2460 int CDECL MSVCRT__mbstowcs_s(MSVCRT_size_t *ret, MSVCRT_wchar_t *wcstr,
2461         MSVCRT_size_t size, const char *mbstr, MSVCRT_size_t count)
2462 {
2463     return MSVCRT__mbstowcs_s_l(ret, wcstr, size, mbstr, count, NULL);
2464 }
2465
2466 /*********************************************************************
2467  *              mbsrtowcs(MSVCRT.@)
2468  */
2469 MSVCRT_size_t CDECL MSVCRT_mbsrtowcs(MSVCRT_wchar_t *wcstr,
2470         const char **pmbstr, MSVCRT_size_t count, MSVCRT_mbstate_t *state)
2471 {
2472     MSVCRT_mbstate_t s = (state ? *state : 0);
2473     MSVCRT_wchar_t tmpdst;
2474     MSVCRT_size_t ret = 0;
2475     const char *p;
2476
2477     if(!MSVCRT_CHECK_PMT(pmbstr != NULL))
2478         return -1;
2479
2480     p = *pmbstr;
2481     while(!wcstr || count>ret) {
2482         int ch_len = MSVCRT_mbrtowc(&tmpdst, p, 2, &s);
2483         if(wcstr)
2484             wcstr[ret] = tmpdst;
2485
2486         if(ch_len < 0) {
2487             return -1;
2488         }else if(ch_len == 0) {
2489             if(wcstr) *pmbstr = NULL;
2490             return ret;
2491         }
2492
2493         p += ch_len;
2494         ret++;
2495     }
2496
2497     if(wcstr) *pmbstr = p;
2498     return ret;
2499 }
2500
2501 /*********************************************************************
2502  *              mbsrtowcs_s(MSVCRT.@)
2503  */
2504 int CDECL MSVCRT_mbsrtowcs_s(MSVCRT_size_t *ret, MSVCRT_wchar_t *wcstr, MSVCRT_size_t len,
2505         const char **mbstr, MSVCRT_size_t count, MSVCRT_mbstate_t *state)
2506 {
2507     MSVCRT_size_t tmp;
2508
2509     if(!ret) ret = &tmp;
2510     if(!MSVCRT_CHECK_PMT(!!wcstr == !!len)) {
2511         *ret = -1;
2512         return MSVCRT_EINVAL;
2513     }
2514
2515     *ret = MSVCRT_mbsrtowcs(wcstr, mbstr, count>len ? len : count, state);
2516     if(*ret == -1) {
2517         if(wcstr) *wcstr = 0;
2518         return *MSVCRT__errno();
2519     }
2520     (*ret)++;
2521     if(*ret > len) {
2522         /* no place for terminating '\0' */
2523         if(wcstr) *wcstr = 0;
2524         return 0;
2525     }
2526     if(wcstr) wcstr[(*ret)-1] = 0;
2527     return 0;
2528 }
2529
2530 /*********************************************************************
2531  *              _mbctohira (MSVCRT.@)
2532  *
2533  *              Converts a sjis katakana character to hiragana.
2534  */
2535 unsigned int CDECL _mbctohira(unsigned int c)
2536 {
2537     if(_ismbckata(c) && c <= 0x8393)
2538         return (c - 0x8340 - (c >= 0x837f ? 1 : 0)) + 0x829f;
2539     return c;
2540 }
2541
2542 /*********************************************************************
2543  *              _mbctokata (MSVCRT.@)
2544  *
2545  *              Converts a sjis hiragana character to katakana.
2546  */
2547 unsigned int CDECL _mbctokata(unsigned int c)
2548 {
2549     if(_ismbchira(c))
2550         return (c - 0x829f) + 0x8340 + (c >= 0x82de ? 1 : 0);
2551     return c;
2552 }
2553
2554 /*********************************************************************
2555  *              _ismbcl0_l (MSVCRT.@)
2556  */
2557 int CDECL _ismbcl0_l(unsigned int c, MSVCRT__locale_t locale)
2558 {
2559     MSVCRT_pthreadmbcinfo mbcinfo;
2560
2561     if(!locale)
2562         mbcinfo = get_mbcinfo();
2563     else
2564         mbcinfo = locale->mbcinfo;
2565
2566     if(mbcinfo->mbcodepage == 932)
2567     {
2568         /* JIS non-Kanji */
2569         return _ismbclegal_l(c, locale) && c >= 0x8140 && c <= 0x889e;
2570     }
2571
2572     return 0;
2573 }
2574
2575 /*********************************************************************
2576  *              _ismbcl0 (MSVCRT.@)
2577  */
2578 int CDECL _ismbcl0(unsigned int c)
2579 {
2580     return _ismbcl0_l(c, NULL);
2581 }
2582
2583 /*********************************************************************
2584  *              _ismbcl1_l (MSVCRT.@)
2585  */
2586 int CDECL _ismbcl1_l(unsigned int c, MSVCRT__locale_t locale)
2587 {
2588     MSVCRT_pthreadmbcinfo mbcinfo;
2589
2590     if(!locale)
2591         mbcinfo = get_mbcinfo();
2592     else
2593         mbcinfo = locale->mbcinfo;
2594
2595     if(mbcinfo->mbcodepage == 932)
2596     {
2597         /* JIS level-1 */
2598         return _ismbclegal_l(c, locale) && c >= 0x889f && c <= 0x9872;
2599     }
2600
2601     return 0;
2602 }
2603
2604 /*********************************************************************
2605  *              _ismbcl1 (MSVCRT.@)
2606  */
2607 int CDECL _ismbcl1(unsigned int c)
2608 {
2609     return _ismbcl1_l(c, NULL);
2610 }
2611
2612 /*********************************************************************
2613  *              _ismbcl2_l (MSVCRT.@)
2614  */
2615 int CDECL _ismbcl2_l(unsigned int c, MSVCRT__locale_t locale)
2616 {
2617     MSVCRT_pthreadmbcinfo mbcinfo;
2618
2619     if(!locale)
2620         mbcinfo = get_mbcinfo();
2621     else
2622         mbcinfo = locale->mbcinfo;
2623
2624     if(mbcinfo->mbcodepage == 932)
2625     {
2626         /* JIS level-2 */
2627         return _ismbclegal_l(c, locale) && c >= 0x989f && c <= 0xeaa4;
2628     }
2629
2630     return 0;
2631 }
2632
2633 /*********************************************************************
2634  *              _ismbcl2 (MSVCRT.@)
2635  */
2636 int CDECL _ismbcl2(unsigned int c)
2637 {
2638     return _ismbcl2_l(c, NULL);
2639 }