intl/dcigettext.c

   1 /* Implementation of the internal dcigettext function.
   2    Copyright (C) 1995-2017 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU Lesser General Public License as published by
   6    the Free Software Foundation; either version 2.1 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  16
  17 /* Tell glibc's <string.h> to provide a prototype for mempcpy().
  18    This must come before <config.h> because <config.h> may include
  19    <features.h>, and once <features.h> has been included, it's too late.  */
  20 #ifndef _GNU_SOURCE
  21 # define _GNU_SOURCE    1
  22 #endif
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include <config.h>
  26 #endif
  27
  28 #include <sys/types.h>
  29
  30 #ifdef __GNUC__
  31 # define alloca __builtin_alloca
  32 # define HAVE_ALLOCA 1
  33 #else
  34 # ifdef _MSC_VER
  35 #  include <malloc.h>
  36 #  define alloca _alloca
  37 # else
  38 #  if defined HAVE_ALLOCA_H || defined _LIBC
  39 #   include <alloca.h>
  40 #  else
  41 #   ifdef _AIX
  42  #pragma alloca
  43 #   else
  44 #    ifndef alloca
  45 char *alloca ();
  46 #    endif
  47 #   endif
  48 #  endif
  49 # endif
  50 #endif
  51
  52 #include <errno.h>
  53 #ifndef errno
  54 extern int errno;
  55 #endif
  56 #ifndef __set_errno
  57 # define __set_errno(val) errno = (val)
  58 #endif
  59
  60 #include <stddef.h>
  61 #include <stdlib.h>
  62 #include <stdio.h>
  63 #include <string.h>
  64
  65 #if defined HAVE_UNISTD_H || defined _LIBC
  66 # include <unistd.h>
  67 #endif
  68
  69 #include <locale.h>
  70
  71 #ifdef _LIBC
  72   /* Guess whether integer division by zero raises signal SIGFPE.
  73      Set to 1 only if you know for sure.  In case of doubt, set to 0.  */
  74 # if defined __alpha__ || defined __arm__ || defined __i386__ \
  75      || defined __m68k__ || defined __s390__
  76 #  define INTDIV0_RAISES_SIGFPE 1
  77 # else
  78 #  define INTDIV0_RAISES_SIGFPE 0
  79 # endif
  80 #endif
  81 #if !INTDIV0_RAISES_SIGFPE
  82 # include <signal.h>
  83 #endif
  84
  85 #if defined HAVE_SYS_PARAM_H || defined _LIBC
  86 # include <sys/param.h>
  87 #endif
  88
  89 #if !defined _LIBC
  90 # include "localcharset.h"
  91 #endif
  92
  93 #include "gettextP.h"
  94 #include "plural-exp.h"
  95 #ifdef _LIBC
  96 # include <libintl.h>
  97 #else
  98 # ifdef IN_LIBGLOCALE
  99 #  include <libintl.h>
 100 # endif
 101 # include "libgnuintl.h"
 102 #endif
 103 #include "hash-string.h"
 104
 105 /* Handle multi-threaded applications.  */
 106 #ifdef _LIBC
 107 # include <libc-lock.h>
 108 # define gl_rwlock_define_initialized __libc_rwlock_define_initialized
 109 # define gl_rwlock_rdlock __libc_rwlock_rdlock
 110 # define gl_rwlock_wrlock __libc_rwlock_wrlock
 111 # define gl_rwlock_unlock __libc_rwlock_unlock
 112 #else
 113 # include "lock.h"
 114 #endif
 115
 116 /* Alignment of types.  */
 117 #if defined __GNUC__ && __GNUC__ >= 2
 118 # define alignof(TYPE) __alignof__ (TYPE)
 119 #else
 120 # define alignof(TYPE) \
 121     ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
 122 #endif
 123
 124 /* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>.  */
 125 #ifndef offsetof
 126 # define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
 127 #endif
 128
 129 /* @@ end of prolog @@ */
 130
 131 #ifdef _LIBC
 132 /* Rename the non ANSI C functions.  This is required by the standard
 133    because some ANSI C functions will require linking with this object
 134    file and the name space must not be polluted.  */
 135 # define strdup __strdup
 136 # define getcwd __getcwd
 137 # ifndef stpcpy
 138 #  define stpcpy __stpcpy
 139 # endif
 140 # define tfind __tfind
 141 #else
 142 # if !defined HAVE_GETCWD
 143 char *getwd ();
 144 #  define getcwd(buf, max) getwd (buf)
 145 # else
 146 #  if VMS
 147 #   define getcwd(buf, max) (getcwd) (buf, max, 0)
 148 #  else
 149 char *getcwd ();
 150 #  endif
 151 # endif
 152 # ifndef HAVE_STPCPY
 153 static char *stpcpy (char *dest, const char *src);
 154 # endif
 155 # ifndef HAVE_MEMPCPY
 156 static void *mempcpy (void *dest, const void *src, size_t n);
 157 # endif
 158 #endif
 159
 160 /* Use a replacement if the system does not provide the `tsearch' function
 161    family.  */
 162 #if defined HAVE_TSEARCH || defined _LIBC
 163 # include <search.h>
 164 #else
 165 # define tsearch libintl_tsearch
 166 # define tfind libintl_tfind
 167 # define tdelete libintl_tdelete
 168 # define twalk libintl_twalk
 169 # include "tsearch.h"
 170 #endif
 171
 172 #ifdef _LIBC
 173 # define tsearch __tsearch
 174 #endif
 175
 176 /* Amount to increase buffer size by in each try.  */
 177 #define PATH_INCR 32
 178
 179 /* The following is from pathmax.h.  */
 180 /* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define
 181    PATH_MAX but might cause redefinition warnings when sys/param.h is
 182    later included (as on MORE/BSD 4.3).  */
 183 #if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__)
 184 # include <limits.h>
 185 #endif
 186
 187 #ifndef _POSIX_PATH_MAX
 188 # define _POSIX_PATH_MAX 255
 189 #endif
 190
 191 #if !defined PATH_MAX && defined _PC_PATH_MAX
 192 # define PATH_MAX (__pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : __pathconf ("/", _PC_PATH_MAX))
 193 #endif
 194
 195 /* Don't include sys/param.h if it already has been.  */
 196 #if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN
 197 # include <sys/param.h>
 198 #endif
 199
 200 #if !defined PATH_MAX && defined MAXPATHLEN
 201 # define PATH_MAX MAXPATHLEN
 202 #endif
 203
 204 #ifndef PATH_MAX
 205 # define PATH_MAX _POSIX_PATH_MAX
 206 #endif
 207
 208 /* Pathname support.
 209    ISSLASH(C)           tests whether C is a directory separator character.
 210    IS_ABSOLUTE_PATH(P)  tests whether P is an absolute path.  If it is not,
 211                         it may be concatenated to a directory pathname.
 212    IS_PATH_WITH_DIR(P)  tests whether P contains a directory specification.
 213  */
 214 #if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__ || defined __EMX__ || defined __DJGPP__
 215   /* Win32, Cygwin, OS/2, DOS */
 216 # define ISSLASH(C) ((C) == '/' || (C) == '\\')
 217 # define HAS_DEVICE(P) \
 218     ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
 219      && (P)[1] == ':')
 220 # define IS_ABSOLUTE_PATH(P) (ISSLASH ((P)[0]) || HAS_DEVICE (P))
 221 # define IS_PATH_WITH_DIR(P) \
 222     (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
 223 #else
 224   /* Unix */
 225 # define ISSLASH(C) ((C) == '/')
 226 # define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0])
 227 # define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
 228 #endif
 229
 230 /* Whether to support different locales in different threads.  */
 231 #if defined _LIBC || HAVE_USELOCALE || defined IN_LIBGLOCALE
 232 # define HAVE_PER_THREAD_LOCALE
 233 #endif
 234
 235 /* This is the type used for the search tree where known translations
 236    are stored.  */
 237 struct known_translation_t
 238 {
 239   /* Domain in which to search.  */
 240   const char *domainname;
 241
 242   /* The category.  */
 243   int category;
 244
 245 #ifdef HAVE_PER_THREAD_LOCALE
 246   /* Name of the relevant locale category, or "" for the global locale.  */
 247   const char *localename;
 248 #endif
 249
 250 #ifdef IN_LIBGLOCALE
 251   /* The character encoding.  */
 252   const char *encoding;
 253 #endif
 254
 255   /* State of the catalog counter at the point the string was found.  */
 256   int counter;
 257
 258   /* Catalog where the string was found.  */
 259   struct loaded_l10nfile *domain;
 260
 261   /* And finally the translation.  */
 262   const char *translation;
 263   size_t translation_length;
 264
 265   /* Pointer to the string in question.  */
 266   union
 267     {
 268       char appended[ZERO];  /* used if domain != NULL */
 269       const char *ptr;      /* used if domain == NULL */
 270     }
 271   msgid;
 272 };
 273
 274 gl_rwlock_define_initialized (static, tree_lock)
 275
 276 /* Root of the search tree with known translations.  */
 277 static void *root;
 278
 279 /* Function to compare two entries in the table of known translations.  */
 280 static int
 281 transcmp (const void *p1, const void *p2)
 282 {
 283   const struct known_translation_t *s1;
 284   const struct known_translation_t *s2;
 285   int result;
 286
 287   s1 = (const struct known_translation_t *) p1;
 288   s2 = (const struct known_translation_t *) p2;
 289
 290   result = strcmp (s1->domain != NULL ? s1->msgid.appended : s1->msgid.ptr,
 291                    s2->domain != NULL ? s2->msgid.appended : s2->msgid.ptr);
 292   if (result == 0)
 293     {
 294       result = strcmp (s1->domainname, s2->domainname);
 295       if (result == 0)
 296         {
 297 #ifdef HAVE_PER_THREAD_LOCALE
 298           result = strcmp (s1->localename, s2->localename);
 299           if (result == 0)
 300 #endif
 301             {
 302 #ifdef IN_LIBGLOCALE
 303               result = strcmp (s1->encoding, s2->encoding);
 304               if (result == 0)
 305 #endif
 306                 /* We compare the category last (though this is the cheapest
 307                    operation) since it is hopefully always the same (namely
 308                    LC_MESSAGES).  */
 309                 result = s1->category - s2->category;
 310             }
 311         }
 312     }
 313
 314   return result;
 315 }
 316
 317 /* Name of the default domain used for gettext(3) prior any call to
 318    textdomain(3).  The default value for this is "messages".  */
 319 const char _nl_default_default_domain[] attribute_hidden = "messages";
 320
 321 #ifndef IN_LIBGLOCALE
 322 /* Value used as the default domain for gettext(3).  */
 323 const char *_nl_current_default_domain attribute_hidden
 324      = _nl_default_default_domain;
 325 #endif
 326
 327 /* Contains the default location of the message catalogs.  */
 328 #if defined __EMX__
 329 extern const char _nl_default_dirname[];
 330 #else
 331 # ifdef _LIBC
 332 extern const char _nl_default_dirname[];
 333 libc_hidden_proto (_nl_default_dirname)
 334 # endif
 335 const char _nl_default_dirname[] = LOCALEDIR;
 336 # ifdef _LIBC
 337 libc_hidden_data_def (_nl_default_dirname)
 338 # endif
 339 #endif
 340
 341 #ifndef IN_LIBGLOCALE
 342 /* List with bindings of specific domains created by bindtextdomain()
 343    calls.  */
 344 struct binding *_nl_domain_bindings;
 345 #endif
 346
 347 /* Prototypes for local functions.  */
 348 static char *plural_lookup (struct loaded_l10nfile *domain,
 349                             unsigned long int n,
 350                             const char *translation, size_t translation_len)
 351      internal_function;
 352
 353 #ifdef IN_LIBGLOCALE
 354 static const char *guess_category_value (int category,
 355                                          const char *categoryname,
 356                                          const char *localename)
 357      internal_function;
 358 #else
 359 static const char *guess_category_value (int category,
 360                                          const char *categoryname)
 361      internal_function;
 362 #endif
 363
 364 #ifdef _LIBC
 365 # include "../locale/localeinfo.h"
 366 # define category_to_name(category) \
 367   _nl_category_names.str + _nl_category_name_idxs[category]
 368 #else
 369 static const char *category_to_name (int category) internal_function;
 370 #endif
 371 #if (defined _LIBC || HAVE_ICONV) && !defined IN_LIBGLOCALE
 372 static const char *get_output_charset (struct binding *domainbinding)
 373      internal_function;
 374 #endif
 375
 376
 377 /* For those losing systems which don't have `alloca' we have to add
 378    some additional code emulating it.  */
 379 #ifdef HAVE_ALLOCA
 380 /* Nothing has to be done.  */
 381 # define freea(p) /* nothing */
 382 # define ADD_BLOCK(list, address) /* nothing */
 383 # define FREE_BLOCKS(list) /* nothing */
 384 #else
 385 struct block_list
 386 {
 387   void *address;
 388   struct block_list *next;
 389 };
 390 # define ADD_BLOCK(list, addr)                                                \
 391   do {                                                                        \
 392     struct block_list *newp = (struct block_list *) malloc (sizeof (*newp));  \
 393     /* If we cannot get a free block we cannot add the new element to         \
 394        the list.  */                                                          \
 395     if (newp != NULL) {                                                       \
 396       newp->address = (addr);                                                 \
 397       newp->next = (list);                                                    \
 398       (list) = newp;                                                          \
 399     }                                                                         \
 400   } while (0)
 401 # define FREE_BLOCKS(list)                                                    \
 402   do {                                                                        \
 403     while (list != NULL) {                                                    \
 404       struct block_list *old = list;                                          \
 405       list = list->next;                                                      \
 406       free (old->address);                                                    \
 407       free (old);                                                             \
 408     }                                                                         \
 409   } while (0)
 410 # undef alloca
 411 # define alloca(size) (malloc (size))
 412 # define freea(p) free (p)
 413 #endif  /* have alloca */
 414
 415
 416 #ifdef _LIBC
 417 /* List of blocks allocated for translations.  */
 418 typedef struct transmem_list
 419 {
 420   struct transmem_list *next;
 421   char data[ZERO];
 422 } transmem_block_t;
 423 static struct transmem_list *transmem_list;
 424 #else
 425 typedef unsigned char transmem_block_t;
 426 #endif
 427
 428
 429 /* Names for the libintl functions are a problem.  They must not clash
 430    with existing names and they should follow ANSI C.  But this source
 431    code is also used in GNU C Library where the names have a __
 432    prefix.  So we have to make a difference here.  */
 433 #ifdef _LIBC
 434 # define DCIGETTEXT __dcigettext
 435 #else
 436 # define DCIGETTEXT libintl_dcigettext
 437 #endif
 438
 439 /* Lock variable to protect the global data in the gettext implementation.  */
 440 gl_rwlock_define_initialized (, _nl_state_lock attribute_hidden)
 441
 442 /* Checking whether the binaries runs SUID must be done and glibc provides
 443    easier methods therefore we make a difference here.  */
 444 #ifdef _LIBC
 445 # define ENABLE_SECURE __libc_enable_secure
 446 # define DETERMINE_SECURE
 447 #else
 448 # ifndef HAVE_GETUID
 449 #  define getuid() 0
 450 # endif
 451 # ifndef HAVE_GETGID
 452 #  define getgid() 0
 453 # endif
 454 # ifndef HAVE_GETEUID
 455 #  define geteuid() getuid()
 456 # endif
 457 # ifndef HAVE_GETEGID
 458 #  define getegid() getgid()
 459 # endif
 460 static int enable_secure;
 461 # define ENABLE_SECURE (enable_secure == 1)
 462 # define DETERMINE_SECURE \
 463   if (enable_secure == 0)                                                     \
 464     {                                                                         \
 465       if (getuid () != geteuid () || getgid () != getegid ())                 \
 466         enable_secure = 1;                                                    \
 467       else                                                                    \
 468         enable_secure = -1;                                                   \
 469     }
 470 #endif
 471
 472 /* Get the function to evaluate the plural expression.  */
 473 #include "eval-plural.h"
 474
 475 /* Look up MSGID in the DOMAINNAME message catalog for the current
 476    CATEGORY locale and, if PLURAL is nonzero, search over string
 477    depending on the plural form determined by N.  */
 478 #ifdef IN_LIBGLOCALE
 479 char *
 480 gl_dcigettext (const char *domainname,
 481                const char *msgid1, const char *msgid2,
 482                int plural, unsigned long int n,
 483                int category,
 484                const char *localename, const char *encoding)
 485 #else
 486 char *
 487 DCIGETTEXT (const char *domainname, const char *msgid1, const char *msgid2,
 488             int plural, unsigned long int n, int category)
 489 #endif
 490 {
 491 #ifndef HAVE_ALLOCA
 492   struct block_list *block_list = NULL;
 493 #endif
 494   struct loaded_l10nfile *domain;
 495   struct binding *binding;
 496   const char *categoryname;
 497   const char *categoryvalue;
 498   const char *dirname;
 499   char *xdirname = NULL;
 500   char *xdomainname;
 501   char *single_locale;
 502   char *retval;
 503   size_t retlen;
 504   int saved_errno;
 505   struct known_translation_t search;
 506   struct known_translation_t **foundp = NULL;
 507 #if defined HAVE_PER_THREAD_LOCALE && !defined IN_LIBGLOCALE
 508   const char *localename;
 509 #endif
 510   size_t domainname_len;
 511
 512   /* If no real MSGID is given return NULL.  */
 513   if (msgid1 == NULL)
 514     return NULL;
 515
 516 #ifdef _LIBC
 517   if (category < 0 || category >= __LC_LAST || category == LC_ALL)
 518     /* Bogus.  */
 519     return (plural == 0
 520             ? (char *) msgid1
 521             /* Use the Germanic plural rule.  */
 522             : n == 1 ? (char *) msgid1 : (char *) msgid2);
 523 #endif
 524
 525   /* Preserve the `errno' value.  */
 526   saved_errno = errno;
 527
 528 #ifdef _LIBC
 529   __libc_rwlock_define (extern, __libc_setlocale_lock attribute_hidden)
 530   __libc_rwlock_rdlock (__libc_setlocale_lock);
 531 #endif
 532
 533   gl_rwlock_rdlock (_nl_state_lock);
 534
 535   /* If DOMAINNAME is NULL, we are interested in the default domain.  If
 536      CATEGORY is not LC_MESSAGES this might not make much sense but the
 537      definition left this undefined.  */
 538   if (domainname == NULL)
 539     domainname = _nl_current_default_domain;
 540
 541   /* OS/2 specific: backward compatibility with older libintl versions  */
 542 #ifdef LC_MESSAGES_COMPAT
 543   if (category == LC_MESSAGES_COMPAT)
 544     category = LC_MESSAGES;
 545 #endif
 546
 547   /* Try to find the translation among those which we found at
 548      some time.  */
 549   search.domain = NULL;
 550   search.msgid.ptr = msgid1;
 551   search.domainname = domainname;
 552   search.category = category;
 553 #ifdef HAVE_PER_THREAD_LOCALE
 554 # ifndef IN_LIBGLOCALE
 555 #  ifdef _LIBC
 556   localename = __current_locale_name (category);
 557 #  else
 558   categoryname = category_to_name (category);
 559 #   define CATEGORYNAME_INITIALIZED
 560   localename = _nl_locale_name_thread_unsafe (category, categoryname);
 561   if (localename == NULL)
 562     localename = "";
 563 #  endif
 564 # endif
 565   search.localename = localename;
 566 # ifdef IN_LIBGLOCALE
 567   search.encoding = encoding;
 568 # endif
 569
 570   /* Since tfind/tsearch manage a balanced tree, concurrent tfind and
 571      tsearch calls can be fatal.  */
 572   gl_rwlock_rdlock (tree_lock);
 573
 574   foundp = (struct known_translation_t **) tfind (&search, &root, transcmp);
 575
 576   gl_rwlock_unlock (tree_lock);
 577
 578   if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
 579     {
 580       /* Now deal with plural.  */
 581       if (plural)
 582         retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation,
 583                                 (*foundp)->translation_length);
 584       else
 585         retval = (char *) (*foundp)->translation;
 586
 587       gl_rwlock_unlock (_nl_state_lock);
 588 # ifdef _LIBC
 589       __libc_rwlock_unlock (__libc_setlocale_lock);
 590 # endif
 591       __set_errno (saved_errno);
 592       return retval;
 593     }
 594 #endif
 595
 596   /* See whether this is a SUID binary or not.  */
 597   DETERMINE_SECURE;
 598
 599   /* First find matching binding.  */
 600 #ifdef IN_LIBGLOCALE
 601   /* We can use a trivial binding, since _nl_find_msg will ignore it anyway,
 602      and _nl_load_domain and _nl_find_domain just pass it through.  */
 603   binding = NULL;
 604   dirname = bindtextdomain (domainname, NULL);
 605 #else
 606   for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
 607     {
 608       int compare = strcmp (domainname, binding->domainname);
 609       if (compare == 0)
 610         /* We found it!  */
 611         break;
 612       if (compare < 0)
 613         {
 614           /* It is not in the list.  */
 615           binding = NULL;
 616           break;
 617         }
 618     }
 619
 620   if (binding == NULL)
 621     dirname = _nl_default_dirname;
 622   else
 623     {
 624       dirname = binding->dirname;
 625 #endif
 626       if (!IS_ABSOLUTE_PATH (dirname))
 627         {
 628           /* We have a relative path.  Make it absolute now.  */
 629           char *cwd = getcwd (NULL, 0);
 630           if (cwd == NULL)
 631             /* We cannot get the current working directory.  Don't
 632                signal an error but simply return the default
 633                string.  */
 634             goto return_untranslated;
 635           int ret = __asprintf (&xdirname, "%s/%s", cwd, dirname);
 636           free (cwd);
 637           if (ret < 0)
 638               return NULL;
 639           dirname = xdirname;
 640         }
 641 #ifndef IN_LIBGLOCALE
 642     }
 643 #endif
 644
 645   /* Now determine the symbolic name of CATEGORY and its value.  */
 646 #ifndef CATEGORYNAME_INITIALIZED
 647   categoryname = category_to_name (category);
 648 #endif
 649 #ifdef IN_LIBGLOCALE
 650   categoryvalue = guess_category_value (category, categoryname, localename);
 651 #else
 652   categoryvalue = guess_category_value (category, categoryname);
 653 #endif
 654
 655   domainname_len = strlen (domainname);
 656   xdomainname = (char *) alloca (strlen (categoryname)
 657                                  + domainname_len + 5);
 658   ADD_BLOCK (block_list, xdomainname);
 659
 660   stpcpy ((char *) mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"),
 661                             domainname, domainname_len),
 662           ".mo");
 663
 664   /* Creating working area.  */
 665   single_locale = (char *) alloca (strlen (categoryvalue) + 1);
 666   ADD_BLOCK (block_list, single_locale);
 667
 668
 669   /* Search for the given string.  This is a loop because we perhaps
 670      got an ordered list of languages to consider for the translation.  */
 671   while (1)
 672     {
 673       /* Make CATEGORYVALUE point to the next element of the list.  */
 674       while (categoryvalue[0] != '\0' && categoryvalue[0] == ':')
 675         ++categoryvalue;
 676       if (categoryvalue[0] == '\0')
 677         {
 678           /* The whole contents of CATEGORYVALUE has been searched but
 679              no valid entry has been found.  We solve this situation
 680              by implicitly appending a "C" entry, i.e. no translation
 681              will take place.  */
 682           single_locale[0] = 'C';
 683           single_locale[1] = '\0';
 684         }
 685       else
 686         {
 687           char *cp = single_locale;
 688           while (categoryvalue[0] != '\0' && categoryvalue[0] != ':')
 689             *cp++ = *categoryvalue++;
 690           *cp = '\0';
 691
 692           /* When this is a SUID binary we must not allow accessing files
 693              outside the dedicated directories.  */
 694           if (ENABLE_SECURE && IS_PATH_WITH_DIR (single_locale))
 695             /* Ingore this entry.  */
 696             continue;
 697         }
 698
 699       /* If the current locale value is C (or POSIX) we don't load a
 700          domain.  Return the MSGID.  */
 701       if (strcmp (single_locale, "C") == 0
 702           || strcmp (single_locale, "POSIX") == 0)
 703         break;
 704
 705       /* Find structure describing the message catalog matching the
 706          DOMAINNAME and CATEGORY.  */
 707       domain = _nl_find_domain (dirname, single_locale, xdomainname, binding);
 708
 709       if (domain != NULL)
 710         {
 711 #if defined IN_LIBGLOCALE
 712           retval = _nl_find_msg (domain, binding, encoding, msgid1, &retlen);
 713 #else
 714           retval = _nl_find_msg (domain, binding, msgid1, 1, &retlen);
 715 #endif
 716
 717           if (retval == NULL)
 718             {
 719               int cnt;
 720
 721               for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
 722                 {
 723 #if defined IN_LIBGLOCALE
 724                   retval = _nl_find_msg (domain->successor[cnt], binding,
 725                                          encoding, msgid1, &retlen);
 726 #else
 727                   retval = _nl_find_msg (domain->successor[cnt], binding,
 728                                          msgid1, 1, &retlen);
 729 #endif
 730
 731                   /* Resource problems are not fatal, instead we return no
 732                      translation.  */
 733                   if (__builtin_expect (retval == (char *) -1, 0))
 734                     goto return_untranslated;
 735
 736                   if (retval != NULL)
 737                     {
 738                       domain = domain->successor[cnt];
 739                       break;
 740                     }
 741                 }
 742             }
 743
 744           /* Returning -1 means that some resource problem exists
 745              (likely memory) and that the strings could not be
 746              converted.  Return the original strings.  */
 747           if (__builtin_expect (retval == (char *) -1, 0))
 748             break;
 749
 750           if (retval != NULL)
 751             {
 752               /* Found the translation of MSGID1 in domain DOMAIN:
 753                  starting at RETVAL, RETLEN bytes.  */
 754               free (xdirname);
 755               FREE_BLOCKS (block_list);
 756               if (foundp == NULL)
 757                 {
 758                   /* Create a new entry and add it to the search tree.  */
 759                   size_t msgid_len;
 760                   size_t size;
 761                   struct known_translation_t *newp;
 762
 763                   msgid_len = strlen (msgid1) + 1;
 764                   size = offsetof (struct known_translation_t, msgid)
 765                          + msgid_len + domainname_len + 1;
 766 #ifdef HAVE_PER_THREAD_LOCALE
 767                   size += strlen (localename) + 1;
 768 #endif
 769                   newp = (struct known_translation_t *) malloc (size);
 770                   if (newp != NULL)
 771                     {
 772                       char *new_domainname;
 773 #ifdef HAVE_PER_THREAD_LOCALE
 774                       char *new_localename;
 775 #endif
 776
 777                       new_domainname =
 778                         (char *) mempcpy (newp->msgid.appended, msgid1,
 779                                           msgid_len);
 780                       memcpy (new_domainname, domainname, domainname_len + 1);
 781 #ifdef HAVE_PER_THREAD_LOCALE
 782                       new_localename = new_domainname + domainname_len + 1;
 783                       strcpy (new_localename, localename);
 784 #endif
 785                       newp->domainname = new_domainname;
 786                       newp->category = category;
 787 #ifdef HAVE_PER_THREAD_LOCALE
 788                       newp->localename = new_localename;
 789 #endif
 790 #ifdef IN_LIBGLOCALE
 791                       newp->encoding = encoding;
 792 #endif
 793                       newp->counter = _nl_msg_cat_cntr;
 794                       newp->domain = domain;
 795                       newp->translation = retval;
 796                       newp->translation_length = retlen;
 797
 798                       gl_rwlock_wrlock (tree_lock);
 799
 800                       /* Insert the entry in the search tree.  */
 801                       foundp = (struct known_translation_t **)
 802                         tsearch (newp, &root, transcmp);
 803
 804                       gl_rwlock_unlock (tree_lock);
 805
 806                       if (foundp == NULL
 807                           || __builtin_expect (*foundp != newp, 0))
 808                         /* The insert failed.  */
 809                         free (newp);
 810                     }
 811                 }
 812               else
 813                 {
 814                   /* We can update the existing entry.  */
 815                   (*foundp)->counter = _nl_msg_cat_cntr;
 816                   (*foundp)->domain = domain;
 817                   (*foundp)->translation = retval;
 818                   (*foundp)->translation_length = retlen;
 819                 }
 820
 821               __set_errno (saved_errno);
 822
 823               /* Now deal with plural.  */
 824               if (plural)
 825                 retval = plural_lookup (domain, n, retval, retlen);
 826
 827               gl_rwlock_unlock (_nl_state_lock);
 828 #ifdef _LIBC
 829               __libc_rwlock_unlock (__libc_setlocale_lock);
 830 #endif
 831               return retval;
 832             }
 833         }
 834     }
 835
 836  return_untranslated:
 837   /* Return the untranslated MSGID.  */
 838   free (xdirname);
 839   FREE_BLOCKS (block_list);
 840   gl_rwlock_unlock (_nl_state_lock);
 841 #ifdef _LIBC
 842   __libc_rwlock_unlock (__libc_setlocale_lock);
 843 #endif
 844 #ifndef _LIBC
 845   if (!ENABLE_SECURE)
 846     {
 847       extern void _nl_log_untranslated (const char *logfilename,
 848                                         const char *domainname,
 849                                         const char *msgid1, const char *msgid2,
 850                                         int plural);
 851       const char *logfilename = getenv ("GETTEXT_LOG_UNTRANSLATED");
 852
 853       if (logfilename != NULL && logfilename[0] != '\0')
 854         _nl_log_untranslated (logfilename, domainname, msgid1, msgid2, plural);
 855     }
 856 #endif
 857   __set_errno (saved_errno);
 858   return (plural == 0
 859           ? (char *) msgid1
 860           /* Use the Germanic plural rule.  */
 861           : n == 1 ? (char *) msgid1 : (char *) msgid2);
 862 }
 863
 864
 865 /* Look up the translation of msgid within DOMAIN_FILE and DOMAINBINDING.
 866    Return it if found.  Return NULL if not found or in case of a conversion
 867    failure (problem in the particular message catalog).  Return (char *) -1
 868    in case of a memory allocation failure during conversion (only if
 869    ENCODING != NULL resp. CONVERT == true).  */
 870 char *
 871 internal_function
 872 #ifdef IN_LIBGLOCALE
 873 _nl_find_msg (struct loaded_l10nfile *domain_file,
 874               struct binding *domainbinding, const char *encoding,
 875               const char *msgid,
 876               size_t *lengthp)
 877 #else
 878 _nl_find_msg (struct loaded_l10nfile *domain_file,
 879               struct binding *domainbinding,
 880               const char *msgid, int convert,
 881               size_t *lengthp)
 882 #endif
 883 {
 884   struct loaded_domain *domain;
 885   nls_uint32 nstrings;
 886   size_t act;
 887   char *result;
 888   size_t resultlen;
 889
 890   if (domain_file->decided <= 0)
 891     _nl_load_domain (domain_file, domainbinding);
 892
 893   if (domain_file->data == NULL)
 894     return NULL;
 895
 896   domain = (struct loaded_domain *) domain_file->data;
 897
 898   nstrings = domain->nstrings;
 899
 900   /* Locate the MSGID and its translation.  */
 901   if (domain->hash_tab != NULL)
 902     {
 903       /* Use the hashing table.  */
 904       nls_uint32 len = strlen (msgid);
 905       nls_uint32 hash_val = __hash_string (msgid);
 906       nls_uint32 idx = hash_val % domain->hash_size;
 907       nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));
 908
 909       while (1)
 910         {
 911           nls_uint32 nstr =
 912             W (domain->must_swap_hash_tab, domain->hash_tab[idx]);
 913
 914           if (nstr == 0)
 915             /* Hash table entry is empty.  */
 916             return NULL;
 917
 918           nstr--;
 919
 920           /* Compare msgid with the original string at index nstr.
 921              We compare the lengths with >=, not ==, because plural entries
 922              are represented by strings with an embedded NUL.  */
 923           if (nstr < nstrings
 924               ? W (domain->must_swap, domain->orig_tab[nstr].length) >= len
 925                 && (strcmp (msgid,
 926                             domain->data + W (domain->must_swap,
 927                                               domain->orig_tab[nstr].offset))
 928                     == 0)
 929               : domain->orig_sysdep_tab[nstr - nstrings].length > len
 930                 && (strcmp (msgid,
 931                             domain->orig_sysdep_tab[nstr - nstrings].pointer)
 932                     == 0))
 933             {
 934               act = nstr;
 935               goto found;
 936             }
 937
 938           if (idx >= domain->hash_size - incr)
 939             idx -= domain->hash_size - incr;
 940           else
 941             idx += incr;
 942         }
 943       /* NOTREACHED */
 944     }
 945   else
 946     {
 947       /* Try the default method:  binary search in the sorted array of
 948          messages.  */
 949       size_t top, bottom;
 950
 951       bottom = 0;
 952       top = nstrings;
 953       while (bottom < top)
 954         {
 955           int cmp_val;
 956
 957           act = (bottom + top) / 2;
 958           cmp_val = strcmp (msgid, (domain->data
 959                                     + W (domain->must_swap,
 960                                          domain->orig_tab[act].offset)));
 961           if (cmp_val < 0)
 962             top = act;
 963           else if (cmp_val > 0)
 964             bottom = act + 1;
 965           else
 966             goto found;
 967         }
 968       /* No translation was found.  */
 969       return NULL;
 970     }
 971
 972  found:
 973   /* The translation was found at index ACT.  If we have to convert the
 974      string to use a different character set, this is the time.  */
 975   if (act < nstrings)
 976     {
 977       result = (char *)
 978         (domain->data + W (domain->must_swap, domain->trans_tab[act].offset));
 979       resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
 980     }
 981   else
 982     {
 983       result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer;
 984       resultlen = domain->trans_sysdep_tab[act - nstrings].length;
 985     }
 986
 987 #if defined _LIBC || HAVE_ICONV
 988 # ifdef IN_LIBGLOCALE
 989   if (encoding != NULL)
 990 # else
 991   if (convert)
 992 # endif
 993     {
 994       /* We are supposed to do a conversion.  */
 995 # ifndef IN_LIBGLOCALE
 996       const char *encoding = get_output_charset (domainbinding);
 997 # endif
 998       size_t nconversions;
 999       struct converted_domain *convd;
1000       size_t i;
1001
1002       /* Protect against reallocation of the table.  */
1003       gl_rwlock_rdlock (domain->conversions_lock);
1004
1005       /* Search whether a table with converted translations for this
1006          encoding has already been allocated.  */
1007       nconversions = domain->nconversions;
1008       convd = NULL;
1009
1010       for (i = nconversions; i > 0; )
1011         {
1012           i--;
1013           if (strcmp (domain->conversions[i].encoding, encoding) == 0)
1014             {
1015               convd = &domain->conversions[i];
1016               break;
1017             }
1018         }
1019
1020       gl_rwlock_unlock (domain->conversions_lock);
1021
1022       if (convd == NULL)
1023         {
1024           /* We have to allocate a new conversions table.  */
1025           gl_rwlock_wrlock (domain->conversions_lock);
1026           nconversions = domain->nconversions;
1027
1028           /* Maybe in the meantime somebody added the translation.
1029              Recheck.  */
1030           for (i = nconversions; i > 0; )
1031             {
1032               i--;
1033               if (strcmp (domain->conversions[i].encoding, encoding) == 0)
1034                 {
1035                   convd = &domain->conversions[i];
1036                   goto found_convd;
1037                 }
1038             }
1039
1040           {
1041             /* Allocate a table for the converted translations for this
1042                encoding.  */
1043             struct converted_domain *new_conversions =
1044               (struct converted_domain *)
1045               (domain->conversions != NULL
1046                ? realloc (domain->conversions,
1047                           (nconversions + 1) * sizeof (struct converted_domain))
1048                : malloc ((nconversions + 1) * sizeof (struct converted_domain)));
1049
1050             if (__builtin_expect (new_conversions == NULL, 0))
1051               {
1052                 /* Nothing we can do, no more memory.  We cannot use the
1053                    translation because it might be encoded incorrectly.  */
1054               unlock_fail:
1055                 gl_rwlock_unlock (domain->conversions_lock);
1056                 return (char *) -1;
1057               }
1058
1059             domain->conversions = new_conversions;
1060
1061             /* Copy the 'encoding' string to permanent storage.  */
1062             encoding = strdup (encoding);
1063             if (__builtin_expect (encoding == NULL, 0))
1064               /* Nothing we can do, no more memory.  We cannot use the
1065                  translation because it might be encoded incorrectly.  */
1066               goto unlock_fail;
1067
1068             convd = &new_conversions[nconversions];
1069             convd->encoding = encoding;
1070
1071             /* Find out about the character set the file is encoded with.
1072                This can be found (in textual form) in the entry "".  If this
1073                entry does not exist or if this does not contain the 'charset='
1074                information, we will assume the charset matches the one the
1075                current locale and we don't have to perform any conversion.  */
1076 # ifdef _LIBC
1077             convd->conv = (__gconv_t) -1;
1078 # else
1079 #  if HAVE_ICONV
1080             convd->conv = (iconv_t) -1;
1081 #  endif
1082 # endif
1083             {
1084               char *nullentry;
1085               size_t nullentrylen;
1086
1087               /* Get the header entry.  This is a recursion, but it doesn't
1088                  reallocate domain->conversions because we pass
1089                  encoding = NULL or convert = 0, respectively.  */
1090               nullentry =
1091 # ifdef IN_LIBGLOCALE
1092                 _nl_find_msg (domain_file, domainbinding, NULL, "",
1093                               &nullentrylen);
1094 # else
1095                 _nl_find_msg (domain_file, domainbinding, "", 0, &nullentrylen);
1096 # endif
1097
1098               /* Resource problems are fatal.  If we continue onwards we will
1099                  only attempt to calloc a new conv_tab and fail later.  */
1100               if (__builtin_expect (nullentry == (char *) -1, 0))
1101                 return (char *) -1;
1102
1103               if (nullentry != NULL)
1104                 {
1105                   const char *charsetstr;
1106
1107                   charsetstr = strstr (nullentry, "charset=");
1108                   if (charsetstr != NULL)
1109                     {
1110                       size_t len;
1111                       char *charset;
1112                       const char *outcharset;
1113
1114                       charsetstr += strlen ("charset=");
1115                       len = strcspn (charsetstr, " \t\n");
1116
1117                       charset = (char *) alloca (len + 1);
1118 # if defined _LIBC || HAVE_MEMPCPY
1119                       *((char *) mempcpy (charset, charsetstr, len)) = '\0';
1120 # else
1121                       memcpy (charset, charsetstr, len);
1122                       charset[len] = '\0';
1123 # endif
1124
1125                       outcharset = encoding;
1126
1127 # ifdef _LIBC
1128                       /* We always want to use transliteration.  */
1129                       outcharset = norm_add_slashes (outcharset, "TRANSLIT");
1130                       charset = norm_add_slashes (charset, "");
1131                       int r = __gconv_open (outcharset, charset, &convd->conv,
1132                                             GCONV_AVOID_NOCONV);
1133                       if (__builtin_expect (r != __GCONV_OK, 0))
1134                         {
1135                           /* If the output encoding is the same there is
1136                              nothing to do.  Otherwise do not use the
1137                              translation at all.  */
1138                           if (__builtin_expect (r != __GCONV_NULCONV, 1))
1139                             {
1140                               gl_rwlock_unlock (domain->conversions_lock);
1141                               free ((char *) encoding);
1142                               return NULL;
1143                             }
1144
1145                           convd->conv = (__gconv_t) -1;
1146                         }
1147 # else
1148 #  if HAVE_ICONV
1149                       /* When using GNU libc >= 2.2 or GNU libiconv >= 1.5,
1150                          we want to use transliteration.  */
1151 #   if (((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2) \
1152         && !defined __UCLIBC__) \
1153        || _LIBICONV_VERSION >= 0x0105
1154                       if (strchr (outcharset, '/') == NULL)
1155                         {
1156                           char *tmp;
1157
1158                           len = strlen (outcharset);
1159                           tmp = (char *) alloca (len + 10 + 1);
1160                           memcpy (tmp, outcharset, len);
1161                           memcpy (tmp + len, "//TRANSLIT", 10 + 1);
1162                           outcharset = tmp;
1163
1164                           convd->conv = iconv_open (outcharset, charset);
1165
1166                           freea (outcharset);
1167                         }
1168                       else
1169 #   endif
1170                         convd->conv = iconv_open (outcharset, charset);
1171 #  endif
1172 # endif
1173
1174                       freea (charset);
1175                     }
1176                 }
1177             }
1178             convd->conv_tab = NULL;
1179             /* Here domain->conversions is still == new_conversions.  */
1180             domain->nconversions++;
1181           }
1182
1183         found_convd:
1184           gl_rwlock_unlock (domain->conversions_lock);
1185         }
1186
1187       if (
1188 # ifdef _LIBC
1189           convd->conv != (__gconv_t) -1
1190 # else
1191 #  if HAVE_ICONV
1192           convd->conv != (iconv_t) -1
1193 #  endif
1194 # endif
1195           )
1196         {
1197           /* We are supposed to do a conversion.  First allocate an
1198              appropriate table with the same structure as the table
1199              of translations in the file, where we can put the pointers
1200              to the converted strings in.
1201              There is a slight complication with plural entries.  They
1202              are represented by consecutive NUL terminated strings.  We
1203              handle this case by converting RESULTLEN bytes, including
1204              NULs.  */
1205
1206           /* This lock primarily protects the memory management variables
1207              freemem, freemem_size.  It also protects write accesses to
1208              convd->conv_tab.  It's not worth using a separate lock (such
1209              as domain->conversions_lock) for this purpose, because when
1210              modifying convd->conv_tab, we also need to lock freemem,
1211              freemem_size for most of the time.  */
1212           __libc_lock_define_initialized (static, lock)
1213
1214           if (__builtin_expect (convd->conv_tab == NULL, 0))
1215             {
1216               __libc_lock_lock (lock);
1217               if (convd->conv_tab == NULL)
1218                 {
1219                   convd->conv_tab =
1220                     (char **) calloc (nstrings + domain->n_sysdep_strings,
1221                                       sizeof (char *));
1222                   if (convd->conv_tab != NULL)
1223                     goto not_translated_yet;
1224                   /* Mark that we didn't succeed allocating a table.  */
1225                   convd->conv_tab = (char **) -1;
1226                 }
1227               __libc_lock_unlock (lock);
1228             }
1229
1230           if (__builtin_expect (convd->conv_tab == (char **) -1, 0))
1231             /* Nothing we can do, no more memory.  We cannot use the
1232                translation because it might be encoded incorrectly.  */
1233             return (char *) -1;
1234
1235           if (convd->conv_tab[act] == NULL)
1236             {
1237               /* We haven't used this string so far, so it is not
1238                  translated yet.  Do this now.  */
1239               /* We use a bit more efficient memory handling.
1240                  We allocate always larger blocks which get used over
1241                  time.  This is faster than many small allocations.   */
1242 # define INITIAL_BLOCK_SIZE     4080
1243               static unsigned char *freemem;
1244               static size_t freemem_size;
1245
1246               const unsigned char *inbuf;
1247               unsigned char *outbuf;
1248               int malloc_count;
1249 # ifndef _LIBC
1250               transmem_block_t *transmem_list;
1251 # endif
1252
1253               __libc_lock_lock (lock);
1254             not_translated_yet:
1255
1256               inbuf = (const unsigned char *) result;
1257               outbuf = freemem + sizeof (size_t);
1258 # ifndef _LIBC
1259               transmem_list = NULL;
1260 # endif
1261
1262               malloc_count = 0;
1263               while (1)
1264                 {
1265                   transmem_block_t *newmem;
1266 # ifdef _LIBC
1267                   size_t non_reversible;
1268                   int res;
1269
1270                   if (freemem_size < sizeof (size_t))
1271                     goto resize_freemem;
1272
1273                   res = __gconv (convd->conv,
1274                                  &inbuf, inbuf + resultlen,
1275                                  &outbuf,
1276                                  outbuf + freemem_size - sizeof (size_t),
1277                                  &non_reversible);
1278
1279                   if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
1280                     break;
1281
1282                   if (res != __GCONV_FULL_OUTPUT)
1283                     {
1284                       /* We should not use the translation at all, it
1285                          is incorrectly encoded.  */
1286                       __libc_lock_unlock (lock);
1287                       return NULL;
1288                     }
1289
1290                   inbuf = (const unsigned char *) result;
1291 # else
1292 #  if HAVE_ICONV
1293                   const char *inptr = (const char *) inbuf;
1294                   size_t inleft = resultlen;
1295                   char *outptr = (char *) outbuf;
1296                   size_t outleft;
1297
1298                   if (freemem_size < sizeof (size_t))
1299                     goto resize_freemem;
1300
1301                   outleft = freemem_size - sizeof (size_t);
1302                   if (iconv (convd->conv,
1303                              (ICONV_CONST char **) &inptr, &inleft,
1304                              &outptr, &outleft)
1305                       != (size_t) (-1))
1306                     {
1307                       outbuf = (unsigned char *) outptr;
1308                       break;
1309                     }
1310                   if (errno != E2BIG)
1311                     {
1312                       __libc_lock_unlock (lock);
1313                       return NULL;
1314                     }
1315 #  endif
1316 # endif
1317
1318                 resize_freemem:
1319                   /* We must allocate a new buffer or resize the old one.  */
1320                   if (malloc_count > 0)
1321                     {
1322                       ++malloc_count;
1323                       freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
1324                       newmem = (transmem_block_t *) realloc (transmem_list,
1325                                                              freemem_size);
1326 # ifdef _LIBC
1327                       if (newmem != NULL)
1328                         transmem_list = newmem;
1329                       else
1330                         {
1331                           struct transmem_list *old = transmem_list;
1332
1333                           transmem_list = transmem_list->next;
1334                           free (old);
1335                         }
1336 # endif
1337                     }
1338                   else
1339                     {
1340                       malloc_count = 1;
1341                       freemem_size = INITIAL_BLOCK_SIZE;
1342                       newmem = (transmem_block_t *) malloc (freemem_size);
1343 # ifdef _LIBC
1344                       if (newmem != NULL)
1345                         {
1346                           /* Add the block to the list of blocks we have to free
1347                              at some point.  */
1348                           newmem->next = transmem_list;
1349                           transmem_list = newmem;
1350                         }
1351                       /* Fall through and return -1.  */
1352 # endif
1353                     }
1354                   if (__builtin_expect (newmem == NULL, 0))
1355                     {
1356                       freemem = NULL;
1357                       freemem_size = 0;
1358                       __libc_lock_unlock (lock);
1359                       return (char *) -1;
1360                     }
1361
1362 # ifdef _LIBC
1363                   freemem = (unsigned char *) newmem->data;
1364                   freemem_size -= offsetof (struct transmem_list, data);
1365 # else
1366                   transmem_list = newmem;
1367                   freemem = newmem;
1368 # endif
1369
1370                   outbuf = freemem + sizeof (size_t);
1371                 }
1372
1373               /* We have now in our buffer a converted string.  Put this
1374                  into the table of conversions.  */
1375               *(size_t *) freemem = outbuf - freemem - sizeof (size_t);
1376               convd->conv_tab[act] = (char *) freemem;
1377               /* Shrink freemem, but keep it aligned.  */
1378               freemem_size -= outbuf - freemem;
1379               freemem = outbuf;
1380               freemem += freemem_size & (alignof (size_t) - 1);
1381               freemem_size = freemem_size & ~ (alignof (size_t) - 1);
1382
1383               __libc_lock_unlock (lock);
1384             }
1385
1386           /* Now convd->conv_tab[act] contains the translation of all
1387              the plural variants.  */
1388           result = convd->conv_tab[act] + sizeof (size_t);
1389           resultlen = *(size_t *) convd->conv_tab[act];
1390         }
1391     }
1392
1393   /* The result string is converted.  */
1394
1395 #endif /* _LIBC || HAVE_ICONV */
1396
1397   *lengthp = resultlen;
1398   return result;
1399 }
1400
1401
1402 /* Look up a plural variant.  */
1403 static char *
1404 internal_function
1405 plural_lookup (struct loaded_l10nfile *domain, unsigned long int n,
1406                const char *translation, size_t translation_len)
1407 {
1408   struct loaded_domain *domaindata = (struct loaded_domain *) domain->data;
1409   unsigned long int index;
1410   const char *p;
1411
1412   index = plural_eval (domaindata->plural, n);
1413   if (index >= domaindata->nplurals)
1414     /* This should never happen.  It means the plural expression and the
1415        given maximum value do not match.  */
1416     index = 0;
1417
1418   /* Skip INDEX strings at TRANSLATION.  */
1419   p = translation;
1420   while (index-- > 0)
1421     {
1422 #ifdef _LIBC
1423       p = __rawmemchr (p, '\0');
1424 #else
1425       p = strchr (p, '\0');
1426 #endif
1427       /* And skip over the NUL byte.  */
1428       p++;
1429
1430       if (p >= translation + translation_len)
1431         /* This should never happen.  It means the plural expression
1432            evaluated to a value larger than the number of variants
1433            available for MSGID1.  */
1434         return (char *) translation;
1435     }
1436   return (char *) p;
1437 }
1438
1439 #ifndef _LIBC
1440 /* Return string representation of locale CATEGORY.  */
1441 static const char *
1442 internal_function
1443 category_to_name (int category)
1444 {
1445   const char *retval;
1446
1447   switch (category)
1448   {
1449 #ifdef LC_COLLATE
1450   case LC_COLLATE:
1451     retval = "LC_COLLATE";
1452     break;
1453 #endif
1454 #ifdef LC_CTYPE
1455   case LC_CTYPE:
1456     retval = "LC_CTYPE";
1457     break;
1458 #endif
1459 #ifdef LC_MONETARY
1460   case LC_MONETARY:
1461     retval = "LC_MONETARY";
1462     break;
1463 #endif
1464 #ifdef LC_NUMERIC
1465   case LC_NUMERIC:
1466     retval = "LC_NUMERIC";
1467     break;
1468 #endif
1469 #ifdef LC_TIME
1470   case LC_TIME:
1471     retval = "LC_TIME";
1472     break;
1473 #endif
1474 #ifdef LC_MESSAGES
1475   case LC_MESSAGES:
1476     retval = "LC_MESSAGES";
1477     break;
1478 #endif
1479 #ifdef LC_RESPONSE
1480   case LC_RESPONSE:
1481     retval = "LC_RESPONSE";
1482     break;
1483 #endif
1484 #ifdef LC_ALL
1485   case LC_ALL:
1486     /* This might not make sense but is perhaps better than any other
1487        value.  */
1488     retval = "LC_ALL";
1489     break;
1490 #endif
1491   default:
1492     /* If you have a better idea for a default value let me know.  */
1493     retval = "LC_XXX";
1494   }
1495
1496   return retval;
1497 }
1498 #endif
1499
1500 /* Guess value of current locale from value of the environment variables
1501    or system-dependent defaults.  */
1502 static const char *
1503 internal_function
1504 #ifdef IN_LIBGLOCALE
1505 guess_category_value (int category, const char *categoryname,
1506                       const char *locale)
1507
1508 #else
1509 guess_category_value (int category, const char *categoryname)
1510 #endif
1511 {
1512   const char *language;
1513 #ifndef IN_LIBGLOCALE
1514   const char *locale;
1515 # ifndef _LIBC
1516   const char *language_default;
1517   int locale_defaulted;
1518 # endif
1519 #endif
1520
1521   /* We use the settings in the following order:
1522      1. The value of the environment variable 'LANGUAGE'.  This is a GNU
1523         extension.  Its value can be a colon-separated list of locale names.
1524      2. The value of the environment variable 'LC_ALL', 'LC_xxx', or 'LANG'.
1525         More precisely, the first among these that is set to a non-empty value.
1526         This is how POSIX specifies it.  The value is a single locale name.
1527      3. A system-dependent preference list of languages.  Its value can be a
1528         colon-separated list of locale names.
1529      4. A system-dependent default locale name.
1530      This way:
1531        - System-dependent settings can be overridden by environment variables.
1532        - If the system provides both a list of languages and a default locale,
1533          the former is used.  */
1534
1535 #ifndef IN_LIBGLOCALE
1536   /* Fetch the locale name, through the POSIX method of looking to `LC_ALL',
1537      `LC_xxx', and `LANG'.  On some systems this can be done by the
1538      `setlocale' function itself.  */
1539 # ifdef _LIBC
1540   locale = __current_locale_name (category);
1541 # else
1542   locale_defaulted = 0;
1543 #  if HAVE_USELOCALE
1544   locale = _nl_locale_name_thread_unsafe (category, categoryname);
1545   if (locale == NULL)
1546 #  endif
1547     {
1548       locale = _nl_locale_name_posix (category, categoryname);
1549       if (locale == NULL)
1550         {
1551           locale = _nl_locale_name_default ();
1552           locale_defaulted = 1;
1553         }
1554     }
1555 # endif
1556 #endif
1557
1558   /* Ignore LANGUAGE and its system-dependent analogon if the locale is set
1559      to "C" because
1560      1. "C" locale usually uses the ASCII encoding, and most international
1561         messages use non-ASCII characters. These characters get displayed
1562         as question marks (if using glibc's iconv()) or as invalid 8-bit
1563         characters (because other iconv()s refuse to convert most non-ASCII
1564         characters to ASCII). In any case, the output is ugly.
1565      2. The precise output of some programs in the "C" locale is specified
1566         by POSIX and should not depend on environment variables like
1567         "LANGUAGE" or system-dependent information.  We allow such programs
1568         to use gettext().  */
1569   if (strcmp (locale, "C") == 0)
1570     return locale;
1571
1572   /* The highest priority value is the value of the 'LANGUAGE' environment
1573      variable.  */
1574   language = getenv ("LANGUAGE");
1575   if (language != NULL && language[0] != '\0')
1576     return language;
1577 #if !defined IN_LIBGLOCALE && !defined _LIBC
1578   /* The next priority value is the locale name, if not defaulted.  */
1579   if (locale_defaulted)
1580     {
1581       /* The next priority value is the default language preferences list. */
1582       language_default = _nl_language_preferences_default ();
1583       if (language_default != NULL)
1584         return language_default;
1585     }
1586   /* The least priority value is the locale name, if defaulted.  */
1587 #endif
1588   return locale;
1589 }
1590
1591 #if (defined _LIBC || HAVE_ICONV) && !defined IN_LIBGLOCALE
1592 /* Returns the output charset.  */
1593 static const char *
1594 internal_function
1595 get_output_charset (struct binding *domainbinding)
1596 {
1597   /* The output charset should normally be determined by the locale.  But
1598      sometimes the locale is not used or not correctly set up, so we provide
1599      a possibility for the user to override this: the OUTPUT_CHARSET
1600      environment variable.  Moreover, the value specified through
1601      bind_textdomain_codeset overrides both.  */
1602   if (domainbinding != NULL && domainbinding->codeset != NULL)
1603     return domainbinding->codeset;
1604   else
1605     {
1606       /* For speed reasons, we look at the value of OUTPUT_CHARSET only
1607          once.  This is a user variable that is not supposed to change
1608          during a program run.  */
1609       static char *output_charset_cache;
1610       static int output_charset_cached;
1611
1612       if (!output_charset_cached)
1613         {
1614           const char *value = getenv ("OUTPUT_CHARSET");
1615
1616           if (value != NULL && value[0] != '\0')
1617             {
1618               size_t len = strlen (value) + 1;
1619               char *value_copy = (char *) malloc (len);
1620
1621               if (value_copy != NULL)
1622                 memcpy (value_copy, value, len);
1623               output_charset_cache = value_copy;
1624             }
1625           output_charset_cached = 1;
1626         }
1627
1628       if (output_charset_cache != NULL)
1629         return output_charset_cache;
1630       else
1631         {
1632 # ifdef _LIBC
1633           return _NL_CURRENT (LC_CTYPE, CODESET);
1634 # else
1635 #  if HAVE_ICONV
1636           return locale_charset ();
1637 #  endif
1638 # endif
1639         }
1640     }
1641 }
1642 #endif
1643
1644 /* @@ begin of epilog @@ */
1645
1646 /* We don't want libintl.a to depend on any other library.  So we
1647    avoid the non-standard function stpcpy.  In GNU C Library this
1648    function is available, though.  Also allow the symbol HAVE_STPCPY
1649    to be defined.  */
1650 #if !_LIBC && !HAVE_STPCPY
1651 static char *
1652 stpcpy (char *dest, const char *src)
1653 {
1654   while ((*dest++ = *src++) != '\0')
1655     /* Do nothing. */ ;
1656   return dest - 1;
1657 }
1658 #endif
1659
1660 #if !_LIBC && !HAVE_MEMPCPY
1661 static void *
1662 mempcpy (void *dest, const void *src, size_t n)
1663 {
1664   return (void *) ((char *) memcpy (dest, src, n) + n);
1665 }
1666 #endif
1667
1668 #if !_LIBC && !HAVE_TSEARCH
1669 # include "tsearch.c"
1670 #endif
1671
1672
1673 #ifdef _LIBC
1674 /* If we want to free all resources we have to do some work at
1675    program's end.  */
1676 libc_freeres_fn (free_mem)
1677 {
1678   void *old;
1679
1680   while (_nl_domain_bindings != NULL)
1681     {
1682       struct binding *oldp = _nl_domain_bindings;
1683       _nl_domain_bindings = _nl_domain_bindings->next;
1684       if (oldp->dirname != _nl_default_dirname)
1685         /* Yes, this is a pointer comparison.  */
1686         free (oldp->dirname);
1687       free (oldp->codeset);
1688       free (oldp);
1689     }
1690
1691   if (_nl_current_default_domain != _nl_default_default_domain)
1692     /* Yes, again a pointer comparison.  */
1693     free ((char *) _nl_current_default_domain);
1694
1695   /* Remove the search tree with the known translations.  */
1696   __tdestroy (root, free);
1697   root = NULL;
1698
1699   while (transmem_list != NULL)
1700     {
1701       old = transmem_list;
1702       transmem_list = transmem_list->next;
1703       free (old);
1704     }
1705 }
1706 #endif