1/* Implementation of the internal dcigettext function.
2 Copyright (C) 1995-2022 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 <https://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) _nl_category_names_get (category)
364#else
365static const char *category_to_name (int category);
366#endif
367#if (defined _LIBC || HAVE_ICONV) && !defined IN_LIBGLOCALE
368static const char *get_output_charset (struct binding *domainbinding);
369#endif
370
371
372/* For those losing systems which don't have `alloca' we have to add
373 some additional code emulating it. */
374#ifdef HAVE_ALLOCA
375/* Nothing has to be done. */
376# define freea(p) /* nothing */
377# define ADD_BLOCK(list, address) /* nothing */
378# define FREE_BLOCKS(list) /* nothing */
379#else
380struct block_list
381{
382 void *address;
383 struct block_list *next;
384};
385# define ADD_BLOCK(list, addr) \
386 do { \
387 struct block_list *newp = (struct block_list *) malloc (sizeof (*newp)); \
388 /* If we cannot get a free block we cannot add the new element to \
389 the list. */ \
390 if (newp != NULL) { \
391 newp->address = (addr); \
392 newp->next = (list); \
393 (list) = newp; \
394 } \
395 } while (0)
396# define FREE_BLOCKS(list) \
397 do { \
398 while (list != NULL) { \
399 struct block_list *old = list; \
400 list = list->next; \
401 free (old->address); \
402 free (old); \
403 } \
404 } while (0)
405# undef alloca
406# define alloca(size) (malloc (size))
407# define freea(p) free (p)
408#endif /* have alloca */
409
410
411#ifdef _LIBC
412/* List of blocks allocated for translations. */
413typedef struct transmem_list
414{
415 struct transmem_list *next;
416 char data[ZERO];
417} transmem_block_t;
418static struct transmem_list *transmem_list;
419#else
420typedef unsigned char transmem_block_t;
421#endif
422
423
424/* Names for the libintl functions are a problem. They must not clash
425 with existing names and they should follow ANSI C. But this source
426 code is also used in GNU C Library where the names have a __
427 prefix. So we have to make a difference here. */
428#ifdef _LIBC
429# define DCIGETTEXT __dcigettext
430#else
431# define DCIGETTEXT libintl_dcigettext
432#endif
433
434/* Lock variable to protect the global data in the gettext implementation. */
435gl_rwlock_define_initialized (, _nl_state_lock attribute_hidden)
436
437/* Checking whether the binaries runs SUID must be done and glibc provides
438 easier methods therefore we make a difference here. */
439#ifdef _LIBC
440# define ENABLE_SECURE __libc_enable_secure
441# define DETERMINE_SECURE
442#else
443# ifndef HAVE_GETUID
444# define getuid() 0
445# endif
446# ifndef HAVE_GETGID
447# define getgid() 0
448# endif
449# ifndef HAVE_GETEUID
450# define geteuid() getuid()
451# endif
452# ifndef HAVE_GETEGID
453# define getegid() getgid()
454# endif
455static int enable_secure;
456# define ENABLE_SECURE (enable_secure == 1)
457# define DETERMINE_SECURE \
458 if (enable_secure == 0) \
459 { \
460 if (getuid () != geteuid () || getgid () != getegid ()) \
461 enable_secure = 1; \
462 else \
463 enable_secure = -1; \
464 }
465#endif
466
467/* Get the function to evaluate the plural expression. */
468#include "eval-plural.h"
469
470/* Look up MSGID in the DOMAINNAME message catalog for the current
471 CATEGORY locale and, if PLURAL is nonzero, search over string
472 depending on the plural form determined by N. */
473#ifdef IN_LIBGLOCALE
474char *
475gl_dcigettext (const char *domainname,
476 const char *msgid1, const char *msgid2,
477 int plural, unsigned long int n,
478 int category,
479 const char *localename, const char *encoding)
480#else
481char *
482DCIGETTEXT (const char *domainname, const char *msgid1, const char *msgid2,
483 int plural, unsigned long int n, int category)
484#endif
485{
486#ifndef HAVE_ALLOCA
487 struct block_list *block_list = NULL;
488#endif
489 struct loaded_l10nfile *domain;
490 struct binding *binding;
491 const char *categoryname;
492 const char *categoryvalue;
493 const char *dirname;
494 char *xdirname = NULL;
495 char *xdomainname;
496 char *single_locale;
497 char *retval;
498 size_t retlen;
499 int saved_errno;
500 struct known_translation_t search;
501 struct known_translation_t **foundp = NULL;
502#if defined HAVE_PER_THREAD_LOCALE && !defined IN_LIBGLOCALE
503 const char *localename;
504#endif
505 size_t domainname_len;
506
507 /* If no real MSGID is given return NULL. */
508 if (msgid1 == NULL)
509 return NULL;
510
511#ifdef _LIBC
512 if (category < 0 || category >= __LC_LAST || category == LC_ALL)
513 /* Bogus. */
514 return (plural == 0
515 ? (char *) msgid1
516 /* Use the Germanic plural rule. */
517 : n == 1 ? (char *) msgid1 : (char *) msgid2);
518#endif
519
520 /* Preserve the `errno' value. */
521 saved_errno = errno;
522
523#ifdef _LIBC
524 __libc_rwlock_define (extern, __libc_setlocale_lock attribute_hidden)
525 __libc_rwlock_rdlock (__libc_setlocale_lock);
526#endif
527
528 gl_rwlock_rdlock (_nl_state_lock);
529
530 /* If DOMAINNAME is NULL, we are interested in the default domain. If
531 CATEGORY is not LC_MESSAGES this might not make much sense but the
532 definition left this undefined. */
533 if (domainname == NULL)
534 domainname = _nl_current_default_domain;
535
536 /* OS/2 specific: backward compatibility with older libintl versions */
537#ifdef LC_MESSAGES_COMPAT
538 if (category == LC_MESSAGES_COMPAT)
539 category = LC_MESSAGES;
540#endif
541
542 /* Try to find the translation among those which we found at
543 some time. */
544 search.domain = NULL;
545 search.msgid.ptr = msgid1;
546 search.domainname = domainname;
547 search.category = category;
548#ifdef HAVE_PER_THREAD_LOCALE
549# ifndef IN_LIBGLOCALE
550# ifdef _LIBC
551 localename = __current_locale_name (category);
552# else
553 categoryname = category_to_name (category);
554# define CATEGORYNAME_INITIALIZED
555 localename = _nl_locale_name_thread_unsafe (category, categoryname);
556 if (localename == NULL)
557 localename = "";
558# endif
559# endif
560 search.localename = localename;
561# ifdef IN_LIBGLOCALE
562 search.encoding = encoding;
563# endif
564
565 /* Since tfind/tsearch manage a balanced tree, concurrent tfind and
566 tsearch calls can be fatal. */
567 gl_rwlock_rdlock (tree_lock);
568
569 foundp = (struct known_translation_t **) tfind (&search, &root, transcmp);
570
571 gl_rwlock_unlock (tree_lock);
572
573 if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
574 {
575 /* Now deal with plural. */
576 if (plural)
577 retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation,
578 (*foundp)->translation_length);
579 else
580 retval = (char *) (*foundp)->translation;
581
582 gl_rwlock_unlock (_nl_state_lock);
583# ifdef _LIBC
584 __libc_rwlock_unlock (__libc_setlocale_lock);
585# endif
586 __set_errno (saved_errno);
587 return retval;
588 }
589#endif
590
591 /* See whether this is a SUID binary or not. */
592 DETERMINE_SECURE;
593
594 /* First find matching binding. */
595#ifdef IN_LIBGLOCALE
596 /* We can use a trivial binding, since _nl_find_msg will ignore it anyway,
597 and _nl_load_domain and _nl_find_domain just pass it through. */
598 binding = NULL;
599 dirname = bindtextdomain (domainname, NULL);
600#else
601 for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
602 {
603 int compare = strcmp (domainname, binding->domainname);
604 if (compare == 0)
605 /* We found it! */
606 break;
607 if (compare < 0)
608 {
609 /* It is not in the list. */
610 binding = NULL;
611 break;
612 }
613 }
614
615 if (binding == NULL)
616 dirname = _nl_default_dirname;
617 else
618 {
619 dirname = binding->dirname;
620#endif
621 if (!IS_ABSOLUTE_PATH (dirname))
622 {
623 /* We have a relative path. Make it absolute now. */
624 char *cwd = getcwd (NULL, 0);
625 if (cwd == NULL)
626 /* We cannot get the current working directory. Don't
627 signal an error but simply return the default
628 string. */
629 goto return_untranslated;
630 int ret = __asprintf (&xdirname, "%s/%s", cwd, dirname);
631 free (cwd);
632 if (ret < 0)
633 goto return_untranslated;
634 dirname = xdirname;
635 }
636#ifndef IN_LIBGLOCALE
637 }
638#endif
639
640 /* Now determine the symbolic name of CATEGORY and its value. */
641#ifndef CATEGORYNAME_INITIALIZED
642 categoryname = category_to_name (category);
643#endif
644#ifdef IN_LIBGLOCALE
645 categoryvalue = guess_category_value (category, categoryname, localename);
646#else
647 categoryvalue = guess_category_value (category, categoryname);
648#endif
649
650 domainname_len = strlen (domainname);
651 xdomainname = (char *) alloca (strlen (categoryname)
652 + domainname_len + 5);
653 ADD_BLOCK (block_list, xdomainname);
654
655 stpcpy ((char *) mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"),
656 domainname, domainname_len),
657 ".mo");
658
659 /* Creating working area. */
660 single_locale = (char *) alloca (strlen (categoryvalue) + 1);
661 ADD_BLOCK (block_list, single_locale);
662
663
664 /* Search for the given string. This is a loop because we perhaps
665 got an ordered list of languages to consider for the translation. */
666 while (1)
667 {
668 /* Make CATEGORYVALUE point to the next element of the list. */
669 while (categoryvalue[0] != '\0' && categoryvalue[0] == ':')
670 ++categoryvalue;
671 if (categoryvalue[0] == '\0')
672 {
673 /* The whole contents of CATEGORYVALUE has been searched but
674 no valid entry has been found. We solve this situation
675 by implicitly appending a "C" entry, i.e. no translation
676 will take place. */
677 single_locale[0] = 'C';
678 single_locale[1] = '\0';
679 }
680 else
681 {
682 char *cp = single_locale;
683 while (categoryvalue[0] != '\0' && categoryvalue[0] != ':')
684 *cp++ = *categoryvalue++;
685 *cp = '\0';
686
687 /* When this is a SUID binary we must not allow accessing files
688 outside the dedicated directories. */
689 if (ENABLE_SECURE && IS_PATH_WITH_DIR (single_locale))
690 /* Ingore this entry. */
691 continue;
692 }
693
694 /* If the current locale value is C (or POSIX) we don't load a
695 domain. Return the MSGID. */
696 if (strcmp (single_locale, "C") == 0
697 || strcmp (single_locale, "POSIX") == 0)
698 break;
699
700 /* Find structure describing the message catalog matching the
701 DOMAINNAME and CATEGORY. */
702 domain = _nl_find_domain (dirname, single_locale, xdomainname, binding);
703
704 if (domain != NULL)
705 {
706#if defined IN_LIBGLOCALE
707 retval = _nl_find_msg (domain, binding, encoding, msgid1, &retlen);
708#else
709 retval = _nl_find_msg (domain, binding, msgid1, 1, &retlen);
710#endif
711
712 if (retval == NULL)
713 {
714 int cnt;
715
716 for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
717 {
718#if defined IN_LIBGLOCALE
719 retval = _nl_find_msg (domain->successor[cnt], binding,
720 encoding, msgid1, &retlen);
721#else
722 retval = _nl_find_msg (domain->successor[cnt], binding,
723 msgid1, 1, &retlen);
724#endif
725
726 /* Resource problems are not fatal, instead we return no
727 translation. */
728 if (__builtin_expect (retval == (char *) -1, 0))
729 goto return_untranslated;
730
731 if (retval != NULL)
732 {
733 domain = domain->successor[cnt];
734 break;
735 }
736 }
737 }
738
739 /* Returning -1 means that some resource problem exists
740 (likely memory) and that the strings could not be
741 converted. Return the original strings. */
742 if (__builtin_expect (retval == (char *) -1, 0))
743 break;
744
745 if (retval != NULL)
746 {
747 /* Found the translation of MSGID1 in domain DOMAIN:
748 starting at RETVAL, RETLEN bytes. */
749 free (xdirname);
750 FREE_BLOCKS (block_list);
751 if (foundp == NULL)
752 {
753 /* Create a new entry and add it to the search tree. */
754 size_t msgid_len;
755 size_t size;
756 struct known_translation_t *newp;
757
758 msgid_len = strlen (msgid1) + 1;
759 size = offsetof (struct known_translation_t, msgid)
760 + msgid_len + domainname_len + 1;
761#ifdef HAVE_PER_THREAD_LOCALE
762 size += strlen (localename) + 1;
763#endif
764 newp = (struct known_translation_t *) malloc (size);
765 if (newp != NULL)
766 {
767 char *new_domainname;
768#ifdef HAVE_PER_THREAD_LOCALE
769 char *new_localename;
770#endif
771
772 new_domainname =
773 (char *) mempcpy (newp->msgid.appended, msgid1,
774 msgid_len);
775 memcpy (new_domainname, domainname, domainname_len + 1);
776#ifdef HAVE_PER_THREAD_LOCALE
777 new_localename = new_domainname + domainname_len + 1;
778 strcpy (new_localename, localename);
779#endif
780 newp->domainname = new_domainname;
781 newp->category = category;
782#ifdef HAVE_PER_THREAD_LOCALE
783 newp->localename = new_localename;
784#endif
785#ifdef IN_LIBGLOCALE
786 newp->encoding = encoding;
787#endif
788 newp->counter = _nl_msg_cat_cntr;
789 newp->domain = domain;
790 newp->translation = retval;
791 newp->translation_length = retlen;
792
793 gl_rwlock_wrlock (tree_lock);
794
795 /* Insert the entry in the search tree. */
796 foundp = (struct known_translation_t **)
797 tsearch (newp, &root, transcmp);
798
799 gl_rwlock_unlock (tree_lock);
800
801 if (foundp == NULL
802 || __builtin_expect (*foundp != newp, 0))
803 /* The insert failed. */
804 free (newp);
805 }
806 }
807 else
808 {
809 /* We can update the existing entry. */
810 (*foundp)->counter = _nl_msg_cat_cntr;
811 (*foundp)->domain = domain;
812 (*foundp)->translation = retval;
813 (*foundp)->translation_length = retlen;
814 }
815
816 __set_errno (saved_errno);
817
818 /* Now deal with plural. */
819 if (plural)
820 retval = plural_lookup (domain, n, retval, retlen);
821
822 gl_rwlock_unlock (_nl_state_lock);
823#ifdef _LIBC
824 __libc_rwlock_unlock (__libc_setlocale_lock);
825#endif
826 return retval;
827 }
828 }
829 }
830
831 return_untranslated:
832 /* Return the untranslated MSGID. */
833 free (xdirname);
834 FREE_BLOCKS (block_list);
835 gl_rwlock_unlock (_nl_state_lock);
836#ifdef _LIBC
837 __libc_rwlock_unlock (__libc_setlocale_lock);
838#endif
839#ifndef _LIBC
840 if (!ENABLE_SECURE)
841 {
842 extern void _nl_log_untranslated (const char *logfilename,
843 const char *domainname,
844 const char *msgid1, const char *msgid2,
845 int plural);
846 const char *logfilename = getenv ("GETTEXT_LOG_UNTRANSLATED");
847
848 if (logfilename != NULL && logfilename[0] != '\0')
849 _nl_log_untranslated (logfilename, domainname, msgid1, msgid2, plural);
850 }
851#endif
852 __set_errno (saved_errno);
853 return (plural == 0
854 ? (char *) msgid1
855 /* Use the Germanic plural rule. */
856 : n == 1 ? (char *) msgid1 : (char *) msgid2);
857}
858
859
860/* Look up the translation of msgid within DOMAIN_FILE and DOMAINBINDING.
861 Return it if found. Return NULL if not found or in case of a conversion
862 failure (problem in the particular message catalog). Return (char *) -1
863 in case of a memory allocation failure during conversion (only if
864 ENCODING != NULL resp. CONVERT == true). */
865char *
866#ifdef IN_LIBGLOCALE
867_nl_find_msg (struct loaded_l10nfile *domain_file,
868 struct binding *domainbinding, const char *encoding,
869 const char *msgid,
870 size_t *lengthp)
871#else
872_nl_find_msg (struct loaded_l10nfile *domain_file,
873 struct binding *domainbinding,
874 const char *msgid, int convert,
875 size_t *lengthp)
876#endif
877{
878 struct loaded_domain *domain;
879 nls_uint32 nstrings;
880 size_t act;
881 char *result;
882 size_t resultlen;
883
884 if (domain_file->decided <= 0)
885 _nl_load_domain (domain_file, domainbinding);
886
887 if (domain_file->data == NULL)
888 return NULL;
889
890 domain = (struct loaded_domain *) domain_file->data;
891
892 nstrings = domain->nstrings;
893
894 /* Locate the MSGID and its translation. */
895 if (domain->hash_tab != NULL)
896 {
897 /* Use the hashing table. */
898 nls_uint32 len = strlen (msgid);
899 nls_uint32 hash_val = __hash_string (msgid);
900 nls_uint32 idx = hash_val % domain->hash_size;
901 nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));
902
903 while (1)
904 {
905 nls_uint32 nstr =
906 W (domain->must_swap_hash_tab, domain->hash_tab[idx]);
907
908 if (nstr == 0)
909 /* Hash table entry is empty. */
910 return NULL;
911
912 nstr--;
913
914 /* Compare msgid with the original string at index nstr.
915 We compare the lengths with >=, not ==, because plural entries
916 are represented by strings with an embedded NUL. */
917 if (nstr < nstrings
918 ? W (domain->must_swap, domain->orig_tab[nstr].length) >= len
919 && (strcmp (msgid,
920 domain->data + W (domain->must_swap,
921 domain->orig_tab[nstr].offset))
922 == 0)
923 : domain->orig_sysdep_tab[nstr - nstrings].length > len
924 && (strcmp (msgid,
925 domain->orig_sysdep_tab[nstr - nstrings].pointer)
926 == 0))
927 {
928 act = nstr;
929 goto found;
930 }
931
932 if (idx >= domain->hash_size - incr)
933 idx -= domain->hash_size - incr;
934 else
935 idx += incr;
936 }
937 /* NOTREACHED */
938 }
939 else
940 {
941 /* Try the default method: binary search in the sorted array of
942 messages. */
943 size_t top, bottom;
944
945 bottom = 0;
946 top = nstrings;
947 while (bottom < top)
948 {
949 int cmp_val;
950
951 act = (bottom + top) / 2;
952 cmp_val = strcmp (msgid, (domain->data
953 + W (domain->must_swap,
954 domain->orig_tab[act].offset)));
955 if (cmp_val < 0)
956 top = act;
957 else if (cmp_val > 0)
958 bottom = act + 1;
959 else
960 goto found;
961 }
962 /* No translation was found. */
963 return NULL;
964 }
965
966 found:
967 /* The translation was found at index ACT. If we have to convert the
968 string to use a different character set, this is the time. */
969 if (act < nstrings)
970 {
971 result = (char *)
972 (domain->data + W (domain->must_swap, domain->trans_tab[act].offset));
973 resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
974 }
975 else
976 {
977 result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer;
978 resultlen = domain->trans_sysdep_tab[act - nstrings].length;
979 }
980
981#if defined _LIBC || HAVE_ICONV
982# ifdef IN_LIBGLOCALE
983 if (encoding != NULL)
984# else
985 if (convert)
986# endif
987 {
988 /* We are supposed to do a conversion. */
989# ifndef IN_LIBGLOCALE
990 const char *encoding = get_output_charset (domainbinding);
991# endif
992 size_t nconversions;
993 struct converted_domain *convd;
994 size_t i;
995
996 /* Protect against reallocation of the table. */
997 gl_rwlock_rdlock (domain->conversions_lock);
998
999 /* Search whether a table with converted translations for this
1000 encoding has already been allocated. */
1001 nconversions = domain->nconversions;
1002 convd = NULL;
1003
1004 for (i = nconversions; i > 0; )
1005 {
1006 i--;
1007 if (strcmp (domain->conversions[i].encoding, encoding) == 0)
1008 {
1009 convd = &domain->conversions[i];
1010 break;
1011 }
1012 }
1013
1014 gl_rwlock_unlock (domain->conversions_lock);
1015
1016 if (convd == NULL)
1017 {
1018 /* We have to allocate a new conversions table. */
1019 gl_rwlock_wrlock (domain->conversions_lock);
1020 nconversions = domain->nconversions;
1021
1022 /* Maybe in the meantime somebody added the translation.
1023 Recheck. */
1024 for (i = nconversions; i > 0; )
1025 {
1026 i--;
1027 if (strcmp (domain->conversions[i].encoding, encoding) == 0)
1028 {
1029 convd = &domain->conversions[i];
1030 goto found_convd;
1031 }
1032 }
1033
1034 {
1035 /* Allocate a table for the converted translations for this
1036 encoding. */
1037 struct converted_domain *new_conversions =
1038 (struct converted_domain *)
1039 (domain->conversions != NULL
1040 ? realloc (domain->conversions,
1041 (nconversions + 1) * sizeof (struct converted_domain))
1042 : malloc ((nconversions + 1) * sizeof (struct converted_domain)));
1043
1044 if (__builtin_expect (new_conversions == NULL, 0))
1045 {
1046 /* Nothing we can do, no more memory. We cannot use the
1047 translation because it might be encoded incorrectly. */
1048 unlock_fail:
1049 gl_rwlock_unlock (domain->conversions_lock);
1050 return (char *) -1;
1051 }
1052
1053 domain->conversions = new_conversions;
1054
1055 /* Copy the 'encoding' string to permanent storage. */
1056 encoding = strdup (encoding);
1057 if (__builtin_expect (encoding == NULL, 0))
1058 /* Nothing we can do, no more memory. We cannot use the
1059 translation because it might be encoded incorrectly. */
1060 goto unlock_fail;
1061
1062 convd = &new_conversions[nconversions];
1063 convd->encoding = encoding;
1064
1065 /* Find out about the character set the file is encoded with.
1066 This can be found (in textual form) in the entry "". If this
1067 entry does not exist or if this does not contain the 'charset='
1068 information, we will assume the charset matches the one the
1069 current locale and we don't have to perform any conversion. */
1070# ifdef _LIBC
1071 convd->conv = (__gconv_t) -1;
1072# else
1073# if HAVE_ICONV
1074 convd->conv = (iconv_t) -1;
1075# endif
1076# endif
1077 {
1078 char *nullentry;
1079 size_t nullentrylen;
1080
1081 /* Get the header entry. This is a recursion, but it doesn't
1082 reallocate domain->conversions because we pass
1083 encoding = NULL or convert = 0, respectively. */
1084 nullentry =
1085# ifdef IN_LIBGLOCALE
1086 _nl_find_msg (domain_file, domainbinding, NULL, "",
1087 &nullentrylen);
1088# else
1089 _nl_find_msg (domain_file, domainbinding, "", 0, &nullentrylen);
1090# endif
1091
1092 /* Resource problems are fatal. If we continue onwards we will
1093 only attempt to calloc a new conv_tab and fail later. */
1094 if (__builtin_expect (nullentry == (char *) -1, 0))
1095 return (char *) -1;
1096
1097 if (nullentry != NULL)
1098 {
1099 const char *charsetstr;
1100
1101 charsetstr = strstr (nullentry, "charset=");
1102 if (charsetstr != NULL)
1103 {
1104 size_t len;
1105 char *charset;
1106 const char *outcharset;
1107
1108 charsetstr += strlen ("charset=");
1109 len = strcspn (charsetstr, " \t\n");
1110
1111 charset = (char *) alloca (len + 1);
1112# if defined _LIBC || HAVE_MEMPCPY
1113 *((char *) mempcpy (charset, charsetstr, len)) = '\0';
1114# else
1115 memcpy (charset, charsetstr, len);
1116 charset[len] = '\0';
1117# endif
1118
1119 outcharset = encoding;
1120
1121# ifdef _LIBC
1122
1123 struct gconv_spec conv_spec;
1124
1125 __gconv_create_spec (&conv_spec, charset, outcharset);
1126
1127 /* We always want to use transliteration. */
1128 conv_spec.translit = true;
1129
1130 int r = __gconv_open (&conv_spec, &convd->conv,
1131 GCONV_AVOID_NOCONV);
1132
1133 __gconv_destroy_spec (&conv_spec);
1134
1135 if (__builtin_expect (r != __GCONV_OK, 0))
1136 {
1137 /* If the output encoding is the same there is
1138 nothing to do. Otherwise do not use the
1139 translation at all. */
1140 if (__builtin_expect (r != __GCONV_NULCONV, 1))
1141 {
1142 gl_rwlock_unlock (domain->conversions_lock);
1143 free ((char *) encoding);
1144 return NULL;
1145 }
1146
1147 convd->conv = (__gconv_t) -1;
1148 }
1149# else
1150# if HAVE_ICONV
1151 /* When using GNU libc >= 2.2 or GNU libiconv >= 1.5,
1152 we want to use transliteration. */
1153# if (((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2) \
1154 && !defined __UCLIBC__) \
1155 || _LIBICONV_VERSION >= 0x0105
1156 if (strchr (outcharset, '/') == NULL)
1157 {
1158 char *tmp;
1159
1160 len = strlen (outcharset);
1161 tmp = (char *) alloca (len + 10 + 1);
1162 memcpy (tmp, outcharset, len);
1163 memcpy (tmp + len, "//TRANSLIT", 10 + 1);
1164 outcharset = tmp;
1165
1166 convd->conv = iconv_open (outcharset, charset);
1167
1168 freea (outcharset);
1169 }
1170 else
1171# endif
1172 convd->conv = iconv_open (outcharset, charset);
1173# endif
1174# endif
1175
1176 freea (charset);
1177 }
1178 }
1179 }
1180 convd->conv_tab = NULL;
1181 /* Here domain->conversions is still == new_conversions. */
1182 domain->nconversions++;
1183 }
1184
1185 found_convd:
1186 gl_rwlock_unlock (domain->conversions_lock);
1187 }
1188
1189 if (
1190# ifdef _LIBC
1191 convd->conv != (__gconv_t) -1
1192# else
1193# if HAVE_ICONV
1194 convd->conv != (iconv_t) -1
1195# endif
1196# endif
1197 )
1198 {
1199 /* We are supposed to do a conversion. First allocate an
1200 appropriate table with the same structure as the table
1201 of translations in the file, where we can put the pointers
1202 to the converted strings in.
1203 There is a slight complication with plural entries. They
1204 are represented by consecutive NUL terminated strings. We
1205 handle this case by converting RESULTLEN bytes, including
1206 NULs. */
1207
1208 /* This lock primarily protects the memory management variables
1209 freemem, freemem_size. It also protects write accesses to
1210 convd->conv_tab. It's not worth using a separate lock (such
1211 as domain->conversions_lock) for this purpose, because when
1212 modifying convd->conv_tab, we also need to lock freemem,
1213 freemem_size for most of the time. */
1214 __libc_lock_define_initialized (static, lock)
1215
1216 if (__builtin_expect (convd->conv_tab == NULL, 0))
1217 {
1218 __libc_lock_lock (lock);
1219 if (convd->conv_tab == NULL)
1220 {
1221 convd->conv_tab =
1222 (char **) calloc (nstrings + domain->n_sysdep_strings,
1223 sizeof (char *));
1224 if (convd->conv_tab != NULL)
1225 goto not_translated_yet;
1226 /* Mark that we didn't succeed allocating a table. */
1227 convd->conv_tab = (char **) -1;
1228 }
1229 __libc_lock_unlock (lock);
1230 }
1231
1232 if (__builtin_expect (convd->conv_tab == (char **) -1, 0))
1233 /* Nothing we can do, no more memory. We cannot use the
1234 translation because it might be encoded incorrectly. */
1235 return (char *) -1;
1236
1237 if (convd->conv_tab[act] == NULL)
1238 {
1239 /* We haven't used this string so far, so it is not
1240 translated yet. Do this now. */
1241 /* We use a bit more efficient memory handling.
1242 We allocate always larger blocks which get used over
1243 time. This is faster than many small allocations. */
1244# define INITIAL_BLOCK_SIZE 4080
1245 static unsigned char *freemem;
1246 static size_t freemem_size;
1247
1248 const unsigned char *inbuf;
1249 unsigned char *outbuf;
1250 int malloc_count;
1251# ifndef _LIBC
1252 transmem_block_t *transmem_list;
1253# endif
1254
1255 __libc_lock_lock (lock);
1256 not_translated_yet:
1257
1258 inbuf = (const unsigned char *) result;
1259 outbuf = freemem + sizeof (size_t);
1260# ifndef _LIBC
1261 transmem_list = NULL;
1262# endif
1263
1264 malloc_count = 0;
1265 while (1)
1266 {
1267 transmem_block_t *newmem;
1268# ifdef _LIBC
1269 size_t non_reversible;
1270 int res;
1271
1272 if (freemem_size < sizeof (size_t))
1273 goto resize_freemem;
1274
1275 res = __gconv (convd->conv,
1276 &inbuf, inbuf + resultlen,
1277 &outbuf,
1278 outbuf + freemem_size - sizeof (size_t),
1279 &non_reversible);
1280
1281 if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
1282 break;
1283
1284 if (res != __GCONV_FULL_OUTPUT)
1285 {
1286 /* We should not use the translation at all, it
1287 is incorrectly encoded. */
1288 __libc_lock_unlock (lock);
1289 return NULL;
1290 }
1291
1292 inbuf = (const unsigned char *) result;
1293# else
1294# if HAVE_ICONV
1295 const char *inptr = (const char *) inbuf;
1296 size_t inleft = resultlen;
1297 char *outptr = (char *) outbuf;
1298 size_t outleft;
1299
1300 if (freemem_size < sizeof (size_t))
1301 goto resize_freemem;
1302
1303 outleft = freemem_size - sizeof (size_t);
1304 if (iconv (convd->conv,
1305 (ICONV_CONST char **) &inptr, &inleft,
1306 &outptr, &outleft)
1307 != (size_t) (-1))
1308 {
1309 outbuf = (unsigned char *) outptr;
1310 break;
1311 }
1312 if (errno != E2BIG)
1313 {
1314 __libc_lock_unlock (lock);
1315 return NULL;
1316 }
1317# endif
1318# endif
1319
1320 resize_freemem:
1321 /* We must allocate a new buffer or resize the old one. */
1322 if (malloc_count > 0)
1323 {
1324 ++malloc_count;
1325 freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
1326 newmem = (transmem_block_t *) realloc (transmem_list,
1327 freemem_size);
1328# ifdef _LIBC
1329 if (newmem != NULL)
1330 transmem_list = newmem;
1331 else
1332 {
1333 struct transmem_list *old = transmem_list;
1334
1335 transmem_list = transmem_list->next;
1336 free (old);
1337 }
1338# endif
1339 }
1340 else
1341 {
1342 malloc_count = 1;
1343 freemem_size = INITIAL_BLOCK_SIZE;
1344 newmem = (transmem_block_t *) malloc (freemem_size);
1345# ifdef _LIBC
1346 if (newmem != NULL)
1347 {
1348 /* Add the block to the list of blocks we have to free
1349 at some point. */
1350 newmem->next = transmem_list;
1351 transmem_list = newmem;
1352 }
1353 /* Fall through and return -1. */
1354# endif
1355 }
1356 if (__builtin_expect (newmem == NULL, 0))
1357 {
1358 freemem = NULL;
1359 freemem_size = 0;
1360 __libc_lock_unlock (lock);
1361 return (char *) -1;
1362 }
1363
1364# ifdef _LIBC
1365 freemem = (unsigned char *) newmem->data;
1366 freemem_size -= offsetof (struct transmem_list, data);
1367# else
1368 transmem_list = newmem;
1369 freemem = newmem;
1370# endif
1371
1372 outbuf = freemem + sizeof (size_t);
1373 }
1374
1375 /* We have now in our buffer a converted string. Put this
1376 into the table of conversions. */
1377 *(size_t *) freemem = outbuf - freemem - sizeof (size_t);
1378 convd->conv_tab[act] = (char *) freemem;
1379 /* Shrink freemem, but keep it aligned. */
1380 freemem_size -= outbuf - freemem;
1381 freemem = outbuf;
1382 freemem += freemem_size & (alignof (size_t) - 1);
1383 freemem_size = freemem_size & ~ (alignof (size_t) - 1);
1384
1385 __libc_lock_unlock (lock);
1386 }
1387
1388 /* Now convd->conv_tab[act] contains the translation of all
1389 the plural variants. */
1390 result = convd->conv_tab[act] + sizeof (size_t);
1391 resultlen = *(size_t *) convd->conv_tab[act];
1392 }
1393 }
1394
1395 /* The result string is converted. */
1396
1397#endif /* _LIBC || HAVE_ICONV */
1398
1399 *lengthp = resultlen;
1400 return result;
1401}
1402
1403
1404/* Look up a plural variant. */
1405static char *
1406plural_lookup (struct loaded_l10nfile *domain, unsigned long int n,
1407 const char *translation, size_t translation_len)
1408{
1409 struct loaded_domain *domaindata = (struct loaded_domain *) domain->data;
1410 unsigned long int index;
1411 const char *p;
1412
1413 index = plural_eval (domaindata->plural, n);
1414 if (index >= domaindata->nplurals)
1415 /* This should never happen. It means the plural expression and the
1416 given maximum value do not match. */
1417 index = 0;
1418
1419 /* Skip INDEX strings at TRANSLATION. */
1420 p = translation;
1421 while (index-- > 0)
1422 {
1423#ifdef _LIBC
1424 p = __rawmemchr (p, '\0');
1425#else
1426 p = strchr (p, '\0');
1427#endif
1428 /* And skip over the NUL byte. */
1429 p++;
1430
1431 if (p >= translation + translation_len)
1432 /* This should never happen. It means the plural expression
1433 evaluated to a value larger than the number of variants
1434 available for MSGID1. */
1435 return (char *) translation;
1436 }
1437 return (char *) p;
1438}
1439
1440#ifndef _LIBC
1441/* Return string representation of locale CATEGORY. */
1442static const char *
1443category_to_name (int category)
1444{
1445 const char *retval;
1446
1447 switch (category)
1448 {
1449#ifdef LC_COLLATE
1450 case LC_COLLATE:
1451 retval = "LC_COLLATE";
1452 break;
1453#endif
1454#ifdef LC_CTYPE
1455 case LC_CTYPE:
1456 retval = "LC_CTYPE";
1457 break;
1458#endif
1459#ifdef LC_MONETARY
1460 case LC_MONETARY:
1461 retval = "LC_MONETARY";
1462 break;
1463#endif
1464#ifdef LC_NUMERIC
1465 case LC_NUMERIC:
1466 retval = "LC_NUMERIC";
1467 break;
1468#endif
1469#ifdef LC_TIME
1470 case LC_TIME:
1471 retval = "LC_TIME";
1472 break;
1473#endif
1474#ifdef LC_MESSAGES
1475 case LC_MESSAGES:
1476 retval = "LC_MESSAGES";
1477 break;
1478#endif
1479#ifdef LC_RESPONSE
1480 case LC_RESPONSE:
1481 retval = "LC_RESPONSE";
1482 break;
1483#endif
1484#ifdef LC_ALL
1485 case LC_ALL:
1486 /* This might not make sense but is perhaps better than any other
1487 value. */
1488 retval = "LC_ALL";
1489 break;
1490#endif
1491 default:
1492 /* If you have a better idea for a default value let me know. */
1493 retval = "LC_XXX";
1494 }
1495
1496 return retval;
1497}
1498#endif
1499
1500/* Guess value of current locale from value of the environment variables
1501 or system-dependent defaults. */
1502static const char *
1503#ifdef IN_LIBGLOCALE
1504guess_category_value (int category, const char *categoryname,
1505 const char *locale)
1506
1507#else
1508guess_category_value (int category, const char *categoryname)
1509#endif
1510{
1511 const char *language;
1512#ifndef IN_LIBGLOCALE
1513 const char *locale;
1514# ifndef _LIBC
1515 const char *language_default;
1516 int locale_defaulted;
1517# endif
1518#endif
1519
1520 /* We use the settings in the following order:
1521 1. The value of the environment variable 'LANGUAGE'. This is a GNU
1522 extension. Its value can be a colon-separated list of locale names.
1523 2. The value of the environment variable 'LC_ALL', 'LC_xxx', or 'LANG'.
1524 More precisely, the first among these that is set to a non-empty value.
1525 This is how POSIX specifies it. The value is a single locale name.
1526 3. A system-dependent preference list of languages. Its value can be a
1527 colon-separated list of locale names.
1528 4. A system-dependent default locale name.
1529 This way:
1530 - System-dependent settings can be overridden by environment variables.
1531 - If the system provides both a list of languages and a default locale,
1532 the former is used. */
1533
1534#ifndef IN_LIBGLOCALE
1535 /* Fetch the locale name, through the POSIX method of looking to `LC_ALL',
1536 `LC_xxx', and `LANG'. On some systems this can be done by the
1537 `setlocale' function itself. */
1538# ifdef _LIBC
1539 locale = __current_locale_name (category);
1540# else
1541 locale_defaulted = 0;
1542# if HAVE_USELOCALE
1543 locale = _nl_locale_name_thread_unsafe (category, categoryname);
1544 if (locale == NULL)
1545# endif
1546 {
1547 locale = _nl_locale_name_posix (category, categoryname);
1548 if (locale == NULL)
1549 {
1550 locale = _nl_locale_name_default ();
1551 locale_defaulted = 1;
1552 }
1553 }
1554# endif
1555#endif
1556
1557 /* Ignore LANGUAGE and its system-dependent analogon if the locale is set
1558 to "C" because
1559 1. "C" locale usually uses the ASCII encoding, and most international
1560 messages use non-ASCII characters. These characters get displayed
1561 as question marks (if using glibc's iconv()) or as invalid 8-bit
1562 characters (because other iconv()s refuse to convert most non-ASCII
1563 characters to ASCII). In any case, the output is ugly.
1564 2. The precise output of some programs in the "C" locale is specified
1565 by POSIX and should not depend on environment variables like
1566 "LANGUAGE" or system-dependent information. We allow such programs
1567 to use gettext(). */
1568 if (strcmp (locale, "C") == 0)
1569 return locale;
1570
1571 /* The highest priority value is the value of the 'LANGUAGE' environment
1572 variable. */
1573 language = getenv ("LANGUAGE");
1574 if (language != NULL && language[0] != '\0')
1575 return language;
1576#if !defined IN_LIBGLOCALE && !defined _LIBC
1577 /* The next priority value is the locale name, if not defaulted. */
1578 if (locale_defaulted)
1579 {
1580 /* The next priority value is the default language preferences list. */
1581 language_default = _nl_language_preferences_default ();
1582 if (language_default != NULL)
1583 return language_default;
1584 }
1585 /* The least priority value is the locale name, if defaulted. */
1586#endif
1587 return locale;
1588}
1589
1590#if (defined _LIBC || HAVE_ICONV) && !defined IN_LIBGLOCALE
1591/* Returns the output charset. */
1592static const char *
1593get_output_charset (struct binding *domainbinding)
1594{
1595 /* The output charset should normally be determined by the locale. But
1596 sometimes the locale is not used or not correctly set up, so we provide
1597 a possibility for the user to override this: the OUTPUT_CHARSET
1598 environment variable. Moreover, the value specified through
1599 bind_textdomain_codeset overrides both. */
1600 if (domainbinding != NULL && domainbinding->codeset != NULL)
1601 return domainbinding->codeset;
1602 else
1603 {
1604 /* For speed reasons, we look at the value of OUTPUT_CHARSET only
1605 once. This is a user variable that is not supposed to change
1606 during a program run. */
1607 static char *output_charset_cache;
1608 static int output_charset_cached;
1609
1610 if (!output_charset_cached)
1611 {
1612 const char *value = getenv ("OUTPUT_CHARSET");
1613
1614 if (value != NULL && value[0] != '\0')
1615 {
1616 size_t len = strlen (value) + 1;
1617 char *value_copy = (char *) malloc (len);
1618
1619 if (value_copy != NULL)
1620 memcpy (value_copy, value, len);
1621 output_charset_cache = value_copy;
1622 }
1623 output_charset_cached = 1;
1624 }
1625
1626 if (output_charset_cache != NULL)
1627 return output_charset_cache;
1628 else
1629 {
1630# ifdef _LIBC
1631 return _NL_CURRENT (LC_CTYPE, CODESET);
1632# else
1633# if HAVE_ICONV
1634 return locale_charset ();
1635# endif
1636# endif
1637 }
1638 }
1639}
1640#endif
1641
1642/* @@ begin of epilog @@ */
1643
1644/* We don't want libintl.a to depend on any other library. So we
1645 avoid the non-standard function stpcpy. In GNU C Library this
1646 function is available, though. Also allow the symbol HAVE_STPCPY
1647 to be defined. */
1648#if !_LIBC && !HAVE_STPCPY
1649static char *
1650stpcpy (char *dest, const char *src)
1651{
1652 while ((*dest++ = *src++) != '\0')
1653 /* Do nothing. */ ;
1654 return dest - 1;
1655}
1656#endif
1657
1658#if !_LIBC && !HAVE_MEMPCPY
1659static void *
1660mempcpy (void *dest, const void *src, size_t n)
1661{
1662 return (void *) ((char *) memcpy (dest, src, n) + n);
1663}
1664#endif
1665
1666#if !_LIBC && !HAVE_TSEARCH
1667# include "tsearch.c"
1668#endif
1669
1670
1671#ifdef _LIBC
1672/* If we want to free all resources we have to do some work at
1673 program's end. */
1674libc_freeres_fn (free_mem)
1675{
1676 void *old;
1677
1678 while (_nl_domain_bindings != NULL)
1679 {
1680 struct binding *oldp = _nl_domain_bindings;
1681 _nl_domain_bindings = _nl_domain_bindings->next;
1682 if (oldp->dirname != _nl_default_dirname)
1683 /* Yes, this is a pointer comparison. */
1684 free (oldp->dirname);
1685 free (oldp->codeset);
1686 free (oldp);
1687 }
1688
1689 if (_nl_current_default_domain != _nl_default_default_domain)
1690 /* Yes, again a pointer comparison. */
1691 free ((char *) _nl_current_default_domain);
1692
1693 /* Remove the search tree with the known translations. */
1694 __tdestroy (root, free);
1695 root = NULL;
1696
1697 while (transmem_list != NULL)
1698 {
1699 old = transmem_list;
1700 transmem_list = transmem_list->next;
1701 free (old);
1702 }
1703}
1704#endif
1705

source code of glibc/intl/dcigettext.c