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 "msvcrt.h"
  27 #include "wine/unicode.h"
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  31
  32 unsigned char MSVCRT_mbctype[257] = { 0 };
  33 static int g_mbcp_is_multibyte = 0;
  34
  35 int MSVCRT___mb_cur_max = 1;
  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 multibyte cp932 punctuation marks to single byte equivalents */
  57 static const unsigned char mbctombb_932_punct[] = {
  58   0x20,0xa4,0xa1,0x2c,0x2e,0xa5,0x3a,0x3b,0x3f,0x21,0xde,0xdf,0x00,0x00,0x00,0x5e,
  59   0x7e,0x5f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x00,0x00,0x2f,0x00,
  60   0x00,0x00,0x7c,0x00,0x00,0x60,0x27,0x00,0x22,0x28,0x29,0x00,0x00,0x5b,0x5d,0x7b,
  61   0x7d,0x00,0x00,0x00,0x00,0xa2,0xa3,0x00,0x00,0x00,0x00,0x2b,0x2d,0x00,0x00,0x00,
  62   0x00,0x3d,0x00,0x3c,0x3e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5c,
  63   0x24,0x00,0x00,0x25,0x23,0x26,0x2a,0x40};
  64
  65 /* Maps multibyte cp932 hiragana/katakana to single-byte equivalents */
  66 static const unsigned char mbctombb_932_kana[] = {
  67   0xa7,0xb1,0xa8,0xb2,0xa9,0xb3,0xaa,0xb4,0xab,0xb5,0xb6,0xb6,0xb7,0xb7,0xb8,0xb8,
  68   0xb9,0xb9,0xba,0xba,0xbb,0xbb,0xbc,0xbc,0xbd,0xbd,0xbe,0xbe,0xbf,0xbf,0xc0,0xc0,
  69   0xc1,0xc1,0xaf,0xc2,0xc2,0xc3,0xc3,0xc4,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xca,
  70   0xca,0xcb,0xcb,0xcb,0xcc,0xcc,0xcc,0xcd,0xcd,0xcd,0xce,0xce,0xce,0xcf,0xd0,0xd1,
  71   0xd2,0xd3,0xac,0xd4,0xad,0xd5,0xae,0xd6,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdc,0xb2,
  72   0xb4,0xa6,0xdd,0xb3,0xb6,0xb9};
  73
  74 static MSVCRT_wchar_t msvcrt_mbc_to_wc(unsigned int ch)
  75 {
  76   MSVCRT_wchar_t chW;
  77   char mbch[2];
  78   int n_chars;
  79
  80   if (ch <= 0xff) {
  81     mbch[0] = ch;
  82     n_chars = 1;
  83   } else {
  84     mbch[0] = (ch >> 8) & 0xff;
  85     mbch[1] = ch & 0xff;
  86     n_chars = 2;
  87   }
  88   if (!MultiByteToWideChar(get_locale()->locinfo->lc_codepage, 0, mbch, n_chars, &chW, 1))
  89   {
  90     WARN("MultiByteToWideChar failed on %x\n", ch);
  91     return 0;
  92   }
  93   return chW;
  94 }
  95
  96 static inline MSVCRT_size_t u_strlen( const unsigned char *str )
  97 {
  98   return strlen( (const char*) str );
  99 }
 100
 101 static inline unsigned char* u_strncat( unsigned char* dst, const unsigned char* src, MSVCRT_size_t len )
 102 {
 103   return (unsigned char*)strncat( (char*)dst, (const char*)src, len);
 104 }
 105
 106 static inline int u_strcmp( const unsigned char *s1, const unsigned char *s2 )
 107 {
 108   return strcmp( (const char*)s1, (const char*)s2 );
 109 }
 110
 111 static inline int u_strcasecmp( const unsigned char *s1, const unsigned char *s2 )
 112 {
 113   return strcasecmp( (const char*)s1, (const char*)s2 );
 114 }
 115
 116 static inline int u_strncmp( const unsigned char *s1, const unsigned char *s2, MSVCRT_size_t len )
 117 {
 118   return strncmp( (const char*)s1, (const char*)s2, len );
 119 }
 120
 121 static inline int u_strncasecmp( const unsigned char *s1, const unsigned char *s2, MSVCRT_size_t len )
 122 {
 123   return strncasecmp( (const char*)s1, (const char*)s2, len );
 124 }
 125
 126 static inline unsigned char *u_strchr( const unsigned char *s, unsigned char x )
 127 {
 128   return (unsigned char*) strchr( (const char*)s, x );
 129 }
 130
 131 static inline unsigned char *u_strrchr( const unsigned char *s, unsigned char x )
 132 {
 133   return (unsigned char*) strrchr( (const char*)s, x );
 134 }
 135
 136 static inline unsigned char *u_strtok( unsigned char *s, const unsigned char *delim )
 137 {
 138   return (unsigned char*) strtok( (char*)s, (const char*)delim );
 139 }
 140
 141 static inline unsigned char *u__strset( unsigned char *s, unsigned char c )
 142 {
 143   return (unsigned char*) _strset( (char*)s, c);
 144 }
 145
 146 static inline unsigned char *u__strnset( unsigned char *s, unsigned char c, MSVCRT_size_t len )
 147 {
 148   return (unsigned char*) MSVCRT__strnset( (char*)s, c, len );
 149 }
 150
 151 static inline MSVCRT_size_t u_strcspn( const unsigned char *s, const unsigned char *rej )
 152 {
 153   return strcspn( (const char *)s, (const char*)rej );
 154 }
 155
 156 /*********************************************************************
 157  *              __p__mbctype (MSVCRT.@)
 158  */
 159 unsigned char* CDECL __p__mbctype(void)
 160 {
 161   return MSVCRT_mbctype;
 162 }
 163
 164 /*********************************************************************
 165  *              ___mb_cur_max_func(MSVCRT.@)
 166  */
 167 int* CDECL MSVCRT____mb_cur_max_func(void)
 168 {
 169   return &get_locale()->locinfo->mb_cur_max;
 170 }
 171
 172 /* ___mb_cur_max_l_func - not exported in native msvcrt */
 173 int* CDECL ___mb_cur_max_l_func(MSVCRT__locale_t locale)
 174 {
 175   if(!locale)
 176     locale = get_locale();
 177
 178   return &locale->locinfo->mb_cur_max;
 179 }
 180
 181 /*********************************************************************
 182  *              _setmbcp (MSVCRT.@)
 183  */
 184 int CDECL _setmbcp(int cp)
 185 {
 186   MSVCRT__locale_t locale = get_locale();
 187   int newcp;
 188   CPINFO cpi;
 189   BYTE *bytes;
 190   WORD chartypes[256];
 191   WORD *curr_type;
 192   char bufA[256];
 193   WCHAR bufW[256];
 194   int charcount;
 195   int ret;
 196   int i;
 197
 198   switch (cp)
 199   {
 200     case _MB_CP_ANSI:
 201       newcp = GetACP();
 202       break;
 203     case _MB_CP_OEM:
 204       newcp = GetOEMCP();
 205       break;
 206     case _MB_CP_LOCALE:
 207       newcp = locale->locinfo->lc_codepage;
 208       break;
 209     case _MB_CP_SBCS:
 210       newcp = 20127;   /* ASCII */
 211       break;
 212     default:
 213       newcp = cp;
 214       break;
 215   }
 216
 217   if (!GetCPInfo(newcp, &cpi))
 218   {
 219     WARN("Codepage %d not found\n", newcp);
 220     *MSVCRT__errno() = MSVCRT_EINVAL;
 221     return -1;
 222   }
 223
 224   /* setup the _mbctype */
 225   memset(MSVCRT_mbctype, 0, sizeof(MSVCRT_mbctype));
 226
 227   bytes = cpi.LeadByte;
 228   while (bytes[0] || bytes[1])
 229   {
 230     for (i = bytes[0]; i <= bytes[1]; i++)
 231       MSVCRT_mbctype[i + 1] |= _M1;
 232     bytes += 2;
 233   }
 234
 235   if (cpi.MaxCharSize > 1)
 236   {
 237     /* trail bytes not available through kernel32 but stored in a structure in msvcrt */
 238     struct cp_extra_info_t *cpextra = g_cpextrainfo;
 239
 240     g_mbcp_is_multibyte = 1;
 241     while (TRUE)
 242     {
 243       if (cpextra->cp == 0 || cpextra->cp == newcp)
 244       {
 245         if (cpextra->cp == 0)
 246           FIXME("trail bytes data not available for DBCS codepage %d - assuming all bytes\n", newcp);
 247
 248         bytes = cpextra->TrailBytes;
 249         while (bytes[0] || bytes[1])
 250         {
 251           for (i = bytes[0]; i <= bytes[1]; i++)
 252             MSVCRT_mbctype[i + 1] |= _M2;
 253           bytes += 2;
 254         }
 255         break;
 256       }
 257       cpextra++;
 258     }
 259   }
 260   else
 261     g_mbcp_is_multibyte = 0;
 262
 263   /* we can't use GetStringTypeA directly because we don't have a locale - only a code page
 264    */
 265   charcount = 0;
 266   for (i = 0; i < 256; i++)
 267     if (!(MSVCRT_mbctype[i + 1] & _M1))
 268       bufA[charcount++] = i;
 269
 270   ret = MultiByteToWideChar(newcp, 0, bufA, charcount, bufW, charcount);
 271   if (ret != charcount)
 272     ERR("MultiByteToWideChar of chars failed for cp %d, ret=%d (exp %d), error=%d\n", newcp, ret, charcount, GetLastError());
 273
 274   GetStringTypeW(CT_CTYPE1, bufW, charcount, chartypes);
 275
 276   curr_type = chartypes;
 277   for (i = 0; i < 256; i++)
 278     if (!(MSVCRT_mbctype[i + 1] & _M1))
 279     {
 280         if ((*curr_type) & C1_UPPER)
 281             MSVCRT_mbctype[i + 1] |= _SBUP;
 282         if ((*curr_type) & C1_LOWER)
 283             MSVCRT_mbctype[i + 1] |= _SBLOW;
 284         curr_type++;
 285     }
 286
 287   if (newcp == 932)   /* CP932 only - set _MP and _MS */
 288   {
 289     /* On Windows it's possible to calculate the _MP and _MS from CT_CTYPE1
 290      * and CT_CTYPE3. But as of Wine 0.9.43 we return wrong values what makes
 291      * it hard. As this is set only for codepage 932 we hardcode it what gives
 292      * also faster execution.
 293      */
 294     for (i = 161; i <= 165; i++)
 295       MSVCRT_mbctype[i + 1] |= _MP;
 296     for (i = 166; i <= 223; i++)
 297       MSVCRT_mbctype[i + 1] |= _MS;
 298   }
 299
 300   locale->locinfo->lc_collate_cp = newcp;
 301   locale->locinfo->lc_codepage = newcp;
 302   TRACE("(%d) -> %d\n", cp, locale->locinfo->lc_codepage);
 303   return 0;
 304 }
 305
 306 /*********************************************************************
 307  *              _getmbcp (MSVCRT.@)
 308  */
 309 int CDECL _getmbcp(void)
 310 {
 311   /* FIXME: get_locale()->mbcinfo->mbcodepage should be used here */
 312   return get_locale()->locinfo->lc_codepage;
 313 }
 314
 315 /*********************************************************************
 316  *              _mbsnextc(MSVCRT.@)
 317  */
 318 unsigned int CDECL _mbsnextc(const unsigned char* str)
 319 {
 320   if(_ismbblead(*str))
 321     return *str << 8 | str[1];
 322   return *str;
 323 }
 324
 325 /*********************************************************************
 326  *              _mbctolower(MSVCRT.@)
 327  */
 328 unsigned int CDECL _mbctolower(unsigned int c)
 329 {
 330     if (MSVCRT_isleadbyte(c))
 331     {
 332       FIXME("Handle MBC chars\n");
 333       return c;
 334     }
 335     return tolower(c); /* ASCII CP or SB char */
 336 }
 337
 338 /*********************************************************************
 339  *              _mbctoupper(MSVCRT.@)
 340  */
 341 unsigned int CDECL _mbctoupper(unsigned int c)
 342 {
 343     if (MSVCRT_isleadbyte(c))
 344     {
 345       FIXME("Handle MBC chars\n");
 346       return c;
 347     }
 348     return toupper(c); /* ASCII CP or SB char */
 349 }
 350
 351 /*********************************************************************
 352  *              _mbctombb (MSVCRT.@)
 353  */
 354 unsigned int CDECL _mbctombb(unsigned int c)
 355 {
 356     unsigned int value;
 357
 358     if(get_locale()->locinfo->lc_codepage == 932)
 359     {
 360         if(c >= 0x829f && c <= 0x82f1)    /* Hiragana */
 361             return mbctombb_932_kana[c - 0x829f];
 362         if(c >= 0x8340 && c <= 0x8396 && c != 0x837f)    /* Katakana */
 363             return mbctombb_932_kana[c - 0x8340 - (c >= 0x837f ? 1 : 0)];
 364         if(c >= 0x8140 && c <= 0x8197)    /* Punctuation */
 365         {
 366             value = mbctombb_932_punct[c - 0x8140];
 367             return value ? value : c;
 368         }
 369         if((c >= 0x824f && c <= 0x8258) || /* Fullwidth digits */
 370            (c >= 0x8260 && c <= 0x8279))   /* Fullwidth capitals letters */
 371             return c - 0x821f;
 372         if(c >= 0x8281 && c <= 0x829a)     /* Fullwidth small letters */
 373             return c - 0x8220;
 374         /* all other cases return c */
 375     }
 376     return c;
 377 }
 378
 379 /*********************************************************************
 380  *              _mbcjistojms(MSVCRT.@)
 381  *
 382  *              Converts a jis character to sjis.
 383  *              Based on description from
 384  *              http://www.slayers.ne.jp/~oouchi/code/jistosjis.html
 385  */
 386 unsigned int CDECL _mbcjistojms(unsigned int c)
 387 {
 388   /* Conversion takes place only when codepage is 932.
 389      In all other cases, c is returned unchanged */
 390   if(get_locale()->locinfo->lc_codepage == 932)
 391   {
 392     if(HIBYTE(c) >= 0x21 && HIBYTE(c) <= 0x7e &&
 393        LOBYTE(c) >= 0x21 && LOBYTE(c) <= 0x7e)
 394     {
 395       if(HIBYTE(c) % 2)
 396         c += 0x1f;
 397       else
 398         c += 0x7d;
 399
 400       if(LOBYTE(c) > 0x7F)
 401         c += 0x1;
 402
 403       c = (((HIBYTE(c) - 0x21)/2 + 0x81) << 8) | LOBYTE(c);
 404
 405       if(HIBYTE(c) > 0x9f)
 406         c += 0x4000;
 407     }
 408     else
 409       return 0; /* Codepage is 932, but c can't be converted */
 410   }
 411
 412   return c;
 413 }
 414
 415 /*********************************************************************
 416  *              _mbsdec(MSVCRT.@)
 417  */
 418 unsigned char* CDECL _mbsdec(const unsigned char* start, const unsigned char* cur)
 419 {
 420   if(get_locale()->locinfo->mb_cur_max > 1)
 421     return (unsigned char *)(_ismbstrail(start,cur-1) ? cur - 2 : cur -1);
 422
 423   return (unsigned char *)cur - 1; /* ASCII CP or SB char */
 424 }
 425
 426 /*********************************************************************
 427  *              _mbclen(MSVCRT.@)
 428  */
 429 unsigned int CDECL _mbclen(const unsigned char* str)
 430 {
 431   return _ismbblead(*str) ? 2 : 1;
 432 }
 433
 434 /*********************************************************************
 435  *              _mbsinc(MSVCRT.@)
 436  */
 437 unsigned char* CDECL _mbsinc(const unsigned char* str)
 438 {
 439   return (unsigned char *)(str + _mbclen(str));
 440 }
 441
 442 /*********************************************************************
 443  *              _mbsninc(MSVCRT.@)
 444  */
 445 unsigned char* CDECL _mbsninc(const unsigned char* str, MSVCRT_size_t num)
 446 {
 447   if(!str)
 448     return NULL;
 449
 450   while (num > 0 && *str)
 451   {
 452     if (_ismbblead(*str))
 453     {
 454       if (!*(str+1))
 455          break;
 456       str++;
 457     }
 458     str++;
 459     num--;
 460   }
 461
 462   return (unsigned char*)str;
 463 }
 464
 465 /*********************************************************************
 466  *              _mbslen(MSVCRT.@)
 467  */
 468 MSVCRT_size_t CDECL _mbslen(const unsigned char* str)
 469 {
 470   MSVCRT_size_t len = 0;
 471   while(*str)
 472   {
 473     if (_ismbblead(*str))
 474     {
 475       str++;
 476       if (!*str)  /* count only full chars */
 477         break;
 478     }
 479     str++;
 480     len++;
 481   }
 482   return len;
 483 }
 484
 485 /*********************************************************************
 486  *              _mbccpy(MSVCRT.@)
 487  */
 488 void CDECL _mbccpy(unsigned char* dest, const unsigned char* src)
 489 {
 490   *dest = *src;
 491   if(_ismbblead(*src))
 492     *++dest = *++src; /* MB char */
 493 }
 494
 495 /*********************************************************************
 496  *              _mbsncpy(MSVCRT.@)
 497  * REMARKS
 498  *  The parameter n is the number or characters to copy, not the size of
 499  *  the buffer. Use _mbsnbcpy for a function analogical to strncpy
 500  */
 501 unsigned char* CDECL _mbsncpy(unsigned char* dst, const unsigned char* src, MSVCRT_size_t n)
 502 {
 503   unsigned char* ret = dst;
 504   if(!n)
 505     return dst;
 506   if (g_mbcp_is_multibyte)
 507   {
 508     while (*src && n)
 509     {
 510       n--;
 511       if (_ismbblead(*src))
 512       {
 513         if (!*(src+1))
 514         {
 515             *dst++ = 0;
 516             *dst++ = 0;
 517             break;
 518         }
 519
 520         *dst++ = *src++;
 521       }
 522
 523       *dst++ = *src++;
 524     }
 525   }
 526   else
 527   {
 528     while (n)
 529     {
 530         n--;
 531         if (!(*dst++ = *src++)) break;
 532     }
 533   }
 534   while (n--) *dst++ = 0;
 535   return ret;
 536 }
 537
 538 /*********************************************************************
 539  *              _mbsnbcpy_s(MSVCRT.@)
 540  * REMARKS
 541  * Unlike _mbsnbcpy this function does not pad the rest of the dest
 542  * string with 0
 543  */
 544 int CDECL _mbsnbcpy_s(unsigned char* dst, MSVCRT_size_t size, const unsigned char* src, MSVCRT_size_t n)
 545 {
 546     MSVCRT_size_t pos = 0;
 547
 548     if(!dst || size == 0)
 549         return MSVCRT_EINVAL;
 550     if(!src)
 551     {
 552         dst[0] = '\0';
 553         return MSVCRT_EINVAL;
 554     }
 555     if(!n)
 556         return 0;
 557
 558     if(g_mbcp_is_multibyte)
 559     {
 560         int is_lead = 0;
 561         while (*src && n)
 562         {
 563             if(pos == size)
 564             {
 565                 dst[0] = '\0';
 566                 return MSVCRT_ERANGE;
 567             }
 568             is_lead = (!is_lead && _ismbblead(*src));
 569             n--;
 570             dst[pos++] = *src++;
 571         }
 572
 573         if (is_lead) /* if string ends with a lead, remove it */
 574             dst[pos - 1] = 0;
 575     }
 576     else
 577     {
 578         while (n)
 579         {
 580             n--;
 581             if(pos == size)
 582             {
 583                 dst[0] = '\0';
 584                 return MSVCRT_ERANGE;
 585             }
 586
 587             if(!(*src)) break;
 588             dst[pos++] = *src++;
 589         }
 590     }
 591
 592     if(pos < size)
 593         dst[pos] = '\0';
 594     else
 595     {
 596         dst[0] = '\0';
 597         return MSVCRT_ERANGE;
 598     }
 599
 600     return 0;
 601 }
 602
 603 /*********************************************************************
 604  *              _mbsnbcpy(MSVCRT.@)
 605  * REMARKS
 606  *  Like strncpy this function doesn't enforce the string to be
 607  *  NUL-terminated
 608  */
 609 unsigned char* CDECL _mbsnbcpy(unsigned char* dst, const unsigned char* src, MSVCRT_size_t n)
 610 {
 611   unsigned char* ret = dst;
 612   if(!n)
 613     return dst;
 614   if(g_mbcp_is_multibyte)
 615   {
 616     int is_lead = 0;
 617     while (*src && n)
 618     {
 619       is_lead = (!is_lead && _ismbblead(*src));
 620       n--;
 621       *dst++ = *src++;
 622     }
 623
 624     if (is_lead) /* if string ends with a lead, remove it */
 625         *(dst - 1) = 0;
 626   }
 627   else
 628   {
 629     while (n)
 630     {
 631         n--;
 632         if (!(*dst++ = *src++)) break;
 633     }
 634   }
 635   while (n--) *dst++ = 0;
 636   return ret;
 637 }
 638
 639 /*********************************************************************
 640  *              _mbscmp(MSVCRT.@)
 641  */
 642 int CDECL _mbscmp(const unsigned char* str, const unsigned char* cmp)
 643 {
 644   if(get_locale()->locinfo->mb_cur_max > 1)
 645   {
 646     unsigned int strc, cmpc;
 647     do {
 648       if(!*str)
 649         return *cmp ? -1 : 0;
 650       if(!*cmp)
 651         return 1;
 652       strc = _mbsnextc(str);
 653       cmpc = _mbsnextc(cmp);
 654       if(strc != cmpc)
 655         return strc < cmpc ? -1 : 1;
 656       str +=(strc > 255) ? 2 : 1;
 657       cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
 658     } while(1);
 659   }
 660   return u_strcmp(str, cmp); /* ASCII CP */
 661 }
 662
 663 /*********************************************************************
 664  *              _mbsicoll(MSVCRT.@)
 665  * FIXME: handle locales.
 666  */
 667 int CDECL _mbsicoll(const unsigned char* str, const unsigned char* cmp)
 668 {
 669   if(get_locale()->locinfo->mb_cur_max > 1)
 670   {
 671     unsigned int strc, cmpc;
 672     do {
 673       if(!*str)
 674         return *cmp ? -1 : 0;
 675       if(!*cmp)
 676         return 1;
 677       strc = _mbctolower(_mbsnextc(str));
 678       cmpc = _mbctolower(_mbsnextc(cmp));
 679       if(strc != cmpc)
 680         return strc < cmpc ? -1 : 1;
 681       str +=(strc > 255) ? 2 : 1;
 682       cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
 683     } while(1);
 684   }
 685   return u_strcasecmp(str, cmp); /* ASCII CP */
 686 }
 687
 688 /*********************************************************************
 689  *              _mbscoll(MSVCRT.@)
 690  * Performs a case-sensitive comparison according to the current code page
 691  * RETURN
 692  *   _NLSCMPERROR if error
 693  * FIXME: handle locales.
 694  */
 695 int CDECL _mbscoll(const unsigned char* str, const unsigned char* cmp)
 696 {
 697   if(get_locale()->locinfo->mb_cur_max > 1)
 698   {
 699     unsigned int strc, cmpc;
 700     do {
 701       if(!*str)
 702         return *cmp ? -1 : 0;
 703       if(!*cmp)
 704         return 1;
 705       strc = _mbsnextc(str);
 706       cmpc = _mbsnextc(cmp);
 707       if(strc != cmpc)
 708         return strc < cmpc ? -1 : 1;
 709       str +=(strc > 255) ? 2 : 1;
 710       cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
 711     } while(1);
 712   }
 713   return u_strcmp(str, cmp); /* ASCII CP */
 714 }
 715
 716
 717 /*********************************************************************
 718  *              _mbsicmp(MSVCRT.@)
 719  */
 720 int CDECL _mbsicmp(const unsigned char* str, const unsigned char* cmp)
 721 {
 722   if(get_locale()->locinfo->mb_cur_max > 1)
 723   {
 724     unsigned int strc, cmpc;
 725     do {
 726       if(!*str)
 727         return *cmp ? -1 : 0;
 728       if(!*cmp)
 729         return 1;
 730       strc = _mbctolower(_mbsnextc(str));
 731       cmpc = _mbctolower(_mbsnextc(cmp));
 732       if(strc != cmpc)
 733         return strc < cmpc ? -1 : 1;
 734       str +=(strc > 255) ? 2 : 1;
 735       cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
 736     } while(1);
 737   }
 738   return u_strcasecmp(str, cmp); /* ASCII CP */
 739 }
 740
 741 /*********************************************************************
 742  *              _mbsncmp(MSVCRT.@)
 743  */
 744 int CDECL _mbsncmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 745 {
 746   if(!len)
 747     return 0;
 748
 749   if(get_locale()->locinfo->mb_cur_max > 1)
 750   {
 751     unsigned int strc, cmpc;
 752     while(len--)
 753     {
 754       int inc;
 755       if(!*str)
 756         return *cmp ? -1 : 0;
 757       if(!*cmp)
 758         return 1;
 759       strc = _mbsnextc(str);
 760       cmpc = _mbsnextc(cmp);
 761       if(strc != cmpc)
 762         return strc < cmpc ? -1 : 1;
 763       inc=(strc > 255) ? 2 : 1; /* Equal, use same increment */
 764       str += inc;
 765       cmp += inc;
 766     }
 767     return 0; /* Matched len chars */
 768   }
 769   return u_strncmp(str, cmp, len); /* ASCII CP */
 770 }
 771
 772 /*********************************************************************
 773  *              _mbsnbcmp(MSVCRT.@)
 774  */
 775 int CDECL _mbsnbcmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 776 {
 777   if (!len)
 778     return 0;
 779   if(get_locale()->locinfo->mb_cur_max > 1)
 780   {
 781     unsigned int strc, cmpc;
 782     while (len)
 783     {
 784       int clen;
 785       if(!*str)
 786         return *cmp ? -1 : 0;
 787       if(!*cmp)
 788         return 1;
 789       if (MSVCRT_isleadbyte(*str))
 790       {
 791         strc=(len>=2)?_mbsnextc(str):0;
 792         clen=2;
 793       }
 794       else
 795       {
 796         strc=*str;
 797         clen=1;
 798       }
 799       if (MSVCRT_isleadbyte(*cmp))
 800         cmpc=(len>=2)?_mbsnextc(cmp):0;
 801       else
 802         cmpc=*str;
 803       if(strc != cmpc)
 804         return strc < cmpc ? -1 : 1;
 805       len -= clen;
 806       str += clen;
 807       cmp += clen;
 808     }
 809     return 0; /* Matched len chars */
 810   }
 811   return u_strncmp(str,cmp,len);
 812 }
 813
 814 /*********************************************************************
 815  *              _mbsnicmp(MSVCRT.@)
 816  *
 817  * Compare two multibyte strings case insensitively to 'len' characters.
 818  */
 819 int CDECL _mbsnicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 820 {
 821   /* FIXME: No tolower() for mb strings yet */
 822   if(get_locale()->locinfo->mb_cur_max > 1)
 823   {
 824     unsigned int strc, cmpc;
 825     while(len--)
 826     {
 827       if(!*str)
 828         return *cmp ? -1 : 0;
 829       if(!*cmp)
 830         return 1;
 831       strc = _mbctolower(_mbsnextc(str));
 832       cmpc = _mbctolower(_mbsnextc(cmp));
 833       if(strc != cmpc)
 834         return strc < cmpc ? -1 : 1;
 835       str +=(strc > 255) ? 2 : 1;
 836       cmp +=(strc > 255) ? 2 : 1; /* Equal, use same increment */
 837     }
 838     return 0; /* Matched len chars */
 839   }
 840   return u_strncasecmp(str, cmp, len); /* ASCII CP */
 841 }
 842
 843 /*********************************************************************
 844  *              _mbsnbicmp(MSVCRT.@)
 845  */
 846 int CDECL _mbsnbicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 847 {
 848   if (!len)
 849     return 0;
 850   if(get_locale()->locinfo->mb_cur_max > 1)
 851   {
 852     unsigned int strc, cmpc;
 853     while (len)
 854     {
 855       int clen;
 856       if(!*str)
 857         return *cmp ? -1 : 0;
 858       if(!*cmp)
 859         return 1;
 860       if (MSVCRT_isleadbyte(*str))
 861       {
 862         strc=(len>=2)?_mbsnextc(str):0;
 863         clen=2;
 864       }
 865       else
 866       {
 867         strc=*str;
 868         clen=1;
 869       }
 870       if (MSVCRT_isleadbyte(*cmp))
 871         cmpc=(len>=2)?_mbsnextc(cmp):0;
 872       else
 873         cmpc=*str;
 874       strc = _mbctolower(strc);
 875       cmpc = _mbctolower(cmpc);
 876       if(strc != cmpc)
 877         return strc < cmpc ? -1 : 1;
 878       len -= clen;
 879       str += clen;
 880       cmp += clen;
 881     }
 882     return 0; /* Matched len bytes */
 883   }
 884   return u_strncasecmp(str,cmp,len);
 885 }
 886
 887 /*********************************************************************
 888  *              _mbscat (MSVCRT.@)
 889  */
 890 unsigned char * CDECL _mbscat( unsigned char *dst, const unsigned char *src )
 891 {
 892     strcat( (char *)dst, (const char *)src );
 893     return dst;
 894 }
 895
 896 /*********************************************************************
 897  *              _mbscpy (MSVCRT.@)
 898  */
 899 unsigned char* CDECL _mbscpy( unsigned char *dst, const unsigned char *src )
 900 {
 901     strcpy( (char *)dst, (const char *)src );
 902     return dst;
 903 }
 904
 905 /*********************************************************************
 906  *              _mbsstr (MSVCRT.@)
 907  */
 908 unsigned char * CDECL _mbsstr(const unsigned char *haystack, const unsigned char *needle)
 909 {
 910     return (unsigned char *)strstr( (const char *)haystack, (const char *)needle );
 911 }
 912
 913 /*********************************************************************
 914  *              _mbschr(MSVCRT.@)
 915  *
 916  * Find a multibyte character in a multibyte string.
 917  */
 918 unsigned char* CDECL _mbschr(const unsigned char* s, unsigned int x)
 919 {
 920   if(get_locale()->locinfo->mb_cur_max > 1)
 921   {
 922     unsigned int c;
 923     while (1)
 924     {
 925       c = _mbsnextc(s);
 926       if (c == x)
 927         return (unsigned char*)s;
 928       if (!c)
 929         return NULL;
 930       s += c > 255 ? 2 : 1;
 931     }
 932   }
 933   return u_strchr(s, x); /* ASCII CP */
 934 }
 935
 936 /*********************************************************************
 937  *              _mbsrchr(MSVCRT.@)
 938  */
 939 unsigned char* CDECL _mbsrchr(const unsigned char* s, unsigned int x)
 940 {
 941   if(get_locale()->locinfo->mb_cur_max > 1)
 942   {
 943     unsigned int c;
 944     unsigned char* match=NULL;
 945     if(!s)
 946       return NULL;
 947     while (1) {
 948       c = _mbsnextc(s);
 949       if (c == x)
 950         match=(unsigned char*)s;
 951       if (!c)
 952         return match;
 953       s +=(c > 255) ? 2 : 1;
 954     }
 955   }
 956   return u_strrchr(s, x);
 957 }
 958
 959 /*********************************************************************
 960  *              _mbstok(MSVCRT.@)
 961  *
 962  * Find and extract tokens from strings
 963  */
 964 unsigned char* CDECL _mbstok(unsigned char *str, const unsigned char *delim)
 965 {
 966     thread_data_t *data = msvcrt_get_thread_data();
 967     unsigned char *ret;
 968
 969     if(get_locale()->locinfo->mb_cur_max > 1)
 970     {
 971         unsigned int c;
 972
 973         if (!str)
 974             if (!(str = data->mbstok_next)) return NULL;
 975
 976         while ((c = _mbsnextc(str)) && _mbschr(delim, c)) {
 977             str += c > 255 ? 2 : 1;
 978         }
 979         if (!*str) return NULL;
 980         ret = str++;
 981         while ((c = _mbsnextc(str)) && !_mbschr(delim, c)) {
 982             str += c > 255 ? 2 : 1;
 983         }
 984         if (*str) {
 985             *str++ = 0;
 986             if (c > 255) *str++ = 0;
 987         }
 988         data->mbstok_next = str;
 989         return ret;
 990     }
 991     return u_strtok(str, delim); /* ASCII CP */
 992 }
 993
 994 /*********************************************************************
 995  *              mbtowc(MSVCRT.@)
 996  */
 997 int CDECL MSVCRT_mbtowc(MSVCRT_wchar_t *dst, const char* str, MSVCRT_size_t n)
 998 {
 999     /* temp var needed because MultiByteToWideChar wants non NULL destination */
1000     MSVCRT_wchar_t tmpdst = '\0';
1001
1002     if(n <= 0 || !str)
1003         return 0;
1004     if(!MultiByteToWideChar(CP_ACP, 0, str, n, &tmpdst, 1))
1005         return -1;
1006     if(dst)
1007         *dst = tmpdst;
1008     /* return the number of bytes from src that have been used */
1009     if(!*str)
1010         return 0;
1011     if(n >= 2 && MSVCRT_isleadbyte(*str) && str[1])
1012         return 2;
1013     return 1;
1014 }
1015
1016 /*********************************************************************
1017  *              _mbbtombc(MSVCRT.@)
1018  */
1019 unsigned int CDECL _mbbtombc(unsigned int c)
1020 {
1021   if(get_locale()->locinfo->mb_cur_max > 1 &&
1022      ((c >= 0x20 && c <=0x7e) ||(c >= 0xa1 && c <= 0xdf)))
1023   {
1024     /* FIXME: I can't get this function to return anything
1025      * different from what I pass it...
1026      */
1027   }
1028   return c;  /* ASCII CP or no MB char */
1029 }
1030
1031 /*********************************************************************
1032  *              _mbbtype(MSVCRT.@)
1033  */
1034 int CDECL _mbbtype(unsigned char c, int type)
1035 {
1036     if (type == 1)
1037     {
1038         if ((c >= 0x20 && c <= 0x7e) || (c >= 0xa1 && c <= 0xdf))
1039             return _MBC_SINGLE;
1040         else if ((c >= 0x40 && c <= 0x7e) || (c >= 0x80 && c <= 0xfc))
1041             return _MBC_TRAIL;
1042         else
1043             return _MBC_ILLEGAL;
1044     }
1045     else
1046     {
1047         if ((c >= 0x20 && c <= 0x7e) || (c >= 0xa1 && c <= 0xdf))
1048             return _MBC_SINGLE;
1049         else if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfc))
1050             return _MBC_LEAD;
1051         else
1052             return _MBC_ILLEGAL;
1053     }
1054 }
1055
1056 /*********************************************************************
1057  *              _ismbbkana(MSVCRT.@)
1058  */
1059 int CDECL _ismbbkana(unsigned int c)
1060 {
1061   /* FIXME: use lc_ctype when supported, not lc_all */
1062   if(get_locale()->locinfo->lc_codepage == 932)
1063   {
1064     /* Japanese/Katakana, CP 932 */
1065     return (c >= 0xa1 && c <= 0xdf);
1066   }
1067   return 0;
1068 }
1069
1070 /*********************************************************************
1071  *              _ismbcdigit(MSVCRT.@)
1072  */
1073 int CDECL _ismbcdigit(unsigned int ch)
1074 {
1075     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1076     return (get_char_typeW( wch ) & C1_DIGIT);
1077 }
1078
1079 /*********************************************************************
1080  *              _ismbcgraph(MSVCRT.@)
1081  */
1082 int CDECL _ismbcgraph(unsigned int ch)
1083 {
1084     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1085     return (get_char_typeW( wch ) & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA));
1086 }
1087
1088 /*********************************************************************
1089  *              _ismbcalpha (MSVCRT.@)
1090  */
1091 int CDECL _ismbcalpha(unsigned int ch)
1092 {
1093     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1094     return (get_char_typeW( wch ) & C1_ALPHA);
1095 }
1096
1097 /*********************************************************************
1098  *              _ismbclower (MSVCRT.@)
1099  */
1100 int CDECL _ismbclower(unsigned int ch)
1101 {
1102     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1103     return (get_char_typeW( wch ) & C1_UPPER);
1104 }
1105
1106 /*********************************************************************
1107  *              _ismbcupper (MSVCRT.@)
1108  */
1109 int CDECL _ismbcupper(unsigned int ch)
1110 {
1111     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1112     return (get_char_typeW( wch ) & C1_LOWER);
1113 }
1114
1115 /*********************************************************************
1116  *              _ismbcsymbol(MSVCRT.@)
1117  */
1118 int CDECL _ismbcsymbol(unsigned int ch)
1119 {
1120     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1121     WORD ctype;
1122     if (!GetStringTypeW(CT_CTYPE3, &wch, 1, &ctype))
1123     {
1124         WARN("GetStringTypeW failed on %x\n", ch);
1125         return 0;
1126     }
1127     return ((ctype & C3_SYMBOL) != 0);
1128 }
1129
1130 /*********************************************************************
1131  *              _ismbcalnum (MSVCRT.@)
1132  */
1133 int CDECL _ismbcalnum(unsigned int ch)
1134 {
1135     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1136     return (get_char_typeW( wch ) & (C1_ALPHA | C1_DIGIT));
1137 }
1138
1139 /*********************************************************************
1140  *              _ismbcspace (MSVCRT.@)
1141  */
1142 int CDECL _ismbcspace(unsigned int ch)
1143 {
1144     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1145     return (get_char_typeW( wch ) & C1_SPACE);
1146 }
1147
1148 /*********************************************************************
1149  *              _ismbcprint (MSVCRT.@)
1150  */
1151 int CDECL _ismbcprint(unsigned int ch)
1152 {
1153     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1154     return (get_char_typeW( wch ) & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA | C1_SPACE));
1155 }
1156
1157 /*********************************************************************
1158  *              _ismbcpunct(MSVCRT.@)
1159  */
1160 int CDECL _ismbcpunct(unsigned int ch)
1161 {
1162     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
1163     return (get_char_typeW( wch ) & C1_PUNCT);
1164 }
1165
1166 /*********************************************************************
1167  *              _ismbchira(MSVCRT.@)
1168  */
1169 int CDECL _ismbchira(unsigned int c)
1170 {
1171   /* FIXME: use lc_ctype when supported, not lc_all */
1172   if(get_locale()->locinfo->lc_codepage == 932)
1173   {
1174     /* Japanese/Hiragana, CP 932 */
1175     return (c >= 0x829f && c <= 0x82f1);
1176   }
1177   return 0;
1178 }
1179
1180 /*********************************************************************
1181  *              _ismbckata(MSVCRT.@)
1182  */
1183 int CDECL _ismbckata(unsigned int c)
1184 {
1185   /* FIXME: use lc_ctype when supported, not lc_all */
1186   if(get_locale()->locinfo->lc_codepage == 932)
1187   {
1188     if(c < 256)
1189       return _ismbbkana(c);
1190     /* Japanese/Katakana, CP 932 */
1191     return (c >= 0x8340 && c <= 0x8396 && c != 0x837f);
1192   }
1193   return 0;
1194 }
1195
1196 /*********************************************************************
1197  *              _ismbblead(MSVCRT.@)
1198  */
1199 int CDECL _ismbblead(unsigned int c)
1200 {
1201   return (MSVCRT_mbctype[(c&0xff) + 1] & _M1) != 0;
1202 }
1203
1204
1205 /*********************************************************************
1206  *              _ismbbtrail(MSVCRT.@)
1207  */
1208 int CDECL _ismbbtrail(unsigned int c)
1209 {
1210   return (MSVCRT_mbctype[(c&0xff) + 1] & _M2) != 0;
1211 }
1212
1213 /*********************************************************************
1214  *              _ismbclegal(MSVCRT.@)
1215  */
1216 int CDECL _ismbclegal(unsigned int c)
1217 {
1218     return _ismbblead(HIBYTE(c)) && _ismbbtrail(LOBYTE(c));
1219 }
1220
1221 /*********************************************************************
1222  *              _ismbslead(MSVCRT.@)
1223  */
1224 int CDECL _ismbslead(const unsigned char* start, const unsigned char* str)
1225 {
1226   int lead = 0;
1227
1228   if(!g_mbcp_is_multibyte)
1229     return 0;
1230
1231   /* Lead bytes can also be trail bytes so we need to analyse the string
1232    */
1233   while (start <= str)
1234   {
1235     if (!*start)
1236       return 0;
1237     lead = !lead && _ismbblead(*start);
1238     start++;
1239   }
1240
1241   return lead ? -1 : 0;
1242 }
1243
1244 /*********************************************************************
1245  *              _ismbstrail(MSVCRT.@)
1246  */
1247 int CDECL _ismbstrail(const unsigned char* start, const unsigned char* str)
1248 {
1249   /* Note: this function doesn't check _ismbbtrail */
1250   if ((str > start) && _ismbslead(start, str-1))
1251     return -1;
1252   else
1253     return 0;
1254 }
1255
1256 /*********************************************************************
1257  *              _mbsbtype (MSVCRT.@)
1258  */
1259 int CDECL _mbsbtype(const unsigned char *str, MSVCRT_size_t count)
1260 {
1261   int lead = 0;
1262   const unsigned char *end = str + count;
1263   int mbcp = g_mbcp_is_multibyte;
1264
1265   /* Lead bytes can also be trail bytes so we need to analyse the string.
1266    * Also we must return _MBC_ILLEGAL for chars past the end of the string
1267    */
1268   while (str < end) /* Note: we skip the last byte - will check after the loop */
1269   {
1270     if (!*str)
1271       return _MBC_ILLEGAL;
1272     lead = mbcp && !lead && _ismbblead(*str);
1273     str++;
1274   }
1275
1276   if (lead)
1277     if (_ismbbtrail(*str))
1278       return _MBC_TRAIL;
1279     else
1280       return _MBC_ILLEGAL;
1281   else
1282     if (_ismbblead(*str))
1283       return _MBC_LEAD;
1284     else
1285       return _MBC_SINGLE;
1286 }
1287
1288 /*********************************************************************
1289  *              _mbsset(MSVCRT.@)
1290  */
1291 unsigned char* CDECL _mbsset(unsigned char* str, unsigned int c)
1292 {
1293   unsigned char* ret = str;
1294
1295   if(get_locale()->locinfo->mb_cur_max == 1 || c < 256)
1296     return u__strset(str, c); /* ASCII CP or SB char */
1297
1298   c &= 0xffff; /* Strip high bits */
1299
1300   while(str[0] && str[1])
1301   {
1302     *str++ = c >> 8;
1303     *str++ = c & 0xff;
1304   }
1305   if(str[0])
1306     str[0] = '\0'; /* FIXME: OK to shorten? */
1307
1308   return ret;
1309 }
1310
1311 /*********************************************************************
1312  *              _mbsnbset(MSVCRT.@)
1313  */
1314 unsigned char* CDECL _mbsnbset(unsigned char *str, unsigned int c, MSVCRT_size_t len)
1315 {
1316     unsigned char *ret = str;
1317
1318     if(!len)
1319         return ret;
1320
1321     if(get_locale()->locinfo->mb_cur_max == 1 || c < 256)
1322         return u__strnset(str, c, len); /* ASCII CP or SB char */
1323
1324     c &= 0xffff; /* Strip high bits */
1325
1326     while(str[0] && str[1] && (len > 1))
1327     {
1328         *str++ = c >> 8;
1329         len--;
1330         *str++ = c & 0xff;
1331         len--;
1332     }
1333     if(len && str[0]) {
1334         /* as per msdn pad with a blank character */
1335         str[0] = ' ';
1336     }
1337
1338     return ret;
1339 }
1340
1341 /*********************************************************************
1342  *              _mbsnset(MSVCRT.@)
1343  */
1344 unsigned char* CDECL _mbsnset(unsigned char* str, unsigned int c, MSVCRT_size_t len)
1345 {
1346   unsigned char *ret = str;
1347
1348   if(!len)
1349     return ret;
1350
1351   if(get_locale()->locinfo->mb_cur_max == 1 || c < 256)
1352     return u__strnset(str, c, len); /* ASCII CP or SB char */
1353
1354   c &= 0xffff; /* Strip high bits */
1355
1356   while(str[0] && str[1] && len--)
1357   {
1358     *str++ = c >> 8;
1359     *str++ = c & 0xff;
1360   }
1361   if(len && str[0])
1362     str[0] = '\0'; /* FIXME: OK to shorten? */
1363
1364   return ret;
1365 }
1366
1367 /*********************************************************************
1368  *              _mbsnccnt(MSVCRT.@)
1369  * 'c' is for 'character'.
1370  */
1371 MSVCRT_size_t CDECL _mbsnccnt(const unsigned char* str, MSVCRT_size_t len)
1372 {
1373   MSVCRT_size_t ret;
1374   if(get_locale()->locinfo->mb_cur_max > 1)
1375   {
1376     ret=0;
1377     while(*str && len-- > 0)
1378     {
1379       if(MSVCRT_isleadbyte(*str))
1380       {
1381         if (!len)
1382           break;
1383         len--;
1384         str++;
1385       }
1386       str++;
1387       ret++;
1388     }
1389     return ret;
1390   }
1391   ret=u_strlen(str);
1392   return min(ret, len); /* ASCII CP */
1393 }
1394
1395 /*********************************************************************
1396  *              _mbsnbcnt(MSVCRT.@)
1397  * 'b' is for byte count.
1398  */
1399 MSVCRT_size_t CDECL _mbsnbcnt(const unsigned char* str, MSVCRT_size_t len)
1400 {
1401   MSVCRT_size_t ret;
1402   if(get_locale()->locinfo->mb_cur_max > 1)
1403   {
1404     const unsigned char* xstr = str;
1405     while(*xstr && len-- > 0)
1406     {
1407       if (MSVCRT_isleadbyte(*xstr++))
1408         xstr++;
1409     }
1410     return xstr-str;
1411   }
1412   ret=u_strlen(str);
1413   return min(ret, len); /* ASCII CP */
1414 }
1415
1416 /*********************************************************************
1417  *              _mbsnbcat(MSVCRT.@)
1418  */
1419 unsigned char* CDECL _mbsnbcat(unsigned char* dst, const unsigned char* src, MSVCRT_size_t len)
1420 {
1421     if(get_locale()->locinfo->mb_cur_max > 1)
1422     {
1423         unsigned char *res = dst;
1424         while (*dst) {
1425             if (MSVCRT_isleadbyte(*dst++)) {
1426                 if (*dst) {
1427                     dst++;
1428                 } else {
1429                     /* as per msdn overwrite the lead byte in front of '\0' */
1430                     dst--;
1431                     break;
1432                 }
1433             }
1434         }
1435         while (*src && len--) *dst++ = *src++;
1436         *dst = '\0';
1437         return res;
1438     }
1439     return u_strncat(dst, src, len); /* ASCII CP */
1440 }
1441
1442 int CDECL _mbsnbcat_s(unsigned char *dst, MSVCRT_size_t size, const unsigned char *src, MSVCRT_size_t len)
1443 {
1444     unsigned char *ptr = dst;
1445     MSVCRT_size_t i;
1446
1447     if (!dst && !size && !src && !len)
1448         return 0;
1449
1450     if (!dst || !size || !src)
1451     {
1452         if (dst && size)
1453             *dst = '\0';
1454
1455         *MSVCRT__errno() = MSVCRT_EINVAL;
1456         return MSVCRT_EINVAL;
1457     }
1458
1459     /* Find the null terminator of the destination buffer. */
1460     while (size && *ptr)
1461         size--, ptr++;
1462
1463     if (!size)
1464     {
1465         *dst = '\0';
1466         *MSVCRT__errno() = MSVCRT_EINVAL;
1467         return MSVCRT_EINVAL;
1468     }
1469
1470     /* If necessary, check that the character preceding the null terminator is
1471      * a lead byte and move the pointer back by one for later overwrite. */
1472     if (ptr != dst && get_locale()->locinfo->mb_cur_max > 1 && MSVCRT_isleadbyte(*(ptr - 1)))
1473         size++, ptr--;
1474
1475     for (i = 0; *src && i < len; i++)
1476     {
1477         *ptr++ = *src++;
1478         size--;
1479
1480         if (!size)
1481         {
1482             *dst = '\0';
1483             *MSVCRT__errno() = MSVCRT_ERANGE;
1484             return MSVCRT_ERANGE;
1485         }
1486     }
1487
1488     *ptr = '\0';
1489     return 0;
1490 }
1491
1492 /*********************************************************************
1493  *              _mbsncat(MSVCRT.@)
1494  */
1495 unsigned char* CDECL _mbsncat(unsigned char* dst, const unsigned char* src, MSVCRT_size_t len)
1496 {
1497   if(get_locale()->locinfo->mb_cur_max > 1)
1498   {
1499     unsigned char *res = dst;
1500     while (*dst)
1501     {
1502       if (MSVCRT_isleadbyte(*dst++))
1503         dst++;
1504     }
1505     while (*src && len--)
1506     {
1507       *dst++ = *src;
1508       if(MSVCRT_isleadbyte(*src++))
1509         *dst++ = *src++;
1510     }
1511     *dst = '\0';
1512     return res;
1513   }
1514   return u_strncat(dst, src, len); /* ASCII CP */
1515 }
1516
1517
1518 /*********************************************************************
1519  *              _mbslwr(MSVCRT.@)
1520  */
1521 unsigned char* CDECL _mbslwr(unsigned char* s)
1522 {
1523   unsigned char *ret = s;
1524   if (!s)
1525     return NULL;
1526   if (get_locale()->locinfo->mb_cur_max > 1)
1527   {
1528     unsigned int c;
1529     while (*s)
1530     {
1531       c = _mbctolower(_mbsnextc(s));
1532       /* Note that I assume that the size of the character is unchanged */
1533       if (c > 255)
1534       {
1535           *s++=(c>>8);
1536           c=c & 0xff;
1537       }
1538       *s++=c;
1539     }
1540   }
1541   else for ( ; *s; s++) *s = tolower(*s);
1542   return ret;
1543 }
1544
1545
1546 /*********************************************************************
1547  *              _mbsupr(MSVCRT.@)
1548  */
1549 unsigned char* CDECL _mbsupr(unsigned char* s)
1550 {
1551   unsigned char *ret = s;
1552   if (!s)
1553     return NULL;
1554   if (get_locale()->locinfo->mb_cur_max > 1)
1555   {
1556     unsigned int c;
1557     while (*s)
1558     {
1559       c = _mbctoupper(_mbsnextc(s));
1560       /* Note that I assume that the size of the character is unchanged */
1561       if (c > 255)
1562       {
1563           *s++=(c>>8);
1564           c=c & 0xff;
1565       }
1566       *s++=c;
1567     }
1568   }
1569   else for ( ; *s; s++) *s = toupper(*s);
1570   return ret;
1571 }
1572
1573
1574 /*********************************************************************
1575  *              _mbsspn (MSVCRT.@)
1576  */
1577 MSVCRT_size_t CDECL _mbsspn(const unsigned char* string, const unsigned char* set)
1578 {
1579     const unsigned char *p, *q;
1580
1581     for (p = string; *p; p++)
1582     {
1583         if (MSVCRT_isleadbyte(*p))
1584         {
1585             for (q = set; *q; q++)
1586             {
1587                 if (!q[1])
1588                     break;
1589                 if ((*p == *q) &&  (p[1] == q[1]))
1590                     break;
1591                 q++;
1592             }
1593             if (!q[0] || !q[1]) break;
1594         }
1595         else
1596         {
1597             for (q = set; *q; q++)
1598                 if (*p == *q)
1599                     break;
1600             if (!*q) break;
1601         }
1602     }
1603     return p - string;
1604 }
1605
1606 /*********************************************************************
1607  *              _mbsspnp (MSVCRT.@)
1608  */
1609 unsigned char* CDECL _mbsspnp(const unsigned char* string, const unsigned char* set)
1610 {
1611     const unsigned char *p, *q;
1612
1613     for (p = string; *p; p++)
1614     {
1615         if (MSVCRT_isleadbyte(*p))
1616         {
1617             for (q = set; *q; q++)
1618             {
1619                 if (!q[1])
1620                     break;
1621                 if ((*p == *q) &&  (p[1] == q[1]))
1622                     break;
1623                 q++;
1624             }
1625             if (!q[0] || !q[1]) break;
1626         }
1627         else
1628         {
1629             for (q = set; *q; q++)
1630                 if (*p == *q)
1631                     break;
1632             if (!*q) break;
1633         }
1634     }
1635     if (*p == '\0')
1636         return NULL;
1637     return (unsigned char *)p;
1638 }
1639
1640 /*********************************************************************
1641  *              _mbscspn(MSVCRT.@)
1642  */
1643 MSVCRT_size_t CDECL _mbscspn(const unsigned char* str, const unsigned char* cmp)
1644 {
1645   if (get_locale()->locinfo->mb_cur_max > 1)
1646     FIXME("don't handle double character case\n");
1647   return u_strcspn(str, cmp);
1648 }
1649
1650 /*********************************************************************
1651  *              _mbsrev (MSVCRT.@)
1652  */
1653 unsigned char* CDECL _mbsrev(unsigned char* str)
1654 {
1655     int i, len = _mbslen(str);
1656     unsigned char *p, *temp=MSVCRT_malloc(len*2);
1657
1658     if(!temp)
1659         return str;
1660
1661     /* unpack multibyte string to temp buffer */
1662     p=str;
1663     for(i=0; i<len; i++)
1664     {
1665         if (MSVCRT_isleadbyte(*p))
1666         {
1667             temp[i*2]=*p++;
1668             temp[i*2+1]=*p++;
1669         }
1670         else
1671         {
1672             temp[i*2]=*p++;
1673             temp[i*2+1]=0;
1674         }
1675     }
1676
1677     /* repack it in the reverse order */
1678     p=str;
1679     for(i=len-1; i>=0; i--)
1680     {
1681         if(MSVCRT_isleadbyte(temp[i*2]))
1682         {
1683             *p++=temp[i*2];
1684             *p++=temp[i*2+1];
1685         }
1686         else
1687         {
1688             *p++=temp[i*2];
1689         }
1690     }
1691
1692     MSVCRT_free(temp);
1693
1694     return str;
1695 }
1696
1697 /*********************************************************************
1698  *              _mbspbrk (MSVCRT.@)
1699  */
1700 unsigned char* CDECL _mbspbrk(const unsigned char* str, const unsigned char* accept)
1701 {
1702     const unsigned char* p;
1703
1704     while(*str)
1705     {
1706         for(p = accept; *p; p += (MSVCRT_isleadbyte(*p)?2:1) )
1707         {
1708             if (*p == *str)
1709                 if( !MSVCRT_isleadbyte(*p) || ( *(p+1) == *(str+1) ) )
1710                      return (unsigned char*)str;
1711         }
1712         str += (MSVCRT_isleadbyte(*str)?2:1);
1713     }
1714     return NULL;
1715 }
1716
1717
1718 /*
1719  * Functions depending on locale codepage
1720  */
1721
1722 /*********************************************************************
1723  *              mblen(MSVCRT.@)
1724  * REMARKS
1725  *  Unlike most of the multibyte string functions this function uses
1726  *  the locale codepage, not the codepage set by _setmbcp
1727  */
1728 int CDECL MSVCRT_mblen(const char* str, MSVCRT_size_t size)
1729 {
1730   if (str && *str && size)
1731   {
1732     if(get_locale()->locinfo->mb_cur_max == 1)
1733       return 1; /* ASCII CP */
1734
1735     return !MSVCRT_isleadbyte(*str) ? 1 : (size>1 ? 2 : -1);
1736   }
1737   return 0;
1738 }
1739
1740 /*********************************************************************
1741  *              _mbstrlen_l(MSVCRT.@)
1742  */
1743 MSVCRT_size_t CDECL _mbstrlen_l(const char* str, MSVCRT__locale_t locale)
1744 {
1745     if(!locale)
1746         locale = get_locale();
1747
1748     if(locale->locinfo->mb_cur_max > 1) {
1749         MSVCRT_size_t len = 0;
1750         while(*str) {
1751             /* FIXME: According to the documentation we are supposed to test for
1752              * multi-byte character validity. Whatever that means
1753              */
1754             str += MSVCRT_isleadbyte(*str) ? 2 : 1;
1755             len++;
1756         }
1757         return len;
1758     }
1759
1760     return strlen(str);
1761 }
1762
1763 /*********************************************************************
1764  *              _mbstrlen(MSVCRT.@)
1765  */
1766 MSVCRT_size_t CDECL _mbstrlen(const char* str)
1767 {
1768     return _mbstrlen_l(str, NULL);
1769 }
1770
1771 /*********************************************************************
1772  *              _mbstowcs_l(MSVCRT.@)
1773  */
1774 MSVCRT_size_t CDECL MSVCRT__mbstowcs_l(MSVCRT_wchar_t *wcstr, const char *mbstr,
1775         MSVCRT_size_t count, MSVCRT__locale_t locale)
1776 {
1777     MSVCRT_size_t i, size;
1778
1779     if(!locale)
1780         locale = get_locale();
1781
1782     /* Ignore count parameter */
1783     if(!wcstr)
1784         return MultiByteToWideChar(locale->locinfo->lc_codepage, 0, mbstr, -1, NULL, 0)-1;
1785
1786     for(i=0, size=0; i<count; i++) {
1787         if(mbstr[size] == '\0')
1788             break;
1789
1790         size += (MSVCRT_isleadbyte(mbstr[size]) ? 2 : 1);
1791     }
1792
1793     size = MultiByteToWideChar(locale->locinfo->lc_codepage, 0,
1794             mbstr, size, wcstr, count);
1795
1796     if(size<count && wcstr)
1797         wcstr[size] = '\0';
1798
1799     return size;
1800 }
1801
1802 /*********************************************************************
1803  *              mbstowcs(MSVCRT.@)
1804  */
1805 MSVCRT_size_t CDECL MSVCRT_mbstowcs(MSVCRT_wchar_t *wcstr,
1806         const char *mbstr, MSVCRT_size_t count)
1807 {
1808     return MSVCRT__mbstowcs_l(wcstr, mbstr, count, NULL);
1809 }
1810
1811 /*********************************************************************
1812  *              _mbstowcs_s_l(MSVCRT.@)
1813  */
1814 int CDECL MSVCRT__mbstowcs_s_l(MSVCRT_size_t *ret, MSVCRT_wchar_t *wcstr,
1815         MSVCRT_size_t size, const char *mbstr,
1816         MSVCRT_size_t count, MSVCRT__locale_t locale)
1817 {
1818     MSVCRT_size_t conv;
1819
1820     if(!wcstr && !size) {
1821         conv = MSVCRT__mbstowcs_l(NULL, mbstr, 0, locale);
1822         if(ret)
1823             *ret = conv;
1824         return 0;
1825     }
1826
1827     if(!MSVCRT_CHECK_PMT(mbstr != NULL) || !MSVCRT_CHECK_PMT(wcstr != NULL)) {
1828         if(wcstr && size)
1829             wcstr[0] = '\0';
1830         *MSVCRT__errno() = MSVCRT_EINVAL;
1831         return MSVCRT_EINVAL;
1832     }
1833
1834     if(count==MSVCRT__TRUNCATE || size<count)
1835         conv = size;
1836     else
1837         conv = count;
1838
1839     conv = MSVCRT__mbstowcs_l(wcstr, mbstr, conv, locale);
1840     if(conv<size)
1841         wcstr[conv++] = '\0';
1842     else if(conv==size && (count==MSVCRT__TRUNCATE || wcstr[conv-1]=='\0'))
1843         wcstr[conv-1] = '\0';
1844     else {
1845         MSVCRT_INVALID_PMT("wcstr[size] is too small");
1846         if(size)
1847             wcstr[0] = '\0';
1848         *MSVCRT__errno() = MSVCRT_ERANGE;
1849         return MSVCRT_ERANGE;
1850     }
1851
1852     if(ret)
1853         *ret = conv;
1854     return 0;
1855 }
1856
1857 /*********************************************************************
1858  *              mbstowcs_s(MSVCRT.@)
1859  */
1860 int CDECL MSVCRT__mbstowcs_s(MSVCRT_size_t *ret, MSVCRT_wchar_t *wcstr,
1861         MSVCRT_size_t size, const char *mbstr, MSVCRT_size_t count)
1862 {
1863     return MSVCRT__mbstowcs_s_l(ret, wcstr, size, mbstr, count, NULL);
1864 }