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       FIXME("%s %s %d\n",str,cmp,len);
 429   }
 430   return strncmp(str,cmp,len);
 431 }
 432
 433 /*********************************************************************
 434  *              _mbsnicmp(MSVCRT.@)
 435  *
 436  * Compare two multibyte strings case insensitively to 'len' characters.
 437  */
 438 int _mbsnicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 439 {
 440   /* FIXME: No tolower() for mb strings yet */
 441   if(MSVCRT___mb_cur_max > 1)
 442   {
 443     unsigned int strc, cmpc;
 444     while(len--)
 445     {
 446       if(!*str)
 447         return *cmp ? -1 : 0;
 448       if(!*cmp)
 449         return 1;
 450       strc = _mbctolower(_mbsnextc(str));
 451       cmpc = _mbctolower(_mbsnextc(cmp));
 452       if(strc != cmpc)
 453         return strc < cmpc ? -1 : 1;
 454       str +=(strc > 255) ? 2 : 1;
 455       cmp +=(strc > 255) ? 2 : 1; /* Equal, use same increment */
 456     }
 457     return 0; /* Matched len chars */
 458   }
 459   return strncasecmp(str, cmp, len); /* ASCII CP */
 460 }
 461
 462 /*********************************************************************
 463  *              _mbsnbicmp(MSVCRT.@)
 464  */
 465 int _mbsnbicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 466 {
 467   if (!len)
 468     return 0;
 469   if(MSVCRT___mb_cur_max > 1)
 470   {
 471     unsigned int strc, cmpc;
 472     while (len)
 473     {
 474       int clen;
 475       if(!*str)
 476         return *cmp ? -1 : 0;
 477       if(!*cmp)
 478         return 1;
 479       if (MSVCRT_isleadbyte(*str))
 480       {
 481         strc=(len>=2)?_mbsnextc(str):0;
 482         clen=2;
 483       }
 484       else
 485       {
 486         strc=*str;
 487         clen=1;
 488       }
 489       if (MSVCRT_isleadbyte(*cmp))
 490         cmpc=(len>=2)?_mbsnextc(cmp):0;
 491       else
 492         cmpc=*str;
 493       strc = _mbctolower(strc);
 494       cmpc = _mbctolower(cmpc);
 495       if(strc != cmpc)
 496         return strc < cmpc ? -1 : 1;
 497       len -= clen;
 498       str += clen;
 499       cmp += clen;
 500     }
 501     return 0; /* Matched len bytes */
 502       FIXME("%s %s %d\n",str,cmp,len);
 503   }
 504   return strncmp(str,cmp,len);
 505 }
 506
 507 /*********************************************************************
 508  *              _mbschr(MSVCRT.@)
 509  *
 510  * Find a multibyte character in a multibyte string.
 511  */
 512 unsigned char* _mbschr(const unsigned char* s, unsigned int x)
 513 {
 514   if(MSVCRT___mb_cur_max > 1)
 515   {
 516     unsigned int c;
 517     while (1)
 518     {
 519       c = _mbsnextc(s);
 520       if (c == x)
 521         return (unsigned char*)s;
 522       if (!c)
 523         return NULL;
 524       s += c > 255 ? 2 : 1;
 525     }
 526   }
 527   return strchr(s, x); /* ASCII CP */
 528 }
 529
 530 /*********************************************************************
 531  *              _mbsrchr(MSVCRT.@)
 532  */
 533 unsigned char* _mbsrchr(const unsigned char* s, unsigned int x)
 534 {
 535   if(MSVCRT___mb_cur_max > 1)
 536   {
 537     unsigned int c;
 538     unsigned char* match=NULL;
 539     if(!s)
 540       return NULL;
 541     while (1) {
 542       c = _mbsnextc(s);
 543       if (c == x)
 544         match=(unsigned char*)s;
 545       if (!c)
 546         return match;
 547       s +=(c > 255) ? 2 : 1;
 548     }
 549   }
 550   return strrchr(s,x);
 551 }
 552
 553 /*********************************************************************
 554  *              _mbstok(MSVCRT.@)
 555  *
 556  * Find and extract tokens from strings
 557  */
 558 unsigned char* _mbstok(unsigned char *str, const unsigned char *delim)
 559 {
 560     static char *next = NULL;
 561     char *ret;
 562
 563     if(MSVCRT___mb_cur_max > 1)
 564     {
 565         unsigned int c;
 566
 567         if (!str)
 568             if (!(str = next)) return NULL;
 569
 570         while ((c = _mbsnextc(str)) && _mbschr(delim, c)) {
 571             str += c > 255 ? 2 : 1;
 572         }
 573         if (!*str) return NULL;
 574         ret = str++;
 575         while ((c = _mbsnextc(str)) && !_mbschr(delim, c)) {
 576             str += c > 255 ? 2 : 1;
 577         }
 578         if (*str) {
 579             *str++ = 0;
 580             if (c > 255) *str++ = 0;
 581         }
 582         next = str;
 583         return ret;
 584     }
 585     return strtok(str, delim);  /* ASCII CP */
 586 }
 587
 588 /*********************************************************************
 589  *              mbtowc(MSVCRT.@)
 590  */
 591 int MSVCRT_mbtowc(MSVCRT_wchar_t *dst, const char* str, MSVCRT_size_t n)
 592 {
 593   if(n <= 0 || !str)
 594     return 0;
 595   if(!MultiByteToWideChar(CP_ACP, 0, str, n, dst, 1))
 596     return 0;
 597   /* return the number of bytes from src that have been used */
 598   if(!*str)
 599     return 0;
 600   if(n >= 2 && MSVCRT_isleadbyte(*str) && str[1])
 601     return 2;
 602   return 1;
 603 }
 604
 605 /*********************************************************************
 606  *              _mbbtombc(MSVCRT.@)
 607  */
 608 unsigned int _mbbtombc(unsigned int c)
 609 {
 610   if(MSVCRT___mb_cur_max > 1 &&
 611      ((c >= 0x20 && c <=0x7e) ||(c >= 0xa1 && c <= 0xdf)))
 612   {
 613     /* FIXME: I can't get this function to return anything
 614      * different to what I pass it...
 615      */
 616   }
 617   return c;  /* ASCII CP or no MB char */
 618 }
 619
 620 /*********************************************************************
 621  *              _ismbbkana(MSVCRT.@)
 622  */
 623 int _ismbbkana(unsigned int c)
 624 {
 625   /* FIXME: use lc_ctype when supported, not lc_all */
 626   if(MSVCRT_current_lc_all_cp == 932)
 627   {
 628     /* Japanese/Katakana, CP 932 */
 629     return (c >= 0xa1 && c <= 0xdf);
 630   }
 631   return 0;
 632 }
 633
 634 /*********************************************************************
 635  *              _ismbcdigit(MSVCRT.@)
 636  */
 637 int _ismbcdigit(unsigned int ch)
 638 {
 639     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 640     return (get_char_typeW( wch ) & C1_DIGIT);
 641 }
 642
 643 /*********************************************************************
 644  *              _ismbcgraph(MSVCRT.@)
 645  */
 646 int _ismbcgraph(unsigned int ch)
 647 {
 648     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 649     return (get_char_typeW( wch ) & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA));
 650 }
 651
 652 /*********************************************************************
 653  *              _ismbcalpha (MSVCRT.@)
 654  */
 655 int _ismbcalpha(unsigned int ch)
 656 {
 657     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 658     return (get_char_typeW( wch ) & C1_ALPHA);
 659 }
 660
 661 /*********************************************************************
 662  *              _ismbclower (MSVCRT.@)
 663  */
 664 int _ismbclower(unsigned int ch)
 665 {
 666     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 667     return (get_char_typeW( wch ) & C1_UPPER);
 668 }
 669
 670 /*********************************************************************
 671  *              _ismbcupper (MSVCRT.@)
 672  */
 673 int _ismbcupper(unsigned int ch)
 674 {
 675     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 676     return (get_char_typeW( wch ) & C1_LOWER);
 677 }
 678
 679 /*********************************************************************
 680  *              _ismbcsymbol(MSVCRT.@)
 681  */
 682 int _ismbcsymbol(unsigned int ch)
 683 {
 684     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 685     WORD ctype;
 686     if (!GetStringTypeW(CT_CTYPE3, &wch, 1, &ctype))
 687     {
 688         WARN("GetStringTypeW failed on %x\n", ch);
 689         return 0;
 690     }
 691     return ((ctype & C3_SYMBOL) != 0);
 692 }
 693
 694 /*********************************************************************
 695  *              _ismbcalnum (MSVCRT.@)
 696  */
 697 int _ismbcalnum(unsigned int ch)
 698 {
 699     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 700     return (get_char_typeW( wch ) & (C1_ALPHA | C1_DIGIT));
 701 }
 702
 703 /*********************************************************************
 704  *              _ismbcspace (MSVCRT.@)
 705  */
 706 int _ismbcspace(unsigned int ch)
 707 {
 708     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 709     return (get_char_typeW( wch ) & C1_SPACE);
 710 }
 711
 712 /*********************************************************************
 713  *              _ismbcprint (MSVCRT.@)
 714  */
 715 int _ismbcprint(unsigned int ch)
 716 {
 717     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 718     return (get_char_typeW( wch ) & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA | C1_SPACE));
 719 }
 720
 721 /*********************************************************************
 722  *              _ismbcpunct(MSVCRT.@)
 723  */
 724 int _ismbcpunct(unsigned int ch)
 725 {
 726     MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
 727     return (get_char_typeW( wch ) & C1_PUNCT);
 728 }
 729
 730 /*********************************************************************
 731  *              _ismbchira(MSVCRT.@)
 732  */
 733 int _ismbchira(unsigned int c)
 734 {
 735   /* FIXME: use lc_ctype when supported, not lc_all */
 736   if(MSVCRT_current_lc_all_cp == 932)
 737   {
 738     /* Japanese/Hiragana, CP 932 */
 739     return (c >= 0x829f && c <= 0x82f1);
 740   }
 741   return 0;
 742 }
 743
 744 /*********************************************************************
 745  *              _ismbckata(MSVCRT.@)
 746  */
 747 int _ismbckata(unsigned int c)
 748 {
 749   /* FIXME: use lc_ctype when supported, not lc_all */
 750   if(MSVCRT_current_lc_all_cp == 932)
 751   {
 752     if(c < 256)
 753       return _ismbbkana(c);
 754     /* Japanese/Katakana, CP 932 */
 755     return (c >= 0x8340 && c <= 0x8396 && c != 0x837f);
 756   }
 757   return 0;
 758 }
 759
 760 /*********************************************************************
 761  *              _ismbblead(MSVCRT.@)
 762  */
 763 int _ismbblead(unsigned int c)
 764 {
 765   /* FIXME: should reference MSVCRT_mbctype */
 766   return MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(c);
 767 }
 768
 769
 770 /*********************************************************************
 771  *              _ismbbtrail(MSVCRT.@)
 772  */
 773 int _ismbbtrail(unsigned int c)
 774 {
 775   /* FIXME: should reference MSVCRT_mbctype */
 776   return !_ismbblead(c);
 777 }
 778
 779 /*********************************************************************
 780  *              _ismbslead(MSVCRT.@)
 781  */
 782 int _ismbslead(const unsigned char* start, const unsigned char* str)
 783 {
 784   /* Lead bytes can also be trail bytes if caller messed up
 785    * iterating through the string...
 786    */
 787   if(MSVCRT___mb_cur_max > 1)
 788   {
 789     while(start < str)
 790       start += MSVCRT_isleadbyte(*str) ? 2 : 1;
 791
 792     if(start == str)
 793       return MSVCRT_isleadbyte(*str);
 794   }
 795   return 0; /* Must have been a trail, we skipped it */
 796 }
 797
 798 /*********************************************************************
 799  *              _ismbstrail(MSVCRT.@)
 800  */
 801 int _ismbstrail(const unsigned char* start, const unsigned char* str)
 802 {
 803   /* Must not be a lead, and must be preceeded by one */
 804   return !_ismbslead(start, str) && MSVCRT_isleadbyte(str[-1]);
 805 }
 806
 807 /*********************************************************************
 808  *              _mbsset(MSVCRT.@)
 809  */
 810 unsigned char* _mbsset(unsigned char* str, unsigned int c)
 811 {
 812   unsigned char* ret = str;
 813
 814   if(MSVCRT___mb_cur_max == 1 || c < 256)
 815     return _strset(str, c); /* ASCII CP or SB char */
 816
 817   c &= 0xffff; /* Strip high bits */
 818
 819   while(str[0] && str[1])
 820   {
 821     *str++ = c >> 8;
 822     *str++ = c & 0xff;
 823   }
 824   if(str[0])
 825     str[0] = '\0'; /* FIXME: OK to shorten? */
 826
 827   return ret;
 828 }
 829
 830 /*********************************************************************
 831  *              _mbsnbset(MSVCRT.@)
 832  */
 833 unsigned char* _mbsnbset(unsigned char *str, unsigned int c, MSVCRT_size_t len)
 834 {
 835     unsigned char *ret = str;
 836
 837     if(!len)
 838         return ret;
 839
 840     if(MSVCRT___mb_cur_max == 1 || c < 256)
 841         return _strnset(str, c, len); /* ASCII CP or SB char */
 842
 843     c &= 0xffff; /* Strip high bits */
 844
 845     while(str[0] && str[1] && (len > 1))
 846     {
 847         *str++ = c >> 8;
 848         len--;
 849         *str++ = c & 0xff;
 850         len--;
 851     }
 852     if(len && str[0]) {
 853         /* as per msdn pad with a blank character */
 854         str[0] = ' ';
 855     }
 856
 857     return ret;
 858 }
 859
 860 /*********************************************************************
 861  *              _mbsnset(MSVCRT.@)
 862  */
 863 unsigned char* _mbsnset(unsigned char* str, unsigned int c, MSVCRT_size_t len)
 864 {
 865   unsigned char *ret = str;
 866
 867   if(!len)
 868     return ret;
 869
 870   if(MSVCRT___mb_cur_max == 1 || c < 256)
 871     return _strnset(str, c, len); /* ASCII CP or SB char */
 872
 873   c &= 0xffff; /* Strip high bits */
 874
 875   while(str[0] && str[1] && len--)
 876   {
 877     *str++ = c >> 8;
 878     *str++ = c & 0xff;
 879   }
 880   if(len && str[0])
 881     str[0] = '\0'; /* FIXME: OK to shorten? */
 882
 883   return ret;
 884 }
 885
 886 /*********************************************************************
 887  *              _mbsnccnt(MSVCRT.@)
 888  * 'c' is for 'character'.
 889  */
 890 MSVCRT_size_t _mbsnccnt(const unsigned char* str, MSVCRT_size_t len)
 891 {
 892   MSVCRT_size_t ret;
 893   if(MSVCRT___mb_cur_max > 1)
 894   {
 895     ret=0;
 896     while(*str && len-- > 0)
 897     {
 898       if(MSVCRT_isleadbyte(*str))
 899       {
 900         if (!len)
 901           break;
 902         len--;
 903         str++;
 904       }
 905       str++;
 906       ret++;
 907     }
 908     return ret;
 909   }
 910   ret=strlen(str);
 911   return min(ret, len); /* ASCII CP */
 912 }
 913
 914 /*********************************************************************
 915  *              _mbsnbcnt(MSVCRT.@)
 916  * 'b' is for byte count.
 917  */
 918 MSVCRT_size_t _mbsnbcnt(const unsigned char* str, MSVCRT_size_t len)
 919 {
 920   MSVCRT_size_t ret;
 921   if(MSVCRT___mb_cur_max > 1)
 922   {
 923     const unsigned char* xstr = str;
 924     while(*xstr && len-- > 0)
 925     {
 926       if (MSVCRT_isleadbyte(*xstr++))
 927         xstr++;
 928     }
 929     return xstr-str;
 930   }
 931   ret=strlen(str);
 932   return min(ret, len); /* ASCII CP */
 933 }
 934
 935
 936 /*********************************************************************
 937  *              _mbsncat(MSVCRT.@)
 938  */
 939 unsigned char* _mbsncat(unsigned char* dst, const unsigned char* src, MSVCRT_size_t len)
 940 {
 941   if(MSVCRT___mb_cur_max > 1)
 942   {
 943     char *res = dst;
 944     while (*dst)
 945     {
 946       if (MSVCRT_isleadbyte(*dst++))
 947         dst++;
 948     }
 949     while (*src && len--)
 950     {
 951       *dst++ = *src;
 952       if(MSVCRT_isleadbyte(*src++))
 953         *dst++ = *src++;
 954     }
 955     *dst = '\0';
 956     return res;
 957   }
 958   return strncat(dst, src, len); /* ASCII CP */
 959 }
 960
 961
 962 /*********************************************************************
 963  *              _mbslwr(MSVCRT.@)
 964  */
 965 unsigned char* _mbslwr(unsigned char* s)
 966 {
 967   if (!s)
 968     return NULL;
 969   if (MSVCRT___mb_cur_max > 1)
 970   {
 971     unsigned int c;
 972     unsigned char* p=s;
 973     while (*s)
 974     {
 975       c = _mbctolower(_mbsnextc(s));
 976       /* Note that I assume that the size of the character is unchanged */
 977       if (c > 255)
 978       {
 979           *s++=(c>>8);
 980           c=c & 0xff;
 981       }
 982       *s++=c;
 983     }
 984     return p;
 985   }
 986   return _strlwr(s);
 987 }
 988
 989
 990 /*********************************************************************
 991  *              _mbsupr(MSVCRT.@)
 992  */
 993 unsigned char* _mbsupr(unsigned char* s)
 994 {
 995   if (!s)
 996     return NULL;
 997   if (MSVCRT___mb_cur_max > 1)
 998   {
 999     unsigned int c;
1000     unsigned char* p=s;
1001     while (*s)
1002     {
1003       c = _mbctoupper(_mbsnextc(s));
1004       /* Note that I assume that the size of the character is unchanged */
1005       if (c > 255)
1006       {
1007           *s++=(c>>8);
1008           c=c & 0xff;
1009       }
1010       *s++=c;
1011     }
1012     return p;
1013   }
1014   return _strupr(s);
1015 }
1016
1017
1018 /*********************************************************************
1019  *              _mbsspn (MSVCRT.@)
1020  */
1021 MSVCRT_size_t _mbsspn(const unsigned char* string, const unsigned char* set)
1022 {
1023   const unsigned char *p, *q;
1024
1025   for (p = string; *p; p++)
1026     {
1027       if (MSVCRT_isleadbyte(*p))
1028         {
1029           for (q = set; *q; q++)
1030             {
1031               if (!q[1])
1032                 break;
1033               if ((*p == *q) &&  (p[1] == q[1]))
1034                 break;
1035               q++;
1036             }
1037           if (*++p == '\0')
1038             break;
1039         }
1040       else
1041         for (q = set; *q; q++)
1042           if (*p == *q)
1043             break;
1044     }
1045   return p - string;
1046 }
1047
1048 /*********************************************************************
1049  *              _mbscspn(MSVCRT.@)
1050  */
1051 MSVCRT_size_t _mbscspn(const unsigned char* str, const unsigned char* cmp)
1052 {
1053   if (MSVCRT___mb_cur_max > 1)
1054     FIXME("don't handle double character case\n");
1055   return strcspn(str, cmp);
1056 }
1057
1058 /*********************************************************************
1059  *              _mbsrev (MSVCRT.@)
1060  */
1061 unsigned char* _mbsrev(unsigned char* str)
1062 {
1063     int i, len = _mbslen(str);
1064     unsigned char *p, *temp=MSVCRT_malloc(len*2);
1065
1066     if(!temp)
1067         return str;
1068
1069     /* unpack multibyte string to temp buffer */
1070     p=str;
1071     for(i=0; i<len; i++)
1072     {
1073         if (MSVCRT_isleadbyte(*p))
1074         {
1075             temp[i*2]=*p++;
1076             temp[i*2+1]=*p++;
1077         }
1078         else
1079         {
1080             temp[i*2]=*p++;
1081             temp[i*2+1]=0;
1082         }
1083     }
1084
1085     /* repack it in the reverse order */
1086     p=str;
1087     for(i=len-1; i>=0; i--)
1088     {
1089         if(MSVCRT_isleadbyte(temp[i*2]))
1090         {
1091             *p++=temp[i*2];
1092             *p++=temp[i*2+1];
1093         }
1094         else
1095         {
1096             *p++=temp[i*2];
1097         }
1098     }
1099
1100     MSVCRT_free(temp);
1101
1102     return str;
1103 }
1104
1105 /*********************************************************************
1106  *              _mbspbrk (MSVCRT.@)
1107  */
1108 unsigned char* _mbspbrk(const unsigned char* str, const unsigned char* accept)
1109 {
1110     const unsigned char* p;
1111
1112     while(*str)
1113     {
1114         for(p = accept; *p; p += (MSVCRT_isleadbyte(*p)?2:1) )
1115         {
1116             if (*p == *str)
1117                 if( !MSVCRT_isleadbyte(*p) || ( *(p+1) == *(str+1) ) )
1118                      return (unsigned char*)str;
1119         }
1120         str += (MSVCRT_isleadbyte(*str)?2:1);
1121     }
1122     return NULL;
1123 }