/[zanavi_public1]/navit/intl/dcigettext.c
ZANavi

Contents of /navit/intl/dcigettext.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2 - (show annotations) (download)
Fri Oct 28 21:19:04 2011 UTC (8 years, 11 months ago) by zoff99
File MIME type: text/plain
File size: 33451 byte(s)
import files
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
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 # if VMS
152 # define getcwd(buf, max) (getcwd) (buf, max, 0)
153 # else
154 char *getcwd ();
155 # endif
156 # endif
157 # ifndef HAVE_STPCPY
158 static char *stpcpy (char *dest, const char *src);
159 # endif
160 # ifndef HAVE_MEMPCPY
161 static void *mempcpy (void *dest, const void *src, size_t n);
162 # endif
163 #endif
164
165 /* Amount to increase buffer size by in each try. */
166 #define PATH_INCR 32
167
168 /* The following is from pathmax.h. */
169 /* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define
170 PATH_MAX but might cause redefinition warnings when sys/param.h is
171 later included (as on MORE/BSD 4.3). */
172 #if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__)
173 # include <limits.h>
174 #endif
175
176 #ifndef _POSIX_PATH_MAX
177 # define _POSIX_PATH_MAX 255
178 #endif
179
180 #if !defined PATH_MAX && defined _PC_PATH_MAX
181 # define PATH_MAX (pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : pathconf ("/", _PC_PATH_MAX))
182 #endif
183
184 /* Don't include sys/param.h if it already has been. */
185 #if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN
186 # include <sys/param.h>
187 #endif
188
189 #if !defined PATH_MAX && defined MAXPATHLEN
190 # define PATH_MAX MAXPATHLEN
191 #endif
192
193 #ifndef PATH_MAX
194 # define PATH_MAX _POSIX_PATH_MAX
195 #endif
196
197 /* Pathname support.
198 ISSLASH(C) tests whether C is a directory separator character.
199 IS_ABSOLUTE_PATH(P) tests whether P is an absolute path. If it is not,
200 it may be concatenated to a directory pathname.
201 IS_PATH_WITH_DIR(P) tests whether P contains a directory specification.
202 */
203 #if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__
204 /* Win32, OS/2, DOS */
205 # define ISSLASH(C) ((C) == '/' || (C) == '\\')
206 # define HAS_DEVICE(P) \
207 ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
208 && (P)[1] == ':')
209 # define IS_ABSOLUTE_PATH(P) (ISSLASH ((P)[0]) || HAS_DEVICE (P))
210 # define IS_PATH_WITH_DIR(P) \
211 (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
212 #else
213 /* Unix */
214 # define ISSLASH(C) ((C) == '/')
215 # define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0])
216 # define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
217 #endif
218
219 /* This is the type used for the search tree where known translations
220 are stored. */
221 struct known_translation_t
222 {
223 /* Domain in which to search. */
224 char *domainname;
225
226 /* The category. */
227 int category;
228
229 /* State of the catalog counter at the point the string was found. */
230 int counter;
231
232 /* Catalog where the string was found. */
233 struct loaded_l10nfile *domain;
234
235 /* And finally the translation. */
236 const char *translation;
237 size_t translation_length;
238
239 /* Pointer to the string in question. */
240 char msgid[ZERO];
241 };
242
243 /* Root of the search tree with known translations. We can use this
244 only if the system provides the `tsearch' function family. */
245 #if defined HAVE_TSEARCH || defined _LIBC
246 # include <search.h>
247
248 static void *root;
249
250 # ifdef _LIBC
251 # define tsearch __tsearch
252 # endif
253
254 /* Function to compare two entries in the table of known translations. */
255 static int
256 transcmp (const void *p1, const void *p2)
257 {
258 const struct known_translation_t *s1;
259 const struct known_translation_t *s2;
260 int result;
261
262 s1 = (const struct known_translation_t *) p1;
263 s2 = (const struct known_translation_t *) p2;
264
265 result = strcmp (s1->msgid, s2->msgid);
266 if (result == 0)
267 {
268 result = strcmp (s1->domainname, s2->domainname);
269 if (result == 0)
270 /* We compare the category last (though this is the cheapest
271 operation) since it is hopefully always the same (namely
272 LC_MESSAGES). */
273 result = s1->category - s2->category;
274 }
275
276 return result;
277 }
278 #endif
279
280 #ifndef INTVARDEF
281 # define INTVARDEF(name)
282 #endif
283 #ifndef INTUSE
284 # define INTUSE(name) name
285 #endif
286
287 /* Name of the default domain used for gettext(3) prior any call to
288 textdomain(3). The default value for this is "messages". */
289 const char _nl_default_default_domain[] attribute_hidden = "messages";
290
291 /* Value used as the default domain for gettext(3). */
292 const char *_nl_current_default_domain attribute_hidden
293 = _nl_default_default_domain;
294
295 /* Contains the default location of the message catalogs. */
296 #if defined __EMX__
297 extern const char _nl_default_dirname[];
298 #else
299 const char _nl_default_dirname[] = LOCALEDIR;
300 INTVARDEF (_nl_default_dirname)
301 #endif
302
303 /* List with bindings of specific domains created by bindtextdomain()
304 calls. */
305 struct binding *_nl_domain_bindings;
306
307 /* Prototypes for local functions. */
308 static char *plural_lookup (struct loaded_l10nfile *domain,
309 unsigned long int n,
310 const char *translation, size_t translation_len)
311 internal_function;
312 static const char *guess_category_value (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 (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 (const char *domainname, const char *msgid1, const char *msgid2,
428 int plural, unsigned long int n, int category)
429 {
430 #ifndef HAVE_ALLOCA
431 struct block_list *block_list = NULL;
432 #endif
433 struct loaded_l10nfile *domain;
434 struct binding *binding;
435 const char *categoryname;
436 const char *categoryvalue;
437 char *dirname, *xdomainname;
438 char *single_locale;
439 char *retval;
440 size_t retlen;
441 int saved_errno;
442 #if defined HAVE_TSEARCH || defined _LIBC
443 struct known_translation_t *search;
444 struct known_translation_t **foundp = NULL;
445 size_t msgid_len;
446 #endif
447 size_t domainname_len;
448
449 /* If no real MSGID is given return NULL. */
450 if (msgid1 == NULL)
451 return NULL;
452
453 #ifdef _LIBC
454 if (category < 0 || category >= __LC_LAST || category == LC_ALL)
455 /* Bogus. */
456 return (plural == 0
457 ? (char *) msgid1
458 /* Use the Germanic plural rule. */
459 : n == 1 ? (char *) msgid1 : (char *) msgid2);
460 #endif
461
462 __libc_rwlock_rdlock (_nl_state_lock);
463
464 /* If DOMAINNAME is NULL, we are interested in the default domain. If
465 CATEGORY is not LC_MESSAGES this might not make much sense but the
466 definition left this undefined. */
467 if (domainname == NULL)
468 domainname = _nl_current_default_domain;
469
470 /* OS/2 specific: backward compatibility with older libintl versions */
471 #ifdef LC_MESSAGES_COMPAT
472 if (category == LC_MESSAGES_COMPAT)
473 category = LC_MESSAGES;
474 #endif
475
476 #if defined HAVE_TSEARCH || defined _LIBC
477 msgid_len = strlen (msgid1) + 1;
478
479 /* Try to find the translation among those which we found at
480 some time. */
481 search = (struct known_translation_t *)
482 alloca (offsetof (struct known_translation_t, msgid) + msgid_len);
483 memcpy (search->msgid, msgid1, msgid_len);
484 search->domainname = (char *) domainname;
485 search->category = category;
486
487 foundp = (struct known_translation_t **) tfind (search, &root, transcmp);
488 freea (search);
489 if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
490 {
491 /* Now deal with plural. */
492 if (plural)
493 retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation,
494 (*foundp)->translation_length);
495 else
496 retval = (char *) (*foundp)->translation;
497
498 __libc_rwlock_unlock (_nl_state_lock);
499 return retval;
500 }
501 #endif
502
503 /* Preserve the `errno' value. */
504 saved_errno = errno;
505
506 /* See whether this is a SUID binary or not. */
507 DETERMINE_SECURE;
508
509 /* First find matching binding. */
510 for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
511 {
512 int compare = strcmp (domainname, binding->domainname);
513 if (compare == 0)
514 /* We found it! */
515 break;
516 if (compare < 0)
517 {
518 /* It is not in the list. */
519 binding = NULL;
520 break;
521 }
522 }
523
524 if (binding == NULL)
525 dirname = (char *) INTUSE(_nl_default_dirname);
526 else if (IS_ABSOLUTE_PATH (binding->dirname))
527 dirname = binding->dirname;
528 else
529 {
530 /* We have a relative path. Make it absolute now. */
531 size_t dirname_len = strlen (binding->dirname) + 1;
532 size_t path_max;
533 char *ret;
534
535 path_max = (unsigned int) PATH_MAX;
536 path_max += 2; /* The getcwd docs say to do this. */
537
538 for (;;)
539 {
540 dirname = (char *) alloca (path_max + dirname_len);
541 ADD_BLOCK (block_list, dirname);
542
543 __set_errno (0);
544 ret = getcwd (dirname, path_max);
545 if (ret != NULL || errno != ERANGE)
546 break;
547
548 path_max += path_max / 2;
549 path_max += PATH_INCR;
550 }
551
552 if (ret == NULL)
553 /* We cannot get the current working directory. Don't signal an
554 error but simply return the default string. */
555 goto return_untranslated;
556
557 stpcpy (stpcpy (strchr (dirname, '\0'), "/"), binding->dirname);
558 }
559
560 /* Now determine the symbolic name of CATEGORY and its value. */
561 categoryname = category_to_name (category);
562 categoryvalue = guess_category_value (category, categoryname);
563
564 domainname_len = strlen (domainname);
565 xdomainname = (char *) alloca (strlen (categoryname)
566 + domainname_len + 5);
567 ADD_BLOCK (block_list, xdomainname);
568
569 stpcpy (mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"),
570 domainname, domainname_len),
571 ".mo");
572
573 /* Creating working area. */
574 single_locale = (char *) alloca (strlen (categoryvalue) + 1);
575 ADD_BLOCK (block_list, single_locale);
576
577
578 /* Search for the given string. This is a loop because we perhaps
579 got an ordered list of languages to consider for the translation. */
580 while (1)
581 {
582 /* Make CATEGORYVALUE point to the next element of the list. */
583 while (categoryvalue[0] != '\0' && categoryvalue[0] == ':')
584 ++categoryvalue;
585 if (categoryvalue[0] == '\0')
586 {
587 /* The whole contents of CATEGORYVALUE has been searched but
588 no valid entry has been found. We solve this situation
589 by implicitly appending a "C" entry, i.e. no translation
590 will take place. */
591 single_locale[0] = 'C';
592 single_locale[1] = '\0';
593 }
594 else
595 {
596 char *cp = single_locale;
597 while (categoryvalue[0] != '\0' && categoryvalue[0] != ':')
598 *cp++ = *categoryvalue++;
599 *cp = '\0';
600
601 /* When this is a SUID binary we must not allow accessing files
602 outside the dedicated directories. */
603 if (ENABLE_SECURE && IS_PATH_WITH_DIR (single_locale))
604 /* Ingore this entry. */
605 continue;
606 }
607
608 /* If the current locale value is C (or POSIX) we don't load a
609 domain. Return the MSGID. */
610 if (strcmp (single_locale, "C") == 0
611 || strcmp (single_locale, "POSIX") == 0)
612 break;
613
614 /* Find structure describing the message catalog matching the
615 DOMAINNAME and CATEGORY. */
616 domain = _nl_find_domain (dirname, single_locale, xdomainname, binding);
617
618 if (domain != NULL)
619 {
620 retval = _nl_find_msg (domain, binding, msgid1, &retlen);
621
622 if (retval == NULL)
623 {
624 int cnt;
625
626 for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
627 {
628 retval = _nl_find_msg (domain->successor[cnt], binding,
629 msgid1, &retlen);
630
631 if (retval != NULL)
632 {
633 domain = domain->successor[cnt];
634 break;
635 }
636 }
637 }
638
639 if (retval != NULL)
640 {
641 /* Found the translation of MSGID1 in domain DOMAIN:
642 starting at RETVAL, RETLEN bytes. */
643 FREE_BLOCKS (block_list);
644 #if defined HAVE_TSEARCH || defined _LIBC
645 if (foundp == NULL)
646 {
647 /* Create a new entry and add it to the search tree. */
648 struct known_translation_t *newp;
649
650 newp = (struct known_translation_t *)
651 malloc (offsetof (struct known_translation_t, msgid)
652 + msgid_len + domainname_len + 1);
653 if (newp != NULL)
654 {
655 newp->domainname =
656 mempcpy (newp->msgid, msgid1, msgid_len);
657 memcpy (newp->domainname, domainname, domainname_len + 1);
658 newp->category = category;
659 newp->counter = _nl_msg_cat_cntr;
660 newp->domain = domain;
661 newp->translation = retval;
662 newp->translation_length = retlen;
663
664 /* Insert the entry in the search tree. */
665 foundp = (struct known_translation_t **)
666 tsearch (newp, &root, transcmp);
667 if (foundp == NULL
668 || __builtin_expect (*foundp != newp, 0))
669 /* The insert failed. */
670 free (newp);
671 }
672 }
673 else
674 {
675 /* We can update the existing entry. */
676 (*foundp)->counter = _nl_msg_cat_cntr;
677 (*foundp)->domain = domain;
678 (*foundp)->translation = retval;
679 (*foundp)->translation_length = retlen;
680 }
681 #endif
682 __set_errno (saved_errno);
683
684 /* Now deal with plural. */
685 if (plural)
686 retval = plural_lookup (domain, n, retval, retlen);
687
688 __libc_rwlock_unlock (_nl_state_lock);
689 return retval;
690 }
691 }
692 }
693
694 return_untranslated:
695 /* Return the untranslated MSGID. */
696 FREE_BLOCKS (block_list);
697 __libc_rwlock_unlock (_nl_state_lock);
698 #ifndef _LIBC
699 if (!ENABLE_SECURE)
700 {
701 extern void _nl_log_untranslated (const char *logfilename,
702 const char *domainname,
703 const char *msgid1, const char *msgid2,
704 int plural);
705 const char *logfilename = getenv ("GETTEXT_LOG_UNTRANSLATED");
706
707 if (logfilename != NULL && logfilename[0] != '\0')
708 _nl_log_untranslated (logfilename, domainname, msgid1, msgid2, plural);
709 }
710 #endif
711 __set_errno (saved_errno);
712 return (plural == 0
713 ? (char *) msgid1
714 /* Use the Germanic plural rule. */
715 : n == 1 ? (char *) msgid1 : (char *) msgid2);
716 }
717
718
719 char *
720 internal_function
721 _nl_find_msg (struct loaded_l10nfile *domain_file,
722 struct binding *domainbinding, const char *msgid,
723 size_t *lengthp)
724 {
725 struct loaded_domain *domain;
726 nls_uint32 nstrings;
727 size_t act;
728 char *result;
729 size_t resultlen;
730
731 if (domain_file->decided == 0)
732 _nl_load_domain (domain_file, domainbinding);
733
734 if (domain_file->data == NULL)
735 return NULL;
736
737 domain = (struct loaded_domain *) domain_file->data;
738
739 nstrings = domain->nstrings;
740
741 /* Locate the MSGID and its translation. */
742 if (domain->hash_tab != NULL)
743 {
744 /* Use the hashing table. */
745 nls_uint32 len = strlen (msgid);
746 nls_uint32 hash_val = hash_string (msgid);
747 nls_uint32 idx = hash_val % domain->hash_size;
748 nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));
749
750 while (1)
751 {
752 nls_uint32 nstr =
753 W (domain->must_swap_hash_tab, domain->hash_tab[idx]);
754
755 if (nstr == 0)
756 /* Hash table entry is empty. */
757 return NULL;
758
759 nstr--;
760
761 /* Compare msgid with the original string at index nstr.
762 We compare the lengths with >=, not ==, because plural entries
763 are represented by strings with an embedded NUL. */
764 if (nstr < nstrings
765 ? W (domain->must_swap, domain->orig_tab[nstr].length) >= len
766 && (strcmp (msgid,
767 domain->data + W (domain->must_swap,
768 domain->orig_tab[nstr].offset))
769 == 0)
770 : domain->orig_sysdep_tab[nstr - nstrings].length > len
771 && (strcmp (msgid,
772 domain->orig_sysdep_tab[nstr - nstrings].pointer)
773 == 0))
774 {
775 act = nstr;
776 goto found;
777 }
778
779 if (idx >= domain->hash_size - incr)
780 idx -= domain->hash_size - incr;
781 else
782 idx += incr;
783 }
784 /* NOTREACHED */
785 }
786 else
787 {
788 /* Try the default method: binary search in the sorted array of
789 messages. */
790 size_t top, bottom;
791
792 bottom = 0;
793 top = nstrings;
794 while (bottom < top)
795 {
796 int cmp_val;
797
798 act = (bottom + top) / 2;
799 cmp_val = strcmp (msgid, (domain->data
800 + W (domain->must_swap,
801 domain->orig_tab[act].offset)));
802 if (cmp_val < 0)
803 top = act;
804 else if (cmp_val > 0)
805 bottom = act + 1;
806 else
807 goto found;
808 }
809 /* No translation was found. */
810 return NULL;
811 }
812
813 found:
814 /* The translation was found at index ACT. If we have to convert the
815 string to use a different character set, this is the time. */
816 if (act < nstrings)
817 {
818 result = (char *)
819 (domain->data + W (domain->must_swap, domain->trans_tab[act].offset));
820 resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
821 }
822 else
823 {
824 result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer;
825 resultlen = domain->trans_sysdep_tab[act - nstrings].length;
826 }
827
828 #if defined _LIBC || HAVE_ICONV
829 if (domain->codeset_cntr
830 != (domainbinding != NULL ? domainbinding->codeset_cntr : 0))
831 {
832 /* The domain's codeset has changed through bind_textdomain_codeset()
833 since the message catalog was initialized or last accessed. We
834 have to reinitialize the converter. */
835 _nl_free_domain_conv (domain);
836 _nl_init_domain_conv (domain_file, domain, domainbinding);
837 }
838
839 if (
840 # ifdef _LIBC
841 domain->conv != (__gconv_t) -1
842 # else
843 # if HAVE_ICONV
844 domain->conv != (iconv_t) -1
845 # endif
846 # endif
847 )
848 {
849 /* We are supposed to do a conversion. First allocate an
850 appropriate table with the same structure as the table
851 of translations in the file, where we can put the pointers
852 to the converted strings in.
853 There is a slight complication with plural entries. They
854 are represented by consecutive NUL terminated strings. We
855 handle this case by converting RESULTLEN bytes, including
856 NULs. */
857
858 if (domain->conv_tab == NULL
859 && ((domain->conv_tab =
860 (char **) calloc (nstrings + domain->n_sysdep_strings,
861 sizeof (char *)))
862 == NULL))
863 /* Mark that we didn't succeed allocating a table. */
864 domain->conv_tab = (char **) -1;
865
866 if (__builtin_expect (domain->conv_tab == (char **) -1, 0))
867 /* Nothing we can do, no more memory. */
868 goto converted;
869
870 if (domain->conv_tab[act] == NULL)
871 {
872 /* We haven't used this string so far, so it is not
873 translated yet. Do this now. */
874 /* We use a bit more efficient memory handling.
875 We allocate always larger blocks which get used over
876 time. This is faster than many small allocations. */
877 __libc_lock_define_initialized (static, lock)
878 # define INITIAL_BLOCK_SIZE 4080
879 static unsigned char *freemem;
880 static size_t freemem_size;
881
882 const unsigned char *inbuf;
883 unsigned char *outbuf;
884 int malloc_count;
885 # ifndef _LIBC
886 transmem_block_t *transmem_list = NULL;
887 # endif
888
889 __libc_lock_lock (lock);
890
891 inbuf = (const unsigned char *) result;
892 outbuf = freemem + sizeof (size_t);
893
894 malloc_count = 0;
895 while (1)
896 {
897 transmem_block_t *newmem;
898 # ifdef _LIBC
899 size_t non_reversible;
900 int res;
901
902 if (freemem_size < sizeof (size_t))
903 goto resize_freemem;
904
905 res = __gconv (domain->conv,
906 &inbuf, inbuf + resultlen,
907 &outbuf,
908 outbuf + freemem_size - sizeof (size_t),
909 &non_reversible);
910
911 if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
912 break;
913
914 if (res != __GCONV_FULL_OUTPUT)
915 {
916 __libc_lock_unlock (lock);
917 goto converted;
918 }
919
920 inbuf = result;
921 # else
922 # if HAVE_ICONV
923 const char *inptr = (const char *) inbuf;
924 size_t inleft = resultlen;
925 char *outptr = (char *) outbuf;
926 size_t outleft;
927
928 if (freemem_size < sizeof (size_t))
929 goto resize_freemem;
930
931 outleft = freemem_size - sizeof (size_t);
932 if (iconv (domain->conv,
933 (ICONV_CONST char **) &inptr, &inleft,
934 &outptr, &outleft)
935 != (size_t) (-1))
936 {
937 outbuf = (unsigned char *) outptr;
938 break;
939 }
940 if (errno != E2BIG)
941 {
942 __libc_lock_unlock (lock);
943 goto converted;
944 }
945 # endif
946 # endif
947
948 resize_freemem:
949 /* We must allocate a new buffer or resize the old one. */
950 if (malloc_count > 0)
951 {
952 ++malloc_count;
953 freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
954 newmem = (transmem_block_t *) realloc (transmem_list,
955 freemem_size);
956 # ifdef _LIBC
957 if (newmem != NULL)
958 transmem_list = transmem_list->next;
959 else
960 {
961 struct transmem_list *old = transmem_list;
962
963 transmem_list = transmem_list->next;
964 free (old);
965 }
966 # endif
967 }
968 else
969 {
970 malloc_count = 1;
971 freemem_size = INITIAL_BLOCK_SIZE;
972 newmem = (transmem_block_t *) malloc (freemem_size);
973 }
974 if (__builtin_expect (newmem == NULL, 0))
975 {
976 freemem = NULL;
977 freemem_size = 0;
978 __libc_lock_unlock (lock);
979 goto converted;
980 }
981
982 # ifdef _LIBC
983 /* Add the block to the list of blocks we have to free
984 at some point. */
985 newmem->next = transmem_list;
986 transmem_list = newmem;
987
988 freemem = newmem->data;
989 freemem_size -= offsetof (struct transmem_list, data);
990 # else
991 transmem_list = newmem;
992 freemem = newmem;
993 # endif
994
995 outbuf = freemem + sizeof (size_t);
996 }
997
998 /* We have now in our buffer a converted string. Put this
999 into the table of conversions. */
1000 *(size_t *) freemem = outbuf - freemem - sizeof (size_t);
1001 domain->conv_tab[act] = (char *) freemem;
1002 /* Shrink freemem, but keep it aligned. */
1003 freemem_size -= outbuf - freemem;
1004 freemem = outbuf;
1005 freemem += freemem_size & (alignof (size_t) - 1);
1006 freemem_size = freemem_size & ~ (alignof (size_t) - 1);
1007
1008 __libc_lock_unlock (lock);
1009 }
1010
1011 /* Now domain->conv_tab[act] contains the translation of all
1012 the plural variants. */
1013 result = domain->conv_tab[act] + sizeof (size_t);
1014 resultlen = *(size_t *) domain->conv_tab[act];
1015 }
1016
1017 converted:
1018 /* The result string is converted. */
1019
1020 #endif /* _LIBC || HAVE_ICONV */
1021
1022 *lengthp = resultlen;
1023 return result;
1024 }
1025
1026
1027 /* Look up a plural variant. */
1028 static char *
1029 internal_function
1030 plural_lookup (struct loaded_l10nfile *domain, unsigned long int n,
1031 const char *translation, size_t translation_len)
1032 {
1033 struct loaded_domain *domaindata = (struct loaded_domain *) domain->data;
1034 unsigned long int index;
1035 const char *p;
1036
1037 index = plural_eval (domaindata->plural, n);
1038 if (index >= domaindata->nplurals)
1039 /* This should never happen. It means the plural expression and the
1040 given maximum value do not match. */
1041 index = 0;
1042
1043 /* Skip INDEX strings at TRANSLATION. */
1044 p = translation;
1045 while (index-- > 0)
1046 {
1047 #ifdef _LIBC
1048 p = __rawmemchr (p, '\0');
1049 #else
1050 p = strchr (p, '\0');
1051 #endif
1052 /* And skip over the NUL byte. */
1053 p++;
1054
1055 if (p >= translation + translation_len)
1056 /* This should never happen. It means the plural expression
1057 evaluated to a value larger than the number of variants
1058 available for MSGID1. */
1059 return (char *) translation;
1060 }
1061 return (char *) p;
1062 }
1063
1064 #ifndef _LIBC
1065 /* Return string representation of locale CATEGORY. */
1066 static const char *
1067 internal_function
1068 category_to_name (int category)
1069 {
1070 const char *retval;
1071
1072 switch (category)
1073 {
1074 #ifdef LC_COLLATE
1075 case LC_COLLATE:
1076 retval = "LC_COLLATE";
1077 break;
1078 #endif
1079 #ifdef LC_CTYPE
1080 case LC_CTYPE:
1081 retval = "LC_CTYPE";
1082 break;
1083 #endif
1084 #ifdef LC_MONETARY
1085 case LC_MONETARY:
1086 retval = "LC_MONETARY";
1087 break;
1088 #endif
1089 #ifdef LC_NUMERIC
1090 case LC_NUMERIC:
1091 retval = "LC_NUMERIC";
1092 break;
1093 #endif
1094 #ifdef LC_TIME
1095 case LC_TIME:
1096 retval = "LC_TIME";
1097 break;
1098 #endif
1099 #ifdef LC_MESSAGES
1100 case LC_MESSAGES:
1101 retval = "LC_MESSAGES";
1102 break;
1103 #endif
1104 #ifdef LC_RESPONSE
1105 case LC_RESPONSE:
1106 retval = "LC_RESPONSE";
1107 break;
1108 #endif
1109 #ifdef LC_ALL
1110 case LC_ALL:
1111 /* This might not make sense but is perhaps better than any other
1112 value. */
1113 retval = "LC_ALL";
1114 break;
1115 #endif
1116 default:
1117 /* If you have a better idea for a default value let me know. */
1118 retval = "LC_XXX";
1119 }
1120
1121 return retval;
1122 }
1123 #endif
1124
1125 /* Guess value of current locale from value of the environment variables. */
1126 static const char *
1127 internal_function
1128 guess_category_value (int category, const char *categoryname)
1129 {
1130 const char *language;
1131 const char *retval;
1132
1133 /* The highest priority value is the `LANGUAGE' environment
1134 variable. But we don't use the value if the currently selected
1135 locale is the C locale. This is a GNU extension. */
1136 language = getenv ("LANGUAGE");
1137 if (language != NULL && language[0] == '\0')
1138 language = NULL;
1139
1140 /* We have to proceed with the POSIX methods of looking to `LC_ALL',
1141 `LC_xxx', and `LANG'. On some systems this can be done by the
1142 `setlocale' function itself. */
1143 #ifdef _LIBC
1144 retval = __current_locale_name (category);
1145 #else
1146 retval = _nl_locale_name (category, categoryname);
1147 #endif
1148
1149 /* Ignore LANGUAGE if the locale is set to "C" because
1150 1. "C" locale usually uses the ASCII encoding, and most international
1151 messages use non-ASCII characters. These characters get displayed
1152 as question marks (if using glibc's iconv()) or as invalid 8-bit
1153 characters (because other iconv()s refuse to convert most non-ASCII
1154 characters to ASCII). In any case, the output is ugly.
1155 2. The precise output of some programs in the "C" locale is specified
1156 by POSIX and should not depend on environment variables like
1157 "LANGUAGE". We allow such programs to use gettext(). */
1158 return language != NULL && strcmp (retval, "C") != 0 ? language : retval;
1159 }
1160
1161 /* @@ begin of epilog @@ */
1162
1163 /* We don't want libintl.a to depend on any other library. So we
1164 avoid the non-standard function stpcpy. In GNU C Library this
1165 function is available, though. Also allow the symbol HAVE_STPCPY
1166 to be defined. */
1167 #if !_LIBC && !HAVE_STPCPY
1168 static char *
1169 stpcpy (char *dest, const char *src)
1170 {
1171 while ((*dest++ = *src++) != '\0')
1172 /* Do nothing. */ ;
1173 return dest - 1;
1174 }
1175 #endif
1176
1177 #if !_LIBC && !HAVE_MEMPCPY
1178 static void *
1179 mempcpy (void *dest, const void *src, size_t n)
1180 {
1181 return (void *) ((char *) memcpy (dest, src, n) + n);
1182 }
1183 #endif
1184
1185
1186 #ifdef _LIBC
1187 /* If we want to free all resources we have to do some work at
1188 program's end. */
1189 libc_freeres_fn (free_mem)
1190 {
1191 void *old;
1192
1193 while (_nl_domain_bindings != NULL)
1194 {
1195 struct binding *oldp = _nl_domain_bindings;
1196 _nl_domain_bindings = _nl_domain_bindings->next;
1197 if (oldp->dirname != INTUSE(_nl_default_dirname))
1198 /* Yes, this is a pointer comparison. */
1199 free (oldp->dirname);
1200 free (oldp->codeset);
1201 free (oldp);
1202 }
1203
1204 if (_nl_current_default_domain != _nl_default_default_domain)
1205 /* Yes, again a pointer comparison. */
1206 free ((char *) _nl_current_default_domain);
1207
1208 /* Remove the search tree with the known translations. */
1209 __tdestroy (root, free);
1210 root = NULL;
1211
1212 while (transmem_list != NULL)
1213 {
1214 old = transmem_list;
1215 transmem_list = transmem_list->next;
1216 free (old);
1217 }
1218 }
1219 #endif

   
Visit the ZANavi Wiki