Update.

	* Versions.def: Add GLIBC_2.2 for libc.

	* iconv/gconv.h: Make header suitable for inclusion in public header
	by protecting all names with __.
	* iconv/gconv.c: Adapt for symbol name changes.
	* iconv/gconv.h: Likewise.
	* iconv/gconv_builtin.c: Likewise.
	* iconv/gconv_close.c: Likewise.
	* iconv/gconv_db.c: Likewise.
	* iconv/gconv_dl.c: Likewise.
	* iconv/gconv_int.h: Likewise.
	* iconv/gconv_open.c: Likewise.
	* iconv/gconv_simple.c: Likewise.
	* iconv/iconv.c: Likewise.
	* iconv/iconv_close.c: Likewise.
	* iconv/iconv_open.c: Likewise.
	* iconv/loop.c: Likewise.
	* iconv/skeleton.c: Likewise.
	* iconvdata/8bit-gap.c: Likewise.
	* iconvdata/8bit-generic.c: Likewise.
	* iconvdata/ansi_x3.110.c: Likewise.
	* iconvdata/big5.c: Likewise.
	* iconvdata/cns11643.h: Likewise.
	* iconvdata/cns11643l1.h: Likewise.
	* iconvdata/euc-cn.c: Likewise.
	* iconvdata/euc-jp.c: Likewise.
	* iconvdata/euc-kr.c: Likewise.
	* iconvdata/euc-tw.c: Likewise.
	* iconvdata/gb2312.h: Likewise.
	* iconvdata/iso-2022-jp.c: Likewise.
	* iconvdata/iso-2022-kr.c: Likewise.
	* iconvdata/iso646.c: Likewise.
	* iconvdata/iso8859-1.c: Likewise.
	* iconvdata/iso_6937-2.c: Likewise.
	* iconvdata/iso_6937.c: Likewise.
	* iconvdata/jis0201.h: Likewise.
	* iconvdata/jis0208.h: Likewise.
	* iconvdata/jis0212.h: Likewise.
	* iconvdata/johab.c: Likewise.
	* iconvdata/ksc5601.h: Likewise.
	* iconvdata/sjis.c: Likewise.
	* iconvdata/t.61.c: Likewise.
	* iconvdata/uhc.c: Likewise.
	* stdlib/mblen.c: Likewise.
	* stdlib/mbtowc.c: Likewise.
	* stdlib/wctomb.c: Likewise.
	* wcsmbs/btowc.c: Likewise.
	* wcsmbs/mbrtowc.c: Likewise.
	* wcsmbs/mbsnrtowcs.c: Likewise.
	* wcsmbs/mbsrtowcs.c: Likewise.
	* wcsmbs/wchar.h: Likewise.
	* wcsmbs/wcrtomb.c: Likewise.
	* wcsmbs/wcsmbsload.c: Likewise.
	* wcsmbs/wcsmbsload.h: Likewise.
	* wcsmbs/wcsnrtombs.c: Likewise.
	* wcsmbs/wcsrtombs.c: Likewise.
	* wcsmbs/wctob.c: Likewise.

	* include/limits.h (MB_LEN_MAX): Increase to 16.

	* sysdeps/generic/_G_config.h: Define _G_fpos_t as struct.  Define
	_G_iconv_t.
	* sysdeps/unix/sysv/linux/_G_config.h: Likewise.
	* include/wchar.h: Change mbstate_t to __mbstate_t.

	* libio/Makefile (routines): Add wfiledoalloc, oldiofgetpos,
	oldiofgetpos64, oldiofsetpos, oldiofsetpos64, fputwc, fputwc_u,
	getwc, getwc_u, getwchar, getwchar_u, iofgetws, iofgetws_u,
	iofputws, iofputws_u, iogetwline, iowpadn, ioungetwc, putwc, putwc_u,
	putchar, putchar_u, swprintf, vwprintf, wprintf, wscanf, fwscanf,
	vwscanf, vswprintf, iovswscanf, swscanf, wgenops, wstrops, wfileops,
	and iofwide.
	(tests): Add tst_swprintf, tst_wprintf, tst_swscanf, and tst_wscanf.
	* libio/Versions: Add _IO_fgetpos, _IO_fgetpos64, _IO_fsetpos,
	_IO_fsetpos64, fgetpos, fgetpos64, fgetwc, fgetwc_unlocked, fgetws,
	fgetws_unlocked, fputwc, fputwc_unlocked, fputws, fputws_unlocked,
	fsetpos, fsetpos64, fwide, fwprintf, fwscanf, getwc, getwc_unlocked,
	getwchar, getwchar_unlocked, putwc, putwc_unlocked, putwchar,
	putwchar_unlocked, swprintf, swscanf, ungetwc, vfwprintf, vswprintf,
	vwprintf, vfwscanf, vswscanf, vwscanf, wprintf, and wscanf to
	GLIBC_2.2 for libc.
	* libio/libio.h: Define codecvt struct.  Define _IO_wide_data.
	Extend _IO_file contain pointer to codecvt, widedata and mode.
	(_IO_getwc_unlocked): New macro.
	(_IO_putwc_unlocked): New macro.
	(_IO_fwide): New macro.
	* libio/libioP.h: Add new prototypes and adjust existing declarations.
	* libio/fileops.c (_IO_new_file_close_it): Reset normal or widedata
	buffers based on mode.
	(new_do_write): Set _IO_write_end to _IO_buf_end if stream is wide
	oriented.
	(_IO_new_file_overflow): Don't depend only on _IO_CURRENTLY_PUTTING
	flag to be enough to signal unallocated buffer.  For wide oriented
	stream don't make it linebuffered.  Don't use _IO_do_flush, use
	_IO_new_do_write directly.
	(_IO_new_file_seekoff): Change return value type to _IO_off64_t.
	(_IO_file_seek): Likewise.
	* libio/genops.c (_IO_least_marker): Make global.
	(__underflow): Orient stream if not already done.
	(__uflow): Likewise.
	(_IO_default_seekpos): Change to type _IO_off64_t.
	(_IO_default_seekoff): Likewise.
	(_IO_default_seek): Likewise.
	(_IO_no_init): New function.  Similar to _IO_init but allows to orient
	in initialization.
	* libio/iolibio.h: Add prototype for _IO_vswprintf.  Change _IO_pos_BAD
	to use _IO_off64_t.
	* libio/ftello.c: Use _IO_off_t.  For now abort when use with wide
	char stream.
	* libio/ftello64.c: Likewise.
	* libio/ioftell.c: Likewise.
	* libio/iofopncook.c: Likewise.
	* libio/ioseekoff.c: Likewise.
	* libio/ioseekpos.c: Likewise.
	* libio/oldfileops.c: Likewise.
	* libio/iofgetpos.c: Store state of conversion if necessary.
	* libio/iofgetpos64.c: Likewise.
	* libio/iofsetpos.c: Restore conversion state if necessary.
	* libio/iofsetpos64.c: Likewise.
	* libio/iofdopen.c: Initialize so that stream can be wide oriented.
	* libio/iofopen.c: Likewise.
	* libio/iofopen64.c: Likewise.
	* libio/iopopen.c: Likewise.
	* libio/iovdprintf.c: Likewise.
	* libio/iovsprintf.c: Likewise.
	* libio/iovsscanf.c: Likewise.
	* libio/memstream.c: Likewise.
	* libio/obprintf.c: Likewise.
	* libio/iofputs.c: Orient stream if not already happened.
	* libio/iofputs_u.c: Likewise.
	* libio/iofwrite.c: Likewise.
	* libio/iofwrite_u.c: Likewise.
	* libio/ioputs.c: Likewise.
	* libio/iosetbuffer.c: Handle not yet oriented stream.
	* libio/iosetvbuf.c: Likewise.
	* libio/oldstdfiles.c: Adjust FILEBUF_LITERAL call.
	* libio/stdfiles.c: Likewise.
	* libio/strops.c (_IO_str_overflow): Correctly free buffer after
	failed allocation.
	(_IO_str_seekoff): Use _IO_off64_t.
	* libio/vasprintf.c: Pre-orient stream.
	* libio/vsnprintf.c: Likewise.
	* libio/fputwc.c: New file.
	* libio/fputwc_u.c: New file.
	* libio/fwprintf.c: New file.
	* libio/fwscanf.c: New file.
	* libio/getwc.c: New file.
	* libio/getwc_u.c: New file.
	* libio/getwchar.c: New file.
	* libio/getwchar_u.c: New file.
	* libio/iofgetws.c: New file.
	* libio/iofgetws_u.c: New file.
	* libio/iofputws.c: New file.
	* libio/iofputws_u.c: New file.
	* libio/iofwide.c: New file.
	* libio/iogetwline.c: New file.
	* libio/ioungetwc.c: New file.
	* libio/iovswscanf.c: New file.
	* libio/iowpadn.c: New file.
	* libio/oldiofgetpos.c: New file.
	* libio/oldiofgetpos64.c: New file.
	* libio/oldiofsetpos.c: New file.
	* libio/oldiofsetpos64.c: New file.
	* libio/putwc.c: New file.
	* libio/putwc_u.c: New file.
	* libio/putwchar.c: New file.
	* libio/putwchar_u.c: New file.
	* libio/swprintf.c: New file.
	* libio/swscanf.c: New file.
	* libio/tst_swprintf.c: New file.
	* libio/tst_swscanf.c: New file.
	* libio/tst_wprintf.c: New file.
	* libio/tst_wscanf.c: New file.
	* libio/tst_wscanf.input: New file.
	* libio/vswprintf.c: New file.
	* libio/vwprintf.c: New file.
	* libio/vwscanf.c: New file.
	* libio/wfiledoalloc.c: New file.
	* libio/wfileops.c: New file.
	* libio/wgenops.c: New file.
	* libio/wprintf.c: New file.
	* libio/wscanf.c: New file.
	* libio/wstrops.c: New file.
	* stdio-common/Makefile (routines): Add _itowa, itowa-digits,
	vfwprintf, and vfwscanf.
	* stdio-common/_itoa.c (base_table): Rename to _IO_base_table and
	make global.
	* stdio-common/_itowa.c: New file.
	* stdio-common/_itowa.h: New file.
	* stdio-common/itoa-digits.c: Minimal optimization.
	* stdio-common/itowa-digits.c: New file.
	* stdio-common/printf-parse.h: Allow use in wide character context.
	* stdio-common/printf-prs.c: Define ISASCII and MBRLEN.
	* stdio-common/printf.h (printf_info): Add wide bit.
	* stdio-common/printf_fp.c: Determine from wide bit whether stream
	is wide oriented or not.
	* stdio-common/printf_size.c: Likewise.
	* sysdeps/generic/printf_fphex.c: Likewise.
	* stdlib/strfmon.c: Call __printf_fp with wide bit cleared.
	* stdio-common/vfprintf.c: Rewrite to allow use in wide character
	context.
	* stdio-common/vfscand.c: Likewise.
	* stdio-common/vfwprintf.c: New file.
	* stdio-common/vfwscanf.c: New file.

	* time/Makefile (routines): Add wcsftime.
	(tests): Add tst_wcsftime.
	* time/Versions: Add wcsftime to GLIBC_2.2 for libc.
	* time/strftime.c: Make usable as wcsftime.
	* time/wcsftime.c: New file.
	* time/tst_wcsftime.c: New file.

	* wcsmbs/Makefile (routines): Add wmempcpy and wcschrnul.
	* wcsmbs/Versions: Add wmempcpy and wcschrnul to GLIBC_2.2 for libc.
	* wcsmbs/wcschrnul.c: New file.
	* wcsmbs/wmemcpy.c: New file.
	* wcsmbs/wmemcpy.c: Rename to __wmemcpy and make wmemcpy weak alias.
	* wcsmbs/wmemmove.c: Likewise for wmemmove.

	* manual/stdio.texi: Document is_char and wide element if printf_info.

	* manual/time.texi: Document wcsftime.

	* include/wchar.h: Add prototypes for __wmemcpy, __wmempcpy,
	__wmemmove, __wcschrnul, and __vfwscanf.

	* locale/langinfo.h: Add new LC_TIME entries for wchar_t data.
	* locale/C-time.c: Adapt for above change.
	* locale/categories.def: Likewise.
	* locale/localeinfo.h: Likewise.
	* localedata/Makefile: Don't run tests for now.

14 files changed, 294 insertions, 287 deletions

diff --git a/iconv/gconv.c b/iconv/gconv.c
index 14398e2e37..828db9d6f8 100644
--- a/iconv/gconv.c
+++ b/iconv/gconv.c
@@ -27,43 +27,45 @@
 
 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;
 }
diff --git a/iconv/gconv.h b/iconv/gconv.h
index 4b71ccf4b8..f4a66c68d4 100644
--- a/iconv/gconv.h
+++ b/iconv/gconv.h
@@ -24,106 +24,108 @@
 #define _GCONV_H	1
 
 #include <features.h>
+#define __need_mbstate_t
 #include <wchar.h>
 #define __need_size_t
 #include <stddef.h>
 
 /* ISO 10646 value used to signal invalid value.  */
-#define UNKNOWN_10646_CHAR	((wchar_t) 0xfffd)
+#define __UNKNOWN_10646_CHAR	((wchar_t) 0xfffd)
 
 /* Error codes for gconv functions.  */
 enum
 {
-  GCONV_OK = 0,
-  GCONV_NOCONV,
-  GCONV_NODB,
-  GCONV_NOMEM,
-
-  GCONV_EMPTY_INPUT,
-  GCONV_FULL_OUTPUT,
-  GCONV_ILLEGAL_INPUT,
-  GCONV_INCOMPLETE_INPUT,
-
-  GCONV_ILLEGAL_DESCRIPTOR,
-  GCONV_INTERNAL_ERROR
+  __GCONV_OK = 0,
+  __GCONV_NOCONV,
+  __GCONV_NODB,
+  __GCONV_NOMEM,
+
+  __GCONV_EMPTY_INPUT,
+  __GCONV_FULL_OUTPUT,
+  __GCONV_ILLEGAL_INPUT,
+  __GCONV_INCOMPLETE_INPUT,
+
+  __GCONV_ILLEGAL_DESCRIPTOR,
+  __GCONV_INTERNAL_ERROR
 };
 
 
 /* Forward declarations.  */
-struct gconv_step;
-struct gconv_step_data;
-struct gconv_loaded_object;
+struct __gconv_step;
+struct __gconv_step_data;
+struct __gconv_loaded_object;
 
 
 /* Type of a conversion function.  */
-typedef int (*gconv_fct) __PMT ((struct gconv_step *,
-				 struct gconv_step_data *,
-				 __const unsigned char **,
-				 __const unsigned char *, size_t *, int));
+typedef int (*__gconv_fct) __PMT ((struct __gconv_step *,
+				   struct __gconv_step_data *,
+				   __const unsigned char **,
+				   __const unsigned char *, size_t *, int));
 
 /* Constructor and destructor for local data for conversion step.  */
-typedef int (*gconv_init_fct) __PMT ((struct gconv_step *));
-typedef void (*gconv_end_fct) __PMT ((struct gconv_step *));
+typedef int (*__gconv_init_fct) __PMT ((struct __gconv_step *));
+typedef void (*__gconv_end_fct) __PMT ((struct __gconv_step *));
 
 
 /* Description of a conversion step.  */
-struct gconv_step
+struct __gconv_step
 {
-  struct gconv_loaded_object *shlib_handle;
-  __const char *modname;
+  struct __gconv_loaded_object *__shlib_handle;
+  __const char *__modname;
 
-  int counter;
+  int __counter;
 
-  __const char *from_name;
-  __const char *to_name;
+  __const char *__from_name;
+  __const char *__to_name;
 
-  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;
 
   /* Information about the number of bytes needed or produced in this
      step.  This helps optimizing the buffer sizes.  */
-  int min_needed_from;
-  int max_needed_from;
-  int min_needed_to;
-  int max_needed_to;
+  int __min_needed_from;
+  int __max_needed_from;
+  int __min_needed_to;
+  int __max_needed_to;
 
   /* Flag whether this is a stateful encoding or not.  */
-  int stateful;
+  int __stateful;
 
-  void *data;		/* Pointer to step-local data.  */
+  void *__data;		/* Pointer to step-local data.  */
 };
 
 /* Additional data for steps in use of conversion descriptor.  This is
    allocated by the `init' function.  */
-struct gconv_step_data
+struct __gconv_step_data
 {
-  unsigned char *outbuf;    /* Output buffer for this step.  */
-  unsigned char *outbufend; /* Address of first byte after the output buffer.*/
+  unsigned char *__outbuf;    /* Output buffer for this step.  */
+  unsigned char *__outbufend; /* Address of first byte after the output
+				 buffer.*/
 
   /* Is this the last module in the chain.  */
-  int is_last;
+  int __is_last;
 
   /* Counter for number of invocations of the module function for this
      descriptor.  */
-  int invocation_counter;
+  int __invocation_counter;
 
   /* Flag whether this is an internal use of the module (in the mb*towc*
      and wc*tomb* functions) or regular with iconv(3).  */
-  int internal_use;
+  int __internal_use;
 
-  mbstate_t *statep;
-  mbstate_t __state;	/* This element should not be used directly by
+  __mbstate_t *__statep;
+  __mbstate_t __state;	/* This element should not be used directly by
 			   any module; always use STATEP!  */
 };
 
 
 /* Combine conversion step description with data.  */
-typedef struct gconv_info
+typedef struct __gconv_info
 {
-  size_t nsteps;
-  struct gconv_step *steps;
-  struct gconv_step_data data[0];
-} *gconv_t;
+  size_t __nsteps;
+  struct __gconv_step *__steps;
+  struct __gconv_step_data __data[0];
+} *__gconv_t;
 
 #endif /* gconv.h */
diff --git a/iconv/gconv_builtin.c b/iconv/gconv_builtin.c
index 4f3ca565ac..ca3ca3e5e6 100644
--- a/iconv/gconv_builtin.c
+++ b/iconv/gconv_builtin.c
@@ -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;
 }
diff --git a/iconv/gconv_close.c b/iconv/gconv_close.c
index 2fe842467b..a22123b1c9 100644
--- a/iconv/gconv_close.c
+++ b/iconv/gconv_close.c
@@ -25,23 +25,23 @@
 
 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);
diff --git a/iconv/gconv_db.c b/iconv/gconv_db.c
index 4abc1ae48b..727be41c25 100644
--- a/iconv/gconv_db.c
+++ b/iconv/gconv_db.c
@@ -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.  */
diff --git a/iconv/gconv_dl.c b/iconv/gconv_dl.c
index 52cf9d3064..dc90986077 100644
--- a/iconv/gconv_dl.c
+++ b/iconv/gconv_dl.c
@@ -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
diff --git a/iconv/gconv_int.h b/iconv/gconv_int.h
index 9b00e6522c..29f495c30f 100644
--- a/iconv/gconv_int.h
+++ b/iconv/gconv_int.h
@@ -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)
diff --git a/iconv/gconv_open.c b/iconv/gconv_open.c
index f3b6dfa86e..e10abbbd4f 100644
--- a/iconv/gconv_open.c
+++ b/iconv/gconv_open.c
@@ -26,31 +26,32 @@
 
 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;
diff --git a/iconv/gconv_simple.c b/iconv/gconv_simple.c
index 74dbfc0356..3f9df34de2 100644
--- a/iconv/gconv_simple.c
+++ b/iconv/gconv_simple.c
@@ -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;							      \
 	  }								      \
 									      \
diff --git a/iconv/iconv.c b/iconv/iconv.c
index a6c84367a7..85a39e3fa5 100644
--- a/iconv/iconv.c
+++ b/iconv/iconv.c
@@ -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;
 
diff --git a/iconv/iconv_close.c b/iconv/iconv_close.c
index d3974c5799..6f81aa2595 100644
--- a/iconv/iconv_close.c
+++ b/iconv/iconv_close.c
@@ -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;
 }
diff --git a/iconv/iconv_open.c b/iconv/iconv_open.c
index 51dcf0baaa..e566c6a544 100644
--- a/iconv/iconv_open.c
+++ b/iconv/iconv_open.c
@@ -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;
diff --git a/iconv/loop.c b/iconv/loop.c
index eac4c758e0..ada4f0a755 100644
--- a/iconv/loop.c
+++ b/iconv/loop.c
@@ -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;
 	    }
 
diff --git a/iconv/skeleton.c b/iconv/skeleton.c
index a9fc2495f1..cd750ba8ae 100644
--- a/iconv/skeleton.c
+++ b/iconv/skeleton.c
@@ -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;