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