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