1 /* Implementation of the internal dcigettext function.
2 Copyright (C) 1995-1999, 2000-2003 Free Software Foundation, Inc.
3
4 This program is free software; you can redistribute it and/or modify it
5 under the terms of the GNU Library General Public License as published
6 by the Free Software Foundation; either version 2, or (at your option)
7 any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public
15 License along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
17 USA. */
18
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. */
22 #ifndef _GNU_SOURCE
23 # define _GNU_SOURCE 1
24 #endif
25
26 #ifdef HAVE_CONFIG_H
27 # include <config.h>
28 #endif
29
30 #include <sys/types.h>
31
32 #ifdef __GNUC__
33 # define alloca __builtin_alloca
34 # define HAVE_ALLOCA 1
35 #else
36 # ifdef _MSC_VER
37 # include <malloc.h>
38 # define alloca _alloca
39 # else
40 # if defined HAVE_ALLOCA_H || defined _LIBC
41 # include <alloca.h>
42 # else
43 # ifdef _AIX
44 #pragma alloca
45 # else
46 # ifndef alloca
47 char *alloca ();
48 # endif
49 # endif
50 # endif
51 # endif
52 #endif
53
54 #include <errno.h>
55 #ifndef errno
56 extern int errno;
57 #endif
58 #ifndef __set_errno
59 # define __set_errno(val) errno = (val)
60 #endif
61
62 #include <stddef.h>
63 #include <stdlib.h>
64 #include <string.h>
65
66 #if defined HAVE_UNISTD_H || defined _LIBC
67 # include <unistd.h>
68 #endif
69
70 #include <locale.h>
71
72 #ifdef _LIBC
73 /* Guess whether integer division by zero raises signal SIGFPE.
74 Set to 1 only if you know for sure. In case of doubt, set to 0. */
75 # if defined __alpha__ || defined __arm__ || defined __i386__ \
76 || defined __m68k__ || defined __s390__
77 # define INTDIV0_RAISES_SIGFPE 1
78 # else
79 # define INTDIV0_RAISES_SIGFPE 0
80 # endif
81 #endif
82 #if !INTDIV0_RAISES_SIGFPE
83 # include <signal.h>
84 #endif
85
86 #if defined HAVE_SYS_PARAM_H || defined _LIBC
87 # include <sys/param.h>
88 #endif
89
90 #include "gettextP.h"
91 #include "plural-exp.h"
92 #ifdef _LIBC
93 # include <libintl.h>
94 #else
95 # include "libgnuintl.h"
96 #endif
97 #include "hash-string.h"
98
99 /* Thread safetyness. */
100 #ifdef _LIBC
101 # include <bits/libc-lock.h>
102 #else
103 /* Provide dummy implementation if this is outside glibc. */
104 # define __libc_lock_define_initialized(CLASS, NAME)
105 # define __libc_lock_lock(NAME)
106 # define __libc_lock_unlock(NAME)
107 # define __libc_rwlock_define_initialized(CLASS, NAME)
108 # define __libc_rwlock_rdlock(NAME)
109 # define __libc_rwlock_unlock(NAME)
110 #endif
111
112 /* Alignment of types. */
113 #if defined __GNUC__ && __GNUC__ >= 2
114 # define alignof(TYPE) __alignof__ (TYPE)
115 #else
116 # define alignof(TYPE) \
117 ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
118 #endif
119
120 /* The internal variables in the standalone libintl.a must have different
121 names than the internal variables in GNU libc, otherwise programs
122 using libintl.a cannot be linked statically. */
123 #if !defined _LIBC
124 # define _nl_default_default_domain libintl_nl_default_default_domain
125 # define _nl_current_default_domain libintl_nl_current_default_domain
126 # define _nl_default_dirname libintl_nl_default_dirname
127 # define _nl_domain_bindings libintl_nl_domain_bindings
128 #endif
129
130 /* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>. */
131 #ifndef offsetof
132 # define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
133 #endif
134
135 /* @@ end of prolog @@ */
136
137 #ifdef _LIBC
138 /* Rename the non ANSI C functions. This is required by the standard
139 because some ANSI C functions will require linking with this object
140 file and the name space must not be polluted. */
141 # define getcwd __getcwd
142 # ifndef stpcpy
143 # define stpcpy __stpcpy
144 # endif
145 # define tfind __tfind
146 #else
147 # if !defined HAVE_GETCWD
148 char *getwd ();
149 # define getcwd(buf, max) getwd (buf)
150 # else
151 char *getcwd ();
152 # endif
153 # ifndef HAVE_STPCPY
154 static char *stpcpy PARAMS ((char *dest, const char *src));
155 # endif
156 # ifndef HAVE_MEMPCPY
157 static void *mempcpy PARAMS ((void *dest, const void *src, size_t n));
158 # endif
159 #endif
160
161 /* Amount to increase buffer size by in each try. */
162 #define PATH_INCR 32
163
164 /* The following is from pathmax.h. */
165 /* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define
166 PATH_MAX but might cause redefinition warnings when sys/param.h is
167 later included (as on MORE/BSD 4.3). */
168 #if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__)
169 # include <limits.h>
170 #endif
171
172 #ifndef _POSIX_PATH_MAX
173 # define _POSIX_PATH_MAX 255
174 #endif
175
176 #if !defined PATH_MAX && defined _PC_PATH_MAX
177 # define PATH_MAX (pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : pathconf ("/", _PC_PATH_MAX))
178 #endif
179
180 /* Don't include sys/param.h if it already has been. */
181 #if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN
182 # include <sys/param.h>
183 #endif
184
185 #if !defined PATH_MAX && defined MAXPATHLEN
186 # define PATH_MAX MAXPATHLEN
187 #endif
188
189 #ifndef PATH_MAX
190 # define PATH_MAX _POSIX_PATH_MAX
191 #endif
192
193 /* Pathname support.
194 ISSLASH(C) tests whether C is a directory separator character.
195 IS_ABSOLUTE_PATH(P) tests whether P is an absolute path. If it is not,
196 it may be concatenated to a directory pathname.
197 IS_PATH_WITH_DIR(P) tests whether P contains a directory specification.
198 */
199 #if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__
200 /* Win32, OS/2, DOS */
201 # define ISSLASH(C) ((C) == '/' || (C) == '\\')
202 # define HAS_DEVICE(P) \
203 ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
204 && (P)[1] == ':')
205 # define IS_ABSOLUTE_PATH(P) (ISSLASH ((P)[0]) || HAS_DEVICE (P))
206 # define IS_PATH_WITH_DIR(P) \
207 (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
208 #else
209 /* Unix */
210 # define ISSLASH(C) ((C) == '/')
211 # define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0])
212 # define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
213 #endif
214
215 /* This is the type used for the search tree where known translations
216 are stored. */
217 struct known_translation_t
218 {
219 /* Domain in which to search. */
220 char *domainname;
221
222 /* The category. */
223 int category;
224
225 /* State of the catalog counter at the point the string was found. */
226 int counter;
227
228 /* Catalog where the string was found. */
229 struct loaded_l10nfile *domain;
230
231 /* And finally the translation. */
232 const char *translation;
233 size_t translation_length;
234
235 /* Pointer to the string in question. */
236 char msgid[ZERO];
237 };
238
239 /* Root of the search tree with known translations. We can use this
240 only if the system provides the `tsearch' function family. */
241 #if defined HAVE_TSEARCH || defined _LIBC
242 # include <search.h>
243
244 static void *root;
245
246 # ifdef _LIBC
247 # define tsearch __tsearch
248 # endif
249
250 /* Function to compare two entries in the table of known translations. */
251 static int transcmp PARAMS ((const void *p1, const void *p2));
252 static int
transcmp(p1,p2)253 transcmp (p1, p2)
254 const void *p1;
255 const void *p2;
256 {
257 const struct known_translation_t *s1;
258 const struct known_translation_t *s2;
259 int result;
260
261 s1 = (const struct known_translation_t *) p1;
262 s2 = (const struct known_translation_t *) p2;
263
264 result = strcmp (s1->msgid, s2->msgid);
265 if (result == 0)
266 {
267 result = strcmp (s1->domainname, s2->domainname);
268 if (result == 0)
269 /* We compare the category last (though this is the cheapest
270 operation) since it is hopefully always the same (namely
271 LC_MESSAGES). */
272 result = s1->category - s2->category;
273 }
274
275 return result;
276 }
277 #endif
278
279 #ifndef INTVARDEF
280 # define INTVARDEF(name)
281 #endif
282 #ifndef INTUSE
283 # define INTUSE(name) name
284 #endif
285
286 /* Name of the default domain used for gettext(3) prior any call to
287 textdomain(3). The default value for this is "messages". */
288 const char _nl_default_default_domain[] attribute_hidden = "messages";
289
290 /* Value used as the default domain for gettext(3). */
291 const char *_nl_current_default_domain attribute_hidden
292 = _nl_default_default_domain;
293
294 /* Contains the default location of the message catalogs. */
295 #if defined __EMX__
296 extern const char _nl_default_dirname[];
297 #else
298 const char _nl_default_dirname[] = LOCALEDIR;
299 INTVARDEF (_nl_default_dirname)
300 #endif
301
302 /* List with bindings of specific domains created by bindtextdomain()
303 calls. */
304 struct binding *_nl_domain_bindings;
305
306 /* Prototypes for local functions. */
307 static char *plural_lookup PARAMS ((struct loaded_l10nfile *domain,
308 unsigned long int n,
309 const char *translation,
310 size_t translation_len))
311 internal_function;
312 static const char *guess_category_value PARAMS ((int category,
313 const char *categoryname))
314 internal_function;
315 #ifdef _LIBC
316 # include "../locale/localeinfo.h"
317 # define category_to_name(category) _nl_category_names[category]
318 #else
319 static const char *category_to_name PARAMS ((int category)) internal_function;
320 #endif
321
322
323 /* For those loosing systems which don't have `alloca' we have to add
324 some additional code emulating it. */
325 #ifdef HAVE_ALLOCA
326 /* Nothing has to be done. */
327 # define freea(p) /* nothing */
328 # define ADD_BLOCK(list, address) /* nothing */
329 # define FREE_BLOCKS(list) /* nothing */
330 #else
331 struct block_list
332 {
333 void *address;
334 struct block_list *next;
335 };
336 # define ADD_BLOCK(list, addr) \
337 do { \
338 struct block_list *newp = (struct block_list *) malloc (sizeof (*newp)); \
339 /* If we cannot get a free block we cannot add the new element to \
340 the list. */ \
341 if (newp != NULL) { \
342 newp->address = (addr); \
343 newp->next = (list); \
344 (list) = newp; \
345 } \
346 } while (0)
347 # define FREE_BLOCKS(list) \
348 do { \
349 while (list != NULL) { \
350 struct block_list *old = list; \
351 list = list->next; \
352 free (old->address); \
353 free (old); \
354 } \
355 } while (0)
356 # undef alloca
357 # define alloca(size) (malloc (size))
358 # define freea(p) free (p)
359 #endif /* have alloca */
360
361
362 #ifdef _LIBC
363 /* List of blocks allocated for translations. */
364 typedef struct transmem_list
365 {
366 struct transmem_list *next;
367 char data[ZERO];
368 } transmem_block_t;
369 static struct transmem_list *transmem_list;
370 #else
371 typedef unsigned char transmem_block_t;
372 #endif
373
374
375 /* Names for the libintl functions are a problem. They must not clash
376 with existing names and they should follow ANSI C. But this source
377 code is also used in GNU C Library where the names have a __
378 prefix. So we have to make a difference here. */
379 #ifdef _LIBC
380 # define DCIGETTEXT __dcigettext
381 #else
382 # define DCIGETTEXT libintl_dcigettext
383 #endif
384
385 /* Lock variable to protect the global data in the gettext implementation. */
386 #ifdef _LIBC
387 __libc_rwlock_define_initialized (, _nl_state_lock attribute_hidden)
388 #endif
389
390 /* Checking whether the binaries runs SUID must be done and glibc provides
391 easier methods therefore we make a difference here. */
392 #ifdef _LIBC
393 # define ENABLE_SECURE __libc_enable_secure
394 # define DETERMINE_SECURE
395 #else
396 # ifndef HAVE_GETUID
397 # define getuid() 0
398 # endif
399 # ifndef HAVE_GETGID
400 # define getgid() 0
401 # endif
402 # ifndef HAVE_GETEUID
403 # define geteuid() getuid()
404 # endif
405 # ifndef HAVE_GETEGID
406 # define getegid() getgid()
407 # endif
408 static int enable_secure;
409 # define ENABLE_SECURE (enable_secure == 1)
410 # define DETERMINE_SECURE \
411 if (enable_secure == 0) \
412 { \
413 if (getuid () != geteuid () || getgid () != getegid ()) \
414 enable_secure = 1; \
415 else \
416 enable_secure = -1; \
417 }
418 #endif
419
420 /* Get the function to evaluate the plural expression. */
421 #include "eval-plural.h"
422
423 /* Look up MSGID in the DOMAINNAME message catalog for the current
424 CATEGORY locale and, if PLURAL is nonzero, search over string
425 depending on the plural form determined by N. */
426 char *
427 DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
428 const char *domainname;
429 const char *msgid1;
430 const char *msgid2;
431 int plural;
432 unsigned long int n;
433 int category;
434 {
435 #ifndef HAVE_ALLOCA
436 struct block_list *block_list = NULL;
437 #endif
438 struct loaded_l10nfile *domain;
439 struct binding *binding;
440 const char *categoryname;
441 const char *categoryvalue;
442 char *dirname, *xdomainname;
443 char *single_locale;
444 char *retval;
445 size_t retlen;
446 int saved_errno;
447 #if defined HAVE_TSEARCH || defined _LIBC
448 struct known_translation_t *search;
449 struct known_translation_t **foundp = NULL;
450 size_t msgid_len;
451 #endif
452 size_t domainname_len;
453
454 /* If no real MSGID is given return NULL. */
455 if (msgid1 == NULL)
456 return NULL;
457
458 #ifdef _LIBC
459 if (category < 0 || category >= __LC_LAST || category == LC_ALL)
460 /* Bogus. */
461 return (plural == 0
462 ? (char *) msgid1
463 /* Use the Germanic plural rule. */
464 : n == 1 ? (char *) msgid1 : (char *) msgid2);
465 #endif
466
467 __libc_rwlock_rdlock (_nl_state_lock);
468
469 /* If DOMAINNAME is NULL, we are interested in the default domain. If
470 CATEGORY is not LC_MESSAGES this might not make much sense but the
471 definition left this undefined. */
472 if (domainname == NULL)
473 domainname = _nl_current_default_domain;
474
475 /* OS/2 specific: backward compatibility with older libintl versions */
476 #ifdef LC_MESSAGES_COMPAT
477 if (category == LC_MESSAGES_COMPAT)
478 category = LC_MESSAGES;
479 #endif
480
481 #if defined HAVE_TSEARCH || defined _LIBC
482 msgid_len = strlen (msgid1) + 1;
483
484 /* Try to find the translation among those which we found at
485 some time. */
486 search = (struct known_translation_t *)
487 alloca (offsetof (struct known_translation_t, msgid) + msgid_len);
488 memcpy (search->msgid, msgid1, msgid_len);
489 search->domainname = (char *) domainname;
490 search->category = category;
491
492 foundp = (struct known_translation_t **) tfind (search, &root, transcmp);
493 freea (search);
494 if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
495 {
496 /* Now deal with plural. */
497 if (plural)
498 retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation,
499 (*foundp)->translation_length);
500 else
501 retval = (char *) (*foundp)->translation;
502
503 __libc_rwlock_unlock (_nl_state_lock);
504 return retval;
505 }
506 #endif
507
508 /* Preserve the `errno' value. */
509 saved_errno = errno;
510
511 /* See whether this is a SUID binary or not. */
512 DETERMINE_SECURE;
513
514 /* First find matching binding. */
515 for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
516 {
517 int compare = strcmp (domainname, binding->domainname);
518 if (compare == 0)
519 /* We found it! */
520 break;
521 if (compare < 0)
522 {
523 /* It is not in the list. */
524 binding = NULL;
525 break;
526 }
527 }
528
529 if (binding == NULL)
530 dirname = (char *) INTUSE(_nl_default_dirname);
531 else if (IS_ABSOLUTE_PATH (binding->dirname))
532 dirname = binding->dirname;
533 else
534 {
535 /* We have a relative path. Make it absolute now. */
536 size_t dirname_len = strlen (binding->dirname) + 1;
537 size_t path_max;
538 char *ret;
539
540 path_max = (unsigned int) PATH_MAX;
541 path_max += 2; /* The getcwd docs say to do this. */
542
543 for (;;)
544 {
545 dirname = (char *) alloca (path_max + dirname_len);
546 ADD_BLOCK (block_list, dirname);
547
548 __set_errno (0);
549 ret = getcwd (dirname, path_max);
550 if (ret != NULL || errno != ERANGE)
551 break;
552
553 path_max += path_max / 2;
554 path_max += PATH_INCR;
555 }
556
557 if (ret == NULL)
558 /* We cannot get the current working directory. Don't signal an
559 error but simply return the default string. */
560 goto return_untranslated;
561
562 stpcpy (stpcpy (strchr (dirname, '\0'), "/"), binding->dirname);
563 }
564
565 /* Now determine the symbolic name of CATEGORY and its value. */
566 categoryname = category_to_name (category);
567 categoryvalue = guess_category_value (category, categoryname);
568
569 domainname_len = strlen (domainname);
570 xdomainname = (char *) alloca (strlen (categoryname)
571 + domainname_len + 5);
572 ADD_BLOCK (block_list, xdomainname);
573
574 stpcpy (mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"),
575 domainname, domainname_len),
576 ".mo");
577
578 /* Creating working area. */
579 single_locale = (char *) alloca (strlen (categoryvalue) + 1);
580 ADD_BLOCK (block_list, single_locale);
581
582
583 /* Search for the given string. This is a loop because we perhaps
584 got an ordered list of languages to consider for the translation. */
585 while (1)
586 {
587 /* Make CATEGORYVALUE point to the next element of the list. */
588 while (categoryvalue[0] != '\0' && categoryvalue[0] == ':')
589 ++categoryvalue;
590 if (categoryvalue[0] == '\0')
591 {
592 /* The whole contents of CATEGORYVALUE has been searched but
593 no valid entry has been found. We solve this situation
594 by implicitly appending a "C" entry, i.e. no translation
595 will take place. */
596 single_locale[0] = 'C';
597 single_locale[1] = '\0';
598 }
599 else
600 {
601 char *cp = single_locale;
602 while (categoryvalue[0] != '\0' && categoryvalue[0] != ':')
603 *cp++ = *categoryvalue++;
604 *cp = '\0';
605
606 /* When this is a SUID binary we must not allow accessing files
607 outside the dedicated directories. */
608 if (ENABLE_SECURE && IS_PATH_WITH_DIR (single_locale))
609 /* Ingore this entry. */
610 continue;
611 }
612
613 /* If the current locale value is C (or POSIX) we don't load a
614 domain. Return the MSGID. */
615 if (strcmp (single_locale, "C") == 0
616 || strcmp (single_locale, "POSIX") == 0)
617 break;
618
619 /* Find structure describing the message catalog matching the
620 DOMAINNAME and CATEGORY. */
621 domain = _nl_find_domain (dirname, single_locale, xdomainname, binding);
622
623 if (domain != NULL)
624 {
625 retval = _nl_find_msg (domain, binding, msgid1, &retlen);
626
627 if (retval == NULL)
628 {
629 int cnt;
630
631 for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
632 {
633 retval = _nl_find_msg (domain->successor[cnt], binding,
634 msgid1, &retlen);
635
636 if (retval != NULL)
637 {
638 domain = domain->successor[cnt];
639 break;
640 }
641 }
642 }
643
644 if (retval != NULL)
645 {
646 /* Found the translation of MSGID1 in domain DOMAIN:
647 starting at RETVAL, RETLEN bytes. */
648 FREE_BLOCKS (block_list);
649 #if defined HAVE_TSEARCH || defined _LIBC
650 if (foundp == NULL)
651 {
652 /* Create a new entry and add it to the search tree. */
653 struct known_translation_t *newp;
654
655 newp = (struct known_translation_t *)
656 malloc (offsetof (struct known_translation_t, msgid)
657 + msgid_len + domainname_len + 1);
658 if (newp != NULL)
659 {
660 newp->domainname =
661 mempcpy (newp->msgid, msgid1, msgid_len);
662 memcpy (newp->domainname, domainname, domainname_len + 1);
663 newp->category = category;
664 newp->counter = _nl_msg_cat_cntr;
665 newp->domain = domain;
666 newp->translation = retval;
667 newp->translation_length = retlen;
668
669 /* Insert the entry in the search tree. */
670 foundp = (struct known_translation_t **)
671 tsearch (newp, &root, transcmp);
672 if (foundp == NULL
673 || __builtin_expect (*foundp != newp, 0))
674 /* The insert failed. */
675 free (newp);
676 }
677 }
678 else
679 {
680 /* We can update the existing entry. */
681 (*foundp)->counter = _nl_msg_cat_cntr;
682 (*foundp)->domain = domain;
683 (*foundp)->translation = retval;
684 (*foundp)->translation_length = retlen;
685 }
686 #endif
687 __set_errno (saved_errno);
688
689 /* Now deal with plural. */
690 if (plural)
691 retval = plural_lookup (domain, n, retval, retlen);
692
693 __libc_rwlock_unlock (_nl_state_lock);
694 return retval;
695 }
696 }
697 }
698
699 return_untranslated:
700 /* Return the untranslated MSGID. */
701 FREE_BLOCKS (block_list);
702 __libc_rwlock_unlock (_nl_state_lock);
703 #ifndef _LIBC
704 if (!ENABLE_SECURE)
705 {
706 extern void _nl_log_untranslated PARAMS ((const char *logfilename,
707 const char *domainname,
708 const char *msgid1,
709 const char *msgid2,
710 int plural));
711 const char *logfilename = getenv ("GETTEXT_LOG_UNTRANSLATED");
712
713 if (logfilename != NULL && logfilename[0] != '\0')
714 _nl_log_untranslated (logfilename, domainname, msgid1, msgid2, plural);
715 }
716 #endif
717 __set_errno (saved_errno);
718 return (plural == 0
719 ? (char *) msgid1
720 /* Use the Germanic plural rule. */
721 : n == 1 ? (char *) msgid1 : (char *) msgid2);
722 }
723
724
725 char *
726 internal_function
_nl_find_msg(domain_file,domainbinding,msgid,lengthp)727 _nl_find_msg (domain_file, domainbinding, msgid, lengthp)
728 struct loaded_l10nfile *domain_file;
729 struct binding *domainbinding;
730 const char *msgid;
731 size_t *lengthp;
732 {
733 struct loaded_domain *domain;
734 nls_uint32 nstrings;
735 size_t act;
736 char *result;
737 size_t resultlen;
738
739 if (domain_file->decided == 0)
740 _nl_load_domain (domain_file, domainbinding);
741
742 if (domain_file->data == NULL)
743 return NULL;
744
745 domain = (struct loaded_domain *) domain_file->data;
746
747 nstrings = domain->nstrings;
748
749 /* Locate the MSGID and its translation. */
750 if (domain->hash_tab != NULL)
751 {
752 /* Use the hashing table. */
753 nls_uint32 len = strlen (msgid);
754 nls_uint32 hash_val = hash_string (msgid);
755 nls_uint32 idx = hash_val % domain->hash_size;
756 nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));
757
758 while (1)
759 {
760 nls_uint32 nstr =
761 W (domain->must_swap_hash_tab, domain->hash_tab[idx]);
762
763 if (nstr == 0)
764 /* Hash table entry is empty. */
765 return NULL;
766
767 nstr--;
768
769 /* Compare msgid with the original string at index nstr.
770 We compare the lengths with >=, not ==, because plural entries
771 are represented by strings with an embedded NUL. */
772 if (nstr < nstrings
773 ? W (domain->must_swap, domain->orig_tab[nstr].length) >= len
774 && (strcmp (msgid,
775 domain->data + W (domain->must_swap,
776 domain->orig_tab[nstr].offset))
777 == 0)
778 : domain->orig_sysdep_tab[nstr - nstrings].length > len
779 && (strcmp (msgid,
780 domain->orig_sysdep_tab[nstr - nstrings].pointer)
781 == 0))
782 {
783 act = nstr;
784 goto found;
785 }
786
787 if (idx >= domain->hash_size - incr)
788 idx -= domain->hash_size - incr;
789 else
790 idx += incr;
791 }
792 /* NOTREACHED */
793 }
794 else
795 {
796 /* Try the default method: binary search in the sorted array of
797 messages. */
798 size_t top, bottom;
799
800 bottom = 0;
801 top = nstrings;
802 while (bottom < top)
803 {
804 int cmp_val;
805
806 act = (bottom + top) / 2;
807 cmp_val = strcmp (msgid, (domain->data
808 + W (domain->must_swap,
809 domain->orig_tab[act].offset)));
810 if (cmp_val < 0)
811 top = act;
812 else if (cmp_val > 0)
813 bottom = act + 1;
814 else
815 goto found;
816 }
817 /* No translation was found. */
818 return NULL;
819 }
820
821 found:
822 /* The translation was found at index ACT. If we have to convert the
823 string to use a different character set, this is the time. */
824 if (act < nstrings)
825 {
826 result = (char *)
827 (domain->data + W (domain->must_swap, domain->trans_tab[act].offset));
828 resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
829 }
830 else
831 {
832 result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer;
833 resultlen = domain->trans_sysdep_tab[act - nstrings].length;
834 }
835
836 #if defined _LIBC || HAVE_ICONV
837 if (domain->codeset_cntr
838 != (domainbinding != NULL ? domainbinding->codeset_cntr : 0))
839 {
840 /* The domain's codeset has changed through bind_textdomain_codeset()
841 since the message catalog was initialized or last accessed. We
842 have to reinitialize the converter. */
843 _nl_free_domain_conv (domain);
844 _nl_init_domain_conv (domain_file, domain, domainbinding);
845 }
846
847 if (
848 # ifdef _LIBC
849 domain->conv != (__gconv_t) -1
850 # else
851 # if HAVE_ICONV
852 domain->conv != (iconv_t) -1
853 # endif
854 # endif
855 )
856 {
857 /* We are supposed to do a conversion. First allocate an
858 appropriate table with the same structure as the table
859 of translations in the file, where we can put the pointers
860 to the converted strings in.
861 There is a slight complication with plural entries. They
862 are represented by consecutive NUL terminated strings. We
863 handle this case by converting RESULTLEN bytes, including
864 NULs. */
865
866 if (domain->conv_tab == NULL
867 && ((domain->conv_tab =
868 (char **) calloc (nstrings + domain->n_sysdep_strings,
869 sizeof (char *)))
870 == NULL))
871 /* Mark that we didn't succeed allocating a table. */
872 domain->conv_tab = (char **) -1;
873
874 if (__builtin_expect (domain->conv_tab == (char **) -1, 0))
875 /* Nothing we can do, no more memory. */
876 goto converted;
877
878 if (domain->conv_tab[act] == NULL)
879 {
880 /* We haven't used this string so far, so it is not
881 translated yet. Do this now. */
882 /* We use a bit more efficient memory handling.
883 We allocate always larger blocks which get used over
884 time. This is faster than many small allocations. */
885 __libc_lock_define_initialized (static, lock)
886 # define INITIAL_BLOCK_SIZE 4080
887 static unsigned char *freemem;
888 static size_t freemem_size;
889
890 const unsigned char *inbuf;
891 unsigned char *outbuf;
892 int malloc_count;
893 # ifndef _LIBC
894 transmem_block_t *transmem_list = NULL;
895 # endif
896
897 __libc_lock_lock (lock);
898
899 inbuf = (const unsigned char *) result;
900 outbuf = freemem + sizeof (size_t);
901
902 malloc_count = 0;
903 while (1)
904 {
905 transmem_block_t *newmem;
906 # ifdef _LIBC
907 size_t non_reversible;
908 int res;
909
910 if (freemem_size < sizeof (size_t))
911 goto resize_freemem;
912
913 res = __gconv (domain->conv,
914 &inbuf, inbuf + resultlen,
915 &outbuf,
916 outbuf + freemem_size - sizeof (size_t),
917 &non_reversible);
918
919 if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
920 break;
921
922 if (res != __GCONV_FULL_OUTPUT)
923 {
924 __libc_lock_unlock (lock);
925 goto converted;
926 }
927
928 inbuf = result;
929 # else
930 # if HAVE_ICONV
931 const char *inptr = (const char *) inbuf;
932 size_t inleft = resultlen;
933 char *outptr = (char *) outbuf;
934 size_t outleft;
935
936 if (freemem_size < sizeof (size_t))
937 goto resize_freemem;
938
939 outleft = freemem_size - sizeof (size_t);
940 if (iconv (domain->conv,
941 (ICONV_CONST char **) &inptr, &inleft,
942 &outptr, &outleft)
943 != (size_t) (-1))
944 {
945 outbuf = (unsigned char *) outptr;
946 break;
947 }
948 if (errno != E2BIG)
949 {
950 __libc_lock_unlock (lock);
951 goto converted;
952 }
953 # endif
954 # endif
955
956 resize_freemem:
957 /* We must allocate a new buffer or resize the old one. */
958 if (malloc_count > 0)
959 {
960 ++malloc_count;
961 freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
962 newmem = (transmem_block_t *) realloc (transmem_list,
963 freemem_size);
964 # ifdef _LIBC
965 if (newmem != NULL)
966 transmem_list = transmem_list->next;
967 else
968 {
969 struct transmem_list *old = transmem_list;
970
971 transmem_list = transmem_list->next;
972 free (old);
973 }
974 # endif
975 }
976 else
977 {
978 malloc_count = 1;
979 freemem_size = INITIAL_BLOCK_SIZE;
980 newmem = (transmem_block_t *) malloc (freemem_size);
981 }
982 if (__builtin_expect (newmem == NULL, 0))
983 {
984 freemem = NULL;
985 freemem_size = 0;
986 __libc_lock_unlock (lock);
987 goto converted;
988 }
989
990 # ifdef _LIBC
991 /* Add the block to the list of blocks we have to free
992 at some point. */
993 newmem->next = transmem_list;
994 transmem_list = newmem;
995
996 freemem = newmem->data;
997 freemem_size -= offsetof (struct transmem_list, data);
998 # else
999 transmem_list = newmem;
1000 freemem = newmem;
1001 # endif
1002
1003 outbuf = freemem + sizeof (size_t);
1004 }
1005
1006 /* We have now in our buffer a converted string. Put this
1007 into the table of conversions. */
1008 *(size_t *) freemem = outbuf - freemem - sizeof (size_t);
1009 domain->conv_tab[act] = (char *) freemem;
1010 /* Shrink freemem, but keep it aligned. */
1011 freemem_size -= outbuf - freemem;
1012 freemem = outbuf;
1013 freemem += freemem_size & (alignof (size_t) - 1);
1014 freemem_size = freemem_size & ~ (alignof (size_t) - 1);
1015
1016 __libc_lock_unlock (lock);
1017 }
1018
1019 /* Now domain->conv_tab[act] contains the translation of all
1020 the plural variants. */
1021 result = domain->conv_tab[act] + sizeof (size_t);
1022 resultlen = *(size_t *) domain->conv_tab[act];
1023 }
1024
1025 converted:
1026 /* The result string is converted. */
1027
1028 #endif /* _LIBC || HAVE_ICONV */
1029
1030 *lengthp = resultlen;
1031 return result;
1032 }
1033
1034
1035 /* Look up a plural variant. */
1036 static char *
1037 internal_function
plural_lookup(domain,n,translation,translation_len)1038 plural_lookup (domain, n, translation, translation_len)
1039 struct loaded_l10nfile *domain;
1040 unsigned long int n;
1041 const char *translation;
1042 size_t translation_len;
1043 {
1044 struct loaded_domain *domaindata = (struct loaded_domain *) domain->data;
1045 unsigned long int index;
1046 const char *p;
1047
1048 index = plural_eval (domaindata->plural, n);
1049 if (index >= domaindata->nplurals)
1050 /* This should never happen. It means the plural expression and the
1051 given maximum value do not match. */
1052 index = 0;
1053
1054 /* Skip INDEX strings at TRANSLATION. */
1055 p = translation;
1056 while (index-- > 0)
1057 {
1058 #ifdef _LIBC
1059 p = __rawmemchr (p, '\0');
1060 #else
1061 p = strchr (p, '\0');
1062 #endif
1063 /* And skip over the NUL byte. */
1064 p++;
1065
1066 if (p >= translation + translation_len)
1067 /* This should never happen. It means the plural expression
1068 evaluated to a value larger than the number of variants
1069 available for MSGID1. */
1070 return (char *) translation;
1071 }
1072 return (char *) p;
1073 }
1074
1075 #ifndef _LIBC
1076 /* Return string representation of locale CATEGORY. */
1077 static const char *
1078 internal_function
category_to_name(category)1079 category_to_name (category)
1080 int category;
1081 {
1082 const char *retval;
1083
1084 switch (category)
1085 {
1086 #ifdef LC_COLLATE
1087 case LC_COLLATE:
1088 retval = "LC_COLLATE";
1089 break;
1090 #endif
1091 #ifdef LC_CTYPE
1092 case LC_CTYPE:
1093 retval = "LC_CTYPE";
1094 break;
1095 #endif
1096 #ifdef LC_MONETARY
1097 case LC_MONETARY:
1098 retval = "LC_MONETARY";
1099 break;
1100 #endif
1101 #ifdef LC_NUMERIC
1102 case LC_NUMERIC:
1103 retval = "LC_NUMERIC";
1104 break;
1105 #endif
1106 #ifdef LC_TIME
1107 case LC_TIME:
1108 retval = "LC_TIME";
1109 break;
1110 #endif
1111 #ifdef LC_MESSAGES
1112 case LC_MESSAGES:
1113 retval = "LC_MESSAGES";
1114 break;
1115 #endif
1116 #ifdef LC_RESPONSE
1117 case LC_RESPONSE:
1118 retval = "LC_RESPONSE";
1119 break;
1120 #endif
1121 #ifdef LC_ALL
1122 case LC_ALL:
1123 /* This might not make sense but is perhaps better than any other
1124 value. */
1125 retval = "LC_ALL";
1126 break;
1127 #endif
1128 default:
1129 /* If you have a better idea for a default value let me know. */
1130 retval = "LC_XXX";
1131 }
1132
1133 return retval;
1134 }
1135 #endif
1136
1137 /* Guess value of current locale from value of the environment variables. */
1138 static const char *
1139 internal_function
guess_category_value(category,categoryname)1140 guess_category_value (category, categoryname)
1141 int category;
1142 const char *categoryname;
1143 {
1144 const char *language;
1145 const char *retval;
1146
1147 /* The highest priority value is the `LANGUAGE' environment
1148 variable. But we don't use the value if the currently selected
1149 locale is the C locale. This is a GNU extension. */
1150 language = getenv ("LANGUAGE");
1151 if (language != NULL && language[0] == '\0')
1152 language = NULL;
1153
1154 /* We have to proceed with the POSIX methods of looking to `LC_ALL',
1155 `LC_xxx', and `LANG'. On some systems this can be done by the
1156 `setlocale' function itself. */
1157 #ifdef _LIBC
1158 retval = __current_locale_name (category);
1159 #else
1160 retval = _nl_locale_name (category, categoryname);
1161 #endif
1162
1163 /* Ignore LANGUAGE if the locale is set to "C" because
1164 1. "C" locale usually uses the ASCII encoding, and most international
1165 messages use non-ASCII characters. These characters get displayed
1166 as question marks (if using glibc's iconv()) or as invalid 8-bit
1167 characters (because other iconv()s refuse to convert most non-ASCII
1168 characters to ASCII). In any case, the output is ugly.
1169 2. The precise output of some programs in the "C" locale is specified
1170 by POSIX and should not depend on environment variables like
1171 "LANGUAGE". We allow such programs to use gettext(). */
1172 return language != NULL && strcmp (retval, "C") != 0 ? language : retval;
1173 }
1174
1175 /* @@ begin of epilog @@ */
1176
1177 /* We don't want libintl.a to depend on any other library. So we
1178 avoid the non-standard function stpcpy. In GNU C Library this
1179 function is available, though. Also allow the symbol HAVE_STPCPY
1180 to be defined. */
1181 #if !_LIBC && !HAVE_STPCPY
1182 static char *
stpcpy(dest,src)1183 stpcpy (dest, src)
1184 char *dest;
1185 const char *src;
1186 {
1187 while ((*dest++ = *src++) != '\0')
1188 /* Do nothing. */ ;
1189 return dest - 1;
1190 }
1191 #endif
1192
1193 #if !_LIBC && !HAVE_MEMPCPY
1194 static void *
mempcpy(dest,src,n)1195 mempcpy (dest, src, n)
1196 void *dest;
1197 const void *src;
1198 size_t n;
1199 {
1200 return (void *) ((char *) memcpy (dest, src, n) + n);
1201 }
1202 #endif
1203
1204
1205 #ifdef _LIBC
1206 /* If we want to free all resources we have to do some work at
1207 program's end. */
libc_freeres_fn(free_mem)1208 libc_freeres_fn (free_mem)
1209 {
1210 void *old;
1211
1212 while (_nl_domain_bindings != NULL)
1213 {
1214 struct binding *oldp = _nl_domain_bindings;
1215 _nl_domain_bindings = _nl_domain_bindings->next;
1216 if (oldp->dirname != INTUSE(_nl_default_dirname))
1217 /* Yes, this is a pointer comparison. */
1218 free (oldp->dirname);
1219 free (oldp->codeset);
1220 free (oldp);
1221 }
1222
1223 if (_nl_current_default_domain != _nl_default_default_domain)
1224 /* Yes, again a pointer comparison. */
1225 free ((char *) _nl_current_default_domain);
1226
1227 /* Remove the search tree with the known translations. */
1228 __tdestroy (root, free);
1229 root = NULL;
1230
1231 while (transmem_list != NULL)
1232 {
1233 old = transmem_list;
1234 transmem_list = transmem_list->next;
1235 free (old);
1236 }
1237 }
1238 #endif
1239