intl/dcigettext.c

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