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