2002-09-09 Jeff Johnston <jjohnstn@redhat.com>

        * libc/include/sys/_types.h (_mbstate_t): Changed to use
        unsigned char internally.
        * libc/sys/linux/sys/_types.h: Ditto.
        * libc/include/sys/reent.h
        * libc/stdlib/mblen.c (mblen): Use function-specific state
        value from default reentrancy structure.
        * libc/stdlib/mblen_r.c (_mblen_r):  If return code from
        _mbtowc_r is less than 0, reset state __count value and
        return -1.
        * libc/stdlib/mbrlen.c (mbrlen): If the input state pointer
        is NULL, use the function-specific pointer provided in the
        default reentrancy structure.
        * libc/stdlib/mbrtowc.c: Add reentrant form of function.
        If input state pointer is NULL, use function-specific area
        provided in reentrancy structure.
        * libc/stdlib/mbsrtowcs.c: Ditto.
        * libc/stdlib/wcrtomb.c: Ditto.
        * libc/stdlib/wcsrtombs.c: Ditto.
        * libc/stdlib/mbstowcs.c: Reformat.
        * libc/stdlib/wcstombs.c: Ditto.
        * libc/stdlib/mbstowcs_r.c (_mbstowcs_r): If an error occurs,
        reset the state's __count value and return -1.
        * libc/stdlib/mbtowc.c: Ditto.
        * libc/stdlib/mbtowc_r.c (_mbtowc_r): Add restartable functionality.
        If number of bytes is used up before completing a valid multibyte
        character, return -2 and save the state.
        * libc/stdlib/wctomb_r.c (_wctomb_r): Define __state as __count
        and change some __count references to __state for clarity.

diff --git a/newlib/ChangeLog b/newlib/ChangeLog
index 87f27ab..de3e80e 100644 (file)
--- a/newlib/ChangeLog
+++ b/newlib/ChangeLog
@@ -1,3 +1,34 @@
+2002-09-09  Jeff Johnston  <jjohnstn@redhat.com>
+
+        * libc/include/sys/_types.h (_mbstate_t): Changed to use
+        unsigned char internally.
+        * libc/sys/linux/sys/_types.h: Ditto.
+        * libc/include/sys/reent.h
+        * libc/stdlib/mblen.c (mblen): Use function-specific state
+        value from default reentrancy structure.
+        * libc/stdlib/mblen_r.c (_mblen_r):  If return code from
+        _mbtowc_r is less than 0, reset state __count value and
+        return -1.
+        * libc/stdlib/mbrlen.c (mbrlen): If the input state pointer
+        is NULL, use the function-specific pointer provided in the
+        default reentrancy structure.
+        * libc/stdlib/mbrtowc.c: Add reentrant form of function.
+        If input state pointer is NULL, use function-specific area
+        provided in reentrancy structure.
+        * libc/stdlib/mbsrtowcs.c: Ditto.
+        * libc/stdlib/wcrtomb.c: Ditto.
+        * libc/stdlib/wcsrtombs.c: Ditto.
+        * libc/stdlib/mbstowcs.c: Reformat.
+        * libc/stdlib/wcstombs.c: Ditto.
+        * libc/stdlib/mbstowcs_r.c (_mbstowcs_r): If an error occurs,
+        reset the state's __count value and return -1.
+        * libc/stdlib/mbtowc.c: Ditto.
+        * libc/stdlib/mbtowc_r.c (_mbtowc_r): Add restartable functionality.
+        If number of bytes is used up before completing a valid multibyte
+        character, return -2 and save the state.
+        * libc/stdlib/wctomb_r.c (_wctomb_r): Define __state as __count
+        and change some __count references to __state for clarity.
+
 2002-09-06  Jeff Johnston  <jjohnstn@redhat.com>
 
        * libc/include/sys/config.h (MB_LEN_MAX): Removed as this

diff --git a/newlib/libc/include/sys/_types.h b/newlib/libc/include/sys/_types.h
index c47a6ad..1265c46 100644 (file)
--- a/newlib/libc/include/sys/_types.h
+++ b/newlib/libc/include/sys/_types.h
@@ -30,7 +30,7 @@ typedef struct
   union
   {
     wint_t __wch;
-    char __wchb[4];
+    unsigned char __wchb[4];
   } __value;           /* Value so far.  */
 } _mbstate_t;
 #endif /* _MBSTATE_T */

diff --git a/newlib/libc/include/sys/reent.h b/newlib/libc/include/sys/reent.h
index 09160a9..20e1a01 100644 (file)
--- a/newlib/libc/include/sys/reent.h
+++ b/newlib/libc/include/sys/reent.h
@@ -321,6 +321,11 @@ struct _misc_reent
   _mbstate_t _mbtowc_state;
   char _l64a_buf[8];
   int _getdate_err;
+  _mbstate_t _mbrlen_state;
+  _mbstate_t _mbrtowc_state;
+  _mbstate_t _mbsrtowcs_state;
+  _mbstate_t _wcrtomb_state;
+  _mbstate_t _wcsrtombs_state;
 };
 
 /* This version of _reent is layed our with "int"s in pairs, to help
@@ -478,6 +483,16 @@ struct _reent
   _r->_misc->_wctomb_state.__value.__wch = 0; \
   _r->_misc->_mbtowc_state.__count = 0; \
   _r->_misc->_mbtowc_state.__value.__wch = 0; \
+  _r->_misc->_mbrlen_state.__count = 0; \
+  _r->_misc->_mbrlen_state.__value.__wch = 0; \
+  _r->_misc->_mbrtowc_state.__count = 0; \
+  _r->_misc->_mbrtowc_state.__value.__wch = 0; \
+  _r->_misc->_mbsrtowcs_state.__count = 0; \
+  _r->_misc->_mbsrtowcs_state.__value.__wch = 0; \
+  _r->_misc->_wcrtomb_state.__count = 0; \
+  _r->_misc->_wcrtomb_state.__value.__wch = 0; \
+  _r->_misc->_wcsrtombs_state.__count = 0; \
+  _r->_misc->_wcsrtombs_state.__value.__wch = 0; \
   _r->_misc->_l64a_buf[0] = '\0'; \
   _r->_misc->_getdate_err = 0; \
 } while (0)
@@ -503,6 +518,11 @@ struct _reent
 #define _REENT_MBLEN_STATE(ptr)        ((ptr)->_misc->_mblen_state)
 #define _REENT_MBTOWC_STATE(ptr)((ptr)->_misc->_mbtowc_state)
 #define _REENT_WCTOMB_STATE(ptr)((ptr)->_misc->_wctomb_state)
+#define _REENT_MBRLEN_STATE(ptr) ((ptr)->_misc->_mbrlen_state)
+#define _REENT_MBRTOWC_STATE(ptr) ((ptr)->_misc->_mbrtowc_state)
+#define _REENT_MBSRTOWCS_STATE(ptr) ((ptr)->_misc->_mbsrtowcs_state)
+#define _REENT_WCRTOMB_STATE(ptr) ((ptr)->_misc->_wcrtomb_state)
+#define _REENT_WCSRTOMBS_STATE(ptr) ((ptr)->_misc->_wcsrtombs_state)
 #define _REENT_L64A_BUF(ptr)    ((ptr)->_misc->_l64a_buf)
 #define _REENT_GETDATE_ERR_P(ptr) (&((ptr)->_misc->_getdate_err))
 #define _REENT_SIGNAL_BUF(ptr)  ((ptr)->_signal_buf)
@@ -555,6 +575,11 @@ struct _reent
           char _l64a_buf[8];
           char _signal_buf[_REENT_SIGNAL_SIZE];
           int _getdate_err;  
+          _mbstate_t _mbrlen_state;
+          _mbstate_t _mbrtowc_state;
+          _mbstate_t _mbsrtowcs_state;
+          _mbstate_t _wcrtomb_state;
+          _mbstate_t _wcsrtombs_state;
         } _reent;
   /* Two next two fields were once used by malloc.  They are no longer
      used. They are used to preserve the space used before so as to
@@ -587,7 +612,7 @@ struct _reent
     { 0,0,0,0,0,0,0,0}, 0, 1, \
     {{_RAND48_SEED_0, _RAND48_SEED_1, _RAND48_SEED_2}, \
      {_RAND48_MULT_0, _RAND48_MULT_1, _RAND48_MULT_2}, _RAND48_ADD}, \
-    {0, {0}}, {0, {0}}, {0, {0}}, "", "", 0} } }
+    {0, {0}}, {0, {0}}, {0, {0}}, "", "", 0, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}} } } }
 
 #define _REENT_INIT_PTR(var) \
   { int i; \
@@ -630,6 +655,16 @@ struct _reent
     var->_new._reent._mbtowc_state.__value.__wch = 0; \
     var->_new._reent._wctomb_state.__count = 0; \
     var->_new._reent._wctomb_state.__value.__wch = 0; \
+    var->_new._reent._mbrlen_state.__count = 0; \
+    var->_new._reent._mbrlen_state.__value.__wch = 0; \
+    var->_new._reent._mbrtowc_state.__count = 0; \
+    var->_new._reent._mbrtowc_state.__value.__wch = 0; \
+    var->_new._reent._mbsrtowcs_state.__count = 0; \
+    var->_new._reent._mbsrtowcs_state.__value.__wch = 0; \
+    var->_new._reent._wcrtomb_state.__count = 0; \
+    var->_new._reent._wcrtomb_state.__value.__wch = 0; \
+    var->_new._reent._wcsrtombs_state.__count = 0; \
+    var->_new._reent._wcsrtombs_state.__value.__wch = 0; \
     var->_new._reent._l64a_buf[0] = '\0'; \
     var->_new._reent._signal_buf[0] = '\0'; \
     var->_new._reent._getdate_err = 0; \
@@ -668,6 +703,11 @@ struct _reent
 #define _REENT_MBLEN_STATE(ptr)        ((ptr)->_new._reent._mblen_state)
 #define _REENT_MBTOWC_STATE(ptr)((ptr)->_new._reent._mbtowc_state)
 #define _REENT_WCTOMB_STATE(ptr)((ptr)->_new._reent._wctomb_state)
+#define _REENT_MBRLEN_STATE(ptr)((ptr)->_new._reent._mbrlen_state)
+#define _REENT_MBRTOWC_STATE(ptr)((ptr)->_new._reent._mbrtowc_state)
+#define _REENT_MBSRTOWCS_STATE(ptr)((ptr)->_new._reent._mbsrtowcs_state)
+#define _REENT_WCRTOMB_STATE(ptr)((ptr)->_new._reent._wcrtomb_state)
+#define _REENT_WCSRTOMBS_STATE(ptr)((ptr)->_new._reent._wcsrtombs_state)
 #define _REENT_L64A_BUF(ptr)    ((ptr)->_new._reent._l64a_buf)
 #define _REENT_SIGNAL_BUF(ptr)  ((ptr)->_new._reent._signal_buf)
 #define _REENT_GETDATE_ERR_P(ptr) (&((ptr)->_new._reent._getdate_err))

diff --git a/newlib/libc/stdlib/mblen.c b/newlib/libc/stdlib/mblen.c
index a0ed29a..b131095 100644 (file)
--- a/newlib/libc/stdlib/mblen.c
+++ b/newlib/libc/stdlib/mblen.c
@@ -52,21 +52,26 @@ _DEFUN (mblen, (s, n),
         size_t n)
 {
 #ifdef MB_CAPABLE
-        int retval = 0;
-        _REENT_CHECK_MISC(_REENT);
-
-        retval = _mbtowc_r (_REENT, NULL, s, n, &(_REENT_MBLEN_STATE(_REENT)));
-        if (retval < 0)
-          return -1;
-        else
-          return retval;
-
+  int retval = 0;
+  mbstate_t *state;
+  
+  _REENT_CHECK_MISC(_REENT);
+  state = &(_REENT_MBLEN_STATE(_REENT));
+  retval = _mbtowc_r (_REENT, NULL, s, n, state);
+  if (retval < 0)
+    {
+      state->__count = 0;
+      return -1;
+    }
+  else
+    return retval;
+  
 #else /* not MB_CAPABLE */
-        if (s == NULL || *s == '\0')
-                return 0;
-        if (n == 0)
-                return -1;
-        return 1;
+  if (s == NULL || *s == '\0')
+    return 0;
+  if (n == 0)
+    return -1;
+  return 1;
 #endif /* not MB_CAPABLE */
 }
 

diff --git a/newlib/libc/stdlib/mblen_r.c b/newlib/libc/stdlib/mblen_r.c
index cff7395..1d66597 100644 (file)
--- a/newlib/libc/stdlib/mblen_r.c
+++ b/newlib/libc/stdlib/mblen_r.c
@@ -54,14 +54,22 @@ _DEFUN (_mblen_r, (r, s, n, state),
         mbstate_t *state)
 {
 #ifdef MB_CAPABLE
+  int retval;
+  retval = _mbtowc_r (r, NULL, s, n, state);
 
-        return _mbtowc_r (r, NULL, s, n, state);
+  if (retval < 0)
+    {
+      state->__count = 0;
+      return -1;
+    }
+
+  return retval;
 #else /* not MB_CAPABLE */
-        if (s == NULL || *s == '\0')
-                return 0;
-        if (n == 0)
-                return -1;
-        return 1;
+  if (s == NULL || *s == '\0')
+    return 0;
+  if (n == 0)
+    return -1;
+  return 1;
 #endif /* not MB_CAPABLE */
 }
 

diff --git a/newlib/libc/stdlib/mbrlen.c b/newlib/libc/stdlib/mbrlen.c
index 8f0c648..504348d 100644 (file)
--- a/newlib/libc/stdlib/mbrlen.c
+++ b/newlib/libc/stdlib/mbrlen.c
@@ -7,7 +7,13 @@
 size_t
 mbrlen(const char *s, size_t n, mbstate_t *ps)
 {
-  mbstate_t internal;
+#ifdef MB_CAPABLE
+  if (ps == NULL)
+    {
+      _REENT_CHECK_MISC(_REENT);
+      ps = &(_REENT_MBRLEN_STATE(_REENT));
+    }
+#endif
 
-  return mbrtowc(NULL, s, n, ps != NULL ? ps : &internal);
+  return mbrtowc(NULL, s, n, ps);
 }

diff --git a/newlib/libc/stdlib/mbrtowc.c b/newlib/libc/stdlib/mbrtowc.c
index 7934ca1..0db1208 100644 (file)
--- a/newlib/libc/stdlib/mbrtowc.c
+++ b/newlib/libc/stdlib/mbrtowc.c
@@ -6,24 +6,46 @@
 #include <string.h>
 
 size_t
-mbrtowc(wchar_t *pwc, const char *s, size_t n, mbstate_t *ps)
+_DEFUN (_mbrtowc_r, (ptr, pwc, s, n, ps),
+       struct _reent *ptr _AND
+       wchar_t *pwc _AND
+       const char *s _AND
+       size_t n _AND
+       mbstate_t *ps)
 {
   int retval = 0;
-  _REENT_CHECK_MISC(_REENT);
+
+#ifdef MB_CAPABLE
+  if (ps == NULL)
+    {
+      _REENT_CHECK_MISC(ptr);
+      ps = &(_REENT_MBRTOWC_STATE(ptr));
+    }
+#endif
 
   if (s == NULL)
-    retval = _mbtowc_r (_REENT, pwc, "", 1, ps);
+    retval = _mbtowc_r (ptr, pwc, "", 1, ps);
   else
-    retval = _mbtowc_r (_REENT, pwc, s, n, ps);
-
-  if (*pwc == NULL)
-    memset (ps, '\0', sizeof (mbstate_t));
+    retval = _mbtowc_r (ptr, pwc, s, n, ps);
 
   if (retval == -1)
     {
-      _REENT->_errno = EILSEQ;
+      ps->__count = 0;
+      ptr->_errno = EILSEQ;
       return (size_t)(-1);
     }
   else
     return (size_t)retval;
 }
+
+#ifndef _REENT_ONLY
+size_t
+_DEFUN (mbrtowc, (pwc, s, n, ps),
+       wchar_t *pwc _AND
+       const char *s _AND
+       size_t n _AND
+       mbstate_t *ps)
+{
+  return _mbrtowc_r (_REENT, pwc, s, n, ps);
+}
+#endif /* !_REENT_ONLY */

diff --git a/newlib/libc/stdlib/mbsrtowcs.c b/newlib/libc/stdlib/mbsrtowcs.c
index 256ab0d..08d9d0c 100644 (file)
--- a/newlib/libc/stdlib/mbsrtowcs.c
+++ b/newlib/libc/stdlib/mbsrtowcs.c
@@ -5,20 +5,62 @@
 #include <errno.h>
 
 size_t
-mbsrtowcs(wchar_t *dst, const char **src, size_t len, mbstate_t *ps)
+_DEFUN (_mbsrtowcs_r, (r, dst, src, n, ps), 
+       struct _reent *r _AND
+       wchar_t *dst _AND
+       const char **src _AND
+       size_t n _AND
+       mbstate_t *ps)
 {
-  int retval = 0;
-  mbstate_t internal;
+  wchar_t *ptr = dst;
+  size_t max = n;
+  int bytes;
 
-  _REENT_CHECK_MISC(_REENT);
-
-  retval = _mbstowcs_r (_REENT, dst, *src, len, ps != NULL ? ps : &internal);
+#ifdef MB_CAPABLE
+  if (ps == NULL)
+    {
+      _REENT_CHECK_MISC(r);
+      ps = &(_REENT_MBSRTOWCS_STATE(r));
+    }
+#endif
 
-  if (retval == -1)
+  while (n > 0)
     {
-      _REENT->_errno = EILSEQ;
-      return (size_t)(-1);
+      bytes = _mbtowc_r (r, ptr, *src, MB_CUR_MAX, ps);
+      if (bytes > 0)
+       {
+         *src += bytes;
+         ++ptr;
+         --n;
+       }
+      else if (bytes == -2)
+       {
+         *src += MB_CUR_MAX;
+       }
+      else if (bytes == 0)
+       {
+         *src = NULL;
+         return (size_t)(ptr - dst);
+       }
+      else
+       {
+         ps->__count = 0;
+         r->_errno = EILSEQ;
+         return (size_t)-1;
+       }
     }
-  else
-    return (size_t)retval;
+
+  return (size_t)max;
+}
+
+#ifndef _REENT_ONLY
+size_t
+_DEFUN (mbsrtowcs, (dst, src, len, ps),
+       wchar_t *dst _AND
+       const char **src _AND
+       size_t len _AND
+       mbstate_t *ps)
+{
+  return _mbsrtowcs_r (_REENT, dst, src, len, ps);
 }
+#endif /* !_REENT_ONLY */

diff --git a/newlib/libc/stdlib/mbstowcs.c b/newlib/libc/stdlib/mbstowcs.c
index eb0ccd7..cb09f31 100644 (file)
--- a/newlib/libc/stdlib/mbstowcs.c
+++ b/newlib/libc/stdlib/mbstowcs.c
@@ -59,23 +59,23 @@ _DEFUN (mbstowcs, (pwcs, s, n),
         size_t n)
 {
 #ifdef MB_CAPABLE
-        mbstate_t state;
-        state.__count = 0;
-
-        return _mbstowcs_r (_REENT, pwcs, s, n, &state);
+  mbstate_t state;
+  state.__count = 0;
+  
+  return _mbstowcs_r (_REENT, pwcs, s, n, &state);
 #else /* not MB_CAPABLE */
-
-        int count = 0;
-
-        if (n != 0) {
-                do {
-                        if ((*pwcs++ = (wchar_t) *s++) == 0)
-                                break;
-                        count++;
-                } while (--n != 0);
-        }
-
-        return count;
+  
+  int count = 0;
+  
+  if (n != 0) {
+    do {
+      if ((*pwcs++ = (wchar_t) *s++) == 0)
+       break;
+      count++;
+    } while (--n != 0);
+  }
+  
+  return count;
 #endif /* not MB_CAPABLE */
 }
 

diff --git a/newlib/libc/stdlib/mbstowcs_r.c b/newlib/libc/stdlib/mbstowcs_r.c
index 89cda03..c6130b2 100644 (file)
--- a/newlib/libc/stdlib/mbstowcs_r.c
+++ b/newlib/libc/stdlib/mbstowcs_r.c
@@ -18,7 +18,10 @@ _DEFUN (_mbstowcs_r, (reent, pwcs, s, n, state),
     {
       bytes = _mbtowc_r (r, ptr, t, MB_CUR_MAX, state);
       if (bytes < 0)
-        return -1;
+       {
+         state->__count = 0;
+         return -1;
+       }
       else if (bytes == 0)
         return ptr - pwcs;
       t += bytes;

diff --git a/newlib/libc/stdlib/mbtowc.c b/newlib/libc/stdlib/mbtowc.c
index 6da735a..e1e725d 100644 (file)
--- a/newlib/libc/stdlib/mbtowc.c
+++ b/newlib/libc/stdlib/mbtowc.c
@@ -52,6 +52,7 @@ effects vary with the locale.
 #ifndef _REENT_ONLY
 
 #include <stdlib.h>
+#include <wchar.h>
 
 int
 _DEFUN (mbtowc, (pwc, s, n),
@@ -60,23 +61,28 @@ _DEFUN (mbtowc, (pwc, s, n),
         size_t n)
 {
 #ifdef MB_CAPABLE
-        int retval = 0;
-        _REENT_CHECK_MISC(_REENT);
-
-        retval = _mbtowc_r (_REENT, pwc, s, n, &(_REENT_MBTOWC_STATE(_REENT)));
-
-        if (retval < 0)
-          return -1;
-        else
-          return retval;
+  int retval = 0;
+  mbstate_t *ps;
+
+  _REENT_CHECK_MISC(_REENT);
+  ps = &(_REENT_MBTOWC_STATE(_REENT));
+  
+  retval = _mbtowc_r (_REENT, pwc, s, n, ps);
+  
+  if (retval < 0)
+    {
+      ps->__count = 0;
+      return -1;
+    }
+  return retval;
 #else /* not MB_CAPABLE */
-        if (s == NULL)
-                return 0;
-        if (n == 0)
-                return -1;
-        if (pwc)
-                *pwc = (wchar_t) *s;
-        return (*s != '\0');
+  if (s == NULL)
+    return 0;
+  if (n == 0)
+    return -1;
+  if (pwc)
+    *pwc = (wchar_t) *s;
+  return (*s != '\0');
 #endif /* not MB_CAPABLE */
 }
 

diff --git a/newlib/libc/stdlib/mbtowc_r.c b/newlib/libc/stdlib/mbtowc_r.c
index b7909d3..26141b4 100644 (file)
--- a/newlib/libc/stdlib/mbtowc_r.c
+++ b/newlib/libc/stdlib/mbtowc_r.c
@@ -7,9 +7,9 @@
 #ifdef MB_CAPABLE
 typedef enum { ESCAPE, DOLLAR, BRACKET, AT, B, J, 
                NUL, JIS_CHAR, OTHER, JIS_C_NUM } JIS_CHAR_TYPE;
-typedef enum { ASCII, A_ESC, A_ESC_DL, JIS, JIS_1, JIS_2, J_ESC, J_ESC_BR,
-               J2_ESC, J2_ESC_BR, DONE, INV, JIS_S_NUM } JIS_STATE; 
-typedef enum { COPY_A, COPY_J, COPY_J2, MAKE_A, MAKE_J, NOOP, EMPTY, ERROR } JIS_ACTION;
+typedef enum { ASCII, JIS, A_ESC, A_ESC_DL, JIS_1, J_ESC, J_ESC_BR,
+               INV, JIS_S_NUM } JIS_STATE; 
+typedef enum { COPY_A, COPY_J1, COPY_J2, MAKE_A, NOOP, EMPTY, ERROR } JIS_ACTION;
 
 /************************************************************************************** 
  * state/action tables for processing JIS encoding
@@ -20,33 +20,30 @@ typedef enum { COPY_A, COPY_J, COPY_J2, MAKE_A, MAKE_J, NOOP, EMPTY, ERROR } JIS
 
 static JIS_STATE JIS_state_table[JIS_S_NUM][JIS_C_NUM] = {
 /*              ESCAPE   DOLLAR    BRACKET   AT       B       J        NUL      JIS_CHAR  OTHER */
-/* ASCII */   { A_ESC,   DONE,     DONE,     DONE,    DONE,   DONE,    DONE,    DONE,     DONE },
-/* A_ESC */   { DONE,    A_ESC_DL, DONE,     DONE,    DONE,   DONE,    DONE,    DONE,     DONE },
-/* A_ESC_DL */{ DONE,    DONE,     DONE,     JIS,     JIS,    DONE,    DONE,    DONE,     DONE }, 
+/* ASCII */   { A_ESC,   ASCII,    ASCII,    ASCII,   ASCII,  ASCII,   ASCII,   ASCII,    ASCII },
 /* JIS */     { J_ESC,   JIS_1,    JIS_1,    JIS_1,   JIS_1,  JIS_1,   INV,     JIS_1,    INV },
-/* JIS_1 */   { INV,     JIS_2,    JIS_2,    JIS_2,   JIS_2,  JIS_2,   INV,     JIS_2,    INV },
-/* JIS_2 */   { J2_ESC,  DONE,     DONE,     DONE,    DONE,   DONE,    INV,     DONE,     DONE },
+/* A_ESC */   { ASCII,   A_ESC_DL, ASCII,    ASCII,   ASCII,  ASCII,   ASCII,   ASCII,    ASCII },
+/* A_ESC_DL */{ ASCII,   ASCII,    ASCII,    JIS,     JIS,    ASCII,   ASCII,   ASCII,    ASCII }, 
+/* JIS_1 */   { INV,     JIS,      JIS,      JIS,     JIS,    JIS,     INV,     JIS,      INV },
 /* J_ESC */   { INV,     INV,      J_ESC_BR, INV,     INV,    INV,     INV,     INV,      INV },
 /* J_ESC_BR */{ INV,     INV,      INV,      INV,     ASCII,  ASCII,   INV,     INV,      INV },
-/* J2_ESC */  { INV,     INV,      J2_ESC_BR,INV,     INV,    INV,     INV,     INV,      INV },
-/* J2_ESC_BR*/{ INV,     INV,      INV,      INV,     DONE,   DONE,    INV,     INV,      INV },
 };
 
 static JIS_ACTION JIS_action_table[JIS_S_NUM][JIS_C_NUM] = {
 /*              ESCAPE   DOLLAR    BRACKET   AT       B        J        NUL      JIS_CHAR  OTHER */
 /* ASCII */   { NOOP,    COPY_A,   COPY_A,   COPY_A,  COPY_A,  COPY_A,  EMPTY,   COPY_A,  COPY_A},
+/* JIS */     { NOOP,    COPY_J1,  COPY_J1,  COPY_J1, COPY_J1, COPY_J1, ERROR,   COPY_J1, ERROR },
 /* A_ESC */   { COPY_A,  NOOP,     COPY_A,   COPY_A,  COPY_A,  COPY_A,  COPY_A,  COPY_A,  COPY_A},
-/* A_ESC_DL */{ COPY_A,  COPY_A,   COPY_A,   MAKE_J,  MAKE_J,  COPY_A,  COPY_A,  COPY_A,  COPY_A},
-/* JIS */     { NOOP,    NOOP,     NOOP,     NOOP,    NOOP,    NOOP,    ERROR,   NOOP,    ERROR },
-/* JIS_1 */   { ERROR,   NOOP,     NOOP,     NOOP,    NOOP,    NOOP,    ERROR,   NOOP,    ERROR },
-/* JIS_2 */   { NOOP,    COPY_J2,  COPY_J2,  COPY_J2, COPY_J2, COPY_J2, ERROR,   COPY_J2, COPY_J2},
+/* A_ESC_DL */{ COPY_A,  COPY_A,   COPY_A,   NOOP,    NOOP,    COPY_A,  COPY_A,  COPY_A,  COPY_A},
+/* JIS_1 */   { ERROR,   COPY_J2,  COPY_J2,  COPY_J2, COPY_J2, COPY_J2, ERROR,   COPY_J2, ERROR },
 /* J_ESC */   { ERROR,   ERROR,    NOOP,     ERROR,   ERROR,   ERROR,   ERROR,   ERROR,   ERROR },
-/* J_ESC_BR */{ ERROR,   ERROR,    ERROR,    ERROR,   NOOP,    NOOP,    ERROR,   ERROR,   ERROR },
-/* J2_ESC */  { ERROR,   ERROR,    NOOP,     ERROR,   ERROR,   ERROR,   ERROR,   ERROR,   ERROR },
-/* J2_ESC_BR*/{ ERROR,   ERROR,    ERROR,    ERROR,   COPY_J,  COPY_J,  ERROR,   ERROR,   ERROR },
+/* J_ESC_BR */{ ERROR,   ERROR,    ERROR,    ERROR,   MAKE_A,  MAKE_A,  ERROR,   ERROR,   ERROR },
 };
 #endif /* MB_CAPABLE */
 
+/* we override the mbstate_t __count field for more complex encodings and use it store a state value */
+#define __state __count
+
 int
 _DEFUN (_mbtowc_r, (r, pwc, s, n, state),
         struct _reent *r   _AND
@@ -70,230 +67,305 @@ _DEFUN (_mbtowc_r, (r, pwc, s, n, state),
     { /* fall-through */ }
   else if (!strcmp (r->_current_locale, "C-UTF-8"))
     {
-      wchar_t char1 = 0;
+      int ch;
+      int i = 0;
 
       if (s == NULL)
         return 0; /* UTF-8 character encodings are not state-dependent */
 
-      /* we know n >= 1 if we get here */
-      *pwc = 0;
-      char1 = (wchar_t)*t;
-
-      if (char1 == '\0')
-        return 0; /* s points to the null character */
-
-      if (char1 >= 0x0 && char1 <= 0x7f)
-        {
-          /* single-byte sequence */
-          *pwc = char1;
-          return 1;
-        }
-      else if (char1 >= 0xc0 && char1 <= 0xdf)
-        {
-          /* two-byte sequence */
-          if (n >= 2)
-            {
-              wchar_t char2 = (wchar_t)*(t+1);
-
-              if (char2 < 0x80 || char2 > 0xbf)
-                return -1;
-
-              if (char1 < 0xc2)
-                /* overlong UTF-8 sequence */
-                return -1;
-
-              *pwc = ((char1 & 0x1f) << 6)
-                |     (char2 & 0x3f);
-              return 2;
-            }
-          else
-            return -1;
-        }
-      else if (char1 >= 0xe0 && char1 <= 0xef)
-        {
-          /* three-byte sequence */
-          if (n >= 3)
-            {
-              wchar_t char2 = (wchar_t)*(t+1);
-              wchar_t char3 = (wchar_t)*(t+2);
-
-              if (char2 < 0x80 || char2 > 0xbf)
-                return -1;
-              if (char3 < 0x80 || char3 > 0xbf)
-                return -1;
-
-              if (char1 == 0xe0)
-                {
-                  if (char2 < 0xa0)
-                    /* overlong UTF-8 sequence */
-                    return -1;
-                }
-
-              *pwc = ((char1 & 0x0f) << 12)
-                |    ((char2 & 0x3f) << 6)
-                |     (char3 & 0x3f);
-
-              if (*pwc >= 0xd800 && *pwc <= 0xdfff)
-                {
-                  return -1;
-                }
-              else
-                return 3;
-            }
-          else
-            return -2;
-        }
-      else if (char1 >= 0xf0 && char1 <= 0xf7)
-        {
-          /* four-byte sequence */
-          if (n >= 4)
-            {
-              wchar_t char2 = (wchar_t)*(t+1);
-              wchar_t char3 = (wchar_t)*(t+2);
-              wchar_t char4 = (wchar_t)*(t+3);
-
-              if (char2 < 0x80 || char2 > 0xbf)
-                return -1;
-              if (char3 < 0x80 || char3 > 0xbf)
-                return -1;
-              if (char4 < 0x80 || char4 > 0xbf)
-                return -1;
-
-              if (char1 == 0xf0)
-                {
-                  if (char2 < 0x90)
-                    /* overlong UTF-8 sequence */
-                    return -1;
-                }
-                    
-              *pwc = ((char1 & 0x07) << 18)
-                |    ((char2 & 0x3f) << 12)
-                |    ((char3 & 0x3f) << 6)
-                |     (char4 & 0x3f);
-
-              return 4;
-            }
-          else
-            return -2;
-        }
-      else if (char1 >= 0xf8 && char1 <= 0xfb)
-        {
-          /* five-byte sequence */
-          if (n >= 5)
-            {
-              wchar_t char2 = (wchar_t)*(t+1);
-              wchar_t char3 = (wchar_t)*(t+2);
-              wchar_t char4 = (wchar_t)*(t+3);
-              wchar_t char5 = (wchar_t)*(t+4);
-
-              if (char2 < 0x80 || char2 > 0xbf)
-                return -1;
-              if (char3 < 0x80 || char3 > 0xbf)
-                return -1;
-              if (char4 < 0x80 || char4 > 0xbf)
-                return -1;
-              if (char5 < 0x80 || char5 > 0xbf)
-                return -1;
-
-              if (char1 == 0xf8)
-                {
-                  if (char2 < 0x88)
-                    /* overlong UTF-8 sequence */
-                    return -1;
-                }
-                    
-              *pwc = ((char1 & 0x03) << 24)
-                |    ((char2 & 0x3f) << 18)
-                |    ((char3 & 0x3f) << 12)
-                |    ((char4 & 0x3f) << 6)
-                |     (char5 & 0x3f);
-              return 5;
-            }
-          else
-            return -2;
-        }
-      else if (char1 >= 0xfc && char1 <= 0xfd)
+      if (state->__count == 0)
+       ch = t[i++];
+      else
+       {
+         ++n;
+         ch = state->__value.__wchb[0];
+       }
+
+      if (ch == '\0')
+       {
+         *pwc = 0;
+         state->__count = 0;
+         return 0; /* s points to the null character */
+       }
+
+      if (ch >= 0x0 && ch <= 0x7f)
+       {
+         /* single-byte sequence */
+         state->__count = 0;
+         *pwc = ch;
+         return 1;
+       }
+      else if (ch >= 0xc0 && ch <= 0xdf)
+       {
+         /* two-byte sequence */
+         state->__value.__wchb[0] = ch;
+         state->__count = 1;
+         if (n < 2)
+           return -2;
+         ch = t[i++];
+         if (ch < 0x80 || ch > 0xbf)
+           return -1;
+         if (state->__value.__wchb[0] < 0xc2)
+           /* overlong UTF-8 sequence */
+           return -1;
+         state->__count = 0;
+         *pwc = (wchar_t)((state->__value.__wchb[0] & 0x1f) << 6)
+           |    (wchar_t)(ch & 0x3f);
+         return i;
+       }
+      else if (ch >= 0xe0 && ch <= 0xef)
+       {
+         /* three-byte sequence */
+         wchar_t tmp;
+         state->__value.__wchb[0] = ch;
+         if (state->__count == 0)
+           state->__count = 1;
+         else
+           ++n;
+         if (n < 2)
+           return -2;
+         ch = (state->__count == 1) ? t[i++] : state->__value.__wchb[1];
+         if (state->__value.__wchb[0] == 0xe0 && ch < 0xa0)
+           /* overlong UTF-8 sequence */
+           return -1;
+         if (ch < 0x80 || ch > 0xbf)
+           return -1;
+         state->__value.__wchb[1] = ch;
+         state->__count = 2;
+         if (n < 3)
+           return -2;
+         ch = t[i++];
+         if (ch < 0x80 || ch > 0xbf)
+           return -1;
+         state->__count = 0;
+         tmp = (wchar_t)((state->__value.__wchb[0] & 0x0f) << 12)
+           |    (wchar_t)((state->__value.__wchb[1] & 0x3f) << 6)
+           |     (wchar_t)(ch & 0x3f);
+       
+         if (tmp >= 0xd800 && tmp <= 0xdfff)
+           return -1;
+         *pwc = tmp;
+         return i;
+       }
+      else if (ch >= 0xf0 && ch <= 0xf7)
+       {
+         /* four-byte sequence */
+         if (sizeof(wchar_t) < 4)
+           return -1; /* we can't store such a value */
+         state->__value.__wchb[0] = ch;
+         if (state->__count == 0)
+           state->__count = 1;
+         else
+           ++n;
+         if (n < 2)
+           return -2;
+         ch = (state->__count == 1) ? t[i++] : state->__value.__wchb[1];
+         if (state->__value.__wchb[0] == 0xf0 && ch < 0x90)
+           /* overlong UTF-8 sequence */
+           return -1;
+         if (ch < 0x80 || ch > 0xbf)
+           return -1;
+         state->__value.__wchb[1] = ch;
+         if (state->__count == 1)
+           state->__count = 2;
+         else
+           ++n;
+         if (n < 3)
+           return -2;
+         ch = (state->__count == 2) ? t[i++] : state->__value.__wchb[2];
+         if (ch < 0x80 || ch > 0xbf)
+           return -1;
+         state->__value.__wchb[2] = ch;
+         state->__count = 3;
+         if (n < 4)
+           return -2;
+         ch = t[i++];
+         if (ch < 0x80 || ch > 0xbf)
+           return -1;
+         *pwc = (wchar_t)((state->__value.__wchb[0] & 0x07) << 18)
+           |    (wchar_t)((state->__value.__wchb[1] & 0x3f) << 12)
+           |    (wchar_t)((state->__value.__wchb[2] & 0x3f) << 6)
+           |    (wchar_t)(ch & 0x3f);
+       
+         state->__count = 0;
+         return i;
+       }
+      else if (ch >= 0xf8 && ch <= 0xfb)
+       {
+         /* five-byte sequence */
+         if (sizeof(wchar_t) < 4)
+           return -1; /* we can't store such a value */
+         state->__value.__wchb[0] = ch;
+         if (state->__count == 0)
+           state->__count = 1;
+         else
+           ++n;
+         if (n < 2)
+           return -2;
+         ch = (state->__count == 1) ? t[i++] : state->__value.__wchb[1];
+         if (state->__value.__wchb[0] == 0xf8 && ch < 0x88)
+           /* overlong UTF-8 sequence */
+           return -1;
+         if (ch < 0x80 || ch > 0xbf)
+           return -1;
+         state->__value.__wchb[1] = ch;
+         if (state->__count == 1)
+           state->__count = 2;
+         else
+           ++n;
+         if (n < 3)
+           return -2;
+         ch = (state->__count == 2) ? t[i++] : state->__value.__wchb[2];
+         if (ch < 0x80 || ch > 0xbf)
+           return -1;
+         state->__value.__wchb[2] = ch;
+         if (state->__count == 2)
+           state->__count = 3;
+         else
+           ++n;
+         if (n < 4)
+           return -2;
+         ch = (state->__count == 3) ? t[i++] : state->__value.__wchb[3];
+         if (ch < 0x80 || ch > 0xbf)
+           return -1;
+         state->__value.__wchb[3] = ch;
+         state->__count = 4;
+         if (n < 5)
+           return -2;
+         ch = t[i++];
+         *pwc = (wchar_t)((state->__value.__wchb[0] & 0x03) << 24)
+           |    (wchar_t)((state->__value.__wchb[1] & 0x3f) << 18)
+           |    (wchar_t)((state->__value.__wchb[2] & 0x3f) << 12)
+           |    (wchar_t)((state->__value.__wchb[3] & 0x3f) << 6)
+           |    (wchar_t)(ch & 0x3f);
+       
+         state->__count = 0;
+         return i;
+       }
+      else if (ch >= 0xfc && ch <= 0xfd)
         {
           /* six-byte sequence */
-          if (n >= 6)
-            {
-              wchar_t char2 = (wchar_t)*(t+1);
-              wchar_t char3 = (wchar_t)*(t+2);
-              wchar_t char4 = (wchar_t)*(t+3);
-              wchar_t char5 = (wchar_t)*(t+4);
-              wchar_t char6 = (wchar_t)*(t+5);
-
-              if (char2 < 0x80 || char2 > 0xbf)
-                return -1;
-              if (char3 < 0x80 || char3 > 0xbf)
-                return -1;
-              if (char4 < 0x80 || char4 > 0xbf)
-                return -1;
-              if (char5 < 0x80 || char5 > 0xbf)
-                return -1;
-              if (char6 < 0x80 || char6 > 0xbf)
-                return -1;
-
-              if (char1 == 0xfc)
-                {
-                  if (char2 < 0x84)
-                    /* overlong UTF-8 sequence */
-                    return -1;
-                }
-
-              *pwc = ((char1 & 0x01) << 30)
-                |    ((char2 & 0x3f) << 24)
-                |    ((char3 & 0x3f) << 18)
-                |    ((char4 & 0x3f) << 12)
-                |    ((char5 & 0x3f) << 6)
-                |     (char6 & 0x3f);
-              return 6;
-            }
-          else
-            return -2;
-        }
+         int ch2;
+         if (sizeof(wchar_t) < 4)
+           return -1; /* we can't store such a value */
+         state->__value.__wchb[0] = ch;
+         if (state->__count == 0)
+           state->__count = 1;
+         else
+           ++n;
+         if (n < 2)
+           return -2;
+         ch = (state->__count == 1) ? t[i++] : state->__value.__wchb[1];
+         if (state->__value.__wchb[0] == 0xfc && ch < 0x84)
+           /* overlong UTF-8 sequence */
+           return -1;
+         if (ch < 0x80 || ch > 0xbf)
+           return -1;
+         state->__value.__wchb[1] = ch;
+         if (state->__count == 1)
+           state->__count = 2;
+         else
+           ++n;
+         if (n < 3)
+           return -2;
+         ch = (state->__count == 2) ? t[i++] : state->__value.__wchb[2];
+         if (ch < 0x80 || ch > 0xbf)
+           return -1;
+         state->__value.__wchb[2] = ch;
+         if (state->__count == 2)
+           state->__count = 3;
+         else
+           ++n;
+         if (n < 4)
+           return -2;
+         ch = (state->__count == 3) ? t[i++] : state->__value.__wchb[3];
+         if (ch < 0x80 || ch > 0xbf)
+           return -1;
+         state->__value.__wchb[3] = ch;
+         if (state->__count == 3)
+           state->__count = 4;
+         else
+           ++n;
+         if (n < 5)
+           return -2;
+         if (n == 5)
+           return -1; /* at this point we can't save enough to restart */
+         ch = t[i++];
+         if (ch < 0x80 || ch > 0xbf)
+           return -1;
+         ch2 = t[i++];
+         *pwc = (wchar_t)((state->__value.__wchb[0] & 0x01) << 30)
+           |    (wchar_t)((state->__value.__wchb[1] & 0x3f) << 24)
+           |    (wchar_t)((state->__value.__wchb[2] & 0x3f) << 18)
+           |    (wchar_t)((state->__value.__wchb[3] & 0x3f) << 12)
+           |    (wchar_t)((ch & 0x3f) << 6)
+           |    (wchar_t)(ch2 & 0x3f);
+       
+         state->__count = 0;
+         return i;
+       }
       else
-        return -1;
+       return -1;
     }      
   else if (!strcmp (r->_current_locale, "C-SJIS"))
     {
-      int char1;
+      int ch;
+      int i = 0;
       if (s == NULL)
         return 0;  /* not state-dependent */
-      char1 = *t;
-      if (_issjis1 (char1))
-        {
-          int char2 = t[1];
-          if (n <= 1)
-            return -2;
-          if (_issjis2 (char2))
-            {
-              *pwc = (((wchar_t)*t) << 8) + (wchar_t)(*(t+1));
-              return 2;
-            }
-          else  
-            return -1;
-        }
+      ch = t[i++];
+      if (state->__count == 0)
+       {
+         if (_issjis1 (ch))
+           {
+             state->__value.__wchb[0] = ch;
+             state->__count = 1;
+             if (n <= 1)
+               return -2;
+             ch = t[i++];
+           }
+       }
+      if (state->__count == 1)
+       {
+         if (_issjis2 (ch))
+           {
+             *pwc = (((wchar_t)state->__value.__wchb[0]) << 8) + (wchar_t)ch;
+             state->__count = 0;
+             return i;
+           }
+         else  
+           return -1;
+       }
     }
   else if (!strcmp (r->_current_locale, "C-EUCJP"))
     {
-      int char1;
+      int ch;
+      int i = 0;
       if (s == NULL)
         return 0;  /* not state-dependent */
-      char1 = *t;
-      if (_iseucjp (char1))
-        {
-          int char2 = t[1];     
-          if (n <= 1)
-            return -2;
-          if (_iseucjp (char2))
-            {
-              *pwc = (((wchar_t)*t) << 8) + (wchar_t)(*(t+1));
-              return 2;
-            }
-          else
-            return -1;
-        }
+      ch = t[i++];
+      if (state->__count == 0)
+       {
+         if (_iseucjp (ch))
+           {
+             state->__value.__wchb[0] = ch;
+             state->__count = 1;
+             if (n <= 1)
+               return -2;
+             ch = t[i++];
+           }
+       }
+      if (state->__count == 1)
+       {
+         if (_iseucjp (ch))
+           {
+             *pwc = (((wchar_t)state->__value.__wchb[0]) << 8) + (wchar_t)ch;
+             state->__count = 0;
+             return i;
+           }
+         else
+           return -1;
+       }
     }
   else if (!strcmp (r->_current_locale, "C-JIS"))
     {
@@ -301,15 +373,16 @@ _DEFUN (_mbtowc_r, (r, pwc, s, n, state),
       JIS_ACTION action;
       JIS_CHAR_TYPE ch;
       unsigned char *ptr;
-      int i, curr_ch;
+      unsigned int i;
+      int curr_ch;
  
       if (s == NULL)
         {
-          state->__count = 0;
+          state->__state = ASCII;
           return 1;  /* state-dependent */
         }
 
-      curr_state = (state->__count == 0 ? ASCII : JIS);
+      curr_state = state->__state;
       ptr = t;
 
       for (i = 0; i < n; ++i)
@@ -353,23 +426,21 @@ _DEFUN (_mbtowc_r, (r, pwc, s, n, state),
             case NOOP:
               break;
             case EMPTY:
-              state->__count = 0;
+              state->__state = ASCII;
               *pwc = (wchar_t)0;
-              return i;
+              return 0;
             case COPY_A:
-             state->__count = 0;
+             state->__state = ASCII;
               *pwc = (wchar_t)*ptr;
               return (i + 1);
-            case COPY_J:
-              state->__count = 0;
-              *pwc = (((wchar_t)*ptr) << 8) + (wchar_t)(*(ptr+1));
-              return (i + 1);
+            case COPY_J1:
+              state->__value.__wchb[0] = t[i];
+             break;
             case COPY_J2:
-              state->__count = 1;
-              *pwc = (((wchar_t)*ptr) << 8) + (wchar_t)(*(ptr+1));
-              return (ptr - t) + 2;
+              state->__state = JIS;
+              *pwc = (((wchar_t)state->__value.__wchb[0]) << 8) + (wchar_t)(t[i]);
+              return (i + 1);
             case MAKE_A:
-            case MAKE_J:
               ptr = (char *)(t + i + 1);
               break;
             case ERROR:
@@ -379,6 +450,7 @@ _DEFUN (_mbtowc_r, (r, pwc, s, n, state),
 
         }
 
+      state->__state = curr_state;
       return -2;  /* n < bytes needed */
     }
 #endif /* MB_CAPABLE */               

diff --git a/newlib/libc/stdlib/wcrtomb.c b/newlib/libc/stdlib/wcrtomb.c
index f68533c..0eb59ca 100644 (file)
--- a/newlib/libc/stdlib/wcrtomb.c
+++ b/newlib/libc/stdlib/wcrtomb.c
@@ -5,21 +5,45 @@
 #include <errno.h>
 
 size_t
-wcrtomb(char *s, wchar_t wc, mbstate_t *ps)
+_DEFUN (_wcrtomb_r, (ptr, s, wc, ps),
+       struct _reent *ptr _AND
+       char *s _AND
+       wchar_t wc _AND
+       mbstate_t *ps)
 {
   int retval = 0;
-  _REENT_CHECK_MISC(_REENT);
+  char buf[10];
+
+#ifdef MB_CAPABLE
+  if (ps == NULL)
+    {
+      _REENT_CHECK_MISC(ptr);
+      ps = &(_REENT_WCRTOMB_STATE(ptr));
+    }
+#endif
 
   if (s == NULL)
-    retval = _wctomb_r (_REENT, "", wc, ps);
+    retval = _wctomb_r (ptr, buf, L'\0', ps);
   else
-    retval = _wctomb_r (_REENT, s, wc, ps);
+    retval = _wctomb_r (ptr, s, wc, ps);
 
   if (retval == -1)
     {
-      _REENT->_errno = EILSEQ;
+      ps->__count = 0;
+      ptr->_errno = EILSEQ;
       return (size_t)(-1);
     }
   else
     return (size_t)retval;
 }
+
+#ifndef _REENT_ONLY
+size_t
+_DEFUN (wcrtomb, (s, wc, ps),
+       char *s _AND
+       wchar_t wc _AND
+       mbstate_t *ps)
+{
+  return _wcrtomb_r (_REENT, s, wc, ps);
+}
+#endif /* !_REENT_ONLY */

diff --git a/newlib/libc/stdlib/wcsrtombs.c b/newlib/libc/stdlib/wcsrtombs.c
index 22512c0..4313478 100644 (file)
--- a/newlib/libc/stdlib/wcsrtombs.c
+++ b/newlib/libc/stdlib/wcsrtombs.c
@@ -5,18 +5,74 @@
 #include <errno.h>
 
 size_t
-wcsrtombs (char *dst, const wchar_t **src, size_t len, mbstate_t *ps)
+_DEFUN (_wcsrtombs_r, (r, dst, src, len, ps),
+       struct _reent *r _AND
+       char *dst _AND
+       const wchar_t **src _AND
+       size_t len _AND
+       mbstate_t *ps)
 {
-  int retval = 0;
-  _REENT_CHECK_MISC(_REENT);
+  char *ptr = dst;
+  char buff[10];
+  int i, n;
+  int count;
+  wint_t wch;
 
-  retval = _wcstombs_r (_REENT, dst, *src, len, ps);
+#ifdef MB_CAPABLE
+  if (ps == NULL)
+    {
+      _REENT_CHECK_MISC(r);
+      ps = &(_REENT_WCSRTOMBS_STATE(r));
+    }
+#endif
 
-  if (retval == -1)
+  n = (int)len;
+
+  while (n > 0)
     {
-      _REENT->_errno = EILSEQ;
-      return (size_t)(-1);
+      wchar_t *pwcs = (wchar_t *)(*src);
+      int count = ps->__count;
+      wint_t wch = ps->__value.__wch;
+      int bytes = _wctomb_r (r, buff, *pwcs, ps);
+      if (bytes == -1)
+       {
+         r->_errno = EILSEQ;
+         ps->__count = 0;
+         return (size_t)-1;
+       }
+      if (bytes <= n)
+       {
+         for (i = 0; i < bytes; ++i)
+           *ptr++ = buff[i];
+          
+         if (*pwcs == 0x00)
+           {
+             *src = NULL;
+             ps->__count = 0;
+             return (size_t)(ptr - dst - 1);
+           }
+         ++(*src);
+       }
+      else
+       {
+         /* not enough room, we must back up state to before _wctomb_r call */
+         ps->__count = count;
+         ps->__value.__wch = wch;
+       }
+      n -= bytes;
     }
-  else
-    return (size_t)retval;
+
+  return (size_t)(ptr - dst);
+} 
+
+#ifndef _REENT_ONLY
+size_t
+_DEFUN (wcsrtombs, (dst, src, len, ps),
+       char *dst _AND
+       const wchar_t **src _AND
+       size_t len _AND
+       mbstate_t *ps)
+{
+  return _wcsrtombs_r (_REENT, dst, src, len, ps);
 }
+#endif /* !_REENT_ONLY */

diff --git a/newlib/libc/stdlib/wcstombs.c b/newlib/libc/stdlib/wcstombs.c
index c984746..f02d4ab 100644 (file)
--- a/newlib/libc/stdlib/wcstombs.c
+++ b/newlib/libc/stdlib/wcstombs.c
@@ -60,22 +60,22 @@ _DEFUN (wcstombs, (s, pwcs, n),
         size_t         n)
 {
 #ifdef MB_CAPABLE
-        mbstate_t state;
-        state.__count = 0;
-
-        return _wcstombs_r (_REENT, s, pwcs, n, &state);
+  mbstate_t state;
+  state.__count = 0;
+  
+  return _wcstombs_r (_REENT, s, pwcs, n, &state);
 #else /* not MB_CAPABLE */
-        int count = 0;
-
-        if (n != 0) {
-                do {
-                        if ((*s++ = (char) *pwcs++) == 0)
-                                break;
-                        count++;
-                } while (--n != 0);
-        }
-
-        return count;
+  int count = 0;
+  
+  if (n != 0) {
+    do {
+      if ((*s++ = (char) *pwcs++) == 0)
+       break;
+      count++;
+    } while (--n != 0);
+  }
+  
+  return count;
 #endif /* not MB_CAPABLE */
 }
 

diff --git a/newlib/libc/stdlib/wctomb_r.c b/newlib/libc/stdlib/wctomb_r.c
index 7cd84b6..4bcabee 100644 (file)
--- a/newlib/libc/stdlib/wctomb_r.c
+++ b/newlib/libc/stdlib/wctomb_r.c
@@ -4,6 +4,9 @@
 #include <locale.h>
 #include "mbctype.h"
 
+/* for some conversions, we use the __count field as a place to store a state value */
+#define __state __count
+
 int
 _DEFUN (_wctomb_r, (r, s, wchar, state),
         struct _reent *r     _AND 
@@ -126,10 +129,10 @@ _DEFUN (_wctomb_r, (r, s, wchar, state),
         /* first byte is non-zero..validate multi-byte char */
           if (_isjis (char1) && _isjis (char2)) 
             {
-              if (state->__count == 0)
+              if (state->__state == 0)
                 {
                   /* must switch from ASCII to JIS state */
-                  state->__count = 1;
+                  state->__state = 1;
                   *s++ = ESC_CHAR;
                   *s++ = '$';
                   *s++ = 'B';
@@ -144,10 +147,10 @@ _DEFUN (_wctomb_r, (r, s, wchar, state),
         }
       else
         {
-          if (state->__count != 0)
+          if (state->__state != 0)
             {
               /* must switch from JIS to ASCII state */
-              state->__count = 0;
+              state->__state = 0;
               *s++ = ESC_CHAR;
               *s++ = '(';
               *s++ = 'B';

diff --git a/newlib/libc/sys/linux/sys/_types.h b/newlib/libc/sys/linux/sys/_types.h
index 3160129..c37abc3 100644 (file)
--- a/newlib/libc/sys/linux/sys/_types.h
+++ b/newlib/libc/sys/linux/sys/_types.h
@@ -30,7 +30,7 @@ typedef struct
   union
   {
     wint_t __wch;
-    char __wchb[4];
+    unsigned char __wchb[4];
   } __value;           /* Value so far.  */
 } _mbstate_t;
 #endif /* _MBSTATE_T */