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