1/* Implementation of the internal dcigettext function.
2 Copyright (C) 1995-2018 Free Software Foundation, Inc.
3
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU Lesser General Public License as published by
6 the Free Software Foundation; either version 2.1 of the License, or
7 (at your option) 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
12 GNU Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
16
17/* Tell glibc's <string.h> to provide a prototype for mempcpy().
18 This must come before <config.h> because <config.h> may include
19 <features.h>, and once <features.h> has been included, it's too late. */
20#ifndef _GNU_SOURCE
21# define _GNU_SOURCE 1
22#endif
23
24#ifdef HAVE_CONFIG_H
25# include <config.h>
26#endif
27
28#include <sys/types.h>
29
30#ifdef __GNUC__
31# define alloca __builtin_alloca
32# define HAVE_ALLOCA 1
33#else
34# ifdef _MSC_VER
35# include <malloc.h>
36# define alloca _alloca
37# else
38# if defined HAVE_ALLOCA_H || defined _LIBC
39# include <alloca.h>
40# else
41# ifdef _AIX
42 #pragma alloca
43# else
44# ifndef alloca
45char *alloca ();
46# endif
47# endif
48# endif
49# endif
50#endif
51
52#include <errno.h>
53#ifndef errno
54extern int errno;
55#endif
56#ifndef __set_errno
57# define __set_errno(val) errno = (val)
58#endif
59
60#include <stddef.h>
61#include <stdlib.h>
62#include <stdio.h>
63#include <string.h>
64
65#if defined HAVE_UNISTD_H || defined _LIBC
66# include <unistd.h>
67#endif
68
69#include <locale.h>
70
71#ifdef _LIBC
72 /* Guess whether integer division by zero raises signal SIGFPE.
73 Set to 1 only if you know for sure. In case of doubt, set to 0. */
74# if defined __alpha__ || defined __arm__ || defined __i386__ \
75 || defined __m68k__ || defined __s390__
76# define INTDIV0_RAISES_SIGFPE 1
77# else
78# define INTDIV0_RAISES_SIGFPE 0
79# endif
80#endif
81#if !INTDIV0_RAISES_SIGFPE
82# include <signal.h>
83#endif
84
85#if defined HAVE_SYS_PARAM_H || defined _LIBC
86# include <sys/param.h>
87#endif
88
89#if !defined _LIBC
90# include "localcharset.h"
91#endif
92
93#include "gettextP.h"
94#include "plural-exp.h"
95#ifdef _LIBC
96# include <libintl.h>
97#else
98# ifdef IN_LIBGLOCALE
99# include <libintl.h>
100# endif
101# include "libgnuintl.h"
102#endif
103#include "hash-string.h"
104
105/* Handle multi-threaded applications. */
106#ifdef _LIBC
107# include <libc-lock.h>
108# define gl_rwlock_define_initialized __libc_rwlock_define_initialized
109# define gl_rwlock_rdlock __libc_rwlock_rdlock
110# define gl_rwlock_wrlock __libc_rwlock_wrlock
111# define gl_rwlock_unlock __libc_rwlock_unlock
112#else
113# include "lock.h"
114#endif
115
116/* Alignment of types. */
117#if defined __GNUC__ && __GNUC__ >= 2
118# define alignof(TYPE) __alignof__ (TYPE)
119#else
120# define alignof(TYPE) \
121 ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
122#endif
123
124/* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>. */
125#ifndef offsetof
126# define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
127#endif
128
129/* @@ end of prolog @@ */
130
131#ifdef _LIBC
132/* Rename the non ANSI C functions. This is required by the standard
133 because some ANSI C functions will require linking with this object
134 file and the name space must not be polluted. */
135# define strdup __strdup
136# define getcwd __getcwd
137# ifndef stpcpy
138# define stpcpy __stpcpy
139# endif
140# define tfind __tfind
141#else
142# if !defined HAVE_GETCWD
143char *getwd ();
144# define getcwd(buf, max) getwd (buf)
145# else
146# if VMS
147# define getcwd(buf, max) (getcwd) (buf, max, 0)
148# else
149char *getcwd ();
150# endif
151# endif
152# ifndef HAVE_STPCPY
153static char *stpcpy (char *dest, const char *src);
154# endif
155# ifndef HAVE_MEMPCPY
156static void *mempcpy (void *dest, const void *src, size_t n);
157# endif
158#endif
159
160/* Use a replacement if the system does not provide the `tsearch' function
161 family. */
162#if defined HAVE_TSEARCH || defined _LIBC
163# include <search.h>
164#else
165# define tsearch libintl_tsearch
166# define tfind libintl_tfind
167# define tdelete libintl_tdelete
168# define twalk libintl_twalk
169# include "tsearch.h"
170#endif
171
172#ifdef _LIBC
173# define tsearch __tsearch
174#endif
175
176/* Amount to increase buffer size by in each try. */
177#define PATH_INCR 32
178
179/* The following is from pathmax.h. */
180/* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define
181 PATH_MAX but might cause redefinition warnings when sys/param.h is
182 later included (as on MORE/BSD 4.3). */
183#if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__)
184# include <limits.h>
185#endif
186
187#ifndef _POSIX_PATH_MAX
188# define _POSIX_PATH_MAX 255
189#endif
190
191#if !defined PATH_MAX && defined _PC_PATH_MAX
192# define PATH_MAX (__pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : __pathconf ("/", _PC_PATH_MAX))
193#endif
194
195/* Don't include sys/param.h if it already has been. */
196#if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN
197# include <sys/param.h>
198#endif
199
200#if !defined PATH_MAX && defined MAXPATHLEN
201# define PATH_MAX MAXPATHLEN
202#endif
203
204#ifndef PATH_MAX
205# define PATH_MAX _POSIX_PATH_MAX
206#endif
207
208/* Pathname support.
209 ISSLASH(C) tests whether C is a directory separator character.
210 IS_ABSOLUTE_PATH(P) tests whether P is an absolute path. If it is not,
211 it may be concatenated to a directory pathname.
212 IS_PATH_WITH_DIR(P) tests whether P contains a directory specification.
213 */
214#if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__ || defined __EMX__ || defined __DJGPP__
215 /* Win32, Cygwin, OS/2, DOS */
216# define ISSLASH(C) ((C) == '/' || (C) == '\\')
217# define HAS_DEVICE(P) \
218 ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
219 && (P)[1] == ':')
220# define IS_ABSOLUTE_PATH(P) (ISSLASH ((P)[0]) || HAS_DEVICE (P))
221# define IS_PATH_WITH_DIR(P) \
222 (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
223#else
224 /* Unix */
225# define ISSLASH(C) ((C) == '/')
226# define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0])
227# define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
228#endif
229
230/* Whether to support different locales in different threads. */
231#if defined _LIBC || HAVE_USELOCALE || defined IN_LIBGLOCALE
232# define HAVE_PER_THREAD_LOCALE
233#endif
234
235/* This is the type used for the search tree where known translations
236 are stored. */
237struct known_translation_t
238{
239 /* Domain in which to search. */
240 const char *domainname;
241
242 /* The category. */
243 int category;
244
245#ifdef HAVE_PER_THREAD_LOCALE
246 /* Name of the relevant locale category, or "" for the global locale. */
247 const char *localename;
248#endif
249
250#ifdef IN_LIBGLOCALE
251 /* The character encoding. */
252 const char *encoding;
253#endif
254
255 /* State of the catalog counter at the point the string was found. */
256 int counter;
257
258 /* Catalog where the string was found. */
259 struct loaded_l10nfile *domain;
260
261 /* And finally the translation. */
262 const char *translation;
263 size_t translation_length;
264
265 /* Pointer to the string in question. */
266 union
267 {
268 char appended[ZERO]; /* used if domain != NULL */
269 const char *ptr; /* used if domain == NULL */
270 }
271 msgid;
272};
273
274gl_rwlock_define_initialized (static, tree_lock)
275
276/* Root of the search tree with known translations. */
277static void *root;
278
279/* Function to compare two entries in the table of known translations. */
280static int
281transcmp (const void *p1, const void *p2)
282{
283 const struct known_translation_t *s1;
284 const struct known_translation_t *s2;
285 int result;
286
287 s1 = (const struct known_translation_t *) p1;
288 s2 = (const struct known_translation_t *) p2;
289
290 result = strcmp (s1->domain != NULL ? s1->msgid.appended : s1->msgid.ptr,
291 s2->domain != NULL ? s2->msgid.appended : s2->msgid.ptr);
292 if (result == 0)
293 {
294 result = strcmp (s1->domainname, s2->domainname);
295 if (result == 0)
296 {
297#ifdef HAVE_PER_THREAD_LOCALE
298 result = strcmp (s1->localename, s2->localename);
299 if (result == 0)
300#endif
301 {
302#ifdef IN_LIBGLOCALE
303 result = strcmp (s1->encoding, s2->encoding);
304 if (result == 0)
305#endif
306 /* We compare the category last (though this is the cheapest
307 operation) since it is hopefully always the same (namely
308 LC_MESSAGES). */
309 result = s1->category - s2->category;
310 }
311 }
312 }
313
314 return result;
315}
316
317/* Name of the default domain used for gettext(3) prior any call to
318 textdomain(3). The default value for this is "messages". */
319const char _nl_default_default_domain[] attribute_hidden = "messages";
320
321#ifndef IN_LIBGLOCALE
322/* Value used as the default domain for gettext(3). */
323const char *_nl_current_default_domain attribute_hidden
324 = _nl_default_default_domain;
325#endif
326
327/* Contains the default location of the message catalogs. */
328#if defined __EMX__
329extern const char _nl_default_dirname[];
330#else
331# ifdef _LIBC
332extern const char _nl_default_dirname[];
333libc_hidden_proto (_nl_default_dirname)
334# endif
335const char _nl_default_dirname[] = LOCALEDIR;
336# ifdef _LIBC
337libc_hidden_data_def (_nl_default_dirname)
338# endif
339#endif
340
341#ifndef IN_LIBGLOCALE
342/* List with bindings of specific domains created by bindtextdomain()
343 calls. */
344struct binding *_nl_domain_bindings;
345#endif
346
347/* Prototypes for local functions. */
348static char *plural_lookup (struct loaded_l10nfile *domain,
349 unsigned long int n,
350 const char *translation, size_t translation_len);
351
352#ifdef IN_LIBGLOCALE
353static const char *guess_category_value (int category,
354 const char *categoryname,
355 const char *localename);
356#else
357static const char *guess_category_value (int category,
358 const char *categoryname);
359#endif
360
361#ifdef _LIBC
362# include "../locale/localeinfo.h"
363# define category_to_name(category) \
364 _nl_category_names.str + _nl_category_name_idxs[category]
365#else
366static const char *category_to_name (int category);
367#endif
368#if (defined _LIBC || HAVE_ICONV) && !defined IN_LIBGLOCALE
369static const char *get_output_charset (struct binding *domainbinding);
370#endif
371
372
373/* For those losing systems which don't have `alloca' we have to add
374 some additional code emulating it. */
375#ifdef HAVE_ALLOCA
376/* Nothing has to be done. */
377# define freea(p) /* nothing */
378# define ADD_BLOCK(list, address) /* nothing */
379# define FREE_BLOCKS(list) /* nothing */
380#else
381struct block_list
382{
383 void *address;
384 struct block_list *next;
385};
386# define ADD_BLOCK(list, addr) \
387 do { \
388 struct block_list *newp = (struct block_list *) malloc (sizeof (*newp)); \
389 /* If we cannot get a free block we cannot add the new element to \
390 the list. */ \
391 if (newp != NULL) { \
392 newp->address = (addr); \
393 newp->next = (list); \
394 (list) = newp; \
395 } \
396 } while (0)
397# define FREE_BLOCKS(list) \
398 do { \
399 while (list != NULL) { \
400 struct block_list *old = list; \
401 list = list->next; \
402 free (old->address); \
403 free (old); \
404 } \
405 } while (0)
406# undef alloca
407# define alloca(size) (malloc (size))
408# define freea(p) free (p)
409#endif /* have alloca */
410
411
412#ifdef _LIBC
413/* List of blocks allocated for translations. */
414typedef struct transmem_list
415{
416 struct transmem_list *next;
417 char data[ZERO];
418} transmem_block_t;
419static struct transmem_list *transmem_list;
420#else
421typedef unsigned char transmem_block_t;
422#endif
423
424
425/* Names for the libintl functions are a problem. They must not clash
426 with existing names and they should follow ANSI C. But this source
427 code is also used in GNU C Library where the names have a __
428 prefix. So we have to make a difference here. */
429#ifdef _LIBC
430# define DCIGETTEXT __dcigettext
431#else
432# define DCIGETTEXT libintl_dcigettext
433#endif
434
435/* Lock variable to protect the global data in the gettext implementation. */
436gl_rwlock_define_initialized (, _nl_state_lock attribute_hidden)
437
438/* Checking whether the binaries runs SUID must be done and glibc provides
439 easier methods therefore we make a difference here. */
440#ifdef _LIBC
441# define ENABLE_SECURE __libc_enable_secure
442# define DETERMINE_SECURE
443#else
444# ifndef HAVE_GETUID
445# define getuid() 0
446# endif
447# ifndef HAVE_GETGID
448# define getgid() 0
449# endif
450# ifndef HAVE_GETEUID
451# define geteuid() getuid()
452# endif
453# ifndef HAVE_GETEGID
454# define getegid() getgid()
455# endif
456static int enable_secure;
457# define ENABLE_SECURE (enable_secure == 1)
458# define DETERMINE_SECURE \
459 if (enable_secure == 0) \
460 { \
461 if (getuid () != geteuid () || getgid () != getegid ()) \
462 enable_secure = 1; \
463 else \
464 enable_secure = -1; \
465 }
466#endif
467
468/* Get the function to evaluate the plural expression. */
469#include "eval-plural.h"
470
471/* Look up MSGID in the DOMAINNAME message catalog for the current
472 CATEGORY locale and, if PLURAL is nonzero, search over string
473 depending on the plural form determined by N. */
474#ifdef IN_LIBGLOCALE
475char *
476gl_dcigettext (const char *domainname,
477 const char *msgid1, const char *msgid2,
478 int plural, unsigned long int n,
479 int category,
480 const char *localename, const char *encoding)
481#else
482char *
483DCIGETTEXT (const char *domainname, const char *msgid1, const char *msgid2,
484 int plural, unsigned long int n, int category)
485#endif
486{
487#ifndef HAVE_ALLOCA
488 struct block_list *block_list = NULL;
489#endif
490 struct loaded_l10nfile *domain;
491 struct binding *binding;
492 const char *categoryname;
493 const char *categoryvalue;
494 const char *dirname;
495 char *xdirname = NULL;
496 char *xdomainname;
497 char *single_locale;
498 char *retval;
499 size_t retlen;
500 int saved_errno;
501 struct known_translation_t search;
502 struct known_translation_t **foundp = NULL;
503#if defined HAVE_PER_THREAD_LOCALE && !defined IN_LIBGLOCALE
504 const char *localename;
505#endif
506 size_t domainname_len;
507
508 /* If no real MSGID is given return NULL. */
509 if (msgid1 == NULL)
510 return NULL;
511
512#ifdef _LIBC
513 if (category < 0 || category >= __LC_LAST || category == LC_ALL)
514 /* Bogus. */
515 return (plural == 0
516 ? (char *) msgid1
517 /* Use the Germanic plural rule. */
518 : n == 1 ? (char *) msgid1 : (char *) msgid2);
519#endif
520
521 /* Preserve the `errno' value. */
522 saved_errno = errno;
523
524#ifdef _LIBC
525 __libc_rwlock_define (extern, __libc_setlocale_lock attribute_hidden)
526 __libc_rwlock_rdlock (__libc_setlocale_lock);
527#endif
528
529 gl_rwlock_rdlock (_nl_state_lock);
530
531 /* If DOMAINNAME is NULL, we are interested in the default domain. If
532 CATEGORY is not LC_MESSAGES this might not make much sense but the
533 definition left this undefined. */
534 if (domainname == NULL)
535 domainname = _nl_current_default_domain;
536
537 /* OS/2 specific: backward compatibility with older libintl versions */
538#ifdef LC_MESSAGES_COMPAT
539 if (category == LC_MESSAGES_COMPAT)
540 category = LC_MESSAGES;
541#endif
542
543 /* Try to find the translation among those which we found at
544 some time. */
545 search.domain = NULL;
546 search.msgid.ptr = msgid1;
547 search.domainname = domainname;
548 search.category = category;
549#ifdef HAVE_PER_THREAD_LOCALE
550# ifndef IN_LIBGLOCALE
551# ifdef _LIBC
552 localename = __current_locale_name (category);
553# else
554 categoryname = category_to_name (category);
555# define CATEGORYNAME_INITIALIZED
556 localename = _nl_locale_name_thread_unsafe (category, categoryname);
557 if (localename == NULL)
558 localename = "";
559# endif
560# endif
561 search.localename = localename;
562# ifdef IN_LIBGLOCALE
563 search.encoding = encoding;
564# endif
565
566 /* Since tfind/tsearch manage a balanced tree, concurrent tfind and
567 tsearch calls can be fatal. */
568 gl_rwlock_rdlock (tree_lock);
569
570 foundp = (struct known_translation_t **) tfind (&search, &root, transcmp);
571
572 gl_rwlock_unlock (tree_lock);
573
574 if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
575 {
576 /* Now deal with plural. */
577 if (plural)
578 retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation,
579 (*foundp)->translation_length);
580 else
581 retval = (char *) (*foundp)->translation;
582
583 gl_rwlock_unlock (_nl_state_lock);
584# ifdef _LIBC
585 __libc_rwlock_unlock (__libc_setlocale_lock);
586# endif
587 __set_errno (saved_errno);
588 return retval;
589 }
590#endif
591
592 /* See whether this is a SUID binary or not. */
593 DETERMINE_SECURE;
594
595 /* First find matching binding. */
596#ifdef IN_LIBGLOCALE
597 /* We can use a trivial binding, since _nl_find_msg will ignore it anyway,
598 and _nl_load_domain and _nl_find_domain just pass it through. */
599 binding = NULL;
600 dirname = bindtextdomain (domainname, NULL);
601#else
602 for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
603 {
604 int compare = strcmp (domainname, binding->domainname);
605 if (compare == 0)
606 /* We found it! */
607 break;
608 if (compare < 0)
609 {
610 /* It is not in the list. */
611 binding = NULL;
612 break;
613 }
614 }
615
616 if (binding == NULL)
617 dirname = _nl_default_dirname;
618 else
619 {
620 dirname = binding->dirname;
621#endif
622 if (!IS_ABSOLUTE_PATH (dirname))
623 {
624 /* We have a relative path. Make it absolute now. */
625 char *cwd = getcwd (NULL, 0);
626 if (cwd == NULL)
627 /* We cannot get the current working directory. Don't
628 signal an error but simply return the default
629 string. */
630 goto return_untranslated;
631 int ret = __asprintf (&xdirname, "%s/%s", cwd, dirname);
632 free (cwd);
633 if (ret < 0)
634 return NULL;
635 dirname = xdirname;
636 }
637#ifndef IN_LIBGLOCALE
638 }
639#endif
640
641 /* Now determine the symbolic name of CATEGORY and its value. */
642#ifndef CATEGORYNAME_INITIALIZED
643 categoryname = category_to_name (category);
644#endif
645#ifdef IN_LIBGLOCALE
646 categoryvalue = guess_category_value (category, categoryname, localename);
647#else
648 categoryvalue = guess_category_value (category, categoryname);
649#endif
650
651 domainname_len = strlen (domainname);
652 xdomainname = (char *) alloca (strlen (categoryname)
653 + domainname_len + 5);
654 ADD_BLOCK (block_list, xdomainname);
655
656 stpcpy ((char *) mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"),
657 domainname, domainname_len),
658 ".mo");
659
660 /* Creating working area. */
661 single_locale = (char *) alloca (strlen (categoryvalue) + 1);
662 ADD_BLOCK (block_list, single_locale);
663
664
665 /* Search for the given string. This is a loop because we perhaps
666 got an ordered list of languages to consider for the translation. */
667 while (1)
668 {
669 /* Make CATEGORYVALUE point to the next element of the list. */
670 while (categoryvalue[0] != '\0' && categoryvalue[0] == ':')
671 ++categoryvalue;
672 if (categoryvalue[0] == '\0')
673 {
674 /* The whole contents of CATEGORYVALUE has been searched but
675 no valid entry has been found. We solve this situation
676 by implicitly appending a "C" entry, i.e. no translation
677 will take place. */
678 single_locale[0] = 'C';
679 single_locale[1] = '\0';
680 }
681 else
682 {
683 char *cp = single_locale;
684 while (categoryvalue[0] != '\0' && categoryvalue[0] != ':')
685 *cp++ = *categoryvalue++;
686 *cp = '\0';
687
688 /* When this is a SUID binary we must not allow accessing files
689 outside the dedicated directories. */
690 if (ENABLE_SECURE && IS_PATH_WITH_DIR (single_locale))
691 /* Ingore this entry. */
692 continue;
693 }
694
695 /* If the current locale value is C (or POSIX) we don't load a
696 domain. Return the MSGID. */
697 if (strcmp (single_locale, "C") == 0
698 || strcmp (single_locale, "POSIX") == 0)
699 break;
700
701 /* Find structure describing the message catalog matching the
702 DOMAINNAME and CATEGORY. */
703 domain = _nl_find_domain (dirname, single_locale, xdomainname, binding);
704
705 if (domain != NULL)
706 {
707#if defined IN_LIBGLOCALE
708 retval = _nl_find_msg (domain, binding, encoding, msgid1, &retlen);
709#else
710 retval = _nl_find_msg (domain, binding, msgid1, 1, &retlen);
711#endif
712
713 if (retval == NULL)
714 {
715 int cnt;
716
717 for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
718 {
719#if defined IN_LIBGLOCALE
720 retval = _nl_find_msg (domain->successor[cnt], binding,
721 encoding, msgid1, &retlen);
722#else
723 retval = _nl_find_msg (domain->successor[cnt], binding,
724 msgid1, 1, &retlen);
725#endif
726
727 /* Resource problems are not fatal, instead we return no
728 translation. */
729 if (__builtin_expect (retval == (char *) -1, 0))
730 goto return_untranslated;
731
732 if (retval != NULL)
733 {
734 domain = domain->successor[cnt];
735 break;
736 }
737 }
738 }
739
740 /* Returning -1 means that some resource problem exists
741 (likely memory) and that the strings could not be
742 converted. Return the original strings. */
743 if (__builtin_expect (retval == (char *) -1, 0))
744 break;
745
746 if (retval != NULL)
747 {
748 /* Found the translation of MSGID1 in domain DOMAIN:
749 starting at RETVAL, RETLEN bytes. */
750 free (xdirname);
751 FREE_BLOCKS (block_list);
752 if (foundp == NULL)
753 {
754 /* Create a new entry and add it to the search tree. */
755 size_t msgid_len;
756 size_t size;
757 struct known_translation_t *newp;
758
759 msgid_len = strlen (msgid1) + 1;
760 size = offsetof (struct known_translation_t, msgid)
761 + msgid_len + domainname_len + 1;
762#ifdef HAVE_PER_THREAD_LOCALE
763 size += strlen (localename) + 1;
764#endif
765 newp = (struct known_translation_t *) malloc (size);
766 if (newp != NULL)
767 {
768 char *new_domainname;
769#ifdef HAVE_PER_THREAD_LOCALE
770 char *new_localename;
771#endif
772
773 new_domainname =
774 (char *) mempcpy (newp->msgid.appended, msgid1,
775 msgid_len);
776 memcpy (new_domainname, domainname, domainname_len + 1);
777#ifdef HAVE_PER_THREAD_LOCALE
778 new_localename = new_domainname + domainname_len + 1;
779 strcpy (new_localename, localename);
780#endif
781 newp->domainname = new_domainname;
782 newp->category = category;
783#ifdef HAVE_PER_THREAD_LOCALE
784 newp->localename = new_localename;
785#endif
786#ifdef IN_LIBGLOCALE
787 newp->encoding = encoding;
788#endif
789 newp->counter = _nl_msg_cat_cntr;
790 newp->domain = domain;
791 newp->translation = retval;
792 newp->translation_length = retlen;
793
794 gl_rwlock_wrlock (tree_lock);
795
796 /* Insert the entry in the search tree. */
797 foundp = (struct known_translation_t **)
798 tsearch (newp, &root, transcmp);
799
800 gl_rwlock_unlock (tree_lock);
801
802 if (foundp == NULL
803 || __builtin_expect (*foundp != newp, 0))
804 /* The insert failed. */
805 free (newp);
806 }
807 }
808 else
809 {
810 /* We can update the existing entry. */
811 (*foundp)->counter = _nl_msg_cat_cntr;
812 (*foundp)->domain = domain;
813 (*foundp)->translation = retval;
814 (*foundp)->translation_length = retlen;
815 }
816
817 __set_errno (saved_errno);
818
819 /* Now deal with plural. */
820 if (plural)
821 retval = plural_lookup (domain, n, retval, retlen);
822
823 gl_rwlock_unlock (_nl_state_lock);
824#ifdef _LIBC
825 __libc_rwlock_unlock (__libc_setlocale_lock);
826#endif
827 return retval;
828 }
829 }
830 }
831
832 return_untranslated:
833 /* Return the untranslated MSGID. */
834 free (xdirname);
835 FREE_BLOCKS (block_list);
836 gl_rwlock_unlock (_nl_state_lock);
837#ifdef _LIBC
838 __libc_rwlock_unlock (__libc_setlocale_lock);
839#endif
840#ifndef _LIBC
841 if (!ENABLE_SECURE)
842 {
843 extern void _nl_log_untranslated (const char *logfilename,
844 const char *domainname,
845 const char *msgid1, const char *msgid2,
846 int plural);
847 const char *logfilename = getenv ("GETTEXT_LOG_UNTRANSLATED");
848
849 if (logfilename != NULL && logfilename[0] != '\0')
850 _nl_log_untranslated (logfilename, domainname, msgid1, msgid2, plural);
851 }
852#endif
853 __set_errno (saved_errno);
854 return (plural == 0
855 ? (char *) msgid1
856 /* Use the Germanic plural rule. */
857 : n == 1 ? (char *) msgid1 : (char *) msgid2);
858}
859
860
861/* Look up the translation of msgid within DOMAIN_FILE and DOMAINBINDING.
862 Return it if found. Return NULL if not found or in case of a conversion
863 failure (problem in the particular message catalog). Return (char *) -1
864 in case of a memory allocation failure during conversion (only if
865 ENCODING != NULL resp. CONVERT == true). */
866char *
867#ifdef IN_LIBGLOCALE
868_nl_find_msg (struct loaded_l10nfile *domain_file,
869 struct binding *domainbinding, const char *encoding,
870 const char *msgid,
871 size_t *lengthp)
872#else
873_nl_find_msg (struct loaded_l10nfile *domain_file,
874 struct binding *domainbinding,
875 const char *msgid, int convert,
876 size_t *lengthp)
877#endif
878{
879 struct loaded_domain *domain;
880 nls_uint32 nstrings;
881 size_t act;
882 char *result;
883 size_t resultlen;
884
885 if (domain_file->decided <= 0)
886 _nl_load_domain (domain_file, domainbinding);
887
888 if (domain_file->data == NULL)
889 return NULL;
890
891 domain = (struct loaded_domain *) domain_file->data;
892
893 nstrings = domain->nstrings;
894
895 /* Locate the MSGID and its translation. */
896 if (domain->hash_tab != NULL)
897 {
898 /* Use the hashing table. */
899 nls_uint32 len = strlen (msgid);
900 nls_uint32 hash_val = __hash_string (msgid);
901 nls_uint32 idx = hash_val % domain->hash_size;
902 nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));
903
904 while (1)
905 {
906 nls_uint32 nstr =
907 W (domain->must_swap_hash_tab, domain->hash_tab[idx]);
908
909 if (nstr == 0)
910 /* Hash table entry is empty. */
911 return NULL;
912
913 nstr--;
914
915 /* Compare msgid with the original string at index nstr.
916 We compare the lengths with >=, not ==, because plural entries
917 are represented by strings with an embedded NUL. */
918 if (nstr < nstrings
919 ? W (domain->must_swap, domain->orig_tab[nstr].length) >= len
920 && (strcmp (msgid,
921 domain->data + W (domain->must_swap,
922 domain->orig_tab[nstr].offset))
923 == 0)
924 : domain->orig_sysdep_tab[nstr - nstrings].length > len
925 && (strcmp (msgid,
926 domain->orig_sysdep_tab[nstr - nstrings].pointer)
927 == 0))
928 {
929 act = nstr;
930 goto found;
931 }
932
933 if (idx >= domain->hash_size - incr)
934 idx -= domain->hash_size - incr;
935 else
936 idx += incr;
937 }
938 /* NOTREACHED */
939 }
940 else
941 {
942 /* Try the default method: binary search in the sorted array of
943 messages. */
944 size_t top, bottom;
945
946 bottom = 0;
947 top = nstrings;
948 while (bottom < top)
949 {
950 int cmp_val;
951
952 act = (bottom + top) / 2;
953 cmp_val = strcmp (msgid, (domain->data
954 + W (domain->must_swap,
955 domain->orig_tab[act].offset)));
956 if (cmp_val < 0)
957 top = act;
958 else if (cmp_val > 0)
959 bottom = act + 1;
960 else
961 goto found;
962 }
963 /* No translation was found. */
964 return NULL;
965 }
966
967 found:
968 /* The translation was found at index ACT. If we have to convert the
969 string to use a different character set, this is the time. */
970 if (act < nstrings)
971 {
972 result = (char *)
973 (domain->data + W (domain->must_swap, domain->trans_tab[act].offset));
974 resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
975 }
976 else
977 {
978 result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer;
979 resultlen = domain->trans_sysdep_tab[act - nstrings].length;
980 }
981
982#if defined _LIBC || HAVE_ICONV
983# ifdef IN_LIBGLOCALE
984 if (encoding != NULL)
985# else
986 if (convert)
987# endif
988 {
989 /* We are supposed to do a conversion. */
990# ifndef IN_LIBGLOCALE
991 const char *encoding = get_output_charset (domainbinding);
992# endif
993 size_t nconversions;
994 struct converted_domain *convd;
995 size_t i;
996
997 /* Protect against reallocation of the table. */
998 gl_rwlock_rdlock (domain->conversions_lock);
999
1000 /* Search whether a table with converted translations for this
1001 encoding has already been allocated. */
1002 nconversions = domain->nconversions;
1003 convd = NULL;
1004
1005 for (i = nconversions; i > 0; )
1006 {
1007 i--;
1008 if (strcmp (domain->conversions[i].encoding, encoding) == 0)
1009 {
1010 convd = &domain->conversions[i];
1011 break;
1012 }
1013 }
1014
1015 gl_rwlock_unlock (domain->conversions_lock);
1016
1017 if (convd == NULL)
1018 {
1019 /* We have to allocate a new conversions table. */
1020 gl_rwlock_wrlock (domain->conversions_lock);
1021 nconversions = domain->nconversions;
1022
1023 /* Maybe in the meantime somebody added the translation.
1024 Recheck. */
1025 for (i = nconversions; i > 0; )
1026 {
1027 i--;
1028 if (strcmp (domain->conversions[i].encoding, encoding) == 0)
1029 {
1030 convd = &domain->conversions[i];
1031 goto found_convd;
1032 }
1033 }
1034
1035 {
1036 /* Allocate a table for the converted translations for this
1037 encoding. */
1038 struct converted_domain *new_conversions =
1039 (struct converted_domain *)
1040 (domain->conversions != NULL
1041 ? realloc (domain->conversions,
1042 (nconversions + 1) * sizeof (struct converted_domain))
1043 : malloc ((nconversions + 1) * sizeof (struct converted_domain)));
1044
1045 if (__builtin_expect (new_conversions == NULL, 0))
1046 {
1047 /* Nothing we can do, no more memory. We cannot use the
1048 translation because it might be encoded incorrectly. */
1049 unlock_fail:
1050 gl_rwlock_unlock (domain->conversions_lock);
1051 return (char *) -1;
1052 }
1053
1054 domain->conversions = new_conversions;
1055
1056 /* Copy the 'encoding' string to permanent storage. */
1057 encoding = strdup (encoding);
1058 if (__builtin_expect (encoding == NULL, 0))
1059 /* Nothing we can do, no more memory. We cannot use the
1060 translation because it might be encoded incorrectly. */
1061 goto unlock_fail;
1062
1063 convd = &new_conversions[nconversions];
1064 convd->encoding = encoding;
1065
1066 /* Find out about the character set the file is encoded with.
1067 This can be found (in textual form) in the entry "". If this
1068 entry does not exist or if this does not contain the 'charset='
1069 information, we will assume the charset matches the one the
1070 current locale and we don't have to perform any conversion. */
1071# ifdef _LIBC
1072 convd->conv = (__gconv_t) -1;
1073# else
1074# if HAVE_ICONV
1075 convd->conv = (iconv_t) -1;
1076# endif
1077# endif
1078 {
1079 char *nullentry;
1080 size_t nullentrylen;
1081
1082 /* Get the header entry. This is a recursion, but it doesn't
1083 reallocate domain->conversions because we pass
1084 encoding = NULL or convert = 0, respectively. */
1085 nullentry =
1086# ifdef IN_LIBGLOCALE
1087 _nl_find_msg (domain_file, domainbinding, NULL, "",
1088 &nullentrylen);
1089# else
1090 _nl_find_msg (domain_file, domainbinding, "", 0, &nullentrylen);
1091# endif
1092
1093 /* Resource problems are fatal. If we continue onwards we will
1094 only attempt to calloc a new conv_tab and fail later. */
1095 if (__builtin_expect (nullentry == (char *) -1, 0))
1096 return (char *) -1;
1097
1098 if (nullentry != NULL)
1099 {
1100 const char *charsetstr;
1101
1102 charsetstr = strstr (nullentry, "charset=");
1103 if (charsetstr != NULL)
1104 {
1105 size_t len;
1106 char *charset;
1107 const char *outcharset;
1108
1109 charsetstr += strlen ("charset=");
1110 len = strcspn (charsetstr, " \t\n");
1111
1112 charset = (char *) alloca (len + 1);
1113# if defined _LIBC || HAVE_MEMPCPY
1114 *((char *) mempcpy (charset, charsetstr, len)) = '\0';
1115# else
1116 memcpy (charset, charsetstr, len);
1117 charset[len] = '\0';
1118# endif
1119
1120 outcharset = encoding;
1121
1122# ifdef _LIBC
1123 /* We always want to use transliteration. */
1124 outcharset = norm_add_slashes (outcharset, "TRANSLIT");
1125 charset = norm_add_slashes (charset, "");
1126 int r = __gconv_open (outcharset, charset, &convd->conv,
1127 GCONV_AVOID_NOCONV);
1128 if (__builtin_expect (r != __GCONV_OK, 0))
1129 {
1130 /* If the output encoding is the same there is
1131 nothing to do. Otherwise do not use the
1132 translation at all. */
1133 if (__builtin_expect (r != __GCONV_NULCONV, 1))
1134 {
1135 gl_rwlock_unlock (domain->conversions_lock);
1136 free ((char *) encoding);
1137 return NULL;
1138 }
1139
1140 convd->conv = (__gconv_t) -1;
1141 }
1142# else
1143# if HAVE_ICONV
1144 /* When using GNU libc >= 2.2 or GNU libiconv >= 1.5,
1145 we want to use transliteration. */
1146# if (((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2) \
1147 && !defined __UCLIBC__) \
1148 || _LIBICONV_VERSION >= 0x0105
1149 if (strchr (outcharset, '/') == NULL)
1150 {
1151 char *tmp;
1152
1153 len = strlen (outcharset);
1154 tmp = (char *) alloca (len + 10 + 1);
1155 memcpy (tmp, outcharset, len);
1156 memcpy (tmp + len, "//TRANSLIT", 10 + 1);
1157 outcharset = tmp;
1158
1159 convd->conv = iconv_open (outcharset, charset);
1160
1161 freea (outcharset);
1162 }
1163 else
1164# endif
1165 convd->conv = iconv_open (outcharset, charset);
1166# endif
1167# endif
1168
1169 freea (charset);
1170 }
1171 }
1172 }
1173 convd->conv_tab = NULL;
1174 /* Here domain->conversions is still == new_conversions. */
1175 domain->nconversions++;
1176 }
1177
1178 found_convd:
1179 gl_rwlock_unlock (domain->conversions_lock);
1180 }
1181
1182 if (
1183# ifdef _LIBC
1184 convd->conv != (__gconv_t) -1
1185# else
1186# if HAVE_ICONV
1187 convd->conv != (iconv_t) -1
1188# endif
1189# endif
1190 )
1191 {
1192 /* We are supposed to do a conversion. First allocate an
1193 appropriate table with the same structure as the table
1194 of translations in the file, where we can put the pointers
1195 to the converted strings in.
1196 There is a slight complication with plural entries. They
1197 are represented by consecutive NUL terminated strings. We
1198 handle this case by converting RESULTLEN bytes, including
1199 NULs. */
1200
1201 /* This lock primarily protects the memory management variables
1202 freemem, freemem_size. It also protects write accesses to
1203 convd->conv_tab. It's not worth using a separate lock (such
1204 as domain->conversions_lock) for this purpose, because when
1205 modifying convd->conv_tab, we also need to lock freemem,
1206 freemem_size for most of the time. */
1207 __libc_lock_define_initialized (static, lock)
1208
1209 if (__builtin_expect (convd->conv_tab == NULL, 0))
1210 {
1211 __libc_lock_lock (lock);
1212 if (convd->conv_tab == NULL)
1213 {
1214 convd->conv_tab =
1215 (char **) calloc (nstrings + domain->n_sysdep_strings,
1216 sizeof (char *));
1217 if (convd->conv_tab != NULL)
1218 goto not_translated_yet;
1219 /* Mark that we didn't succeed allocating a table. */
1220 convd->conv_tab = (char **) -1;
1221 }
1222 __libc_lock_unlock (lock);
1223 }
1224
1225 if (__builtin_expect (convd->conv_tab == (char **) -1, 0))
1226 /* Nothing we can do, no more memory. We cannot use the
1227 translation because it might be encoded incorrectly. */
1228 return (char *) -1;
1229
1230 if (convd->conv_tab[act] == NULL)
1231 {
1232 /* We haven't used this string so far, so it is not
1233 translated yet. Do this now. */
1234 /* We use a bit more efficient memory handling.
1235 We allocate always larger blocks which get used over
1236 time. This is faster than many small allocations. */
1237# define INITIAL_BLOCK_SIZE 4080
1238 static unsigned char *freemem;
1239 static size_t freemem_size;
1240
1241 const unsigned char *inbuf;
1242 unsigned char *outbuf;
1243 int malloc_count;
1244# ifndef _LIBC
1245 transmem_block_t *transmem_list;
1246# endif
1247
1248 __libc_lock_lock (lock);
1249 not_translated_yet:
1250
1251 inbuf = (const unsigned char *) result;
1252 outbuf = freemem + sizeof (size_t);
1253# ifndef _LIBC
1254 transmem_list = NULL;
1255# endif
1256
1257 malloc_count = 0;
1258 while (1)
1259 {
1260 transmem_block_t *newmem;
1261# ifdef _LIBC
1262 size_t non_reversible;
1263 int res;
1264
1265 if (freemem_size < sizeof (size_t))
1266 goto resize_freemem;
1267
1268 res = __gconv (convd->conv,
1269 &inbuf, inbuf + resultlen,
1270 &outbuf,
1271 outbuf + freemem_size - sizeof (size_t),
1272 &non_reversible);
1273
1274 if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
1275 break;
1276
1277 if (res != __GCONV_FULL_OUTPUT)
1278 {
1279 /* We should not use the translation at all, it
1280 is incorrectly encoded. */
1281 __libc_lock_unlock (lock);
1282 return NULL;
1283 }
1284
1285 inbuf = (const unsigned char *) result;
1286# else
1287# if HAVE_ICONV
1288 const char *inptr = (const char *) inbuf;
1289 size_t inleft = resultlen;
1290 char *outptr = (char *) outbuf;
1291 size_t outleft;
1292
1293 if (freemem_size < sizeof (size_t))
1294 goto resize_freemem;
1295
1296 outleft = freemem_size - sizeof (size_t);
1297 if (iconv (convd->conv,
1298 (ICONV_CONST char **) &inptr, &inleft,
1299 &outptr, &outleft)
1300 != (size_t) (-1))
1301 {
1302 outbuf = (unsigned char *) outptr;
1303 break;
1304 }
1305 if (errno != E2BIG)
1306 {
1307 __libc_lock_unlock (lock);
1308 return NULL;
1309 }
1310# endif
1311# endif
1312
1313 resize_freemem:
1314 /* We must allocate a new buffer or resize the old one. */
1315 if (malloc_count > 0)
1316 {
1317 ++malloc_count;
1318 freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
1319 newmem = (transmem_block_t *) realloc (transmem_list,
1320 freemem_size);
1321# ifdef _LIBC
1322 if (newmem != NULL)
1323 transmem_list = newmem;
1324 else
1325 {
1326 struct transmem_list *old = transmem_list;
1327
1328 transmem_list = transmem_list->next;
1329 free (old);
1330 }
1331# endif
1332 }
1333 else
1334 {
1335 malloc_count = 1;
1336 freemem_size = INITIAL_BLOCK_SIZE;
1337 newmem = (transmem_block_t *) malloc (freemem_size);
1338# ifdef _LIBC
1339 if (newmem != NULL)
1340 {
1341 /* Add the block to the list of blocks we have to free
1342 at some point. */
1343 newmem->next = transmem_list;
1344 transmem_list = newmem;
1345 }
1346 /* Fall through and return -1. */
1347# endif
1348 }
1349 if (__builtin_expect (newmem == NULL, 0))
1350 {
1351 freemem = NULL;
1352 freemem_size = 0;
1353 __libc_lock_unlock (lock);
1354 return (char *) -1;
1355 }
1356
1357# ifdef _LIBC
1358 freemem = (unsigned char *) newmem->data;
1359 freemem_size -= offsetof (struct transmem_list, data);
1360# else
1361 transmem_list = newmem;
1362 freemem = newmem;
1363# endif
1364
1365 outbuf = freemem + sizeof (size_t);
1366 }
1367
1368 /* We have now in our buffer a converted string. Put this
1369 into the table of conversions. */
1370 *(size_t *) freemem = outbuf - freemem - sizeof (size_t);
1371 convd->conv_tab[act] = (char *) freemem;
1372 /* Shrink freemem, but keep it aligned. */
1373 freemem_size -= outbuf - freemem;
1374 freemem = outbuf;
1375 freemem += freemem_size & (alignof (size_t) - 1);
1376 freemem_size = freemem_size & ~ (alignof (size_t) - 1);
1377
1378 __libc_lock_unlock (lock);
1379 }
1380
1381 /* Now convd->conv_tab[act] contains the translation of all
1382 the plural variants. */
1383 result = convd->conv_tab[act] + sizeof (size_t);
1384 resultlen = *(size_t *) convd->conv_tab[act];
1385 }
1386 }
1387
1388 /* The result string is converted. */
1389
1390#endif /* _LIBC || HAVE_ICONV */
1391
1392 *lengthp = resultlen;
1393 return result;
1394}
1395
1396
1397/* Look up a plural variant. */
1398static char *
1399plural_lookup (struct loaded_l10nfile *domain, unsigned long int n,
1400 const char *translation, size_t translation_len)
1401{
1402 struct loaded_domain *domaindata = (struct loaded_domain *) domain->data;
1403 unsigned long int index;
1404 const char *p;
1405
1406 index = plural_eval (domaindata->plural, n);
1407 if (index >= domaindata->nplurals)
1408 /* This should never happen. It means the plural expression and the
1409 given maximum value do not match. */
1410 index = 0;
1411
1412 /* Skip INDEX strings at TRANSLATION. */
1413 p = translation;
1414 while (index-- > 0)
1415 {
1416#ifdef _LIBC
1417 p = __rawmemchr (p, '\0');
1418#else
1419 p = strchr (p, '\0');
1420#endif
1421 /* And skip over the NUL byte. */
1422 p++;
1423
1424 if (p >= translation + translation_len)
1425 /* This should never happen. It means the plural expression
1426 evaluated to a value larger than the number of variants
1427 available for MSGID1. */
1428 return (char *) translation;
1429 }
1430 return (char *) p;
1431}
1432
1433#ifndef _LIBC
1434/* Return string representation of locale CATEGORY. */
1435static const char *
1436category_to_name (int category)
1437{
1438 const char *retval;
1439
1440 switch (category)
1441 {
1442#ifdef LC_COLLATE
1443 case LC_COLLATE:
1444 retval = "LC_COLLATE";
1445 break;
1446#endif
1447#ifdef LC_CTYPE
1448 case LC_CTYPE:
1449 retval = "LC_CTYPE";
1450 break;
1451#endif
1452#ifdef LC_MONETARY
1453 case LC_MONETARY:
1454 retval = "LC_MONETARY";
1455 break;
1456#endif
1457#ifdef LC_NUMERIC
1458 case LC_NUMERIC:
1459 retval = "LC_NUMERIC";
1460 break;
1461#endif
1462#ifdef LC_TIME
1463 case LC_TIME:
1464 retval = "LC_TIME";
1465 break;
1466#endif
1467#ifdef LC_MESSAGES
1468 case LC_MESSAGES:
1469 retval = "LC_MESSAGES";
1470 break;
1471#endif
1472#ifdef LC_RESPONSE
1473 case LC_RESPONSE:
1474 retval = "LC_RESPONSE";
1475 break;
1476#endif
1477#ifdef LC_ALL
1478 case LC_ALL:
1479 /* This might not make sense but is perhaps better than any other
1480 value. */
1481 retval = "LC_ALL";
1482 break;
1483#endif
1484 default:
1485 /* If you have a better idea for a default value let me know. */
1486 retval = "LC_XXX";
1487 }
1488
1489 return retval;
1490}
1491#endif
1492
1493/* Guess value of current locale from value of the environment variables
1494 or system-dependent defaults. */
1495static const char *
1496#ifdef IN_LIBGLOCALE
1497guess_category_value (int category, const char *categoryname,
1498 const char *locale)
1499
1500#else
1501guess_category_value (int category, const char *categoryname)
1502#endif
1503{
1504 const char *language;
1505#ifndef IN_LIBGLOCALE
1506 const char *locale;
1507# ifndef _LIBC
1508 const char *language_default;
1509 int locale_defaulted;
1510# endif
1511#endif
1512
1513 /* We use the settings in the following order:
1514 1. The value of the environment variable 'LANGUAGE'. This is a GNU
1515 extension. Its value can be a colon-separated list of locale names.
1516 2. The value of the environment variable 'LC_ALL', 'LC_xxx', or 'LANG'.
1517 More precisely, the first among these that is set to a non-empty value.
1518 This is how POSIX specifies it. The value is a single locale name.
1519 3. A system-dependent preference list of languages. Its value can be a
1520 colon-separated list of locale names.
1521 4. A system-dependent default locale name.
1522 This way:
1523 - System-dependent settings can be overridden by environment variables.
1524 - If the system provides both a list of languages and a default locale,
1525 the former is used. */
1526
1527#ifndef IN_LIBGLOCALE
1528 /* Fetch the locale name, through the POSIX method of looking to `LC_ALL',
1529 `LC_xxx', and `LANG'. On some systems this can be done by the
1530 `setlocale' function itself. */
1531# ifdef _LIBC
1532 locale = __current_locale_name (category);
1533# else
1534 locale_defaulted = 0;
1535# if HAVE_USELOCALE
1536 locale = _nl_locale_name_thread_unsafe (category, categoryname);
1537 if (locale == NULL)
1538# endif
1539 {
1540 locale = _nl_locale_name_posix (category, categoryname);
1541 if (locale == NULL)
1542 {
1543 locale = _nl_locale_name_default ();
1544 locale_defaulted = 1;
1545 }
1546 }
1547# endif
1548#endif
1549
1550 /* Ignore LANGUAGE and its system-dependent analogon if the locale is set
1551 to "C" because
1552 1. "C" locale usually uses the ASCII encoding, and most international
1553 messages use non-ASCII characters. These characters get displayed
1554 as question marks (if using glibc's iconv()) or as invalid 8-bit
1555 characters (because other iconv()s refuse to convert most non-ASCII
1556 characters to ASCII). In any case, the output is ugly.
1557 2. The precise output of some programs in the "C" locale is specified
1558 by POSIX and should not depend on environment variables like
1559 "LANGUAGE" or system-dependent information. We allow such programs
1560 to use gettext(). */
1561 if (strcmp (locale, "C") == 0)
1562 return locale;
1563
1564 /* The highest priority value is the value of the 'LANGUAGE' environment
1565 variable. */
1566 language = getenv ("LANGUAGE");
1567 if (language != NULL && language[0] != '\0')
1568 return language;
1569#if !defined IN_LIBGLOCALE && !defined _LIBC
1570 /* The next priority value is the locale name, if not defaulted. */
1571 if (locale_defaulted)
1572 {
1573 /* The next priority value is the default language preferences list. */
1574 language_default = _nl_language_preferences_default ();
1575 if (language_default != NULL)
1576 return language_default;
1577 }
1578 /* The least priority value is the locale name, if defaulted. */
1579#endif
1580 return locale;
1581}
1582
1583#if (defined _LIBC || HAVE_ICONV) && !defined IN_LIBGLOCALE
1584/* Returns the output charset. */
1585static const char *
1586get_output_charset (struct binding *domainbinding)
1587{
1588 /* The output charset should normally be determined by the locale. But
1589 sometimes the locale is not used or not correctly set up, so we provide
1590 a possibility for the user to override this: the OUTPUT_CHARSET
1591 environment variable. Moreover, the value specified through
1592 bind_textdomain_codeset overrides both. */
1593 if (domainbinding != NULL && domainbinding->codeset != NULL)
1594 return domainbinding->codeset;
1595 else
1596 {
1597 /* For speed reasons, we look at the value of OUTPUT_CHARSET only
1598 once. This is a user variable that is not supposed to change
1599 during a program run. */
1600 static char *output_charset_cache;
1601 static int output_charset_cached;
1602
1603 if (!output_charset_cached)
1604 {
1605 const char *value = getenv ("OUTPUT_CHARSET");
1606
1607 if (value != NULL && value[0] != '\0')
1608 {
1609 size_t len = strlen (value) + 1;
1610 char *value_copy = (char *) malloc (len);
1611
1612 if (value_copy != NULL)
1613 memcpy (value_copy, value, len);
1614 output_charset_cache = value_copy;
1615 }
1616 output_charset_cached = 1;
1617 }
1618
1619 if (output_charset_cache != NULL)
1620 return output_charset_cache;
1621 else
1622 {
1623# ifdef _LIBC
1624 return _NL_CURRENT (LC_CTYPE, CODESET);
1625# else
1626# if HAVE_ICONV
1627 return locale_charset ();
1628# endif
1629# endif
1630 }
1631 }
1632}
1633#endif
1634
1635/* @@ begin of epilog @@ */
1636
1637/* We don't want libintl.a to depend on any other library. So we
1638 avoid the non-standard function stpcpy. In GNU C Library this
1639 function is available, though. Also allow the symbol HAVE_STPCPY
1640 to be defined. */
1641#if !_LIBC && !HAVE_STPCPY
1642static char *
1643stpcpy (char *dest, const char *src)
1644{
1645 while ((*dest++ = *src++) != '\0')
1646 /* Do nothing. */ ;
1647 return dest - 1;
1648}
1649#endif
1650
1651#if !_LIBC && !HAVE_MEMPCPY
1652static void *
1653mempcpy (void *dest, const void *src, size_t n)
1654{
1655 return (void *) ((char *) memcpy (dest, src, n) + n);
1656}
1657#endif
1658
1659#if !_LIBC && !HAVE_TSEARCH
1660# include "tsearch.c"
1661#endif
1662
1663
1664#ifdef _LIBC
1665/* If we want to free all resources we have to do some work at
1666 program's end. */
1667libc_freeres_fn (free_mem)
1668{
1669 void *old;
1670
1671 while (_nl_domain_bindings != NULL)
1672 {
1673 struct binding *oldp = _nl_domain_bindings;
1674 _nl_domain_bindings = _nl_domain_bindings->next;
1675 if (oldp->dirname != _nl_default_dirname)
1676 /* Yes, this is a pointer comparison. */
1677 free (oldp->dirname);
1678 free (oldp->codeset);
1679 free (oldp);
1680 }
1681
1682 if (_nl_current_default_domain != _nl_default_default_domain)
1683 /* Yes, again a pointer comparison. */
1684 free ((char *) _nl_current_default_domain);
1685
1686 /* Remove the search tree with the known translations. */
1687 __tdestroy (root, free);
1688 root = NULL;
1689
1690 while (transmem_list != NULL)
1691 {
1692 old = transmem_list;
1693 transmem_list = transmem_list->next;
1694 free (old);
1695 }
1696}
1697#endif
1698