1 /* Implementation of the internal dcigettext function.
2 Copyright (C) 1995-2020 Free Software Foundation, Inc.
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.
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.
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/>. */
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. */
21 # define _GNU_SOURCE 1
28 #include <sys/types.h>
31 # define alloca __builtin_alloca
32 # define HAVE_ALLOCA 1
36 # define alloca _alloca
38 # if defined HAVE_ALLOCA_H || defined _LIBC
57 # define __set_errno(val) errno = (val)
65 #if defined HAVE_UNISTD_H || defined _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
78 # define INTDIV0_RAISES_SIGFPE 0
81 #if !INTDIV0_RAISES_SIGFPE
85 #if defined HAVE_SYS_PARAM_H || defined _LIBC
86 # include <sys/param.h>
90 # include "localcharset.h"
94 #include "plural-exp.h"
101 # include "libgnuintl.h"
103 #include "hash-string.h"
105 /* Handle multi-threaded applications. */
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
116 /* Alignment of types. */
117 #if defined __GNUC__ && __GNUC__ >= 2
118 # define alignof(TYPE) __alignof__ (TYPE)
120 # define alignof(TYPE) \
121 ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
124 /* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>. */
126 # define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
129 /* @@ end of prolog @@ */
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
138 # define stpcpy __stpcpy
140 # define tfind __tfind
142 # if !defined HAVE_GETCWD
144 # define getcwd(buf, max) getwd (buf)
147 # define getcwd(buf, max) (getcwd) (buf, max, 0)
153 static char *stpcpy (char *dest
, const char *src
);
155 # ifndef HAVE_MEMPCPY
156 static void *mempcpy (void *dest
, const void *src
, size_t n
);
160 /* Use a replacement if the system does not provide the `tsearch' function
162 #if defined HAVE_TSEARCH || defined _LIBC
165 # define tsearch libintl_tsearch
166 # define tfind libintl_tfind
167 # define tdelete libintl_tdelete
168 # define twalk libintl_twalk
169 # include "tsearch.h"
173 # define tsearch __tsearch
176 /* Amount to increase buffer size by in each try. */
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__)
187 #ifndef _POSIX_PATH_MAX
188 # define _POSIX_PATH_MAX 255
191 #if !defined PATH_MAX && defined _PC_PATH_MAX
192 # define PATH_MAX (__pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : __pathconf ("/", _PC_PATH_MAX))
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>
200 #if !defined PATH_MAX && defined MAXPATHLEN
201 # define PATH_MAX MAXPATHLEN
205 # define PATH_MAX _POSIX_PATH_MAX
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.
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')) \
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))
225 # define ISSLASH(C) ((C) == '/')
226 # define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0])
227 # define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
230 /* Whether to support different locales in different threads. */
231 #if defined _LIBC || HAVE_USELOCALE || defined IN_LIBGLOCALE
232 # define HAVE_PER_THREAD_LOCALE
235 /* This is the type used for the search tree where known translations
237 struct known_translation_t
239 /* Domain in which to search. */
240 const char *domainname
;
245 #ifdef HAVE_PER_THREAD_LOCALE
246 /* Name of the relevant locale category, or "" for the global locale. */
247 const char *localename
;
251 /* The character encoding. */
252 const char *encoding
;
255 /* State of the catalog counter at the point the string was found. */
258 /* Catalog where the string was found. */
259 struct loaded_l10nfile
*domain
;
261 /* And finally the translation. */
262 const char *translation
;
263 size_t translation_length
;
265 /* Pointer to the string in question. */
268 char appended
[ZERO
]; /* used if domain != NULL */
269 const char *ptr
; /* used if domain == NULL */
274 gl_rwlock_define_initialized (static, tree_lock
)
276 /* Root of the search tree with known translations. */
279 /* Function to compare two entries in the table of known translations. */
281 transcmp (const void *p1
, const void *p2
)
283 const struct known_translation_t
*s1
;
284 const struct known_translation_t
*s2
;
287 s1
= (const struct known_translation_t
*) p1
;
288 s2
= (const struct known_translation_t
*) p2
;
290 result
= strcmp (s1
->domain
!= NULL
? s1
->msgid
.appended
: s1
->msgid
.ptr
,
291 s2
->domain
!= NULL
? s2
->msgid
.appended
: s2
->msgid
.ptr
);
294 result
= strcmp (s1
->domainname
, s2
->domainname
);
297 #ifdef HAVE_PER_THREAD_LOCALE
298 result
= strcmp (s1
->localename
, s2
->localename
);
303 result
= strcmp (s1
->encoding
, s2
->encoding
);
306 /* We compare the category last (though this is the cheapest
307 operation) since it is hopefully always the same (namely
309 result
= s1
->category
- s2
->category
;
317 /* Name of the default domain used for gettext(3) prior any call to
318 textdomain(3). The default value for this is "messages". */
319 const char _nl_default_default_domain
[] attribute_hidden
= "messages";
321 #ifndef IN_LIBGLOCALE
322 /* Value used as the default domain for gettext(3). */
323 const char *_nl_current_default_domain attribute_hidden
324 = _nl_default_default_domain
;
327 /* Contains the default location of the message catalogs. */
329 extern const char _nl_default_dirname
[];
332 extern const char _nl_default_dirname
[];
333 libc_hidden_proto (_nl_default_dirname
)
335 const char _nl_default_dirname
[] = LOCALEDIR
;
337 libc_hidden_data_def (_nl_default_dirname
)
341 #ifndef IN_LIBGLOCALE
342 /* List with bindings of specific domains created by bindtextdomain()
344 struct binding
*_nl_domain_bindings
;
347 /* Prototypes for local functions. */
348 static char *plural_lookup (struct loaded_l10nfile
*domain
,
350 const char *translation
, size_t translation_len
);
353 static const char *guess_category_value (int category
,
354 const char *categoryname
,
355 const char *localename
);
357 static const char *guess_category_value (int category
,
358 const char *categoryname
);
362 # include "../locale/localeinfo.h"
363 # define category_to_name(category) _nl_category_names_get (category)
365 static const char *category_to_name (int category
);
367 #if (defined _LIBC || HAVE_ICONV) && !defined IN_LIBGLOCALE
368 static const char *get_output_charset (struct binding
*domainbinding
);
372 /* For those losing systems which don't have `alloca' we have to add
373 some additional code emulating it. */
375 /* Nothing has to be done. */
376 # define freea(p) /* nothing */
377 # define ADD_BLOCK(list, address) /* nothing */
378 # define FREE_BLOCKS(list) /* nothing */
383 struct block_list
*next
;
385 # define ADD_BLOCK(list, addr) \
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 \
390 if (newp != NULL) { \
391 newp->address = (addr); \
392 newp->next = (list); \
396 # define FREE_BLOCKS(list) \
398 while (list != NULL) { \
399 struct block_list *old = list; \
401 free (old->address); \
406 # define alloca(size) (malloc (size))
407 # define freea(p) free (p)
408 #endif /* have alloca */
412 /* List of blocks allocated for translations. */
413 typedef struct transmem_list
415 struct transmem_list
*next
;
418 static struct transmem_list
*transmem_list
;
420 typedef unsigned char transmem_block_t
;
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. */
429 # define DCIGETTEXT __dcigettext
431 # define DCIGETTEXT libintl_dcigettext
434 /* Lock variable to protect the global data in the gettext implementation. */
435 gl_rwlock_define_initialized (, _nl_state_lock attribute_hidden
)
437 /* Checking whether the binaries runs SUID must be done and glibc provides
438 easier methods therefore we make a difference here. */
440 # define ENABLE_SECURE __libc_enable_secure
441 # define DETERMINE_SECURE
449 # ifndef HAVE_GETEUID
450 # define geteuid() getuid()
452 # ifndef HAVE_GETEGID
453 # define getegid() getgid()
455 static int enable_secure
;
456 # define ENABLE_SECURE (enable_secure == 1)
457 # define DETERMINE_SECURE \
458 if (enable_secure == 0) \
460 if (getuid () != geteuid () || getgid () != getegid ()) \
463 enable_secure = -1; \
467 /* Get the function to evaluate the plural expression. */
468 #include "eval-plural.h"
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. */
475 gl_dcigettext (const char *domainname
,
476 const char *msgid1
, const char *msgid2
,
477 int plural
, unsigned long int n
,
479 const char *localename
, const char *encoding
)
482 DCIGETTEXT (const char *domainname
, const char *msgid1
, const char *msgid2
,
483 int plural
, unsigned long int n
, int category
)
487 struct block_list
*block_list
= NULL
;
489 struct loaded_l10nfile
*domain
;
490 struct binding
*binding
;
491 const char *categoryname
;
492 const char *categoryvalue
;
494 char *xdirname
= NULL
;
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
;
505 size_t domainname_len
;
507 /* If no real MSGID is given return NULL. */
512 if (category
< 0 || category
>= __LC_LAST
|| category
== LC_ALL
)
516 /* Use the Germanic plural rule. */
517 : n
== 1 ? (char *) msgid1
: (char *) msgid2
);
520 /* Preserve the `errno' value. */
524 __libc_rwlock_define (extern, __libc_setlocale_lock attribute_hidden
)
525 __libc_rwlock_rdlock (__libc_setlocale_lock
);
528 gl_rwlock_rdlock (_nl_state_lock
);
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
;
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
;
542 /* Try to find the translation among those which we found at
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
551 localename
= __current_locale_name (category
);
553 categoryname
= category_to_name (category
);
554 # define CATEGORYNAME_INITIALIZED
555 localename
= _nl_locale_name_thread_unsafe (category
, categoryname
);
556 if (localename
== NULL
)
560 search
.localename
= localename
;
561 # ifdef IN_LIBGLOCALE
562 search
.encoding
= encoding
;
565 /* Since tfind/tsearch manage a balanced tree, concurrent tfind and
566 tsearch calls can be fatal. */
567 gl_rwlock_rdlock (tree_lock
);
569 foundp
= (struct known_translation_t
**) tfind (&search
, &root
, transcmp
);
571 gl_rwlock_unlock (tree_lock
);
573 if (foundp
!= NULL
&& (*foundp
)->counter
== _nl_msg_cat_cntr
)
575 /* Now deal with plural. */
577 retval
= plural_lookup ((*foundp
)->domain
, n
, (*foundp
)->translation
,
578 (*foundp
)->translation_length
);
580 retval
= (char *) (*foundp
)->translation
;
582 gl_rwlock_unlock (_nl_state_lock
);
584 __libc_rwlock_unlock (__libc_setlocale_lock
);
586 __set_errno (saved_errno
);
591 /* See whether this is a SUID binary or not. */
594 /* First find matching binding. */
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. */
599 dirname
= bindtextdomain (domainname
, NULL
);
601 for (binding
= _nl_domain_bindings
; binding
!= NULL
; binding
= binding
->next
)
603 int compare
= strcmp (domainname
, binding
->domainname
);
609 /* It is not in the list. */
616 dirname
= _nl_default_dirname
;
619 dirname
= binding
->dirname
;
621 if (!IS_ABSOLUTE_PATH (dirname
))
623 /* We have a relative path. Make it absolute now. */
624 char *cwd
= getcwd (NULL
, 0);
626 /* We cannot get the current working directory. Don't
627 signal an error but simply return the default
629 goto return_untranslated
;
630 int ret
= __asprintf (&xdirname
, "%s/%s", cwd
, dirname
);
633 goto return_untranslated
;
636 #ifndef IN_LIBGLOCALE
640 /* Now determine the symbolic name of CATEGORY and its value. */
641 #ifndef CATEGORYNAME_INITIALIZED
642 categoryname
= category_to_name (category
);
645 categoryvalue
= guess_category_value (category
, categoryname
, localename
);
647 categoryvalue
= guess_category_value (category
, categoryname
);
650 domainname_len
= strlen (domainname
);
651 xdomainname
= (char *) alloca (strlen (categoryname
)
652 + domainname_len
+ 5);
653 ADD_BLOCK (block_list
, xdomainname
);
655 stpcpy ((char *) mempcpy (stpcpy (stpcpy (xdomainname
, categoryname
), "/"),
656 domainname
, domainname_len
),
659 /* Creating working area. */
660 single_locale
= (char *) alloca (strlen (categoryvalue
) + 1);
661 ADD_BLOCK (block_list
, single_locale
);
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. */
668 /* Make CATEGORYVALUE point to the next element of the list. */
669 while (categoryvalue
[0] != '\0' && categoryvalue
[0] == ':')
671 if (categoryvalue
[0] == '\0')
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
677 single_locale
[0] = 'C';
678 single_locale
[1] = '\0';
682 char *cp
= single_locale
;
683 while (categoryvalue
[0] != '\0' && categoryvalue
[0] != ':')
684 *cp
++ = *categoryvalue
++;
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. */
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)
700 /* Find structure describing the message catalog matching the
701 DOMAINNAME and CATEGORY. */
702 domain
= _nl_find_domain (dirname
, single_locale
, xdomainname
, binding
);
706 #if defined IN_LIBGLOCALE
707 retval
= _nl_find_msg (domain
, binding
, encoding
, msgid1
, &retlen
);
709 retval
= _nl_find_msg (domain
, binding
, msgid1
, 1, &retlen
);
716 for (cnt
= 0; domain
->successor
[cnt
] != NULL
; ++cnt
)
718 #if defined IN_LIBGLOCALE
719 retval
= _nl_find_msg (domain
->successor
[cnt
], binding
,
720 encoding
, msgid1
, &retlen
);
722 retval
= _nl_find_msg (domain
->successor
[cnt
], binding
,
726 /* Resource problems are not fatal, instead we return no
728 if (__builtin_expect (retval
== (char *) -1, 0))
729 goto return_untranslated
;
733 domain
= domain
->successor
[cnt
];
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))
747 /* Found the translation of MSGID1 in domain DOMAIN:
748 starting at RETVAL, RETLEN bytes. */
750 FREE_BLOCKS (block_list
);
753 /* Create a new entry and add it to the search tree. */
756 struct known_translation_t
*newp
;
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;
764 newp
= (struct known_translation_t
*) malloc (size
);
767 char *new_domainname
;
768 #ifdef HAVE_PER_THREAD_LOCALE
769 char *new_localename
;
773 (char *) mempcpy (newp
->msgid
.appended
, msgid1
,
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
);
780 newp
->domainname
= new_domainname
;
781 newp
->category
= category
;
782 #ifdef HAVE_PER_THREAD_LOCALE
783 newp
->localename
= new_localename
;
786 newp
->encoding
= encoding
;
788 newp
->counter
= _nl_msg_cat_cntr
;
789 newp
->domain
= domain
;
790 newp
->translation
= retval
;
791 newp
->translation_length
= retlen
;
793 gl_rwlock_wrlock (tree_lock
);
795 /* Insert the entry in the search tree. */
796 foundp
= (struct known_translation_t
**)
797 tsearch (newp
, &root
, transcmp
);
799 gl_rwlock_unlock (tree_lock
);
802 || __builtin_expect (*foundp
!= newp
, 0))
803 /* The insert failed. */
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
;
816 __set_errno (saved_errno
);
818 /* Now deal with plural. */
820 retval
= plural_lookup (domain
, n
, retval
, retlen
);
822 gl_rwlock_unlock (_nl_state_lock
);
824 __libc_rwlock_unlock (__libc_setlocale_lock
);
832 /* Return the untranslated MSGID. */
834 FREE_BLOCKS (block_list
);
835 gl_rwlock_unlock (_nl_state_lock
);
837 __libc_rwlock_unlock (__libc_setlocale_lock
);
842 extern void _nl_log_untranslated (const char *logfilename
,
843 const char *domainname
,
844 const char *msgid1
, const char *msgid2
,
846 const char *logfilename
= getenv ("GETTEXT_LOG_UNTRANSLATED");
848 if (logfilename
!= NULL
&& logfilename
[0] != '\0')
849 _nl_log_untranslated (logfilename
, domainname
, msgid1
, msgid2
, plural
);
852 __set_errno (saved_errno
);
855 /* Use the Germanic plural rule. */
856 : n
== 1 ? (char *) msgid1
: (char *) msgid2
);
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). */
867 _nl_find_msg (struct loaded_l10nfile
*domain_file
,
868 struct binding
*domainbinding
, const char *encoding
,
872 _nl_find_msg (struct loaded_l10nfile
*domain_file
,
873 struct binding
*domainbinding
,
874 const char *msgid
, int convert
,
878 struct loaded_domain
*domain
;
884 if (domain_file
->decided
<= 0)
885 _nl_load_domain (domain_file
, domainbinding
);
887 if (domain_file
->data
== NULL
)
890 domain
= (struct loaded_domain
*) domain_file
->data
;
892 nstrings
= domain
->nstrings
;
894 /* Locate the MSGID and its translation. */
895 if (domain
->hash_tab
!= NULL
)
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));
906 W (domain
->must_swap_hash_tab
, domain
->hash_tab
[idx
]);
909 /* Hash table entry is empty. */
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. */
918 ? W (domain
->must_swap
, domain
->orig_tab
[nstr
].length
) >= len
920 domain
->data
+ W (domain
->must_swap
,
921 domain
->orig_tab
[nstr
].offset
))
923 : domain
->orig_sysdep_tab
[nstr
- nstrings
].length
> len
925 domain
->orig_sysdep_tab
[nstr
- nstrings
].pointer
)
932 if (idx
>= domain
->hash_size
- incr
)
933 idx
-= domain
->hash_size
- incr
;
941 /* Try the default method: binary search in the sorted array of
951 act
= (bottom
+ top
) / 2;
952 cmp_val
= strcmp (msgid
, (domain
->data
953 + W (domain
->must_swap
,
954 domain
->orig_tab
[act
].offset
)));
957 else if (cmp_val
> 0)
962 /* No translation was 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. */
972 (domain
->data
+ W (domain
->must_swap
, domain
->trans_tab
[act
].offset
));
973 resultlen
= W (domain
->must_swap
, domain
->trans_tab
[act
].length
) + 1;
977 result
= (char *) domain
->trans_sysdep_tab
[act
- nstrings
].pointer
;
978 resultlen
= domain
->trans_sysdep_tab
[act
- nstrings
].length
;
981 #if defined _LIBC || HAVE_ICONV
982 # ifdef IN_LIBGLOCALE
983 if (encoding
!= NULL
)
988 /* We are supposed to do a conversion. */
989 # ifndef IN_LIBGLOCALE
990 const char *encoding
= get_output_charset (domainbinding
);
993 struct converted_domain
*convd
;
996 /* Protect against reallocation of the table. */
997 gl_rwlock_rdlock (domain
->conversions_lock
);
999 /* Search whether a table with converted translations for this
1000 encoding has already been allocated. */
1001 nconversions
= domain
->nconversions
;
1004 for (i
= nconversions
; i
> 0; )
1007 if (strcmp (domain
->conversions
[i
].encoding
, encoding
) == 0)
1009 convd
= &domain
->conversions
[i
];
1014 gl_rwlock_unlock (domain
->conversions_lock
);
1018 /* We have to allocate a new conversions table. */
1019 gl_rwlock_wrlock (domain
->conversions_lock
);
1020 nconversions
= domain
->nconversions
;
1022 /* Maybe in the meantime somebody added the translation.
1024 for (i
= nconversions
; i
> 0; )
1027 if (strcmp (domain
->conversions
[i
].encoding
, encoding
) == 0)
1029 convd
= &domain
->conversions
[i
];
1035 /* Allocate a table for the converted translations for this
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
)));
1044 if (__builtin_expect (new_conversions
== NULL
, 0))
1046 /* Nothing we can do, no more memory. We cannot use the
1047 translation because it might be encoded incorrectly. */
1049 gl_rwlock_unlock (domain
->conversions_lock
);
1053 domain
->conversions
= new_conversions
;
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. */
1062 convd
= &new_conversions
[nconversions
];
1063 convd
->encoding
= encoding
;
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. */
1071 convd
->conv
= (__gconv_t
) -1;
1074 convd
->conv
= (iconv_t
) -1;
1079 size_t nullentrylen
;
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. */
1085 # ifdef IN_LIBGLOCALE
1086 _nl_find_msg (domain_file
, domainbinding
, NULL
, "",
1089 _nl_find_msg (domain_file
, domainbinding
, "", 0, &nullentrylen
);
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))
1097 if (nullentry
!= NULL
)
1099 const char *charsetstr
;
1101 charsetstr
= strstr (nullentry
, "charset=");
1102 if (charsetstr
!= NULL
)
1106 const char *outcharset
;
1108 charsetstr
+= strlen ("charset=");
1109 len
= strcspn (charsetstr
, " \t\n");
1111 charset
= (char *) alloca (len
+ 1);
1112 # if defined _LIBC || HAVE_MEMPCPY
1113 *((char *) mempcpy (charset
, charsetstr
, len
)) = '\0';
1115 memcpy (charset
, charsetstr
, len
);
1116 charset
[len
] = '\0';
1119 outcharset
= encoding
;
1122 /* We always want to use transliteration. */
1123 outcharset
= norm_add_slashes (outcharset
, "TRANSLIT");
1124 charset
= norm_add_slashes (charset
, "");
1125 int r
= __gconv_open (outcharset
, charset
, &convd
->conv
,
1126 GCONV_AVOID_NOCONV
);
1127 if (__builtin_expect (r
!= __GCONV_OK
, 0))
1129 /* If the output encoding is the same there is
1130 nothing to do. Otherwise do not use the
1131 translation at all. */
1132 if (__builtin_expect (r
!= __GCONV_NULCONV
, 1))
1134 gl_rwlock_unlock (domain
->conversions_lock
);
1135 free ((char *) encoding
);
1139 convd
->conv
= (__gconv_t
) -1;
1143 /* When using GNU libc >= 2.2 or GNU libiconv >= 1.5,
1144 we want to use transliteration. */
1145 # if (((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2) \
1146 && !defined __UCLIBC__) \
1147 || _LIBICONV_VERSION >= 0x0105
1148 if (strchr (outcharset
, '/') == NULL
)
1152 len
= strlen (outcharset
);
1153 tmp
= (char *) alloca (len
+ 10 + 1);
1154 memcpy (tmp
, outcharset
, len
);
1155 memcpy (tmp
+ len
, "//TRANSLIT", 10 + 1);
1158 convd
->conv
= iconv_open (outcharset
, charset
);
1164 convd
->conv
= iconv_open (outcharset
, charset
);
1172 convd
->conv_tab
= NULL
;
1173 /* Here domain->conversions is still == new_conversions. */
1174 domain
->nconversions
++;
1178 gl_rwlock_unlock (domain
->conversions_lock
);
1183 convd
->conv
!= (__gconv_t
) -1
1186 convd
->conv
!= (iconv_t
) -1
1191 /* We are supposed to do a conversion. First allocate an
1192 appropriate table with the same structure as the table
1193 of translations in the file, where we can put the pointers
1194 to the converted strings in.
1195 There is a slight complication with plural entries. They
1196 are represented by consecutive NUL terminated strings. We
1197 handle this case by converting RESULTLEN bytes, including
1200 /* This lock primarily protects the memory management variables
1201 freemem, freemem_size. It also protects write accesses to
1202 convd->conv_tab. It's not worth using a separate lock (such
1203 as domain->conversions_lock) for this purpose, because when
1204 modifying convd->conv_tab, we also need to lock freemem,
1205 freemem_size for most of the time. */
1206 __libc_lock_define_initialized (static, lock
)
1208 if (__builtin_expect (convd
->conv_tab
== NULL
, 0))
1210 __libc_lock_lock (lock
);
1211 if (convd
->conv_tab
== NULL
)
1214 (char **) calloc (nstrings
+ domain
->n_sysdep_strings
,
1216 if (convd
->conv_tab
!= NULL
)
1217 goto not_translated_yet
;
1218 /* Mark that we didn't succeed allocating a table. */
1219 convd
->conv_tab
= (char **) -1;
1221 __libc_lock_unlock (lock
);
1224 if (__builtin_expect (convd
->conv_tab
== (char **) -1, 0))
1225 /* Nothing we can do, no more memory. We cannot use the
1226 translation because it might be encoded incorrectly. */
1229 if (convd
->conv_tab
[act
] == NULL
)
1231 /* We haven't used this string so far, so it is not
1232 translated yet. Do this now. */
1233 /* We use a bit more efficient memory handling.
1234 We allocate always larger blocks which get used over
1235 time. This is faster than many small allocations. */
1236 # define INITIAL_BLOCK_SIZE 4080
1237 static unsigned char *freemem
;
1238 static size_t freemem_size
;
1240 const unsigned char *inbuf
;
1241 unsigned char *outbuf
;
1244 transmem_block_t
*transmem_list
;
1247 __libc_lock_lock (lock
);
1250 inbuf
= (const unsigned char *) result
;
1251 outbuf
= freemem
+ sizeof (size_t);
1253 transmem_list
= NULL
;
1259 transmem_block_t
*newmem
;
1261 size_t non_reversible
;
1264 if (freemem_size
< sizeof (size_t))
1265 goto resize_freemem
;
1267 res
= __gconv (convd
->conv
,
1268 &inbuf
, inbuf
+ resultlen
,
1270 outbuf
+ freemem_size
- sizeof (size_t),
1273 if (res
== __GCONV_OK
|| res
== __GCONV_EMPTY_INPUT
)
1276 if (res
!= __GCONV_FULL_OUTPUT
)
1278 /* We should not use the translation at all, it
1279 is incorrectly encoded. */
1280 __libc_lock_unlock (lock
);
1284 inbuf
= (const unsigned char *) result
;
1287 const char *inptr
= (const char *) inbuf
;
1288 size_t inleft
= resultlen
;
1289 char *outptr
= (char *) outbuf
;
1292 if (freemem_size
< sizeof (size_t))
1293 goto resize_freemem
;
1295 outleft
= freemem_size
- sizeof (size_t);
1296 if (iconv (convd
->conv
,
1297 (ICONV_CONST
char **) &inptr
, &inleft
,
1301 outbuf
= (unsigned char *) outptr
;
1306 __libc_lock_unlock (lock
);
1313 /* We must allocate a new buffer or resize the old one. */
1314 if (malloc_count
> 0)
1317 freemem_size
= malloc_count
* INITIAL_BLOCK_SIZE
;
1318 newmem
= (transmem_block_t
*) realloc (transmem_list
,
1322 transmem_list
= newmem
;
1325 struct transmem_list
*old
= transmem_list
;
1327 transmem_list
= transmem_list
->next
;
1335 freemem_size
= INITIAL_BLOCK_SIZE
;
1336 newmem
= (transmem_block_t
*) malloc (freemem_size
);
1340 /* Add the block to the list of blocks we have to free
1342 newmem
->next
= transmem_list
;
1343 transmem_list
= newmem
;
1345 /* Fall through and return -1. */
1348 if (__builtin_expect (newmem
== NULL
, 0))
1352 __libc_lock_unlock (lock
);
1357 freemem
= (unsigned char *) newmem
->data
;
1358 freemem_size
-= offsetof (struct transmem_list
, data
);
1360 transmem_list
= newmem
;
1364 outbuf
= freemem
+ sizeof (size_t);
1367 /* We have now in our buffer a converted string. Put this
1368 into the table of conversions. */
1369 *(size_t *) freemem
= outbuf
- freemem
- sizeof (size_t);
1370 convd
->conv_tab
[act
] = (char *) freemem
;
1371 /* Shrink freemem, but keep it aligned. */
1372 freemem_size
-= outbuf
- freemem
;
1374 freemem
+= freemem_size
& (alignof (size_t) - 1);
1375 freemem_size
= freemem_size
& ~ (alignof (size_t) - 1);
1377 __libc_lock_unlock (lock
);
1380 /* Now convd->conv_tab[act] contains the translation of all
1381 the plural variants. */
1382 result
= convd
->conv_tab
[act
] + sizeof (size_t);
1383 resultlen
= *(size_t *) convd
->conv_tab
[act
];
1387 /* The result string is converted. */
1389 #endif /* _LIBC || HAVE_ICONV */
1391 *lengthp
= resultlen
;
1396 /* Look up a plural variant. */
1398 plural_lookup (struct loaded_l10nfile
*domain
, unsigned long int n
,
1399 const char *translation
, size_t translation_len
)
1401 struct loaded_domain
*domaindata
= (struct loaded_domain
*) domain
->data
;
1402 unsigned long int index
;
1405 index
= plural_eval (domaindata
->plural
, n
);
1406 if (index
>= domaindata
->nplurals
)
1407 /* This should never happen. It means the plural expression and the
1408 given maximum value do not match. */
1411 /* Skip INDEX strings at TRANSLATION. */
1416 p
= __rawmemchr (p
, '\0');
1418 p
= strchr (p
, '\0');
1420 /* And skip over the NUL byte. */
1423 if (p
>= translation
+ translation_len
)
1424 /* This should never happen. It means the plural expression
1425 evaluated to a value larger than the number of variants
1426 available for MSGID1. */
1427 return (char *) translation
;
1433 /* Return string representation of locale CATEGORY. */
1435 category_to_name (int category
)
1443 retval
= "LC_COLLATE";
1448 retval
= "LC_CTYPE";
1453 retval
= "LC_MONETARY";
1458 retval
= "LC_NUMERIC";
1468 retval
= "LC_MESSAGES";
1473 retval
= "LC_RESPONSE";
1478 /* This might not make sense but is perhaps better than any other
1484 /* If you have a better idea for a default value let me know. */
1492 /* Guess value of current locale from value of the environment variables
1493 or system-dependent defaults. */
1495 #ifdef IN_LIBGLOCALE
1496 guess_category_value (int category
, const char *categoryname
,
1500 guess_category_value (int category
, const char *categoryname
)
1503 const char *language
;
1504 #ifndef IN_LIBGLOCALE
1507 const char *language_default
;
1508 int locale_defaulted
;
1512 /* We use the settings in the following order:
1513 1. The value of the environment variable 'LANGUAGE'. This is a GNU
1514 extension. Its value can be a colon-separated list of locale names.
1515 2. The value of the environment variable 'LC_ALL', 'LC_xxx', or 'LANG'.
1516 More precisely, the first among these that is set to a non-empty value.
1517 This is how POSIX specifies it. The value is a single locale name.
1518 3. A system-dependent preference list of languages. Its value can be a
1519 colon-separated list of locale names.
1520 4. A system-dependent default locale name.
1522 - System-dependent settings can be overridden by environment variables.
1523 - If the system provides both a list of languages and a default locale,
1524 the former is used. */
1526 #ifndef IN_LIBGLOCALE
1527 /* Fetch the locale name, through the POSIX method of looking to `LC_ALL',
1528 `LC_xxx', and `LANG'. On some systems this can be done by the
1529 `setlocale' function itself. */
1531 locale
= __current_locale_name (category
);
1533 locale_defaulted
= 0;
1535 locale
= _nl_locale_name_thread_unsafe (category
, categoryname
);
1539 locale
= _nl_locale_name_posix (category
, categoryname
);
1542 locale
= _nl_locale_name_default ();
1543 locale_defaulted
= 1;
1549 /* Ignore LANGUAGE and its system-dependent analogon if the locale is set
1551 1. "C" locale usually uses the ASCII encoding, and most international
1552 messages use non-ASCII characters. These characters get displayed
1553 as question marks (if using glibc's iconv()) or as invalid 8-bit
1554 characters (because other iconv()s refuse to convert most non-ASCII
1555 characters to ASCII). In any case, the output is ugly.
1556 2. The precise output of some programs in the "C" locale is specified
1557 by POSIX and should not depend on environment variables like
1558 "LANGUAGE" or system-dependent information. We allow such programs
1559 to use gettext(). */
1560 if (strcmp (locale
, "C") == 0)
1563 /* The highest priority value is the value of the 'LANGUAGE' environment
1565 language
= getenv ("LANGUAGE");
1566 if (language
!= NULL
&& language
[0] != '\0')
1568 #if !defined IN_LIBGLOCALE && !defined _LIBC
1569 /* The next priority value is the locale name, if not defaulted. */
1570 if (locale_defaulted
)
1572 /* The next priority value is the default language preferences list. */
1573 language_default
= _nl_language_preferences_default ();
1574 if (language_default
!= NULL
)
1575 return language_default
;
1577 /* The least priority value is the locale name, if defaulted. */
1582 #if (defined _LIBC || HAVE_ICONV) && !defined IN_LIBGLOCALE
1583 /* Returns the output charset. */
1585 get_output_charset (struct binding
*domainbinding
)
1587 /* The output charset should normally be determined by the locale. But
1588 sometimes the locale is not used or not correctly set up, so we provide
1589 a possibility for the user to override this: the OUTPUT_CHARSET
1590 environment variable. Moreover, the value specified through
1591 bind_textdomain_codeset overrides both. */
1592 if (domainbinding
!= NULL
&& domainbinding
->codeset
!= NULL
)
1593 return domainbinding
->codeset
;
1596 /* For speed reasons, we look at the value of OUTPUT_CHARSET only
1597 once. This is a user variable that is not supposed to change
1598 during a program run. */
1599 static char *output_charset_cache
;
1600 static int output_charset_cached
;
1602 if (!output_charset_cached
)
1604 const char *value
= getenv ("OUTPUT_CHARSET");
1606 if (value
!= NULL
&& value
[0] != '\0')
1608 size_t len
= strlen (value
) + 1;
1609 char *value_copy
= (char *) malloc (len
);
1611 if (value_copy
!= NULL
)
1612 memcpy (value_copy
, value
, len
);
1613 output_charset_cache
= value_copy
;
1615 output_charset_cached
= 1;
1618 if (output_charset_cache
!= NULL
)
1619 return output_charset_cache
;
1623 return _NL_CURRENT (LC_CTYPE
, CODESET
);
1626 return locale_charset ();
1634 /* @@ begin of epilog @@ */
1636 /* We don't want libintl.a to depend on any other library. So we
1637 avoid the non-standard function stpcpy. In GNU C Library this
1638 function is available, though. Also allow the symbol HAVE_STPCPY
1640 #if !_LIBC && !HAVE_STPCPY
1642 stpcpy (char *dest
, const char *src
)
1644 while ((*dest
++ = *src
++) != '\0')
1650 #if !_LIBC && !HAVE_MEMPCPY
1652 mempcpy (void *dest
, const void *src
, size_t n
)
1654 return (void *) ((char *) memcpy (dest
, src
, n
) + n
);
1658 #if !_LIBC && !HAVE_TSEARCH
1659 # include "tsearch.c"
1664 /* If we want to free all resources we have to do some work at
1666 libc_freeres_fn (free_mem
)
1670 while (_nl_domain_bindings
!= NULL
)
1672 struct binding
*oldp
= _nl_domain_bindings
;
1673 _nl_domain_bindings
= _nl_domain_bindings
->next
;
1674 if (oldp
->dirname
!= _nl_default_dirname
)
1675 /* Yes, this is a pointer comparison. */
1676 free (oldp
->dirname
);
1677 free (oldp
->codeset
);
1681 if (_nl_current_default_domain
!= _nl_default_default_domain
)
1682 /* Yes, again a pointer comparison. */
1683 free ((char *) _nl_current_default_domain
);
1685 /* Remove the search tree with the known translations. */
1686 __tdestroy (root
, free
);
1689 while (transmem_list
!= NULL
)
1691 old
= transmem_list
;
1692 transmem_list
= transmem_list
->next
;