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