|
0
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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 *
|
|
|
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 *
|
|
|
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. */
|
|
|
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
|
