1 /* Implementation of the internal dcigettext function.
2 Copyright (C) 1995-2013 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
19 /* Tell glibc's <string.h> to provide a prototype for mempcpy().
20 This must come before <config.h> because <config.h> may include
21 <features.h>, and once <features.h> has been included, it's too late. */
23 # define _GNU_SOURCE 1
30 #include <sys/types.h>
33 # define alloca __builtin_alloca
34 # define HAVE_ALLOCA 1
36 # if defined HAVE_ALLOCA_H || defined _LIBC
54 # define __set_errno(val) errno = (val)
61 #if defined HAVE_UNISTD_H || defined _LIBC
67 #if defined HAVE_SYS_PARAM_H || defined _LIBC
68 # include <sys/param.h>
72 #include "plural-exp.h"
76 # include "libgnuintl.h"
78 #include "hash-string.h"
80 /* Thread safetyness. */
82 # include <bits/libc-lock.h>
84 /* Provide dummy implementation if this is outside glibc. */
85 # define __libc_lock_define_initialized(CLASS, NAME)
86 # define __libc_lock_lock(NAME)
87 # define __libc_lock_unlock(NAME)
88 # define __libc_rwlock_define_initialized(CLASS, NAME)
89 # define __libc_rwlock_rdlock(NAME)
90 # define __libc_rwlock_unlock(NAME)
93 /* Alignment of types. */
94 #if defined __GNUC__ && __GNUC__ >= 2
95 # define alignof(TYPE) __alignof__ (TYPE)
97 # define alignof(TYPE) \
98 ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
101 /* The internal variables in the standalone libintl.a must have different
102 names than the internal variables in GNU libc, otherwise programs
103 using libintl.a cannot be linked statically. */
105 # define _nl_default_default_domain libintl_nl_default_default_domain
106 # define _nl_current_default_domain libintl_nl_current_default_domain
107 # define _nl_default_dirname libintl_nl_default_dirname
108 # define _nl_domain_bindings libintl_nl_domain_bindings
111 /* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>. */
113 # define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
116 /* @@ end of prolog @@ */
119 /* Rename the non ANSI C functions. This is required by the standard
120 because some ANSI C functions will require linking with this object
121 file and the name space must not be polluted. */
122 # define getcwd __getcwd
124 # define stpcpy __stpcpy
126 # define tfind __tfind
128 # if !defined HAVE_GETCWD
130 # define getcwd(buf, max) getwd (buf)
135 static char *stpcpy
PARAMS ((char *dest
, const char *src
));
137 # ifndef HAVE_MEMPCPY
138 static void *mempcpy
PARAMS ((void *dest
, const void *src
, size_t n
));
142 /* Amount to increase buffer size by in each try. */
145 /* The following is from pathmax.h. */
146 /* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define
147 PATH_MAX but might cause redefinition warnings when sys/param.h is
148 later included (as on MORE/BSD 4.3). */
149 #if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__)
153 #ifndef _POSIX_PATH_MAX
154 # define _POSIX_PATH_MAX 255
157 #if !defined PATH_MAX && defined _PC_PATH_MAX
158 # define PATH_MAX (pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : pathconf ("/", _PC_PATH_MAX))
161 /* Don't include sys/param.h if it already has been. */
162 #if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN
163 # include <sys/param.h>
166 #if !defined PATH_MAX && defined MAXPATHLEN
167 # define PATH_MAX MAXPATHLEN
171 # define PATH_MAX _POSIX_PATH_MAX
174 /* Whether to support different locales in different threads. */
175 #if defined _LIBC || HAVE_NL_LOCALE_NAME
176 # define HAVE_PER_THREAD_LOCALE
179 /* This is the type used for the search tree where known translations
181 struct known_translation_t
183 /* Domain in which to search. */
184 const char *domainname
;
189 #ifdef HAVE_PER_THREAD_LOCALE
190 /* Name of the relevant locale category, or "" for the global locale. */
191 const char *localename
;
194 /* State of the catalog counter at the point the string was found. */
197 /* Catalog where the string was found. */
198 struct loaded_l10nfile
*domain
;
200 /* And finally the translation. */
201 const char *translation
;
202 size_t translation_length
;
204 /* Pointer to the string in question. */
207 char appended
[ZERO
]; /* used if domain != NULL */
208 const char *ptr
; /* used if domain == NULL */
213 /* Root of the search tree with known translations. We can use this
214 only if the system provides the `tsearch' function family. */
215 #if defined HAVE_TSEARCH || defined _LIBC
221 # define tsearch __tsearch
224 /* Function to compare two entries in the table of known translations. */
225 static int transcmp
PARAMS ((const void *p1
, const void *p2
));
231 const struct known_translation_t
*s1
;
232 const struct known_translation_t
*s2
;
235 s1
= (const struct known_translation_t
*) p1
;
236 s2
= (const struct known_translation_t
*) p2
;
238 result
= strcmp (s1
->domain
!= NULL
? s1
->msgid
.appended
: s1
->msgid
.ptr
,
239 s2
->domain
!= NULL
? s2
->msgid
.appended
: s2
->msgid
.ptr
);
242 result
= strcmp (s1
->domainname
, s2
->domainname
);
245 #ifdef HAVE_PER_THREAD_LOCALE
246 result
= strcmp (s1
->localename
, s2
->localename
);
249 /* We compare the category last (though this is the cheapest
250 operation) since it is hopefully always the same (namely
252 result
= s1
->category
- s2
->category
;
260 /* Name of the default domain used for gettext(3) prior any call to
261 textdomain(3). The default value for this is "messages". */
262 const char _nl_default_default_domain
[] attribute_hidden
= "messages";
264 /* Value used as the default domain for gettext(3). */
265 const char *_nl_current_default_domain attribute_hidden
266 = _nl_default_default_domain
;
268 /* Contains the default location of the message catalogs. */
271 extern const char _nl_default_dirname
[];
272 libc_hidden_proto (_nl_default_dirname
)
274 const char _nl_default_dirname
[] = LOCALEDIR
;
276 libc_hidden_data_def (_nl_default_dirname
)
279 /* List with bindings of specific domains created by bindtextdomain()
281 struct binding
*_nl_domain_bindings
;
283 /* Prototypes for local functions. */
284 static char *plural_lookup
PARAMS ((struct loaded_l10nfile
*domain
,
286 const char *translation
,
287 size_t translation_len
))
289 static const char *guess_category_value
PARAMS ((int category
,
290 const char *categoryname
))
293 # include "../locale/localeinfo.h"
294 # define category_to_name(category) \
295 _nl_category_names.str + _nl_category_name_idxs[category]
297 static const char *category_to_name
PARAMS ((int category
)) internal_function
;
301 /* For those loosing systems which don't have `alloca' we have to add
302 some additional code emulating it. */
304 /* Nothing has to be done. */
305 # define freea(p) /* nothing */
306 # define ADD_BLOCK(list, address) /* nothing */
307 # define FREE_BLOCKS(list) /* nothing */
312 struct block_list
*next
;
314 # define ADD_BLOCK(list, addr) \
316 struct block_list *newp = (struct block_list *) malloc (sizeof (*newp)); \
317 /* If we cannot get a free block we cannot add the new element to \
319 if (newp != NULL) { \
320 newp->address = (addr); \
321 newp->next = (list); \
325 # define FREE_BLOCKS(list) \
327 while (list != NULL) { \
328 struct block_list *old = list; \
330 free (old->address); \
335 # define alloca(size) (malloc (size))
336 # define freea(p) free (p)
337 #endif /* have alloca */
341 /* List of blocks allocated for translations. */
342 typedef struct transmem_list
344 struct transmem_list
*next
;
347 static struct transmem_list
*transmem_list
;
349 typedef unsigned char transmem_block_t
;
351 #if defined _LIBC || HAVE_ICONV
352 static const char *get_output_charset
PARAMS ((struct binding
*domainbinding
))
357 /* Names for the libintl functions are a problem. They must not clash
358 with existing names and they should follow ANSI C. But this source
359 code is also used in GNU C Library where the names have a __
360 prefix. So we have to make a difference here. */
362 # define DCIGETTEXT __dcigettext
364 # define DCIGETTEXT libintl_dcigettext
367 /* Lock variable to protect the global data in the gettext implementation. */
369 __libc_rwlock_define_initialized (, _nl_state_lock attribute_hidden
)
372 /* Checking whether the binaries runs SUID must be done and glibc provides
373 easier methods therefore we make a difference here. */
375 # define ENABLE_SECURE __libc_enable_secure
376 # define DETERMINE_SECURE
384 # ifndef HAVE_GETEUID
385 # define geteuid() getuid()
387 # ifndef HAVE_GETEGID
388 # define getegid() getgid()
390 static int enable_secure
;
391 # define ENABLE_SECURE (enable_secure == 1)
392 # define DETERMINE_SECURE \
393 if (enable_secure == 0) \
395 if (getuid () != geteuid () || getgid () != getegid ()) \
398 enable_secure = -1; \
402 /* Get the function to evaluate the plural expression. */
403 #include "plural-eval.c"
405 /* Look up MSGID in the DOMAINNAME message catalog for the current
406 CATEGORY locale and, if PLURAL is nonzero, search over string
407 depending on the plural form determined by N. */
409 DCIGETTEXT (domainname
, msgid1
, msgid2
, plural
, n
, category
)
410 const char *domainname
;
418 struct block_list
*block_list
= NULL
;
420 struct loaded_l10nfile
*domain
;
421 struct binding
*binding
;
422 const char *categoryname
;
423 const char *categoryvalue
;
424 char *dirname
, *xdomainname
;
429 #if defined HAVE_TSEARCH || defined _LIBC
430 struct known_translation_t search
;
431 struct known_translation_t
**foundp
= NULL
;
432 # ifdef HAVE_PER_THREAD_LOCALE
433 const char *localename
;
436 size_t domainname_len
;
438 /* If no real MSGID is given return NULL. */
443 if (category
< 0 || category
>= __LC_LAST
|| category
== LC_ALL
)
447 /* Use the Germanic plural rule. */
448 : n
== 1 ? (char *) msgid1
: (char *) msgid2
);
452 __libc_rwlock_define (extern, __libc_setlocale_lock attribute_hidden
)
453 __libc_rwlock_rdlock (__libc_setlocale_lock
);
456 __libc_rwlock_rdlock (_nl_state_lock
);
458 /* If DOMAINNAME is NULL, we are interested in the default domain. If
459 CATEGORY is not LC_MESSAGES this might not make much sense but the
460 definition left this undefined. */
461 if (domainname
== NULL
)
462 domainname
= _nl_current_default_domain
;
464 #if defined HAVE_TSEARCH || defined _LIBC
465 /* Try to find the translation among those which we found at
467 search
.domain
= NULL
;
468 search
.msgid
.ptr
= msgid1
;
469 search
.domainname
= domainname
;
470 search
.category
= category
;
471 # ifdef HAVE_PER_THREAD_LOCALE
473 localename
= strdupa (__current_locale_name (category
));
475 search
.localename
= localename
;
478 /* Since tfind/tsearch manage a balanced tree, concurrent tfind and
479 tsearch calls can be fatal. */
480 __libc_rwlock_define_initialized (static, tree_lock
);
481 __libc_rwlock_rdlock (tree_lock
);
483 foundp
= (struct known_translation_t
**) tfind (&search
, &root
, transcmp
);
485 __libc_rwlock_unlock (tree_lock
);
487 if (foundp
!= NULL
&& (*foundp
)->counter
== _nl_msg_cat_cntr
)
489 /* Now deal with plural. */
491 retval
= plural_lookup ((*foundp
)->domain
, n
, (*foundp
)->translation
,
492 (*foundp
)->translation_length
);
494 retval
= (char *) (*foundp
)->translation
;
497 __libc_rwlock_unlock (__libc_setlocale_lock
);
499 __libc_rwlock_unlock (_nl_state_lock
);
504 /* Preserve the `errno' value. */
507 /* See whether this is a SUID binary or not. */
510 /* First find matching binding. */
511 for (binding
= _nl_domain_bindings
; binding
!= NULL
; binding
= binding
->next
)
513 int compare
= strcmp (domainname
, binding
->domainname
);
519 /* It is not in the list. */
526 dirname
= (char *) _nl_default_dirname
;
527 else if (binding
->dirname
[0] == '/')
528 dirname
= binding
->dirname
;
531 /* We have a relative path. Make it absolute now. */
532 size_t dirname_len
= strlen (binding
->dirname
) + 1;
536 path_max
= (unsigned int) PATH_MAX
;
537 path_max
+= 2; /* The getcwd docs say to do this. */
541 dirname
= (char *) alloca (path_max
+ dirname_len
);
542 ADD_BLOCK (block_list
, dirname
);
545 ret
= getcwd (dirname
, path_max
);
546 if (ret
!= NULL
|| errno
!= ERANGE
)
549 path_max
+= path_max
/ 2;
550 path_max
+= PATH_INCR
;
556 stpcpy (stpcpy (strchr (dirname
, '\0'), "/"), binding
->dirname
);
559 /* Now determine the symbolic name of CATEGORY and its value. */
560 categoryname
= category_to_name (category
);
561 categoryvalue
= guess_category_value (category
, categoryname
);
563 domainname_len
= strlen (domainname
);
564 xdomainname
= (char *) alloca (strlen (categoryname
)
565 + domainname_len
+ 5);
566 ADD_BLOCK (block_list
, xdomainname
);
568 stpcpy (mempcpy (stpcpy (stpcpy (xdomainname
, categoryname
), "/"),
569 domainname
, domainname_len
),
572 /* Creating working area. */
573 single_locale
= (char *) alloca (strlen (categoryvalue
) + 1);
574 ADD_BLOCK (block_list
, single_locale
);
577 /* Search for the given string. This is a loop because we perhaps
578 got an ordered list of languages to consider for the translation. */
581 /* Make CATEGORYVALUE point to the next element of the list. */
582 while (categoryvalue
[0] != '\0' && categoryvalue
[0] == ':')
584 if (categoryvalue
[0] == '\0')
586 /* The whole contents of CATEGORYVALUE has been searched but
587 no valid entry has been found. We solve this situation
588 by implicitly appending a "C" entry, i.e. no translation
590 single_locale
[0] = 'C';
591 single_locale
[1] = '\0';
595 char *cp
= single_locale
;
596 while (categoryvalue
[0] != '\0' && categoryvalue
[0] != ':')
597 *cp
++ = *categoryvalue
++;
600 /* When this is a SUID binary we must not allow accessing files
601 outside the dedicated directories. */
602 if (ENABLE_SECURE
&& strchr (single_locale
, '/') != NULL
)
603 /* Ingore this entry. */
607 /* If the current locale value is C (or POSIX) we don't load a
608 domain. Return the MSGID. */
609 if (strcmp (single_locale
, "C") == 0
610 || strcmp (single_locale
, "POSIX") == 0)
613 FREE_BLOCKS (block_list
);
614 __libc_rwlock_unlock (__libc_setlocale_lock
);
615 __libc_rwlock_unlock (_nl_state_lock
);
616 __set_errno (saved_errno
);
619 /* Use the Germanic plural rule. */
620 : n
== 1 ? (char *) msgid1
: (char *) msgid2
);
624 /* Find structure describing the message catalog matching the
625 DOMAINNAME and CATEGORY. */
626 domain
= _nl_find_domain (dirname
, single_locale
, xdomainname
, binding
);
630 retval
= _nl_find_msg (domain
, binding
, msgid1
, 1, &retlen
);
636 for (cnt
= 0; domain
->successor
[cnt
] != NULL
; ++cnt
)
638 retval
= _nl_find_msg (domain
->successor
[cnt
], binding
,
643 domain
= domain
->successor
[cnt
];
649 /* Returning -1 means that some resource problem exists
650 (likely memory) and that the strings could not be
651 converted. Return the original strings. */
652 if (__builtin_expect (retval
== (char *) -1, 0))
657 /* Found the translation of MSGID1 in domain DOMAIN:
658 starting at RETVAL, RETLEN bytes. */
659 FREE_BLOCKS (block_list
);
660 #if defined HAVE_TSEARCH || defined _LIBC
663 /* Create a new entry and add it to the search tree. */
666 struct known_translation_t
*newp
;
668 msgid_len
= strlen (msgid1
) + 1;
669 size
= offsetof (struct known_translation_t
, msgid
)
670 + msgid_len
+ domainname_len
+ 1;
671 # ifdef HAVE_PER_THREAD_LOCALE
672 size
+= strlen (localename
) + 1;
674 newp
= (struct known_translation_t
*) malloc (size
);
677 char *new_domainname
;
678 # ifdef HAVE_PER_THREAD_LOCALE
679 char *new_localename
;
683 mempcpy (newp
->msgid
.appended
, msgid1
, msgid_len
);
684 memcpy (new_domainname
, domainname
, domainname_len
+ 1);
685 # ifdef HAVE_PER_THREAD_LOCALE
686 new_localename
= new_domainname
+ domainname_len
+ 1;
687 strcpy (new_localename
, localename
);
689 newp
->domainname
= new_domainname
;
690 newp
->category
= category
;
691 # ifdef HAVE_PER_THREAD_LOCALE
692 newp
->localename
= new_localename
;
694 newp
->counter
= _nl_msg_cat_cntr
;
695 newp
->domain
= domain
;
696 newp
->translation
= retval
;
697 newp
->translation_length
= retlen
;
699 __libc_rwlock_wrlock (tree_lock
);
701 /* Insert the entry in the search tree. */
702 foundp
= (struct known_translation_t
**)
703 tsearch (newp
, &root
, transcmp
);
705 __libc_rwlock_unlock (tree_lock
);
708 || __builtin_expect (*foundp
!= newp
, 0))
709 /* The insert failed. */
715 /* We can update the existing entry. */
716 (*foundp
)->counter
= _nl_msg_cat_cntr
;
717 (*foundp
)->domain
= domain
;
718 (*foundp
)->translation
= retval
;
719 (*foundp
)->translation_length
= retlen
;
722 __set_errno (saved_errno
);
724 /* Now deal with plural. */
726 retval
= plural_lookup (domain
, n
, retval
, retlen
);
728 __libc_rwlock_unlock (__libc_setlocale_lock
);
729 __libc_rwlock_unlock (_nl_state_lock
);
740 _nl_find_msg (domain_file
, domainbinding
, msgid
, convert
, lengthp
)
741 struct loaded_l10nfile
*domain_file
;
742 struct binding
*domainbinding
;
747 struct loaded_domain
*domain
;
753 if (domain_file
->decided
<= 0)
754 _nl_load_domain (domain_file
, domainbinding
);
756 if (domain_file
->data
== NULL
)
759 domain
= (struct loaded_domain
*) domain_file
->data
;
761 nstrings
= domain
->nstrings
;
763 /* Locate the MSGID and its translation. */
764 if (domain
->hash_tab
!= NULL
)
766 /* Use the hashing table. */
767 nls_uint32 len
= strlen (msgid
);
768 nls_uint32 hash_val
= __hash_string (msgid
);
769 nls_uint32 idx
= hash_val
% domain
->hash_size
;
770 nls_uint32 incr
= 1 + (hash_val
% (domain
->hash_size
- 2));
775 W (domain
->must_swap_hash_tab
, domain
->hash_tab
[idx
]);
778 /* Hash table entry is empty. */
783 /* Compare msgid with the original string at index nstr.
784 We compare the lengths with >=, not ==, because plural entries
785 are represented by strings with an embedded NUL. */
787 ? W (domain
->must_swap
, domain
->orig_tab
[nstr
].length
) >= len
789 domain
->data
+ W (domain
->must_swap
,
790 domain
->orig_tab
[nstr
].offset
))
792 : domain
->orig_sysdep_tab
[nstr
- nstrings
].length
> len
794 domain
->orig_sysdep_tab
[nstr
- nstrings
].pointer
)
801 if (idx
>= domain
->hash_size
- incr
)
802 idx
-= domain
->hash_size
- incr
;
810 /* Try the default method: binary search in the sorted array of
820 act
= (bottom
+ top
) / 2;
821 cmp_val
= strcmp (msgid
, (domain
->data
822 + W (domain
->must_swap
,
823 domain
->orig_tab
[act
].offset
)));
826 else if (cmp_val
> 0)
831 /* No translation was found. */
836 /* The translation was found at index ACT. If we have to convert the
837 string to use a different character set, this is the time. */
841 (domain
->data
+ W (domain
->must_swap
, domain
->trans_tab
[act
].offset
));
842 resultlen
= W (domain
->must_swap
, domain
->trans_tab
[act
].length
) + 1;
846 result
= (char *) domain
->trans_sysdep_tab
[act
- nstrings
].pointer
;
847 resultlen
= domain
->trans_sysdep_tab
[act
- nstrings
].length
;
850 #if defined _LIBC || HAVE_ICONV
853 /* We are supposed to do a conversion. */
854 const char *encoding
= get_output_charset (domainbinding
);
856 /* Protect against reallocation of the table. */
857 __libc_rwlock_rdlock (domain
->conversions_lock
);
859 /* Search whether a table with converted translations for this
860 encoding has already been allocated. */
861 size_t nconversions
= domain
->nconversions
;
862 struct converted_domain
*convd
= NULL
;
865 for (i
= nconversions
; i
> 0; )
868 if (strcmp (domain
->conversions
[i
].encoding
, encoding
) == 0)
870 convd
= &domain
->conversions
[i
];
875 __libc_rwlock_unlock (domain
->conversions_lock
);
879 /* We have to allocate a new conversions table. */
880 __libc_rwlock_wrlock (domain
->conversions_lock
);
881 nconversions
= domain
->nconversions
;
883 /* Maybe in the meantime somebody added the translation.
885 for (i
= nconversions
; i
> 0; )
888 if (strcmp (domain
->conversions
[i
].encoding
, encoding
) == 0)
890 convd
= &domain
->conversions
[i
];
895 /* Allocate a table for the converted translations for this
897 struct converted_domain
*new_conversions
=
898 (struct converted_domain
*)
899 realloc (domain
->conversions
,
900 (nconversions
+ 1) * sizeof (struct converted_domain
));
902 if (__builtin_expect (new_conversions
== NULL
, 0))
904 /* Nothing we can do, no more memory. We cannot use the
905 translation because it might be encoded incorrectly. */
907 __libc_rwlock_unlock (domain
->conversions_lock
);
911 domain
->conversions
= new_conversions
;
913 /* Copy the 'encoding' string to permanent storage. */
914 encoding
= strdup (encoding
);
915 if (__builtin_expect (encoding
== NULL
, 0))
916 /* Nothing we can do, no more memory. We cannot use the
917 translation because it might be encoded incorrectly. */
920 convd
= &new_conversions
[nconversions
];
921 convd
->encoding
= encoding
;
923 /* Find out about the character set the file is encoded with.
924 This can be found (in textual form) in the entry "". If this
925 entry does not exist or if this does not contain the 'charset='
926 information, we will assume the charset matches the one the
927 current locale and we don't have to perform any conversion. */
929 convd
->conv
= (__gconv_t
) -1;
932 convd
->conv
= (iconv_t
) -1;
939 /* Get the header entry. This is a recursion, but it doesn't
940 reallocate domain->conversions because we pass convert = 0. */
942 _nl_find_msg (domain_file
, domainbinding
, "", 0, &nullentrylen
);
944 if (nullentry
!= NULL
)
946 const char *charsetstr
;
948 charsetstr
= strstr (nullentry
, "charset=");
949 if (charsetstr
!= NULL
)
953 const char *outcharset
;
955 charsetstr
+= strlen ("charset=");
956 len
= strcspn (charsetstr
, " \t\n");
958 charset
= (char *) alloca (len
+ 1);
959 # if defined _LIBC || HAVE_MEMPCPY
960 *((char *) mempcpy (charset
, charsetstr
, len
)) = '\0';
962 memcpy (charset
, charsetstr
, len
);
966 outcharset
= encoding
;
969 /* We always want to use transliteration. */
970 outcharset
= norm_add_slashes (outcharset
, "TRANSLIT");
971 charset
= norm_add_slashes (charset
, "");
972 int r
= __gconv_open (outcharset
, charset
, &convd
->conv
,
974 if (__builtin_expect (r
!= __GCONV_OK
, 0))
976 /* If the output encoding is the same there is
977 nothing to do. Otherwise do not use the
978 translation at all. */
979 if (__builtin_expect (r
!= __GCONV_NULCONV
, 1))
981 __libc_rwlock_unlock (domain
->conversions_lock
);
982 free ((char *) encoding
);
986 convd
->conv
= (__gconv_t
) -1;
990 /* When using GNU libc >= 2.2 or GNU libiconv >= 1.5,
991 we want to use transliteration. */
992 # if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2 \
993 || _LIBICONV_VERSION >= 0x0105
994 if (strchr (outcharset
, '/') == NULL
)
998 len
= strlen (outcharset
);
999 tmp
= (char *) alloca (len
+ 10 + 1);
1000 memcpy (tmp
, outcharset
, len
);
1001 memcpy (tmp
+ len
, "//TRANSLIT", 10 + 1);
1004 convd
->conv
= iconv_open (outcharset
, charset
);
1010 convd
->conv
= iconv_open (outcharset
, charset
);
1018 convd
->conv_tab
= NULL
;
1019 /* Here domain->conversions is still == new_conversions. */
1020 domain
->nconversions
++;
1023 __libc_rwlock_unlock (domain
->conversions_lock
);
1028 convd
->conv
!= (__gconv_t
) -1
1031 convd
->conv
!= (iconv_t
) -1
1036 __libc_lock_define_initialized (static, lock
)
1037 /* We are supposed to do a conversion. First allocate an
1038 appropriate table with the same structure as the table
1039 of translations in the file, where we can put the pointers
1040 to the converted strings in.
1041 There is a slight complication with plural entries. They
1042 are represented by consecutive NUL terminated strings. We
1043 handle this case by converting RESULTLEN bytes, including
1046 if (__builtin_expect (convd
->conv_tab
== NULL
, 0))
1048 __libc_lock_lock (lock
);
1049 if (convd
->conv_tab
== NULL
)
1052 = calloc (nstrings
+ domain
->n_sysdep_strings
,
1054 if (convd
->conv_tab
!= NULL
)
1055 goto not_translated_yet
;
1056 /* Mark that we didn't succeed allocating a table. */
1057 convd
->conv_tab
= (char **) -1;
1059 __libc_lock_unlock (lock
);
1062 if (__builtin_expect (convd
->conv_tab
== (char **) -1, 0))
1063 /* Nothing we can do, no more memory. We cannot use the
1064 translation because it might be encoded incorrectly. */
1067 if (convd
->conv_tab
[act
] == NULL
)
1069 __libc_lock_lock (lock
);
1070 not_translated_yet
:;
1072 /* We haven't used this string so far, so it is not
1073 translated yet. Do this now. */
1074 /* We use a bit more efficient memory handling.
1075 We allocate always larger blocks which get used over
1076 time. This is faster than many small allocations. */
1077 # define INITIAL_BLOCK_SIZE 4080
1078 static unsigned char *freemem
;
1079 static size_t freemem_size
;
1081 const unsigned char *inbuf
;
1082 unsigned char *outbuf
;
1085 transmem_block_t
*transmem_list
= NULL
;
1088 inbuf
= (const unsigned char *) result
;
1089 outbuf
= freemem
+ sizeof (size_t);
1094 transmem_block_t
*newmem
;
1096 size_t non_reversible
;
1099 if (freemem_size
< sizeof (size_t))
1100 goto resize_freemem
;
1102 res
= __gconv (convd
->conv
,
1103 &inbuf
, inbuf
+ resultlen
,
1105 outbuf
+ freemem_size
- sizeof (size_t),
1108 if (res
== __GCONV_OK
|| res
== __GCONV_EMPTY_INPUT
)
1111 if (res
!= __GCONV_FULL_OUTPUT
)
1113 /* We should not use the translation at all, it
1114 is incorrectly encoded. */
1115 __libc_lock_unlock (lock
);
1119 inbuf
= (const unsigned char *) result
;
1122 const char *inptr
= (const char *) inbuf
;
1123 size_t inleft
= resultlen
;
1124 char *outptr
= (char *) outbuf
;
1127 if (freemem_size
< sizeof (size_t))
1128 goto resize_freemem
;
1130 outleft
= freemem_size
- sizeof (size_t);
1131 if (iconv (convd
->conv
,
1132 (ICONV_CONST
char **) &inptr
, &inleft
,
1136 outbuf
= (unsigned char *) outptr
;
1141 __libc_lock_unlock (lock
);
1148 /* We must allocate a new buffer or resize the old one. */
1149 if (malloc_count
> 0)
1152 freemem_size
= malloc_count
* INITIAL_BLOCK_SIZE
;
1153 newmem
= (transmem_block_t
*) realloc (transmem_list
,
1157 transmem_list
= newmem
;
1160 struct transmem_list
*old
= transmem_list
;
1162 transmem_list
= transmem_list
->next
;
1170 freemem_size
= INITIAL_BLOCK_SIZE
;
1171 newmem
= (transmem_block_t
*) malloc (freemem_size
);
1173 /* Add the block to the list of blocks we have to free
1175 newmem
->next
= transmem_list
;
1176 transmem_list
= newmem
;
1179 if (__builtin_expect (newmem
== NULL
, 0))
1183 __libc_lock_unlock (lock
);
1188 freemem
= (unsigned char *) newmem
->data
;
1189 freemem_size
-= offsetof (struct transmem_list
, data
);
1191 transmem_list
= newmem
;
1195 outbuf
= freemem
+ sizeof (size_t);
1198 /* We have now in our buffer a converted string. Put this
1199 into the table of conversions. */
1200 *(size_t *) freemem
= outbuf
- freemem
- sizeof (size_t);
1201 convd
->conv_tab
[act
] = (char *) freemem
;
1202 /* Shrink freemem, but keep it aligned. */
1203 freemem_size
-= outbuf
- freemem
;
1205 freemem
+= freemem_size
& (alignof (size_t) - 1);
1206 freemem_size
= freemem_size
& ~ (alignof (size_t) - 1);
1208 __libc_lock_unlock (lock
);
1211 /* Now convd->conv_tab[act] contains the translation of all
1212 the plural variants. */
1213 result
= convd
->conv_tab
[act
] + sizeof (size_t);
1214 resultlen
= *(size_t *) convd
->conv_tab
[act
];
1218 /* The result string is converted. */
1220 #endif /* _LIBC || HAVE_ICONV */
1222 *lengthp
= resultlen
;
1227 /* Look up a plural variant. */
1230 plural_lookup (domain
, n
, translation
, translation_len
)
1231 struct loaded_l10nfile
*domain
;
1232 unsigned long int n
;
1233 const char *translation
;
1234 size_t translation_len
;
1236 struct loaded_domain
*domaindata
= (struct loaded_domain
*) domain
->data
;
1237 unsigned long int index
;
1240 index
= plural_eval (domaindata
->plural
, n
);
1241 if (index
>= domaindata
->nplurals
)
1242 /* This should never happen. It means the plural expression and the
1243 given maximum value do not match. */
1246 /* Skip INDEX strings at TRANSLATION. */
1251 p
= __rawmemchr (p
, '\0');
1253 p
= strchr (p
, '\0');
1255 /* And skip over the NUL byte. */
1258 if (p
>= translation
+ translation_len
)
1259 /* This should never happen. It means the plural expression
1260 evaluated to a value larger than the number of variants
1261 available for MSGID1. */
1262 return (char *) translation
;
1268 /* Return string representation of locale CATEGORY. */
1271 category_to_name (category
)
1280 retval
= "LC_COLLATE";
1285 retval
= "LC_CTYPE";
1290 retval
= "LC_MONETARY";
1295 retval
= "LC_NUMERIC";
1305 retval
= "LC_MESSAGES";
1310 retval
= "LC_RESPONSE";
1315 /* This might not make sense but is perhaps better than any other
1321 /* If you have a better idea for a default value let me know. */
1329 /* Guess value of current locale from value of the environment variables. */
1332 guess_category_value (category
, categoryname
)
1334 const char *categoryname
;
1336 const char *language
;
1339 /* The highest priority value is the `LANGUAGE' environment
1340 variable. But we don't use the value if the currently selected
1341 locale is the C locale. This is a GNU extension. */
1342 language
= getenv ("LANGUAGE");
1343 if (language
!= NULL
&& language
[0] == '\0')
1346 /* We have to proceed with the POSIX methods of looking to `LC_ALL',
1347 `LC_xxx', and `LANG'. On some systems this can be done by the
1348 `setlocale' function itself. */
1350 retval
= __current_locale_name (category
);
1352 retval
= _nl_locale_name (category
, categoryname
);
1355 return language
!= NULL
&& strcmp (retval
, "C") != 0 ? language
: retval
;
1358 #if defined _LIBC || HAVE_ICONV
1359 /* Returns the output charset. */
1362 get_output_charset (domainbinding
)
1363 struct binding
*domainbinding
;
1365 /* The output charset should normally be determined by the locale. But
1366 sometimes the locale is not used or not correctly set up, so we provide
1367 a possibility for the user to override this: the OUTPUT_CHARSET
1368 environment variable. Moreover, the value specified through
1369 bind_textdomain_codeset overrides both. */
1370 if (domainbinding
!= NULL
&& domainbinding
->codeset
!= NULL
)
1371 return domainbinding
->codeset
;
1374 /* For speed reasons, we look at the value of OUTPUT_CHARSET only
1375 once. This is a user variable that is not supposed to change
1376 during a program run. */
1377 static char *output_charset_cache
;
1378 static int output_charset_cached
;
1380 if (!output_charset_cached
)
1382 const char *value
= getenv ("OUTPUT_CHARSET");
1384 if (value
!= NULL
&& value
[0] != '\0')
1386 size_t len
= strlen (value
) + 1;
1387 char *value_copy
= (char *) malloc (len
);
1389 if (value_copy
!= NULL
)
1390 memcpy (value_copy
, value
, len
);
1391 output_charset_cache
= value_copy
;
1393 output_charset_cached
= 1;
1396 if (output_charset_cache
!= NULL
)
1397 return output_charset_cache
;
1401 return _NL_CURRENT (LC_CTYPE
, CODESET
);
1404 extern const char *locale_charset
PARAMS ((void));
1405 return locale_charset ();
1413 /* @@ begin of epilog @@ */
1415 /* We don't want libintl.a to depend on any other library. So we
1416 avoid the non-standard function stpcpy. In GNU C Library this
1417 function is available, though. Also allow the symbol HAVE_STPCPY
1419 #if !_LIBC && !HAVE_STPCPY
1425 while ((*dest
++ = *src
++) != '\0')
1431 #if !_LIBC && !HAVE_MEMPCPY
1433 mempcpy (dest
, src
, n
)
1438 return (void *) ((char *) memcpy (dest
, src
, n
) + n
);
1444 /* If we want to free all resources we have to do some work at
1446 libc_freeres_fn (free_mem
)
1450 while (_nl_domain_bindings
!= NULL
)
1452 struct binding
*oldp
= _nl_domain_bindings
;
1453 _nl_domain_bindings
= _nl_domain_bindings
->next
;
1454 if (oldp
->dirname
!= _nl_default_dirname
)
1455 /* Yes, this is a pointer comparison. */
1456 free (oldp
->dirname
);
1457 free (oldp
->codeset
);
1461 if (_nl_current_default_domain
!= _nl_default_default_domain
)
1462 /* Yes, again a pointer comparison. */
1463 free ((char *) _nl_current_default_domain
);
1465 /* Remove the search tree with the known translations. */
1466 __tdestroy (root
, free
);
1469 while (transmem_list
!= NULL
)
1471 old
= transmem_list
;
1472 transmem_list
= transmem_list
->next
;