intl/dcigettext.c

   1 /* Implementation of the internal dcigettext function.
   2    Copyright (C) 1995-1999, 2000, 2001 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 General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    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 General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software Foundation,
  16    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 /* Tell glibc's <string.h> to provide a prototype for mempcpy().
  19    This must come before <config.h> because <config.h> may include
  20    <features.h>, and once <features.h> has been included, it's too late.  */
  21 #ifndef _GNU_SOURCE
  22 # define _GNU_SOURCE    1
  23 #endif
  24
  25 #ifdef HAVE_CONFIG_H
  26 # include <config.h>
  27 #endif
  28
  29 #include <sys/types.h>
  30
  31 #ifdef __GNUC__
  32 # define alloca __builtin_alloca
  33 # define HAVE_ALLOCA 1
  34 #else
  35 # if defined HAVE_ALLOCA_H || defined _LIBC
  36 #  include <alloca.h>
  37 # else
  38 #  ifdef _AIX
  39  #pragma alloca
  40 #  else
  41 #   ifndef alloca
  42 char *alloca ();
  43 #   endif
  44 #  endif
  45 # endif
  46 #endif
  47
  48 #include <errno.h>
  49 #ifndef errno
  50 extern int errno;
  51 #endif
  52 #ifndef __set_errno
  53 # define __set_errno(val) errno = (val)
  54 #endif
  55
  56 #include <stddef.h>
  57 #include <stdlib.h>
  58
  59 #include <string.h>
  60 #if !HAVE_STRCHR && !defined _LIBC
  61 # ifndef strchr
  62 #  define strchr index
  63 # endif
  64 #endif
  65
  66 #if defined HAVE_UNISTD_H || defined _LIBC
  67 # include <unistd.h>
  68 #endif
  69
  70 #include <locale.h>
  71
  72 #if defined HAVE_SYS_PARAM_H || defined _LIBC
  73 # include <sys/param.h>
  74 #endif
  75
  76 #include "gettextP.h"
  77 #ifdef _LIBC
  78 # include <libintl.h>
  79 #else
  80 # include "libgnuintl.h"
  81 #endif
  82 #include "hash-string.h"
  83
  84 /* Thread safetyness.  */
  85 #ifdef _LIBC
  86 # include <bits/libc-lock.h>
  87 #else
  88 /* Provide dummy implementation if this is outside glibc.  */
  89 # define __libc_lock_define_initialized(CLASS, NAME)
  90 # define __libc_lock_lock(NAME)
  91 # define __libc_lock_unlock(NAME)
  92 # define __libc_rwlock_define_initialized(CLASS, NAME)
  93 # define __libc_rwlock_rdlock(NAME)
  94 # define __libc_rwlock_unlock(NAME)
  95 #endif
  96
  97 /* Alignment of types.  */
  98 #if defined __GNUC__ && __GNUC__ >= 2
  99 # define alignof(TYPE) __alignof__ (TYPE)
 100 #else
 101 # define alignof(TYPE) \
 102     ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
 103 #endif
 104
 105 /* The internal variables in the standalone libintl.a must have different
 106    names than the internal variables in GNU libc, otherwise programs
 107    using libintl.a cannot be linked statically.  */
 108 #if !defined _LIBC
 109 # define _nl_default_default_domain _nl_default_default_domain__
 110 # define _nl_current_default_domain _nl_current_default_domain__
 111 # define _nl_default_dirname _nl_default_dirname__
 112 # define _nl_domain_bindings _nl_domain_bindings__
 113 #endif
 114
 115 /* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>.  */
 116 #ifndef offsetof
 117 # define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
 118 #endif
 119
 120 /* @@ end of prolog @@ */
 121
 122 #ifdef _LIBC
 123 /* Rename the non ANSI C functions.  This is required by the standard
 124    because some ANSI C functions will require linking with this object
 125    file and the name space must not be polluted.  */
 126 # define getcwd __getcwd
 127 # ifndef stpcpy
 128 #  define stpcpy __stpcpy
 129 # endif
 130 # define tfind __tfind
 131 #else
 132 # if !defined HAVE_GETCWD
 133 char *getwd ();
 134 #  define getcwd(buf, max) getwd (buf)
 135 # else
 136 char *getcwd ();
 137 # endif
 138 # ifndef HAVE_STPCPY
 139 static char *stpcpy PARAMS ((char *dest, const char *src));
 140 # endif
 141 # ifndef HAVE_MEMPCPY
 142 static void *mempcpy PARAMS ((void *dest, const void *src, size_t n));
 143 # endif
 144 #endif
 145
 146 /* Amount to increase buffer size by in each try.  */
 147 #define PATH_INCR 32
 148
 149 /* The following is from pathmax.h.  */
 150 /* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define
 151    PATH_MAX but might cause redefinition warnings when sys/param.h is
 152    later included (as on MORE/BSD 4.3).  */
 153 #if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__)
 154 # include <limits.h>
 155 #endif
 156
 157 #ifndef _POSIX_PATH_MAX
 158 # define _POSIX_PATH_MAX 255
 159 #endif
 160
 161 #if !defined PATH_MAX && defined _PC_PATH_MAX
 162 # define PATH_MAX (pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : pathconf ("/", _PC_PATH_MAX))
 163 #endif
 164
 165 /* Don't include sys/param.h if it already has been.  */
 166 #if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN
 167 # include <sys/param.h>
 168 #endif
 169
 170 #if !defined PATH_MAX && defined MAXPATHLEN
 171 # define PATH_MAX MAXPATHLEN
 172 #endif
 173
 174 #ifndef PATH_MAX
 175 # define PATH_MAX _POSIX_PATH_MAX
 176 #endif
 177
 178 /* Pathname support.
 179    ISSLASH(C)           tests whether C is a directory separator character.
 180    IS_ABSOLUTE_PATH(P)  tests whether P is an absolute path.  If it is not,
 181                         it may be concatenated to a directory pathname.
 182    IS_PATH_WITH_DIR(P)  tests whether P contains a directory specification.
 183  */
 184 #if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__
 185   /* Win32, OS/2, DOS */
 186 # define ISSLASH(C) ((C) == '/' || (C) == '\\')
 187 # define HAS_DEVICE(P) \
 188     ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
 189      && (P)[1] == ':')
 190 # define IS_ABSOLUTE_PATH(P) (ISSLASH ((P)[0]) || HAS_DEVICE (P))
 191 # define IS_PATH_WITH_DIR(P) \
 192     (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
 193 #else
 194   /* Unix */
 195 # define ISSLASH(C) ((C) == '/')
 196 # define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0])
 197 # define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
 198 #endif
 199
 200 /* XPG3 defines the result of `setlocale (category, NULL)' as:
 201    ``Directs `setlocale()' to query `category' and return the current
 202      setting of `local'.''
 203    However it does not specify the exact format.  Neither do SUSV2 and
 204    ISO C 99.  So we can use this feature only on selected systems (e.g.
 205    those using GNU C Library).  */
 206 #if defined _LIBC || (defined __GNU_LIBRARY__ && __GNU_LIBRARY__ >= 2)
 207 # define HAVE_LOCALE_NULL
 208 #endif
 209
 210 /* This is the type used for the search tree where known translations
 211    are stored.  */
 212 struct known_translation_t
 213 {
 214   /* Domain in which to search.  */
 215   char *domainname;
 216
 217   /* The category.  */
 218   int category;
 219
 220   /* State of the catalog counter at the point the string was found.  */
 221   int counter;
 222
 223   /* Catalog where the string was found.  */
 224   struct loaded_l10nfile *domain;
 225
 226   /* And finally the translation.  */
 227   const char *translation;
 228   size_t translation_length;
 229
 230   /* Pointer to the string in question.  */
 231   char msgid[ZERO];
 232 };
 233
 234 /* Root of the search tree with known translations.  We can use this
 235    only if the system provides the `tsearch' function family.  */
 236 #if defined HAVE_TSEARCH || defined _LIBC
 237 # include <search.h>
 238
 239 static void *root;
 240
 241 # ifdef _LIBC
 242 #  define tsearch __tsearch
 243 # endif
 244
 245 /* Function to compare two entries in the table of known translations.  */
 246 static int transcmp PARAMS ((const void *p1, const void *p2));
 247 static int
 248 transcmp (p1, p2)
 249      const void *p1;
 250      const void *p2;
 251 {
 252   const struct known_translation_t *s1;
 253   const struct known_translation_t *s2;
 254   int result;
 255
 256   s1 = (const struct known_translation_t *) p1;
 257   s2 = (const struct known_translation_t *) p2;
 258
 259   result = strcmp (s1->msgid, s2->msgid);
 260   if (result == 0)
 261     {
 262       result = strcmp (s1->domainname, s2->domainname);
 263       if (result == 0)
 264         /* We compare the category last (though this is the cheapest
 265            operation) since it is hopefully always the same (namely
 266            LC_MESSAGES).  */
 267         result = s1->category - s2->category;
 268     }
 269
 270   return result;
 271 }
 272 #endif
 273
 274 /* Name of the default domain used for gettext(3) prior any call to
 275    textdomain(3).  The default value for this is "messages".  */
 276 const char _nl_default_default_domain[] = "messages";
 277
 278 /* Value used as the default domain for gettext(3).  */
 279 const char *_nl_current_default_domain = _nl_default_default_domain;
 280
 281 /* Contains the default location of the message catalogs.  */
 282 const char _nl_default_dirname[] = LOCALEDIR;
 283
 284 /* List with bindings of specific domains created by bindtextdomain()
 285    calls.  */
 286 struct binding *_nl_domain_bindings;
 287
 288 /* Prototypes for local functions.  */
 289 static char *plural_lookup PARAMS ((struct loaded_l10nfile *domain,
 290                                     unsigned long int n,
 291                                     const char *translation,
 292                                     size_t translation_len))
 293      internal_function;
 294 static unsigned long int plural_eval PARAMS ((struct expression *pexp,
 295                                               unsigned long int n))
 296      internal_function;
 297 static const char *category_to_name PARAMS ((int category)) internal_function;
 298 static const char *guess_category_value PARAMS ((int category,
 299                                                  const char *categoryname))
 300      internal_function;
 301
 302
 303 /* For those loosing systems which don't have `alloca' we have to add
 304    some additional code emulating it.  */
 305 #ifdef HAVE_ALLOCA
 306 /* Nothing has to be done.  */
 307 # define ADD_BLOCK(list, address) /* nothing */
 308 # define FREE_BLOCKS(list) /* nothing */
 309 #else
 310 struct block_list
 311 {
 312   void *address;
 313   struct block_list *next;
 314 };
 315 # define ADD_BLOCK(list, addr)                                                \
 316   do {                                                                        \
 317     struct block_list *newp = (struct block_list *) malloc (sizeof (*newp));  \
 318     /* If we cannot get a free block we cannot add the new element to         \
 319        the list.  */                                                          \
 320     if (newp != NULL) {                                                       \
 321       newp->address = (addr);                                                 \
 322       newp->next = (list);                                                    \
 323       (list) = newp;                                                          \
 324     }                                                                         \
 325   } while (0)
 326 # define FREE_BLOCKS(list)                                                    \
 327   do {                                                                        \
 328     while (list != NULL) {                                                    \
 329       struct block_list *old = list;                                          \
 330       list = list->next;                                                      \
 331       free (old);                                                             \
 332     }                                                                         \
 333   } while (0)
 334 # undef alloca
 335 # define alloca(size) (malloc (size))
 336 #endif  /* have alloca */
 337
 338
 339 #ifdef _LIBC
 340 /* List of blocks allocated for translations.  */
 341 typedef struct transmem_list
 342 {
 343   struct transmem_list *next;
 344   char data[ZERO];
 345 } transmem_block_t;
 346 static struct transmem_list *transmem_list;
 347 #else
 348 typedef unsigned char transmem_block_t;
 349 #endif
 350
 351
 352 /* Names for the libintl functions are a problem.  They must not clash
 353    with existing names and they should follow ANSI C.  But this source
 354    code is also used in GNU C Library where the names have a __
 355    prefix.  So we have to make a difference here.  */
 356 #ifdef _LIBC
 357 # define DCIGETTEXT __dcigettext
 358 #else
 359 # define DCIGETTEXT dcigettext__
 360 #endif
 361
 362 /* Lock variable to protect the global data in the gettext implementation.  */
 363 #ifdef _LIBC
 364 __libc_rwlock_define_initialized (, _nl_state_lock)
 365 #endif
 366
 367 /* Checking whether the binaries runs SUID must be done and glibc provides
 368    easier methods therefore we make a difference here.  */
 369 #ifdef _LIBC
 370 # define ENABLE_SECURE __libc_enable_secure
 371 # define DETERMINE_SECURE
 372 #else
 373 # ifndef HAVE_GETUID
 374 #  define getuid() 0
 375 # endif
 376 # ifndef HAVE_GETGID
 377 #  define getgid() 0
 378 # endif
 379 # ifndef HAVE_GETEUID
 380 #  define geteuid() getuid()
 381 # endif
 382 # ifndef HAVE_GETEGID
 383 #  define getegid() getgid()
 384 # endif
 385 static int enable_secure;
 386 # define ENABLE_SECURE (enable_secure == 1)
 387 # define DETERMINE_SECURE \
 388   if (enable_secure == 0)                                                     \
 389     {                                                                         \
 390       if (getuid () != geteuid () || getgid () != getegid ())                 \
 391         enable_secure = 1;                                                    \
 392       else                                                                    \
 393         enable_secure = -1;                                                   \
 394     }
 395 #endif
 396
 397 /* Look up MSGID in the DOMAINNAME message catalog for the current
 398    CATEGORY locale and, if PLURAL is nonzero, search over string
 399    depending on the plural form determined by N.  */
 400 char *
 401 DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
 402      const char *domainname;
 403      const char *msgid1;
 404      const char *msgid2;
 405      int plural;
 406      unsigned long int n;
 407      int category;
 408 {
 409 #ifndef HAVE_ALLOCA
 410   struct block_list *block_list = NULL;
 411 #endif
 412   struct loaded_l10nfile *domain;
 413   struct binding *binding;
 414   const char *categoryname;
 415   const char *categoryvalue;
 416   char *dirname, *xdomainname;
 417   char *single_locale;
 418   char *retval;
 419   size_t retlen;
 420   int saved_errno;
 421 #if defined HAVE_TSEARCH || defined _LIBC
 422   struct known_translation_t *search;
 423   struct known_translation_t **foundp = NULL;
 424   size_t msgid_len;
 425 #endif
 426   size_t domainname_len;
 427
 428   /* If no real MSGID is given return NULL.  */
 429   if (msgid1 == NULL)
 430     return NULL;
 431
 432   __libc_rwlock_rdlock (_nl_state_lock);
 433
 434   /* If DOMAINNAME is NULL, we are interested in the default domain.  If
 435      CATEGORY is not LC_MESSAGES this might not make much sense but the
 436      definition left this undefined.  */
 437   if (domainname == NULL)
 438     domainname = _nl_current_default_domain;
 439
 440 #if defined HAVE_TSEARCH || defined _LIBC
 441   msgid_len = strlen (msgid1) + 1;
 442
 443   /* Try to find the translation among those which we found at
 444      some time.  */
 445   search = (struct known_translation_t *)
 446            alloca (offsetof (struct known_translation_t, msgid) + msgid_len);
 447   memcpy (search->msgid, msgid1, msgid_len);
 448   search->domainname = (char *) domainname;
 449   search->category = category;
 450
 451   foundp = (struct known_translation_t **) tfind (search, &root, transcmp);
 452   if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
 453     {
 454       /* Now deal with plural.  */
 455       if (plural)
 456         retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation,
 457                                 (*foundp)->translation_length);
 458       else
 459         retval = (char *) (*foundp)->translation;
 460
 461       __libc_rwlock_unlock (_nl_state_lock);
 462       return retval;
 463     }
 464 #endif
 465
 466   /* Preserve the `errno' value.  */
 467   saved_errno = errno;
 468
 469   /* See whether this is a SUID binary or not.  */
 470   DETERMINE_SECURE;
 471
 472   /* First find matching binding.  */
 473   for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
 474     {
 475       int compare = strcmp (domainname, binding->domainname);
 476       if (compare == 0)
 477         /* We found it!  */
 478         break;
 479       if (compare < 0)
 480         {
 481           /* It is not in the list.  */
 482           binding = NULL;
 483           break;
 484         }
 485     }
 486
 487   if (binding == NULL)
 488     dirname = (char *) _nl_default_dirname;
 489   else if (IS_ABSOLUTE_PATH (binding->dirname))
 490     dirname = binding->dirname;
 491   else
 492     {
 493       /* We have a relative path.  Make it absolute now.  */
 494       size_t dirname_len = strlen (binding->dirname) + 1;
 495       size_t path_max;
 496       char *ret;
 497
 498       path_max = (unsigned int) PATH_MAX;
 499       path_max += 2;            /* The getcwd docs say to do this.  */
 500
 501       for (;;)
 502         {
 503           dirname = (char *) alloca (path_max + dirname_len);
 504           ADD_BLOCK (block_list, dirname);
 505
 506           __set_errno (0);
 507           ret = getcwd (dirname, path_max);
 508           if (ret != NULL || errno != ERANGE)
 509             break;
 510
 511           path_max += path_max / 2;
 512           path_max += PATH_INCR;
 513         }
 514
 515       if (ret == NULL)
 516         {
 517           /* We cannot get the current working directory.  Don't signal an
 518              error but simply return the default string.  */
 519           FREE_BLOCKS (block_list);
 520           __set_errno (saved_errno);
 521           return (plural == 0
 522                   ? (char *) msgid1
 523                   /* Use the Germanic plural rule.  */
 524                   : n == 1 ? (char *) msgid1 : (char *) msgid2);
 525         }
 526
 527       stpcpy (stpcpy (strchr (dirname, '\0'), "/"), binding->dirname);
 528     }
 529
 530   /* Now determine the symbolic name of CATEGORY and its value.  */
 531   categoryname = category_to_name (category);
 532   categoryvalue = guess_category_value (category, categoryname);
 533
 534   domainname_len = strlen (domainname);
 535   xdomainname = (char *) alloca (strlen (categoryname)
 536                                  + domainname_len + 5);
 537   ADD_BLOCK (block_list, xdomainname);
 538
 539   stpcpy (mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"),
 540                   domainname, domainname_len),
 541           ".mo");
 542
 543   /* Creating working area.  */
 544   single_locale = (char *) alloca (strlen (categoryvalue) + 1);
 545   ADD_BLOCK (block_list, single_locale);
 546
 547
 548   /* Search for the given string.  This is a loop because we perhaps
 549      got an ordered list of languages to consider for the translation.  */
 550   while (1)
 551     {
 552       /* Make CATEGORYVALUE point to the next element of the list.  */
 553       while (categoryvalue[0] != '\0' && categoryvalue[0] == ':')
 554         ++categoryvalue;
 555       if (categoryvalue[0] == '\0')
 556         {
 557           /* The whole contents of CATEGORYVALUE has been searched but
 558              no valid entry has been found.  We solve this situation
 559              by implicitly appending a "C" entry, i.e. no translation
 560              will take place.  */
 561           single_locale[0] = 'C';
 562           single_locale[1] = '\0';
 563         }
 564       else
 565         {
 566           char *cp = single_locale;
 567           while (categoryvalue[0] != '\0' && categoryvalue[0] != ':')
 568             *cp++ = *categoryvalue++;
 569           *cp = '\0';
 570
 571           /* When this is a SUID binary we must not allow accessing files
 572              outside the dedicated directories.  */
 573           if (ENABLE_SECURE && IS_PATH_WITH_DIR (single_locale))
 574             /* Ingore this entry.  */
 575             continue;
 576         }
 577
 578       /* If the current locale value is C (or POSIX) we don't load a
 579          domain.  Return the MSGID.  */
 580       if (strcmp (single_locale, "C") == 0
 581           || strcmp (single_locale, "POSIX") == 0)
 582         {
 583           FREE_BLOCKS (block_list);
 584           __libc_rwlock_unlock (_nl_state_lock);
 585           __set_errno (saved_errno);
 586           return (plural == 0
 587                   ? (char *) msgid1
 588                   /* Use the Germanic plural rule.  */
 589                   : n == 1 ? (char *) msgid1 : (char *) msgid2);
 590         }
 591
 592
 593       /* Find structure describing the message catalog matching the
 594          DOMAINNAME and CATEGORY.  */
 595       domain = _nl_find_domain (dirname, single_locale, xdomainname, binding);
 596
 597       if (domain != NULL)
 598         {
 599           retval = _nl_find_msg (domain, binding, msgid1, &retlen);
 600
 601           if (retval == NULL)
 602             {
 603               int cnt;
 604
 605               for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
 606                 {
 607                   retval = _nl_find_msg (domain->successor[cnt], binding,
 608                                          msgid1, &retlen);
 609
 610                   if (retval != NULL)
 611                     {
 612                       domain = domain->successor[cnt];
 613                       break;
 614                     }
 615                 }
 616             }
 617
 618           if (retval != NULL)
 619             {
 620               /* Found the translation of MSGID1 in domain DOMAIN:
 621                  starting at RETVAL, RETLEN bytes.  */
 622               FREE_BLOCKS (block_list);
 623               __set_errno (saved_errno);
 624 #if defined HAVE_TSEARCH || defined _LIBC
 625               if (foundp == NULL)
 626                 {
 627                   /* Create a new entry and add it to the search tree.  */
 628                   struct known_translation_t *newp;
 629
 630                   newp = (struct known_translation_t *)
 631                     malloc (offsetof (struct known_translation_t, msgid)
 632                             + msgid_len + domainname_len + 1);
 633                   if (newp != NULL)
 634                     {
 635                       newp->domainname =
 636                         mempcpy (newp->msgid, msgid1, msgid_len);
 637                       memcpy (newp->domainname, domainname, domainname_len + 1);
 638                       newp->category = category;
 639                       newp->counter = _nl_msg_cat_cntr;
 640                       newp->domain = domain;
 641                       newp->translation = retval;
 642                       newp->translation_length = retlen;
 643
 644                       /* Insert the entry in the search tree.  */
 645                       foundp = (struct known_translation_t **)
 646                         tsearch (newp, &root, transcmp);
 647                       if (foundp == NULL
 648                           || __builtin_expect (*foundp != newp, 0))
 649                         /* The insert failed.  */
 650                         free (newp);
 651                     }
 652                 }
 653               else
 654                 {
 655                   /* We can update the existing entry.  */
 656                   (*foundp)->counter = _nl_msg_cat_cntr;
 657                   (*foundp)->domain = domain;
 658                   (*foundp)->translation = retval;
 659                   (*foundp)->translation_length = retlen;
 660                 }
 661 #endif
 662               /* Now deal with plural.  */
 663               if (plural)
 664                 retval = plural_lookup (domain, n, retval, retlen);
 665
 666               __libc_rwlock_unlock (_nl_state_lock);
 667               return retval;
 668             }
 669         }
 670     }
 671   /* NOTREACHED */
 672 }
 673
 674
 675 char *
 676 internal_function
 677 _nl_find_msg (domain_file, domainbinding, msgid, lengthp)
 678      struct loaded_l10nfile *domain_file;
 679      struct binding *domainbinding;
 680      const char *msgid;
 681      size_t *lengthp;
 682 {
 683   struct loaded_domain *domain;
 684   size_t act;
 685   char *result;
 686   size_t resultlen;
 687
 688   if (domain_file->decided == 0)
 689     _nl_load_domain (domain_file, domainbinding);
 690
 691   if (domain_file->data == NULL)
 692     return NULL;
 693
 694   domain = (struct loaded_domain *) domain_file->data;
 695
 696   /* Locate the MSGID and its translation.  */
 697   if (domain->hash_size > 2 && domain->hash_tab != NULL)
 698     {
 699       /* Use the hashing table.  */
 700       nls_uint32 len = strlen (msgid);
 701       nls_uint32 hash_val = hash_string (msgid);
 702       nls_uint32 idx = hash_val % domain->hash_size;
 703       nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));
 704
 705       while (1)
 706         {
 707           nls_uint32 nstr = W (domain->must_swap, domain->hash_tab[idx]);
 708
 709           if (nstr == 0)
 710             /* Hash table entry is empty.  */
 711             return NULL;
 712
 713           /* Compare msgid with the original string at index nstr-1.
 714              We compare the lengths with >=, not ==, because plural entries
 715              are represented by strings with an embedded NUL.  */
 716           if (W (domain->must_swap, domain->orig_tab[nstr - 1].length) >= len
 717               && (strcmp (msgid,
 718                           domain->data + W (domain->must_swap,
 719                                             domain->orig_tab[nstr - 1].offset))
 720                   == 0))
 721             {
 722               act = nstr - 1;
 723               goto found;
 724             }
 725
 726           if (idx >= domain->hash_size - incr)
 727             idx -= domain->hash_size - incr;
 728           else
 729             idx += incr;
 730         }
 731       /* NOTREACHED */
 732     }
 733   else
 734     {
 735       /* Try the default method:  binary search in the sorted array of
 736          messages.  */
 737       size_t top, bottom;
 738
 739       bottom = 0;
 740       top = domain->nstrings;
 741       while (bottom < top)
 742         {
 743           int cmp_val;
 744
 745           act = (bottom + top) / 2;
 746           cmp_val = strcmp (msgid, (domain->data
 747                                     + W (domain->must_swap,
 748                                          domain->orig_tab[act].offset)));
 749           if (cmp_val < 0)
 750             top = act;
 751           else if (cmp_val > 0)
 752             bottom = act + 1;
 753           else
 754             goto found;
 755         }
 756       /* No translation was found.  */
 757       return NULL;
 758     }
 759
 760  found:
 761   /* The translation was found at index ACT.  If we have to convert the
 762      string to use a different character set, this is the time.  */
 763   result = ((char *) domain->data
 764             + W (domain->must_swap, domain->trans_tab[act].offset));
 765   resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
 766
 767 #if defined _LIBC || HAVE_ICONV
 768   if (domain->codeset_cntr
 769       != (domainbinding != NULL ? domainbinding->codeset_cntr : 0))
 770     {
 771       /* The domain's codeset has changed through bind_textdomain_codeset()
 772          since the message catalog was initialized or last accessed.  We
 773          have to reinitialize the converter.  */
 774       _nl_free_domain_conv (domain);
 775       _nl_init_domain_conv (domain_file, domain, domainbinding);
 776     }
 777
 778   if (
 779 # ifdef _LIBC
 780       domain->conv != (__gconv_t) -1
 781 # else
 782 #  if HAVE_ICONV
 783       domain->conv != (iconv_t) -1
 784 #  endif
 785 # endif
 786       )
 787     {
 788       /* We are supposed to do a conversion.  First allocate an
 789          appropriate table with the same structure as the table
 790          of translations in the file, where we can put the pointers
 791          to the converted strings in.
 792          There is a slight complication with plural entries.  They
 793          are represented by consecutive NUL terminated strings.  We
 794          handle this case by converting RESULTLEN bytes, including
 795          NULs.  */
 796
 797       if (domain->conv_tab == NULL
 798           && ((domain->conv_tab = (char **) calloc (domain->nstrings,
 799                                                     sizeof (char *)))
 800               == NULL))
 801         /* Mark that we didn't succeed allocating a table.  */
 802         domain->conv_tab = (char **) -1;
 803
 804       if (__builtin_expect (domain->conv_tab == (char **) -1, 0))
 805         /* Nothing we can do, no more memory.  */
 806         goto converted;
 807
 808       if (domain->conv_tab[act] == NULL)
 809         {
 810           /* We haven't used this string so far, so it is not
 811              translated yet.  Do this now.  */
 812           /* We use a bit more efficient memory handling.
 813              We allocate always larger blocks which get used over
 814              time.  This is faster than many small allocations.   */
 815           __libc_lock_define_initialized (static, lock)
 816 # define INITIAL_BLOCK_SIZE     4080
 817           static unsigned char *freemem;
 818           static size_t freemem_size;
 819
 820           const unsigned char *inbuf;
 821           unsigned char *outbuf;
 822           int malloc_count;
 823 # ifndef _LIBC
 824           transmem_block_t *transmem_list = NULL;
 825 # endif
 826
 827           __libc_lock_lock (lock);
 828
 829           inbuf = (const unsigned char *) result;
 830           outbuf = freemem + sizeof (size_t);
 831
 832           malloc_count = 0;
 833           while (1)
 834             {
 835               transmem_block_t *newmem;
 836 # ifdef _LIBC
 837               size_t non_reversible;
 838               int res;
 839
 840               if (freemem_size < sizeof (size_t))
 841                 goto resize_freemem;
 842
 843               res = __gconv (domain->conv,
 844                              &inbuf, inbuf + resultlen,
 845                              &outbuf,
 846                              outbuf + freemem_size - sizeof (size_t),
 847                              &non_reversible);
 848
 849               if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
 850                 break;
 851
 852               if (res != __GCONV_FULL_OUTPUT)
 853                 {
 854                   __libc_lock_unlock (lock);
 855                   goto converted;
 856                 }
 857
 858               inbuf = result;
 859 # else
 860 #  if HAVE_ICONV
 861               const char *inptr = (const char *) inbuf;
 862               size_t inleft = resultlen;
 863               char *outptr = (char *) outbuf;
 864               size_t outleft;
 865
 866               if (freemem_size < sizeof (size_t))
 867                 goto resize_freemem;
 868
 869               outleft = freemem_size - sizeof (size_t);
 870               if (iconv (domain->conv,
 871                          (ICONV_CONST char **) &inptr, &inleft,
 872                          &outptr, &outleft)
 873                   != (size_t) (-1))
 874                 {
 875                   outbuf = (unsigned char *) outptr;
 876                   break;
 877                 }
 878               if (errno != E2BIG)
 879                 {
 880                   __libc_lock_unlock (lock);
 881                   goto converted;
 882                 }
 883 #  endif
 884 # endif
 885
 886             resize_freemem:
 887               /* We must allocate a new buffer or resize the old one.  */
 888               if (malloc_count > 0)
 889                 {
 890                   ++malloc_count;
 891                   freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
 892                   newmem = (transmem_block_t *) realloc (transmem_list,
 893                                                          freemem_size);
 894 # ifdef _LIBC
 895                   if (newmem != NULL)
 896                     transmem_list = transmem_list->next;
 897                   else
 898                     {
 899                       struct transmem_list *old = transmem_list;
 900
 901                       transmem_list = transmem_list->next;
 902                       free (old);
 903                     }
 904 # endif
 905                 }
 906               else
 907                 {
 908                   malloc_count = 1;
 909                   freemem_size = INITIAL_BLOCK_SIZE;
 910                   newmem = (transmem_block_t *) malloc (freemem_size);
 911                 }
 912               if (__builtin_expect (newmem == NULL, 0))
 913                 {
 914                   freemem = NULL;
 915                   freemem_size = 0;
 916                   __libc_lock_unlock (lock);
 917                   goto converted;
 918                 }
 919
 920 # ifdef _LIBC
 921               /* Add the block to the list of blocks we have to free
 922                  at some point.  */
 923               newmem->next = transmem_list;
 924               transmem_list = newmem;
 925
 926               freemem = newmem->data;
 927               freemem_size -= offsetof (struct transmem_list, data);
 928 # else
 929               transmem_list = newmem;
 930               freemem = newmem;
 931 # endif
 932
 933               outbuf = freemem + sizeof (size_t);
 934             }
 935
 936           /* We have now in our buffer a converted string.  Put this
 937              into the table of conversions.  */
 938           *(size_t *) freemem = outbuf - freemem - sizeof (size_t);
 939           domain->conv_tab[act] = (char *) freemem;
 940           /* Shrink freemem, but keep it aligned.  */
 941           freemem_size -= outbuf - freemem;
 942           freemem = outbuf;
 943           freemem += freemem_size & (alignof (size_t) - 1);
 944           freemem_size = freemem_size & ~ (alignof (size_t) - 1);
 945
 946           __libc_lock_unlock (lock);
 947         }
 948
 949       /* Now domain->conv_tab[act] contains the translation of all
 950          the plural variants.  */
 951       result = domain->conv_tab[act] + sizeof (size_t);
 952       resultlen = *(size_t *) domain->conv_tab[act];
 953     }
 954
 955  converted:
 956   /* The result string is converted.  */
 957
 958 #endif /* _LIBC || HAVE_ICONV */
 959
 960   *lengthp = resultlen;
 961   return result;
 962 }
 963
 964
 965 /* Look up a plural variant.  */
 966 static char *
 967 internal_function
 968 plural_lookup (domain, n, translation, translation_len)
 969      struct loaded_l10nfile *domain;
 970      unsigned long int n;
 971      const char *translation;
 972      size_t translation_len;
 973 {
 974   struct loaded_domain *domaindata = (struct loaded_domain *) domain->data;
 975   unsigned long int index;
 976   const char *p;
 977
 978   index = plural_eval (domaindata->plural, n);
 979   if (index >= domaindata->nplurals)
 980     /* This should never happen.  It means the plural expression and the
 981        given maximum value do not match.  */
 982     index = 0;
 983
 984   /* Skip INDEX strings at TRANSLATION.  */
 985   p = translation;
 986   while (index-- > 0)
 987     {
 988 #ifdef _LIBC
 989       p = __rawmemchr (p, '\0');
 990 #else
 991       p = strchr (p, '\0');
 992 #endif
 993       /* And skip over the NUL byte.  */
 994       p++;
 995
 996       if (p >= translation + translation_len)
 997         /* This should never happen.  It means the plural expression
 998            evaluated to a value larger than the number of variants
 999            available for MSGID1.  */
1000         return (char *) translation;
1001     }
1002   return (char *) p;
1003 }
1004
1005
1006 /* Function to evaluate the plural expression and return an index value.  */
1007 static unsigned long int
1008 internal_function
1009 plural_eval (pexp, n)
1010      struct expression *pexp;
1011      unsigned long int n;
1012 {
1013   switch (pexp->nargs)
1014     {
1015     case 0:
1016       switch (pexp->operation)
1017         {
1018         case var:
1019           return n;
1020         case num:
1021           return pexp->val.num;
1022         default:
1023           break;
1024         }
1025       /* NOTREACHED */
1026       break;
1027     case 1:
1028       {
1029         /* pexp->operation must be lnot.  */
1030         unsigned long int arg = plural_eval (pexp->val.args[0], n);
1031         return ! arg;
1032       }
1033     case 2:
1034       {
1035         unsigned long int leftarg = plural_eval (pexp->val.args[0], n);
1036         if (pexp->operation == lor)
1037           return leftarg || plural_eval (pexp->val.args[1], n);
1038         else if (pexp->operation == land)
1039           return leftarg && plural_eval (pexp->val.args[1], n);
1040         else
1041           {
1042             unsigned long int rightarg = plural_eval (pexp->val.args[1], n);
1043
1044             switch (pexp->operation)
1045               {
1046               case mult:
1047                 return leftarg * rightarg;
1048               case divide:
1049                 return leftarg / rightarg;
1050               case module:
1051                 return leftarg % rightarg;
1052               case plus:
1053                 return leftarg + rightarg;
1054               case minus:
1055                 return leftarg - rightarg;
1056               case less_than:
1057                 return leftarg < rightarg;
1058               case greater_than:
1059                 return leftarg > rightarg;
1060               case less_or_equal:
1061                 return leftarg <= rightarg;
1062               case greater_or_equal:
1063                 return leftarg >= rightarg;
1064               case equal:
1065                 return leftarg == rightarg;
1066               case not_equal:
1067                 return leftarg != rightarg;
1068               default:
1069                 break;
1070               }
1071           }
1072         /* NOTREACHED */
1073         break;
1074       }
1075     case 3:
1076       {
1077         /* pexp->operation must be qmop.  */
1078         unsigned long int boolarg = plural_eval (pexp->val.args[0], n);
1079         return plural_eval (pexp->val.args[boolarg ? 1 : 2], n);
1080       }
1081     }
1082   /* NOTREACHED */
1083   return 0;
1084 }
1085
1086
1087 /* Return string representation of locale CATEGORY.  */
1088 static const char *
1089 internal_function
1090 category_to_name (category)
1091      int category;
1092 {
1093   const char *retval;
1094
1095   switch (category)
1096   {
1097 #ifdef LC_COLLATE
1098   case LC_COLLATE:
1099     retval = "LC_COLLATE";
1100     break;
1101 #endif
1102 #ifdef LC_CTYPE
1103   case LC_CTYPE:
1104     retval = "LC_CTYPE";
1105     break;
1106 #endif
1107 #ifdef LC_MONETARY
1108   case LC_MONETARY:
1109     retval = "LC_MONETARY";
1110     break;
1111 #endif
1112 #ifdef LC_NUMERIC
1113   case LC_NUMERIC:
1114     retval = "LC_NUMERIC";
1115     break;
1116 #endif
1117 #ifdef LC_TIME
1118   case LC_TIME:
1119     retval = "LC_TIME";
1120     break;
1121 #endif
1122 #ifdef LC_MESSAGES
1123   case LC_MESSAGES:
1124     retval = "LC_MESSAGES";
1125     break;
1126 #endif
1127 #ifdef LC_RESPONSE
1128   case LC_RESPONSE:
1129     retval = "LC_RESPONSE";
1130     break;
1131 #endif
1132 #ifdef LC_ALL
1133   case LC_ALL:
1134     /* This might not make sense but is perhaps better than any other
1135        value.  */
1136     retval = "LC_ALL";
1137     break;
1138 #endif
1139   default:
1140     /* If you have a better idea for a default value let me know.  */
1141     retval = "LC_XXX";
1142   }
1143
1144   return retval;
1145 }
1146
1147 /* Guess value of current locale from value of the environment variables.  */
1148 static const char *
1149 internal_function
1150 guess_category_value (category, categoryname)
1151      int category;
1152      const char *categoryname;
1153 {
1154   const char *language;
1155   const char *retval;
1156
1157   /* The highest priority value is the `LANGUAGE' environment
1158      variable.  But we don't use the value if the currently selected
1159      locale is the C locale.  This is a GNU extension.  */
1160   language = getenv ("LANGUAGE");
1161   if (language != NULL && language[0] == '\0')
1162     language = NULL;
1163
1164   /* We have to proceed with the POSIX methods of looking to `LC_ALL',
1165      `LC_xxx', and `LANG'.  On some systems this can be done by the
1166      `setlocale' function itself.  */
1167 #if defined _LIBC || (defined HAVE_SETLOCALE && defined HAVE_LC_MESSAGES && defined HAVE_LOCALE_NULL)
1168   retval = setlocale (category, NULL);
1169 #else
1170   /* Setting of LC_ALL overwrites all other.  */
1171   retval = getenv ("LC_ALL");
1172   if (retval == NULL || retval[0] == '\0')
1173     {
1174       /* Next comes the name of the desired category.  */
1175       retval = getenv (categoryname);
1176       if (retval == NULL || retval[0] == '\0')
1177         {
1178           /* Last possibility is the LANG environment variable.  */
1179           retval = getenv ("LANG");
1180           if (retval == NULL || retval[0] == '\0')
1181             /* We use C as the default domain.  POSIX says this is
1182                implementation defined.  */
1183             return "C";
1184         }
1185     }
1186 #endif
1187
1188   return language != NULL && strcmp (retval, "C") != 0 ? language : retval;
1189 }
1190
1191 /* @@ begin of epilog @@ */
1192
1193 /* We don't want libintl.a to depend on any other library.  So we
1194    avoid the non-standard function stpcpy.  In GNU C Library this
1195    function is available, though.  Also allow the symbol HAVE_STPCPY
1196    to be defined.  */
1197 #if !_LIBC && !HAVE_STPCPY
1198 static char *
1199 stpcpy (dest, src)
1200      char *dest;
1201      const char *src;
1202 {
1203   while ((*dest++ = *src++) != '\0')
1204     /* Do nothing. */ ;
1205   return dest - 1;
1206 }
1207 #endif
1208
1209 #if !_LIBC && !HAVE_MEMPCPY
1210 static void *
1211 mempcpy (dest, src, n)
1212      void *dest;
1213      const void *src;
1214      size_t n;
1215 {
1216   return (void *) ((char *) memcpy (dest, src, n) + n);
1217 }
1218 #endif
1219
1220
1221 #ifdef _LIBC
1222 /* If we want to free all resources we have to do some work at
1223    program's end.  */
1224 static void __attribute__ ((unused))
1225 free_mem (void)
1226 {
1227   void *old;
1228
1229   while (_nl_domain_bindings != NULL)
1230     {
1231       struct binding *oldp = _nl_domain_bindings;
1232       _nl_domain_bindings = _nl_domain_bindings->next;
1233       if (oldp->dirname != _nl_default_dirname)
1234         /* Yes, this is a pointer comparison.  */
1235         free (oldp->dirname);
1236       free (oldp->codeset);
1237       free (oldp);
1238     }
1239
1240   if (_nl_current_default_domain != _nl_default_default_domain)
1241     /* Yes, again a pointer comparison.  */
1242     free ((char *) _nl_current_default_domain);
1243
1244   /* Remove the search tree with the known translations.  */
1245   __tdestroy (root, free);
1246   root = NULL;
1247
1248   while (transmem_list != NULL)
1249     {
1250       old = transmem_list;
1251       transmem_list = transmem_list->next;
1252       free (old);
1253     }
1254 }
1255
1256 text_set_element (__libc_subfreeres, free_mem);
1257 #endif