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