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