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