Rewritten.
authordrepper <drepper>
Mon, 20 Apr 1998 18:38:50 +0000 (18:38 +0000)
committerdrepper <drepper>
Mon, 20 Apr 1998 18:38:50 +0000 (18:38 +0000)
wcsmbs/btowc.c
wcsmbs/mbrtowc.c
wcsmbs/mbsnrtowcs.c
wcsmbs/mbsrtowcs.c
wcsmbs/wcrtomb.c
wcsmbs/wcsmbsload.c
wcsmbs/wcsnrtombs.c
wcsmbs/wcsrtombs.c
wcsmbs/wctob.c

index 7efe62e..b40a98f 100644 (file)
@@ -31,7 +31,7 @@ __btowc (c)
   char buf[sizeof (wchar_t)];
   struct gconv_step_data data;
   char inbuf[1];
-  size_t inbytes;
+  char *inptr = inbuf;
   size_t converted;
   int status;
 
@@ -42,8 +42,7 @@ __btowc (c)
 
   /* Tell where we want the result.  */
   data.outbuf = (char *) buf;
-  data.outbufavail = 0;
-  data.outbufsize = sizeof (wchar_t);
+  data.outbufend = data.outbuf + sizeof (wchar_t);
   data.is_last = 1;
   data.statep = &data.__state;
 
@@ -55,10 +54,9 @@ __btowc (c)
 
   /* Create the input string.  */
   inbuf[0] = c;
-  inbytes = 1;
 
   status = (*__wcsmbs_gconv_fcts.towc->fct) (__wcsmbs_gconv_fcts.towc,
-                                            &data, inbuf, &inbytes,
+                                            &data, &inptr, inptr + 1,
                                             &converted, 0);
   /* The conversion failed.  */
   if (status != GCONV_OK && status != GCONV_FULL_OUTPUT
index 14ca0b0..1dcaf96 100644 (file)
@@ -36,14 +36,15 @@ __mbrtowc (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps)
 {
   wchar_t buf[1];
   struct gconv_step_data data;
-  size_t inbytes;
   int status;
   size_t result;
+  size_t dummy;
+  const char *inbuf;
+  char *outbuf = (char *) (pwc ?: buf);
 
   /* Tell where we want the result.  */
-  data.outbuf = (char *) (pwc ?: buf);
-  data.outbufavail = 0;
-  data.outbufsize = sizeof (wchar_t);
+  data.outbuf = outbuf;
+  data.outbufend = outbuf + sizeof (wchar_t);
   data.is_last = 1;
   data.statep = ps ?: &state;
 
@@ -60,9 +61,10 @@ __mbrtowc (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps)
   update_conversion_ptrs ();
 
   /* Do a normal conversion.  */
-  inbytes = n;
+  inbuf = s;
   status = (*__wcsmbs_gconv_fcts.towc->fct) (__wcsmbs_gconv_fcts.towc,
-                                            &data, s, &inbytes, NULL, 0);
+                                            &data, &inbuf, inbuf + n,
+                                            &dummy, 0);
 
   /* There must not be any problems with the conversion but illegal input
      characters.  The output buffer must be large enough, otherwise the
@@ -76,14 +78,14 @@ __mbrtowc (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps)
   if (status == GCONV_OK || status == GCONV_EMPTY_INPUT
       || status == GCONV_FULL_OUTPUT)
     {
-      if (data.outbufavail > 0 && *(wchar_t *)data.outbuf == L'\0')
+      if (data.outbuf != outbuf && *(wchar_t *)data.outbuf == L'\0')
        {
          /* The converted character is the NUL character.  */
          assert (__mbsinit (data.statep));
          result = 0;
        }
       else
-       result = n - inbytes;
+       result = inbuf - s;
     }
   else
     {
index d408b39..46a718b 100644 (file)
@@ -44,7 +44,7 @@ __mbsnrtowcs (dst, src, nmc, len, ps)
      size_t len;
      mbstate_t *ps;
 {
-  size_t inbytes_in;
+  const char *srcend;
   struct gconv_step_data data;
   size_t result = 0;
   int status;
@@ -55,7 +55,7 @@ __mbsnrtowcs (dst, src, nmc, len, ps)
 
   if (nmc == 0)
     return 0;
-  inbytes_in = __strnlen (*src, nmc - 1) + 1;
+  srcend = *src + __strnlen (*src, nmc - 1) + 1;
 
   /* Make sure we use the correct function.  */
   update_conversion_ptrs ();
@@ -64,21 +64,15 @@ __mbsnrtowcs (dst, src, nmc, len, ps)
   if (dst == NULL)
     {
       wchar_t buf[64];         /* Just an arbitrary size.  */
-      size_t inbytes = inbytes_in;
       const char *inbuf = *src;
       size_t written;
 
       data.outbuf = (char *) buf;
-      data.outbufsize = sizeof (buf);
+      data.outbufend = data.outbuf + sizeof (buf);
       do
        {
-         inbuf += inbytes_in - inbytes;
-         inbytes_in = inbytes;
-         data.outbufavail = 0;
-         written = 0;
-
          status = (*__wcsmbs_gconv_fcts.towc->fct) (__wcsmbs_gconv_fcts.towc,
-                                                    &data, inbuf, &inbytes,
+                                                    &data, &inbuf, srcend,
                                                     &written, 0);
          result += written;
        }
@@ -94,14 +88,11 @@ __mbsnrtowcs (dst, src, nmc, len, ps)
       /* This code is based on the safe assumption that all internal
         multi-byte encodings use the NUL byte only to mark the end
         of the string.  */
-      size_t inbytes = inbytes_in;
-
       data.outbuf = (char *) dst;
-      data.outbufsize = len * sizeof (wchar_t);
-      data.outbufavail = 0;
+      data.outbufend = data.outbuf + len * sizeof (wchar_t);
 
       status = (*__wcsmbs_gconv_fcts.towc->fct) (__wcsmbs_gconv_fcts.towc,
-                                                &data, *src, &inbytes,
+                                                &data, src, srcend,
                                                 &result, 0);
 
       /* We have to determine whether the last character converted
@@ -114,8 +105,6 @@ __mbsnrtowcs (dst, src, nmc, len, ps)
          *src = NULL;
          --result;
        }
-      else
-       *src += inbytes_in - inbytes;
     }
 
   /* There must not be any problems with the conversion but illegal input
index 8f9efb3..9172fd9 100644 (file)
@@ -19,6 +19,7 @@
 
 #include <errno.h>
 #include <gconv.h>
+#include <stdlib.h>
 #include <string.h>
 #include <wchar.h>
 #include <wcsmbsload.h>
@@ -55,22 +56,16 @@ __mbsrtowcs (dst, src, len, ps)
   if (dst == NULL)
     {
       wchar_t buf[64];         /* Just an arbitrary size.  */
-      size_t inbytes_in = strlen (*src) + 1;
-      size_t inbytes = inbytes_in;
+      const char *srcend = *src + strlen (*src) + 1;
       const char *inbuf = *src;
       size_t written;
 
       data.outbuf = (char *) buf;
-      data.outbufsize = sizeof (buf);
+      data.outbufend = data.outbuf + sizeof (buf);
       do
        {
-         inbuf += inbytes_in - inbytes;
-         inbytes_in = inbytes;
-         data.outbufavail = 0;
-         written = 0;
-
          status = (*__wcsmbs_gconv_fcts.towc->fct) (__wcsmbs_gconv_fcts.towc,
-                                                    &data, inbuf, &inbytes,
+                                                    &data, &inbuf, srcend,
                                                     &written, 0);
          result += written;
        }
@@ -86,15 +81,13 @@ __mbsrtowcs (dst, src, len, ps)
       /* This code is based on the safe assumption that all internal
         multi-byte encodings use the NUL byte only to mark the end
         of the string.  */
-      size_t inbytes_in = __strnlen (*src, len * MB_CUR_MAX) + 1;
-      size_t inbytes = inbytes_in;
+      const char *srcend = *src + __strnlen (*src, len * MB_CUR_MAX) + 1;
 
       data.outbuf = (char *) dst;
-      data.outbufsize = len * sizeof (wchar_t);
-      data.outbufavail = 0;
+      data.outbufend = data.outbuf + len * sizeof (wchar_t);
 
       status = (*__wcsmbs_gconv_fcts.towc->fct) (__wcsmbs_gconv_fcts.towc,
-                                                &data, *src, &inbytes,
+                                                &data, src, srcend,
                                                 &result, 0);
 
       /* We have to determine whether the last character converted
@@ -107,8 +100,6 @@ __mbsrtowcs (dst, src, len, ps)
          *src = NULL;
          --result;
        }
-      else
-       *src += inbytes_in - inbytes;
     }
 
   /* There must not be any problems with the conversion but illegal input
index dcc2ef6..6fd33e0 100644 (file)
@@ -40,11 +40,11 @@ __wcrtomb (char *s, wchar_t wc, mbstate_t *ps)
   struct gconv_step_data data;
   int status;
   size_t result;
+  size_t dummy;
 
   /* Tell where we want the result.  */
   data.outbuf = s;
-  data.outbufavail = 0;
-  data.outbufsize = MB_CUR_MAX;
+  data.outbufend = s + MB_CUR_MAX;
   data.is_last = 1;
   data.statep = ps ?: &state;
 
@@ -64,23 +64,21 @@ __wcrtomb (char *s, wchar_t wc, mbstate_t *ps)
      by a NUL byte.  */
   if (wc == L'\0')
     {
-      size_t inbytes = 0;
-
       status = (*__wcsmbs_gconv_fcts.tomb->fct) (__wcsmbs_gconv_fcts.tomb,
-                                                &data, NULL, &inbytes,
-                                                NULL, 1);
+                                                &data, NULL, NULL, &dummy, 1);
 
       if (status == GCONV_OK || status == GCONV_EMPTY_INPUT)
-       data.outbuf[data.outbufavail++] = '\0';
+       *data.outbuf++ = '\0';
     }
   else
     {
       /* Do a normal conversion.  */
-      size_t inbytes = sizeof (wchar_t);
+      const char *inbuf = (const char *) &wc;
 
       status = (*__wcsmbs_gconv_fcts.tomb->fct) (__wcsmbs_gconv_fcts.tomb,
-                                                &data, (char *) &wc, &inbytes,
-                                                NULL, 0);
+                                                &data, &inbuf,
+                                                inbuf + sizeof (wchar_t),
+                                                &dummy, 0);
     }
 
   /* There must not be any problems with the conversion but illegal input
@@ -94,7 +92,7 @@ __wcrtomb (char *s, wchar_t wc, mbstate_t *ps)
 
   if (status == GCONV_OK || status == GCONV_EMPTY_INPUT
       || status == GCONV_FULL_OUTPUT)
-    result = data.outbufavail;
+    result = data.outbuf - s;
   else
     {
       result = (size_t) -1;
index c7e5651..f4babc4 100644 (file)
@@ -37,8 +37,8 @@ static struct gconv_step to_wc =
   shlib_handle: NULL,
   modname: NULL,
   counter: INT_MAX,
-  from_name: "ANSI_X3.4-1968",
-  to_name: "#INTERNAL#",
+  from_name: "ANSI_X3.4-1968//",
+  to_name: "INTERNAL",
   fct: __gconv_transform_ascii_internal,
   init_fct: NULL,
   end_fct: NULL,
@@ -50,8 +50,8 @@ static struct gconv_step to_mb =
   shlib_handle: NULL,
   modname: NULL,
   counter: INT_MAX,
-  from_name: "#INTERNAL#",
-  to_name: "ANSI_X3.4-1968",
+  from_name: "INTERNAL",
+  to_name: "ANSI_X3.4-1968//",
   fct: __gconv_transform_internal_ascii,
   init_fct: NULL,
   end_fct: NULL,
@@ -113,8 +113,8 @@ __wcsmbs_load_conv (const struct locale_data *new_category)
          /* Get name of charset of the locale.  */
          charset_name = new_category->values[_NL_ITEM_INDEX(CODESET)].string;
 
-         __wcsmbs_gconv_fcts.tomb = getfct (charset_name, "#INTERNAL#");
-         __wcsmbs_gconv_fcts.towc = getfct ("#INTERNAL#", charset_name);
+         __wcsmbs_gconv_fcts.tomb = getfct (charset_name, "INTERNAL");
+         __wcsmbs_gconv_fcts.towc = getfct ("INTERNAL", charset_name);
 
          /* If any of the conversion functions is not available we don't
             use any since this would mean we cannot convert back and
index 0daf0e3..4b6232a 100644 (file)
@@ -44,7 +44,7 @@ __wcsnrtombs (dst, src, nwc, len, ps)
      mbstate_t *ps;
 {
   struct gconv_step_data data;
-  size_t inbytes_in;
+  const wchar_t *srcend;
   int status;
   size_t result;
 
@@ -54,7 +54,7 @@ __wcsnrtombs (dst, src, nwc, len, ps)
 
   if (nwc == 0)
     return 0;
-  inbytes_in = (__wcsnlen (*src, nwc - 1) + 1) * sizeof (wchar_t);
+  srcend = *src + __wcsnlen (*src, nwc - 1) + 1;
 
   /* Make sure we use the correct function.  */
   update_conversion_ptrs ();
@@ -63,30 +63,25 @@ __wcsnrtombs (dst, src, nwc, len, ps)
   if (dst == NULL)
     {
       char buf[256];           /* Just an arbitrary value.  */
-      size_t inbytes = inbytes_in;
       const wchar_t *inbuf = *src;
       size_t written;
 
       data.outbuf = buf;
-      data.outbufsize = sizeof (buf);
+      data.outbufend = buf + sizeof (buf);
 
       do
        {
-         inbuf += (inbytes_in - inbytes) / sizeof (wchar_t);
-         inbytes_in = inbytes;
-         data.outbufavail = 0;
-         written = 0;
-
          status = (*__wcsmbs_gconv_fcts.tomb->fct) (__wcsmbs_gconv_fcts.tomb,
                                                     &data,
-                                                    (const char *) inbuf,
-                                                    &inbytes, &written, 0);
+                                                    (const char **) &inbuf,
+                                                    (const char *) srcend,
+                                                    &written, 0);
          result += written;
        }
       while (status == GCONV_FULL_OUTPUT);
 
       if ((status == GCONV_OK || status == GCONV_EMPTY_INPUT)
-         && buf[data.outbufavail - 1] == '\0')
+         && data.outbuf[-1] == '\0')
        /* Don't count the NUL character in.  */
        --result;
     }
@@ -95,28 +90,24 @@ __wcsnrtombs (dst, src, nwc, len, ps)
       /* This code is based on the safe assumption that all internal
         multi-byte encodings use the NUL byte only to mark the end
         of the string.  */
-      size_t inbytes = inbytes_in;
-
       data.outbuf = dst;
-      data.outbufavail = 0;
-      data.outbufsize = len;
+      data.outbufend = dst + len;
 
       status = (*__wcsmbs_gconv_fcts.tomb->fct) (__wcsmbs_gconv_fcts.tomb,
-                                                &data, (const char *) *src,
-                                                &inbytes, &result, 0);
+                                                &data, (const char **) src,
+                                                (const char *) srcend,
+                                                &result, 0);
 
       /* We have to determine whether the last character converted
         is the NUL character.  */
       if ((status == GCONV_OK || status == GCONV_EMPTY_INPUT)
-         && dst[data.outbufavail - 1] == '\0')
+         && data.outbuf[-1] == '\0')
        {
-         assert (data.outbufavail > 0);
+         assert (data.outbuf != dst);
          assert (__mbsinit (data.statep));
          *src = NULL;
          --result;
        }
-      else
-       *src += result;
     }
 
   /* There must not be any problems with the conversion but illegal input
index 7b59fc7..428ef3d 100644 (file)
@@ -55,31 +55,26 @@ __wcsrtombs (dst, src, len, ps)
   if (dst == NULL)
     {
       char buf[256];           /* Just an arbitrary value.  */
-      size_t inbytes_in = (__wcslen (*src) + 1) * sizeof (wchar_t);
-      size_t inbytes = inbytes_in;
+      const wchar_t *srcend = *src + __wcslen (*src) + 1;
       const wchar_t *inbuf = *src;
       size_t written;
 
       data.outbuf = buf;
-      data.outbufsize = sizeof (buf);
+      data.outbufend = buf + sizeof (buf);
 
       do
        {
-         inbuf += (inbytes_in - inbytes) / sizeof (wchar_t);
-         inbytes_in = inbytes;
-         data.outbufavail = 0;
-         written = 0;
-
          status = (*__wcsmbs_gconv_fcts.tomb->fct) (__wcsmbs_gconv_fcts.tomb,
                                                     &data,
-                                                    (const char *) inbuf,
-                                                    &inbytes, &written, 0);
+                                                    (const char **) &inbuf,
+                                                    (const char *) srcend,
+                                                    &written, 0);
          result += written;
        }
       while (status == GCONV_FULL_OUTPUT);
 
       if ((status == GCONV_OK || status == GCONV_EMPTY_INPUT)
-         && buf[data.outbufavail - 1] == '\0')
+         && data.outbuf[-1] == '\0')
        /* Don't count the NUL character in.  */
        --result;
     }
@@ -88,31 +83,27 @@ __wcsrtombs (dst, src, len, ps)
       /* This code is based on the safe assumption that all internal
         multi-byte encodings use the NUL byte only to mark the end
         of the string.  */
-      size_t inbytes_in = ((__wcsnlen (*src, len * MB_CUR_MAX) + 1)
-                          * sizeof (wchar_t));
-      size_t inbytes = inbytes_in;
+      const wchar_t *srcend = *src + __wcsnlen (*src, len * MB_CUR_MAX) + 1;
 
       data.outbuf = dst;
-      data.outbufavail = 0;
-      data.outbufsize = len;
+      data.outbufend = dst + len;
 
       status = (*__wcsmbs_gconv_fcts.tomb->fct) (__wcsmbs_gconv_fcts.tomb,
-                                                &data, (const char *) *src,
-                                                &inbytes, &result, 0);
+                                                &data, (const char **) src,
+                                                (const char *) srcend,
+                                                &result, 0);
 
       /* We have to determine whether the last character converted
         is the NUL character.  */
       if ((status == GCONV_OK || status == GCONV_EMPTY_INPUT
           || status == GCONV_FULL_OUTPUT)
-         && dst[data.outbufavail - 1] == '\0')
+         && data.outbuf[-1] == '\0')
        {
-         assert (data.outbufavail > 0);
+         assert (data.outbuf != dst);
          assert (__mbsinit (data.statep));
          *src = NULL;
          --result;
        }
-      else
-       *src += result;
     }
 
   /* There must not be any problems with the conversion but illegal input
index e70b4e7..b06d170 100644 (file)
@@ -31,14 +31,13 @@ wctob (c)
   char buf[MB_LEN_MAX];
   struct gconv_step_data data;
   wchar_t inbuf[1];
-  size_t inbytes;
+  wchar_t *inptr = inbuf;
   size_t converted;
   int status;
 
   /* Tell where we want the result.  */
-  data.outbuf = (char *) buf;
-  data.outbufavail = 0;
-  data.outbufsize = MB_LEN_MAX;
+  data.outbuf = buf;
+  data.outbufend = buf + MB_LEN_MAX;
   data.is_last = 1;
   data.statep = &data.__state;
 
@@ -50,15 +49,15 @@ wctob (c)
 
   /* Create the input string.  */
   inbuf[0] = c;
-  inbytes = sizeof (wchar_t);
 
   status = (*__wcsmbs_gconv_fcts.tomb->fct) (__wcsmbs_gconv_fcts.tomb, &data,
-                                            (const char *) inbuf, &inbytes,
+                                            (const char **) &inptr,
+                                            (const char *) &inbuf[1],
                                             &converted, 0);
   /* The conversion failed or the output is too long.  */
   if ((status != GCONV_OK && status != GCONV_FULL_OUTPUT
        && status != GCONV_EMPTY_INPUT)
-      || data.outbufavail != 1)
+      || data.outbuf != buf + 1)
     return EOF;
 
   return buf[0];