Adapt for symbol name changes in gconv.h.
authordrepper <drepper>
Wed, 16 Jun 1999 20:50:12 +0000 (20:50 +0000)
committerdrepper <drepper>
Wed, 16 Jun 1999 20:50:12 +0000 (20:50 +0000)
13 files changed:
iconv/gconv.c
iconv/gconv_builtin.c
iconv/gconv_close.c
iconv/gconv_db.c
iconv/gconv_dl.c
iconv/gconv_int.h
iconv/gconv_open.c
iconv/gconv_simple.c
iconv/iconv.c
iconv/iconv_close.c
iconv/iconv_open.c
iconv/loop.c
iconv/skeleton.c

index 14398e2..828db9d 100644 (file)
 
 int
 internal_function
-__gconv (gconv_t cd, const unsigned char **inbuf, const unsigned char *inbufend,
-        unsigned char **outbuf, unsigned char *outbufend, size_t *converted)
+__gconv (__gconv_t cd, const unsigned char **inbuf,
+        const unsigned char *inbufend, unsigned char **outbuf,
+        unsigned char *outbufend, size_t *converted)
 {
-  size_t last_step = cd->nsteps - 1;
+  size_t last_step = cd->__nsteps - 1;
   int result;
 
-  if (cd == (gconv_t) -1L)
-    return GCONV_ILLEGAL_DESCRIPTOR;
+  if (cd == (__gconv_t) -1L)
+    return __GCONV_ILLEGAL_DESCRIPTOR;
 
   assert (converted != NULL);
   *converted = 0;
 
   if (inbuf == NULL || *inbuf == NULL)
     /* We just flush.  */
-    result = _CALL_DL_FCT (cd->steps->fct,
-                          (cd->steps, cd->data, NULL, NULL, converted, 1));
+    result = _CALL_DL_FCT (cd->__steps->__fct,
+                          (cd->__steps, cd->__data, NULL, NULL,
+                           converted, 1));
   else
     {
       const unsigned char *last_start;
 
       assert (outbuf != NULL && *outbuf != NULL);
-      cd->data[last_step].outbuf = *outbuf;
-      cd->data[last_step].outbufend = outbufend;
+      cd->__data[last_step].__outbuf = *outbuf;
+      cd->__data[last_step].__outbufend = outbufend;
 
       do
        {
          last_start = *inbuf;
-         result = _CALL_DL_FCT (cd->steps->fct,
-                                (cd->steps, cd->data, inbuf, inbufend,
+         result = _CALL_DL_FCT (cd->__steps->__fct,
+                                (cd->__steps, cd->__data, inbuf, inbufend,
                                  converted, 0));
        }
-      while (result == GCONV_EMPTY_INPUT && last_start != *inbuf
-            && *inbuf + cd->steps->min_needed_from <= inbufend);
+      while (result == __GCONV_EMPTY_INPUT && last_start != *inbuf
+            && *inbuf + cd->__steps->__min_needed_from <= inbufend);
     }
 
   if (outbuf != NULL && *outbuf != NULL)
-    *outbuf = cd->data[last_step].outbuf;
+    *outbuf = cd->__data[last_step].__outbuf;
 
   return result;
 }
index 4f3ca56..ca3ca3e 100644 (file)
@@ -1,5 +1,5 @@
 /* Table for builtin transformation mapping.
-   Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
 
@@ -29,9 +29,9 @@
 static struct builtin_map
 {
   const char *name;
-  gconv_fct fct;
-  gconv_init_fct init;
-  gconv_end_fct end;
+  __gconv_fct fct;
+  __gconv_init_fct init;
+  __gconv_end_fct end;
 
   int min_needed_from;
   int max_needed_from;
@@ -43,15 +43,15 @@ static struct builtin_map
 #define BUILTIN_TRANSFORMATION(From, ConstPfx, ConstLen, To, Cost, Name, \
                               Fct, Init, End, MinF, MaxF, MinT, MaxT) \
   {                                                                          \
-    name: Name,                                                                      \
-    fct: Fct,                                                                \
-    init: Init,                                                                      \
-    end: End,                                                                \
+    .name = Name,                                                            \
+    .fct = Fct,                                                                      \
+    .init = Init,                                                            \
+    .end = End,                                                                      \
                                                                              \
-    min_needed_from: MinF,                                                   \
-    max_needed_from: MaxF,                                                   \
-    min_needed_to: MinT,                                                     \
-    max_needed_to: MaxT                                                              \
+    .min_needed_from = MinF,                                                 \
+    .max_needed_from = MaxF,                                                 \
+    .min_needed_to = MinT,                                                   \
+    .max_needed_to = MaxT                                                    \
   },
 #define BUILTIN_ALIAS(From, To)
 
@@ -61,7 +61,7 @@ static struct builtin_map
 
 void
 internal_function
-__gconv_get_builtin_trans (const char *name, struct gconv_step *step)
+__gconv_get_builtin_trans (const char *name, struct __gconv_step *step)
 {
   size_t cnt;
 
@@ -71,17 +71,17 @@ __gconv_get_builtin_trans (const char *name, struct gconv_step *step)
 
   assert (cnt < sizeof (map) / sizeof (map[0]));
 
-  step->fct = map[cnt].fct;
-  step->init_fct = map[cnt].init;
-  step->end_fct = map[cnt].end;
-  step->counter = INT_MAX;
-  step->shlib_handle = NULL;
+  step->__fct = map[cnt].fct;
+  step->__init_fct = map[cnt].init;
+  step->__end_fct = map[cnt].end;
+  step->__counter = INT_MAX;
+  step->__shlib_handle = NULL;
 
-  step->min_needed_from = map[cnt].min_needed_from;
-  step->max_needed_from = map[cnt].max_needed_from;
-  step->min_needed_to = map[cnt].min_needed_to;
-  step->max_needed_to = map[cnt].max_needed_to;
+  step->__min_needed_from = map[cnt].min_needed_from;
+  step->__max_needed_from = map[cnt].max_needed_from;
+  step->__min_needed_to = map[cnt].min_needed_to;
+  step->__max_needed_to = map[cnt].max_needed_to;
 
   /* None of the builtin converters handles stateful encoding.  */
-  step->stateful = 0;
+  step->__stateful = 0;
 }
index 2fe8424..a22123b 100644 (file)
 
 int
 internal_function
-__gconv_close (gconv_t cd)
+__gconv_close (__gconv_t cd)
 {
-  struct gconv_step *srunp;
-  struct gconv_step_data *drunp;
+  struct __gconv_step *srunp;
+  struct __gconv_step_data *drunp;
   size_t nsteps;
 
   /* Free all resources by calling destructor functions and release
      the implementations.  */
-  srunp = cd->steps;
-  nsteps = cd->nsteps;
-  drunp = cd->data;
+  srunp = cd->__steps;
+  nsteps = cd->__nsteps;
+  drunp = cd->__data;
   do
     {
-      if (!drunp->is_last && drunp->outbuf != NULL)
-       free (drunp->outbuf);
+      if (!drunp->__is_last && drunp->__outbuf != NULL)
+       free (drunp->__outbuf);
     }
-  while (!(drunp++)->is_last);
+  while (!(drunp++)->__is_last);
 
   /* Free the data allocated for the descriptor.  */
   free (cd);
index 4abc1ae..727be41 100644 (file)
@@ -82,7 +82,7 @@ struct known_derivation
 {
   const char *from;
   const char *to;
-  struct gconv_step *steps;
+  struct __gconv_step *steps;
   size_t nsteps;
 };
 
@@ -107,7 +107,7 @@ static void *known_derivations;
 static int
 internal_function
 derivation_lookup (const char *fromset, const char *toset,
-                  struct gconv_step **handle, size_t *nsteps)
+                  struct __gconv_step **handle, size_t *nsteps)
 {
   struct known_derivation key = { fromset, toset, NULL, 0 };
   struct known_derivation **result;
@@ -115,21 +115,21 @@ derivation_lookup (const char *fromset, const char *toset,
   result = __tfind (&key, &known_derivations, derivation_compare);
 
   if (result == NULL)
-    return GCONV_NOCONV;
+    return __GCONV_NOCONV;
 
   *handle = (*result)->steps;
   *nsteps = (*result)->nsteps;
 
   /* Please note that we return GCONV_OK even if the last search for
      this transformation was unsuccessful.  */
-  return GCONV_OK;
+  return __GCONV_OK;
 }
 
 /* Add new derivation to list of known ones.  */
 static void
 internal_function
 add_derivation (const char *fromset, const char *toset,
-               struct gconv_step *handle, size_t nsteps)
+               struct __gconv_step *handle, size_t nsteps)
 {
   struct known_derivation *new_deriv;
   size_t fromset_len = strlen (fromset) + 1;
@@ -163,14 +163,14 @@ free_derivation (void *p)
   size_t cnt;
 
   for (cnt = 0; cnt < deriv->nsteps; ++cnt)
-    if (deriv->steps[cnt].end_fct)
-      _CALL_DL_FCT (deriv->steps[cnt].end_fct, (&deriv->steps[cnt]));
+    if (deriv->steps[cnt].__end_fct)
+      _CALL_DL_FCT (deriv->steps[cnt].__end_fct, (&deriv->steps[cnt]));
 
   /* Free the name strings.  */
-  free ((char *) deriv->steps[0].from_name);
-  free ((char *) deriv->steps[deriv->nsteps - 1].to_name);
+  free ((char *) deriv->steps[0].__from_name);
+  free ((char *) deriv->steps[deriv->nsteps - 1].__to_name);
 
-  free ((struct gconv_step *) deriv->steps);
+  free ((struct __gconv_step *) deriv->steps);
   free (deriv);
 }
 
@@ -178,40 +178,40 @@ free_derivation (void *p)
 static int
 internal_function
 gen_steps (struct derivation_step *best, const char *toset,
-          const char *fromset, struct gconv_step **handle, size_t *nsteps)
+          const char *fromset, struct __gconv_step **handle, size_t *nsteps)
 {
   size_t step_cnt = 0;
-  struct gconv_step *result;
+  struct __gconv_step *result;
   struct derivation_step *current;
-  int status = GCONV_NOMEM;
+  int status = __GCONV_NOMEM;
 
   /* First determine number of steps.  */
   for (current = best; current->last != NULL; current = current->last)
     ++step_cnt;
 
-  result = (struct gconv_step *) malloc (sizeof (struct gconv_step)
-                                        * step_cnt);
+  result = (struct __gconv_step *) malloc (sizeof (struct __gconv_step)
+                                          * step_cnt);
   if (result != NULL)
     {
       int failed = 0;
 
-      status = GCONV_OK;
+      status = __GCONV_OK;
       *nsteps = step_cnt;
       current = best;
       while (step_cnt-- > 0)
        {
-         result[step_cnt].from_name = (step_cnt == 0
-                                       ? __strdup (fromset)
-                                       : current->last->result_set);
-         result[step_cnt].to_name = (step_cnt + 1 == *nsteps
-                                     ? __strdup (current->result_set)
-                                     : result[step_cnt + 1].from_name);
+         result[step_cnt].__from_name = (step_cnt == 0
+                                         ? __strdup (fromset)
+                                         : current->last->result_set);
+         result[step_cnt].__to_name = (step_cnt + 1 == *nsteps
+                                       ? __strdup (current->result_set)
+                                       : result[step_cnt + 1].__from_name);
 
 #ifndef STATIC_GCONV
          if (current->code->module_name[0] == '/')
            {
              /* Load the module, return handle for it.  */
-             struct gconv_loaded_object *shlib_handle =
+             struct __gconv_loaded_object *shlib_handle =
                __gconv_find_shlib (current->code->module_name);
 
              if (shlib_handle == NULL)
@@ -220,12 +220,12 @@ gen_steps (struct derivation_step *best, const char *toset,
                  break;
                }
 
-             result[step_cnt].shlib_handle = shlib_handle;
-             result[step_cnt].modname = shlib_handle->name;
-             result[step_cnt].counter = 0;
-             result[step_cnt].fct = shlib_handle->fct;
-             result[step_cnt].init_fct = shlib_handle->init_fct;
-             result[step_cnt].end_fct = shlib_handle->end_fct;
+             result[step_cnt].__shlib_handle = shlib_handle;
+             result[step_cnt].__modname = shlib_handle->name;
+             result[step_cnt].__counter = 0;
+             result[step_cnt].__fct = shlib_handle->fct;
+             result[step_cnt].__init_fct = shlib_handle->init_fct;
+             result[step_cnt].__end_fct = shlib_handle->end_fct;
            }
          else
 #endif
@@ -234,12 +234,12 @@ gen_steps (struct derivation_step *best, const char *toset,
                                       &result[step_cnt]);
 
          /* Call the init function.  */
-         if (result[step_cnt].init_fct != NULL)
+         if (result[step_cnt].__init_fct != NULL)
             {
-              status = _CALL_DL_FCT (result[step_cnt].init_fct,
+              status = _CALL_DL_FCT (result[step_cnt].__init_fct,
                                      (&result[step_cnt]));
 
-              if (status != GCONV_OK)
+              if (status != __GCONV_OK)
                 {
                   failed = 1;
                   /* Make sure we unload this modules.  */
@@ -256,17 +256,17 @@ gen_steps (struct derivation_step *best, const char *toset,
          /* Something went wrong while initializing the modules.  */
          while (++step_cnt < *nsteps)
            {
-             if (result[step_cnt].end_fct != NULL)
-               _CALL_DL_FCT (result[step_cnt].end_fct, (&result[step_cnt]));
+             if (result[step_cnt].__end_fct != NULL)
+               _CALL_DL_FCT (result[step_cnt].__end_fct, (&result[step_cnt]));
 #ifndef STATIC_GCONV
-             __gconv_release_shlib (result[step_cnt].shlib_handle);
+             __gconv_release_shlib (result[step_cnt].__shlib_handle);
 #endif
            }
          free (result);
          *nsteps = 0;
          *handle = NULL;
-         if (status == GCONV_OK)
-           status = GCONV_NOCONV;
+         if (status == __GCONV_OK)
+           status = __GCONV_NOCONV;
        }
       else
        *handle = result;
@@ -287,7 +287,7 @@ static int
 internal_function
 find_derivation (const char *toset, const char *toset_expand,
                 const char *fromset, const char *fromset_expand,
-                struct gconv_step **handle, size_t *nsteps)
+                struct __gconv_step **handle, size_t *nsteps)
 {
   __libc_lock_define_initialized (static, lock)
   struct derivation_step *first, *current, **lastp, *solution = NULL;
@@ -297,7 +297,7 @@ find_derivation (const char *toset, const char *toset_expand,
 
   result = derivation_lookup (fromset_expand ?: fromset, toset_expand ?: toset,
                              handle, nsteps);
-  if (result == GCONV_OK)
+  if (result == __GCONV_OK)
     return result;
 
   __libc_lock_lock (lock);
@@ -307,7 +307,7 @@ find_derivation (const char *toset, const char *toset_expand,
      find it but at the same time another thread looked for this derivation. */
   result = derivation_lookup (fromset_expand ?: fromset, toset_expand ?: toset,
                              handle, nsteps);
-  if (result == GCONV_OK)
+  if (result == __GCONV_OK)
     {
       __libc_lock_unlock (lock);
       return result;
@@ -613,7 +613,7 @@ find_derivation (const char *toset, const char *toset_expand,
 int
 internal_function
 __gconv_find_transform (const char *toset, const char *fromset,
-                       struct gconv_step **handle, size_t *nsteps)
+                       struct __gconv_step **handle, size_t *nsteps)
 {
   __libc_once_define (static, once);
   const char *fromset_expand = NULL;
@@ -630,7 +630,7 @@ __gconv_find_transform (const char *toset, const char *fromset,
   if (__gconv_modules_db == NULL)
     {
       __libc_lock_unlock (lock);
-      return GCONV_NOCONV;
+      return __GCONV_NOCONV;
     }
 
   /* See whether the names are aliases.  */
@@ -653,23 +653,23 @@ __gconv_find_transform (const char *toset, const char *fromset,
 
 #ifndef STATIC_GCONV
   /* Increment the user counter.  */
-  if (result == GCONV_OK)
+  if (result == __GCONV_OK)
     {
       size_t cnt = *nsteps;
-      struct gconv_step *steps = *handle;
+      struct __gconv_step *steps = *handle;
 
       while (cnt > 0)
-       if (steps[--cnt].counter++ == 0)
+       if (steps[--cnt].__counter++ == 0)
          {
-           steps[cnt].shlib_handle =
-             __gconv_find_shlib (steps[cnt].modname);
-           if (steps[cnt].shlib_handle == NULL)
+           steps[cnt].__shlib_handle =
+             __gconv_find_shlib (steps[cnt].__modname);
+           if (steps[cnt].__shlib_handle == NULL)
              {
                /* Oops, this is the second time we use this module (after
                   unloading) and this time loading failed!?  */
                while (++cnt < *nsteps)
-                 __gconv_release_shlib (steps[cnt].shlib_handle);
-               result = GCONV_NOCONV;
+                 __gconv_release_shlib (steps[cnt].__shlib_handle);
+               result = __GCONV_NOCONV;
                break;
              }
          }
@@ -682,8 +682,8 @@ __gconv_find_transform (const char *toset, const char *fromset,
   /* The following code is necessary since `find_derivation' will return
      GCONV_OK even when no derivation was found but the same request
      was processed before.  I.e., negative results will also be cached.  */
-  return (result == GCONV_OK
-         ? (*handle == NULL ? GCONV_NOCONV : GCONV_OK)
+  return (result == __GCONV_OK
+         ? (*handle == NULL ? __GCONV_NOCONV : __GCONV_OK)
          : result);
 }
 
@@ -691,22 +691,22 @@ __gconv_find_transform (const char *toset, const char *fromset,
 /* Release the entries of the modules list.  */
 int
 internal_function
-__gconv_close_transform (struct gconv_step *steps, size_t nsteps)
+__gconv_close_transform (struct __gconv_step *steps, size_t nsteps)
 {
-  int result = GCONV_OK;
+  int result = __GCONV_OK;
 
 #ifndef STATIC_GCONV
   /* Acquire the lock.  */
   __libc_lock_lock (lock);
 
   while (nsteps-- > 0)
-    if (steps[nsteps].shlib_handle != NULL
-       && --steps[nsteps].counter == 0)
+    if (steps[nsteps].__shlib_handle != NULL
+       && --steps[nsteps].__counter == 0)
       {
-       result = __gconv_release_shlib (steps[nsteps].shlib_handle);
-       if (result != GCONV_OK)
+       result = __gconv_release_shlib (steps[nsteps].__shlib_handle);
+       if (result != __GCONV_OK)
          break;
-       steps[nsteps].shlib_handle = NULL;
+       steps[nsteps].__shlib_handle = NULL;
       }
 
   /* Release the lock.  */
index 52cf9d3..dc90986 100644 (file)
@@ -50,10 +50,10 @@ static void *loaded;
 static int
 known_compare (const void *p1, const void *p2)
 {
-  const struct gconv_loaded_object *s1 =
-    (const struct gconv_loaded_object *) p1;
-  const struct gconv_loaded_object *s2 =
-    (const struct gconv_loaded_object *) p2;
+  const struct __gconv_loaded_object *s1 =
+    (const struct __gconv_loaded_object *) p1;
+  const struct __gconv_loaded_object *s2 =
+    (const struct __gconv_loaded_object *) p2;
 
   return (intptr_t) s1->handle - (intptr_t) s2->handle;
 }
@@ -62,7 +62,7 @@ known_compare (const void *p1, const void *p2)
 static void
 do_open (void *a)
 {
-  struct gconv_loaded_object *args = (struct gconv_loaded_object *) a;
+  struct __gconv_loaded_object *args = (struct __gconv_loaded_object *) a;
   /* Open and relocate the shared object.  */
   args->handle = _dl_open (args->name, RTLD_LAZY, NULL);
 }
@@ -124,11 +124,11 @@ __gconv_find_func (void *handle, const char *name)
 
 /* Open the gconv database if necessary.  A non-negative return value
    means success.  */
-struct gconv_loaded_object *
+struct __gconv_loaded_object *
 internal_function
 __gconv_find_shlib (const char *name)
 {
-  struct gconv_loaded_object *found;
+  struct __gconv_loaded_object *found;
   void *keyp;
 
   /* Search the tree of shared objects previously requested.  Data in
@@ -144,7 +144,7 @@ __gconv_find_shlib (const char *name)
   if (keyp == NULL)
     {
       /* This name was not known before.  */
-      found = malloc (sizeof (struct gconv_loaded_object));
+      found = malloc (sizeof (struct __gconv_loaded_object));
       if (found != NULL)
        {
          /* Point the tree node at this new structure.  */
@@ -161,7 +161,7 @@ __gconv_find_shlib (const char *name)
        }
     }
   else
-    found = *(struct gconv_loaded_object **) keyp;
+    found = *(struct __gconv_loaded_object **) keyp;
 
   /* Try to load the shared object if the usage count is 0.  This
      implies that if the shared object is not loadable, the handle is
@@ -206,12 +206,12 @@ __gconv_find_shlib (const char *name)
 /* This is very ugly but the tsearch functions provide no way to pass
    information to the walker function.  So we use a global variable.
    It is MT safe since we use a lock.  */
-static struct gconv_loaded_object *release_handle;
+static struct __gconv_loaded_object *release_handle;
 
 static void
 do_release_shlib (const void *nodep, VISIT value, int level)
 {
-  struct gconv_loaded_object *obj = *(struct gconv_loaded_object **) nodep;
+  struct __gconv_loaded_object *obj = *(struct __gconv_loaded_object **) nodep;
 
   if (value != preorder && value != leaf)
     return;
@@ -238,7 +238,7 @@ do_release_shlib (const void *nodep, VISIT value, int level)
 /* Notify system that a shared object is not longer needed.  */
 int
 internal_function
-__gconv_release_shlib (struct gconv_loaded_object *handle)
+__gconv_release_shlib (struct __gconv_loaded_object *handle)
 {
   /* Urgh, this is ugly but we have no other possibility.  */
   release_handle = handle;
@@ -248,7 +248,7 @@ __gconv_release_shlib (struct gconv_loaded_object *handle)
      if necessary.  */
   __twalk (loaded, do_release_shlib);
 
-  return GCONV_OK;
+  return __GCONV_OK;
 }
 
 
@@ -256,7 +256,7 @@ __gconv_release_shlib (struct gconv_loaded_object *handle)
 static void
 do_release_all (void *nodep)
 {
-  struct gconv_loaded_object *obj = (struct gconv_loaded_object *) nodep;
+  struct __gconv_loaded_object *obj = (struct __gconv_loaded_object *) nodep;
 
   /* Unload the shared object.  We don't use the trick to
      catch errors since in the case an error is signalled
index 9b00e65..29f495c 100644 (file)
@@ -41,7 +41,7 @@ struct gconv_alias
 /* Structure describing one loaded shared object.  This normally are
    objects to perform conversation but as a special case the db shared
    object is also handled.  */
-struct gconv_loaded_object
+struct __gconv_loaded_object
 {
   /* Name of the object.  */
   const char *name;
@@ -54,9 +54,9 @@ struct gconv_loaded_object
   struct link_map *handle;
 
   /* Pointer to the functions the module defines.  */
-  gconv_fct fct;
-  gconv_init_fct init_fct;
-  gconv_end_fct end_fct;
+  __gconv_fct fct;
+  __gconv_init_fct init_fct;
+  __gconv_end_fct end_fct;
 };
 
 
@@ -95,18 +95,18 @@ extern struct gconv_module *__gconv_modules_db;
 
 /* Return in *HANDLE decriptor for transformation from FROMSET to TOSET.  */
 extern int __gconv_open (const char *__toset, const char *__fromset,
-                        gconv_t *__handle)
+                        __gconv_t *__handle)
      internal_function;
 
 /* Free resources associated with transformation descriptor CD.  */
-extern int __gconv_close (gconv_t cd)
+extern int __gconv_close (__gconv_t cd)
      internal_function;
 
 /* Transform at most *INBYTESLEFT bytes from buffer starting at *INBUF
    according to rules described by CD and place up to *OUTBYTESLEFT
    bytes in buffer starting at *OUTBUF.  Return number of written
    characters in *CONVERTED if this pointer is not null.  */
-extern int __gconv (gconv_t __cd, const unsigned char **__inbuf,
+extern int __gconv (__gconv_t __cd, const unsigned char **__inbuf,
                    const unsigned char *inbufend, unsigned char **__outbuf,
                    unsigned char *outbufend, size_t *converted)
      internal_function;
@@ -114,7 +114,7 @@ extern int __gconv (gconv_t __cd, const unsigned char **__inbuf,
 /* Return in *HANDLE a pointer to an array with *NSTEPS elements describing
    the single steps necessary for transformation from FROMSET to TOSET.  */
 extern int __gconv_find_transform (const char *__toset, const char *__fromset,
-                                  struct gconv_step **__handle,
+                                  struct __gconv_step **__handle,
                                   size_t *__nsteps)
      internal_function;
 
@@ -126,13 +126,13 @@ extern int __gconv_alias_compare (const void *__p1, const void *__p2);
 
 /* Clear reference to transformation step implementations which might
    cause the code to be unloaded.  */
-extern int __gconv_close_transform (struct gconv_step *__steps,
+extern int __gconv_close_transform (struct __gconv_step *__steps,
                                    size_t __nsteps)
      internal_function;
 
 /* Load shared object named by NAME.  If already loaded increment reference
    count.  */
-extern struct gconv_loaded_object *__gconv_find_shlib (const char *__name)
+extern struct __gconv_loaded_object *__gconv_find_shlib (const char *__name)
      internal_function;
 
 /* Find function named NAME in shared object referenced by HANDLE.  */
@@ -141,12 +141,12 @@ void *__gconv_find_func (void *handle, const char *name)
 
 /* Release shared object.  If no further reference is available unload
    the object.  */
-extern int __gconv_release_shlib (struct gconv_loaded_object *__handle)
+extern int __gconv_release_shlib (struct __gconv_loaded_object *__handle)
      internal_function;
 
 /* Fill STEP with information about builtin module with NAME.  */
 extern void __gconv_get_builtin_trans (const char *__name,
-                                      struct gconv_step *__step)
+                                      struct __gconv_step *__step)
      internal_function;
 
 
@@ -154,7 +154,8 @@ extern void __gconv_get_builtin_trans (const char *__name,
 /* Builtin transformations.  */
 #ifdef _LIBC
 # define __BUILTIN_TRANS(Name) \
-  extern int Name (struct gconv_step *__step, struct gconv_step_data *__data, \
+  extern int Name (struct __gconv_step *__step,                                      \
+                  struct __gconv_step_data *__data,                          \
                   const unsigned char **__inbuf,                             \
                   const unsigned char *__inbufend, size_t *__written,        \
                   int __do_flush)
index f3b6dfa..e10abbb 100644 (file)
 
 int
 internal_function
-__gconv_open (const char *toset, const char *fromset, gconv_t *handle)
+__gconv_open (const char *toset, const char *fromset, __gconv_t *handle)
 {
-  struct gconv_step *steps;
+  struct __gconv_step *steps;
   size_t nsteps;
-  gconv_t result = NULL;
+  __gconv_t result = NULL;
   size_t cnt = 0;
   int res;
 
   res = __gconv_find_transform (toset, fromset, &steps, &nsteps);
-  if (res == GCONV_OK)
+  if (res == __GCONV_OK)
     {
       /* Allocate room for handle.  */
-      result = (gconv_t) malloc (sizeof (struct gconv_info)
-                                + nsteps * sizeof (struct gconv_step_data));
+      result = (__gconv_t) malloc (sizeof (struct __gconv_info)
+                                  + (nsteps
+                                     * sizeof (struct __gconv_step_data)));
       if (result == NULL)
-       res = GCONV_NOMEM;
+       res = __GCONV_NOMEM;
       else
        {
          /* Remember the list of steps.  */
-         result->steps = steps;
-         result->nsteps = nsteps;
+         result->__steps = steps;
+         result->__nsteps = nsteps;
 
          /* Clear the array for the step data.  */
-         memset (result->data, '\0',
-                 nsteps * sizeof (struct gconv_step_data));
+         memset (result->__data, '\0',
+                 nsteps * sizeof (struct __gconv_step_data));
 
          /* Call all initialization functions for the transformation
             step implemenations.  */
@@ -58,37 +59,37 @@ __gconv_open (const char *toset, const char *fromset, gconv_t *handle)
            {
              /* If this is the last step we must not allocate an
                 output buffer.  */
-             result->data[cnt].is_last = cnt == nsteps - 1;
+             result->__data[cnt].__is_last = cnt == nsteps - 1;
 
              /* Reset the counter.  */
-             result->data[cnt].invocation_counter = 0;
+             result->__data[cnt].__invocation_counter = 0;
 
              /* It's a regular use.  */
-             result->data[cnt].internal_use = 0;
+             result->__data[cnt].__internal_use = 0;
 
              /* We use the `mbstate_t' member in DATA.  */
-             result->data[cnt].statep = &result->data[cnt].__state;
+             result->__data[cnt].__statep = &result->__data[cnt].__state;
 
              /* Allocate the buffer.  */
-             if (!result->data[cnt].is_last)
+             if (!result->__data[cnt].__is_last)
                {
                  size_t size = (GCONV_NCHAR_GOAL
-                                * steps[cnt].max_needed_to);
+                                * steps[cnt].__max_needed_to);
 
-                 result->data[cnt].outbuf = (char *) malloc (size);
-                 if (result->data[cnt].outbuf == NULL)
+                 result->__data[cnt].__outbuf = (char *) malloc (size);
+                 if (result->__data[cnt].__outbuf == NULL)
                    {
-                     res = GCONV_NOMEM;
+                     res = __GCONV_NOMEM;
                      break;
                    }
-                 result->data[cnt].outbufend = (result->data[cnt].outbuf
-                                                + size);
+                 result->__data[cnt].__outbufend =
+                   result->__data[cnt].__outbuf + size;
                }
            }
        }
     }
 
-  if (res != GCONV_OK)
+  if (res != __GCONV_OK)
     {
       /* Something went wrong.  Free all the resources.  */
       int serrno = errno;
@@ -96,7 +97,7 @@ __gconv_open (const char *toset, const char *fromset, gconv_t *handle)
       if (result != NULL)
        {
          while (cnt-- > 0)
-           free (result->data[cnt].outbuf);
+           free (result->__data[cnt].__outbuf);
 
          free (result);
          result = NULL;
index 74dbfc0..3f9df34 100644 (file)
@@ -90,11 +90,11 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
 
   /* Determine the status.  */
   if (*outptrp == outend)
-    result = GCONV_FULL_OUTPUT;
+    result = __GCONV_FULL_OUTPUT;
   else if (*inptrp == inend)
-    result = GCONV_EMPTY_INPUT;
+    result = __GCONV_EMPTY_INPUT;
   else
-    result = GCONV_INCOMPLETE_INPUT;
+    result = __GCONV_INCOMPLETE_INPUT;
 
   if (converted != NULL)
     converted += n_convert;
@@ -123,7 +123,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
     if (*inptr > '\x7f')                                                     \
       {                                                                              \
        /* This is no correct ANSI_X3.4-1968 character.  */                   \
-       result = GCONV_ILLEGAL_INPUT;                                         \
+       result = __GCONV_ILLEGAL_INPUT;                                       \
        break;                                                                \
       }                                                                              \
                                                                              \
@@ -152,7 +152,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
     if (*((uint32_t *) inptr) > 0x7f)                                        \
       {                                                                              \
        /* This is no correct ANSI_X3.4-1968 character.  */                   \
-       result = GCONV_ILLEGAL_INPUT;                                         \
+       result = __GCONV_ILLEGAL_INPUT;                                       \
        break;                                                                \
       }                                                                              \
                                                                              \
@@ -200,7 +200,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
        if (outptr + step >= outend)                                          \
          {                                                                   \
            /* Too long.  */                                                  \
-           result = GCONV_FULL_OUTPUT;                                       \
+           result = __GCONV_FULL_OUTPUT;                                     \
            break;                                                            \
          }                                                                   \
                                                                              \
@@ -287,14 +287,14 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
        else                                                                  \
          {                                                                   \
            /* This is an illegal encoding.  */                               \
-           result = GCONV_ILLEGAL_INPUT;                                     \
+           result = __GCONV_ILLEGAL_INPUT;                                   \
            break;                                                            \
          }                                                                   \
                                                                              \
        if (NEED_LENGTH_TEST && inptr + cnt > inend)                          \
          {                                                                   \
            /* We don't have enough input.  */                                \
-           result = GCONV_INCOMPLETE_INPUT;                                  \
+           result = __GCONV_INCOMPLETE_INPUT;                                \
            break;                                                            \
          }                                                                   \
                                                                              \
@@ -306,7 +306,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
            if ((byte & 0xc0) != 0x80)                                        \
              {                                                               \
                /* This is an illegal encoding.  */                           \
-               result = GCONV_ILLEGAL_INPUT;                                 \
+               result = __GCONV_ILLEGAL_INPUT;                               \
                break;                                                        \
              }                                                               \
                                                                              \
@@ -366,7 +366,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
   {                                                                          \
     if (*((uint32_t *) inptr) >= 0x10000)                                    \
       {                                                                              \
-       result = GCONV_ILLEGAL_INPUT;                                         \
+       result = __GCONV_ILLEGAL_INPUT;                                       \
        break;                                                                \
       }                                                                              \
     /* Please note that we use the `uint32_t' from-pointer as an `uint16_t'   \
@@ -379,7 +379,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
   {                                                                          \
     if (*((uint32_t *) inptr) >= 0x10000)                                    \
       {                                                                              \
-       result = GCONV_ILLEGAL_INPUT;                                         \
+       result = __GCONV_ILLEGAL_INPUT;                                       \
        break;                                                                \
       }                                                                              \
     *((uint16_t *) outptr)++ = *((uint32_t *) inptr)++;                              \
@@ -432,7 +432,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
   {                                                                          \
     if (*((uint32_t *) inptr) >= 0x10000)                                    \
       {                                                                              \
-       result = GCONV_ILLEGAL_INPUT;                                         \
+       result = __GCONV_ILLEGAL_INPUT;                                       \
        break;                                                                \
       }                                                                              \
     *((uint16_t *) outptr)++ = *((uint32_t *) inptr)++;                              \
@@ -442,7 +442,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
   {                                                                          \
     if (*((uint32_t *) inptr) >= 0x10000)                                    \
       {                                                                              \
-       result = GCONV_ILLEGAL_INPUT;                                         \
+       result = __GCONV_ILLEGAL_INPUT;                                       \
        break;                                                                \
       }                                                                              \
     *((uint16_t *) outptr)++ = bswap_16 (((uint16_t *) inptr)[1]);           \
@@ -475,7 +475,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
       {                                                                              \
        if (*((uint32_t *) inptr) >= 0x110000)                                \
          {                                                                   \
-           result = GCONV_ILLEGAL_INPUT;                                     \
+           result = __GCONV_ILLEGAL_INPUT;                                   \
            break;                                                            \
          }                                                                   \
                                                                              \
@@ -483,7 +483,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
        if (NEED_LENGTH_TEST && outptr + 4 > outend)                          \
          {                                                                   \
            /* Overflow in the output buffer.  */                             \
-           result = GCONV_FULL_OUTPUT;                                       \
+           result = __GCONV_FULL_OUTPUT;                                     \
            break;                                                            \
          }                                                                   \
                                                                              \
@@ -506,7 +506,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
       {                                                                              \
        if (*((uint32_t *) inptr) >= 0x110000)                                \
          {                                                                   \
-           result = GCONV_ILLEGAL_INPUT;                                     \
+           result = __GCONV_ILLEGAL_INPUT;                                   \
            break;                                                            \
          }                                                                   \
                                                                              \
@@ -514,7 +514,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
        if (NEED_LENGTH_TEST && outptr + 4 > outend)                          \
          {                                                                   \
            /* Overflow in the output buffer.  */                             \
-           result = GCONV_FULL_OUTPUT;                                       \
+           result = __GCONV_FULL_OUTPUT;                                     \
            break;                                                            \
          }                                                                   \
                                                                              \
@@ -565,7 +565,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
          {                                                                   \
            /* We don't have enough input for another complete input          \
               character.  */                                                 \
-           result = GCONV_INCOMPLETE_INPUT;                                  \
+           result = __GCONV_INCOMPLETE_INPUT;                                \
            break;                                                            \
          }                                                                   \
                                                                              \
@@ -573,7 +573,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
        if (u2 < 0xdc00 || u2 >= 0xdfff)                                      \
          {                                                                   \
            /* This is no valid second word for a surrogate.  */              \
-           result = GCONV_ILLEGAL_INPUT;                                     \
+           result = __GCONV_ILLEGAL_INPUT;                                   \
            break;                                                            \
          }                                                                   \
                                                                              \
@@ -602,7 +602,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
          {                                                                   \
            /* We don't have enough input for another complete input          \
               character.  */                                                 \
-           result = GCONV_INCOMPLETE_INPUT;                                  \
+           result = __GCONV_INCOMPLETE_INPUT;                                \
            break;                                                            \
          }                                                                   \
                                                                              \
@@ -610,7 +610,7 @@ internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
        if (u2 < 0xdc00 || u2 >= 0xdfff)                                      \
          {                                                                   \
            /* This is no valid second word for a surrogate.  */              \
-           result = GCONV_ILLEGAL_INPUT;                                     \
+           result = __GCONV_ILLEGAL_INPUT;                                   \
            break;                                                            \
          }                                                                   \
                                                                              \
index a6c8436..85a39e3 100644 (file)
@@ -31,7 +31,7 @@ size_t
 iconv (iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf,
        size_t *outbytesleft)
 {
-  gconv_t gcd = (gconv_t) cd;
+  __gconv_t gcd = (__gconv_t) cd;
   char *outstart = outbuf ? *outbuf : NULL;
   size_t converted;
   int result;
@@ -59,28 +59,28 @@ iconv (iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf,
 
   switch (result)
     {
-    case GCONV_ILLEGAL_DESCRIPTOR:
+    case __GCONV_ILLEGAL_DESCRIPTOR:
       __set_errno (EBADF);
       converted = (size_t) -1L;
       break;
 
-    case GCONV_ILLEGAL_INPUT:
+    case __GCONV_ILLEGAL_INPUT:
       __set_errno (EILSEQ);
       converted = (size_t) -1L;
       break;
 
-    case GCONV_FULL_OUTPUT:
+    case __GCONV_FULL_OUTPUT:
       __set_errno (E2BIG);
       converted = (size_t) -1L;
       break;
 
-    case GCONV_INCOMPLETE_INPUT:
+    case __GCONV_INCOMPLETE_INPUT:
       __set_errno (EINVAL);
       converted = (size_t) -1L;
       break;
 
-    case GCONV_EMPTY_INPUT:
-    case GCONV_OK:
+    case __GCONV_EMPTY_INPUT:
+    case __GCONV_OK:
       /* Nothing.  */
       break;
 
index d3974c5..6f81aa2 100644 (file)
@@ -1,5 +1,5 @@
 /* Release any resource associated with given conversion descriptor.
-   Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
 
@@ -33,5 +33,5 @@ iconv_close (iconv_t cd)
       return -1;
     }
 
-  return __gconv_close ((gconv_t) cd) ? -1 : 0;
+  return __gconv_close ((__gconv_t) cd) ? -1 : 0;
 }
index 51dcf0b..e566c6a 100644 (file)
@@ -69,7 +69,7 @@ iconv_open (const char *tocode, const char *fromcode)
   char *fromcode_conv;
   size_t tocode_len;
   size_t fromcode_len;
-  gconv_t cd;
+  __gconv_t cd;
   int res;
 
   /* Normalize the name.  We remove all characters beside alpha-numeric,
@@ -87,10 +87,10 @@ iconv_open (const char *tocode, const char *fromcode)
 
   res = __gconv_open (tocode, fromcode, &cd);
 
-  if (res != GCONV_OK)
+  if (res != __GCONV_OK)
     {
       /* We must set the error number according to the specs.  */
-      if (res == GCONV_NOCONV || res == GCONV_NODB)
+      if (res == __GCONV_NOCONV || res == __GCONV_NODB)
        __set_errno (EINVAL);
 
       return (iconv_t) -1;
index eac4c75..ada4f0a 100644 (file)
@@ -1,5 +1,5 @@
 /* Conversion loop frame work.
-   Copyright (C) 1998 Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
 
@@ -51,6 +51,7 @@
 */
 
 #include <gconv.h>
+#include <wchar.h>
 #include <sys/param.h>         /* For MIN.  */
 #define __need_size_t
 #include <stddef.h>
@@ -124,7 +125,7 @@ LOOPFCT (const unsigned char **inptrp, const unsigned char *inend,
         unsigned char **outptrp, unsigned char *outend, mbstate_t *state,
         void *data, size_t *converted EXTRA_LOOP_DECLS)
 {
-  int result = GCONV_OK;
+  int result = __GCONV_OK;
   const unsigned char *inptr = *inptrp;
   unsigned char *outptr = *outptrp;
 #ifndef COUNT_CONVERTED
@@ -157,7 +158,7 @@ LOOPFCT (const unsigned char **inptrp, const unsigned char *inend,
 #endif
     }
 
-  if (result == GCONV_OK)
+  if (result == __GCONV_OK)
     {
 #if MIN_NEEDED_INPUT == MAX_NEEDED_INPUT \
     && MIN_NEEDED_OUTPUT == MAX_NEEDED_OUTPUT
@@ -166,16 +167,16 @@ LOOPFCT (const unsigned char **inptrp, const unsigned char *inend,
         to be determined is the status.  */
       if (inptr == inend)
        /* No more input.  */
-       result = GCONV_EMPTY_INPUT;
+       result = __GCONV_EMPTY_INPUT;
       else if ((MIN_NEEDED_OUTPUT != 1 && outptr + MIN_NEEDED_OUTPUT > outend)
               || (MIN_NEEDED_OUTPUT == 1 && outptr >= outend))
        /* Overflow in the output buffer.  */
-       result = GCONV_FULL_OUTPUT;
+       result = __GCONV_FULL_OUTPUT;
       else
        /* We have something left in the input buffer.  */
-       result = GCONV_INCOMPLETE_INPUT;
+       result = __GCONV_INCOMPLETE_INPUT;
 #else
-      result = GCONV_EMPTY_INPUT;
+      result = __GCONV_EMPTY_INPUT;
 
 # undef NEED_LENGTH_TEST
 # define NEED_LENGTH_TEST      1
@@ -188,14 +189,14 @@ LOOPFCT (const unsigned char **inptrp, const unsigned char *inend,
              || (MIN_NEEDED_OUTPUT == 1 && outptr >= outend))
            {
              /* Overflow in the output buffer.  */
-             result = GCONV_FULL_OUTPUT;
+             result = __GCONV_FULL_OUTPUT;
              break;
            }
          if (MIN_NEEDED_INPUT > 1 && inptr + MIN_NEEDED_INPUT > inend)
            {
              /* We don't have enough input for another complete input
                 character.  */
-             result = GCONV_INCOMPLETE_INPUT;
+             result = __GCONV_INCOMPLETE_INPUT;
              break;
            }
 
index a9fc249..cd750ba 100644 (file)
@@ -95,7 +95,7 @@ static int from_object;
 static int to_object;
 
 # ifndef FROM_DIRECTION
-#  define FROM_DIRECTION (step->data == &from_object)
+#  define FROM_DIRECTION (step->__data == &from_object)
 # endif
 #else
 # ifndef FROM_DIRECTION
@@ -140,37 +140,37 @@ static int to_object;
 # endif
 
 int
-gconv_init (struct gconv_step *step)
+gconv_init (struct __gconv_step *step)
 {
   /* Determine which direction.  */
-  if (strcmp (step->from_name, CHARSET_NAME) == 0)
+  if (strcmp (step->__from_name, CHARSET_NAME) == 0)
     {
-      step->data = &from_object;
+      step->__data = &from_object;
 
-      step->min_needed_from = MIN_NEEDED_FROM;
-      step->max_needed_from = MAX_NEEDED_FROM;
-      step->min_needed_to = MIN_NEEDED_TO;
-      step->max_needed_to = MAX_NEEDED_TO;
+      step->__min_needed_from = MIN_NEEDED_FROM;
+      step->__max_needed_from = MAX_NEEDED_FROM;
+      step->__min_needed_to = MIN_NEEDED_TO;
+      step->__max_needed_to = MAX_NEEDED_TO;
     }
-  else if (strcmp (step->to_name, CHARSET_NAME) == 0)
+  else if (strcmp (step->__to_name, CHARSET_NAME) == 0)
     {
-      step->data = &to_object;
+      step->__data = &to_object;
 
-      step->min_needed_from = MIN_NEEDED_TO;
-      step->max_needed_from = MAX_NEEDED_TO;
-      step->min_needed_to = MIN_NEEDED_FROM;
-      step->max_needed_to = MAX_NEEDED_FROM;
+      step->__min_needed_from = MIN_NEEDED_TO;
+      step->__max_needed_from = MAX_NEEDED_TO;
+      step->__min_needed_to = MIN_NEEDED_FROM;
+      step->__max_needed_to = MAX_NEEDED_FROM;
     }
   else
-    return GCONV_NOCONV;
+    return __GCONV_NOCONV;
 
 #ifdef RESET_STATE
-  step->stateful = 1;
+  step->__stateful = 1;
 #else
-  step->stateful = 0;
+  step->__stateful = 0;
 #endif
 
-  return GCONV_OK;
+  return __GCONV_OK;
 }
 #endif
 
@@ -195,13 +195,13 @@ gconv_init (struct gconv_step *step)
 #endif
 
 int
-FUNCTION_NAME (struct gconv_step *step, struct gconv_step_data *data,
+FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
               const unsigned char **inbuf, const unsigned char *inbufend,
               size_t *written, int do_flush)
 {
-  struct gconv_step *next_step = step + 1;
-  struct gconv_step_data *next_data = data + 1;
-  gconv_fct fct = next_step->fct;
+  struct __gconv_step *next_step = step + 1;
+  struct __gconv_step_data *next_data = data + 1;
+  __gconv_fct fct = next_step->__fct;
   int status;
 
   /* If the function is called with no input this means we have to reset
@@ -209,7 +209,7 @@ FUNCTION_NAME (struct gconv_step *step, struct gconv_step_data *data,
      dropped.  */
   if (do_flush)
     {
-      status = GCONV_OK;
+      status = __GCONV_OK;
 
 #ifdef EMIT_SHIFT_TO_INIT
       /* Emit the escape sequence to reset the state.  */
@@ -217,7 +217,7 @@ FUNCTION_NAME (struct gconv_step *step, struct gconv_step_data *data,
 #endif
       /* Call the steps down the chain if there are any but only if we
          successfully emitted the escape sequence.  */
-      if (status == GCONV_OK && ! data->is_last)
+      if (status == __GCONV_OK && ! data->__is_last)
        status = DL_CALL_FCT (fct, (next_step, next_data, NULL, NULL,
                                    written, 1));
     }
@@ -225,8 +225,8 @@ FUNCTION_NAME (struct gconv_step *step, struct gconv_step_data *data,
     {
       /* We preserve the initial values of the pointer variables.  */
       const unsigned char *inptr = *inbuf;
-      unsigned char *outbuf = data->outbuf;
-      unsigned char *outend = data->outbufend;
+      unsigned char *outbuf = data->__outbuf;
+      unsigned char *outend = data->__outbufend;
       unsigned char *outstart;
 
       /* This variable is used to count the number of characters we
@@ -251,20 +251,20 @@ FUNCTION_NAME (struct gconv_step *step, struct gconv_step_data *data,
          if (FROM_DIRECTION)
            /* Run the conversion loop.  */
            status = FROM_LOOP (inbuf, inbufend, &outbuf, outend,
-                               data->statep, step->data, &converted
+                               data->__statep, step->__data, &converted
                                EXTRA_LOOP_ARGS);
          else
            /* Run the conversion loop.  */
            status = TO_LOOP (inbuf, inbufend, &outbuf, outend,
-                             data->statep, step->data, &converted
+                             data->__statep, step->__data, &converted
                              EXTRA_LOOP_ARGS);
 
          /* If this is the last step leave the loop, there is nothing
              we can do.  */
-         if (data->is_last)
+         if (data->__is_last)
            {
              /* Store information about how many bytes are available.  */
-             data->outbuf = outbuf;
+             data->__outbuf = outbuf;
 
              /* Remember how many characters we converted.  */
              *written += converted;
@@ -275,13 +275,13 @@ FUNCTION_NAME (struct gconv_step *step, struct gconv_step_data *data,
          /* Write out all output which was produced.  */
          if (outbuf > outstart)
            {
-             const unsigned char *outerr = data->outbuf;
+             const unsigned char *outerr = data->__outbuf;
              int result;
 
              result = DL_CALL_FCT (fct, (next_step, next_data, &outerr,
                                          outbuf, written, 0));
 
-             if (result != GCONV_EMPTY_INPUT)
+             if (result != __GCONV_EMPTY_INPUT)
                {
                  if (outerr != outbuf)
                    {
@@ -307,7 +307,7 @@ FUNCTION_NAME (struct gconv_step *step, struct gconv_step_data *data,
                                             (const unsigned char *) inbufend,
                                             (unsigned char **) &outbuf,
                                             (unsigned char *) outerr,
-                                            data->statep, step->data,
+                                            data->__statep, step->__data,
                                             &converted EXTRA_LOOP_ARGS);
                      else
                        /* Run the conversion loop.  */
@@ -315,13 +315,13 @@ FUNCTION_NAME (struct gconv_step *step, struct gconv_step_data *data,
                                           (const unsigned char *) inbufend,
                                           (unsigned char **) &outbuf,
                                           (unsigned char *) outerr,
-                                          data->statep, step->data,
+                                          data->__statep, step->__data,
                                           &converted EXTRA_LOOP_ARGS);
 
                      /* We must run out of output buffer space in this
                         rerun.  */
                      assert (outbuf == outerr);
-                     assert (nstatus == GCONV_FULL_OUTPUT);
+                     assert (nstatus == __GCONV_FULL_OUTPUT);
 #endif /* reset input buffer */
                    }
 
@@ -331,18 +331,18 @@ FUNCTION_NAME (struct gconv_step *step, struct gconv_step_data *data,
              else
                /* All the output is consumed, we can make another run
                   if everything was ok.  */
-               if (status == GCONV_FULL_OUTPUT)
-                 status = GCONV_OK;
+               if (status == __GCONV_FULL_OUTPUT)
+                 status = __GCONV_OK;
            }
        }
-      while (status == GCONV_OK);
+      while (status == __GCONV_OK);
 
 #ifdef END_LOOP
       END_LOOP
 #endif
 
       /* We finished one use of this step.  */
-      ++data->invocation_counter;
+      ++data->__invocation_counter;
     }
 
   return status;