Use mkdir -p instead of test -d + mkdir.
[kopensolaris-gnu/glibc.git] / intl / dcigettext.c
index dcdc93c..f294ded 100644 (file)
@@ -1,20 +1,21 @@
 /* Implementation of the internal dcigettext function.
 /* Implementation of the internal dcigettext function.
-   Copyright (C) 1995-1999, 2000, 2001 Free Software Foundation, Inc.
+   Copyright (C) 1995-2002,2003,2004,2005 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
 
    The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
 
    The GNU C Library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
    The GNU C Library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
+   Lesser General Public License for more details.
 
 
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
 
 /* Tell glibc's <string.h> to provide a prototype for mempcpy().
    This must come before <config.h> because <config.h> may include
 
 /* Tell glibc's <string.h> to provide a prototype for mempcpy().
    This must come before <config.h> because <config.h> may include
 
 #include <sys/types.h>
 
 
 #include <sys/types.h>
 
-#if defined __GNUC__ && !defined C_ALLOCA
+#ifdef __GNUC__
 # define alloca __builtin_alloca
 # define HAVE_ALLOCA 1
 #else
 # define alloca __builtin_alloca
 # define HAVE_ALLOCA 1
 #else
-# if (defined HAVE_ALLOCA_H || defined _LIBC) && !defined C_ALLOCA
+# if defined HAVE_ALLOCA_H || defined _LIBC
 #  include <alloca.h>
 # else
 #  ifdef _AIX
 #  include <alloca.h>
 # else
 #  ifdef _AIX
@@ -54,42 +55,22 @@ extern int errno;
 # define __set_errno(val) errno = (val)
 #endif
 
 # define __set_errno(val) errno = (val)
 #endif
 
-#if defined STDC_HEADERS || defined _LIBC
-# include <stddef.h>
-# include <stdlib.h>
-#else
-char *getenv ();
-# ifdef HAVE_MALLOC_H
-#  include <malloc.h>
-# else
-void free ();
-# endif
-#endif
-
-#if defined HAVE_STRING_H || defined _LIBC
-# include <string.h>
-#else
-# include <strings.h>
-#endif
-#if !HAVE_STRCHR && !defined _LIBC
-# ifndef strchr
-#  define strchr index
-# endif
-#endif
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
 
 #if defined HAVE_UNISTD_H || defined _LIBC
 # include <unistd.h>
 #endif
 
 
 #if defined HAVE_UNISTD_H || defined _LIBC
 # include <unistd.h>
 #endif
 
-#if defined HAVE_LOCALE_H || defined _LIBC
-# include <locale.h>
-#endif
+#include <locale.h>
 
 #if defined HAVE_SYS_PARAM_H || defined _LIBC
 # include <sys/param.h>
 #endif
 
 #include "gettextP.h"
 
 #if defined HAVE_SYS_PARAM_H || defined _LIBC
 # include <sys/param.h>
 #endif
 
 #include "gettextP.h"
+#include "plural-exp.h"
 #ifdef _LIBC
 # include <libintl.h>
 #else
 #ifdef _LIBC
 # include <libintl.h>
 #else
@@ -122,10 +103,10 @@ void free ();
    names than the internal variables in GNU libc, otherwise programs
    using libintl.a cannot be linked statically.  */
 #if !defined _LIBC
    names than the internal variables in GNU libc, otherwise programs
    using libintl.a cannot be linked statically.  */
 #if !defined _LIBC
-# define _nl_default_default_domain _nl_default_default_domain__
-# define _nl_current_default_domain _nl_current_default_domain__
-# define _nl_default_dirname _nl_default_dirname__
-# define _nl_domain_bindings _nl_domain_bindings__
+# define _nl_default_default_domain libintl_nl_default_default_domain
+# define _nl_current_default_domain libintl_nl_current_default_domain
+# define _nl_default_dirname libintl_nl_default_dirname
+# define _nl_domain_bindings libintl_nl_domain_bindings
 #endif
 
 /* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>.  */
 #endif
 
 /* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>.  */
@@ -191,14 +172,9 @@ static void *mempcpy PARAMS ((void *dest, const void *src, size_t n));
 # define PATH_MAX _POSIX_PATH_MAX
 #endif
 
 # define PATH_MAX _POSIX_PATH_MAX
 #endif
 
-/* XPG3 defines the result of `setlocale (category, NULL)' as:
-   ``Directs `setlocale()' to query `category' and return the current
-     setting of `local'.''
-   However it does not specify the exact format.  Neither do SUSV2 and
-   ISO C 99.  So we can use this feature only on selected systems (e.g.
-   those using GNU C Library).  */
-#ifdef _LIBC
-# define HAVE_LOCALE_NULL
+/* Whether to support different locales in different threads.  */
+#if defined _LIBC || HAVE_NL_LOCALE_NAME
+# define HAVE_PER_THREAD_LOCALE
 #endif
 
 /* This is the type used for the search tree where known translations
 #endif
 
 /* This is the type used for the search tree where known translations
@@ -206,11 +182,16 @@ static void *mempcpy PARAMS ((void *dest, const void *src, size_t n));
 struct known_translation_t
 {
   /* Domain in which to search.  */
 struct known_translation_t
 {
   /* Domain in which to search.  */
-  char *domainname;
+  const char *domainname;
 
   /* The category.  */
   int category;
 
 
   /* The category.  */
   int category;
 
+#ifdef HAVE_PER_THREAD_LOCALE
+  /* Name of the relevant locale category, or "" for the global locale.  */
+  const char *localename;
+#endif
+
   /* State of the catalog counter at the point the string was found.  */
   int counter;
 
   /* State of the catalog counter at the point the string was found.  */
   int counter;
 
@@ -255,10 +236,16 @@ transcmp (p1, p2)
     {
       result = strcmp (s1->domainname, s2->domainname);
       if (result == 0)
     {
       result = strcmp (s1->domainname, s2->domainname);
       if (result == 0)
-       /* We compare the category last (though this is the cheapest
-          operation) since it is hopefully always the same (namely
-          LC_MESSAGES).  */
-       result = s1->category - s2->category;
+       {
+#ifdef HAVE_PER_THREAD_LOCALE
+         result = strcmp (s1->localename, s2->localename);
+         if (result == 0)
+#endif
+           /* We compare the category last (though this is the cheapest
+              operation) since it is hopefully always the same (namely
+              LC_MESSAGES).  */
+           result = s1->category - s2->category;
+       }
     }
 
   return result;
     }
 
   return result;
@@ -267,13 +254,22 @@ transcmp (p1, p2)
 
 /* Name of the default domain used for gettext(3) prior any call to
    textdomain(3).  The default value for this is "messages".  */
 
 /* Name of the default domain used for gettext(3) prior any call to
    textdomain(3).  The default value for this is "messages".  */
-const char _nl_default_default_domain[] = "messages";
+const char _nl_default_default_domain[] attribute_hidden = "messages";
 
 /* Value used as the default domain for gettext(3).  */
 
 /* Value used as the default domain for gettext(3).  */
-const char *_nl_current_default_domain = _nl_default_default_domain;
+const char *_nl_current_default_domain attribute_hidden
+     = _nl_default_default_domain;
 
 /* Contains the default location of the message catalogs.  */
 
 /* Contains the default location of the message catalogs.  */
+
+#ifdef _LIBC
+extern const char _nl_default_dirname[];
+libc_hidden_proto (_nl_default_dirname)
+#endif
 const char _nl_default_dirname[] = LOCALEDIR;
 const char _nl_default_dirname[] = LOCALEDIR;
+#ifdef _LIBC
+libc_hidden_data_def (_nl_default_dirname)
+#endif
 
 /* List with bindings of specific domains created by bindtextdomain()
    calls.  */
 
 /* List with bindings of specific domains created by bindtextdomain()
    calls.  */
@@ -285,19 +281,22 @@ static char *plural_lookup PARAMS ((struct loaded_l10nfile *domain,
                                    const char *translation,
                                    size_t translation_len))
      internal_function;
                                    const char *translation,
                                    size_t translation_len))
      internal_function;
-static unsigned long int plural_eval PARAMS ((struct expression *pexp,
-                                             unsigned long int n))
-     internal_function;
-static const char *category_to_name PARAMS ((int category)) internal_function;
 static const char *guess_category_value PARAMS ((int category,
                                                 const char *categoryname))
      internal_function;
 static const char *guess_category_value PARAMS ((int category,
                                                 const char *categoryname))
      internal_function;
+#ifdef _LIBC
+# include "../locale/localeinfo.h"
+# define category_to_name(category)    _nl_category_names[category]
+#else
+static const char *category_to_name PARAMS ((int category)) internal_function;
+#endif
 
 
 /* For those loosing systems which don't have `alloca' we have to add
    some additional code emulating it.  */
 #ifdef HAVE_ALLOCA
 /* Nothing has to be done.  */
 
 
 /* For those loosing systems which don't have `alloca' we have to add
    some additional code emulating it.  */
 #ifdef HAVE_ALLOCA
 /* Nothing has to be done.  */
+# define freea(p) /* nothing */
 # define ADD_BLOCK(list, address) /* nothing */
 # define FREE_BLOCKS(list) /* nothing */
 #else
 # define ADD_BLOCK(list, address) /* nothing */
 # define FREE_BLOCKS(list) /* nothing */
 #else
@@ -322,11 +321,13 @@ struct block_list
     while (list != NULL) {                                                   \
       struct block_list *old = list;                                         \
       list = list->next;                                                     \
     while (list != NULL) {                                                   \
       struct block_list *old = list;                                         \
       list = list->next;                                                     \
+      free (old->address);                                                   \
       free (old);                                                            \
     }                                                                        \
   } while (0)
 # undef alloca
 # define alloca(size) (malloc (size))
       free (old);                                                            \
     }                                                                        \
   } while (0)
 # undef alloca
 # define alloca(size) (malloc (size))
+# define freea(p) free (p)
 #endif /* have alloca */
 
 
 #endif /* have alloca */
 
 
@@ -341,6 +342,10 @@ static struct transmem_list *transmem_list;
 #else
 typedef unsigned char transmem_block_t;
 #endif
 #else
 typedef unsigned char transmem_block_t;
 #endif
+#if defined _LIBC || HAVE_ICONV
+static const char *get_output_charset PARAMS ((struct binding *domainbinding))
+     internal_function;
+#endif
 
 
 /* Names for the libintl functions are a problem.  They must not clash
 
 
 /* Names for the libintl functions are a problem.  They must not clash
@@ -350,11 +355,13 @@ typedef unsigned char transmem_block_t;
 #ifdef _LIBC
 # define DCIGETTEXT __dcigettext
 #else
 #ifdef _LIBC
 # define DCIGETTEXT __dcigettext
 #else
-# define DCIGETTEXT dcigettext__
+# define DCIGETTEXT libintl_dcigettext
 #endif
 
 /* Lock variable to protect the global data in the gettext implementation.  */
 #endif
 
 /* Lock variable to protect the global data in the gettext implementation.  */
-__libc_rwlock_define_initialized (, _nl_state_lock)
+#ifdef _LIBC
+__libc_rwlock_define_initialized (, _nl_state_lock attribute_hidden)
+#endif
 
 /* Checking whether the binaries runs SUID must be done and glibc provides
    easier methods therefore we make a difference here.  */
 
 /* Checking whether the binaries runs SUID must be done and glibc provides
    easier methods therefore we make a difference here.  */
@@ -362,6 +369,18 @@ __libc_rwlock_define_initialized (, _nl_state_lock)
 # define ENABLE_SECURE __libc_enable_secure
 # define DETERMINE_SECURE
 #else
 # define ENABLE_SECURE __libc_enable_secure
 # define DETERMINE_SECURE
 #else
+# ifndef HAVE_GETUID
+#  define getuid() 0
+# endif
+# ifndef HAVE_GETGID
+#  define getgid() 0
+# endif
+# ifndef HAVE_GETEUID
+#  define geteuid() getuid()
+# endif
+# ifndef HAVE_GETEGID
+#  define getegid() getgid()
+# endif
 static int enable_secure;
 # define ENABLE_SECURE (enable_secure == 1)
 # define DETERMINE_SECURE \
 static int enable_secure;
 # define ENABLE_SECURE (enable_secure == 1)
 # define DETERMINE_SECURE \
@@ -374,6 +393,9 @@ static int enable_secure;
     }
 #endif
 
     }
 #endif
 
+/* Get the function to evaluate the plural expression.  */
+#include "plural-eval.c"
+
 /* Look up MSGID in the DOMAINNAME message catalog for the current
    CATEGORY locale and, if PLURAL is nonzero, search over string
    depending on the plural form determined by N.  */
 /* Look up MSGID in the DOMAINNAME message catalog for the current
    CATEGORY locale and, if PLURAL is nonzero, search over string
    depending on the plural form determined by N.  */
@@ -402,6 +424,9 @@ DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
   struct known_translation_t *search;
   struct known_translation_t **foundp = NULL;
   size_t msgid_len;
   struct known_translation_t *search;
   struct known_translation_t **foundp = NULL;
   size_t msgid_len;
+# ifdef HAVE_PER_THREAD_LOCALE
+  const char *localename;
+# endif
 #endif
   size_t domainname_len;
 
 #endif
   size_t domainname_len;
 
@@ -409,6 +434,15 @@ DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
   if (msgid1 == NULL)
     return NULL;
 
   if (msgid1 == NULL)
     return NULL;
 
+#ifdef _LIBC
+  if (category < 0 || category >= __LC_LAST || category == LC_ALL)
+    /* Bogus.  */
+    return (plural == 0
+           ? (char *) msgid1
+           /* Use the Germanic plural rule.  */
+           : n == 1 ? (char *) msgid1 : (char *) msgid2);
+#endif
+
   __libc_rwlock_rdlock (_nl_state_lock);
 
   /* If DOMAINNAME is NULL, we are interested in the default domain.  If
   __libc_rwlock_rdlock (_nl_state_lock);
 
   /* If DOMAINNAME is NULL, we are interested in the default domain.  If
@@ -425,10 +459,25 @@ DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
   search = (struct known_translation_t *)
           alloca (offsetof (struct known_translation_t, msgid) + msgid_len);
   memcpy (search->msgid, msgid1, msgid_len);
   search = (struct known_translation_t *)
           alloca (offsetof (struct known_translation_t, msgid) + msgid_len);
   memcpy (search->msgid, msgid1, msgid_len);
-  search->domainname = (char *) domainname;
+  search->domainname = domainname;
   search->category = category;
   search->category = category;
+# ifdef HAVE_PER_THREAD_LOCALE
+#  ifdef _LIBC
+  localename = __current_locale_name (category);
+#  endif
+  search->localename = localename;
+# endif
+
+  /* Since tfind/tsearch manage a balanced tree, concurrent tfind and
+     tsearch calls can be fatal.  */
+  __libc_rwlock_define_initialized (static, tree_lock);
+  __libc_rwlock_rdlock (tree_lock);
 
   foundp = (struct known_translation_t **) tfind (search, &root, transcmp);
 
   foundp = (struct known_translation_t **) tfind (search, &root, transcmp);
+
+  __libc_rwlock_unlock (tree_lock);
+
+  freea (search);
   if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
     {
       /* Now deal with plural.  */
   if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
     {
       /* Now deal with plural.  */
@@ -478,16 +527,18 @@ DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
       path_max = (unsigned int) PATH_MAX;
       path_max += 2;           /* The getcwd docs say to do this.  */
 
       path_max = (unsigned int) PATH_MAX;
       path_max += 2;           /* The getcwd docs say to do this.  */
 
-      dirname = (char *) alloca (path_max + dirname_len);
-      ADD_BLOCK (block_list, dirname);
-
-      __set_errno (0);
-      while ((ret = getcwd (dirname, path_max)) == NULL && errno == ERANGE)
+      for (;;)
        {
        {
-         path_max += PATH_INCR;
          dirname = (char *) alloca (path_max + dirname_len);
          ADD_BLOCK (block_list, dirname);
          dirname = (char *) alloca (path_max + dirname_len);
          ADD_BLOCK (block_list, dirname);
+
          __set_errno (0);
          __set_errno (0);
+         ret = getcwd (dirname, path_max);
+         if (ret != NULL || errno != ERANGE)
+           break;
+
+         path_max += path_max / 2;
+         path_max += PATH_INCR;
        }
 
       if (ret == NULL)
        }
 
       if (ret == NULL)
@@ -495,6 +546,7 @@ DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
          /* We cannot get the current working directory.  Don't signal an
             error but simply return the default string.  */
          FREE_BLOCKS (block_list);
          /* We cannot get the current working directory.  Don't signal an
             error but simply return the default string.  */
          FREE_BLOCKS (block_list);
+         __libc_rwlock_unlock (_nl_state_lock);
          __set_errno (saved_errno);
          return (plural == 0
                  ? (char *) msgid1
          __set_errno (saved_errno);
          return (plural == 0
                  ? (char *) msgid1
@@ -574,7 +626,7 @@ DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
 
       if (domain != NULL)
        {
 
       if (domain != NULL)
        {
-         retval = _nl_find_msg (domain, msgid1, &retlen);
+         retval = _nl_find_msg (domain, binding, msgid1, 1, &retlen);
 
          if (retval == NULL)
            {
 
          if (retval == NULL)
            {
@@ -582,8 +634,8 @@ DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
 
              for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
                {
 
              for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
                {
-                 retval = _nl_find_msg (domain->successor[cnt], msgid1,
-                                        &retlen);
+                 retval = _nl_find_msg (domain->successor[cnt], binding,
+                                        msgid1, 1, &retlen);
 
                  if (retval != NULL)
                    {
 
                  if (retval != NULL)
                    {
@@ -598,30 +650,50 @@ DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
              /* Found the translation of MSGID1 in domain DOMAIN:
                 starting at RETVAL, RETLEN bytes.  */
              FREE_BLOCKS (block_list);
              /* Found the translation of MSGID1 in domain DOMAIN:
                 starting at RETVAL, RETLEN bytes.  */
              FREE_BLOCKS (block_list);
-             __set_errno (saved_errno);
 #if defined HAVE_TSEARCH || defined _LIBC
              if (foundp == NULL)
                {
                  /* Create a new entry and add it to the search tree.  */
 #if defined HAVE_TSEARCH || defined _LIBC
              if (foundp == NULL)
                {
                  /* Create a new entry and add it to the search tree.  */
+                 size_t size;
                  struct known_translation_t *newp;
 
                  struct known_translation_t *newp;
 
-                 newp = (struct known_translation_t *)
-                   malloc (offsetof (struct known_translation_t, msgid)
-                           + msgid_len + domainname_len + 1);
+                 size = offsetof (struct known_translation_t, msgid)
+                        + msgid_len + domainname_len + 1;
+# ifdef HAVE_PER_THREAD_LOCALE
+                 size += strlen (localename) + 1;
+# endif
+                 newp = (struct known_translation_t *) malloc (size);
                  if (newp != NULL)
                    {
                  if (newp != NULL)
                    {
-                     newp->domainname =
-                       mempcpy (newp->msgid, msgid1, msgid_len);
-                     memcpy (newp->domainname, domainname, domainname_len + 1);
+                     char *new_domainname;
+# ifdef HAVE_PER_THREAD_LOCALE
+                     char *new_localename;
+# endif
+
+                     new_domainname = mempcpy (newp->msgid, msgid1, msgid_len);
+                     memcpy (new_domainname, domainname, domainname_len + 1);
+# ifdef HAVE_PER_THREAD_LOCALE
+                     new_localename = new_domainname + domainname_len + 1;
+                     strcpy (new_localename, localename);
+# endif
+                     newp->domainname = new_domainname;
                      newp->category = category;
                      newp->category = category;
+# ifdef HAVE_PER_THREAD_LOCALE
+                     newp->localename = new_localename;
+# endif
                      newp->counter = _nl_msg_cat_cntr;
                      newp->domain = domain;
                      newp->translation = retval;
                      newp->translation_length = retlen;
 
                      newp->counter = _nl_msg_cat_cntr;
                      newp->domain = domain;
                      newp->translation = retval;
                      newp->translation_length = retlen;
 
+                     __libc_rwlock_wrlock (tree_lock);
+
                      /* Insert the entry in the search tree.  */
                      foundp = (struct known_translation_t **)
                        tsearch (newp, &root, transcmp);
                      /* Insert the entry in the search tree.  */
                      foundp = (struct known_translation_t **)
                        tsearch (newp, &root, transcmp);
+
+                     __libc_rwlock_unlock (tree_lock);
+
                      if (foundp == NULL
                          || __builtin_expect (*foundp != newp, 0))
                        /* The insert failed.  */
                      if (foundp == NULL
                          || __builtin_expect (*foundp != newp, 0))
                        /* The insert failed.  */
@@ -637,6 +709,8 @@ DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
                  (*foundp)->translation_length = retlen;
                }
 #endif
                  (*foundp)->translation_length = retlen;
                }
 #endif
+             __set_errno (saved_errno);
+
              /* Now deal with plural.  */
              if (plural)
                retval = plural_lookup (domain, n, retval, retlen);
              /* Now deal with plural.  */
              if (plural)
                retval = plural_lookup (domain, n, retval, retlen);
@@ -652,51 +726,64 @@ DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
 
 char *
 internal_function
 
 char *
 internal_function
-_nl_find_msg (domain_file, msgid, lengthp)
+_nl_find_msg (domain_file, domainbinding, msgid, convert, lengthp)
      struct loaded_l10nfile *domain_file;
      struct loaded_l10nfile *domain_file;
+     struct binding *domainbinding;
      const char *msgid;
      const char *msgid;
+     int convert;
      size_t *lengthp;
 {
   struct loaded_domain *domain;
      size_t *lengthp;
 {
   struct loaded_domain *domain;
+  nls_uint32 nstrings;
   size_t act;
   char *result;
   size_t resultlen;
 
   size_t act;
   char *result;
   size_t resultlen;
 
-  if (domain_file->decided == 0)
-    _nl_load_domain (domain_file);
+  if (domain_file->decided <= 0)
+    _nl_load_domain (domain_file, domainbinding);
 
   if (domain_file->data == NULL)
     return NULL;
 
   domain = (struct loaded_domain *) domain_file->data;
 
 
   if (domain_file->data == NULL)
     return NULL;
 
   domain = (struct loaded_domain *) domain_file->data;
 
+  nstrings = domain->nstrings;
+
   /* Locate the MSGID and its translation.  */
   /* Locate the MSGID and its translation.  */
-  if (domain->hash_size > 2 && domain->hash_tab != NULL)
+  if (domain->hash_tab != NULL)
     {
       /* Use the hashing table.  */
       nls_uint32 len = strlen (msgid);
     {
       /* Use the hashing table.  */
       nls_uint32 len = strlen (msgid);
-      nls_uint32 hash_val = hash_string (msgid);
+      nls_uint32 hash_val = __hash_string (msgid);
       nls_uint32 idx = hash_val % domain->hash_size;
       nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));
 
       while (1)
        {
       nls_uint32 idx = hash_val % domain->hash_size;
       nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));
 
       while (1)
        {
-         nls_uint32 nstr = W (domain->must_swap, domain->hash_tab[idx]);
+         nls_uint32 nstr =
+           W (domain->must_swap_hash_tab, domain->hash_tab[idx]);
 
          if (nstr == 0)
            /* Hash table entry is empty.  */
            return NULL;
 
 
          if (nstr == 0)
            /* Hash table entry is empty.  */
            return NULL;
 
-         /* Compare msgid with the original string at index nstr-1.
+         nstr--;
+
+         /* Compare msgid with the original string at index nstr.
             We compare the lengths with >=, not ==, because plural entries
             are represented by strings with an embedded NUL.  */
             We compare the lengths with >=, not ==, because plural entries
             are represented by strings with an embedded NUL.  */
-         if (W (domain->must_swap, domain->orig_tab[nstr - 1].length) >= len
-             && (strcmp (msgid,
-                         domain->data + W (domain->must_swap,
-                                           domain->orig_tab[nstr - 1].offset))
-                 == 0))
+         if (nstr < nstrings
+             ? W (domain->must_swap, domain->orig_tab[nstr].length) >= len
+               && (strcmp (msgid,
+                           domain->data + W (domain->must_swap,
+                                             domain->orig_tab[nstr].offset))
+                   == 0)
+             : domain->orig_sysdep_tab[nstr - nstrings].length > len
+               && (strcmp (msgid,
+                           domain->orig_sysdep_tab[nstr - nstrings].pointer)
+                   == 0))
            {
            {
-             act = nstr - 1;
+             act = nstr;
              goto found;
            }
 
              goto found;
            }
 
@@ -714,7 +801,7 @@ _nl_find_msg (domain_file, msgid, lengthp)
       size_t top, bottom;
 
       bottom = 0;
       size_t top, bottom;
 
       bottom = 0;
-      top = domain->nstrings;
+      top = nstrings;
       while (bottom < top)
        {
          int cmp_val;
       while (bottom < top)
        {
          int cmp_val;
@@ -737,186 +824,330 @@ _nl_find_msg (domain_file, msgid, lengthp)
  found:
   /* The translation was found at index ACT.  If we have to convert the
      string to use a different character set, this is the time.  */
  found:
   /* The translation was found at index ACT.  If we have to convert the
      string to use a different character set, this is the time.  */
-  result = ((char *) domain->data
-           + W (domain->must_swap, domain->trans_tab[act].offset));
-  resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
+  if (act < nstrings)
+    {
+      result = (char *)
+       (domain->data + W (domain->must_swap, domain->trans_tab[act].offset));
+      resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
+    }
+  else
+    {
+      result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer;
+      resultlen = domain->trans_sysdep_tab[act - nstrings].length;
+    }
 
 #if defined _LIBC || HAVE_ICONV
 
 #if defined _LIBC || HAVE_ICONV
-  if (
+  if (convert)
+    {
+      /* We are supposed to do a conversion.  */
+      const char *encoding = get_output_charset (domainbinding);
+
+      /* Search whether a table with converted translations for this
+        encoding has already been allocated.  */
+      size_t nconversions = domain->nconversions;
+      struct converted_domain *convd = NULL;
+      size_t i;
+
+      for (i = nconversions; i > 0; )
+       {
+         i--;
+         if (strcmp (domain->conversions[i].encoding, encoding) == 0)
+           {
+             convd = &domain->conversions[i];
+             break;
+           }
+       }
+
+      if (convd == NULL)
+       {
+         /* Allocate a table for the converted translations for this
+            encoding.  */
+         struct converted_domain *new_conversions =
+           (struct converted_domain *)
+           (domain->conversions != NULL
+            ? realloc (domain->conversions,
+                       (nconversions + 1) * sizeof (struct converted_domain))
+            : malloc ((nconversions + 1) * sizeof (struct converted_domain)));
+
+         if (__builtin_expect (new_conversions == NULL, 0))
+           /* Nothing we can do, no more memory.  */
+           goto converted;
+         domain->conversions = new_conversions;
+
+         /* Copy the 'encoding' string to permanent storage.  */
+         encoding = strdup (encoding);
+         if (__builtin_expect (encoding == NULL, 0))
+           /* Nothing we can do, no more memory.  */
+           goto converted;
+
+         convd = &new_conversions[nconversions];
+         convd->encoding = encoding;
+
+         /* Find out about the character set the file is encoded with.
+            This can be found (in textual form) in the entry "".  If this
+            entry does not exist or if this does not contain the 'charset='
+            information, we will assume the charset matches the one the
+            current locale and we don't have to perform any conversion.  */
 # ifdef _LIBC
 # ifdef _LIBC
-      domain->conv != (__gconv_t) -1
+         convd->conv = (__gconv_t) -1;
 # else
 #  if HAVE_ICONV
 # else
 #  if HAVE_ICONV
-      domain->conv != (iconv_t) -1
+         convd->conv = (iconv_t) -1;
 #  endif
 # endif
 #  endif
 # endif
-      )
-    {
-      /* We are supposed to do a conversion.  First allocate an
-        appropriate table with the same structure as the table
-        of translations in the file, where we can put the pointers
-        to the converted strings in.
-        There is a slight complication with plural entries.  They
-        are represented by consecutive NUL terminated strings.  We
-        handle this case by converting RESULTLEN bytes, including
-        NULs.  */
-
-      if (domain->conv_tab == NULL
-         && ((domain->conv_tab = (char **) calloc (domain->nstrings,
-                                                   sizeof (char *)))
-             == NULL))
-       /* Mark that we didn't succeed allocating a table.  */
-       domain->conv_tab = (char **) -1;
-
-      if (__builtin_expect (domain->conv_tab == (char **) -1, 0))
-       /* Nothing we can do, no more memory.  */
-       goto converted;
-
-      if (domain->conv_tab[act] == NULL)
+         {
+           char *nullentry;
+           size_t nullentrylen;
+
+           /* Get the header entry.  This is a recursion, but it doesn't
+              reallocate domain->conversions because we pass convert = 0.  */
+           nullentry =
+             _nl_find_msg (domain_file, domainbinding, "", 0, &nullentrylen);
+
+           if (nullentry != NULL)
+             {
+               const char *charsetstr;
+
+               charsetstr = strstr (nullentry, "charset=");
+               if (charsetstr != NULL)
+                 {
+                   size_t len;
+                   char *charset;
+                   const char *outcharset;
+
+                   charsetstr += strlen ("charset=");
+                   len = strcspn (charsetstr, " \t\n");
+
+                   charset = (char *) alloca (len + 1);
+# if defined _LIBC || HAVE_MEMPCPY
+                   *((char *) mempcpy (charset, charsetstr, len)) = '\0';
+# else
+                   memcpy (charset, charsetstr, len);
+                   charset[len] = '\0';
+# endif
+
+                   outcharset = encoding;
+
+# ifdef _LIBC
+                   /* We always want to use transliteration.  */
+                   outcharset = norm_add_slashes (outcharset, "TRANSLIT");
+                   charset = norm_add_slashes (charset, "");
+                   if (__gconv_open (outcharset, charset, &convd->conv,
+                                     GCONV_AVOID_NOCONV)
+                       != __GCONV_OK)
+                     convd->conv = (__gconv_t) -1;
+# else
+#  if HAVE_ICONV
+                   /* When using GNU libc >= 2.2 or GNU libiconv >= 1.5,
+                      we want to use transliteration.  */
+#   if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2 \
+       || _LIBICONV_VERSION >= 0x0105
+                   if (strchr (outcharset, '/') == NULL)
+                     {
+                       char *tmp;
+
+                       len = strlen (outcharset);
+                       tmp = (char *) alloca (len + 10 + 1);
+                       memcpy (tmp, outcharset, len);
+                       memcpy (tmp + len, "//TRANSLIT", 10 + 1);
+                       outcharset = tmp;
+
+                       convd->conv = iconv_open (outcharset, charset);
+
+                       freea (outcharset);
+                     }
+                   else
+#   endif
+                     convd->conv = iconv_open (outcharset, charset);
+#  endif
+# endif
+
+                   freea (charset);
+                 }
+             }
+         }
+         convd->conv_tab = NULL;
+         /* Here domain->conversions is still == new_conversions.  */
+         domain->nconversions++;
+       }
+
+      if (
+# ifdef _LIBC
+         convd->conv != (__gconv_t) -1
+# else
+#  if HAVE_ICONV
+         convd->conv != (iconv_t) -1
+#  endif
+# endif
+         )
        {
        {
-         /* We haven't used this string so far, so it is not
-            translated yet.  Do this now.  */
-         /* We use a bit more efficient memory handling.
-            We allocate always larger blocks which get used over
-            time.  This is faster than many small allocations.   */
-         __libc_lock_define_initialized (static, lock)
+         /* We are supposed to do a conversion.  First allocate an
+            appropriate table with the same structure as the table
+            of translations in the file, where we can put the pointers
+            to the converted strings in.
+            There is a slight complication with plural entries.  They
+            are represented by consecutive NUL terminated strings.  We
+            handle this case by converting RESULTLEN bytes, including
+            NULs.  */
+
+         if (convd->conv_tab == NULL
+             && ((convd->conv_tab =
+                   (char **) calloc (nstrings + domain->n_sysdep_strings,
+                                     sizeof (char *)))
+                 == NULL))
+           /* Mark that we didn't succeed allocating a table.  */
+           convd->conv_tab = (char **) -1;
+
+         if (__builtin_expect (convd->conv_tab == (char **) -1, 0))
+           /* Nothing we can do, no more memory.  */
+           goto converted;
+
+         if (convd->conv_tab[act] == NULL)
+           {
+             /* We haven't used this string so far, so it is not
+                translated yet.  Do this now.  */
+             /* We use a bit more efficient memory handling.
+                We allocate always larger blocks which get used over
+                time.  This is faster than many small allocations.   */
+             __libc_lock_define_initialized (static, lock)
 # define INITIAL_BLOCK_SIZE    4080
 # define INITIAL_BLOCK_SIZE    4080
-         static unsigned char *freemem;
-         static size_t freemem_size;
+             static unsigned char *freemem;
+             static size_t freemem_size;
 
 
-         const unsigned char *inbuf;
-         unsigned char *outbuf;
-         int malloc_count;
+             const unsigned char *inbuf;
+             unsigned char *outbuf;
+             int malloc_count;
 # ifndef _LIBC
 # ifndef _LIBC
-         transmem_block_t *transmem_list = NULL;
+             transmem_block_t *transmem_list = NULL;
 # endif
 
 # endif
 
-         __libc_lock_lock (lock);
+             __libc_lock_lock (lock);
 
 
-         inbuf = (const unsigned char *) result;
-         outbuf = freemem + sizeof (size_t);
+             inbuf = (const unsigned char *) result;
+             outbuf = freemem + sizeof (size_t);
 
 
-         malloc_count = 0;
-         while (1)
-           {
-             transmem_block_t *newmem;
+             malloc_count = 0;
+             while (1)
+               {
+                 transmem_block_t *newmem;
 # ifdef _LIBC
 # ifdef _LIBC
-             size_t non_reversible;
-             int res;
+                 size_t non_reversible;
+                 int res;
 
 
-             if (freemem_size < sizeof (size_t))
-               goto resize_freemem;
+                 if (freemem_size < sizeof (size_t))
+                   goto resize_freemem;
 
 
-             res = __gconv (domain->conv,
-                            &inbuf, inbuf + resultlen,
-                            &outbuf,
-                            outbuf + freemem_size - sizeof (size_t),
-                            &non_reversible);
+                 res = __gconv (convd->conv,
+                                &inbuf, inbuf + resultlen,
+                                &outbuf,
+                                outbuf + freemem_size - sizeof (size_t),
+                                &non_reversible);
 
 
-             if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
-               break;
+                 if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
+                   break;
 
 
-             if (res != __GCONV_FULL_OUTPUT)
-               {
-                 __libc_lock_unlock (lock);
-                 goto converted;
-               }
+                 if (res != __GCONV_FULL_OUTPUT)
+                   {
+                     __libc_lock_unlock (lock);
+                     goto converted;
+                   }
 
 
-             inbuf = result;
+                 inbuf = (const unsigned char *) result;
 # else
 #  if HAVE_ICONV
 # else
 #  if HAVE_ICONV
-             const char *inptr = (const char *) inbuf;
-             size_t inleft = resultlen;
-             char *outptr = (char *) outbuf;
-             size_t outleft;
-
-             if (freemem_size < sizeof (size_t))
-               goto resize_freemem;
-
-             outleft = freemem_size - sizeof (size_t);
-             if (iconv (domain->conv,
-                        (ICONV_CONST char **) &inptr, &inleft,
-                        &outptr, &outleft)
-                 != (size_t) (-1))
-               {
-                 outbuf = (unsigned char *) outptr;
-                 break;
-               }
-             if (errno != E2BIG)
-               {
-                 __libc_lock_unlock (lock);
-                 goto converted;
-               }
+                 const char *inptr = (const char *) inbuf;
+                 size_t inleft = resultlen;
+                 char *outptr = (char *) outbuf;
+                 size_t outleft;
+
+                 if (freemem_size < sizeof (size_t))
+                   goto resize_freemem;
+
+                 outleft = freemem_size - sizeof (size_t);
+                 if (iconv (convd->conv,
+                            (ICONV_CONST char **) &inptr, &inleft,
+                            &outptr, &outleft)
+                     != (size_t) (-1))
+                   {
+                     outbuf = (unsigned char *) outptr;
+                     break;
+                   }
+                 if (errno != E2BIG)
+                   {
+                     __libc_lock_unlock (lock);
+                     goto converted;
+                   }
 #  endif
 # endif
 
 #  endif
 # endif
 
-           resize_freemem:
-             /* We must allocate a new buffer or resize the old one.  */
-             if (malloc_count > 0)
-               {
-                 ++malloc_count;
-                 freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
-                 newmem = (transmem_block_t *) realloc (transmem_list,
-                                                        freemem_size);
+               resize_freemem:
+                 /* We must allocate a new buffer or resize the old one.  */
+                 if (malloc_count > 0)
+                   {
+                     ++malloc_count;
+                     freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
+                     newmem = (transmem_block_t *) realloc (transmem_list,
+                                                            freemem_size);
 # ifdef _LIBC
 # ifdef _LIBC
-                 if (newmem != NULL)
-                   transmem_list = transmem_list->next;
+                     if (newmem != NULL)
+                       transmem_list = transmem_list->next;
+                     else
+                       {
+                         struct transmem_list *old = transmem_list;
+
+                         transmem_list = transmem_list->next;
+                         free (old);
+                       }
+# endif
+                   }
                  else
                    {
                  else
                    {
-                     struct transmem_list *old = transmem_list;
-
-                     transmem_list = transmem_list->next;
-                     free (old);
+                     malloc_count = 1;
+                     freemem_size = INITIAL_BLOCK_SIZE;
+                     newmem = (transmem_block_t *) malloc (freemem_size);
+                   }
+                 if (__builtin_expect (newmem == NULL, 0))
+                   {
+                     freemem = NULL;
+                     freemem_size = 0;
+                     __libc_lock_unlock (lock);
+                     goto converted;
                    }
                    }
-# endif
-               }
-             else
-               {
-                 malloc_count = 1;
-                 freemem_size = INITIAL_BLOCK_SIZE;
-                 newmem = (transmem_block_t *) malloc (freemem_size);
-               }
-             if (__builtin_expect (newmem == NULL, 0))
-               {
-                 freemem = NULL;
-                 freemem_size = 0;
-                 __libc_lock_unlock (lock);
-                 goto converted;
-               }
 
 # ifdef _LIBC
 
 # ifdef _LIBC
-             /* Add the block to the list of blocks we have to free
-                 at some point.  */
-             newmem->next = transmem_list;
-             transmem_list = newmem;
+                 /* Add the block to the list of blocks we have to free
+                    at some point.  */
+                 newmem->next = transmem_list;
+                 transmem_list = newmem;
 
 
-             freemem = newmem->data;
-             freemem_size -= offsetof (struct transmem_list, data);
+                 freemem = (unsigned char *) newmem->data;
+                 freemem_size -= offsetof (struct transmem_list, data);
 # else
 # else
-             transmem_list = newmem;
-             freemem = newmem;
+                 transmem_list = newmem;
+                 freemem = newmem;
 # endif
 
 # endif
 
-             outbuf = freemem + sizeof (size_t);
+                 outbuf = freemem + sizeof (size_t);
+               }
+
+             /* We have now in our buffer a converted string.  Put this
+                into the table of conversions.  */
+             *(size_t *) freemem = outbuf - freemem - sizeof (size_t);
+             convd->conv_tab[act] = (char *) freemem;
+             /* Shrink freemem, but keep it aligned.  */
+             freemem_size -= outbuf - freemem;
+             freemem = outbuf;
+             freemem += freemem_size & (alignof (size_t) - 1);
+             freemem_size = freemem_size & ~ (alignof (size_t) - 1);
+
+             __libc_lock_unlock (lock);
            }
 
            }
 
-         /* We have now in our buffer a converted string.  Put this
-            into the table of conversions.  */
-         *(size_t *) freemem = outbuf - freemem - sizeof (size_t);
-         domain->conv_tab[act] = (char *) freemem;
-         /* Shrink freemem, but keep it aligned.  */
-         freemem_size -= outbuf - freemem;
-         freemem = outbuf;
-         freemem += freemem_size & (alignof (size_t) - 1);
-         freemem_size = freemem_size & ~ (alignof (size_t) - 1);
-
-         __libc_lock_unlock (lock);
+         /* Now convd->conv_tab[act] contains the translation of all
+            the plural variants.  */
+         result = convd->conv_tab[act] + sizeof (size_t);
+         resultlen = *(size_t *) convd->conv_tab[act];
        }
        }
-
-      /* Now domain->conv_tab[act] contains the translation of all
-        the plural variants.  */
-      result = domain->conv_tab[act] + sizeof (size_t);
-      resultlen = *(size_t *) domain->conv_tab[act];
     }
 
  converted:
     }
 
  converted:
@@ -969,88 +1200,7 @@ plural_lookup (domain, n, translation, translation_len)
   return (char *) p;
 }
 
   return (char *) p;
 }
 
-
-/* Function to evaluate the plural expression and return an index value.  */
-static unsigned long int
-internal_function
-plural_eval (pexp, n)
-     struct expression *pexp;
-     unsigned long int n;
-{
-  switch (pexp->nargs)
-    {
-    case 0:
-      switch (pexp->operation)
-       {
-       case var:
-         return n;
-       case num:
-         return pexp->val.num;
-       default:
-         break;
-       }
-      /* NOTREACHED */
-      break;
-    case 1:
-      {
-       /* pexp->operation must be lnot.  */
-       unsigned long int arg = plural_eval (pexp->val.args[0], n);
-       return ! arg;
-      }
-    case 2:
-      {
-       unsigned long int leftarg = plural_eval (pexp->val.args[0], n);
-       if (pexp->operation == lor)
-         return leftarg || plural_eval (pexp->val.args[1], n);
-       else if (pexp->operation == land)
-         return leftarg && plural_eval (pexp->val.args[1], n);
-       else
-         {
-           unsigned long int rightarg = plural_eval (pexp->val.args[1], n);
-
-           switch (pexp->operation)
-             {
-             case mult:
-               return leftarg * rightarg;
-             case divide:
-               return leftarg / rightarg;
-             case module:
-               return leftarg % rightarg;
-             case plus:
-               return leftarg + rightarg;
-             case minus:
-               return leftarg - rightarg;
-             case less_than:
-               return leftarg < rightarg;
-             case greater_than:
-               return leftarg > rightarg;
-             case less_or_equal:
-               return leftarg <= rightarg;
-             case greater_or_equal:
-               return leftarg >= rightarg;
-             case equal:
-               return leftarg == rightarg;
-             case not_equal:
-               return leftarg != rightarg;
-             default:
-               break;
-             }
-         }
-       /* NOTREACHED */
-       break;
-      }
-    case 3:
-      {
-       /* pexp->operation must be qmop.  */
-       unsigned long int boolarg = plural_eval (pexp->val.args[0], n);
-       return plural_eval (pexp->val.args[boolarg ? 1 : 2], n);
-      }
-    }
-  /* NOTREACHED */
-  return 0;
-}
-
-
+#ifndef _LIBC
 /* Return string representation of locale CATEGORY.  */
 static const char *
 internal_function
 /* Return string representation of locale CATEGORY.  */
 static const char *
 internal_function
@@ -1110,6 +1260,7 @@ category_to_name (category)
 
   return retval;
 }
 
   return retval;
 }
+#endif
 
 /* Guess value of current locale from value of the environment variables.  */
 static const char *
 
 /* Guess value of current locale from value of the environment variables.  */
 static const char *
@@ -1131,29 +1282,69 @@ guess_category_value (category, categoryname)
   /* We have to proceed with the POSIX methods of looking to `LC_ALL',
      `LC_xxx', and `LANG'.  On some systems this can be done by the
      `setlocale' function itself.  */
   /* We have to proceed with the POSIX methods of looking to `LC_ALL',
      `LC_xxx', and `LANG'.  On some systems this can be done by the
      `setlocale' function itself.  */
-#if defined _LIBC || (defined HAVE_SETLOCALE && defined HAVE_LC_MESSAGES && defined HAVE_LOCALE_NULL)
-  retval = setlocale (category, NULL);
+#ifdef _LIBC
+  retval = __current_locale_name (category);
 #else
 #else
-  /* Setting of LC_ALL overwrites all other.  */
-  retval = getenv ("LC_ALL");
-  if (retval == NULL || retval[0] == '\0')
+  retval = _nl_locale_name (category, categoryname);
+#endif
+
+  return language != NULL && strcmp (retval, "C") != 0 ? language : retval;
+}
+
+#if defined _LIBC || HAVE_ICONV
+/* Returns the output charset.  */
+static const char *
+internal_function
+get_output_charset (domainbinding)
+     struct binding *domainbinding;
+{
+  /* The output charset should normally be determined by the locale.  But
+     sometimes the locale is not used or not correctly set up, so we provide
+     a possibility for the user to override this: the OUTPUT_CHARSET
+     environment variable.  Moreover, the value specified through
+     bind_textdomain_codeset overrides both.  */
+  if (domainbinding != NULL && domainbinding->codeset != NULL)
+    return domainbinding->codeset;
+  else
     {
     {
-      /* Next comes the name of the desired category.  */
-      retval = getenv (categoryname);
-      if (retval == NULL || retval[0] == '\0')
+      /* For speed reasons, we look at the value of OUTPUT_CHARSET only
+        once.  This is a user variable that is not supposed to change
+        during a program run.  */
+      static char *output_charset_cache;
+      static int output_charset_cached;
+
+      if (!output_charset_cached)
        {
        {
-         /* Last possibility is the LANG environment variable.  */
-         retval = getenv ("LANG");
-         if (retval == NULL || retval[0] == '\0')
-           /* We use C as the default domain.  POSIX says this is
-              implementation defined.  */
-           return "C";
+         const char *value = getenv ("OUTPUT_CHARSET");
+
+         if (value != NULL && value[0] != '\0')
+           {
+             size_t len = strlen (value) + 1;
+             char *value_copy = (char *) malloc (len);
+
+             if (value_copy != NULL)
+               memcpy (value_copy, value, len);
+             output_charset_cache = value_copy;
+           }
+         output_charset_cached = 1;
        }
        }
-    }
-#endif
 
 
-  return language != NULL && strcmp (retval, "C") != 0 ? language : retval;
+      if (output_charset_cache != NULL)
+       return output_charset_cache;
+      else
+       {
+# ifdef _LIBC
+         return _NL_CURRENT (LC_CTYPE, CODESET);
+# else
+#  if HAVE_ICONV
+         extern const char *locale_charset PARAMS ((void);
+         return locale_charset ();
+#  endif
+# endif
+       }
+    }
 }
 }
+#endif
 
 /* @@ begin of epilog @@ */
 
 
 /* @@ begin of epilog @@ */
 
@@ -1188,8 +1379,7 @@ mempcpy (dest, src, n)
 #ifdef _LIBC
 /* If we want to free all resources we have to do some work at
    program's end.  */
 #ifdef _LIBC
 /* If we want to free all resources we have to do some work at
    program's end.  */
-static void __attribute__ ((unused))
-free_mem (void)
+libc_freeres_fn (free_mem)
 {
   void *old;
 
 {
   void *old;
 
@@ -1219,6 +1409,4 @@ free_mem (void)
       free (old);
     }
 }
       free (old);
     }
 }
-
-text_set_element (__libc_subfreeres, free_mem);
 #endif
 #endif