mbcs update

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 




   This patch is supposed to cleanup and improve the mbcs support in
msvcrt:
 * adds include/msvcrt/mbctype.h and include/msvcrt/mbstring.h
 * fixes the function prototypes in dlls/msvcrt/mbcs.c (mostly
char/unsigned char and int/MSVCRT_size_t mismatches)
 * fixes a couple of bugs, e.g. _mbsnccnt could lead to len<0 which
since it's an unsigned int would be pretty bad
 * improves the support, e.g. _mbsicmp, _mbsnicmp, ...
 * and reorders functions a bit so that related functions are
implemented next to each other: e.g. _mbscmp, _mbsicmp, _mbsncmp,
_mbsnicmp
 * somewhat unrelated: implements putwc/putwchar by calling
fputwc/fputwchar (AFAICT they are really identical)


Changelog:

   François Gouget <fgouget@codeweavers.com>

 * include/msvcrt/mbctype.h,
   include/msvcrt/mbstring.h,
   include/Makefile.in,
   include/msvcrt/string.h,
   dlls/msvcrt/mbcs.c,
   dlls/msvcrt/msvcrt.spec

   Cleanup and improve the mbcs support
   Add mbctype.h and mbstring.h
   Implement putwc and putwchar


-- 
François Gouget
fgouget@codeweavers.com
--- /dev/null	Fri Nov 16 17:06:31 2001
+++ include/msvcrt/mbctype.h	Tue Dec  4 18:12:53 2001
@@ -0,0 +1,38 @@
+/*
+ * Multibyte char definitions
+ *
+ * Copyright 2001 Francois Gouget.
+ */
+#ifndef __WINE_MBCTYPE_H
+#define __WINE_MBCTYPE_H
+#define __WINE_USE_MSVCRT
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+unsigned char* __p__mbctype(void);
+#define _mbctype                   (__p__mbctype())
+
+int         _getmbcp(void);
+int         _ismbbalnum(unsigned int);
+int         _ismbbalpha(unsigned int);
+int         _ismbbgraph(unsigned int);
+int         _ismbbkalnum(unsigned int);
+int         _ismbbkana(unsigned int);
+int         _ismbbkprint(unsigned int);
+int         _ismbbkpunct(unsigned int);
+int         _ismbblead(unsigned int);
+int         _ismbbprint(unsigned int);
+int         _ismbbpunct(unsigned int);
+int         _ismbbtrail(unsigned int);
+int         _ismbslead(const unsigned char*,const unsigned char*);
+int         _ismbstrail(const unsigned char*,const unsigned char*);
+int         _setmbcp(int);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __WINE_MBCTYPE_H */
--- /dev/null	Fri Nov 16 17:06:31 2001
+++ include/msvcrt/mbstring.h	Tue Dec  4 18:12:58 2001
@@ -0,0 +1,107 @@
+/*
+ * Multibyte string definitions
+ *
+ * Copyright 2001 Francois Gouget.
+ */
+#ifndef __WINE_MBSTRING_H
+#define __WINE_MBSTRING_H
+#define __WINE_USE_MSVCRT
+
+#include "msvcrt/mbctype.h"
+
+#ifdef USE_MSVCRT_PREFIX
+#define MSVCRT(x)    MSVCRT_##x
+#else
+#define MSVCRT(x)    x
+#endif
+
+#ifndef MSVCRT_SIZE_T_DEFINED
+typedef unsigned int MSVCRT(size_t);
+#define MSVCRT_SIZE_T_DEFINED
+#endif
+
+#define _NLSCMPERROR               ((unsigned int)0x7fffffff)
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int         _ismbcalnum(unsigned int);
+int         _ismbcalpha(unsigned int);
+int         _ismbcdigit(unsigned int);
+int         _ismbcgraph(unsigned int);
+int         _ismbchira(unsigned int);
+int         _ismbckata(unsigned int);
+int         _ismbcl0(unsigned int);
+int         _ismbcl1(unsigned int);
+int         _ismbcl2(unsigned int);
+int         _ismbclegal(unsigned int);
+int         _ismbclower(unsigned int);
+int         _ismbcprint(unsigned int);
+int         _ismbcpunct(unsigned int);
+int         _ismbcspace(unsigned int);
+int         _ismbcsymbol(unsigned int);
+int         _ismbcupper(unsigned int);
+unsigned int _mbbtombc(unsigned int);
+int         _mbbtype(unsigned char,int);
+#define     _mbccmp(_cpc1,_cpc2) _mbsncmp((_cpc1),(_cpc2),1)
+void        _mbccpy(unsigned char*,const unsigned char*);
+unsigned int _mbcjistojms(unsigned int);
+unsigned int _mbcjmstojis(unsigned int);
+MSVCRT(size_t) _mbclen(const unsigned char*);
+unsigned int _mbctohira(unsigned int);
+unsigned int _mbctokata(unsigned int);
+unsigned int _mbctolower(unsigned int);
+unsigned int _mbctombb(unsigned int);
+unsigned int _mbctoupper(unsigned int);
+int         _mbsbtype(const unsigned char*,MSVCRT(size_t));
+unsigned char* _mbscat(unsigned char*,const unsigned char*);
+unsigned char* _mbschr(const unsigned char*,unsigned int);
+int         _mbscmp(const unsigned char*,const unsigned char*);
+int         _mbscoll(const unsigned char*,const unsigned char*);
+unsigned char* _mbscpy(unsigned char*,const unsigned char*);
+MSVCRT(size_t) _mbscspn(const unsigned char*,const unsigned char*);
+unsigned char* _mbsdec(const unsigned char*,const unsigned char*);
+unsigned char* _mbsdup(const unsigned char*);
+int         _mbsicmp(const unsigned char*,const unsigned char*);
+int         _mbsicoll(const unsigned char*,const unsigned char*);
+unsigned char* _mbsinc(const unsigned char*);
+MSVCRT(size_t) _mbslen(const unsigned char*);
+unsigned char* _mbslwr(unsigned char*);
+unsigned char* _mbsnbcat(unsigned char*,const unsigned char*,MSVCRT(size_t));
+int         _mbsnbcmp(const unsigned char*,const unsigned char*,MSVCRT(size_t));
+int         _mbsnbcoll(const unsigned char*,const unsigned char*,MSVCRT(size_t));
+MSVCRT(size_t) _mbsnbcnt(const unsigned char*,MSVCRT(size_t));
+unsigned char* _mbsnbcpy(unsigned char*,const unsigned char*
+,MSVCRT(size_t));
+int         _mbsnbicmp(const unsigned char*,const unsigned char*,MSVCRT(size_t));
+int         _mbsnbicoll(const unsigned char*,const unsigned char*,MSVCRT(size_t));
+unsigned char* _mbsnbset(unsigned char*,unsigned int,MSVCRT(size_t))
+;
+unsigned char* _mbsncat(unsigned char*,const unsigned char*,
+ MSVCRT(size_t));
+MSVCRT(size_t) _mbsnccnt(const unsigned char*,MSVCRT(size_t));
+int         _mbsncmp(const unsigned char*,const unsigned char*,MSVCRT(size_t));
+int         _mbsncoll(const unsigned char*,const unsigned char*,MSVCRT(size_t));
+unsigned char* _mbsncpy(unsigned char*,const unsigned char*,MSVCRT(size_t));
+unsigned int _mbsnextc (const unsigned char*);
+int         _mbsnicmp(const unsigned char*,const unsigned char*,MSVCRT(size_t));
+int         _mbsnicoll(const unsigned char*,const unsigned char*,MSVCRT(size_t));
+unsigned char* _mbsninc(const unsigned char*,MSVCRT(size_t));
+unsigned char* _mbsnset(unsigned char*,unsigned int,MSVCRT(size_t));
+unsigned char* _mbspbrk(const unsigned char*,const unsigned char*);
+unsigned char* _mbsrchr(const unsigned char*,unsigned int);
+unsigned char* _mbsrev(unsigned char*);
+unsigned char* _mbsset(unsigned char*,unsigned int);
+MSVCRT(size_t) _mbsspn(const unsigned char*,const unsigned char*);
+unsigned char* _mbsspnp(const unsigned char*,const unsigned char*);
+unsigned char* _mbsstr(const unsigned char*,const unsigned char*);
+unsigned char* _mbstok(unsigned char*,const unsigned char*);
+unsigned char* _mbsupr(unsigned char*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __WINE_MBSTRING_H */
Index: include/Makefile.in
===================================================================
RCS file: /home/wine/wine/include/Makefile.in,v
retrieving revision 1.35
diff -u -r1.35 Makefile.in
--- include/Makefile.in	2001/11/14 21:26:24	1.35
+++ include/Makefile.in	2001/12/05 00:39:24
@@ -61,6 +61,8 @@
 	msvcrt/io.h \
 	msvcrt/locale.h \
 	msvcrt/malloc.h \
+	msvcrt/mbctype.h \
+	msvcrt/mbstring.h \
 	msvcrt/process.h \
 	msvcrt/search.h \
 	msvcrt/stddef.h \
Index: include/msvcrt/string.h
===================================================================
RCS file: /home/wine/wine/include/msvcrt/string.h,v
retrieving revision 1.3
diff -u -r1.3 string.h
--- include/msvcrt/string.h	2001/10/22 18:59:23	1.3
+++ include/msvcrt/string.h	2001/12/05 00:35:02
@@ -28,9 +28,6 @@
 extern "C" {
 #endif
 
-unsigned char* _mbschr(const unsigned char*,unsigned int);
-unsigned char* _mbsncat(unsigned char*,const unsigned char*,MSVCRT(size_t));
-unsigned char* _mbstok(unsigned char*,unsigned char*);
 void*       _memccpy(void*,const void*,int,MSVCRT(size_t));
 int         _memicmp(const void*,const void*,MSVCRT(size_t));
 int         _strcmpi(const char*,const char*);
Index: dlls/msvcrt/mbcs.c
===================================================================
RCS file: /home/wine/wine/dlls/msvcrt/mbcs.c,v
retrieving revision 1.14
diff -u -r1.14 mbcs.c
--- dlls/msvcrt/mbcs.c	2001/11/12 15:47:26	1.14
+++ dlls/msvcrt/mbcs.c	2001/12/05 00:44:48
@@ -11,6 +11,8 @@
 
 #include "msvcrt.h"
 
+#include "msvcrt/mbctype.h"
+#include "msvcrt/mbstring.h"
 #include "msvcrt/stdlib.h"
 #include "msvcrt/string.h"
 #include "msvcrt/wctype.h"
@@ -24,7 +26,7 @@
 /*********************************************************************
  *		__p__mbctype (MSVCRT.@)
  */
-unsigned char *__p__mbctype(void)
+unsigned char* __p__mbctype(void)
 {
   return MSVCRT_mbctype;
 }
@@ -32,7 +34,7 @@
 /*********************************************************************
  *		__p___mb_cur_max(MSVCRT.@)
  */
-int *__p___mb_cur_max(void)
+int* __p___mb_cur_max(void)
 {
   return &MSVCRT___mb_cur_max;
 }
@@ -40,7 +42,7 @@
 /*********************************************************************
  *		_mbsnextc(MSVCRT.@)
  */
-unsigned int _mbsnextc(const unsigned char *str)
+unsigned int _mbsnextc(const unsigned char* str)
 {
   if(MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(*str))
     return *str << 8 | str[1];
@@ -48,9 +50,204 @@
 }
 
 /*********************************************************************
+ *		_mbctolower(MSVCRT.@)
+ */
+unsigned int _mbctolower(unsigned int c)
+{
+    if (MSVCRT_isleadbyte(c))
+    {
+      FIXME("Handle MBC chars\n");
+      return c;
+    }
+    return tolower(c); /* ASCII CP or SB char */
+}
+
+/*********************************************************************
+ *		_mbctoupper(MSVCRT.@)
+ */
+unsigned int _mbctoupper(unsigned int c)
+{
+    if (MSVCRT_isleadbyte(c))
+    {
+      FIXME("Handle MBC chars\n");
+      return c;
+    }
+    return toupper(c); /* ASCII CP or SB char */
+}
+
+/*********************************************************************
+ *		_mbsdec(MSVCRT.@)
+ */
+unsigned char* _mbsdec(const unsigned char* start, const unsigned char* cur)
+{
+  if(MSVCRT___mb_cur_max > 1)
+    return (char *)(_ismbstrail(start,cur-1) ? cur - 2 : cur -1);
+
+  return (char *)cur - 1; /* ASCII CP or SB char */
+}
+
+/*********************************************************************
+ *		_mbsinc(MSVCRT.@)
+ */
+unsigned char* _mbsinc(const unsigned char* str)
+{
+  if(MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(*str))
+    return (unsigned char*)str + 2; /* MB char */
+
+  return (unsigned char*)str + 1; /* ASCII CP or SB char */
+}
+
+/*********************************************************************
+ *		_mbsninc(MSVCRT.@)
+ */
+unsigned char* _mbsninc(const unsigned char* str, MSVCRT_size_t num)
+{
+  if(!str || num < 1)
+    return NULL;
+  if(MSVCRT___mb_cur_max > 1)
+  {
+    while(num--)
+      str = _mbsinc(str);
+    return (unsigned char*)str;
+  }
+  return (unsigned char*)str + num; /* ASCII CP */
+}
+
+/*********************************************************************
+ *		_mbclen(MSVCRT.@)
+ */
+unsigned int _mbclen(const unsigned char* str)
+{
+  return MSVCRT_isleadbyte(*str) ? 2 : 1;
+}
+
+/*********************************************************************
+ *		mblen(MSVCRT.@)
+ */
+int MSVCRT_mblen(const char* str, MSVCRT_size_t size)
+{
+  if (str && *str && size)
+  {
+    if(MSVCRT___mb_cur_max == 1)
+      return 1; /* ASCII CP */
+
+    return !MSVCRT_isleadbyte(*str) ? 1 : (size>1 ? 2 : -1);
+  }
+  return 0;
+}
+
+/*********************************************************************
+ *		_mbslen(MSVCRT.@)
+ */
+MSVCRT_size_t _mbslen(const unsigned char* str)
+{
+  if(MSVCRT___mb_cur_max > 1)
+  {
+    MSVCRT_size_t len = 0;
+    while(*str)
+    {
+      str += MSVCRT_isleadbyte(*str) ? 2 : 1;
+      len++;
+    }
+    return len;
+  }
+  return strlen(str); /* ASCII CP */
+}
+
+/*********************************************************************
+ *		_mbstrlen(MSVCRT.@)
+ */
+MSVCRT_size_t _mbstrlen(const char* str)
+{
+  if(MSVCRT___mb_cur_max > 1)
+  {
+    MSVCRT_size_t len = 0;
+    while(*str)
+    {
+      /* FIXME: According to the documentation we are supposed to test for 
+       * multi-byte character validity. Whatever that means
+       */
+      str += MSVCRT_isleadbyte(*str) ? 2 : 1;
+      len++;
+    }
+    return len;
+  }
+  return strlen(str); /* ASCII CP */
+}
+
+/*********************************************************************
+ *		_mbccpy(MSVCRT.@)
+ */
+void _mbccpy(unsigned char* dest, const unsigned char* src)
+{
+  *dest++ = *src;
+  if(MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(*src))
+    *dest = *++src; /* MB char */
+  else
+    ERR("failure.. is this ok?\n");
+}
+
+/*********************************************************************
+ *		_mbsncpy(MSVCRT.@)
+ */
+unsigned char* _mbsncpy(unsigned char* dst, const unsigned char* src, MSVCRT_size_t n)
+{
+  if(!n)
+    return dst;
+  if(MSVCRT___mb_cur_max > 1)
+  {
+    unsigned char* ret = dst;
+    while (*src && n--)
+    {
+      *dst++ = *src;
+      if (MSVCRT_isleadbyte(*src++))
+          *dst++ = *src++;
+    }
+    while(n--)
+      *dst++ = '\0';
+    return ret;
+  }
+  return strncpy(dst, src, n); /* ASCII CP */
+}
+
+/*********************************************************************
+ *              _mbsnbcpy(MSVCRT.@)
+ */
+unsigned char* _mbsnbcpy(unsigned char* dst, const unsigned char* src, MSVCRT_size_t n)
+{
+  if(!n)
+    return dst;
+  if(MSVCRT___mb_cur_max > 1)
+  {
+    unsigned char* ret = dst;
+    while (*src && (n-- > 1))
+    {
+      *dst++ = *src;
+      if (MSVCRT_isleadbyte(*src++))
+      {
+        *dst++ = *src++;
+        n--;
+      }
+    }
+    if (*src && n && !MSVCRT_isleadbyte(*src))
+    {
+      /* If the last character is a multi-byte character then 
+       * we cannot copy it since we have only one byte left
+       */
+      *dst++ = *src;
+      n--;
+    }
+    while (n--)
+      *dst++ = '\0';
+    return ret;
+  }
+  return strncpy(dst, src, n); /* ASCII CP */
+}
+
+/*********************************************************************
  *		_mbscmp(MSVCRT.@)
  */
-int _mbscmp(const char *str, const char *cmp)
+int _mbscmp(const unsigned char* str, const unsigned char* cmp)
 {
   if(MSVCRT___mb_cur_max > 1)
   {
@@ -72,29 +269,33 @@
 }
 
 /*********************************************************************
- *		_mbscspn(MSVCRT.@)
- */
-int _mbscspn(const char *str, const char *cmp)
-{
-   FIXME("don't handle double character case\n");
-   return strcspn(str, cmp);
-}
-
-/*********************************************************************
  *		_mbsicmp(MSVCRT.@)
  */
-int _mbsicmp(const char *str, const char *cmp)
+int _mbsicmp(const unsigned char* str, const unsigned char* cmp)
 {
-  /* FIXME: No tolower() for mb strings yet */
   if(MSVCRT___mb_cur_max > 1)
-    return _mbscmp(str, cmp);
+  {
+    unsigned int strc, cmpc;
+    do {
+      if(!*str)
+        return *cmp ? -1 : 0;
+      if(!*cmp)
+        return 1;
+      strc = _mbctolower(_mbsnextc(str));
+      cmpc = _mbctolower(_mbsnextc(cmp));
+      if(strc != cmpc)
+        return strc < cmpc ? -1 : 1;
+      str +=(strc > 255) ? 2 : 1;
+      cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
+    } while(1);
+  }
   return strcasecmp(str, cmp); /* ASCII CP */
 }
 
 /*********************************************************************
- *		_mbsncmp    (MSVCRT.@)
+ *		_mbsncmp(MSVCRT.@)
  */
-int _mbsncmp(const char *str, const char *cmp, unsigned int len)
+int _mbsncmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 {
   if(!len)
     return 0;
@@ -104,6 +305,7 @@
     unsigned int strc, cmpc;
     while(len--)
     {
+      int inc;
       if(!*str)
         return *cmp ? -1 : 0;
       if(!*cmp)
@@ -112,8 +314,9 @@
       cmpc = _mbsnextc(cmp);
       if(strc != cmpc)
         return strc < cmpc ? -1 : 1;
-      str +=(strc > 255) ? 2 : 1;
-      cmp +=(strc > 255) ? 2 : 1; /* Equal, use same increment */
+      inc=(strc > 255) ? 2 : 1; /* Equal, use same increment */
+      str += inc;
+      cmp += inc;
     }
     return 0; /* Matched len chars */
   }
@@ -121,76 +324,127 @@
 }
 
 /*********************************************************************
- *                  _mbsnicmp(MSVCRT.@)
- *
- * Compare two multibyte strings case insensitively to 'len' characters.
+ *              _mbsnbcmp(MSVCRT.@)
  */
-int _mbsnicmp(const char *str, const char *cmp, unsigned int len)
+int _mbsnbcmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 {
-  /* FIXME: No tolower() for mb strings yet */
+  if (!len)
+    return 0;
   if(MSVCRT___mb_cur_max > 1)
-    return _mbsncmp(str, cmp, len);
-  return strncasecmp(str, cmp, len); /* ASCII CP */
-}
-
-/*********************************************************************
- *		_mbsinc(MSVCRT.@)
- */
-char *_mbsinc(const unsigned char *str)
-{
-  if(MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(*str))
-    return (char *)str + 2; /* MB char */
-
-  return (char *)str + 1; /* ASCII CP or SB char */
+  {
+    unsigned int strc, cmpc;
+    while (len)
+    {
+      int clen;
+      if(!*str)
+        return *cmp ? -1 : 0;
+      if(!*cmp)
+        return 1;
+      if (MSVCRT_isleadbyte(*str))
+      {
+        strc=(len>=2)?_mbsnextc(str):0;
+        clen=2;
+      }
+      else
+      {
+        strc=*str;
+        clen=1;
+      }
+      if (MSVCRT_isleadbyte(*cmp))
+        cmpc=(len>=2)?_mbsnextc(cmp):0;
+      else
+        cmpc=*str;
+      if(strc != cmpc)
+        return strc < cmpc ? -1 : 1;
+      len -= clen;
+      str += clen;
+      cmp += clen;
+    }
+    return 0; /* Matched len chars */
+      FIXME("%s %s %d\n",str,cmp,len);
+  }
+  return strncmp(str,cmp,len);
 }
 
 /*********************************************************************
- *		_mbsninc(MSVCRT.@)
+ *		_mbsnicmp(MSVCRT.@)
+ *
+ * Compare two multibyte strings case insensitively to 'len' characters.
  */
-char *_mbsninc(const char *str, unsigned int num)
+int _mbsnicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
 {
-  if(!str || num < 1)
-    return NULL;
+  /* FIXME: No tolower() for mb strings yet */
   if(MSVCRT___mb_cur_max > 1)
   {
-    while(num--)
-      str = _mbsinc(str);
-    return (char *)str;
+    unsigned int strc, cmpc;
+    while(len--)
+    {
+      if(!*str)
+        return *cmp ? -1 : 0;
+      if(!*cmp)
+        return 1;
+      strc = _mbctolower(_mbsnextc(str));
+      cmpc = _mbctolower(_mbsnextc(cmp));
+      if(strc != cmpc)
+        return strc < cmpc ? -1 : 1;
+      str +=(strc > 255) ? 2 : 1;
+      cmp +=(strc > 255) ? 2 : 1; /* Equal, use same increment */
+    }
+    return 0; /* Matched len chars */
   }
-  return (char *)str + num; /* ASCII CP */
+  return strncasecmp(str, cmp, len); /* ASCII CP */
 }
 
 /*********************************************************************
- *		_mbslen(MSVCRT.@)
+ *		_mbschr(MSVCRT.@)
+ *
+ * Find a multibyte character in a multibyte string.
  */
-int _mbslen(const unsigned char *str)
+unsigned char* _mbschr(const unsigned char* s, unsigned int x)
 {
   if(MSVCRT___mb_cur_max > 1)
   {
-    int len = 0;
-    while(*str)
+    unsigned int c;
+    while (1)
     {
-      str += MSVCRT_isleadbyte(*str) ? 2 : 1;
-      len++;
+      c = _mbsnextc(s);
+      if (c == x)
+        return (unsigned char*)s;
+      if (!c)
+        return NULL;
+      s += c > 255 ? 2 : 1;
     }
-    return len;
   }
-  return strlen(str); /* ASCII CP */
+  return strchr(s, x); /* ASCII CP */
 }
 
 /*********************************************************************
  *		_mbsrchr(MSVCRT.@)
  */
-char *_mbsrchr(const char *s,unsigned int x)
+unsigned char* _mbsrchr(const unsigned char* s, unsigned int x)
 {
-  /* FIXME: handle multibyte strings */
+  if(MSVCRT___mb_cur_max > 1)
+  {
+    unsigned int c;
+    unsigned char* match=NULL;
+    if(!s)
+      return NULL;
+    while (1) {
+      c = _mbsnextc(s);
+      if (c == x)
+        match=(unsigned char*)s;
+      if (!c)
+        return match;
+      s +=(c > 255) ? 2 : 1;
+    }
+  }
   return strrchr(s,x);
 }
 
 /*********************************************************************
  *		mbtowc(MSVCRT.@)
  */
-int MSVCRT_mbtowc(WCHAR *dst, const char *str, unsigned int n)
+int MSVCRT_mbtowc(WCHAR *dst, const char* str, MSVCRT_size_t n)
 {
   if(n <= 0 || !str)
     return 0;
@@ -205,16 +459,6 @@
 }
 
 /*********************************************************************
- *		_mbccpy(MSVCRT.@)
- */
-void _mbccpy(char *dest, const unsigned char *src)
-{
-  *dest++ = *src;
-  if(MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(*src))
-    *dest = *++src; /* MB char */
-}
-
-/*********************************************************************
  *		_mbbtombc(MSVCRT.@)
  */
 unsigned int _mbbtombc(unsigned int c)
@@ -230,14 +474,6 @@
 }
 
 /*********************************************************************
- *		_mbclen(MSVCRT.@)
- */
-unsigned int _mbclen(const unsigned char *str)
-{
-  return MSVCRT_isleadbyte(*str) ? 2 : 1;
-}
-
-/*********************************************************************
  *		_ismbbkana(MSVCRT.@)
  */
 int _ismbbkana(unsigned int c)
@@ -252,6 +488,32 @@
 }
 
 /*********************************************************************
+ *              _ismbcdigit(MSVCRT.@)
+ */
+int _ismbcdigit(unsigned int ch)
+{
+  if (ch <0x100)
+    return isdigit(ch);
+  else
+    {
+      FIXME("Handle MBC chars\n");
+      return 0;
+    }
+}
+
+/*********************************************************************
+ *              _ismbcspace (MSVCRT.@)
+ */
+int _ismbcspace(unsigned int c)
+{
+
+  if (c<0x100)
+    return isspace(c);
+  FIXME("%c\n",c);
+  return 0;
+}
+
+/*********************************************************************
  *		_ismbchira(MSVCRT.@)
  */
 int _ismbchira(unsigned int c)
@@ -303,7 +565,7 @@
 /*********************************************************************
  *		_ismbslead(MSVCRT.@)
  */
-int _ismbslead(const unsigned char *start, const unsigned char *str)
+int _ismbslead(const unsigned char* start, const unsigned char* str)
 {
   /* Lead bytes can also be trail bytes if caller messed up
    * iterating through the string...
@@ -322,29 +584,18 @@
 /*********************************************************************
  *		_ismbstrail(MSVCRT.@)
  */
-int _ismbstrail(const char *start, const unsigned char *str)
+int _ismbstrail(const unsigned char* start, const unsigned char* str)
 {
   /* Must not be a lead, and must be preceeded by one */
   return !_ismbslead(start, str) && MSVCRT_isleadbyte(str[-1]);
 }
 
 /*********************************************************************
- *		_mbsdec(MSVCRT.@)
- */
-char *_mbsdec(const char *start, const char *cur)
-{
-  if(MSVCRT___mb_cur_max > 1)
-    return (char *)(_ismbstrail(start,cur-1) ? cur - 2 : cur -1);
-
-  return (char *)cur - 1; /* ASCII CP or SB char */
-}
-
-/*********************************************************************
  *		_mbsset(MSVCRT.@)
  */
-char *_mbsset(char *str, unsigned int c)
+unsigned char* _mbsset(unsigned char* str, unsigned int c)
 {
-  char *ret = str;
+  unsigned char* ret = str;
 
   if(MSVCRT___mb_cur_max == 1 || c < 256)
     return _strset(str, c); /* ASCII CP or SB char */
@@ -365,9 +616,9 @@
 /*********************************************************************
  *		_mbsnset(MSVCRT.@)
  */
-char *_mbsnset(char *str, unsigned int c, unsigned int len)
+unsigned char* _mbsnset(unsigned char* str, unsigned int c, MSVCRT_size_t len)
 {
-  char *ret = str;
+  unsigned char *ret = str;
 
   if(!len)
     return ret;
@@ -389,117 +640,52 @@
 }
 
 /*********************************************************************
- *		_mbstrlen(MSVCRT.@)
- */
-MSVCRT_size_t _mbstrlen(const char *str)
-{
-  if(MSVCRT___mb_cur_max > 1)
-  {
-    int len = 0;
-    while(*str)
-    {
-      str += MSVCRT_isleadbyte(*str) ? 2 : 1;
-      len++;
-    }
-    return len;
-  }
-  return strlen(str); /* ASCII CP */
-}
-
-/*********************************************************************
- *		_mbsncpy(MSVCRT.@)
- */
-char *_mbsncpy(char *dst, const char *src, unsigned int len)
-{
-  if(!len)
-    return dst;
-  if(MSVCRT___mb_cur_max > 1)
-  {
-    char *ret = dst;
-    while(src[0] && src[1] && len--)
-    {
-      *dst++ = *src++;
-      *dst++ = *src++;
-    }
-    if(len--)
-    {
-      *dst++ = *src++; /* Last char or '\0' */
-      while(len--)
-        *dst++ = '\0';
-    }
-    return ret;
-  }
-  return strncpy(dst, src, len); /* ASCII CP */
-}
-
-/*********************************************************************
- *		_mbschr(MSVCRT.@)
- *
- * Find a multibyte character in a multibyte string.
- */
-unsigned char* _mbschr(const unsigned char* str, unsigned int c)
-{
-  if(MSVCRT___mb_cur_max > 1)
-  {
-    unsigned int next;
-    while((next = _mbsnextc(str)))
-    {
-      if(next == c)
-        return (char *)str;
-      str += next > 255 ? 2 : 1;
-    }
-    return c ? NULL :(char *)str;
-  }
-  return strchr(str, c); /* ASCII CP */
-}
-
-/*********************************************************************
  *		_mbsnccnt(MSVCRT.@)
  * 'c' is for 'character'.
  */
-unsigned int _mbsnccnt(const unsigned char *str, unsigned int len)
+MSVCRT_size_t _mbsnccnt(const unsigned char* str, MSVCRT_size_t len)
 {
-  int ret = 0;
-
+  MSVCRT_size_t ret;
   if(MSVCRT___mb_cur_max > 1)
   {
+    ret=0;
     while(*str && len-- > 0)
     {
       if(MSVCRT_isleadbyte(*str))
       {
-        str++;
+        if (!len)
+          break;
         len--;
+        str++;
       }
-      ret++;
       str++;
+      ret++;
     }
     return ret;
   }
-  return min(strlen(str), len); /* ASCII CP */
+  ret=strlen(str);
+  return min(ret, len); /* ASCII CP */
 }
 
 /*********************************************************************
  *		_mbsnbcnt(MSVCRT.@)
  * 'b' is for byte count.
  */
-unsigned int _mbsnbcnt(const unsigned char *str, unsigned int len)
+MSVCRT_size_t _mbsnbcnt(const unsigned char* str, MSVCRT_size_t len)
 {
-  const unsigned char *xstr = str;
-
+  MSVCRT_size_t ret;
   if(MSVCRT___mb_cur_max > 1)
   {
+    const unsigned char* xstr = str;
     while(*xstr && len-- > 0)
     {
-      if(MSVCRT_isleadbyte(*xstr))
-      {
+      if (MSVCRT_isleadbyte(*xstr++))
         xstr++;
-        len--;
-      }
-      xstr++;
     }
     return xstr-str;
   }
-  return min(strlen(str), len); /* ASCII CP */
+  ret=strlen(str);
+  return min(ret, len); /* ASCII CP */
 }
 
 
@@ -511,16 +697,18 @@
   if(MSVCRT___mb_cur_max > 1)
   {
     char *res = dst;
-    dst += _mbslen(dst);
-    while(*src && len--)
+    while (*dst)
     {
-      *dst = *src;
-      if(MSVCRT_isleadbyte(*src))
-        *++dst = *++src;
-      dst++;
-      src++;
+      if (MSVCRT_isleadbyte(*dst++))
+        dst++;
     }
-    *dst++ = '\0';
+    while (*src && len--)
+    {
+      *dst++ = *src;
+      if(MSVCRT_isleadbyte(*src++))
+        *dst++ = *src++;
+    }
+    *dst = '\0';
     return res;
   }
   return strncat(dst, src, len); /* ASCII CP */
@@ -528,98 +716,65 @@
 
 
 /*********************************************************************
- *              _ismbcdigit(MSVCRT.@)
- */
-int _ismbcdigit( unsigned int ch)
-{
-  if (ch <0x100)
-    return isdigit(ch);
-  else
-    {
-      FIXME("Handle MBC chars\n");
-      return 0;
-    }
-}
-
-
-/*********************************************************************
- *              _mbsnbcmp(MSVCRT.@)
- */
-int _mbsnbcmp( const unsigned char *str,const unsigned char *cmp, MSVCRT_size_t len )
-{
-  if (!len)
-    return 0;
-  if(MSVCRT___mb_cur_max > 1)
-    {
-      FIXME("%s %s %d\n",str,cmp,len);
-      return 0;
-    }
-  return strncmp(str,cmp,len);
-}
-
-
-/*********************************************************************
  *              _mbslwr(MSVCRT.@)
  */
-unsigned char * _mbslwr(  unsigned char *string    )
+unsigned char* _mbslwr(unsigned char* s)
 {
-  unsigned char *p;
-
-  if(MSVCRT___mb_cur_max > 1)
-    {
-      FIXME("%s\n",string);
-      return string;
-    }
-  p = string;
-  while (*p)
-    {
-      *p= tolower(*p);
-      p++;
+  if (!s)
+    return NULL;
+  if (MSVCRT___mb_cur_max > 1)
+  {
+    unsigned int c;
+    unsigned char* p=s;
+    while (*s)
+    {
+      c = _mbctolower(_mbsnextc(s));
+      /* Note that I assume that the size of the character is unchanged */
+      if (c > 255)
+      {
+          *s++=(c>>8);
+          c=c & 0xff;
+      }
+      *s++=c;
     }
-  return string;
+    return p;
+  }
+  return _strlwr(s);
 }
 
 
 /*********************************************************************
  *              _mbsupr(MSVCRT.@)
  */
-unsigned char * _mbsupr( unsigned char *string )
+unsigned char* _mbsupr(unsigned char* s)
 {
-  unsigned char *p;
-
-  if(MSVCRT___mb_cur_max > 1)
-    {
-      FIXME("%s\n",string);
-      return string;
-    }
-  p = string;
-  while (*p)
-    {
-      *p= toupper(*p);
-      p++;
-    }
-  return string;
-}
-
-
-/*********************************************************************
- *              _mbsnbcpy(MSVCRT.@)
- */
-unsigned char * _mbsnbcpy(unsigned char *dest,const unsigned char *src,MSVCRT_size_t n)
-{
-  if(MSVCRT___mb_cur_max > 1)
-    {
-      FIXME("%s %d\n",src,n);
-      return dest;
+  if (!s)
+    return NULL;
+  if (MSVCRT___mb_cur_max > 1)
+  {
+    unsigned int c;
+    unsigned char* p=s;
+    while (*s)
+    {
+      c = _mbctoupper(_mbsnextc(s));
+      /* Note that I assume that the size of the character is unchanged */
+      if (c > 255)
+      {
+          *s++=(c>>8);
+          c=c & 0xff;
+      }
+      *s++=c;
     }
-  return strncpy(dest, src, n);
+    return p;
+  }
+  return _strupr(s);
 }
 
 
 /*********************************************************************
  *              _mbsspn (MSVCRT.@)
  */
-MSVCRT_size_t _mbsspn(const unsigned char *string, const unsigned char *set)
+MSVCRT_size_t _mbsspn(const unsigned char* string, const unsigned char* set)
 {
   const unsigned char *p, *q;
 
@@ -646,26 +801,23 @@
   return p - string;
 }
 
-
 /*********************************************************************
- *              _ismbcspace (MSVCRT.@)
+ *		_mbscspn(MSVCRT.@)
  */
-int _ismbcspace( unsigned int c)
+MSVCRT_size_t _mbscspn(const unsigned char* str, const unsigned char* cmp)
 {
-
-  if (c <0x100)
-    return isspace(c);
-  FIXME("%c\n",c);
-  return 0;
+  if (MSVCRT___mb_cur_max > 1)
+    FIXME("don't handle double character case\n");
+  return strcspn(str, cmp);
 }
 
 /*********************************************************************
  *              _mbsrev (MSVCRT.@)
  */
-char *_mbsrev(char *str)
+unsigned char* _mbsrev(unsigned char* str)
 {
     int i, len = _mbslen(str);
-    char *p, *temp=MSVCRT_malloc(len*2);
+    unsigned char *p, *temp=MSVCRT_malloc(len*2);
 
     if(!temp)
         return str;
@@ -709,9 +861,9 @@
 /*********************************************************************
  *		_mbspbrk (MSVCRT.@)
  */
-const char *_mbspbrk(const char *str, const char *accept)
+unsigned char* _mbspbrk(const unsigned char* str, const unsigned char* accept)
 {
-    const char *p;
+    const unsigned char* p;
 
     while(*str)
     {
@@ -719,7 +871,7 @@
         {
             if (*p == *str)
                 if( !MSVCRT_isleadbyte(*p) || ( *(p+1) == *(str+1) ) )
-                     return str;
+                     return (unsigned char*)str;
         }
         str += (MSVCRT_isleadbyte(*str)?2:1);
     }
Index: dlls/msvcrt/msvcrt.spec
===================================================================
RCS file: /home/wine/wine/dlls/msvcrt/msvcrt.spec,v
retrieving revision 1.25
diff -u -r1.25 msvcrt.spec
--- dlls/msvcrt/msvcrt.spec	2001/11/12 15:47:26	1.25
+++ dlls/msvcrt/msvcrt.spec	2001/12/05 00:49:54
@@ -347,9 +347,9 @@
 @ cdecl _mbclen(ptr) _mbclen
 @ stub _mbctohira #(long)
 @ stub _mbctokata #(long)
-@ stub _mbctolower #(long)
+@ cdecl _mbctolower(long) _mbctolower
 @ stub _mbctombb #(long)
-@ stub _mbctoupper #(long)
+@ cdecl _mbctoupper(long) _mbctoupper
 @ stub _mbctype
 @ stub _mbsbtype #(ptr long)
 @ cdecl _mbscat(str str) strcat
@@ -667,7 +667,7 @@
 @ cdecl log10(double) log10
 @ cdecl longjmp(long long) MSVCRT_longjmp
 @ cdecl malloc(long) MSVCRT_malloc
-@ stub mblen #(str long)
+@ cdecl mblen(ptr long) MSVCRT_mblen
 @ forward -noimport mbstowcs ntdll.mbstowcs
 @ cdecl mbtowc(wstr str long) MSVCRT_mbtowc
 @ cdecl memchr(ptr long long) memchr
@@ -683,8 +683,8 @@
 @ cdecl putc(long ptr) MSVCRT_putc
 @ cdecl putchar(long) MSVCRT_putchar
 @ cdecl puts(str) MSVCRT_puts
-@ stub putwc #(long ptr)
-@ stub putwchar #(long)
+@ cdecl putwc(long ptr) MSVCRT_fputwc
+@ cdecl putwchar(long) _fputwchar
 @ cdecl qsort(ptr long long ptr) qsort
 @ stub raise #(long)
 @ cdecl rand() MSVCRT_rand

[Index of Archives]     [Gimp for Windows]     [Red Hat]     [Samba]     [Yosemite Camping]     [Graphics Cards]     [Wine Home]

  Powered by Linux