intl/dcigettext.c

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