intl/dcigettext.c

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