1 /* Implementation of the internal dcigettext function.
2 Copyright (C) 1995-1999, 2000-2003 Free Software Foundation, Inc.
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)
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.
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,
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. */
23 # define _GNU_SOURCE 1
30 #include <sys/types.h>
33 # define alloca __builtin_alloca
34 # define HAVE_ALLOCA 1
38 # define alloca _alloca
40 # if defined HAVE_ALLOCA_H || defined _LIBC
59 # define __set_errno(val) errno = (val)
66 #if defined HAVE_UNISTD_H || defined _LIBC
73 #if defined HAVE_SYS_PARAM_H || defined _LIBC
74 # include <sys/param.h>
78 #include "plural-exp.h"
82 # include "libgnuintl.h"
84 #include "hash-string.h"
86 /* Thread safetyness. */
88 # include <bits/libc-lock.h>
90 /* Provide dummy implementation if this is outside glibc. */
91 # define __libc_lock_define_initialized(CLASS, NAME)
92 # define __libc_lock_lock(NAME)
93 # define __libc_lock_unlock(NAME)
94 # define __libc_rwlock_define_initialized(CLASS, NAME)
95 # define __libc_rwlock_rdlock(NAME)
96 # define __libc_rwlock_unlock(NAME)
99 /* Alignment of types. */
100 #if defined __GNUC__ && __GNUC__ >= 2
101 # define alignof(TYPE) __alignof__ (TYPE)
103 # define alignof(TYPE) \
104 ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
107 /* The internal variables in the standalone libintl.a must have different
108 names than the internal variables in GNU libc, otherwise programs
109 using libintl.a cannot be linked statically. */
111 # define _nl_default_default_domain libintl_nl_default_default_domain
112 # define _nl_current_default_domain libintl_nl_current_default_domain
113 # define _nl_default_dirname libintl_nl_default_dirname
114 # define _nl_domain_bindings libintl_nl_domain_bindings
117 /* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>. */
119 # define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
122 /* @@ end of prolog @@ */
125 /* Rename the non ANSI C functions. This is required by the standard
126 because some ANSI C functions will require linking with this object
127 file and the name space must not be polluted. */
128 # define getcwd __getcwd
130 # define stpcpy __stpcpy
132 # define tfind __tfind
134 # if !defined HAVE_GETCWD
136 # define getcwd(buf, max) getwd (buf)
139 # define getcwd(buf, max) (getcwd) (buf, max, 0)
145 static char *stpcpy (char *dest, const char *src);
147 # ifndef HAVE_MEMPCPY
148 static void *mempcpy (void *dest, const void *src, size_t n);
152 /* Amount to increase buffer size by in each try. */
155 /* The following is from pathmax.h. */
156 /* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define
157 PATH_MAX but might cause redefinition warnings when sys/param.h is
158 later included (as on MORE/BSD 4.3). */
159 #if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__)
163 #ifndef _POSIX_PATH_MAX
164 # define _POSIX_PATH_MAX 255
167 #if !defined PATH_MAX && defined _PC_PATH_MAX
168 # define PATH_MAX (pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : pathconf ("/", _PC_PATH_MAX))
171 /* Don't include sys/param.h if it already has been. */
172 #if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN
173 # include <sys/param.h>
176 #if !defined PATH_MAX && defined MAXPATHLEN
177 # define PATH_MAX MAXPATHLEN
181 # define PATH_MAX _POSIX_PATH_MAX
185 ISSLASH(C) tests whether C is a directory separator character.
186 IS_ABSOLUTE_PATH(P) tests whether P is an absolute path. If it is not,
187 it may be concatenated to a directory pathname.
188 IS_PATH_WITH_DIR(P) tests whether P contains a directory specification.
190 #if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__
191 /* Win32, OS/2, DOS */
192 # define ISSLASH(C) ((C) == '/' || (C) == '\\')
193 # define HAS_DEVICE(P) \
194 ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
196 # define IS_ABSOLUTE_PATH(P) (ISSLASH ((P)[0]) || HAS_DEVICE (P))
197 # define IS_PATH_WITH_DIR(P) \
198 (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
201 # define ISSLASH(C) ((C) == '/')
202 # define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0])
203 # define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
206 /* This is the type used for the search tree where known translations
208 struct known_translation_t
210 /* Domain in which to search. */
216 /* State of the catalog counter at the point the string was found. */
219 /* Catalog where the string was found. */
220 struct loaded_l10nfile *domain;
222 /* And finally the translation. */
223 const char *translation;
224 size_t translation_length;
226 /* Pointer to the string in question. */
230 /* Root of the search tree with known translations. We can use this
231 only if the system provides the `tsearch' function family. */
232 #if defined HAVE_TSEARCH || defined _LIBC
238 # define tsearch __tsearch
241 /* Function to compare two entries in the table of known translations. */
243 transcmp (const void *p1, const void *p2)
245 const struct known_translation_t *s1;
246 const struct known_translation_t *s2;
249 s1 = (const struct known_translation_t *) p1;
250 s2 = (const struct known_translation_t *) p2;
252 result = strcmp (s1->msgid, s2->msgid);
255 result = strcmp (s1->domainname, s2->domainname);
257 /* We compare the category last (though this is the cheapest
258 operation) since it is hopefully always the same (namely
260 result = s1->category - s2->category;
268 # define INTVARDEF(name)
271 # define INTUSE(name) name
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";
278 /* Value used as the default domain for gettext(3). */
279 const char *_nl_current_default_domain attribute_hidden
280 = _nl_default_default_domain;
282 /* Contains the default location of the message catalogs. */
284 extern const char _nl_default_dirname[];
286 const char _nl_default_dirname[] = LOCALEDIR;
287 INTVARDEF (_nl_default_dirname)
290 /* List with bindings of specific domains created by bindtextdomain()
292 struct binding *_nl_domain_bindings;
294 /* Prototypes for local functions. */
295 static char *plural_lookup (struct loaded_l10nfile *domain,
297 const char *translation, size_t translation_len)
299 static const char *guess_category_value (int category,
300 const char *categoryname)
303 # include "../locale/localeinfo.h"
304 # define category_to_name(category) _nl_category_names[category]
306 static const char *category_to_name (int category) internal_function;
310 /* For those loosing systems which don't have `alloca' we have to add
311 some additional code emulating it. */
313 /* Nothing has to be done. */
314 # define freea(p) /* nothing */
315 # define ADD_BLOCK(list, address) /* nothing */
316 # define FREE_BLOCKS(list) /* nothing */
321 struct block_list *next;
323 # define ADD_BLOCK(list, addr) \
325 struct block_list *newp = (struct block_list *) malloc (sizeof (*newp)); \
326 /* If we cannot get a free block we cannot add the new element to \
328 if (newp != NULL) { \
329 newp->address = (addr); \
330 newp->next = (list); \
334 # define FREE_BLOCKS(list) \
336 while (list != NULL) { \
337 struct block_list *old = list; \
339 free (old->address); \
344 # define alloca(size) (malloc (size))
345 # define freea(p) free (p)
346 #endif /* have alloca */
350 /* List of blocks allocated for translations. */
351 typedef struct transmem_list
353 struct transmem_list *next;
356 static struct transmem_list *transmem_list;
358 typedef unsigned char transmem_block_t;
362 /* Names for the libintl functions are a problem. They must not clash
363 with existing names and they should follow ANSI C. But this source
364 code is also used in GNU C Library where the names have a __
365 prefix. So we have to make a difference here. */
367 # define DCIGETTEXT __dcigettext
369 # define DCIGETTEXT libintl_dcigettext
372 /* Lock variable to protect the global data in the gettext implementation. */
374 __libc_rwlock_define_initialized (, _nl_state_lock attribute_hidden)
377 /* Checking whether the binaries runs SUID must be done and glibc provides
378 easier methods therefore we make a difference here. */
380 # define ENABLE_SECURE __libc_enable_secure
381 # define DETERMINE_SECURE
389 # ifndef HAVE_GETEUID
390 # define geteuid() getuid()
392 # ifndef HAVE_GETEGID
393 # define getegid() getgid()
395 static int enable_secure;
396 # define ENABLE_SECURE (enable_secure == 1)
397 # define DETERMINE_SECURE \
398 if (enable_secure == 0) \
400 if (getuid () != geteuid () || getgid () != getegid ()) \
403 enable_secure = -1; \
407 /* Get the function to evaluate the plural expression. */
408 #include "eval-plural.h"
410 /* Look up MSGID in the DOMAINNAME message catalog for the current
411 CATEGORY locale and, if PLURAL is nonzero, search over string
412 depending on the plural form determined by N. */
414 DCIGETTEXT (const char *domainname, const char *msgid1, const char *msgid2,
415 int plural, unsigned long int n, int category)
418 struct block_list *block_list = NULL;
420 struct loaded_l10nfile *domain;
421 struct binding *binding;
422 const char *categoryname;
423 const char *categoryvalue;
424 char *dirname, *xdomainname;
429 #if defined HAVE_TSEARCH || defined _LIBC
430 struct known_translation_t *search;
431 struct known_translation_t **foundp = NULL;
434 size_t domainname_len;
436 /* If no real MSGID is given return NULL. */
441 if (category < 0 || category >= __LC_LAST || category == LC_ALL)
445 /* Use the Germanic plural rule. */
446 : n == 1 ? (char *) msgid1 : (char *) msgid2);
449 __libc_rwlock_rdlock (_nl_state_lock);
451 /* If DOMAINNAME is NULL, we are interested in the default domain. If
452 CATEGORY is not LC_MESSAGES this might not make much sense but the
453 definition left this undefined. */
454 if (domainname == NULL)
455 domainname = _nl_current_default_domain;
457 /* OS/2 specific: backward compatibility with older libintl versions */
458 #ifdef LC_MESSAGES_COMPAT
459 if (category == LC_MESSAGES_COMPAT)
460 category = LC_MESSAGES;
463 #if defined HAVE_TSEARCH || defined _LIBC
464 msgid_len = strlen (msgid1) + 1;
466 /* Try to find the translation among those which we found at
468 search = (struct known_translation_t *)
469 alloca (offsetof (struct known_translation_t, msgid) + msgid_len);
470 memcpy (search->msgid, msgid1, msgid_len);
471 search->domainname = (char *) domainname;
472 search->category = category;
474 foundp = (struct known_translation_t **) tfind (search, &root, transcmp);
476 if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
478 /* Now deal with plural. */
480 retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation,
481 (*foundp)->translation_length);
483 retval = (char *) (*foundp)->translation;
485 __libc_rwlock_unlock (_nl_state_lock);
490 /* Preserve the `errno' value. */
493 /* See whether this is a SUID binary or not. */
496 /* First find matching binding. */
497 for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
499 int compare = strcmp (domainname, binding->domainname);
505 /* It is not in the list. */
512 dirname = (char *) INTUSE(_nl_default_dirname);
513 else if (IS_ABSOLUTE_PATH (binding->dirname))
514 dirname = binding->dirname;
517 /* We have a relative path. Make it absolute now. */
518 size_t dirname_len = strlen (binding->dirname) + 1;
522 path_max = (unsigned int) PATH_MAX;
523 path_max += 2; /* The getcwd docs say to do this. */
527 dirname = (char *) alloca (path_max + dirname_len);
528 ADD_BLOCK (block_list, dirname);
531 ret = getcwd (dirname, path_max);
532 if (ret != NULL || errno != ERANGE)
535 path_max += path_max / 2;
536 path_max += PATH_INCR;
540 /* We cannot get the current working directory. Don't signal an
541 error but simply return the default string. */
542 goto return_untranslated;
544 stpcpy (stpcpy (strchr (dirname, '\0'), "/"), binding->dirname);
547 /* Now determine the symbolic name of CATEGORY and its value. */
548 categoryname = category_to_name (category);
549 categoryvalue = guess_category_value (category, categoryname);
551 domainname_len = strlen (domainname);
552 xdomainname = (char *) alloca (strlen (categoryname)
553 + domainname_len + 5);
554 ADD_BLOCK (block_list, xdomainname);
556 stpcpy (mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"),
557 domainname, domainname_len),
560 /* Creating working area. */
561 single_locale = (char *) alloca (strlen (categoryvalue) + 1);
562 ADD_BLOCK (block_list, single_locale);
565 /* Search for the given string. This is a loop because we perhaps
566 got an ordered list of languages to consider for the translation. */
569 /* Make CATEGORYVALUE point to the next element of the list. */
570 while (categoryvalue[0] != '\0' && categoryvalue[0] == ':')
572 if (categoryvalue[0] == '\0')
574 /* The whole contents of CATEGORYVALUE has been searched but
575 no valid entry has been found. We solve this situation
576 by implicitly appending a "C" entry, i.e. no translation
578 single_locale[0] = 'C';
579 single_locale[1] = '\0';
583 char *cp = single_locale;
584 while (categoryvalue[0] != '\0' && categoryvalue[0] != ':')
585 *cp++ = *categoryvalue++;
588 /* When this is a SUID binary we must not allow accessing files
589 outside the dedicated directories. */
590 if (ENABLE_SECURE && IS_PATH_WITH_DIR (single_locale))
591 /* Ingore this entry. */
595 /* If the current locale value is C (or POSIX) we don't load a
596 domain. Return the MSGID. */
597 if (strcmp (single_locale, "C") == 0
598 || strcmp (single_locale, "POSIX") == 0)
601 /* Find structure describing the message catalog matching the
602 DOMAINNAME and CATEGORY. */
603 domain = _nl_find_domain (dirname, single_locale, xdomainname, binding);
607 retval = _nl_find_msg (domain, binding, msgid1, &retlen);
613 for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
615 retval = _nl_find_msg (domain->successor[cnt], binding,
620 domain = domain->successor[cnt];
628 /* Found the translation of MSGID1 in domain DOMAIN:
629 starting at RETVAL, RETLEN bytes. */
630 FREE_BLOCKS (block_list);
631 #if defined HAVE_TSEARCH || defined _LIBC
634 /* Create a new entry and add it to the search tree. */
635 struct known_translation_t *newp;
637 newp = (struct known_translation_t *)
638 malloc (offsetof (struct known_translation_t, msgid)
639 + msgid_len + domainname_len + 1);
643 mempcpy (newp->msgid, msgid1, msgid_len);
644 memcpy (newp->domainname, domainname, domainname_len + 1);
645 newp->category = category;
646 newp->counter = _nl_msg_cat_cntr;
647 newp->domain = domain;
648 newp->translation = retval;
649 newp->translation_length = retlen;
651 /* Insert the entry in the search tree. */
652 foundp = (struct known_translation_t **)
653 tsearch (newp, &root, transcmp);
655 || __builtin_expect (*foundp != newp, 0))
656 /* The insert failed. */
662 /* We can update the existing entry. */
663 (*foundp)->counter = _nl_msg_cat_cntr;
664 (*foundp)->domain = domain;
665 (*foundp)->translation = retval;
666 (*foundp)->translation_length = retlen;
669 __set_errno (saved_errno);
671 /* Now deal with plural. */
673 retval = plural_lookup (domain, n, retval, retlen);
675 __libc_rwlock_unlock (_nl_state_lock);
682 /* Return the untranslated MSGID. */
683 FREE_BLOCKS (block_list);
684 __libc_rwlock_unlock (_nl_state_lock);
688 extern void _nl_log_untranslated (const char *logfilename,
689 const char *domainname,
690 const char *msgid1, const char *msgid2,
692 const char *logfilename = getenv ("GETTEXT_LOG_UNTRANSLATED");
694 if (logfilename != NULL && logfilename[0] != '\0')
695 _nl_log_untranslated (logfilename, domainname, msgid1, msgid2, plural);
698 __set_errno (saved_errno);
701 /* Use the Germanic plural rule. */
702 : n == 1 ? (char *) msgid1 : (char *) msgid2);
708 _nl_find_msg (struct loaded_l10nfile *domain_file,
709 struct binding *domainbinding, const char *msgid,
712 struct loaded_domain *domain;
718 if (domain_file->decided == 0)
719 _nl_load_domain (domain_file, domainbinding);
721 if (domain_file->data == NULL)
724 domain = (struct loaded_domain *) domain_file->data;
726 nstrings = domain->nstrings;
728 /* Locate the MSGID and its translation. */
729 if (domain->hash_tab != NULL)
731 /* Use the hashing table. */
732 nls_uint32 len = strlen (msgid);
733 nls_uint32 hash_val = hash_string (msgid);
734 nls_uint32 idx = hash_val % domain->hash_size;
735 nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));
740 W (domain->must_swap_hash_tab, domain->hash_tab[idx]);
743 /* Hash table entry is empty. */
748 /* Compare msgid with the original string at index nstr.
749 We compare the lengths with >=, not ==, because plural entries
750 are represented by strings with an embedded NUL. */
752 ? W (domain->must_swap, domain->orig_tab[nstr].length) >= len
754 domain->data + W (domain->must_swap,
755 domain->orig_tab[nstr].offset))
757 : domain->orig_sysdep_tab[nstr - nstrings].length > len
759 domain->orig_sysdep_tab[nstr - nstrings].pointer)
766 if (idx >= domain->hash_size - incr)
767 idx -= domain->hash_size - incr;
775 /* Try the default method: binary search in the sorted array of
785 act = (bottom + top) / 2;
786 cmp_val = strcmp (msgid, (domain->data
787 + W (domain->must_swap,
788 domain->orig_tab[act].offset)));
791 else if (cmp_val > 0)
796 /* No translation was found. */
801 /* The translation was found at index ACT. If we have to convert the
802 string to use a different character set, this is the time. */
806 (domain->data + W (domain->must_swap, domain->trans_tab[act].offset));
807 resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
811 result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer;
812 resultlen = domain->trans_sysdep_tab[act - nstrings].length;
815 #if defined _LIBC || HAVE_ICONV
816 if (domain->codeset_cntr
817 != (domainbinding != NULL ? domainbinding->codeset_cntr : 0))
819 /* The domain's codeset has changed through bind_textdomain_codeset()
820 since the message catalog was initialized or last accessed. We
821 have to reinitialize the converter. */
822 _nl_free_domain_conv (domain);
823 _nl_init_domain_conv (domain_file, domain, domainbinding);
828 domain->conv != (__gconv_t) -1
831 domain->conv != (iconv_t) -1
836 /* We are supposed to do a conversion. First allocate an
837 appropriate table with the same structure as the table
838 of translations in the file, where we can put the pointers
839 to the converted strings in.
840 There is a slight complication with plural entries. They
841 are represented by consecutive NUL terminated strings. We
842 handle this case by converting RESULTLEN bytes, including
845 if (domain->conv_tab == NULL
846 && ((domain->conv_tab =
847 (char **) calloc (nstrings + domain->n_sysdep_strings,
850 /* Mark that we didn't succeed allocating a table. */
851 domain->conv_tab = (char **) -1;
853 if (__builtin_expect (domain->conv_tab == (char **) -1, 0))
854 /* Nothing we can do, no more memory. */
857 if (domain->conv_tab[act] == NULL)
859 /* We haven't used this string so far, so it is not
860 translated yet. Do this now. */
861 /* We use a bit more efficient memory handling.
862 We allocate always larger blocks which get used over
863 time. This is faster than many small allocations. */
864 __libc_lock_define_initialized (static, lock)
865 # define INITIAL_BLOCK_SIZE 4080
866 static unsigned char *freemem;
867 static size_t freemem_size;
869 const unsigned char *inbuf;
870 unsigned char *outbuf;
873 transmem_block_t *transmem_list = NULL;
876 __libc_lock_lock (lock);
878 inbuf = (const unsigned char *) result;
879 outbuf = freemem + sizeof (size_t);
884 transmem_block_t *newmem;
886 size_t non_reversible;
889 if (freemem_size < sizeof (size_t))
892 res = __gconv (domain->conv,
893 &inbuf, inbuf + resultlen,
895 outbuf + freemem_size - sizeof (size_t),
898 if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
901 if (res != __GCONV_FULL_OUTPUT)
903 __libc_lock_unlock (lock);
910 const char *inptr = (const char *) inbuf;
911 size_t inleft = resultlen;
912 char *outptr = (char *) outbuf;
915 if (freemem_size < sizeof (size_t))
918 outleft = freemem_size - sizeof (size_t);
919 if (iconv (domain->conv,
920 (ICONV_CONST char **) &inptr, &inleft,
924 outbuf = (unsigned char *) outptr;
929 __libc_lock_unlock (lock);
936 /* We must allocate a new buffer or resize the old one. */
937 if (malloc_count > 0)
940 freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
941 newmem = (transmem_block_t *) realloc (transmem_list,
945 transmem_list = transmem_list->next;
948 struct transmem_list *old = transmem_list;
950 transmem_list = transmem_list->next;
958 freemem_size = INITIAL_BLOCK_SIZE;
959 newmem = (transmem_block_t *) malloc (freemem_size);
961 if (__builtin_expect (newmem == NULL, 0))
965 __libc_lock_unlock (lock);
970 /* Add the block to the list of blocks we have to free
972 newmem->next = transmem_list;
973 transmem_list = newmem;
975 freemem = newmem->data;
976 freemem_size -= offsetof (struct transmem_list, data);
978 transmem_list = newmem;
982 outbuf = freemem + sizeof (size_t);
985 /* We have now in our buffer a converted string. Put this
986 into the table of conversions. */
987 *(size_t *) freemem = outbuf - freemem - sizeof (size_t);
988 domain->conv_tab[act] = (char *) freemem;
989 /* Shrink freemem, but keep it aligned. */
990 freemem_size -= outbuf - freemem;
992 freemem += freemem_size & (alignof (size_t) - 1);
993 freemem_size = freemem_size & ~ (alignof (size_t) - 1);
995 __libc_lock_unlock (lock);
998 /* Now domain->conv_tab[act] contains the translation of all
999 the plural variants. */
1000 result = domain->conv_tab[act] + sizeof (size_t);
1001 resultlen = *(size_t *) domain->conv_tab[act];
1005 /* The result string is converted. */
1007 #endif /* _LIBC || HAVE_ICONV */
1009 *lengthp = resultlen;
1014 /* Look up a plural variant. */
1017 plural_lookup (struct loaded_l10nfile *domain, unsigned long int n,
1018 const char *translation, size_t translation_len)
1020 struct loaded_domain *domaindata = (struct loaded_domain *) domain->data;
1021 unsigned long int index;
1024 index = plural_eval (domaindata->plural, n);
1025 if (index >= domaindata->nplurals)
1026 /* This should never happen. It means the plural expression and the
1027 given maximum value do not match. */
1030 /* Skip INDEX strings at TRANSLATION. */
1035 p = __rawmemchr (p, '\0');
1037 p = strchr (p, '\0');
1039 /* And skip over the NUL byte. */
1042 if (p >= translation + translation_len)
1043 /* This should never happen. It means the plural expression
1044 evaluated to a value larger than the number of variants
1045 available for MSGID1. */
1046 return (char *) translation;
1052 /* Return string representation of locale CATEGORY. */
1055 category_to_name (int category)
1063 retval = "LC_COLLATE";
1068 retval = "LC_CTYPE";
1073 retval = "LC_MONETARY";
1078 retval = "LC_NUMERIC";
1088 retval = "LC_MESSAGES";
1093 retval = "LC_RESPONSE";
1098 /* This might not make sense but is perhaps better than any other
1104 /* If you have a better idea for a default value let me know. */
1112 /* Guess value of current locale from value of the environment variables. */
1115 guess_category_value (int category, const char *categoryname)
1117 const char *language;
1120 /* The highest priority value is the `LANGUAGE' environment
1121 variable. But we don't use the value if the currently selected
1122 locale is the C locale. This is a GNU extension. */
1123 language = getenv ("LANGUAGE");
1124 if (language != NULL && language[0] == '\0')
1127 /* We have to proceed with the POSIX methods of looking to `LC_ALL',
1128 `LC_xxx', and `LANG'. On some systems this can be done by the
1129 `setlocale' function itself. */
1131 retval = __current_locale_name (category);
1133 retval = _nl_locale_name (category, categoryname);
1136 /* Ignore LANGUAGE if the locale is set to "C" because
1137 1. "C" locale usually uses the ASCII encoding, and most international
1138 messages use non-ASCII characters. These characters get displayed
1139 as question marks (if using glibc's iconv()) or as invalid 8-bit
1140 characters (because other iconv()s refuse to convert most non-ASCII
1141 characters to ASCII). In any case, the output is ugly.
1142 2. The precise output of some programs in the "C" locale is specified
1143 by POSIX and should not depend on environment variables like
1144 "LANGUAGE". We allow such programs to use gettext(). */
1145 return language != NULL && strcmp (retval, "C") != 0 ? language : retval;
1148 /* @@ begin of epilog @@ */
1150 /* We don't want libintl.a to depend on any other library. So we
1151 avoid the non-standard function stpcpy. In GNU C Library this
1152 function is available, though. Also allow the symbol HAVE_STPCPY
1154 #if !_LIBC && !HAVE_STPCPY
1156 stpcpy (char *dest, const char *src)
1158 while ((*dest++ = *src++) != '\0')
1164 #if !_LIBC && !HAVE_MEMPCPY
1166 mempcpy (void *dest, const void *src, size_t n)
1168 return (void *) ((char *) memcpy (dest, src, n) + n);
1174 /* If we want to free all resources we have to do some work at
1176 libc_freeres_fn (free_mem)
1180 while (_nl_domain_bindings != NULL)
1182 struct binding *oldp = _nl_domain_bindings;
1183 _nl_domain_bindings = _nl_domain_bindings->next;
1184 if (oldp->dirname != INTUSE(_nl_default_dirname))
1185 /* Yes, this is a pointer comparison. */
1186 free (oldp->dirname);
1187 free (oldp->codeset);
1191 if (_nl_current_default_domain != _nl_default_default_domain)
1192 /* Yes, again a pointer comparison. */
1193 free ((char *) _nl_current_default_domain);
1195 /* Remove the search tree with the known translations. */
1196 __tdestroy (root, free);
1199 while (transmem_list != NULL)
1201 old = transmem_list;
1202 transmem_list = transmem_list->next;