intl/dcigettext.c

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