1 /* Implementation of the internal dcigettext function.
2 Copyright (C) 1995-2005, 2006, 2007 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, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
20 /* Tell glibc's <string.h> to provide a prototype for mempcpy().
21 This must come before <config.h> because <config.h> may include
22 <features.h>, and once <features.h> has been included, it's too late. */
24 # define _GNU_SOURCE 1
31 #include <sys/types.h>
34 # define alloca __builtin_alloca
35 # define HAVE_ALLOCA 1
37 # if defined HAVE_ALLOCA_H || defined _LIBC
55 # define __set_errno(val) errno = (val)
62 #if defined HAVE_UNISTD_H || defined _LIBC
68 #if defined HAVE_SYS_PARAM_H || defined _LIBC
69 # include <sys/param.h>
73 #include "plural-exp.h"
77 # include "libgnuintl.h"
79 #include "hash-string.h"
81 /* Thread safetyness. */
83 # include <bits/libc-lock.h>
85 /* Provide dummy implementation if this is outside glibc. */
86 # define __libc_lock_define_initialized(CLASS, NAME)
87 # define __libc_lock_lock(NAME)
88 # define __libc_lock_unlock(NAME)
89 # define __libc_rwlock_define_initialized(CLASS, NAME)
90 # define __libc_rwlock_rdlock(NAME)
91 # define __libc_rwlock_unlock(NAME)
94 /* Alignment of types. */
95 #if defined __GNUC__ && __GNUC__ >= 2
96 # define alignof(TYPE) __alignof__ (TYPE)
98 # define alignof(TYPE) \
99 ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
102 /* The internal variables in the standalone libintl.a must have different
103 names than the internal variables in GNU libc, otherwise programs
104 using libintl.a cannot be linked statically. */
106 # define _nl_default_default_domain libintl_nl_default_default_domain
107 # define _nl_current_default_domain libintl_nl_current_default_domain
108 # define _nl_default_dirname libintl_nl_default_dirname
109 # define _nl_domain_bindings libintl_nl_domain_bindings
112 /* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>. */
114 # define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
117 /* @@ end of prolog @@ */
120 /* Rename the non ANSI C functions. This is required by the standard
121 because some ANSI C functions will require linking with this object
122 file and the name space must not be polluted. */
123 # define getcwd __getcwd
125 # define stpcpy __stpcpy
127 # define tfind __tfind
129 # if !defined HAVE_GETCWD
131 # define getcwd(buf, max) getwd (buf)
136 static char *stpcpy
PARAMS ((char *dest
, const char *src
));
138 # ifndef HAVE_MEMPCPY
139 static void *mempcpy
PARAMS ((void *dest
, const void *src
, size_t n
));
143 /* Amount to increase buffer size by in each try. */
146 /* The following is from pathmax.h. */
147 /* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define
148 PATH_MAX but might cause redefinition warnings when sys/param.h is
149 later included (as on MORE/BSD 4.3). */
150 #if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__)
154 #ifndef _POSIX_PATH_MAX
155 # define _POSIX_PATH_MAX 255
158 #if !defined PATH_MAX && defined _PC_PATH_MAX
159 # define PATH_MAX (pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : pathconf ("/", _PC_PATH_MAX))
162 /* Don't include sys/param.h if it already has been. */
163 #if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN
164 # include <sys/param.h>
167 #if !defined PATH_MAX && defined MAXPATHLEN
168 # define PATH_MAX MAXPATHLEN
172 # define PATH_MAX _POSIX_PATH_MAX
175 /* Whether to support different locales in different threads. */
176 #if defined _LIBC || HAVE_NL_LOCALE_NAME
177 # define HAVE_PER_THREAD_LOCALE
180 /* This is the type used for the search tree where known translations
182 struct known_translation_t
184 /* Domain in which to search. */
185 const char *domainname
;
190 #ifdef HAVE_PER_THREAD_LOCALE
191 /* Name of the relevant locale category, or "" for the global locale. */
192 const char *localename
;
195 /* State of the catalog counter at the point the string was found. */
198 /* Catalog where the string was found. */
199 struct loaded_l10nfile
*domain
;
201 /* And finally the translation. */
202 const char *translation
;
203 size_t translation_length
;
205 /* Pointer to the string in question. */
208 char appended
[ZERO
]; /* used if domain != NULL */
209 const char *ptr
; /* used if domain == NULL */
214 /* Root of the search tree with known translations. We can use this
215 only if the system provides the `tsearch' function family. */
216 #if defined HAVE_TSEARCH || defined _LIBC
222 # define tsearch __tsearch
225 /* Function to compare two entries in the table of known translations. */
226 static int transcmp
PARAMS ((const void *p1
, const void *p2
));
232 const struct known_translation_t
*s1
;
233 const struct known_translation_t
*s2
;
236 s1
= (const struct known_translation_t
*) p1
;
237 s2
= (const struct known_translation_t
*) p2
;
239 result
= strcmp (s1
->domain
!= NULL
? s1
->msgid
.appended
: s1
->msgid
.ptr
,
240 s2
->domain
!= NULL
? s2
->msgid
.appended
: s2
->msgid
.ptr
);
243 result
= strcmp (s1
->domainname
, s2
->domainname
);
246 #ifdef HAVE_PER_THREAD_LOCALE
247 result
= strcmp (s1
->localename
, s2
->localename
);
250 /* We compare the category last (though this is the cheapest
251 operation) since it is hopefully always the same (namely
253 result
= s1
->category
- s2
->category
;
261 /* Name of the default domain used for gettext(3) prior any call to
262 textdomain(3). The default value for this is "messages". */
263 const char _nl_default_default_domain
[] attribute_hidden
= "messages";
265 /* Value used as the default domain for gettext(3). */
266 const char *_nl_current_default_domain attribute_hidden
267 = _nl_default_default_domain
;
269 /* Contains the default location of the message catalogs. */
272 extern const char _nl_default_dirname
[];
273 libc_hidden_proto (_nl_default_dirname
)
275 const char _nl_default_dirname
[] = LOCALEDIR
;
277 libc_hidden_data_def (_nl_default_dirname
)
280 /* List with bindings of specific domains created by bindtextdomain()
282 struct binding
*_nl_domain_bindings
;
284 /* Prototypes for local functions. */
285 static char *plural_lookup
PARAMS ((struct loaded_l10nfile
*domain
,
287 const char *translation
,
288 size_t translation_len
))
290 static const char *guess_category_value
PARAMS ((int category
,
291 const char *categoryname
))
294 # include "../locale/localeinfo.h"
295 # define category_to_name(category) \
296 _nl_category_names.str + _nl_category_name_idxs[category]
298 static const char *category_to_name
PARAMS ((int category
)) internal_function
;
302 /* For those loosing systems which don't have `alloca' we have to add
303 some additional code emulating it. */
305 /* Nothing has to be done. */
306 # define freea(p) /* nothing */
307 # define ADD_BLOCK(list, address) /* nothing */
308 # define FREE_BLOCKS(list) /* nothing */
313 struct block_list
*next
;
315 # define ADD_BLOCK(list, addr) \
317 struct block_list *newp = (struct block_list *) malloc (sizeof (*newp)); \
318 /* If we cannot get a free block we cannot add the new element to \
320 if (newp != NULL) { \
321 newp->address = (addr); \
322 newp->next = (list); \
326 # define FREE_BLOCKS(list) \
328 while (list != NULL) { \
329 struct block_list *old = list; \
331 free (old->address); \
336 # define alloca(size) (malloc (size))
337 # define freea(p) free (p)
338 #endif /* have alloca */
342 /* List of blocks allocated for translations. */
343 typedef struct transmem_list
345 struct transmem_list
*next
;
348 static struct transmem_list
*transmem_list
;
350 typedef unsigned char transmem_block_t
;
352 #if defined _LIBC || HAVE_ICONV
353 static const char *get_output_charset
PARAMS ((struct binding
*domainbinding
))
358 /* Names for the libintl functions are a problem. They must not clash
359 with existing names and they should follow ANSI C. But this source
360 code is also used in GNU C Library where the names have a __
361 prefix. So we have to make a difference here. */
363 # define DCIGETTEXT __dcigettext
365 # define DCIGETTEXT libintl_dcigettext
368 /* Lock variable to protect the global data in the gettext implementation. */
370 __libc_rwlock_define_initialized (, _nl_state_lock attribute_hidden
)
373 /* Checking whether the binaries runs SUID must be done and glibc provides
374 easier methods therefore we make a difference here. */
376 # define ENABLE_SECURE __libc_enable_secure
377 # define DETERMINE_SECURE
385 # ifndef HAVE_GETEUID
386 # define geteuid() getuid()
388 # ifndef HAVE_GETEGID
389 # define getegid() getgid()
391 static int enable_secure
;
392 # define ENABLE_SECURE (enable_secure == 1)
393 # define DETERMINE_SECURE \
394 if (enable_secure == 0) \
396 if (getuid () != geteuid () || getgid () != getegid ()) \
399 enable_secure = -1; \
403 /* Get the function to evaluate the plural expression. */
404 #include "plural-eval.c"
406 /* Look up MSGID in the DOMAINNAME message catalog for the current
407 CATEGORY locale and, if PLURAL is nonzero, search over string
408 depending on the plural form determined by N. */
410 DCIGETTEXT (domainname
, msgid1
, msgid2
, plural
, n
, category
)
411 const char *domainname
;
419 struct block_list
*block_list
= NULL
;
421 struct loaded_l10nfile
*domain
;
422 struct binding
*binding
;
423 const char *categoryname
;
424 const char *categoryvalue
;
425 char *dirname
, *xdomainname
;
430 #if defined HAVE_TSEARCH || defined _LIBC
431 struct known_translation_t search
;
432 struct known_translation_t
**foundp
= NULL
;
433 # ifdef HAVE_PER_THREAD_LOCALE
434 const char *localename
;
437 size_t domainname_len
;
439 /* If no real MSGID is given return NULL. */
444 if (category
< 0 || category
>= __LC_LAST
|| category
== LC_ALL
)
448 /* Use the Germanic plural rule. */
449 : n
== 1 ? (char *) msgid1
: (char *) msgid2
);
452 __libc_rwlock_rdlock (_nl_state_lock
);
454 /* If DOMAINNAME is NULL, we are interested in the default domain. If
455 CATEGORY is not LC_MESSAGES this might not make much sense but the
456 definition left this undefined. */
457 if (domainname
== NULL
)
458 domainname
= _nl_current_default_domain
;
460 #if defined HAVE_TSEARCH || defined _LIBC
461 /* Try to find the translation among those which we found at
463 search
.domain
= NULL
;
464 search
.msgid
.ptr
= msgid1
;
465 search
.domainname
= domainname
;
466 search
.category
= category
;
467 # ifdef HAVE_PER_THREAD_LOCALE
469 localename
= __current_locale_name (category
);
471 search
.localename
= localename
;
474 /* Since tfind/tsearch manage a balanced tree, concurrent tfind and
475 tsearch calls can be fatal. */
476 __libc_rwlock_define_initialized (static, tree_lock
);
477 __libc_rwlock_rdlock (tree_lock
);
479 foundp
= (struct known_translation_t
**) tfind (&search
, &root
, transcmp
);
481 __libc_rwlock_unlock (tree_lock
);
483 if (foundp
!= NULL
&& (*foundp
)->counter
== _nl_msg_cat_cntr
)
485 /* Now deal with plural. */
487 retval
= plural_lookup ((*foundp
)->domain
, n
, (*foundp
)->translation
,
488 (*foundp
)->translation_length
);
490 retval
= (char *) (*foundp
)->translation
;
492 __libc_rwlock_unlock (_nl_state_lock
);
497 /* Preserve the `errno' value. */
500 /* See whether this is a SUID binary or not. */
503 /* First find matching binding. */
504 for (binding
= _nl_domain_bindings
; binding
!= NULL
; binding
= binding
->next
)
506 int compare
= strcmp (domainname
, binding
->domainname
);
512 /* It is not in the list. */
519 dirname
= (char *) _nl_default_dirname
;
520 else if (binding
->dirname
[0] == '/')
521 dirname
= binding
->dirname
;
524 /* We have a relative path. Make it absolute now. */
525 size_t dirname_len
= strlen (binding
->dirname
) + 1;
529 path_max
= (unsigned int) PATH_MAX
;
530 path_max
+= 2; /* The getcwd docs say to do this. */
534 dirname
= (char *) alloca (path_max
+ dirname_len
);
535 ADD_BLOCK (block_list
, dirname
);
538 ret
= getcwd (dirname
, path_max
);
539 if (ret
!= NULL
|| errno
!= ERANGE
)
542 path_max
+= path_max
/ 2;
543 path_max
+= PATH_INCR
;
548 /* We cannot get the current working directory. Don't signal an
549 error but simply return the default string. */
550 FREE_BLOCKS (block_list
);
551 __libc_rwlock_unlock (_nl_state_lock
);
552 __set_errno (saved_errno
);
555 /* Use the Germanic plural rule. */
556 : n
== 1 ? (char *) msgid1
: (char *) msgid2
);
559 stpcpy (stpcpy (strchr (dirname
, '\0'), "/"), binding
->dirname
);
562 /* Now determine the symbolic name of CATEGORY and its value. */
563 categoryname
= category_to_name (category
);
564 categoryvalue
= guess_category_value (category
, categoryname
);
566 domainname_len
= strlen (domainname
);
567 xdomainname
= (char *) alloca (strlen (categoryname
)
568 + domainname_len
+ 5);
569 ADD_BLOCK (block_list
, xdomainname
);
571 stpcpy (mempcpy (stpcpy (stpcpy (xdomainname
, categoryname
), "/"),
572 domainname
, domainname_len
),
575 /* Creating working area. */
576 single_locale
= (char *) alloca (strlen (categoryvalue
) + 1);
577 ADD_BLOCK (block_list
, single_locale
);
580 /* Search for the given string. This is a loop because we perhaps
581 got an ordered list of languages to consider for the translation. */
584 /* Make CATEGORYVALUE point to the next element of the list. */
585 while (categoryvalue
[0] != '\0' && categoryvalue
[0] == ':')
587 if (categoryvalue
[0] == '\0')
589 /* The whole contents of CATEGORYVALUE has been searched but
590 no valid entry has been found. We solve this situation
591 by implicitly appending a "C" entry, i.e. no translation
593 single_locale
[0] = 'C';
594 single_locale
[1] = '\0';
598 char *cp
= single_locale
;
599 while (categoryvalue
[0] != '\0' && categoryvalue
[0] != ':')
600 *cp
++ = *categoryvalue
++;
603 /* When this is a SUID binary we must not allow accessing files
604 outside the dedicated directories. */
605 if (ENABLE_SECURE
&& strchr (single_locale
, '/') != NULL
)
606 /* Ingore this entry. */
610 /* If the current locale value is C (or POSIX) we don't load a
611 domain. Return the MSGID. */
612 if (strcmp (single_locale
, "C") == 0
613 || strcmp (single_locale
, "POSIX") == 0)
616 FREE_BLOCKS (block_list
);
617 __libc_rwlock_unlock (_nl_state_lock
);
618 __set_errno (saved_errno
);
621 /* Use the Germanic plural rule. */
622 : n
== 1 ? (char *) msgid1
: (char *) msgid2
);
626 /* Find structure describing the message catalog matching the
627 DOMAINNAME and CATEGORY. */
628 domain
= _nl_find_domain (dirname
, single_locale
, xdomainname
, binding
);
632 retval
= _nl_find_msg (domain
, binding
, msgid1
, 1, &retlen
);
638 for (cnt
= 0; domain
->successor
[cnt
] != NULL
; ++cnt
)
640 retval
= _nl_find_msg (domain
->successor
[cnt
], binding
,
645 domain
= domain
->successor
[cnt
];
651 /* Returning -1 means that some resource problem exists
652 (likely memory) and that the strings could not be
653 converted. Return the original strings. */
654 if (__builtin_expect (retval
== (char *) -1, 0))
659 /* Found the translation of MSGID1 in domain DOMAIN:
660 starting at RETVAL, RETLEN bytes. */
661 FREE_BLOCKS (block_list
);
662 #if defined HAVE_TSEARCH || defined _LIBC
665 /* Create a new entry and add it to the search tree. */
668 struct known_translation_t
*newp
;
670 msgid_len
= strlen (msgid1
) + 1;
671 size
= offsetof (struct known_translation_t
, msgid
)
672 + msgid_len
+ domainname_len
+ 1;
673 # ifdef HAVE_PER_THREAD_LOCALE
674 size
+= strlen (localename
) + 1;
676 newp
= (struct known_translation_t
*) malloc (size
);
679 char *new_domainname
;
680 # ifdef HAVE_PER_THREAD_LOCALE
681 char *new_localename
;
685 mempcpy (newp
->msgid
.appended
, msgid1
, msgid_len
);
686 memcpy (new_domainname
, domainname
, domainname_len
+ 1);
687 # ifdef HAVE_PER_THREAD_LOCALE
688 new_localename
= new_domainname
+ domainname_len
+ 1;
689 strcpy (new_localename
, localename
);
691 newp
->domainname
= new_domainname
;
692 newp
->category
= category
;
693 # ifdef HAVE_PER_THREAD_LOCALE
694 newp
->localename
= new_localename
;
696 newp
->counter
= _nl_msg_cat_cntr
;
697 newp
->domain
= domain
;
698 newp
->translation
= retval
;
699 newp
->translation_length
= retlen
;
701 __libc_rwlock_wrlock (tree_lock
);
703 /* Insert the entry in the search tree. */
704 foundp
= (struct known_translation_t
**)
705 tsearch (newp
, &root
, transcmp
);
707 __libc_rwlock_unlock (tree_lock
);
710 || __builtin_expect (*foundp
!= newp
, 0))
711 /* The insert failed. */
717 /* We can update the existing entry. */
718 (*foundp
)->counter
= _nl_msg_cat_cntr
;
719 (*foundp
)->domain
= domain
;
720 (*foundp
)->translation
= retval
;
721 (*foundp
)->translation_length
= retlen
;
724 __set_errno (saved_errno
);
726 /* Now deal with plural. */
728 retval
= plural_lookup (domain
, n
, retval
, retlen
);
730 __libc_rwlock_unlock (_nl_state_lock
);
741 _nl_find_msg (domain_file
, domainbinding
, msgid
, convert
, lengthp
)
742 struct loaded_l10nfile
*domain_file
;
743 struct binding
*domainbinding
;
748 struct loaded_domain
*domain
;
754 if (domain_file
->decided
<= 0)
755 _nl_load_domain (domain_file
, domainbinding
);
757 if (domain_file
->data
== NULL
)
760 domain
= (struct loaded_domain
*) domain_file
->data
;
762 nstrings
= domain
->nstrings
;
764 /* Locate the MSGID and its translation. */
765 if (domain
->hash_tab
!= NULL
)
767 /* Use the hashing table. */
768 nls_uint32 len
= strlen (msgid
);
769 nls_uint32 hash_val
= __hash_string (msgid
);
770 nls_uint32 idx
= hash_val
% domain
->hash_size
;
771 nls_uint32 incr
= 1 + (hash_val
% (domain
->hash_size
- 2));
776 W (domain
->must_swap_hash_tab
, domain
->hash_tab
[idx
]);
779 /* Hash table entry is empty. */
784 /* Compare msgid with the original string at index nstr.
785 We compare the lengths with >=, not ==, because plural entries
786 are represented by strings with an embedded NUL. */
788 ? W (domain
->must_swap
, domain
->orig_tab
[nstr
].length
) >= len
790 domain
->data
+ W (domain
->must_swap
,
791 domain
->orig_tab
[nstr
].offset
))
793 : domain
->orig_sysdep_tab
[nstr
- nstrings
].length
> len
795 domain
->orig_sysdep_tab
[nstr
- nstrings
].pointer
)
802 if (idx
>= domain
->hash_size
- incr
)
803 idx
-= domain
->hash_size
- incr
;
811 /* Try the default method: binary search in the sorted array of
821 act
= (bottom
+ top
) / 2;
822 cmp_val
= strcmp (msgid
, (domain
->data
823 + W (domain
->must_swap
,
824 domain
->orig_tab
[act
].offset
)));
827 else if (cmp_val
> 0)
832 /* No translation was found. */
837 /* The translation was found at index ACT. If we have to convert the
838 string to use a different character set, this is the time. */
842 (domain
->data
+ W (domain
->must_swap
, domain
->trans_tab
[act
].offset
));
843 resultlen
= W (domain
->must_swap
, domain
->trans_tab
[act
].length
) + 1;
847 result
= (char *) domain
->trans_sysdep_tab
[act
- nstrings
].pointer
;
848 resultlen
= domain
->trans_sysdep_tab
[act
- nstrings
].length
;
851 #if defined _LIBC || HAVE_ICONV
854 /* We are supposed to do a conversion. */
855 const char *encoding
= get_output_charset (domainbinding
);
857 /* Protect against reallocation of the table. */
858 __libc_rwlock_rdlock (domain
->conversions_lock
);
860 /* Search whether a table with converted translations for this
861 encoding has already been allocated. */
862 size_t nconversions
= domain
->nconversions
;
863 struct converted_domain
*convd
= NULL
;
866 for (i
= nconversions
; i
> 0; )
869 if (strcmp (domain
->conversions
[i
].encoding
, encoding
) == 0)
871 convd
= &domain
->conversions
[i
];
876 __libc_rwlock_unlock (domain
->conversions_lock
);
880 /* We have to allocate a new conversions table. */
881 __libc_rwlock_wrlock (domain
->conversions_lock
);
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 /* We are supposed to do a conversion. First allocate an
1037 appropriate table with the same structure as the table
1038 of translations in the file, where we can put the pointers
1039 to the converted strings in.
1040 There is a slight complication with plural entries. They
1041 are represented by consecutive NUL terminated strings. We
1042 handle this case by converting RESULTLEN bytes, including
1045 if (convd
->conv_tab
== NULL
1046 && ((convd
->conv_tab
=
1047 (char **) calloc (nstrings
+ domain
->n_sysdep_strings
,
1050 /* Mark that we didn't succeed allocating a table. */
1051 convd
->conv_tab
= (char **) -1;
1053 if (__builtin_expect (convd
->conv_tab
== (char **) -1, 0))
1054 /* Nothing we can do, no more memory. We cannot use the
1055 translation because it might be encoded incorrectly. */
1058 if (convd
->conv_tab
[act
] == NULL
)
1060 /* We haven't used this string so far, so it is not
1061 translated yet. Do this now. */
1062 /* We use a bit more efficient memory handling.
1063 We allocate always larger blocks which get used over
1064 time. This is faster than many small allocations. */
1065 __libc_lock_define_initialized (static, lock
)
1066 # define INITIAL_BLOCK_SIZE 4080
1067 static unsigned char *freemem
;
1068 static size_t freemem_size
;
1070 const unsigned char *inbuf
;
1071 unsigned char *outbuf
;
1074 transmem_block_t
*transmem_list
= NULL
;
1077 __libc_lock_lock (lock
);
1079 inbuf
= (const unsigned char *) result
;
1080 outbuf
= freemem
+ sizeof (size_t);
1085 transmem_block_t
*newmem
;
1087 size_t non_reversible
;
1090 if (freemem_size
< sizeof (size_t))
1091 goto resize_freemem
;
1093 res
= __gconv (convd
->conv
,
1094 &inbuf
, inbuf
+ resultlen
,
1096 outbuf
+ freemem_size
- sizeof (size_t),
1099 if (res
== __GCONV_OK
|| res
== __GCONV_EMPTY_INPUT
)
1102 if (res
!= __GCONV_FULL_OUTPUT
)
1104 /* We should not use the translation at all, it
1105 is incorrectly encoded. */
1106 __libc_lock_unlock (lock
);
1110 inbuf
= (const unsigned char *) result
;
1113 const char *inptr
= (const char *) inbuf
;
1114 size_t inleft
= resultlen
;
1115 char *outptr
= (char *) outbuf
;
1118 if (freemem_size
< sizeof (size_t))
1119 goto resize_freemem
;
1121 outleft
= freemem_size
- sizeof (size_t);
1122 if (iconv (convd
->conv
,
1123 (ICONV_CONST
char **) &inptr
, &inleft
,
1127 outbuf
= (unsigned char *) outptr
;
1132 __libc_lock_unlock (lock
);
1139 /* We must allocate a new buffer or resize the old one. */
1140 if (malloc_count
> 0)
1143 freemem_size
= malloc_count
* INITIAL_BLOCK_SIZE
;
1144 newmem
= (transmem_block_t
*) realloc (transmem_list
,
1148 transmem_list
= transmem_list
->next
;
1151 struct transmem_list
*old
= transmem_list
;
1153 transmem_list
= transmem_list
->next
;
1161 freemem_size
= INITIAL_BLOCK_SIZE
;
1162 newmem
= (transmem_block_t
*) malloc (freemem_size
);
1164 if (__builtin_expect (newmem
== NULL
, 0))
1168 __libc_lock_unlock (lock
);
1173 /* Add the block to the list of blocks we have to free
1175 newmem
->next
= transmem_list
;
1176 transmem_list
= newmem
;
1178 freemem
= (unsigned char *) newmem
->data
;
1179 freemem_size
-= offsetof (struct transmem_list
, data
);
1181 transmem_list
= newmem
;
1185 outbuf
= freemem
+ sizeof (size_t);
1188 /* We have now in our buffer a converted string. Put this
1189 into the table of conversions. */
1190 *(size_t *) freemem
= outbuf
- freemem
- sizeof (size_t);
1191 convd
->conv_tab
[act
] = (char *) freemem
;
1192 /* Shrink freemem, but keep it aligned. */
1193 freemem_size
-= outbuf
- freemem
;
1195 freemem
+= freemem_size
& (alignof (size_t) - 1);
1196 freemem_size
= freemem_size
& ~ (alignof (size_t) - 1);
1198 __libc_lock_unlock (lock
);
1201 /* Now convd->conv_tab[act] contains the translation of all
1202 the plural variants. */
1203 result
= convd
->conv_tab
[act
] + sizeof (size_t);
1204 resultlen
= *(size_t *) convd
->conv_tab
[act
];
1208 /* The result string is converted. */
1210 #endif /* _LIBC || HAVE_ICONV */
1212 *lengthp
= resultlen
;
1217 /* Look up a plural variant. */
1220 plural_lookup (domain
, n
, translation
, translation_len
)
1221 struct loaded_l10nfile
*domain
;
1222 unsigned long int n
;
1223 const char *translation
;
1224 size_t translation_len
;
1226 struct loaded_domain
*domaindata
= (struct loaded_domain
*) domain
->data
;
1227 unsigned long int index
;
1230 index
= plural_eval (domaindata
->plural
, n
);
1231 if (index
>= domaindata
->nplurals
)
1232 /* This should never happen. It means the plural expression and the
1233 given maximum value do not match. */
1236 /* Skip INDEX strings at TRANSLATION. */
1241 p
= __rawmemchr (p
, '\0');
1243 p
= strchr (p
, '\0');
1245 /* And skip over the NUL byte. */
1248 if (p
>= translation
+ translation_len
)
1249 /* This should never happen. It means the plural expression
1250 evaluated to a value larger than the number of variants
1251 available for MSGID1. */
1252 return (char *) translation
;
1258 /* Return string representation of locale CATEGORY. */
1261 category_to_name (category
)
1270 retval
= "LC_COLLATE";
1275 retval
= "LC_CTYPE";
1280 retval
= "LC_MONETARY";
1285 retval
= "LC_NUMERIC";
1295 retval
= "LC_MESSAGES";
1300 retval
= "LC_RESPONSE";
1305 /* This might not make sense but is perhaps better than any other
1311 /* If you have a better idea for a default value let me know. */
1319 /* Guess value of current locale from value of the environment variables. */
1322 guess_category_value (category
, categoryname
)
1324 const char *categoryname
;
1326 const char *language
;
1329 /* The highest priority value is the `LANGUAGE' environment
1330 variable. But we don't use the value if the currently selected
1331 locale is the C locale. This is a GNU extension. */
1332 language
= getenv ("LANGUAGE");
1333 if (language
!= NULL
&& language
[0] == '\0')
1336 /* We have to proceed with the POSIX methods of looking to `LC_ALL',
1337 `LC_xxx', and `LANG'. On some systems this can be done by the
1338 `setlocale' function itself. */
1340 retval
= __current_locale_name (category
);
1342 retval
= _nl_locale_name (category
, categoryname
);
1345 return language
!= NULL
&& strcmp (retval
, "C") != 0 ? language
: retval
;
1348 #if defined _LIBC || HAVE_ICONV
1349 /* Returns the output charset. */
1352 get_output_charset (domainbinding
)
1353 struct binding
*domainbinding
;
1355 /* The output charset should normally be determined by the locale. But
1356 sometimes the locale is not used or not correctly set up, so we provide
1357 a possibility for the user to override this: the OUTPUT_CHARSET
1358 environment variable. Moreover, the value specified through
1359 bind_textdomain_codeset overrides both. */
1360 if (domainbinding
!= NULL
&& domainbinding
->codeset
!= NULL
)
1361 return domainbinding
->codeset
;
1364 /* For speed reasons, we look at the value of OUTPUT_CHARSET only
1365 once. This is a user variable that is not supposed to change
1366 during a program run. */
1367 static char *output_charset_cache
;
1368 static int output_charset_cached
;
1370 if (!output_charset_cached
)
1372 const char *value
= getenv ("OUTPUT_CHARSET");
1374 if (value
!= NULL
&& value
[0] != '\0')
1376 size_t len
= strlen (value
) + 1;
1377 char *value_copy
= (char *) malloc (len
);
1379 if (value_copy
!= NULL
)
1380 memcpy (value_copy
, value
, len
);
1381 output_charset_cache
= value_copy
;
1383 output_charset_cached
= 1;
1386 if (output_charset_cache
!= NULL
)
1387 return output_charset_cache
;
1391 return _NL_CURRENT (LC_CTYPE
, CODESET
);
1394 extern const char *locale_charset
PARAMS ((void);
1395 return locale_charset ();
1403 /* @@ begin of epilog @@ */
1405 /* We don't want libintl.a to depend on any other library. So we
1406 avoid the non-standard function stpcpy. In GNU C Library this
1407 function is available, though. Also allow the symbol HAVE_STPCPY
1409 #if !_LIBC && !HAVE_STPCPY
1415 while ((*dest
++ = *src
++) != '\0')
1421 #if !_LIBC && !HAVE_MEMPCPY
1423 mempcpy (dest
, src
, n
)
1428 return (void *) ((char *) memcpy (dest
, src
, n
) + n
);
1434 /* If we want to free all resources we have to do some work at
1436 libc_freeres_fn (free_mem
)
1440 while (_nl_domain_bindings
!= NULL
)
1442 struct binding
*oldp
= _nl_domain_bindings
;
1443 _nl_domain_bindings
= _nl_domain_bindings
->next
;
1444 if (oldp
->dirname
!= _nl_default_dirname
)
1445 /* Yes, this is a pointer comparison. */
1446 free (oldp
->dirname
);
1447 free (oldp
->codeset
);
1451 if (_nl_current_default_domain
!= _nl_default_default_domain
)
1452 /* Yes, again a pointer comparison. */
1453 free ((char *) _nl_current_default_domain
);
1455 /* Remove the search tree with the known translations. */
1456 __tdestroy (root
, free
);
1459 while (transmem_list
!= NULL
)
1461 old
= transmem_list
;
1462 transmem_list
= transmem_list
->next
;