dlls/msvcrt/mbcs.c

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