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