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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
  28 #include "msvcrt/mbctype.h"
  29 #include "msvcrt/mbstring.h"
  30 #include "msvcrt/stdlib.h"
  31 #include "msvcrt/string.h"
  32 #include "msvcrt/wctype.h"
  33
  34 #include "wine/unicode.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  38
  39 unsigned char MSVCRT_mbctype[257];
  40 int MSVCRT___mb_cur_max = 1;
  41
  42 static MSVCRT_wchar_t msvcrt_mbc_to_wc(unsigned int ch)
  43 {
  44   MSVCRT_wchar_t chW;
  45   char mbch[2];
  46   int n_chars;
  47
  48   if (ch <= 0xff) {
  49     mbch[0] = ch;
  50     n_chars = 1;
  51   } else {
  52     mbch[0] = (ch >> 8) & 0xff;
  53     mbch[1] = ch & 0xff;
  54     n_chars = 2;
  55   }
  56   if (!MultiByteToWideChar(MSVCRT_current_lc_all_cp, 0, mbch, n_chars, &chW, 1))
  57   {
  58     WARN("MultiByteToWideChar failed on %x\n", ch);
  59     return 0;
  60   }
  61   return chW;
  62 }
  63
  64 /*********************************************************************
  65  *              __p__mbctype (MSVCRT.@)
  66  */
  67 unsigned char* __p__mbctype(void)
  68 {
  69   return MSVCRT_mbctype;
  70 }
  71
  72 /*********************************************************************
  73  *              __p___mb_cur_max(MSVCRT.@)
  74  */
  75 int* __p___mb_cur_max(void)
  76 {
  77   return &MSVCRT___mb_cur_max;
  78 }
  79
  80 /*********************************************************************
  81  *              _mbsnextc(MSVCRT.@)
  82  */
  83 unsigned int _mbsnextc(const unsigned char* str)
  84 {
  85   if(MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(*str))
  86     return *str << 8 | str[1];
  87   return *str; /* ASCII CP or SB char */
  88 }
  89
  90 /*********************************************************************
  91  *              _mbctolower(MSVCRT.@)
  92  */
  93 unsigned int _mbctolower(unsigned int c)
  94 {
  95     if (MSVCRT_isleadbyte(c))
  96     {
  97       FIXME("Handle MBC chars\n");
  98       return c;
  99     }
 100     return tolower(c); /* ASCII CP or SB char */
 101 }
 102
 103 /*********************************************************************
 104  *              _mbctoupper(MSVCRT.@)
 105  */
 106 unsigned int _mbctoupper(unsigned int c)
 107 {
 108     if (MSVCRT_isleadbyte(c))
 109     {
 110       FIXME("Handle MBC chars\n");
 111       return c;
 112     }
 113     return toupper(c); /* ASCII CP or SB char */
 114 }
 115
 116 /*********************************************************************
 117  *              _mbsdec(MSVCRT.@)
 118  */
 119 unsigned char* _mbsdec(const unsigned char* start, const unsigned char* cur)
 120 {
 121   if(MSVCRT___mb_cur_max > 1)
 122     return (char *)(_ismbstrail(start,cur-1) ? cur - 2 : cur -1);
 123
 124   return (char *)cur - 1; /* ASCII CP or SB char */
 125 }
 126
 127 /*********************************************************************
 128  *              _mbsinc(MSVCRT.@)
 129  */
 130 unsigned char* _mbsinc(const unsigned char* str)
 131 {
 132   if(MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(*str))
 133     return (unsigned char*)str + 2; /* MB char */
 134
 135   return (unsigned char*)str + 1; /* ASCII CP or SB char */
 136 }
 137
 138 /*********************************************************************
 139  *              _mbsninc(MSVCRT.@)
 140  */
 141 unsigned char* _mbsninc(const unsigned char* str, MSVCRT_size_t num)
 142 {
 143   if(!str || num < 1)
 144     return NULL;
 145   if(MSVCRT___mb_cur_max > 1)
 146   {
 147     while(num--)
 148       str = _mbsinc(str);
 149     return (unsigned char*)str;
 150   }
 151   return (unsigned char*)str + num; /* ASCII CP */
 152 }
 153
 154 /*********************************************************************
 155  *              _mbclen(MSVCRT.@)
 156  */
 157 unsigned int _mbclen(const unsigned char* str)
 158 {
 159   return MSVCRT_isleadbyte(*str) ? 2 : 1;
 160 }
 161
 162 /*********************************************************************
 163  *              mblen(MSVCRT.@)
 164  */
 165 int MSVCRT_mblen(const char* str, MSVCRT_size_t size)
 166 {
 167   if (str && *str && size)
 168   {
 169     if(MSVCRT___mb_cur_max == 1)
 170       return 1; /* ASCII CP */
 171
 172     return !MSVCRT_isleadbyte(*str) ? 1 : (size>1 ? 2 : -1);
 173   }
 174   return 0;
 175 }
 176
 177 /*********************************************************************
 178  *              _mbslen(MSVCRT.@)
 179  */
 180 MSVCRT_size_t _mbslen(const unsigned char* str)
 181 {
 182   if(MSVCRT___mb_cur_max > 1)
 183   {
 184     MSVCRT_size_t len = 0;
 185     while(*str)
 186     {
 187       str += MSVCRT_isleadbyte(*str) ? 2 : 1;
 188       len++;
 189     }
 190     return len;
 191   }
 192   return strlen(str); /* ASCII CP */
 193 }
 194
 195 /*********************************************************************
 196  *              _mbstrlen(MSVCRT.@)
 197  */
 198 MSVCRT_size_t _mbstrlen(const char* str)
 199 {
 200   if(MSVCRT___mb_cur_max > 1)
 201   {
 202     MSVCRT_size_t len = 0;
 203     while(*str)
 204     {
 205       /* FIXME: According to the documentation we are supposed to test for
 206        * multi-byte character validity. Whatever that means
 207        */
 208       str += MSVCRT_isleadbyte(*str) ? 2 : 1;
 209       len++;
 210     }
 211     return len;
 212   }
 213   return strlen(str); /* ASCII CP */
 214 }
 215
 216 /*********************************************************************
 217  *              _mbccpy(MSVCRT.@)
 218  */
 219 void _mbccpy(unsigned char* dest, const unsigned char* src)
 220 {
 221   *dest++ = *src;
 222   if(MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(*src))
 223     *dest = *++src; /* MB char */
 224   else
 225     ERR("failure.. is this ok?\n");
 226 }
 227
 228 /*********************************************************************
 229  *              _mbsncpy(MSVCRT.@)
 230  */
 231 unsigned char* _mbsncpy(unsigned char* dst, const unsigned char* src, MSVCRT_size_t n)
 232 {
 233   if(!n)
 234     return dst;
 235   if(MSVCRT___mb_cur_max > 1)
 236   {
 237     unsigned char* ret = dst;
 238     while (*src && n--)
 239     {
 240       *dst++ = *src;
 241       if (MSVCRT_isleadbyte(*src++))
 242           *dst++ = *src++;
 243     }
 244     while(n--)
 245       *dst++ = '\0';
 246     return ret;
 247   }
 248   return strncpy(dst, src, n); /* ASCII CP */
 249 }
 250
 251 /*********************************************************************
 252  *              _mbsnbcpy(MSVCRT.@)
 253  */
 254 unsigned char* _mbsnbcpy(unsigned char* dst, const unsigned char* src, MSVCRT_size_t n)
 255 {
 256   if(!n)
 257     return dst;
 258   if(MSVCRT___mb_cur_max > 1)
 259   {
 260     unsigned char* ret = dst;
 261     while (*src && (n-- > 1))
 262     {
 263       *dst++ = *src;
 264       if (MSVCRT_isleadbyte(*src++))
 265       {
 266         *dst++ = *src++;
 267         n--;
 268       }
 269     }
 270     if (*src && n && !MSVCRT_isleadbyte(*src))
 271     {
 272       /* If the last character is a multi-byte character then
 273        * we cannot copy it since we have only one byte left
 274        */
 275       *dst++ = *src;
 276       n--;
 277     }
 278     while (n--)
 279       *dst++ = '\0';
 280     return ret;
 281   }
 282   return strncpy(dst, src, n); /* ASCII CP */
 283 }
 284
 285 /*********************************************************************
 286  *              _mbscmp(MSVCRT.@)
 287  */
 288 int _mbscmp(const unsigned char* str, const unsigned char* cmp)
 289 {
 290   if(MSVCRT___mb_cur_max > 1)
 291   {
 292     unsigned int strc, cmpc;
 293     do {
 294       if(!*str)
 295         return *cmp ? -1 : 0;
 296       if(!*cmp)
 297         return 1;
 298       strc = _mbsnextc(str);
 299       cmpc = _mbsnextc(cmp);
 300       if(strc != cmpc)
 301         return strc < cmpc ? -1 : 1;
 302       str +=(strc > 255) ? 2 : 1;
 303       cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
 304     } while(1);
 305   }
 306   return strcmp(str, cmp); /* ASCII CP */
 307 }
 308
 309 /*********************************************************************
 310  *              _mbsicoll(MSVCRT.@)
 311  * FIXME: handle locales.
 312  */
 313 int _mbsicoll(const unsigned char* str, const unsigned char* cmp)
 314 {
 315   if(MSVCRT___mb_cur_max > 1)
 316   {
 317     unsigned int strc, cmpc;
 318     do {
 319       if(!*str)
 320         return *cmp ? -1 : 0;
 321       if(!*cmp)
 322         return 1;
 323       strc = _mbctolower(_mbsnextc(str));
 324       cmpc = _mbctolower(_mbsnextc(cmp));
 325       if(strc != cmpc)
 326         return strc < cmpc ? -1 : 1;
 327       str +=(strc > 255) ? 2 : 1;
 328       cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
 329     } while(1);
 330   }
 331   return strcasecmp(str, cmp); /* ASCII CP */
 332 }
 333
 334
 335 /*********************************************************************
 336  *              _mbsicmp(MSVCRT.@)
 337  */
 338 int _mbsicmp(const unsigned char* str, const unsigned char* cmp)
 339 {
 340   if(MSVCRT___mb_cur_max > 1)
 341   {
 342     unsigned int strc, cmpc;
 343     do {
 344       if(!*str)
 345         return *cmp ? -1 : 0;
 346       if(!*cmp)
 347         return 1;
 348       strc = _mbctolower(_mbsnextc(str));
 349       cmpc = _mbctolower(_mbsnextc(cmp));
 350       if(strc != cmpc)
 351         return strc < cmpc ? -1 : 1;
 352       str +=(strc > 255) ? 2 : 1;
 353       cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
 354     } while(1);
 355   }
 356   return strcasecmp(str, cmp); /* ASCII CP */
 357 }
 358
 359 /*********************************************************************
 360  *              _mbsncmp(MSVCRT.@)
 361  */
 362 int _mbsncmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 363 {
 364   if(!len)
 365     return 0;
 366
 367   if(MSVCRT___mb_cur_max > 1)
 368   {
 369     unsigned int strc, cmpc;
 370     while(len--)
 371     {
 372       int inc;
 373       if(!*str)
 374         return *cmp ? -1 : 0;
 375       if(!*cmp)
 376         return 1;
 377       strc = _mbsnextc(str);
 378       cmpc = _mbsnextc(cmp);
 379       if(strc != cmpc)
 380         return strc < cmpc ? -1 : 1;
 381       inc=(strc > 255) ? 2 : 1; /* Equal, use same increment */
 382       str += inc;
 383       cmp += inc;
 384     }
 385     return 0; /* Matched len chars */
 386   }
 387   return strncmp(str, cmp, len); /* ASCII CP */
 388 }
 389
 390 /*********************************************************************
 391  *              _mbsnbcmp(MSVCRT.@)
 392  */
 393 int _mbsnbcmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 394 {
 395   if (!len)
 396     return 0;
 397   if(MSVCRT___mb_cur_max > 1)
 398   {
 399     unsigned int strc, cmpc;
 400     while (len)
 401     {
 402       int clen;
 403       if(!*str)
 404         return *cmp ? -1 : 0;
 405       if(!*cmp)
 406         return 1;
 407       if (MSVCRT_isleadbyte(*str))
 408       {
 409         strc=(len>=2)?_mbsnextc(str):0;
 410         clen=2;
 411       }
 412       else
 413       {
 414         strc=*str;
 415         clen=1;
 416       }
 417       if (MSVCRT_isleadbyte(*cmp))
 418         cmpc=(len>=2)?_mbsnextc(cmp):0;
 419       else
 420         cmpc=*str;
 421       if(strc != cmpc)
 422         return strc < cmpc ? -1 : 1;
 423       len -= clen;
 424       str += clen;
 425       cmp += clen;
 426     }
 427     return 0; /* Matched len chars */
 428   }
 429   return strncmp(str,cmp,len);
 430 }
 431
 432 /*********************************************************************
 433  *              _mbsnicmp(MSVCRT.@)
 434  *
 435  * Compare two multibyte strings case insensitively to 'len' characters.
 436  */
 437 int _mbsnicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 438 {
 439   /* FIXME: No tolower() for mb strings yet */
 440   if(MSVCRT___mb_cur_max > 1)
 441   {
 442     unsigned int strc, cmpc;
 443     while(len--)
 444     {
 445       if(!*str)
 446         return *cmp ? -1 : 0;
 447       if(!*cmp)
 448         return 1;
 449       strc = _mbctolower(_mbsnextc(str));
 450       cmpc = _mbctolower(_mbsnextc(cmp));
 451       if(strc != cmpc)
 452         return strc < cmpc ? -1 : 1;
 453       str +=(strc > 255) ? 2 : 1;
 454       cmp +=(strc > 255) ? 2 : 1; /* Equal, use same increment */
 455     }
 456     return 0; /* Matched len chars */
 457   }
 458   return strncasecmp(str, cmp, len); /* ASCII CP */
 459 }
 460
 461 /*********************************************************************
 462  *              _mbsnbicmp(MSVCRT.@)
 463  */
 464 int _mbsnbicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 465 {
 466   if (!len)
 467     return 0;
 468   if(MSVCRT___mb_cur_max > 1)
 469   {
 470     unsigned int strc, cmpc;
 471     while (len)
 472     {
 473       int clen;
 474       if(!*str)
 475         return *cmp ? -1 : 0;
 476       if(!*cmp)
 477         return 1;
 478       if (MSVCRT_isleadbyte(*str))
 479       {
 480         strc=(len>=2)?_mbsnextc(str):0;
 481         clen=2;
 482       }
 483       else
 484       {
 485         strc=*str;
 486         clen=1;
 487       }
 488       if (MSVCRT_isleadbyte(*cmp))
 489         cmpc=(len>=2)?_mbsnextc(cmp):0;
 490       else
 491         cmpc=*str;
 492       strc = _mbctolower(strc);
 493       cmpc = _mbctolower(cmpc);
 494       if(strc != cmpc)
 495         return strc < cmpc ? -1 : 1;
 496       len -= clen;
 497       str += clen;
 498       cmp += clen;
 499     }
 500     return 0; /* Matched len bytes */
 501   }
 502   return strncmp(str,cmp,len);
 503 }
 504
 505 /*********************************************************************
 506  *              _mbschr(MSVCRT.@)
 507  *
 508  * Find a multibyte character in a multibyte string.
 509  */
 510 unsigned char* _mbschr(const unsigned char* s, unsigned int x)
 511 {
 512   if(MSVCRT___mb_cur_max > 1)
 513   {
 514     unsigned int c;
 515     while (1)
 516     {
 517       c = _mbsnextc(s);
 518       if (c == x)
 519         return (unsigned char*)s;
 520       if (!c)
 521         return NULL;
 522       s += c > 255 ? 2 : 1;
 523     }
 524   }
 525   return strchr(s, x); /* ASCII CP */
 526 }
 527
 528 /*********************************************************************
 529  *              _mbsrchr(MSVCRT.@)
 530  */
 531 unsigned char* _mbsrchr(const unsigned char* s, unsigned int x)
 532 {
 533   if(MSVCRT___mb_cur_max > 1)
 534   {
 535     unsigned int c;
 536     unsigned char* match=NULL;
 537     if(!s)
 538       return NULL;
 539     while (1) {
 540       c = _mbsnextc(s);
 541       if (c == x)
 542         match=(unsigned char*)s;
 543       if (!c)
 544         return match;
 545       s +=(c > 255) ? 2 : 1;
 546     }
 547   }
 548   return strrchr(s,x);
 549 }
 550
 551 /*********************************************************************
 552  *              _mbstok(MSVCRT.@)
 553  *
 554  * Find and extract tokens from strings
 555  */
 556 unsigned char* _mbstok(unsigned char *str, const unsigned char *delim)
 557 {
 558     MSVCRT_thread_data *data = msvcrt_get_thread_data();
 559     char *ret;
 560
 561     if(MSVCRT___mb_cur_max > 1)
 562     {
 563         unsigned int c;
 564
 565         if (!str)
 566             if (!(str = data->mbstok_next)) return NULL;
 567
 568         while ((c = _mbsnextc(str)) && _mbschr(delim, c)) {
 569             str += c > 255 ? 2 : 1;
 570         }
 571         if (!*str) return NULL;
 572         ret = str++;
 573         while ((c = _mbsnextc(str)) && !_mbschr(delim, c)) {
 574             str += c > 255 ? 2 : 1;
 575         }
 576         if (*str) {
 577             *str++ = 0;
 578             if (c > 255) *str++ = 0;
 579         }
 580         data->mbstok_next = str;
 581         return ret;
 582     }
 583     return strtok(str, delim);  /* ASCII CP */
 584 }
 585
 586 /*********************************************************************
 587  *              mbtowc(MSVCRT.@)
 588  */
 589 int MSVCRT_mbtowc(MSVCRT_wchar_t *dst, const char* str, MSVCRT_size_t n)
 590 {
 591   if(n <= 0 || !str)
 592     return 0;
 593   if(!MultiByteToWideChar(CP_ACP, 0, str, n, dst, 1))
 594     return 0;
 595   /* return the number of bytes from src that have been used */
 596   if(!*str)
 597     return 0;
 598   if(n >= 2 && MSVCRT_isleadbyte(*str) && str[1])
 599     return 2;
 600   return 1;
 601 }
 602
 603 /*********************************************************************
 604  *              _mbbtombc(MSVCRT.@)
 605  */
 606 unsigned int _mbbtombc(unsigned int c)
 607 {
 608   if(MSVCRT___mb_cur_max > 1 &&
 609      ((c >= 0x20 && c <=0x7e) ||(c >= 0xa1 && c <= 0xdf)))
 610   {
 611     /* FIXME: I can't get this function to return anything
 612      * different to what I pass it...
 613      */
 614   }
 615   return c;  /* ASCII CP or no MB char */
 616 }
 617
 618 /*********************************************************************
 619  *              _ismbbkana(MSVCRT.@)
 620  */
 621 int _ismbbkana(unsigned int c)
 622 {
 623   /* FIXME: use lc_ctype when supported, not lc_all */
 624   if(MSVCRT_current_lc_all_cp == 932)
 625   {
 626     /* Japanese/Katakana, CP 932 */
 627     return (c >= 0xa1 && c <= 0xdf);
 628   }
 629   return 0;
 630 }
 631
 632 /*********************************************************************
 633  *              _ismbcdigit(MSVCRT.@)
 634  */
 635 int _ismbcdigit(unsigned int ch)
 636 {
 637     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 638     return (get_char_typeW( wch ) & C1_DIGIT);
 639 }
 640
 641 /*********************************************************************
 642  *              _ismbcgraph(MSVCRT.@)
 643  */
 644 int _ismbcgraph(unsigned int ch)
 645 {
 646     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 647     return (get_char_typeW( wch ) & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA));
 648 }
 649
 650 /*********************************************************************
 651  *              _ismbcalpha (MSVCRT.@)
 652  */
 653 int _ismbcalpha(unsigned int ch)
 654 {
 655     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 656     return (get_char_typeW( wch ) & C1_ALPHA);
 657 }
 658
 659 /*********************************************************************
 660  *              _ismbclower (MSVCRT.@)
 661  */
 662 int _ismbclower(unsigned int ch)
 663 {
 664     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 665     return (get_char_typeW( wch ) & C1_UPPER);
 666 }
 667
 668 /*********************************************************************
 669  *              _ismbcupper (MSVCRT.@)
 670  */
 671 int _ismbcupper(unsigned int ch)
 672 {
 673     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 674     return (get_char_typeW( wch ) & C1_LOWER);
 675 }
 676
 677 /*********************************************************************
 678  *              _ismbcsymbol(MSVCRT.@)
 679  */
 680 int _ismbcsymbol(unsigned int ch)
 681 {
 682     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 683     WORD ctype;
 684     if (!GetStringTypeW(CT_CTYPE3, &wch, 1, &ctype))
 685     {
 686         WARN("GetStringTypeW failed on %x\n", ch);
 687         return 0;
 688     }
 689     return ((ctype & C3_SYMBOL) != 0);
 690 }
 691
 692 /*********************************************************************
 693  *              _ismbcalnum (MSVCRT.@)
 694  */
 695 int _ismbcalnum(unsigned int ch)
 696 {
 697     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 698     return (get_char_typeW( wch ) & (C1_ALPHA | C1_DIGIT));
 699 }
 700
 701 /*********************************************************************
 702  *              _ismbcspace (MSVCRT.@)
 703  */
 704 int _ismbcspace(unsigned int ch)
 705 {
 706     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 707     return (get_char_typeW( wch ) & C1_SPACE);
 708 }
 709
 710 /*********************************************************************
 711  *              _ismbcprint (MSVCRT.@)
 712  */
 713 int _ismbcprint(unsigned int ch)
 714 {
 715     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 716     return (get_char_typeW( wch ) & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA | C1_SPACE));
 717 }
 718
 719 /*********************************************************************
 720  *              _ismbcpunct(MSVCRT.@)
 721  */
 722 int _ismbcpunct(unsigned int ch)
 723 {
 724     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 725     return (get_char_typeW( wch ) & C1_PUNCT);
 726 }
 727
 728 /*********************************************************************
 729  *              _ismbchira(MSVCRT.@)
 730  */
 731 int _ismbchira(unsigned int c)
 732 {
 733   /* FIXME: use lc_ctype when supported, not lc_all */
 734   if(MSVCRT_current_lc_all_cp == 932)
 735   {
 736     /* Japanese/Hiragana, CP 932 */
 737     return (c >= 0x829f && c <= 0x82f1);
 738   }
 739   return 0;
 740 }
 741
 742 /*********************************************************************
 743  *              _ismbckata(MSVCRT.@)
 744  */
 745 int _ismbckata(unsigned int c)
 746 {
 747   /* FIXME: use lc_ctype when supported, not lc_all */
 748   if(MSVCRT_current_lc_all_cp == 932)
 749   {
 750     if(c < 256)
 751       return _ismbbkana(c);
 752     /* Japanese/Katakana, CP 932 */
 753     return (c >= 0x8340 && c <= 0x8396 && c != 0x837f);
 754   }
 755   return 0;
 756 }
 757
 758 /*********************************************************************
 759  *              _ismbblead(MSVCRT.@)
 760  */
 761 int _ismbblead(unsigned int c)
 762 {
 763   /* FIXME: should reference MSVCRT_mbctype */
 764   return MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(c);
 765 }
 766
 767
 768 /*********************************************************************
 769  *              _ismbbtrail(MSVCRT.@)
 770  */
 771 int _ismbbtrail(unsigned int c)
 772 {
 773   /* FIXME: should reference MSVCRT_mbctype */
 774   return !_ismbblead(c);
 775 }
 776
 777 /*********************************************************************
 778  *              _ismbslead(MSVCRT.@)
 779  */
 780 int _ismbslead(const unsigned char* start, const unsigned char* str)
 781 {
 782   /* Lead bytes can also be trail bytes if caller messed up
 783    * iterating through the string...
 784    */
 785   if(MSVCRT___mb_cur_max > 1)
 786   {
 787     while(start < str)
 788       start += MSVCRT_isleadbyte(*str) ? 2 : 1;
 789
 790     if(start == str)
 791       return MSVCRT_isleadbyte(*str);
 792   }
 793   return 0; /* Must have been a trail, we skipped it */
 794 }
 795
 796 /*********************************************************************
 797  *              _ismbstrail(MSVCRT.@)
 798  */
 799 int _ismbstrail(const unsigned char* start, const unsigned char* str)
 800 {
 801   /* Must not be a lead, and must be preceeded by one */
 802   return !_ismbslead(start, str) && MSVCRT_isleadbyte(str[-1]);
 803 }
 804
 805 /*********************************************************************
 806  *              _mbsset(MSVCRT.@)
 807  */
 808 unsigned char* _mbsset(unsigned char* str, unsigned int c)
 809 {
 810   unsigned char* ret = str;
 811
 812   if(MSVCRT___mb_cur_max == 1 || c < 256)
 813     return _strset(str, c); /* ASCII CP or SB char */
 814
 815   c &= 0xffff; /* Strip high bits */
 816
 817   while(str[0] && str[1])
 818   {
 819     *str++ = c >> 8;
 820     *str++ = c & 0xff;
 821   }
 822   if(str[0])
 823     str[0] = '\0'; /* FIXME: OK to shorten? */
 824
 825   return ret;
 826 }
 827
 828 /*********************************************************************
 829  *              _mbsnbset(MSVCRT.@)
 830  */
 831 unsigned char* _mbsnbset(unsigned char *str, unsigned int c, MSVCRT_size_t len)
 832 {
 833     unsigned char *ret = str;
 834
 835     if(!len)
 836         return ret;
 837
 838     if(MSVCRT___mb_cur_max == 1 || c < 256)
 839         return _strnset(str, c, len); /* ASCII CP or SB char */
 840
 841     c &= 0xffff; /* Strip high bits */
 842
 843     while(str[0] && str[1] && (len > 1))
 844     {
 845         *str++ = c >> 8;
 846         len--;
 847         *str++ = c & 0xff;
 848         len--;
 849     }
 850     if(len && str[0]) {
 851         /* as per msdn pad with a blank character */
 852         str[0] = ' ';
 853     }
 854
 855     return ret;
 856 }
 857
 858 /*********************************************************************
 859  *              _mbsnset(MSVCRT.@)
 860  */
 861 unsigned char* _mbsnset(unsigned char* str, unsigned int c, MSVCRT_size_t len)
 862 {
 863   unsigned char *ret = str;
 864
 865   if(!len)
 866     return ret;
 867
 868   if(MSVCRT___mb_cur_max == 1 || c < 256)
 869     return _strnset(str, c, len); /* ASCII CP or SB char */
 870
 871   c &= 0xffff; /* Strip high bits */
 872
 873   while(str[0] && str[1] && len--)
 874   {
 875     *str++ = c >> 8;
 876     *str++ = c & 0xff;
 877   }
 878   if(len && str[0])
 879     str[0] = '\0'; /* FIXME: OK to shorten? */
 880
 881   return ret;
 882 }
 883
 884 /*********************************************************************
 885  *              _mbsnccnt(MSVCRT.@)
 886  * 'c' is for 'character'.
 887  */
 888 MSVCRT_size_t _mbsnccnt(const unsigned char* str, MSVCRT_size_t len)
 889 {
 890   MSVCRT_size_t ret;
 891   if(MSVCRT___mb_cur_max > 1)
 892   {
 893     ret=0;
 894     while(*str && len-- > 0)
 895     {
 896       if(MSVCRT_isleadbyte(*str))
 897       {
 898         if (!len)
 899           break;
 900         len--;
 901         str++;
 902       }
 903       str++;
 904       ret++;
 905     }
 906     return ret;
 907   }
 908   ret=strlen(str);
 909   return min(ret, len); /* ASCII CP */
 910 }
 911
 912 /*********************************************************************
 913  *              _mbsnbcnt(MSVCRT.@)
 914  * 'b' is for byte count.
 915  */
 916 MSVCRT_size_t _mbsnbcnt(const unsigned char* str, MSVCRT_size_t len)
 917 {
 918   MSVCRT_size_t ret;
 919   if(MSVCRT___mb_cur_max > 1)
 920   {
 921     const unsigned char* xstr = str;
 922     while(*xstr && len-- > 0)
 923     {
 924       if (MSVCRT_isleadbyte(*xstr++))
 925         xstr++;
 926     }
 927     return xstr-str;
 928   }
 929   ret=strlen(str);
 930   return min(ret, len); /* ASCII CP */
 931 }
 932
 933
 934 /*********************************************************************
 935  *              _mbsnbcat(MSVCRT.@)
 936  */
 937 unsigned char* _mbsnbcat(unsigned char* dst, const unsigned char* src, MSVCRT_size_t len)
 938 {
 939     if(MSVCRT___mb_cur_max > 1)
 940     {
 941         char *res = dst;
 942         while (*dst) {
 943             if (MSVCRT_isleadbyte(*dst++)) {
 944                 if (*dst) {
 945                     dst++;
 946                 } else {
 947                     /* as per msdn overwrite the lead byte in front of '\0' */
 948                     dst--;
 949                     break;
 950                 }
 951             }
 952         }
 953         while (*src && len--) *dst++ = *src++;
 954         *dst = '\0';
 955         return res;
 956     }
 957     return strncat(dst, src, len); /* ASCII CP */
 958 }
 959
 960
 961 /*********************************************************************
 962  *              _mbsncat(MSVCRT.@)
 963  */
 964 unsigned char* _mbsncat(unsigned char* dst, const unsigned char* src, MSVCRT_size_t len)
 965 {
 966   if(MSVCRT___mb_cur_max > 1)
 967   {
 968     char *res = dst;
 969     while (*dst)
 970     {
 971       if (MSVCRT_isleadbyte(*dst++))
 972         dst++;
 973     }
 974     while (*src && len--)
 975     {
 976       *dst++ = *src;
 977       if(MSVCRT_isleadbyte(*src++))
 978         *dst++ = *src++;
 979     }
 980     *dst = '\0';
 981     return res;
 982   }
 983   return strncat(dst, src, len); /* ASCII CP */
 984 }
 985
 986
 987 /*********************************************************************
 988  *              _mbslwr(MSVCRT.@)
 989  */
 990 unsigned char* _mbslwr(unsigned char* s)
 991 {
 992   if (!s)
 993     return NULL;
 994   if (MSVCRT___mb_cur_max > 1)
 995   {
 996     unsigned int c;
 997     unsigned char* p=s;
 998     while (*s)
 999     {
1000       c = _mbctolower(_mbsnextc(s));
1001       /* Note that I assume that the size of the character is unchanged */
1002       if (c > 255)
1003       {
1004           *s++=(c>>8);
1005           c=c & 0xff;
1006       }
1007       *s++=c;
1008     }
1009     return p;
1010   }
1011   return _strlwr(s);
1012 }
1013
1014
1015 /*********************************************************************
1016  *              _mbsupr(MSVCRT.@)
1017  */
1018 unsigned char* _mbsupr(unsigned char* s)
1019 {
1020   if (!s)
1021     return NULL;
1022   if (MSVCRT___mb_cur_max > 1)
1023   {
1024     unsigned int c;
1025     unsigned char* p=s;
1026     while (*s)
1027     {
1028       c = _mbctoupper(_mbsnextc(s));
1029       /* Note that I assume that the size of the character is unchanged */
1030       if (c > 255)
1031       {
1032           *s++=(c>>8);
1033           c=c & 0xff;
1034       }
1035       *s++=c;
1036     }
1037     return p;
1038   }
1039   return _strupr(s);
1040 }
1041
1042
1043 /*********************************************************************
1044  *              _mbsspn (MSVCRT.@)
1045  */
1046 MSVCRT_size_t _mbsspn(const unsigned char* string, const unsigned char* set)
1047 {
1048   const unsigned char *p, *q;
1049
1050   for (p = string; *p; p++)
1051     {
1052       if (MSVCRT_isleadbyte(*p))
1053         {
1054           for (q = set; *q; q++)
1055             {
1056               if (!q[1])
1057                 break;
1058               if ((*p == *q) &&  (p[1] == q[1]))
1059                 break;
1060               q++;
1061             }
1062           if (*++p == '\0')
1063             break;
1064         }
1065       else
1066         for (q = set; *q; q++)
1067           if (*p == *q)
1068             break;
1069     }
1070   return p - string;
1071 }
1072
1073 /*********************************************************************
1074  *              _mbscspn(MSVCRT.@)
1075  */
1076 MSVCRT_size_t _mbscspn(const unsigned char* str, const unsigned char* cmp)
1077 {
1078   if (MSVCRT___mb_cur_max > 1)
1079     FIXME("don't handle double character case\n");
1080   return strcspn(str, cmp);
1081 }
1082
1083 /*********************************************************************
1084  *              _mbsrev (MSVCRT.@)
1085  */
1086 unsigned char* _mbsrev(unsigned char* str)
1087 {
1088     int i, len = _mbslen(str);
1089     unsigned char *p, *temp=MSVCRT_malloc(len*2);
1090
1091     if(!temp)
1092         return str;
1093
1094     /* unpack multibyte string to temp buffer */
1095     p=str;
1096     for(i=0; i<len; i++)
1097     {
1098         if (MSVCRT_isleadbyte(*p))
1099         {
1100             temp[i*2]=*p++;
1101             temp[i*2+1]=*p++;
1102         }
1103         else
1104         {
1105             temp[i*2]=*p++;
1106             temp[i*2+1]=0;
1107         }
1108     }
1109
1110     /* repack it in the reverse order */
1111     p=str;
1112     for(i=len-1; i>=0; i--)
1113     {
1114         if(MSVCRT_isleadbyte(temp[i*2]))
1115         {
1116             *p++=temp[i*2];
1117             *p++=temp[i*2+1];
1118         }
1119         else
1120         {
1121             *p++=temp[i*2];
1122         }
1123     }
1124
1125     MSVCRT_free(temp);
1126
1127     return str;
1128 }
1129
1130 /*********************************************************************
1131  *              _mbspbrk (MSVCRT.@)
1132  */
1133 unsigned char* _mbspbrk(const unsigned char* str, const unsigned char* accept)
1134 {
1135     const unsigned char* p;
1136
1137     while(*str)
1138     {
1139         for(p = accept; *p; p += (MSVCRT_isleadbyte(*p)?2:1) )
1140         {
1141             if (*p == *str)
1142                 if( !MSVCRT_isleadbyte(*p) || ( *(p+1) == *(str+1) ) )
1143                      return (unsigned char*)str;
1144         }
1145         str += (MSVCRT_isleadbyte(*str)?2:1);
1146     }
1147     return NULL;
1148 }