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 #include <mbctype.h>
  29 #include <mbstring.h>
  30
  31 #include "msvcrt.h"
  32 #include "mtdll.h"
  33 #include "winnls.h"
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  37
  38 unsigned char MSVCRT_mbctype[257] = { 0 };
  39
  40 /* It seems that the data about valid trail bytes is not available from kernel32
  41  * so we have to store is here. The format is the same as for lead bytes in CPINFO */
  42 struct cp_extra_info_t
  43 {
  44     int cp;
  45     BYTE TrailBytes[MAX_LEADBYTES];
  46 };
  47
  48 static struct cp_extra_info_t g_cpextrainfo[] =
  49 {
  50     {932, {0x40, 0x7e, 0x80, 0xfc, 0, 0}},
  51     {936, {0x40, 0xfe, 0, 0}},
  52     {949, {0x41, 0xfe, 0, 0}},
  53     {950, {0x40, 0x7e, 0xa1, 0xfe, 0, 0}},
  54     {1361, {0x31, 0x7e, 0x81, 0xfe, 0, 0}},
  55     {20932, {1, 255, 0, 0}},  /* seems to give different results on different systems */
  56     {0, {1, 255, 0, 0}}       /* match all with FIXME */
  57 };
  58
  59 /* Maps cp932 single byte character to multi byte character */
  60 static const unsigned char mbbtombc_932[] = {
  61   0x40,0x49,0x68,0x94,0x90,0x93,0x95,0x66,0x69,0x6a,0x96,0x7b,0x43,0x7c,0x44,0x5e,
  62   0x4f,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x46,0x47,0x83,0x81,0x84,0x48,
  63   0x97,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,
  64   0x6f,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x6d,0x8f,0x6e,0x4f,0x76,
  65   0x77,0x78,0x79,0x6d,0x8f,0x6e,0x4f,0x51,0x65,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
  66   0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,0x95,0x50,
  67        0x42,0x75,0x76,0x41,0x45,0x92,0x40,0x42,0x44,0x46,0x48,0x83,0x85,0x87,0x62,
  68   0x5b,0x41,0x43,0x45,0x47,0x49,0x4a,0x4c,0x4e,0x50,0x52,0x54,0x56,0x58,0x5a,0x5c,
  69   0x5e,0x60,0x63,0x65,0x67,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x71,0x74,0x77,0x7a,0x7d,
  70   0x7e,0x80,0x81,0x82,0x84,0x86,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8f,0x93,0x4a,0x4b };
  71
  72 /* Maps multibyte cp932 punctuation marks to single byte equivalents */
  73 static const unsigned char mbctombb_932_punct[] = {
  74   0x20,0xa4,0xa1,0x2c,0x2e,0xa5,0x3a,0x3b,0x3f,0x21,0xde,0xdf,0x00,0x00,0x00,0x5e,
  75   0x7e,0x5f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x00,0x00,0x2f,0x00,
  76   0x00,0x00,0x7c,0x00,0x00,0x60,0x27,0x00,0x22,0x28,0x29,0x00,0x00,0x5b,0x5d,0x7b,
  77   0x7d,0x00,0x00,0x00,0x00,0xa2,0xa3,0x00,0x00,0x00,0x00,0x2b,0x2d,0x00,0x00,0x00,
  78   0x00,0x3d,0x00,0x3c,0x3e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5c,
  79   0x24,0x00,0x00,0x25,0x23,0x26,0x2a,0x40};
  80
  81 /* Maps multibyte cp932 hiragana/katakana to single-byte equivalents */
  82 static const unsigned char mbctombb_932_kana[] = {
  83   0xa7,0xb1,0xa8,0xb2,0xa9,0xb3,0xaa,0xb4,0xab,0xb5,0xb6,0xb6,0xb7,0xb7,0xb8,0xb8,
  84   0xb9,0xb9,0xba,0xba,0xbb,0xbb,0xbc,0xbc,0xbd,0xbd,0xbe,0xbe,0xbf,0xbf,0xc0,0xc0,
  85   0xc1,0xc1,0xaf,0xc2,0xc2,0xc3,0xc3,0xc4,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xca,
  86   0xca,0xcb,0xcb,0xcb,0xcc,0xcc,0xcc,0xcd,0xcd,0xcd,0xce,0xce,0xce,0xcf,0xd0,0xd1,
  87   0xd2,0xd3,0xac,0xd4,0xad,0xd5,0xae,0xd6,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdc,0xb2,
  88   0xb4,0xa6,0xdd,0xb3,0xb6,0xb9};
  89
  90 static wchar_t msvcrt_mbc_to_wc_l(unsigned int ch, _locale_t locale)
  91 {
  92     pthreadmbcinfo mbcinfo;
  93     wchar_t chW;
  94     char mbch[2];
  95     int n_chars;
  96
  97     if(locale)
  98         mbcinfo = locale->mbcinfo;
  99     else
 100         mbcinfo = get_mbcinfo();
 101
 102     if (ch <= 0xff) {
 103         mbch[0] = ch;
 104         n_chars = 1;
 105     } else {
 106         mbch[0] = (ch >> 8) & 0xff;
 107         mbch[1] = ch & 0xff;
 108         n_chars = 2;
 109     }
 110     if (!MultiByteToWideChar(mbcinfo->mbcodepage, 0, mbch, n_chars, &chW, 1))
 111     {
 112         WARN("MultiByteToWideChar failed on %x\n", ch);
 113         return 0;
 114     }
 115     return chW;
 116 }
 117
 118 static wchar_t msvcrt_mbc_to_wc(unsigned int ch)
 119 {
 120     return msvcrt_mbc_to_wc_l(ch, NULL);
 121 }
 122
 123 static inline size_t u_strlen( const unsigned char *str )
 124 {
 125   return strlen( (const char*) str );
 126 }
 127
 128 static inline unsigned char* u_strncat( unsigned char* dst, const unsigned char* src, size_t len )
 129 {
 130   return (unsigned char*)strncat( (char*)dst, (const char*)src, len);
 131 }
 132
 133 static inline int u_strcmp( const unsigned char *s1, const unsigned char *s2 )
 134 {
 135   return strcmp( (const char*)s1, (const char*)s2 );
 136 }
 137
 138 static inline int u_strcasecmp( const unsigned char *s1, const unsigned char *s2 )
 139 {
 140   return _stricmp( (const char*)s1, (const char*)s2 );
 141 }
 142
 143 static inline int u_strncmp( const unsigned char *s1, const unsigned char *s2, size_t len )
 144 {
 145   return strncmp( (const char*)s1, (const char*)s2, len );
 146 }
 147
 148 static inline int u_strncasecmp( const unsigned char *s1, const unsigned char *s2, size_t len )
 149 {
 150   return _strnicmp( (const char*)s1, (const char*)s2, len );
 151 }
 152
 153 static inline unsigned char *u_strchr( const unsigned char *s, unsigned char x )
 154 {
 155   return (unsigned char*) strchr( (const char*)s, x );
 156 }
 157
 158 static inline unsigned char *u_strrchr( const unsigned char *s, unsigned char x )
 159 {
 160   return (unsigned char*) strrchr( (const char*)s, x );
 161 }
 162
 163 static inline unsigned char *u__strset( unsigned char *s, unsigned char c )
 164 {
 165   return (unsigned char*) _strset( (char*)s, c);
 166 }
 167
 168 static inline unsigned char *u__strnset( unsigned char *s, unsigned char c, size_t len )
 169 {
 170   return (unsigned char*) _strnset( (char*)s, c, len );
 171 }
 172
 173 /*********************************************************************
 174  *              __p__mbctype (MSVCRT.@)
 175  */
 176 unsigned char* CDECL __p__mbctype(void)
 177 {
 178   return get_mbcinfo()->mbctype;
 179 }
 180
 181 /*********************************************************************
 182  *              __p___mb_cur_max(MSVCRT.@)
 183  */
 184 int* CDECL __p___mb_cur_max(void)
 185 {
 186   return &get_locinfo()->mb_cur_max;
 187 }
 188
 189 /*********************************************************************
 190  *              ___mb_cur_max_func(MSVCRT.@)
 191  */
 192 int CDECL ___mb_cur_max_func(void)
 193 {
 194   return get_locinfo()->mb_cur_max;
 195 }
 196
 197 #if _MSVCR_VER>=80
 198 /*********************************************************************
 199  *              ___mb_cur_max_l_func  (MSVCR80.@)
 200  */
 201 int CDECL ___mb_cur_max_l_func(_locale_t locale)
 202 {
 203   pthreadlocinfo locinfo;
 204
 205   if(!locale)
 206     locinfo = get_locinfo();
 207   else
 208     locinfo = locale->locinfo;
 209
 210   return locinfo->mb_cur_max;
 211 }
 212 #endif
 213
 214 threadmbcinfo* create_mbcinfo(int cp, LCID lcid, threadmbcinfo *old_mbcinfo)
 215 {
 216   threadmbcinfo *mbcinfo;
 217   int newcp;
 218   CPINFO cpi;
 219   BYTE *bytes;
 220   WORD chartypes[256];
 221   char bufA[256];
 222   WCHAR bufW[256], lowW[256], upW[256];
 223   int charcount, maxchar;
 224   int ret;
 225   int i;
 226
 227   if(old_mbcinfo && cp==old_mbcinfo->mbcodepage
 228           && (lcid==-1 || lcid==old_mbcinfo->mblcid)) {
 229     InterlockedIncrement(&old_mbcinfo->refcount);
 230     return old_mbcinfo;
 231   }
 232
 233   mbcinfo = malloc(sizeof(threadmbcinfo));
 234   if(!mbcinfo)
 235     return NULL;
 236   mbcinfo->refcount = 1;
 237
 238   switch (cp)
 239   {
 240     case _MB_CP_ANSI:
 241       newcp = GetACP();
 242       break;
 243     case _MB_CP_OEM:
 244       newcp = GetOEMCP();
 245       break;
 246     case _MB_CP_LOCALE:
 247       newcp = get_locinfo()->lc_codepage;
 248       if(newcp)
 249           break;
 250       /* fall through (C locale) */
 251     case _MB_CP_SBCS:
 252       newcp = 20127;   /* ASCII */
 253       break;
 254     default:
 255       newcp = cp;
 256       break;
 257   }
 258
 259   if(lcid == -1) {
 260     sprintf(bufA, ".%d", newcp);
 261     mbcinfo->mblcid = locale_to_LCID(bufA, NULL, NULL);
 262   } else {
 263     mbcinfo->mblcid = lcid;
 264   }
 265
 266   if(mbcinfo->mblcid == -1)
 267   {
 268     WARN("Can't assign LCID to codepage (%d)\n", mbcinfo->mblcid);
 269     mbcinfo->mblcid = 0;
 270   }
 271
 272   if (!GetCPInfo(newcp, &cpi))
 273   {
 274     WARN("Codepage %d not found\n", newcp);
 275     free(mbcinfo);
 276     return NULL;
 277   }
 278
 279   /* setup the _mbctype */
 280   memset(mbcinfo->mbctype, 0, sizeof(unsigned char[257]));
 281   memset(mbcinfo->mbcasemap, 0, sizeof(unsigned char[256]));
 282
 283   bytes = cpi.LeadByte;
 284   while (bytes[0] || bytes[1])
 285   {
 286     for (i = bytes[0]; i <= bytes[1]; i++)
 287       mbcinfo->mbctype[i + 1] |= _M1;
 288     bytes += 2;
 289   }
 290
 291   if (cpi.MaxCharSize == 2)
 292   {
 293     /* trail bytes not available through kernel32 but stored in a structure in msvcrt */
 294     struct cp_extra_info_t *cpextra = g_cpextrainfo;
 295
 296     mbcinfo->ismbcodepage = 1;
 297     while (TRUE)
 298     {
 299       if (cpextra->cp == 0 || cpextra->cp == newcp)
 300       {
 301         if (cpextra->cp == 0)
 302           FIXME("trail bytes data not available for DBCS codepage %d - assuming all bytes\n", newcp);
 303
 304         bytes = cpextra->TrailBytes;
 305         while (bytes[0] || bytes[1])
 306         {
 307           for (i = bytes[0]; i <= bytes[1]; i++)
 308             mbcinfo->mbctype[i + 1] |= _M2;
 309           bytes += 2;
 310         }
 311         break;
 312       }
 313       cpextra++;
 314     }
 315   }
 316   else
 317     mbcinfo->ismbcodepage = 0;
 318
 319   maxchar = (newcp == CP_UTF8) ? 128 : 256;
 320
 321   /* we can't use GetStringTypeA directly because we don't have a locale - only a code page
 322    */
 323   charcount = 0;
 324   for (i = 0; i < maxchar; i++)
 325     if (!(mbcinfo->mbctype[i + 1] & _M1))
 326       bufA[charcount++] = i;
 327
 328   ret = MultiByteToWideChar(newcp, 0, bufA, charcount, bufW, charcount);
 329   if (ret != charcount)
 330   {
 331     ERR("MultiByteToWideChar of chars failed for cp %d, ret=%d (exp %d), error=%ld\n",
 332             newcp, ret, charcount, GetLastError());
 333   }
 334
 335   GetStringTypeW(CT_CTYPE1, bufW, charcount, chartypes);
 336   LCMapStringW(mbcinfo->mblcid, LCMAP_LOWERCASE, bufW, charcount, lowW, charcount);
 337   LCMapStringW(mbcinfo->mblcid, LCMAP_UPPERCASE, bufW, charcount, upW, charcount);
 338
 339   charcount = 0;
 340   for (i = 0; i < maxchar; i++)
 341     if (!(mbcinfo->mbctype[i + 1] & _M1))
 342     {
 343       if (chartypes[charcount] & C1_UPPER)
 344       {
 345         mbcinfo->mbctype[i + 1] |= _SBUP;
 346         bufW[charcount] = lowW[charcount];
 347       }
 348       else if (chartypes[charcount] & C1_LOWER)
 349       {
 350         mbcinfo->mbctype[i + 1] |= _SBLOW;
 351         bufW[charcount] = upW[charcount];
 352       }
 353       charcount++;
 354     }
 355
 356   ret = WideCharToMultiByte(newcp, 0, bufW, charcount, bufA, charcount, NULL, NULL);
 357   if (ret != charcount)
 358   {
 359     ERR("WideCharToMultiByte failed for cp %d, ret=%d (exp %d), error=%ld\n",
 360             newcp, ret, charcount, GetLastError());
 361   }
 362
 363   charcount = 0;
 364   for (i = 0; i < maxchar; i++)
 365   {
 366     if(!(mbcinfo->mbctype[i + 1] & _M1))
 367     {
 368       if(mbcinfo->mbctype[i + 1] & (_SBUP | _SBLOW))
 369         mbcinfo->mbcasemap[i] = bufA[charcount];
 370       charcount++;
 371     }
 372   }
 373
 374   if (newcp == 932)   /* CP932 only - set _MP and _MS */
 375   {
 376     /* On Windows it's possible to calculate the _MP and _MS from CT_CTYPE1
 377      * and CT_CTYPE3. But as of Wine 0.9.43 we return wrong values what makes
 378      * it hard. As this is set only for codepage 932 we hardcode it what gives
 379      * also faster execution.
 380      */
 381     for (i = 161; i <= 165; i++)
 382       mbcinfo->mbctype[i + 1] |= _MP;
 383     for (i = 166; i <= 223; i++)
 384       mbcinfo->mbctype[i + 1] |= _MS;
 385   }
 386
 387   mbcinfo->mbcodepage = newcp;
 388   return mbcinfo;
 389 }
 390
 391 /*********************************************************************
 392  *              _setmbcp (MSVCRT.@)
 393  */
 394 int CDECL _setmbcp(int cp)
 395 {
 396     thread_data_t *data = msvcrt_get_thread_data();
 397     threadmbcinfo *mbcinfo;
 398
 399     mbcinfo = create_mbcinfo(cp, -1, get_mbcinfo());
 400     if(!mbcinfo)
 401     {
 402         *_errno() = EINVAL;
 403         return -1;
 404     }
 405
 406     if(data->locale_flags & LOCALE_THREAD)
 407     {
 408         if(data->locale_flags & LOCALE_FREE)
 409             free_mbcinfo(data->mbcinfo);
 410         data->mbcinfo = mbcinfo;
 411     }
 412     else
 413     {
 414         _lock(_MB_CP_LOCK);
 415         free_mbcinfo(MSVCRT_locale->mbcinfo);
 416         MSVCRT_locale->mbcinfo = mbcinfo;
 417         memcpy(MSVCRT_mbctype, MSVCRT_locale->mbcinfo->mbctype, sizeof(MSVCRT_mbctype));
 418         _unlock(_MB_CP_LOCK);
 419     }
 420     return 0;
 421 }
 422
 423 /*********************************************************************
 424  *              _getmbcp (MSVCRT.@)
 425  */
 426 int CDECL _getmbcp(void)
 427 {
 428   return get_mbcinfo()->mbcodepage;
 429 }
 430
 431 /*********************************************************************
 432  *              _mbsnextc_l(MSVCRT.@)
 433  */
 434 unsigned int CDECL _mbsnextc_l(const unsigned char* str, _locale_t locale)
 435 {
 436   if(_ismbblead_l(*str, locale))
 437     return *str << 8 | str[1];
 438   return *str;
 439 }
 440
 441 /*********************************************************************
 442  *              _mbsnextc(MSVCRT.@)
 443  */
 444 unsigned int CDECL _mbsnextc(const unsigned char* str)
 445 {
 446     return _mbsnextc_l(str, NULL);
 447 }
 448
 449 /*********************************************************************
 450  *              _mbctolower_l(MSVCRT.@)
 451  */
 452 unsigned int CDECL _mbctolower_l(unsigned int c, _locale_t locale)
 453 {
 454     unsigned char str[2], ret[2];
 455     pthreadmbcinfo mbcinfo;
 456
 457     if(!locale)
 458         mbcinfo = get_mbcinfo();
 459     else
 460         mbcinfo = locale->mbcinfo;
 461
 462     if (c > 0xff)
 463     {
 464         if (!_ismbblead_l((c >> 8) & 0xff, locale))
 465             return c;
 466
 467         str[0] = c >> 8;
 468         str[1] = c;
 469         switch(__crtLCMapStringA(mbcinfo->mblcid, LCMAP_LOWERCASE,
 470                     (char*)str, 2, (char*)ret, 2, mbcinfo->mbcodepage, 0))
 471         {
 472         case 0:
 473             return c;
 474         case 1:
 475             return ret[0];
 476         default:
 477             return ret[1] + (ret[0] << 8);
 478         }
 479     }
 480
 481     return mbcinfo->mbctype[c + 1] & _SBUP ? mbcinfo->mbcasemap[c] : c;
 482 }
 483
 484 /*********************************************************************
 485  *              _mbctolower(MSVCRT.@)
 486  */
 487 unsigned int CDECL _mbctolower(unsigned int c)
 488 {
 489     return _mbctolower_l(c, NULL);
 490 }
 491
 492 /*********************************************************************
 493  *              _mbctoupper_l(MSVCRT.@)
 494  */
 495 unsigned int CDECL _mbctoupper_l(unsigned int c, _locale_t locale)
 496 {
 497     unsigned char str[2], ret[2];
 498     pthreadmbcinfo mbcinfo;
 499
 500     if(!locale)
 501         mbcinfo = get_mbcinfo();
 502     else
 503         mbcinfo = locale->mbcinfo;
 504
 505     if (c > 0xff)
 506     {
 507         if (!_ismbblead_l((c >> 8) & 0xff, locale))
 508             return c;
 509
 510         str[0] = c >> 8;
 511         str[1] = c;
 512         switch(__crtLCMapStringA(mbcinfo->mblcid, LCMAP_UPPERCASE,
 513                     (char*)str, 2, (char*)ret, 2, mbcinfo->mbcodepage, 0))
 514         {
 515         case 0:
 516             return c;
 517         case 1:
 518             return ret[0];
 519         default:
 520             return ret[1] + (ret[0] << 8);
 521         }
 522     }
 523
 524     return mbcinfo->mbctype[c + 1] & _SBLOW ? mbcinfo->mbcasemap[c] : c;
 525 }
 526
 527 /*********************************************************************
 528  *              _mbctoupper(MSVCRT.@)
 529  */
 530 unsigned int CDECL _mbctoupper(unsigned int c)
 531 {
 532     return _mbctoupper_l(c, NULL);
 533 }
 534
 535 /*********************************************************************
 536  *              _mbctombb (MSVCRT.@)
 537  */
 538 unsigned int CDECL _mbctombb(unsigned int c)
 539 {
 540     unsigned int value;
 541
 542     if(get_mbcinfo()->mbcodepage == 932)
 543     {
 544         if(c >= 0x829f && c <= 0x82f1)    /* Hiragana */
 545             return mbctombb_932_kana[c - 0x829f];
 546         if(c >= 0x8340 && c <= 0x8396 && c != 0x837f)    /* Katakana */
 547             return mbctombb_932_kana[c - 0x8340 - (c >= 0x837f ? 1 : 0)];
 548         if(c >= 0x8140 && c <= 0x8197)    /* Punctuation */
 549         {
 550             value = mbctombb_932_punct[c - 0x8140];
 551             return value ? value : c;
 552         }
 553         if((c >= 0x824f && c <= 0x8258) || /* Fullwidth digits */
 554            (c >= 0x8260 && c <= 0x8279))   /* Fullwidth capitals letters */
 555             return c - 0x821f;
 556         if(c >= 0x8281 && c <= 0x829a)     /* Fullwidth small letters */
 557             return c - 0x8220;
 558         /* all other cases return c */
 559     }
 560     return c;
 561 }
 562
 563 /*********************************************************************
 564  *              _mbcjistojms(MSVCRT.@)
 565  *
 566  *              Converts a jis character to sjis.
 567  *              Based on description from
 568  *              http://www.slayers.ne.jp/~oouchi/code/jistosjis.html
 569  */
 570 unsigned int CDECL _mbcjistojms(unsigned int c)
 571 {
 572   /* Conversion takes place only when codepage is 932.
 573      In all other cases, c is returned unchanged */
 574   if(get_mbcinfo()->mbcodepage == 932)
 575   {
 576     if(HIBYTE(c) >= 0x21 && HIBYTE(c) <= 0x7e &&
 577        LOBYTE(c) >= 0x21 && LOBYTE(c) <= 0x7e)
 578     {
 579       if(HIBYTE(c) % 2)
 580         c += 0x1f;
 581       else
 582         c += 0x7d;
 583
 584       if(LOBYTE(c) >= 0x7F)
 585         c += 0x1;
 586
 587       c = (((HIBYTE(c) - 0x21)/2 + 0x81) << 8) | LOBYTE(c);
 588
 589       if(HIBYTE(c) > 0x9f)
 590         c += 0x4000;
 591     }
 592     else
 593       return 0; /* Codepage is 932, but c can't be converted */
 594   }
 595
 596   return c;
 597 }
 598
 599 /*********************************************************************
 600  *              _mbcjmstojis(MSVCRT.@)
 601  *
 602  *              Converts a sjis character to jis.
 603  */
 604 unsigned int CDECL _mbcjmstojis(unsigned int c)
 605 {
 606   /* Conversion takes place only when codepage is 932.
 607      In all other cases, c is returned unchanged */
 608   if(get_mbcinfo()->mbcodepage == 932)
 609   {
 610     if(_ismbclegal(c) && HIBYTE(c) < 0xf0)
 611     {
 612       if(HIBYTE(c) >= 0xe0)
 613         c -= 0x4000;
 614
 615       c = (((HIBYTE(c) - 0x81)*2 + 0x21) << 8) | LOBYTE(c);
 616
 617       if(LOBYTE(c) > 0x7f)
 618         c -= 0x1;
 619
 620       if(LOBYTE(c) > 0x9d)
 621         c += 0x83;
 622       else
 623         c -= 0x1f;
 624     }
 625     else
 626       return 0; /* Codepage is 932, but c can't be converted */
 627   }
 628
 629   return c;
 630 }
 631
 632 /*********************************************************************
 633  *              _mbsdec(MSVCRT.@)
 634  */
 635 unsigned char* CDECL _mbsdec(const unsigned char* start, const unsigned char* cur)
 636 {
 637   if(start >= cur)
 638     return NULL;
 639
 640   if(get_mbcinfo()->ismbcodepage)
 641     return (unsigned char *)(_ismbstrail(start,cur-1) ? cur - 2 : cur -1);
 642
 643   return (unsigned char *)cur - 1; /* ASCII CP or SB char */
 644 }
 645
 646 /*********************************************************************
 647  *              _mbclen_l(MSVCRT.@)
 648  */
 649 size_t CDECL _mbclen_l(const unsigned char* str, _locale_t locale)
 650 {
 651     return _ismbblead_l(*str, locale) && str[1] ? 2 : 1;
 652 }
 653
 654 /*********************************************************************
 655  *              _mbclen(MSVCRT.@)
 656  */
 657 size_t CDECL _mbclen(const unsigned char* str)
 658 {
 659     return _mbclen_l(str, NULL);
 660 }
 661
 662 /*********************************************************************
 663  *              _mbsinc(MSVCRT.@)
 664  */
 665 unsigned char* CDECL _mbsinc(const unsigned char* str)
 666 {
 667   return (unsigned char *)(str + _mbclen(str));
 668 }
 669
 670 /*********************************************************************
 671  *              _mbsninc(MSVCRT.@)
 672  */
 673 unsigned char* CDECL _mbsninc(const unsigned char* str, size_t num)
 674 {
 675   if(!str)
 676     return NULL;
 677
 678   while (num > 0 && *str)
 679   {
 680     if (_ismbblead(*str))
 681     {
 682       if (!*(str+1))
 683          break;
 684       str++;
 685     }
 686     str++;
 687     num--;
 688   }
 689
 690   return (unsigned char*)str;
 691 }
 692
 693 /*********************************************************************
 694  *              _mbsnlen_l(MSVCRT.@)
 695  */
 696 size_t CDECL _mbsnlen_l(const unsigned char *str,
 697         size_t maxsize, _locale_t locale)
 698 {
 699     pthreadmbcinfo mbcinfo;
 700     size_t i = 0, len = 0;
 701
 702     if(!locale)
 703         mbcinfo = get_mbcinfo();
 704     else
 705         mbcinfo = locale->mbcinfo;
 706
 707     if(!mbcinfo->ismbcodepage)
 708         return strnlen((const char*)str, maxsize);
 709
 710     while(i<maxsize && str[i])
 711     {
 712         if (_ismbblead_l(str[i], locale))
 713         {
 714             i++;
 715             if (!str[i])  /* count only full chars */
 716                 break;
 717         }
 718         i++;
 719         len++;
 720     }
 721     return i < maxsize ? len : maxsize;
 722 }
 723
 724 /*********************************************************************
 725  *              _mbslen(MSVCRT.@)
 726  */
 727 size_t CDECL _mbslen(const unsigned char* str)
 728 {
 729     return _mbsnlen_l(str, -1, NULL);
 730 }
 731
 732 /*********************************************************************
 733  *              _mbslen_l(MSVCRT.@)
 734  */
 735 size_t CDECL _mbslen_l(const unsigned char* str, _locale_t locale)
 736 {
 737     return _mbsnlen_l(str, -1, locale);
 738 }
 739
 740 /*********************************************************************
 741  *              _mbsnlen(MSVCRT.@)
 742  */
 743 size_t CDECL _mbsnlen(const unsigned char* str, size_t maxsize)
 744 {
 745     return _mbsnlen_l(str, maxsize, NULL);
 746 }
 747
 748 /*********************************************************************
 749  *              _mbccpy_s_l(MSVCRT.@)
 750  */
 751 int CDECL _mbccpy_s_l(unsigned char* dest, size_t maxsize,
 752         int *copied, const unsigned char* src, _locale_t locale)
 753 {
 754     if(copied) *copied = 0;
 755     if(!MSVCRT_CHECK_PMT(dest != NULL && maxsize >= 1)) return EINVAL;
 756     dest[0] = 0;
 757     if(!MSVCRT_CHECK_PMT(src != NULL)) return EINVAL;
 758
 759     if(_ismbblead_l(*src, locale)) {
 760         if(!src[1]) {
 761             if(copied) *copied = 1;
 762             *_errno() = EILSEQ;
 763             return EILSEQ;
 764         }
 765
 766         if(maxsize < 2) {
 767             MSVCRT_INVALID_PMT("dst buffer is too small", ERANGE);
 768             return ERANGE;
 769         }
 770
 771         *dest++ = *src++;
 772         *dest = *src;
 773         if(copied) *copied = 2;
 774     }else {
 775         *dest = *src;
 776         if(copied) *copied = 1;
 777     }
 778
 779     return 0;
 780 }
 781
 782 /*********************************************************************
 783  *              _mbccpy(MSVCRT.@)
 784  */
 785 void CDECL _mbccpy(unsigned char* dest, const unsigned char* src)
 786 {
 787     _mbccpy_s_l(dest, 2, NULL, src, NULL);
 788 }
 789
 790 /*********************************************************************
 791  *              _mbccpy_l(MSVCRT.@)
 792  */
 793 void CDECL _mbccpy_l(unsigned char* dest, const unsigned char* src,
 794         _locale_t locale)
 795 {
 796     _mbccpy_s_l(dest, 2, NULL, src, locale);
 797 }
 798
 799 /*********************************************************************
 800  *              _mbccpy_s(MSVCRT.@)
 801  */
 802 int CDECL _mbccpy_s(unsigned char* dest, size_t maxsize,
 803         int *copied, const unsigned char* src)
 804 {
 805     return _mbccpy_s_l(dest, maxsize, copied, src, NULL);
 806 }
 807
 808 /*********************************************************************
 809  *              _mbsncpy(MSVCRT.@)
 810  * REMARKS
 811  *  The parameter n is the number or characters to copy, not the size of
 812  *  the buffer. Use _mbsnbcpy for a function analogical to strncpy
 813  */
 814 unsigned char* CDECL _mbsncpy(unsigned char* dst, const unsigned char* src, size_t n)
 815 {
 816   unsigned char* ret = dst;
 817   if(!n)
 818     return dst;
 819   if (get_mbcinfo()->ismbcodepage)
 820   {
 821     while (*src && n)
 822     {
 823       n--;
 824       if (_ismbblead(*src))
 825       {
 826         if (!*(src+1))
 827         {
 828             *dst++ = 0;
 829             *dst++ = 0;
 830             break;
 831         }
 832
 833         *dst++ = *src++;
 834       }
 835
 836       *dst++ = *src++;
 837     }
 838   }
 839   else
 840   {
 841     while (n)
 842     {
 843         n--;
 844         if (!(*dst++ = *src++)) break;
 845     }
 846   }
 847   while (n--) *dst++ = 0;
 848   return ret;
 849 }
 850
 851 /*********************************************************************
 852  *              _mbsnbcpy_s_l(MSVCRT.@)
 853  * REMARKS
 854  * Unlike _mbsnbcpy this function does not pad the rest of the dest
 855  * string with 0
 856  */
 857 int CDECL _mbsnbcpy_s_l(unsigned char* dst, size_t size,
 858         const unsigned char* src, size_t n, _locale_t locale)
 859 {
 860     size_t pos = 0;
 861
 862     if(!dst || size == 0)
 863         return EINVAL;
 864     if(!src)
 865     {
 866         dst[0] = '\0';
 867         return EINVAL;
 868     }
 869     if(!n)
 870         return 0;
 871
 872     if((locale ? locale->mbcinfo : get_mbcinfo())->ismbcodepage)
 873     {
 874         BOOL is_lead = FALSE;
 875         while (*src && n)
 876         {
 877             if(pos == size)
 878             {
 879                 dst[0] = '\0';
 880                 return ERANGE;
 881             }
 882             is_lead = (!is_lead && _ismbblead(*src));
 883             n--;
 884             dst[pos++] = *src++;
 885         }
 886
 887         if (is_lead) /* if string ends with a lead, remove it */
 888             dst[pos - 1] = 0;
 889     }
 890     else
 891     {
 892         while (n)
 893         {
 894             n--;
 895             if(pos == size)
 896             {
 897                 dst[0] = '\0';
 898                 return ERANGE;
 899             }
 900
 901             if(!(*src)) break;
 902             dst[pos++] = *src++;
 903         }
 904     }
 905
 906     if(pos < size)
 907         dst[pos] = '\0';
 908     else
 909     {
 910         dst[0] = '\0';
 911         return ERANGE;
 912     }
 913
 914     return 0;
 915 }
 916
 917 /*********************************************************************
 918  *              _mbsnbcpy_s(MSVCRT.@)
 919  */
 920 int CDECL _mbsnbcpy_s(unsigned char* dst, size_t size, const unsigned char* src, size_t n)
 921 {
 922     return _mbsnbcpy_s_l(dst, size, src, n, NULL);
 923 }
 924
 925 /*********************************************************************
 926  *              _mbscpy_s_l(MSVCRT.@)
 927  */
 928 int CDECL _mbscpy_s_l(unsigned char *dst, size_t size,
 929         const unsigned char *src, _locale_t locale)
 930 {
 931     return _mbsnbcpy_s_l(dst, size, src, -1, locale);
 932 }
 933
 934 /*********************************************************************
 935  *              _mbscpy_s(MSVCRT.@)
 936  */
 937 int CDECL _mbscpy_s(unsigned char *dst, size_t size, const unsigned char *src)
 938 {
 939     return _mbscpy_s_l(dst, size, src, NULL);
 940 }
 941
 942 /*********************************************************************
 943  *              _mbsnbcpy(MSVCRT.@)
 944  * REMARKS
 945  *  Like strncpy this function doesn't enforce the string to be
 946  *  NUL-terminated
 947  */
 948 unsigned char* CDECL _mbsnbcpy(unsigned char* dst, const unsigned char* src, size_t n)
 949 {
 950   unsigned char* ret = dst;
 951   if(!n)
 952     return dst;
 953   if(get_mbcinfo()->ismbcodepage)
 954   {
 955     BOOL is_lead = FALSE;
 956     while (*src && n)
 957     {
 958       is_lead = (!is_lead && _ismbblead(*src));
 959       n--;
 960       *dst++ = *src++;
 961     }
 962
 963     if (is_lead) /* if string ends with a lead, remove it */
 964         *(dst - 1) = 0;
 965   }
 966   else
 967   {
 968     while (n)
 969     {
 970         n--;
 971         if (!(*dst++ = *src++)) break;
 972     }
 973   }
 974   while (n--) *dst++ = 0;
 975   return ret;
 976 }
 977
 978 /*********************************************************************
 979  *              _mbscmp_l(MSVCRT.@)
 980  */
 981 int CDECL _mbscmp_l(const unsigned char* str, const unsigned char* cmp, _locale_t locale)
 982 {
 983   pthreadmbcinfo mbcinfo;
 984
 985   if (!MSVCRT_CHECK_PMT(str && cmp))
 986     return _NLSCMPERROR;
 987
 988   mbcinfo = locale ? locale->mbcinfo : get_mbcinfo();
 989
 990   if(mbcinfo->ismbcodepage)
 991   {
 992     unsigned int strc, cmpc;
 993     do {
 994       if(!*str)
 995         return *cmp ? -1 : 0;
 996       if(!*cmp)
 997         return 1;
 998       strc = _mbsnextc_l(str, locale);
 999       cmpc = _mbsnextc_l(cmp, locale);
1000       if(strc != cmpc)
1001         return strc < cmpc ? -1 : 1;
1002       str +=(strc > 255) ? 2 : 1;
1003       cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
1004     } while(1);
1005   }
1006   return u_strcmp(str, cmp); /* ASCII CP */
1007 }
1008
1009 /*********************************************************************
1010  *              _mbscmp(MSVCRT.@)
1011  */
1012 int CDECL _mbscmp(const unsigned char* str, const unsigned char* cmp)
1013 {
1014     return _mbscmp_l(str, cmp, NULL);
1015 }
1016
1017 /*********************************************************************
1018  *              _mbsnbicoll_l(MSVCRT.@)
1019  */
1020 int CDECL _mbsnbicoll_l(const unsigned char *str1, const unsigned char *str2, size_t len, _locale_t locale)
1021 {
1022     pthreadmbcinfo mbcinfo;
1023
1024     if(!locale)
1025         mbcinfo = get_mbcinfo();
1026     else
1027         mbcinfo = locale->mbcinfo;
1028
1029     if(!mbcinfo->ismbcodepage)
1030         return _strnicoll_l((const char*)str1, (const char*)str2, len, locale);
1031     return CompareStringA(mbcinfo->mblcid, NORM_IGNORECASE, (const char*)str1, len, (const char*)str2, len)-CSTR_EQUAL;
1032 }
1033
1034 /*********************************************************************
1035  *              _mbsicoll_l(MSVCRT.@)
1036  */
1037 int CDECL _mbsicoll_l(const unsigned char *str1, const unsigned char *str2, _locale_t locale)
1038 {
1039     return _mbsnbicoll_l(str1, str2, -1, locale);
1040 }
1041
1042 /*********************************************************************
1043  *              _mbsnbicoll(MSVCRT.@)
1044  */
1045 int CDECL _mbsnbicoll(const unsigned char *str1, const unsigned char *str2, size_t len)
1046 {
1047     return _mbsnbicoll_l(str1, str2, len, NULL);
1048 }
1049
1050 /*********************************************************************
1051  *              _mbsicoll(MSVCRT.@)
1052  */
1053 int CDECL _mbsicoll(const unsigned char* str, const unsigned char* cmp)
1054 {
1055 #if _MSVCR_VER>=60 && _MSVCR_VER<=71
1056     return CompareStringA(get_mbcinfo()->mblcid, NORM_IGNORECASE,
1057             (const char*)str, -1, (const char*)cmp, -1)-CSTR_EQUAL;
1058 #else
1059     return _mbsnbicoll_l(str, cmp, -1, NULL);
1060 #endif
1061 }
1062
1063 /*********************************************************************
1064  *              _mbsnbcoll_l(MSVCRT.@)
1065  */
1066 int CDECL _mbsnbcoll_l(const unsigned char *str1, const unsigned char *str2, size_t len, _locale_t locale)
1067 {
1068     pthreadmbcinfo mbcinfo;
1069
1070     if(!locale)
1071         mbcinfo = get_mbcinfo();
1072     else
1073         mbcinfo = locale->mbcinfo;
1074
1075     if(!mbcinfo->ismbcodepage)
1076         return _strncoll_l((const char*)str1, (const char*)str2, len, locale);
1077     return CompareStringA(mbcinfo->mblcid, 0, (const char*)str1, len, (const char*)str2, len)-CSTR_EQUAL;
1078 }
1079
1080 /*********************************************************************
1081  *              _mbscoll_l(MSVCRT.@)
1082  */
1083 int CDECL _mbscoll_l(const unsigned char *str1, const unsigned char *str2, _locale_t locale)
1084 {
1085     return _mbsnbcoll_l(str1, str2, -1, locale);
1086 }
1087
1088 /*********************************************************************
1089  *              _mbsnbcoll(MSVCRT.@)
1090  */
1091 int CDECL _mbsnbcoll(const unsigned char *str1, const unsigned char *str2, size_t len)
1092 {
1093     return _mbsnbcoll_l(str1, str2, len, NULL);
1094 }
1095
1096 /*********************************************************************
1097  *              _mbscoll(MSVCRT.@)
1098  */
1099 int CDECL _mbscoll(const unsigned char* str, const unsigned char* cmp)
1100 {
1101 #if _MSVCR_VER>=60 && _MSVCR_VER<=71
1102     return CompareStringA(get_mbcinfo()->mblcid, 0,
1103             (const char*)str, -1, (const char*)cmp, -1)-CSTR_EQUAL;
1104 #else
1105     return _mbsnbcoll_l(str, cmp, -1, NULL);
1106 #endif
1107 }
1108
1109 /*********************************************************************
1110  *              _mbsicmp_l(MSVCRT.@)
1111  */
1112 int CDECL _mbsicmp_l(const unsigned char* str, const unsigned char* cmp, _locale_t locale)
1113 {
1114   pthreadmbcinfo mbcinfo;
1115
1116   if(!MSVCRT_CHECK_PMT(str && cmp))
1117     return _NLSCMPERROR;
1118
1119   if(!locale)
1120     mbcinfo = get_mbcinfo();
1121   else
1122     mbcinfo = locale->mbcinfo;
1123   if(mbcinfo->ismbcodepage)
1124   {
1125     unsigned int strc, cmpc;
1126     do {
1127       if(!*str)
1128         return *cmp ? -1 : 0;
1129       if(!*cmp)
1130         return 1;
1131       strc = _mbctolower_l(_mbsnextc_l(str, locale), locale);
1132       cmpc = _mbctolower_l(_mbsnextc_l(cmp, locale), locale);
1133       if(strc != cmpc)
1134         return strc < cmpc ? -1 : 1;
1135       str +=(strc > 255) ? 2 : 1;
1136       cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
1137     } while(1);
1138   }
1139   return u_strcasecmp(str, cmp); /* ASCII CP */
1140 }
1141
1142 /*********************************************************************
1143  *              _mbsicmp(MSVCRT.@)
1144  */
1145 int CDECL _mbsicmp(const unsigned char* str, const unsigned char* cmp)
1146 {
1147   return _mbsicmp_l(str, cmp, NULL);
1148 }
1149
1150 /*********************************************************************
1151  *              _mbsncmp(MSVCRT.@)
1152  */
1153 int CDECL _mbsncmp(const unsigned char* str, const unsigned char* cmp, size_t len)
1154 {
1155   if(!len)
1156     return 0;
1157
1158   if(get_mbcinfo()->ismbcodepage)
1159   {
1160     unsigned int strc, cmpc;
1161     while(len--)
1162     {
1163       int inc;
1164       if(!*str)
1165         return *cmp ? -1 : 0;
1166       if(!*cmp)
1167         return 1;
1168       strc = _mbsnextc(str);
1169       cmpc = _mbsnextc(cmp);
1170       if(strc != cmpc)
1171         return strc < cmpc ? -1 : 1;
1172       inc=(strc > 255) ? 2 : 1; /* Equal, use same increment */
1173       str += inc;
1174       cmp += inc;
1175     }
1176     return 0; /* Matched len chars */
1177   }
1178   return u_strncmp(str, cmp, len); /* ASCII CP */
1179 }
1180
1181 /*********************************************************************
1182  *              _mbsnbcmp(MSVCRT.@)
1183  */
1184 int CDECL _mbsnbcmp(const unsigned char* str, const unsigned char* cmp, size_t len)
1185 {
1186   if (!len)
1187     return 0;
1188   if(get_mbcinfo()->ismbcodepage)
1189   {
1190     unsigned int strc, cmpc;
1191     while (len)
1192     {
1193       int clen;
1194       if(!*str)
1195         return *cmp ? -1 : 0;
1196       if(!*cmp)
1197         return 1;
1198       if (_ismbblead(*str))
1199       {
1200         strc=(len>=2)?_mbsnextc(str):0;
1201         clen=2;
1202       }
1203       else
1204       {
1205         strc=*str;
1206         clen=1;
1207       }
1208       if (_ismbblead(*cmp))
1209         cmpc=(len>=2)?_mbsnextc(cmp):0;
1210       else
1211         cmpc=*cmp;
1212       if(strc != cmpc)
1213         return strc < cmpc ? -1 : 1;
1214       len -= clen;
1215       str += clen;
1216       cmp += clen;
1217     }
1218     return 0; /* Matched len chars */
1219   }
1220   return u_strncmp(str,cmp,len);
1221 }
1222
1223 /*********************************************************************
1224  *              _mbsnicmp(MSVCRT.@)
1225  *
1226  * Compare two multibyte strings case insensitively to 'len' characters.
1227  */
1228 int CDECL _mbsnicmp(const unsigned char* str, const unsigned char* cmp, size_t len)
1229 {
1230   /* FIXME: No tolower() for mb strings yet */
1231   if(get_mbcinfo()->ismbcodepage)
1232   {
1233     unsigned int strc, cmpc;
1234     while(len--)
1235     {
1236       if(!*str)
1237         return *cmp ? -1 : 0;
1238       if(!*cmp)
1239         return 1;
1240       strc = _mbctolower(_mbsnextc(str));
1241       cmpc = _mbctolower(_mbsnextc(cmp));
1242       if(strc != cmpc)
1243         return strc < cmpc ? -1 : 1;
1244       str +=(strc > 255) ? 2 : 1;
1245       cmp +=(strc > 255) ? 2 : 1; /* Equal, use same increment */
1246     }
1247     return 0; /* Matched len chars */
1248   }
1249   return u_strncasecmp(str, cmp, len); /* ASCII CP */
1250 }
1251
1252 /*********************************************************************
1253  *              _mbsnbicmp(MSVCRT.@)
1254  */
1255 int CDECL _mbsnbicmp(const unsigned char* str, const unsigned char* cmp, size_t len)
1256 {
1257   if (!len)
1258     return 0;
1259   if(get_mbcinfo()->ismbcodepage)
1260   {
1261     unsigned int strc, cmpc;
1262     while (len)
1263     {
1264       int clen;
1265       if(!*str)
1266         return *cmp ? -1 : 0;
1267       if(!*cmp)
1268         return 1;
1269       if (_ismbblead(*str))
1270       {
1271         strc=(len>=2)?_mbsnextc(str):0;
1272         clen=2;
1273       }
1274       else
1275       {
1276         strc=*str;
1277         clen=1;
1278       }
1279       if (_ismbblead(*cmp))
1280         cmpc=(len>=2)?_mbsnextc(cmp):0;
1281       else
1282         cmpc=*cmp;
1283       strc = _mbctolower(strc);
1284       cmpc = _mbctolower(cmpc);
1285       if(strc != cmpc)
1286         return strc < cmpc ? -1 : 1;
1287       len -= clen;
1288       str += clen;
1289       cmp += clen;
1290     }
1291     return 0; /* Matched len bytes */
1292   }
1293   return u_strncasecmp(str,cmp,len);
1294 }
1295
1296 /*********************************************************************
1297  *              _mbscat (MSVCRT.@)
1298  */
1299 unsigned char * CDECL _mbscat( unsigned char *dst, const unsigned char *src )
1300 {
1301     strcat( (char *)dst, (const char *)src );
1302     return dst;
1303 }
1304
1305 /*********************************************************************
1306  *              _mbscat_s_l (MSVCRT.@)
1307  */
1308 int CDECL _mbscat_s_l( unsigned char *dst, size_t size,
1309         const unsigned char *src, _locale_t locale )
1310 {
1311     size_t i, j;
1312     int ret = 0;
1313
1314     if(!MSVCRT_CHECK_PMT(dst != NULL)) return EINVAL;
1315     if(!MSVCRT_CHECK_PMT(src != NULL)) return EINVAL;
1316
1317     for(i=0; i<size; i++)
1318         if(!dst[i]) break;
1319     if(i == size) {
1320         MSVCRT_INVALID_PMT("dst is not NULL-terminated", EINVAL);
1321         if(size) dst[0] = 0;
1322         return EINVAL;
1323     }
1324
1325     if(i && _ismbblead_l(dst[i-1], locale)) {
1326         ret = EILSEQ;
1327         i--;
1328     }
1329
1330     for(j=0; src[j] && i+j<size; j++)
1331         dst[i+j] = src[j];
1332     if(i+j == size) {
1333         MSVCRT_INVALID_PMT("dst buffer is too small", ERANGE);
1334         dst[0] = 0;
1335         return ERANGE;
1336     }
1337
1338     if(j && _ismbblead_l(src[j-1], locale)) {
1339         ret = EILSEQ;
1340         j--;
1341     }
1342
1343     dst[i+j] = 0;
1344     return ret;
1345 }
1346
1347 /*********************************************************************
1348  *              _mbscat_s (MSVCRT.@)
1349  */
1350 int CDECL _mbscat_s( unsigned char *dst, size_t size, const unsigned char *src )
1351 {
1352     return _mbscat_s_l(dst, size, src, NULL);
1353 }
1354
1355 /*********************************************************************
1356  *              _mbscpy (MSVCRT.@)
1357  */
1358 unsigned char* CDECL _mbscpy( unsigned char *dst, const unsigned char *src )
1359 {
1360     strcpy( (char *)dst, (const char *)src );
1361     return dst;
1362 }
1363
1364 /*********************************************************************
1365  *              _mbsstr (MSVCRT.@)
1366  */
1367 unsigned char * CDECL _mbsstr(const unsigned char *haystack, const unsigned char *needle)
1368 {
1369     return (unsigned char *)strstr( (const char *)haystack, (const char *)needle );
1370 }
1371
1372 /*********************************************************************
1373  *              _mbschr_l(MSVCRT.@)
1374  */
1375 unsigned char* CDECL _mbschr_l(const unsigned char* s, unsigned int x, _locale_t locale)
1376 {
1377   pthreadmbcinfo mbcinfo;
1378
1379   if(!MSVCRT_CHECK_PMT(s))
1380     return NULL;
1381
1382   if(locale)
1383       mbcinfo = locale->mbcinfo;
1384   else
1385       mbcinfo = get_mbcinfo();
1386   if(mbcinfo->ismbcodepage)
1387   {
1388     unsigned int c;
1389     while (1)
1390     {
1391       c = _mbsnextc_l(s, locale);
1392       if (c == x)
1393         return (unsigned char*)s;
1394       if (!c)
1395         return NULL;
1396       s += c > 255 ? 2 : 1;
1397     }
1398   }
1399   return u_strchr(s, x); /* ASCII CP */
1400 }
1401
1402 /*********************************************************************
1403  *              _mbschr(MSVCRT.@)
1404  */
1405 unsigned char* CDECL _mbschr(const unsigned char* s, unsigned int x)
1406 {
1407   return _mbschr_l(s, x, NULL);
1408 }
1409
1410 /*********************************************************************
1411  *              _mbsrchr(MSVCRT.@)
1412  */
1413 unsigned char* CDECL _mbsrchr(const unsigned char* s, unsigned int x)
1414 {
1415   if(get_mbcinfo()->ismbcodepage)
1416   {
1417     unsigned int c;
1418     unsigned char* match=NULL;
1419     if(!s)
1420       return NULL;
1421     while (1) {
1422       c = _mbsnextc(s);
1423       if (c == x)
1424         match=(unsigned char*)s;
1425       if (!c)
1426         return match;
1427       s +=(c > 255) ? 2 : 1;
1428     }
1429   }
1430   return u_strrchr(s, x);
1431 }
1432
1433 /*********************************************************************
1434  *              _mbstok_s_l(MSVCRT.@)
1435  */
1436 unsigned char* CDECL _mbstok_s_l(unsigned char *str, const unsigned char *delim,
1437         unsigned char **ctx, _locale_t locale)
1438 {
1439     pthreadmbcinfo mbcinfo;
1440     unsigned int c;
1441
1442     if(!MSVCRT_CHECK_PMT(delim != NULL)) return NULL;
1443     if(!MSVCRT_CHECK_PMT(ctx != NULL)) return NULL;
1444     if(!MSVCRT_CHECK_PMT(str || *ctx)) return NULL;
1445
1446     if(locale)
1447         mbcinfo = locale->mbcinfo;
1448     else
1449         mbcinfo = get_mbcinfo();
1450
1451     if(!mbcinfo->ismbcodepage)
1452         return (unsigned char*)strtok_s((char*)str, (const char*)delim, (char**)ctx);
1453
1454     if(!str)
1455         str = *ctx;
1456
1457     while((c=_mbsnextc(str)) && _mbschr(delim, c))
1458         str += c>255 ? 2 : 1;
1459     if(!*str)
1460     {
1461         *ctx = str;
1462         return NULL;
1463     }
1464
1465     *ctx = str + (c>255 ? 2 : 1);
1466     while((c=_mbsnextc(*ctx)) && !_mbschr(delim, c))
1467         *ctx += c>255 ? 2 : 1;
1468     if (**ctx) {
1469         *(*ctx)++ = 0;
1470         if(c > 255)
1471             *(*ctx)++ = 0;
1472     }
1473
1474     return str;
1475 }
1476
1477
1478 /*********************************************************************
1479  *              _mbstok_s(MSVCRT.@)
1480  */
1481 unsigned char* CDECL _mbstok_s(unsigned char *str,
1482         const unsigned char *delim, unsigned char **ctx)
1483 {
1484     return _mbstok_s_l(str, delim, ctx, NULL);
1485 }
1486
1487 /*********************************************************************
1488  *              _mbstok_l(MSVCRT.@)
1489  */
1490 unsigned char* CDECL _mbstok_l(unsigned char *str,
1491         const unsigned char *delim, _locale_t locale)
1492 {
1493     return _mbstok_s_l(str, delim, &msvcrt_get_thread_data()->mbstok_next, locale);
1494 }
1495
1496 /*********************************************************************
1497  *              _mbstok(MSVCRT.@)
1498  */
1499 unsigned char* CDECL _mbstok(unsigned char *str, const unsigned char *delim)
1500 {
1501     thread_data_t *data = msvcrt_get_thread_data();
1502
1503 #if _MSVCR_VER == 0
1504     if(!str && !data->mbstok_next)
1505         return NULL;
1506 #endif
1507
1508     return _mbstok_s_l(str, delim, &data->mbstok_next, NULL);
1509 }
1510
1511 /*********************************************************************
1512  *              _mbbtombc(MSVCRT.@)
1513  */
1514 unsigned int CDECL _mbbtombc(unsigned int c)
1515 {
1516   if(get_mbcinfo()->mbcodepage == 932)
1517   {
1518     if(c >= 0x20 && c <= 0x7e) {
1519       if((c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) || (c >= 0x30 && c <= 0x39))
1520         return mbbtombc_932[c - 0x20] | 0x8200;
1521       else
1522         return mbbtombc_932[c - 0x20] | 0x8100;
1523     }
1524     else if(c >= 0xa1 && c <= 0xdf) {
1525       if(c >= 0xa6 && c <= 0xdd && c != 0xb0)
1526         return mbbtombc_932[c - 0xa1 + 0x5f] | 0x8300;
1527       else
1528         return mbbtombc_932[c - 0xa1 + 0x5f] | 0x8100;
1529     }
1530   }
1531   return c;  /* not Japanese or no MB char */
1532 }
1533
1534 /*********************************************************************
1535  *              _ismbbkana_l(MSVCRT.@)
1536  */
1537 int CDECL _ismbbkana_l(unsigned int c, _locale_t locale)
1538 {
1539     pthreadmbcinfo mbcinfo;
1540
1541     if(locale)
1542         mbcinfo = locale->mbcinfo;
1543     else
1544         mbcinfo = get_mbcinfo();
1545
1546     if(mbcinfo->mbcodepage == 932)
1547     {
1548         /* Japanese/Katakana, CP 932 */
1549         return (c >= 0xa1 && c <= 0xdf);
1550     }
1551     return 0;
1552 }
1553
1554 /*********************************************************************
1555  *              _ismbbkana(MSVCRT.@)
1556  */
1557 int CDECL _ismbbkana(unsigned int c)
1558 {
1559     return _ismbbkana_l( c, NULL );
1560 }
1561
1562 /*********************************************************************
1563  *              _ismbcdigit_l(MSVCRT.@)
1564  */
1565 int CDECL _ismbcdigit_l(unsigned int ch, _locale_t locale)
1566 {
1567     return _iswdigit_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
1568 }
1569
1570 /*********************************************************************
1571  *              _ismbcdigit(MSVCRT.@)
1572  */
1573 int CDECL _ismbcdigit(unsigned int ch)
1574 {
1575     return _ismbcdigit_l( ch, NULL );
1576 }
1577
1578 /*********************************************************************
1579  *              _ismbcgraph_l(MSVCRT.@)
1580  */
1581 int CDECL _ismbcgraph_l(unsigned int ch, _locale_t locale)
1582 {
1583     return _iswgraph_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
1584 }
1585
1586 /*********************************************************************
1587  *              _ismbcgraph(MSVCRT.@)
1588  */
1589 int CDECL _ismbcgraph(unsigned int ch)
1590 {
1591     return _ismbcgraph_l( ch, NULL );
1592 }
1593
1594 /*********************************************************************
1595  *              _ismbcalpha_l (MSVCRT.@)
1596  */
1597 int CDECL _ismbcalpha_l(unsigned int ch, _locale_t locale)
1598 {
1599     return _iswalpha_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
1600 }
1601
1602 /*********************************************************************
1603  *              _ismbcalpha (MSVCRT.@)
1604  */
1605 int CDECL _ismbcalpha(unsigned int ch)
1606 {
1607     return _ismbcalpha_l( ch, NULL );
1608 }
1609
1610 /*********************************************************************
1611  *              _ismbclower_l (MSVCRT.@)
1612  */
1613 int CDECL _ismbclower_l(unsigned int ch, _locale_t locale)
1614 {
1615     return _iswlower_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
1616 }
1617
1618 /*********************************************************************
1619  *              _ismbclower (MSVCRT.@)
1620  */
1621 int CDECL _ismbclower(unsigned int ch)
1622 {
1623     return _ismbclower_l( ch, NULL );
1624 }
1625
1626 /*********************************************************************
1627  *              _ismbcupper_l (MSVCRT.@)
1628  */
1629 int CDECL _ismbcupper_l(unsigned int ch, _locale_t locale)
1630 {
1631     return _iswupper_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
1632 }
1633
1634 /*********************************************************************
1635  *              _ismbcupper (MSVCRT.@)
1636  */
1637 int CDECL _ismbcupper(unsigned int ch)
1638 {
1639     return _ismbcupper_l( ch, NULL );
1640 }
1641
1642 /*********************************************************************
1643  *              _ismbcsymbol(MSVCRT.@)
1644  */
1645 int CDECL _ismbcsymbol(unsigned int ch)
1646 {
1647     wchar_t wch = msvcrt_mbc_to_wc( ch );
1648     WORD ctype;
1649     if (!GetStringTypeW(CT_CTYPE3, &wch, 1, &ctype))
1650     {
1651         WARN("GetStringTypeW failed on %x\n", ch);
1652         return 0;
1653     }
1654     return ((ctype & C3_SYMBOL) != 0);
1655 }
1656
1657 /*********************************************************************
1658  *              _ismbcalnum_l (MSVCRT.@)
1659  */
1660 int CDECL _ismbcalnum_l(unsigned int ch, _locale_t locale)
1661 {
1662     return _iswalnum_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
1663 }
1664
1665 /*********************************************************************
1666  *              _ismbcalnum (MSVCRT.@)
1667  */
1668 int CDECL _ismbcalnum(unsigned int ch)
1669 {
1670     return _ismbcalnum_l( ch, NULL );
1671 }
1672
1673 /*********************************************************************
1674  *              _ismbcspace_l (MSVCRT.@)
1675  */
1676 int CDECL _ismbcspace_l(unsigned int ch, _locale_t locale)
1677 {
1678     return _iswspace_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
1679 }
1680
1681 /*********************************************************************
1682  *              _ismbcspace (MSVCRT.@)
1683  */
1684 int CDECL _ismbcspace(unsigned int ch)
1685 {
1686     return _ismbcspace_l( ch, NULL );
1687 }
1688
1689 /*********************************************************************
1690  *              _ismbcprint_l (MSVCRT.@)
1691  */
1692 int CDECL _ismbcprint_l(unsigned int ch, _locale_t locale)
1693 {
1694     return _iswprint_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
1695 }
1696
1697 /*********************************************************************
1698  *              _ismbcprint (MSVCRT.@)
1699  */
1700 int CDECL _ismbcprint(unsigned int ch)
1701 {
1702     return _ismbcprint_l( ch, NULL );
1703 }
1704
1705 /*********************************************************************
1706  *              _ismbcpunct_l (MSVCRT.@)
1707  */
1708 int CDECL _ismbcpunct_l(unsigned int ch, _locale_t locale)
1709 {
1710     return _iswpunct_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
1711 }
1712
1713 /*********************************************************************
1714  *              _ismbcpunct(MSVCRT.@)
1715  */
1716 int CDECL _ismbcpunct(unsigned int ch)
1717 {
1718     return _ismbcpunct_l( ch, NULL );
1719 }
1720
1721 /*********************************************************************
1722  *              _ismbchira(MSVCRT.@)
1723  */
1724 int CDECL _ismbchira(unsigned int c)
1725 {
1726   if(get_mbcinfo()->mbcodepage == 932)
1727   {
1728     /* Japanese/Hiragana, CP 932 */
1729     return (c >= 0x829f && c <= 0x82f1);
1730   }
1731   return 0;
1732 }
1733
1734 /*********************************************************************
1735  *              _ismbckata(MSVCRT.@)
1736  */
1737 int CDECL _ismbckata(unsigned int c)
1738 {
1739   if(get_mbcinfo()->mbcodepage == 932)
1740   {
1741     /* Japanese/Katakana, CP 932 */
1742     return (c >= 0x8340 && c <= 0x8396 && c != 0x837f);
1743   }
1744   return 0;
1745 }
1746
1747
1748 /*********************************************************************
1749  *              _ismbblead_l(MSVCRT.@)
1750  */
1751 int CDECL _ismbblead_l(unsigned int c, _locale_t locale)
1752 {
1753     pthreadmbcinfo mbcinfo;
1754
1755     if(!locale)
1756         mbcinfo = get_mbcinfo();
1757     else
1758         mbcinfo = locale->mbcinfo;
1759
1760     return (mbcinfo->mbctype[(c&0xff) + 1] & _M1) != 0;
1761 }
1762
1763 /*********************************************************************
1764  *              _ismbblead(MSVCRT.@)
1765  */
1766 int CDECL _ismbblead(unsigned int c)
1767 {
1768     return _ismbblead_l(c, NULL);
1769 }
1770
1771 /*********************************************************************
1772  *              _ismbbtrail_l(MSVCRT.@)
1773  */
1774 int CDECL _ismbbtrail_l(unsigned int c, _locale_t locale)
1775 {
1776     pthreadmbcinfo mbcinfo;
1777
1778     if(!locale)
1779         mbcinfo = get_mbcinfo();
1780     else
1781         mbcinfo = locale->mbcinfo;
1782
1783     return (mbcinfo->mbctype[(c&0xff) + 1] & _M2) != 0;
1784 }
1785
1786 /*********************************************************************
1787  *              _ismbbtrail(MSVCRT.@)
1788  */
1789 int CDECL _ismbbtrail(unsigned int c)
1790 {
1791     return _ismbbtrail_l(c, NULL);
1792 }
1793
1794 /*********************************************************************
1795  *              _ismbclegal_l(MSVCRT.@)
1796  */
1797 int CDECL _ismbclegal_l(unsigned int c, _locale_t locale)
1798 {
1799     return _ismbblead_l(HIBYTE(c), locale) && _ismbbtrail_l(LOBYTE(c), locale);
1800 }
1801
1802 /*********************************************************************
1803  *              _ismbclegal(MSVCRT.@)
1804  */
1805 int CDECL _ismbclegal(unsigned int c)
1806 {
1807     return _ismbclegal_l(c, NULL);
1808 }
1809
1810 /*********************************************************************
1811  *              _ismbslead_l(MSVCRT.@)
1812  */
1813 int CDECL _ismbslead_l(const unsigned char* start, const unsigned char* str, _locale_t locale)
1814 {
1815   pthreadmbcinfo mbcinfo;
1816   int lead = 0;
1817
1818   if (!MSVCRT_CHECK_PMT(start && str))
1819     return 0;
1820
1821   if(locale)
1822       mbcinfo = locale->mbcinfo;
1823   else
1824       mbcinfo = get_mbcinfo();
1825
1826   if(!mbcinfo->ismbcodepage)
1827     return 0;
1828
1829   /* Lead bytes can also be trail bytes so we need to analyse the string
1830    */
1831   while (start <= str)
1832   {
1833     if (!*start)
1834       return 0;
1835     lead = !lead && _ismbblead_l(*start, locale);
1836     start++;
1837   }
1838
1839   return lead ? -1 : 0;
1840 }
1841
1842 /*********************************************************************
1843  *              _ismbslead(MSVCRT.@)
1844  */
1845 int CDECL _ismbslead(const unsigned char* start, const unsigned char* str)
1846 {
1847   return _ismbslead_l(start, str, NULL);
1848 }
1849
1850 /*********************************************************************
1851  *              _ismbstrail(MSVCRT.@)
1852  */
1853 int CDECL _ismbstrail(const unsigned char* start, const unsigned char* str)
1854 {
1855   /* Note: this function doesn't check _ismbbtrail */
1856   if ((str > start) && _ismbslead(start, str-1))
1857     return -1;
1858   else
1859     return 0;
1860 }
1861
1862 /*********************************************************************
1863  *              _mbbtype_l(MSVCRT.@)
1864  */
1865 int CDECL _mbbtype_l(unsigned char c, int type, _locale_t locale)
1866 {
1867     if (type == 1)
1868         return _ismbbtrail_l(c, locale) ? _MBC_TRAIL : _MBC_ILLEGAL;
1869     else
1870         return _ismbblead_l(c, locale) ? _MBC_LEAD
1871                 : _isprint_l(c, locale) ? _MBC_SINGLE : _MBC_ILLEGAL;
1872 }
1873
1874 /*********************************************************************
1875  *              _mbbtype(MSVCRT.@)
1876  */
1877 int CDECL _mbbtype(unsigned char c, int type)
1878 {
1879     return _mbbtype_l(c, type, NULL);
1880 }
1881
1882 /*********************************************************************
1883  *              _mbsbtype (MSVCRT.@)
1884  */
1885 int CDECL _mbsbtype(const unsigned char *str, size_t count)
1886 {
1887   int lead = 0;
1888   const unsigned char *end = str + count;
1889
1890   /* Lead bytes can also be trail bytes so we need to analyse the string.
1891    * Also we must return _MBC_ILLEGAL for chars past the end of the string
1892    */
1893   while (str < end) /* Note: we skip the last byte - will check after the loop */
1894   {
1895     if (!*str)
1896       return _MBC_ILLEGAL;
1897     lead = get_mbcinfo()->ismbcodepage && !lead && _ismbblead(*str);
1898     str++;
1899   }
1900
1901   if (lead)
1902     if (_ismbbtrail(*str))
1903       return _MBC_TRAIL;
1904     else
1905       return _MBC_ILLEGAL;
1906   else
1907     if (_ismbblead(*str))
1908       return _MBC_LEAD;
1909     else
1910       return _MBC_SINGLE;
1911 }
1912
1913 /*********************************************************************
1914  *              _mbsset(MSVCRT.@)
1915  */
1916 unsigned char* CDECL _mbsset(unsigned char* str, unsigned int c)
1917 {
1918   unsigned char* ret = str;
1919
1920   if(!get_mbcinfo()->ismbcodepage || c < 256)
1921     return u__strset(str, c); /* ASCII CP or SB char */
1922
1923   c &= 0xffff; /* Strip high bits */
1924
1925   while(str[0] && str[1])
1926   {
1927     *str++ = c >> 8;
1928     *str++ = c & 0xff;
1929   }
1930   if(str[0])
1931     str[0] = '\0'; /* FIXME: OK to shorten? */
1932
1933   return ret;
1934 }
1935
1936 /*********************************************************************
1937  *              _mbsnbset(MSVCRT.@)
1938  */
1939 unsigned char* CDECL _mbsnbset(unsigned char *str, unsigned int c, size_t len)
1940 {
1941     unsigned char *ret = str;
1942
1943     if(!len)
1944         return ret;
1945
1946     if(!get_mbcinfo()->ismbcodepage || c < 256)
1947         return u__strnset(str, c, len); /* ASCII CP or SB char */
1948
1949     c &= 0xffff; /* Strip high bits */
1950
1951     while(str[0] && str[1] && (len > 1))
1952     {
1953         *str++ = c >> 8;
1954         len--;
1955         *str++ = c & 0xff;
1956         len--;
1957     }
1958     if(len && str[0]) {
1959         /* as per msdn pad with a blank character */
1960         str[0] = ' ';
1961     }
1962
1963     return ret;
1964 }
1965
1966 /*********************************************************************
1967  *              _mbsnset(MSVCRT.@)
1968  */
1969 unsigned char* CDECL _mbsnset(unsigned char* str, unsigned int c, size_t len)
1970 {
1971   unsigned char *ret = str;
1972
1973   if(!len)
1974     return ret;
1975
1976   if(!get_mbcinfo()->ismbcodepage || c < 256)
1977     return u__strnset(str, c, len); /* ASCII CP or SB char */
1978
1979   c &= 0xffff; /* Strip high bits */
1980
1981   while(str[0] && str[1] && len--)
1982   {
1983     *str++ = c >> 8;
1984     *str++ = c & 0xff;
1985   }
1986   if(len && str[0])
1987     str[0] = '\0'; /* FIXME: OK to shorten? */
1988
1989   return ret;
1990 }
1991
1992 /*********************************************************************
1993  *              _mbsnccnt(MSVCRT.@)
1994  * 'c' is for 'character'.
1995  */
1996 size_t CDECL _mbsnccnt(const unsigned char* str, size_t len)
1997 {
1998   size_t ret;
1999   if(get_mbcinfo()->ismbcodepage)
2000   {
2001     ret=0;
2002     while(*str && len-- > 0)
2003     {
2004       if(_ismbblead(*str))
2005       {
2006         if (!len)
2007           break;
2008         len--;
2009         str++;
2010       }
2011       str++;
2012       ret++;
2013     }
2014     return ret;
2015   }
2016   ret=u_strlen(str);
2017   return min(ret, len); /* ASCII CP */
2018 }
2019
2020 /*********************************************************************
2021  *              _mbsnbcnt(MSVCRT.@)
2022  * 'b' is for byte count.
2023  */
2024 size_t CDECL _mbsnbcnt(const unsigned char* str, size_t len)
2025 {
2026   size_t ret;
2027   if(get_mbcinfo()->ismbcodepage)
2028   {
2029     const unsigned char* xstr = str;
2030     while(*xstr && len-- > 0)
2031     {
2032       if (_ismbblead(*xstr++))
2033         xstr++;
2034     }
2035     return xstr-str;
2036   }
2037   ret=u_strlen(str);
2038   return min(ret, len); /* ASCII CP */
2039 }
2040
2041 /*********************************************************************
2042  *              _mbsnbcat(MSVCRT.@)
2043  */
2044 unsigned char* CDECL _mbsnbcat(unsigned char* dst, const unsigned char* src, size_t len)
2045 {
2046     if(get_mbcinfo()->ismbcodepage)
2047     {
2048         unsigned char *res = dst;
2049         while (*dst) {
2050             if (_ismbblead(*dst++)) {
2051                 if (*dst) {
2052                     dst++;
2053                 } else {
2054                     /* as per msdn overwrite the lead byte in front of '\0' */
2055                     dst--;
2056                     break;
2057                 }
2058             }
2059         }
2060         while (*src && len--) *dst++ = *src++;
2061         *dst = '\0';
2062         return res;
2063     }
2064     return u_strncat(dst, src, len); /* ASCII CP */
2065 }
2066
2067 int CDECL _mbsnbcat_s(unsigned char *dst, size_t size, const unsigned char *src, size_t len)
2068 {
2069     unsigned char *ptr = dst;
2070     size_t i;
2071
2072     if (!dst && !size && !src && !len)
2073         return 0;
2074
2075     if (!dst || !size || !src)
2076     {
2077         if (dst && size)
2078             *dst = '\0';
2079
2080         *_errno() = EINVAL;
2081         return EINVAL;
2082     }
2083
2084     /* Find the null terminator of the destination buffer. */
2085     while (size && *ptr)
2086         size--, ptr++;
2087
2088     if (!size)
2089     {
2090         *dst = '\0';
2091         *_errno() = EINVAL;
2092         return EINVAL;
2093     }
2094
2095     /* If necessary, check that the character preceding the null terminator is
2096      * a lead byte and move the pointer back by one for later overwrite. */
2097     if (ptr != dst && get_mbcinfo()->ismbcodepage && _ismbblead(*(ptr - 1)))
2098         size++, ptr--;
2099
2100     for (i = 0; *src && i < len; i++)
2101     {
2102         *ptr++ = *src++;
2103         size--;
2104
2105         if (!size)
2106         {
2107             *dst = '\0';
2108             *_errno() = ERANGE;
2109             return ERANGE;
2110         }
2111     }
2112
2113     *ptr = '\0';
2114     return 0;
2115 }
2116
2117 /*********************************************************************
2118  *              _mbsncat(MSVCRT.@)
2119  */
2120 unsigned char* CDECL _mbsncat(unsigned char* dst, const unsigned char* src, size_t len)
2121 {
2122   if(get_mbcinfo()->ismbcodepage)
2123   {
2124     unsigned char *res = dst;
2125     while (*dst)
2126     {
2127       if (_ismbblead(*dst++))
2128         dst++;
2129     }
2130     while (*src && len--)
2131     {
2132       *dst++ = *src;
2133       if(_ismbblead(*src++))
2134         *dst++ = *src++;
2135     }
2136     *dst = '\0';
2137     return res;
2138   }
2139   return u_strncat(dst, src, len); /* ASCII CP */
2140 }
2141
2142
2143 /*********************************************************************
2144  *              _mbslwr(MSVCRT.@)
2145  */
2146 unsigned char* CDECL _mbslwr(unsigned char* s)
2147 {
2148   unsigned char *ret = s;
2149   if (!s)
2150     return NULL;
2151   if (get_mbcinfo()->ismbcodepage)
2152   {
2153     unsigned int c;
2154     while (*s)
2155     {
2156       c = _mbctolower(_mbsnextc(s));
2157       /* Note that I assume that the size of the character is unchanged */
2158       if (c > 255)
2159       {
2160           *s++=(c>>8);
2161           c=c & 0xff;
2162       }
2163       *s++=c;
2164     }
2165   }
2166   else for ( ; *s; s++) *s = _tolower_l(*s, NULL);
2167   return ret;
2168 }
2169
2170 /*********************************************************************
2171  *              _mbslwr_s_l(MSVCRT.@)
2172  */
2173 int CDECL _mbslwr_s_l(unsigned char* s, size_t len, _locale_t locale)
2174 {
2175   unsigned char *p = s;
2176
2177   if (!s && !len)
2178     return 0;
2179   if (!MSVCRT_CHECK_PMT(s && len))
2180     return EINVAL;
2181
2182   if (get_mbcinfo()->ismbcodepage)
2183   {
2184     unsigned int c;
2185     for ( ; *s && len > 0; len--)
2186     {
2187       c = _mbctolower_l(_mbsnextc_l(s, locale), locale);
2188       /* Note that I assume that the size of the character is unchanged */
2189       if (c > 255)
2190       {
2191           *s++=(c>>8);
2192           c=c & 0xff;
2193       }
2194       *s++=c;
2195     }
2196   }
2197   else
2198   {
2199     for ( ; *s && len > 0; s++, len--)
2200       *s = _tolower_l(*s, locale);
2201   }
2202
2203   if (!MSVCRT_CHECK_PMT(len))
2204   {
2205     *p = 0;
2206     return EINVAL;
2207   }
2208   *s = 0;
2209   return 0;
2210 }
2211
2212 /*********************************************************************
2213  *              _mbslwr_s(MSVCRT.@)
2214  */
2215 int CDECL _mbslwr_s(unsigned char* str, size_t len)
2216 {
2217   return _mbslwr_s_l(str, len, NULL);
2218 }
2219
2220 /*********************************************************************
2221  *              _mbsupr(MSVCRT.@)
2222  */
2223 unsigned char* CDECL _mbsupr(unsigned char* s)
2224 {
2225   unsigned char *ret = s;
2226   if (!s)
2227     return NULL;
2228   if (get_mbcinfo()->ismbcodepage)
2229   {
2230     unsigned int c;
2231     while (*s)
2232     {
2233       c = _mbctoupper(_mbsnextc(s));
2234       /* Note that I assume that the size of the character is unchanged */
2235       if (c > 255)
2236       {
2237           *s++=(c>>8);
2238           c=c & 0xff;
2239       }
2240       *s++=c;
2241     }
2242   }
2243   else for ( ; *s; s++) *s = _toupper_l(*s, NULL);
2244   return ret;
2245 }
2246
2247 /*********************************************************************
2248  *              _mbsupr_s_l(MSVCRT.@)
2249  */
2250 int CDECL _mbsupr_s_l(unsigned char* s, size_t len, _locale_t locale)
2251 {
2252   unsigned char *p = s;
2253
2254   if (!s && !len)
2255     return 0;
2256   if (!MSVCRT_CHECK_PMT(s && len))
2257     return EINVAL;
2258
2259   if (get_mbcinfo()->ismbcodepage)
2260   {
2261     unsigned int c;
2262     for ( ; *s && len > 0; len--)
2263     {
2264       c = _mbctoupper_l(_mbsnextc_l(s, locale), locale);
2265       /* Note that I assume that the size of the character is unchanged */
2266       if (c > 255)
2267       {
2268           *s++=(c>>8);
2269           c=c & 0xff;
2270       }
2271       *s++=c;
2272     }
2273   }
2274   else
2275   {
2276     for ( ; *s && len > 0; s++, len--)
2277       *s = _toupper_l(*s, locale);
2278   }
2279
2280   if (!MSVCRT_CHECK_PMT(len))
2281   {
2282     *p = 0;
2283     return EINVAL;
2284   }
2285   *s = 0;
2286   return 0;
2287 }
2288
2289 /*********************************************************************
2290  *              _mbsupr_s(MSVCRT.@)
2291  */
2292 int CDECL _mbsupr_s(unsigned char* s, size_t len)
2293 {
2294   return _mbsupr_s_l(s, len, NULL);
2295 }
2296
2297 /*********************************************************************
2298  *              _mbsspn_l (MSVCRT.@)
2299  */
2300 size_t CDECL _mbsspn_l(const unsigned char* string,
2301         const unsigned char* set, _locale_t locale)
2302 {
2303     const unsigned char *p, *q;
2304
2305     for (p = string; *p; p++)
2306     {
2307         for (q = set; *q; q++)
2308         {
2309             if (_ismbblead_l(*q, locale))
2310             {
2311                 /* duplicate a bug in native implementation */
2312                 if (!q[1]) break;
2313
2314                 if (p[0] == q[0] && p[1] == q[1])
2315                 {
2316                     p++;
2317                     break;
2318                 }
2319                 q++;
2320             }
2321             else
2322             {
2323                 if (p[0] == q[0]) break;
2324             }
2325         }
2326         if (!*q) break;
2327     }
2328     return p - string;
2329 }
2330
2331 /*********************************************************************
2332  *              _mbsspn (MSVCRT.@)
2333  */
2334 size_t CDECL _mbsspn(const unsigned char* string, const unsigned char* set)
2335 {
2336     return _mbsspn_l(string, set, NULL);
2337 }
2338
2339 /*********************************************************************
2340  *              _mbsspnp (MSVCRT.@)
2341  */
2342 unsigned char* CDECL _mbsspnp(const unsigned char* string, const unsigned char* set)
2343 {
2344     string += _mbsspn( string, set );
2345     return *string ? (unsigned char*)string : NULL;
2346 }
2347
2348 /*********************************************************************
2349  *              _mbscspn_l (MSVCRT.@)
2350  */
2351 size_t CDECL _mbscspn_l(const unsigned char* str,
2352         const unsigned char* cmp, _locale_t locale)
2353 {
2354     const unsigned char *p, *q;
2355
2356     for (p = str; *p; p++)
2357     {
2358         for (q = cmp; *q; q++)
2359         {
2360             if (_ismbblead_l(*q, locale))
2361             {
2362                 /* duplicate a bug in native implementation */
2363                 if (!q[1]) return 0;
2364
2365                 if (p[0] == q[0] && p[1] == q[1])
2366                     return p - str;
2367                 q++;
2368             }
2369             else if (p[0] == q[0])
2370                 return p - str;
2371         }
2372     }
2373     return p - str;
2374 }
2375
2376 /*********************************************************************
2377  *              _mbscspn (MSVCRT.@)
2378  */
2379 size_t CDECL _mbscspn(const unsigned char* str, const unsigned char* cmp)
2380 {
2381     return _mbscspn_l(str, cmp, NULL);
2382 }
2383
2384 /*********************************************************************
2385  *              _mbsrev (MSVCRT.@)
2386  */
2387 unsigned char* CDECL _mbsrev(unsigned char* str)
2388 {
2389     int i, len = _mbslen(str);
2390     unsigned char *p, *temp=malloc(len*2);
2391
2392     if(!temp)
2393         return str;
2394
2395     /* unpack multibyte string to temp buffer */
2396     p=str;
2397     for(i=0; i<len; i++)
2398     {
2399         if (_ismbblead(*p))
2400         {
2401             temp[i*2]=*p++;
2402             temp[i*2+1]=*p++;
2403         }
2404         else
2405         {
2406             temp[i*2]=*p++;
2407             temp[i*2+1]=0;
2408         }
2409     }
2410
2411     /* repack it in the reverse order */
2412     p=str;
2413     for(i=len-1; i>=0; i--)
2414     {
2415         if(_ismbblead(temp[i*2]))
2416         {
2417             *p++=temp[i*2];
2418             *p++=temp[i*2+1];
2419         }
2420         else
2421         {
2422             *p++=temp[i*2];
2423         }
2424     }
2425
2426     free(temp);
2427
2428     return str;
2429 }
2430
2431 /*********************************************************************
2432  *              _mbspbrk (MSVCRT.@)
2433  */
2434 unsigned char* CDECL _mbspbrk(const unsigned char* str, const unsigned char* accept)
2435 {
2436     const unsigned char* p;
2437
2438     while(*str)
2439     {
2440         for(p = accept; *p; p += (_ismbblead(*p)?2:1) )
2441         {
2442             if (*p == *str)
2443                 if( !_ismbblead(*p) || ( *(p+1) == *(str+1) ) )
2444                      return (unsigned char*)str;
2445         }
2446         str += (_ismbblead(*str)?2:1);
2447     }
2448     return NULL;
2449 }
2450
2451
2452 /*
2453  * Functions depending on locale codepage
2454  */
2455
2456 /*********************************************************************
2457  *              mblen(MSVCRT.@)
2458  * REMARKS
2459  *  Unlike most of the multibyte string functions this function uses
2460  *  the locale codepage, not the codepage set by _setmbcp
2461  */
2462 int CDECL mblen(const char* str, size_t size)
2463 {
2464   if (str && *str && size)
2465   {
2466     if(get_locinfo()->mb_cur_max == 1)
2467       return 1; /* ASCII CP */
2468
2469     return !isleadbyte((unsigned char)*str) ? 1 : (size>1 ? 2 : -1);
2470   }
2471   return 0;
2472 }
2473
2474 /*********************************************************************
2475  *              mbrlen(MSVCRT.@)
2476  */
2477 size_t CDECL mbrlen(const char *str, size_t len, mbstate_t *state)
2478 {
2479     mbstate_t s = (state ? *state : 0);
2480     size_t ret;
2481
2482     if(!len || !str || !*str)
2483         return 0;
2484
2485     if(get_locinfo()->mb_cur_max == 1) {
2486         return 1;
2487     }else if(!s && isleadbyte((unsigned char)*str)) {
2488         if(len == 1) {
2489             s = (unsigned char)*str;
2490             ret = -2;
2491         }else {
2492             ret = 2;
2493         }
2494     }else if(!s) {
2495         ret = 1;
2496     }else {
2497         s = 0;
2498         ret = 2;
2499     }
2500
2501     if(state)
2502         *state = s;
2503     return ret;
2504 }
2505
2506 /*********************************************************************
2507  *              _mbstrlen_l(MSVCRT.@)
2508  */
2509 size_t CDECL _mbstrlen_l(const char* str, _locale_t locale)
2510 {
2511     pthreadlocinfo locinfo;
2512
2513     if(!locale)
2514         locinfo = get_locinfo();
2515     else
2516         locinfo = locale->locinfo;
2517
2518     if(locinfo->mb_cur_max > 1) {
2519         size_t len;
2520         len = MultiByteToWideChar(locinfo->lc_codepage, MB_ERR_INVALID_CHARS,
2521                                   str, -1, NULL, 0);
2522         if (!len) {
2523             *_errno() = EILSEQ;
2524             return -1;
2525         }
2526         return len - 1;
2527     }
2528
2529     return strlen(str);
2530 }
2531
2532 /*********************************************************************
2533  *              _mbstrlen(MSVCRT.@)
2534  */
2535 size_t CDECL _mbstrlen(const char* str)
2536 {
2537     return _mbstrlen_l(str, NULL);
2538 }
2539
2540 /*********************************************************************
2541  *              _mbtowc_l(MSVCRT.@)
2542  */
2543 int CDECL _mbtowc_l(wchar_t *dst, const char* str, size_t n, _locale_t locale)
2544 {
2545     pthreadlocinfo locinfo;
2546     wchar_t tmpdst;
2547
2548     if(!locale)
2549         locinfo = get_locinfo();
2550     else
2551         locinfo = locale->locinfo;
2552
2553     if(n <= 0 || !str)
2554         return 0;
2555
2556     if(!*str) {
2557         if(dst) *dst = 0;
2558         return 0;
2559     }
2560
2561     if(!locinfo->lc_codepage) {
2562         if(dst) *dst = (unsigned char)*str;
2563         return 1;
2564     }
2565     if(n>=2 && _isleadbyte_l((unsigned char)*str, locale)) {
2566         if(!MultiByteToWideChar(locinfo->lc_codepage, 0, str, 2, &tmpdst, 1))
2567             return -1;
2568         if(dst) *dst = tmpdst;
2569         return 2;
2570     }
2571     if(!MultiByteToWideChar(locinfo->lc_codepage, 0, str, 1, &tmpdst, 1))
2572         return -1;
2573     if(dst) *dst = tmpdst;
2574     return 1;
2575 }
2576
2577 /*********************************************************************
2578  *              mbtowc(MSVCRT.@)
2579  */
2580 int CDECL mbtowc(wchar_t *dst, const char* str, size_t n)
2581 {
2582     return _mbtowc_l(dst, str, n, NULL);
2583 }
2584
2585 /*********************************************************************
2586  *              btowc(MSVCRT.@)
2587  */
2588 wint_t CDECL btowc(int c)
2589 {
2590     unsigned char letter = c;
2591     wchar_t ret;
2592
2593     if(c == EOF)
2594         return WEOF;
2595     if(!get_locinfo()->lc_codepage)
2596         return c & 255;
2597     if(!MultiByteToWideChar(get_locinfo()->lc_codepage,
2598                 MB_ERR_INVALID_CHARS, (LPCSTR)&letter, 1, &ret, 1))
2599         return WEOF;
2600
2601     return ret;
2602 }
2603
2604 /*********************************************************************
2605  *              mbrtowc(MSVCRT.@)
2606  */
2607 size_t CDECL mbrtowc(wchar_t *dst, const char *str,
2608         size_t n, mbstate_t *state)
2609 {
2610     pthreadlocinfo locinfo = get_locinfo();
2611     mbstate_t s = (state ? *state : 0);
2612     char tmpstr[2];
2613     int len = 0;
2614
2615     if(dst)
2616         *dst = 0;
2617
2618     if(!n || !str || !*str)
2619         return 0;
2620
2621     if(locinfo->mb_cur_max == 1) {
2622         tmpstr[len++] = *str;
2623     }else if(!s && isleadbyte((unsigned char)*str)) {
2624         if(n == 1) {
2625             s = (unsigned char)*str;
2626             len = -2;
2627         }else {
2628             tmpstr[0] = str[0];
2629             tmpstr[1] = str[1];
2630             len = 2;
2631         }
2632     }else if(!s) {
2633         tmpstr[len++] = *str;
2634     }else {
2635         tmpstr[0] = s;
2636         tmpstr[1] = *str;
2637         len = 2;
2638         s = 0;
2639     }
2640
2641     if(len > 0) {
2642         if(!MultiByteToWideChar(locinfo->lc_codepage, 0, tmpstr, len, dst, dst ? 1 : 0))
2643             len = -1;
2644     }
2645
2646     if(state)
2647         *state = s;
2648     return len;
2649 }
2650
2651 /*********************************************************************
2652  *              _mbstowcs_l(MSVCRT.@)
2653  */
2654 size_t CDECL _mbstowcs_l(wchar_t *wcstr, const char *mbstr,
2655         size_t count, _locale_t locale)
2656 {
2657     pthreadlocinfo locinfo;
2658     size_t i, size;
2659
2660     if(!mbstr) {
2661         *_errno() = EINVAL;
2662         return -1;
2663     }
2664
2665     if(!locale)
2666         locinfo = get_locinfo();
2667     else
2668         locinfo = locale->locinfo;
2669
2670     if(!locinfo->lc_codepage) {
2671         if(!wcstr)
2672             return strlen(mbstr);
2673
2674         for(i=0; i<count; i++) {
2675             wcstr[i] = (unsigned char)mbstr[i];
2676             if(!wcstr[i]) break;
2677         }
2678         return i;
2679     }
2680
2681     /* Ignore count parameter */
2682     if(!wcstr) {
2683         size = MultiByteToWideChar(locinfo->lc_codepage,
2684                 MB_ERR_INVALID_CHARS, mbstr, -1, NULL, 0);
2685         if(!size) {
2686             *_errno() = EILSEQ;
2687             return -1;
2688         }
2689         return size - 1;
2690     }
2691
2692     for(i=0, size=0; i<count; i++) {
2693         if(mbstr[size] == '\0')
2694             break;
2695
2696         size += (_isleadbyte_l((unsigned char)mbstr[size], locale) ? 2 : 1);
2697     }
2698
2699     if(size) {
2700         size = MultiByteToWideChar(locinfo->lc_codepage,
2701                 MB_ERR_INVALID_CHARS, mbstr, size, wcstr, count);
2702         if(!size) {
2703             if(count) wcstr[0] = '\0';
2704             *_errno() = EILSEQ;
2705             return -1;
2706         }
2707     }
2708
2709     if(size<count)
2710         wcstr[size] = '\0';
2711
2712     return size;
2713 }
2714
2715 /*********************************************************************
2716  *              mbstowcs(MSVCRT.@)
2717  */
2718 size_t CDECL mbstowcs(wchar_t *wcstr,
2719         const char *mbstr, size_t count)
2720 {
2721     return _mbstowcs_l(wcstr, mbstr, count, NULL);
2722 }
2723
2724 /*********************************************************************
2725  *              _mbstowcs_s_l(MSVCRT.@)
2726  */
2727 int CDECL _mbstowcs_s_l(size_t *ret, wchar_t *wcstr,
2728         size_t size, const char *mbstr, size_t count, _locale_t locale)
2729 {
2730     size_t conv;
2731     int err = 0;
2732
2733     if(!wcstr && !size) {
2734         conv = _mbstowcs_l(NULL, mbstr, 0, locale);
2735         if(ret)
2736             *ret = conv+1;
2737         return 0;
2738     }
2739
2740     if (!MSVCRT_CHECK_PMT(wcstr != NULL)) return EINVAL;
2741     if (!MSVCRT_CHECK_PMT(mbstr != NULL)) {
2742         if(size) wcstr[0] = '\0';
2743         return EINVAL;
2744     }
2745
2746     if(count==_TRUNCATE || size<count)
2747         conv = size;
2748     else
2749         conv = count;
2750
2751     conv = _mbstowcs_l(wcstr, mbstr, conv, locale);
2752     if(conv<size)
2753         wcstr[conv++] = '\0';
2754     else if(conv==size && count==_TRUNCATE && wcstr[conv-1]!='\0') {
2755         wcstr[conv-1] = '\0';
2756         err = STRUNCATE;
2757     }else if(conv==size && wcstr[conv-1]!='\0') {
2758         MSVCRT_INVALID_PMT("wcstr[size] is too small", ERANGE);
2759         if(size)
2760             wcstr[0] = '\0';
2761         return ERANGE;
2762     }
2763
2764     if(ret)
2765         *ret = conv;
2766     return err;
2767 }
2768
2769 /*********************************************************************
2770  *              mbstowcs_s(MSVCRT.@)
2771  */
2772 int CDECL _mbstowcs_s(size_t *ret, wchar_t *wcstr,
2773         size_t size, const char *mbstr, size_t count)
2774 {
2775     return _mbstowcs_s_l(ret, wcstr, size, mbstr, count, NULL);
2776 }
2777
2778 /*********************************************************************
2779  *              mbsrtowcs(MSVCRT.@)
2780  */
2781 size_t CDECL mbsrtowcs(wchar_t *wcstr,
2782         const char **pmbstr, size_t count, mbstate_t *state)
2783 {
2784     mbstate_t s = (state ? *state : 0);
2785     wchar_t tmpdst;
2786     size_t ret = 0;
2787     const char *p;
2788
2789     if(!MSVCRT_CHECK_PMT(pmbstr != NULL))
2790         return -1;
2791
2792     p = *pmbstr;
2793     while(!wcstr || count>ret) {
2794         int ch_len = mbrtowc(&tmpdst, p, 2, &s);
2795         if(wcstr)
2796             wcstr[ret] = tmpdst;
2797
2798         if(ch_len < 0) {
2799             return -1;
2800         }else if(ch_len == 0) {
2801             if(wcstr) *pmbstr = NULL;
2802             return ret;
2803         }
2804
2805         p += ch_len;
2806         ret++;
2807     }
2808
2809     if(wcstr) *pmbstr = p;
2810     return ret;
2811 }
2812
2813 /*********************************************************************
2814  *              mbsrtowcs_s(MSVCRT.@)
2815  */
2816 int CDECL mbsrtowcs_s(size_t *ret, wchar_t *wcstr, size_t len,
2817         const char **mbstr, size_t count, mbstate_t *state)
2818 {
2819     size_t tmp;
2820
2821     if(!ret) ret = &tmp;
2822     if(!MSVCRT_CHECK_PMT(!!wcstr == !!len)) {
2823         *ret = -1;
2824         return EINVAL;
2825     }
2826
2827     *ret = mbsrtowcs(wcstr, mbstr, count>len ? len : count, state);
2828     if(*ret == -1) {
2829         if(wcstr) *wcstr = 0;
2830         return *_errno();
2831     }
2832     (*ret)++;
2833     if(*ret > len) {
2834         /* no place for terminating '\0' */
2835         if(wcstr) *wcstr = 0;
2836         return 0;
2837     }
2838     if(wcstr) wcstr[(*ret)-1] = 0;
2839     return 0;
2840 }
2841
2842 /*********************************************************************
2843  *              _mbctohira (MSVCRT.@)
2844  *
2845  *              Converts a sjis katakana character to hiragana.
2846  */
2847 unsigned int CDECL _mbctohira(unsigned int c)
2848 {
2849     if(_ismbckata(c) && c <= 0x8393)
2850         return (c - 0x8340 - (c >= 0x837f ? 1 : 0)) + 0x829f;
2851     return c;
2852 }
2853
2854 /*********************************************************************
2855  *              _mbctokata (MSVCRT.@)
2856  *
2857  *              Converts a sjis hiragana character to katakana.
2858  */
2859 unsigned int CDECL _mbctokata(unsigned int c)
2860 {
2861     if(_ismbchira(c))
2862         return (c - 0x829f) + 0x8340 + (c >= 0x82de ? 1 : 0);
2863     return c;
2864 }
2865
2866 /*********************************************************************
2867  *              _ismbcl0_l (MSVCRT.@)
2868  */
2869 int CDECL _ismbcl0_l(unsigned int c, _locale_t locale)
2870 {
2871     pthreadmbcinfo mbcinfo;
2872
2873     if(!locale)
2874         mbcinfo = get_mbcinfo();
2875     else
2876         mbcinfo = locale->mbcinfo;
2877
2878     if(mbcinfo->mbcodepage == 932)
2879     {
2880         /* JIS non-Kanji */
2881         return _ismbclegal_l(c, locale) && c >= 0x8140 && c <= 0x889e;
2882     }
2883
2884     return 0;
2885 }
2886
2887 /*********************************************************************
2888  *              _ismbcl0 (MSVCRT.@)
2889  */
2890 int CDECL _ismbcl0(unsigned int c)
2891 {
2892     return _ismbcl0_l(c, NULL);
2893 }
2894
2895 /*********************************************************************
2896  *              _ismbcl1_l (MSVCRT.@)
2897  */
2898 int CDECL _ismbcl1_l(unsigned int c, _locale_t locale)
2899 {
2900     pthreadmbcinfo mbcinfo;
2901
2902     if(!locale)
2903         mbcinfo = get_mbcinfo();
2904     else
2905         mbcinfo = locale->mbcinfo;
2906
2907     if(mbcinfo->mbcodepage == 932)
2908     {
2909         /* JIS level-1 */
2910         return _ismbclegal_l(c, locale) && c >= 0x889f && c <= 0x9872;
2911     }
2912
2913     return 0;
2914 }
2915
2916 /*********************************************************************
2917  *              _ismbcl1 (MSVCRT.@)
2918  */
2919 int CDECL _ismbcl1(unsigned int c)
2920 {
2921     return _ismbcl1_l(c, NULL);
2922 }
2923
2924 /*********************************************************************
2925  *              _ismbcl2_l (MSVCRT.@)
2926  */
2927 int CDECL _ismbcl2_l(unsigned int c, _locale_t locale)
2928 {
2929     pthreadmbcinfo mbcinfo;
2930
2931     if(!locale)
2932         mbcinfo = get_mbcinfo();
2933     else
2934         mbcinfo = locale->mbcinfo;
2935
2936     if(mbcinfo->mbcodepage == 932)
2937     {
2938         /* JIS level-2 */
2939         return _ismbclegal_l(c, locale) && c >= 0x989f && c <= 0xeaa4;
2940     }
2941
2942     return 0;
2943 }
2944
2945 /*********************************************************************
2946  *              _ismbcl2 (MSVCRT.@)
2947  */
2948 int CDECL _ismbcl2(unsigned int c)
2949 {
2950     return _ismbcl2_l(c, NULL);
2951 }