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