« back to all changes in this revision
Viewing changes to intl/dcigettext.c
- browse files at revision 12
- compare with another revision
- download diff
- download tarball
- view history from revision 12
- Committer: Bazaar Package Importer
- Author(s): Luca Falavigna
- Date: 2008-11-10 22:21:49 UTC
- mfrom: (1.10.3 upstream) (5.1.2 sid)
- Revision ID: james.westby@ubuntu.com-20081110222149-pr35f3nmqy5cf52i
Tags: 0.5.21+dfsg-1ubuntu1
* Merge from Debian unstable, remaining Ubuntu changes:
- (Build-)depend on libltdl7-dev (Ubuntu-specific change).
- (Build-)depend on libltdl7-dev (Ubuntu-specific change).
added
removed
intl/dcigettext.c
1
/* Implementation of the internal dcigettext function.
2
Copyright (C) 1995-1999, 2000-2006 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
/* NL_LOCALE_NAME does not work in glibc-2.4. Ignore it. */
31
#undef HAVE_NL_LOCALE_NAME
32
33
#include <sys/types.h>
34
35
#ifdef __GNUC__
36
# define alloca __builtin_alloca
37
# define HAVE_ALLOCA 1
38
#else
39
# ifdef _MSC_VER
40
# include <malloc.h>
41
# define alloca _alloca
42
# else
43
# if defined HAVE_ALLOCA_H || defined _LIBC
44
# include <alloca.h>
45
# else
46
# ifdef _AIX
47
#pragma alloca
48
# else
49
# ifndef alloca
50
char *alloca ();
51
# endif
52
# endif
53
# endif
54
# endif
55
#endif
56
57
#include <errno.h>
58
#ifndef errno
59
extern int errno;
60
#endif
61
#ifndef __set_errno
62
# define __set_errno(val) errno = (val)
63
#endif
64
65
#include <stddef.h>
66
#include <stdlib.h>
67
#include <string.h>
68
69
#if defined HAVE_UNISTD_H || defined _LIBC
70
# include <unistd.h>
71
#endif
72
73
#include <locale.h>
74
75
#ifdef _LIBC
76
/* Guess whether integer division by zero raises signal SIGFPE.
77
Set to 1 only if you know for sure. In case of doubt, set to 0. */
78
# if defined __alpha__ || defined __arm__ || defined __i386__ \
79
|| defined __m68k__ || defined __s390__
80
# define INTDIV0_RAISES_SIGFPE 1
81
# else
82
# define INTDIV0_RAISES_SIGFPE 0
83
# endif
84
#endif
85
#if !INTDIV0_RAISES_SIGFPE
86
# include <signal.h>
87
#endif
88
89
#if defined HAVE_SYS_PARAM_H || defined _LIBC
90
# include <sys/param.h>
91
#endif
92
93
#if !defined _LIBC && HAVE_NL_LOCALE_NAME
94
# include <langinfo.h>
95
#endif
96
97
#include "gettextP.h"
98
#include "plural-exp.h"
99
#ifdef _LIBC
100
# include <libintl.h>
101
#else
102
# ifdef IN_LIBGLOCALE
103
# include <libintl.h>
104
# endif
105
# include "libgnuintl.h"
106
#endif
107
#include "hash-string.h"
108
109
/* Handle multi-threaded applications. */
110
#ifdef _LIBC
111
# include <bits/libc-lock.h>
112
# define gl_rwlock_define_initialized __libc_rwlock_define_initialized
113
# define gl_rwlock_rdlock __libc_rwlock_rdlock
114
# define gl_rwlock_wrlock __libc_rwlock_wrlock
115
# define gl_rwlock_unlock __libc_rwlock_unlock
116
#else
117
# include "lock.h"
118
#endif
119
120
/* Alignment of types. */
121
#if defined __GNUC__ && __GNUC__ >= 2
122
# define alignof(TYPE) __alignof__ (TYPE)
123
#else
124
# define alignof(TYPE) \
125
((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
126
#endif
127
128
/* The internal variables in the standalone libintl.a must have different
129
names than the internal variables in GNU libc, otherwise programs
130
using libintl.a cannot be linked statically. */
131
#if !defined _LIBC
132
# define _nl_default_default_domain libintl_nl_default_default_domain
133
# define _nl_current_default_domain libintl_nl_current_default_domain
134
# define _nl_default_dirname libintl_nl_default_dirname
135
# define _nl_domain_bindings libintl_nl_domain_bindings
136
#endif
137
138
/* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>. */
139
#ifndef offsetof
140
# define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
141
#endif
142
143
/* @@ end of prolog @@ */
144
145
#ifdef _LIBC
146
/* Rename the non ANSI C functions. This is required by the standard
147
because some ANSI C functions will require linking with this object
148
file and the name space must not be polluted. */
149
# define getcwd __getcwd
150
# ifndef stpcpy
151
# define stpcpy __stpcpy
152
# endif
153
# define tfind __tfind
154
#else
155
# if !defined HAVE_GETCWD
156
char *getwd ();
157
# define getcwd(buf, max) getwd (buf)
158
# else
159
# if VMS
160
# define getcwd(buf, max) (getcwd) (buf, max, 0)
161
# else
162
char *getcwd ();
163
# endif
164
# endif
165
# ifndef HAVE_STPCPY
166
static char *stpcpy (char *dest, const char *src);
167
# endif
168
# ifndef HAVE_MEMPCPY
169
static void *mempcpy (void *dest, const void *src, size_t n);
170
# endif
171
#endif
172
173
/* Amount to increase buffer size by in each try. */
174
#define PATH_INCR 32
175
176
/* The following is from pathmax.h. */
177
/* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define
178
PATH_MAX but might cause redefinition warnings when sys/param.h is
179
later included (as on MORE/BSD 4.3). */
180
#if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__)
181
# include <limits.h>
182
#endif
183
184
#ifndef _POSIX_PATH_MAX
185
# define _POSIX_PATH_MAX 255
186
#endif
187
188
#if !defined PATH_MAX && defined _PC_PATH_MAX
189
# define PATH_MAX (pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : pathconf ("/", _PC_PATH_MAX))
190
#endif
191
192
/* Don't include sys/param.h if it already has been. */
193
#if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN
194
# include <sys/param.h>
195
#endif
196
197
#if !defined PATH_MAX && defined MAXPATHLEN
198
# define PATH_MAX MAXPATHLEN
199
#endif
200
201
#ifndef PATH_MAX
202
# define PATH_MAX _POSIX_PATH_MAX
203
#endif
204
205
/* Pathname support.
206
ISSLASH(C) tests whether C is a directory separator character.
207
IS_ABSOLUTE_PATH(P) tests whether P is an absolute path. If it is not,
208
it may be concatenated to a directory pathname.
209
IS_PATH_WITH_DIR(P) tests whether P contains a directory specification.
210
*/
211
#if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__ || defined __EMX__ || defined __DJGPP__
212
/* Win32, Cygwin, OS/2, DOS */
213
# define ISSLASH(C) ((C) == '/' || (C) == '\\')
214
# define HAS_DEVICE(P) \
215
((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
216
&& (P)[1] == ':')
217
# define IS_ABSOLUTE_PATH(P) (ISSLASH ((P)[0]) || HAS_DEVICE (P))
218
# define IS_PATH_WITH_DIR(P) \
219
(strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
220
#else
221
/* Unix */
222
# define ISSLASH(C) ((C) == '/')
223
# define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0])
224
# define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
225
#endif
226
227
/* Whether to support different locales in different threads. */
228
#if defined _LIBC || HAVE_NL_LOCALE_NAME || (HAVE_STRUCT___LOCALE_STRUCT___NAMES && defined USE_IN_GETTEXT_TESTS) || defined IN_LIBGLOCALE
229
# define HAVE_PER_THREAD_LOCALE
230
#endif
231
232
/* This is the type used for the search tree where known translations
233
are stored. */
234
struct known_translation_t
235
{
236
/* Domain in which to search. */
237
const char *domainname;
238
239
/* The category. */
240
int category;
241
242
#ifdef HAVE_PER_THREAD_LOCALE
243
/* Name of the relevant locale category, or "" for the global locale. */
244
const char *localename;
245
#endif
246
247
#ifdef IN_LIBGLOCALE
248
/* The character encoding. */
249
const char *encoding;
250
#endif
251
252
/* State of the catalog counter at the point the string was found. */
253
int counter;
254
255
/* Catalog where the string was found. */
256
struct loaded_l10nfile *domain;
257
258
/* And finally the translation. */
259
const char *translation;
260
size_t translation_length;
261
262
/* Pointer to the string in question. */
263
char msgid[ZERO];
264
};
265
266
/* Root of the search tree with known translations. We can use this
267
only if the system provides the `tsearch' function family. */
268
#if defined HAVE_TSEARCH || defined _LIBC
269
# include <search.h>
270
271
gl_rwlock_define_initialized (static, tree_lock)
272
273
static void *root;
274
275
# ifdef _LIBC
276
# define tsearch __tsearch
277
# endif
278
279
/* Function to compare two entries in the table of known translations. */
280
static int
281
transcmp (const void *p1, const void *p2)
282
{
283
const struct known_translation_t *s1;
284
const struct known_translation_t *s2;
285
int result;
286
287
s1 = (const struct known_translation_t *) p1;
288
s2 = (const struct known_translation_t *) p2;
289
290
result = strcmp (s1->msgid, s2->msgid);
291
if (result == 0)
292
{
293
result = strcmp (s1->domainname, s2->domainname);
294
if (result == 0)
295
{
296
#ifdef HAVE_PER_THREAD_LOCALE
297
result = strcmp (s1->localename, s2->localename);
298
if (result == 0)
299
#endif
300
{
301
#ifdef IN_LIBGLOCALE
302
result = strcmp (s1->encoding, s2->encoding);
303
if (result == 0)
304
#endif
305
/* We compare the category last (though this is the cheapest
306
operation) since it is hopefully always the same (namely
307
LC_MESSAGES). */
308
result = s1->category - s2->category;
309
}
310
}
311
}
312
313
return result;
314
}
315
#endif
316
317
/* Name of the default domain used for gettext(3) prior any call to
318
textdomain(3). The default value for this is "messages". */
319
const char _nl_default_default_domain[] attribute_hidden = "messages";
320
321
#ifndef IN_LIBGLOCALE
322
/* Value used as the default domain for gettext(3). */
323
const char *_nl_current_default_domain attribute_hidden
324
= _nl_default_default_domain;
325
#endif
326
327
/* Contains the default location of the message catalogs. */
328
#if defined __EMX__
329
extern const char _nl_default_dirname[];
330
#else
331
# ifdef _LIBC
332
extern const char _nl_default_dirname[];
333
libc_hidden_proto (_nl_default_dirname)
334
# endif
335
const char _nl_default_dirname[] = LOCALEDIR;
336
# ifdef _LIBC
337
libc_hidden_data_def (_nl_default_dirname)
338
# endif
339
#endif
340
341
#ifndef IN_LIBGLOCALE
342
/* List with bindings of specific domains created by bindtextdomain()
343
calls. */
344
struct binding *_nl_domain_bindings;
345
#endif
346
347
/* Prototypes for local functions. */
348
static char *plural_lookup (struct loaded_l10nfile *domain,
349
unsigned long int n,
350
const char *translation, size_t translation_len)
351
internal_function;
352
353
#ifdef IN_LIBGLOCALE
354
static const char *guess_category_value (int category,
355
const char *categoryname,
356
const char *localename)
357
internal_function;
358
#else
359
static const char *guess_category_value (int category,
360
const char *categoryname)
361
internal_function;
362
#endif
363
364
#ifdef _LIBC
365
# include "../locale/localeinfo.h"
366
# define category_to_name(category) \
367
_nl_category_names.str + _nl_category_name_idxs[category]
368
#else
369
static const char *category_to_name (int category) internal_function;
370
#endif
371
#if (defined _LIBC || HAVE_ICONV) && !defined IN_LIBGLOCALE
372
static const char *get_output_charset (struct binding *domainbinding)
373
internal_function;
374
#endif
375
376
377
/* For those loosing systems which don't have `alloca' we have to add
378
some additional code emulating it. */
379
#ifdef HAVE_ALLOCA
380
/* Nothing has to be done. */
381
# define freea(p) /* nothing */
382
# define ADD_BLOCK(list, address) /* nothing */
383
# define FREE_BLOCKS(list) /* nothing */
384
#else
385
struct block_list
386
{
387
void *address;
388
struct block_list *next;
389
};
390
# define ADD_BLOCK(list, addr) \
391
do { \
392
struct block_list *newp = (struct block_list *) malloc (sizeof (*newp)); \
393
/* If we cannot get a free block we cannot add the new element to \
394
the list. */ \
395
if (newp != NULL) { \
396
newp->address = (addr); \
397
newp->next = (list); \
398
(list) = newp; \
399
} \
400
} while (0)
401
# define FREE_BLOCKS(list) \
402
do { \
403
while (list != NULL) { \
404
struct block_list *old = list; \
405
list = list->next; \
406
free (old->address); \
407
free (old); \
408
} \
409
} while (0)
410
# undef alloca
411
# define alloca(size) (malloc (size))
412
# define freea(p) free (p)
413
#endif /* have alloca */
414
415
416
#ifdef _LIBC
417
/* List of blocks allocated for translations. */
418
typedef struct transmem_list
419
{
420
struct transmem_list *next;
421
char data[ZERO];
422
} transmem_block_t;
423
static struct transmem_list *transmem_list;
424
#else
425
typedef unsigned char transmem_block_t;
426
#endif
427
428
429
/* Names for the libintl functions are a problem. They must not clash
430
with existing names and they should follow ANSI C. But this source
431
code is also used in GNU C Library where the names have a __
432
prefix. So we have to make a difference here. */
433
#ifdef _LIBC
434
# define DCIGETTEXT __dcigettext
435
#else
436
# define DCIGETTEXT libintl_dcigettext
437
#endif
438
439
/* Lock variable to protect the global data in the gettext implementation. */
440
gl_rwlock_define_initialized (, _nl_state_lock attribute_hidden)
441
442
/* Checking whether the binaries runs SUID must be done and glibc provides
443
easier methods therefore we make a difference here. */
444
#ifdef _LIBC
445
# define ENABLE_SECURE __libc_enable_secure
446
# define DETERMINE_SECURE
447
#else
448
# ifndef HAVE_GETUID
449
# define getuid() 0
450
# endif
451
# ifndef HAVE_GETGID
452
# define getgid() 0
453
# endif
454
# ifndef HAVE_GETEUID
455
# define geteuid() getuid()
456
# endif
457
# ifndef HAVE_GETEGID
458
# define getegid() getgid()
459
# endif
460
static int enable_secure;
461
# define ENABLE_SECURE (enable_secure == 1)
462
# define DETERMINE_SECURE \
463
if (enable_secure == 0) \
464
{ \
465
if (getuid () != geteuid () || getgid () != getegid ()) \
466
enable_secure = 1; \
467
else \
468
enable_secure = -1; \
469
}
470
#endif
471
472
/* Get the function to evaluate the plural expression. */
473
#include "eval-plural.h"
474
475
/* Look up MSGID in the DOMAINNAME message catalog for the current
476
CATEGORY locale and, if PLURAL is nonzero, search over string
477
depending on the plural form determined by N. */
478
#ifdef IN_LIBGLOCALE
479
char *
480
gl_dcigettext (const char *domainname,
481
const char *msgid1, const char *msgid2,
482
int plural, unsigned long int n,
483
int category,
484
const char *localename, const char *encoding)
485
#else
486
char *
487
DCIGETTEXT (const char *domainname, const char *msgid1, const char *msgid2,
488
int plural, unsigned long int n, int category)
489
#endif
490
{
491
#ifndef HAVE_ALLOCA
492
struct block_list *block_list = NULL;
493
#endif
494
struct loaded_l10nfile *domain;
495
struct binding *binding;
496
const char *categoryname;
497
const char *categoryvalue;
498
const char *dirname;
499
char *xdomainname;
500
char *single_locale;
501
char *retval;
502
size_t retlen;
503
int saved_errno;
504
#if defined HAVE_TSEARCH || defined _LIBC
505
struct known_translation_t *search;
506
struct known_translation_t **foundp = NULL;
507
size_t msgid_len;
508
# if defined HAVE_PER_THREAD_LOCALE && !defined IN_LIBGLOCALE
509
const char *localename;
510
# endif
511
#endif
512
size_t domainname_len;
513
514
/* If no real MSGID is given return NULL. */
515
if (msgid1 == NULL)
516
return NULL;
517
518
#ifdef _LIBC
519
if (category < 0 || category >= __LC_LAST || category == LC_ALL)
520
/* Bogus. */
521
return (plural == 0
522
? (char *) msgid1
523
/* Use the Germanic plural rule. */
524
: n == 1 ? (char *) msgid1 : (char *) msgid2);
525
#endif
526
527
gl_rwlock_rdlock (_nl_state_lock);
528
529
/* If DOMAINNAME is NULL, we are interested in the default domain. If
530
CATEGORY is not LC_MESSAGES this might not make much sense but the
531
definition left this undefined. */
532
if (domainname == NULL)
533
domainname = _nl_current_default_domain;
534
535
/* OS/2 specific: backward compatibility with older libintl versions */
536
#ifdef LC_MESSAGES_COMPAT
537
if (category == LC_MESSAGES_COMPAT)
538
category = LC_MESSAGES;
539
#endif
540
541
#if defined HAVE_TSEARCH || defined _LIBC
542
msgid_len = strlen (msgid1) + 1;
543
544
/* Try to find the translation among those which we found at
545
some time. */
546
search = (struct known_translation_t *)
547
alloca (offsetof (struct known_translation_t, msgid) + msgid_len);
548
memcpy (search->msgid, msgid1, msgid_len);
549
search->domainname = domainname;
550
search->category = category;
551
# ifdef HAVE_PER_THREAD_LOCALE
552
# ifndef IN_LIBGLOCALE
553
# ifdef _LIBC
554
localename = __current_locale_name (category);
555
# else
556
# if HAVE_NL_LOCALE_NAME
557
/* NL_LOCALE_NAME is public glibc API introduced in glibc-2.4. */
558
localename = nl_langinfo (NL_LOCALE_NAME (category));
559
# else
560
# if HAVE_STRUCT___LOCALE_STRUCT___NAMES && defined USE_IN_GETTEXT_TESTS
561
/* The __names field is not public glibc API and must therefore not be used
562
in code that is installed in public locations. */
563
{
564
locale_t thread_locale = uselocale (NULL);
565
if (thread_locale != LC_GLOBAL_LOCALE)
566
localename = thread_locale->__names[category];
567
else
568
localename = "";
569
}
570
# endif
571
# endif
572
# endif
573
# endif
574
search->localename = localename;
575
# ifdef IN_LIBGLOCALE
576
search->encoding = encoding;
577
# endif
578
# endif
579
580
/* Since tfind/tsearch manage a balanced tree, concurrent tfind and
581
tsearch calls can be fatal. */
582
gl_rwlock_rdlock (tree_lock);
583
584
foundp = (struct known_translation_t **) tfind (search, &root, transcmp);
585
586
gl_rwlock_unlock (tree_lock);
587
588
freea (search);
589
if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
590
{
591
/* Now deal with plural. */
592
if (plural)
593
retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation,
594
(*foundp)->translation_length);
595
else
596
retval = (char *) (*foundp)->translation;
597
598
gl_rwlock_unlock (_nl_state_lock);
599
return retval;
600
}
601
#endif
602
603
/* Preserve the `errno' value. */
604
saved_errno = errno;
605
606
/* See whether this is a SUID binary or not. */
607
DETERMINE_SECURE;
608
609
/* First find matching binding. */
610
#ifdef IN_LIBGLOCALE
611
/* We can use a trivial binding, since _nl_find_msg will ignore it anyway,
612
and _nl_load_domain and _nl_find_domain just pass it through. */
613
binding = NULL;
614
dirname = bindtextdomain (domainname, NULL);
615
#else
616
for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
617
{
618
int compare = strcmp (domainname, binding->domainname);
619
if (compare == 0)
620
/* We found it! */
621
break;
622
if (compare < 0)
623
{
624
/* It is not in the list. */
625
binding = NULL;
626
break;
627
}
628
}
629
630
if (binding == NULL)
631
dirname = _nl_default_dirname;
632
else
633
{
634
dirname = binding->dirname;
635
#endif
636
if (!IS_ABSOLUTE_PATH (dirname))
637
{
638
/* We have a relative path. Make it absolute now. */
639
size_t dirname_len = strlen (dirname) + 1;
640
size_t path_max;
641
char *resolved_dirname;
642
char *ret;
643
644
path_max = (unsigned int) PATH_MAX;
645
path_max += 2; /* The getcwd docs say to do this. */
646
647
for (;;)
648
{
649
resolved_dirname = (char *) alloca (path_max + dirname_len);
650
ADD_BLOCK (block_list, tmp_dirname);
651
652
__set_errno (0);
653
ret = getcwd (resolved_dirname, path_max);
654
if (ret != NULL || errno != ERANGE)
655
break;
656
657
path_max += path_max / 2;
658
path_max += PATH_INCR;
659
}
660
661
if (ret == NULL)
662
/* We cannot get the current working directory. Don't signal an
663
error but simply return the default string. */
664
goto return_untranslated;
665
666
stpcpy (stpcpy (strchr (resolved_dirname, '\0'), "/"), dirname);
667
dirname = resolved_dirname;
668
}
669
#ifndef IN_LIBGLOCALE
670
}
671
#endif
672
673
/* Now determine the symbolic name of CATEGORY and its value. */
674
categoryname = category_to_name (category);
675
#ifdef IN_LIBGLOCALE
676
categoryvalue = guess_category_value (category, categoryname, localename);
677
#else
678
categoryvalue = guess_category_value (category, categoryname);
679
#endif
680
681
domainname_len = strlen (domainname);
682
xdomainname = (char *) alloca (strlen (categoryname)
683
+ domainname_len + 5);
684
ADD_BLOCK (block_list, xdomainname);
685
686
stpcpy (mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"),
687
domainname, domainname_len),
688
".mo");
689
690
/* Creating working area. */
691
single_locale = (char *) alloca (strlen (categoryvalue) + 1);
692
ADD_BLOCK (block_list, single_locale);
693
694
695
/* Search for the given string. This is a loop because we perhaps
696
got an ordered list of languages to consider for the translation. */
697
while (1)
698
{
699
/* Make CATEGORYVALUE point to the next element of the list. */
700
while (categoryvalue[0] != '\0' && categoryvalue[0] == ':')
701
++categoryvalue;
702
if (categoryvalue[0] == '\0')
703
{
704
/* The whole contents of CATEGORYVALUE has been searched but
705
no valid entry has been found. We solve this situation
706
by implicitly appending a "C" entry, i.e. no translation
707
will take place. */
708
single_locale[0] = 'C';
709
single_locale[1] = '\0';
710
}
711
else
712
{
713
char *cp = single_locale;
714
while (categoryvalue[0] != '\0' && categoryvalue[0] != ':')
715
*cp++ = *categoryvalue++;
716
*cp = '\0';
717
718
/* When this is a SUID binary we must not allow accessing files
719
outside the dedicated directories. */
720
if (ENABLE_SECURE && IS_PATH_WITH_DIR (single_locale))
721
/* Ingore this entry. */
722
continue;
723
}
724
725
/* If the current locale value is C (or POSIX) we don't load a
726
domain. Return the MSGID. */
727
if (strcmp (single_locale, "C") == 0
728
|| strcmp (single_locale, "POSIX") == 0)
729
break;
730
731
/* Find structure describing the message catalog matching the
732
DOMAINNAME and CATEGORY. */
733
domain = _nl_find_domain (dirname, single_locale, xdomainname, binding);
734
735
if (domain != NULL)
736
{
737
#if defined IN_LIBGLOCALE
738
retval = _nl_find_msg (domain, binding, encoding, msgid1, &retlen);
739
#else
740
retval = _nl_find_msg (domain, binding, msgid1, 1, &retlen);
741
#endif
742
743
if (retval == NULL)
744
{
745
int cnt;
746
747
for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
748
{
749
#if defined IN_LIBGLOCALE
750
retval = _nl_find_msg (domain->successor[cnt], binding,
751
encoding, msgid1, &retlen);
752
#else
753
retval = _nl_find_msg (domain->successor[cnt], binding,
754
msgid1, 1, &retlen);
755
#endif
756
757
if (retval != NULL)
758
{
759
domain = domain->successor[cnt];
760
break;
761
}
762
}
763
}
764
765
/* Returning -1 means that some resource problem exists
766
(likely memory) and that the strings could not be
767
converted. Return the original strings. */
768
if (__builtin_expect (retval == (char *) -1, 0))
769
break;
770
771
if (retval != NULL)
772
{
773
/* Found the translation of MSGID1 in domain DOMAIN:
774
starting at RETVAL, RETLEN bytes. */
775
FREE_BLOCKS (block_list);
776
#if defined HAVE_TSEARCH || defined _LIBC
777
if (foundp == NULL)
778
{
779
/* Create a new entry and add it to the search tree. */
780
size_t size;
781
struct known_translation_t *newp;
782
783
size = offsetof (struct known_translation_t, msgid)
784
+ msgid_len + domainname_len + 1;
785
# ifdef HAVE_PER_THREAD_LOCALE
786
size += strlen (localename) + 1;
787
# endif
788
newp = (struct known_translation_t *) malloc (size);
789
if (newp != NULL)
790
{
791
char *new_domainname;
792
# ifdef HAVE_PER_THREAD_LOCALE
793
char *new_localename;
794
# endif
795
796
new_domainname = mempcpy (newp->msgid, msgid1, msgid_len);
797
memcpy (new_domainname, domainname, domainname_len + 1);
798
# ifdef HAVE_PER_THREAD_LOCALE
799
new_localename = new_domainname + domainname_len + 1;
800
strcpy (new_localename, localename);
801
# endif
802
newp->domainname = new_domainname;
803
newp->category = category;
804
# ifdef HAVE_PER_THREAD_LOCALE
805
newp->localename = new_localename;
806
# endif
807
# ifdef IN_LIBGLOCALE
808
newp->encoding = encoding;
809
# endif
810
newp->counter = _nl_msg_cat_cntr;
811
newp->domain = domain;
812
newp->translation = retval;
813
newp->translation_length = retlen;
814
815
gl_rwlock_wrlock (tree_lock);
816
817
/* Insert the entry in the search tree. */
818
foundp = (struct known_translation_t **)
819
tsearch (newp, &root, transcmp);
820
821
gl_rwlock_unlock (tree_lock);
822
823
if (foundp == NULL
824
|| __builtin_expect (*foundp != newp, 0))
825
/* The insert failed. */
826
free (newp);
827
}
828
}
829
else
830
{
831
/* We can update the existing entry. */
832
(*foundp)->counter = _nl_msg_cat_cntr;
833
(*foundp)->domain = domain;
834
(*foundp)->translation = retval;
835
(*foundp)->translation_length = retlen;
836
}
837
#endif
838
__set_errno (saved_errno);
839
840
/* Now deal with plural. */
841
if (plural)
842
retval = plural_lookup (domain, n, retval, retlen);
843
844
gl_rwlock_unlock (_nl_state_lock);
845
return retval;
846
}
847
}
848
}
849
850
return_untranslated:
851
/* Return the untranslated MSGID. */
852
FREE_BLOCKS (block_list);
853
gl_rwlock_unlock (_nl_state_lock);
854
#ifndef _LIBC
855
if (!ENABLE_SECURE)
856
{
857
extern void _nl_log_untranslated (const char *logfilename,
858
const char *domainname,
859
const char *msgid1, const char *msgid2,
860
int plural);
861
const char *logfilename = getenv ("GETTEXT_LOG_UNTRANSLATED");
862
863
if (logfilename != NULL && logfilename[0] != '\0')
864
_nl_log_untranslated (logfilename, domainname, msgid1, msgid2, plural);
865
}
866
#endif
867
__set_errno (saved_errno);
868
return (plural == 0
869
? (char *) msgid1
870
/* Use the Germanic plural rule. */
871
: n == 1 ? (char *) msgid1 : (char *) msgid2);
872
}
873
874
875
/* Look up the translation of msgid within DOMAIN_FILE and DOMAINBINDING.
876
Return it if found. Return NULL if not found or in case of a conversion
877
failure (problem in the particular message catalog). Return (char *) -1
878
in case of a memory allocation failure during conversion (only if
879
ENCODING != NULL resp. CONVERT == true). */
880
char *
881
internal_function
882
#ifdef IN_LIBGLOCALE
883
_nl_find_msg (struct loaded_l10nfile *domain_file,
884
struct binding *domainbinding, const char *encoding,
885
const char *msgid,
886
size_t *lengthp)
887
#else
888
_nl_find_msg (struct loaded_l10nfile *domain_file,
889
struct binding *domainbinding,
890
const char *msgid, int convert,
891
size_t *lengthp)
892
#endif
893
{
894
struct loaded_domain *domain;
895
nls_uint32 nstrings;
896
size_t act;
897
char *result;
898
size_t resultlen;
899
900
if (domain_file->decided <= 0)
901
_nl_load_domain (domain_file, domainbinding);
902
903
if (domain_file->data == NULL)
904
return NULL;
905
906
domain = (struct loaded_domain *) domain_file->data;
907
908
nstrings = domain->nstrings;
909
910
/* Locate the MSGID and its translation. */
911
if (domain->hash_tab != NULL)
912
{
913
/* Use the hashing table. */
914
nls_uint32 len = strlen (msgid);
915
nls_uint32 hash_val = __hash_string (msgid);
916
nls_uint32 idx = hash_val % domain->hash_size;
917
nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));
918
919
while (1)
920
{
921
nls_uint32 nstr =
922
W (domain->must_swap_hash_tab, domain->hash_tab[idx]);
923
924
if (nstr == 0)
925
/* Hash table entry is empty. */
926
return NULL;
927
928
nstr--;
929
930
/* Compare msgid with the original string at index nstr.
931
We compare the lengths with >=, not ==, because plural entries
932
are represented by strings with an embedded NUL. */
933
if (nstr < nstrings
934
? W (domain->must_swap, domain->orig_tab[nstr].length) >= len
935
&& (strcmp (msgid,
936
domain->data + W (domain->must_swap,
937
domain->orig_tab[nstr].offset))
938
== 0)
939
: domain->orig_sysdep_tab[nstr - nstrings].length > len
940
&& (strcmp (msgid,
941
domain->orig_sysdep_tab[nstr - nstrings].pointer)
942
== 0))
943
{
944
act = nstr;
945
goto found;
946
}
947
948
if (idx >= domain->hash_size - incr)
949
idx -= domain->hash_size - incr;
950
else
951
idx += incr;
952
}
953
/* NOTREACHED */
954
}
955
else
956
{
957
/* Try the default method: binary search in the sorted array of
958
messages. */
959
size_t top, bottom;
960
961
bottom = 0;
962
top = nstrings;
963
while (bottom < top)
964
{
965
int cmp_val;
966
967
act = (bottom + top) / 2;
968
cmp_val = strcmp (msgid, (domain->data
969
+ W (domain->must_swap,
970
domain->orig_tab[act].offset)));
971
if (cmp_val < 0)
972
top = act;
973
else if (cmp_val > 0)
974
bottom = act + 1;
975
else
976
goto found;
977
}
978
/* No translation was found. */
979
return NULL;
980
}
981
982
found:
983
/* The translation was found at index ACT. If we have to convert the
984
string to use a different character set, this is the time. */
985
if (act < nstrings)
986
{
987
result = (char *)
988
(domain->data + W (domain->must_swap, domain->trans_tab[act].offset));
989
resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
990
}
991
else
992
{
993
result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer;
994
resultlen = domain->trans_sysdep_tab[act - nstrings].length;
995
}
996
997
#if defined _LIBC || HAVE_ICONV
998
# ifdef IN_LIBGLOCALE
999
if (encoding != NULL)
1000
# else
1001
if (convert)
1002
# endif
1003
{
1004
/* We are supposed to do a conversion. */
1005
# ifndef IN_LIBGLOCALE
1006
const char *encoding = get_output_charset (domainbinding);
1007
# endif
1008
1009
/* Search whether a table with converted translations for this
1010
encoding has already been allocated. */
1011
size_t nconversions = domain->nconversions;
1012
struct converted_domain *convd = NULL;
1013
size_t i;
1014
1015
for (i = nconversions; i > 0; )
1016
{
1017
i--;
1018
if (strcmp (domain->conversions[i].encoding, encoding) == 0)
1019
{
1020
convd = &domain->conversions[i];
1021
break;
1022
}
1023
}
1024
1025
if (convd == NULL)
1026
{
1027
/* Allocate a table for the converted translations for this
1028
encoding. */
1029
struct converted_domain *new_conversions =
1030
(struct converted_domain *)
1031
(domain->conversions != NULL
1032
? realloc (domain->conversions,
1033
(nconversions + 1) * sizeof (struct converted_domain))
1034
: malloc ((nconversions + 1) * sizeof (struct converted_domain)));
1035
1036
if (__builtin_expect (new_conversions == NULL, 0))
1037
/* Nothing we can do, no more memory. We cannot use the
1038
translation because it might be encoded incorrectly. */
1039
return (char *) -1;
1040
1041
domain->conversions = new_conversions;
1042
1043
/* Copy the 'encoding' string to permanent storage. */
1044
encoding = strdup (encoding);
1045
if (__builtin_expect (encoding == NULL, 0))
1046
/* Nothing we can do, no more memory. We cannot use the
1047
translation because it might be encoded incorrectly. */
1048
return (char *) -1;
1049
1050
convd = &new_conversions[nconversions];
1051
convd->encoding = encoding;
1052
1053
/* Find out about the character set the file is encoded with.
1054
This can be found (in textual form) in the entry "". If this
1055
entry does not exist or if this does not contain the 'charset='
1056
information, we will assume the charset matches the one the
1057
current locale and we don't have to perform any conversion. */
1058
# ifdef _LIBC
1059
convd->conv = (__gconv_t) -1;
1060
# else
1061
# if HAVE_ICONV
1062
convd->conv = (iconv_t) -1;
1063
# endif
1064
# endif
1065
{
1066
char *nullentry;
1067
size_t nullentrylen;
1068
1069
/* Get the header entry. This is a recursion, but it doesn't
1070
reallocate domain->conversions because we pass
1071
encoding = NULL or convert = 0, respectively. */
1072
nullentry =
1073
# ifdef IN_LIBGLOCALE
1074
_nl_find_msg (domain_file, domainbinding, NULL, "",
1075
&nullentrylen);
1076
# else
1077
_nl_find_msg (domain_file, domainbinding, "", 0, &nullentrylen);
1078
# endif
1079
1080
if (nullentry != NULL)
1081
{
1082
const char *charsetstr;
1083
1084
charsetstr = strstr (nullentry, "charset=");
1085
if (charsetstr != NULL)
1086
{
1087
size_t len;
1088
char *charset;
1089
const char *outcharset;
1090
1091
charsetstr += strlen ("charset=");
1092
len = strcspn (charsetstr, " \t\n");
1093
1094
charset = (char *) alloca (len + 1);
1095
# if defined _LIBC || HAVE_MEMPCPY
1096
*((char *) mempcpy (charset, charsetstr, len)) = '\0';
1097
# else
1098
memcpy (charset, charsetstr, len);
1099
charset[len] = '\0';
1100
# endif
1101
1102
outcharset = encoding;
1103
1104
# ifdef _LIBC
1105
/* We always want to use transliteration. */
1106
outcharset = norm_add_slashes (outcharset, "TRANSLIT");
1107
charset = norm_add_slashes (charset, "");
1108
int r = __gconv_open (outcharset, charset, &convd->conv,
1109
GCONV_AVOID_NOCONV);
1110
if (__builtin_expect (r != __GCONV_OK, 0))
1111
{
1112
/* If the output encoding is the same there is
1113
nothing to do. Otherwise do not use the
1114
translation at all. */
1115
if (__builtin_expect (r != __GCONV_NOCONV, 1))
1116
return NULL;
1117
1118
convd->conv = (__gconv_t) -1;
1119
}
1120
# else
1121
# if HAVE_ICONV
1122
/* When using GNU libc >= 2.2 or GNU libiconv >= 1.5,
1123
we want to use transliteration. */
1124
# if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2 \
1125
|| _LIBICONV_VERSION >= 0x0105
1126
if (strchr (outcharset, '/') == NULL)
1127
{
1128
char *tmp;
1129
1130
len = strlen (outcharset);
1131
tmp = (char *) alloca (len + 10 + 1);
1132
memcpy (tmp, outcharset, len);
1133
memcpy (tmp + len, "//TRANSLIT", 10 + 1);
1134
outcharset = tmp;
1135
1136
convd->conv = iconv_open (outcharset, charset);
1137
1138
freea (outcharset);
1139
}
1140
else
1141
# endif
1142
convd->conv = iconv_open (outcharset, charset);
1143
# endif
1144
# endif
1145
1146
freea (charset);
1147
}
1148
}
1149
}
1150
convd->conv_tab = NULL;
1151
/* Here domain->conversions is still == new_conversions. */
1152
domain->nconversions++;
1153
}
1154
1155
if (
1156
# ifdef _LIBC
1157
convd->conv != (__gconv_t) -1
1158
# else
1159
# if HAVE_ICONV
1160
convd->conv != (iconv_t) -1
1161
# endif
1162
# endif
1163
)
1164
{
1165
/* We are supposed to do a conversion. First allocate an
1166
appropriate table with the same structure as the table
1167
of translations in the file, where we can put the pointers
1168
to the converted strings in.
1169
There is a slight complication with plural entries. They
1170
are represented by consecutive NUL terminated strings. We
1171
handle this case by converting RESULTLEN bytes, including
1172
NULs. */
1173
1174
if (convd->conv_tab == NULL
1175
&& ((convd->conv_tab =
1176
(char **) calloc (nstrings + domain->n_sysdep_strings,
1177
sizeof (char *)))
1178
== NULL))
1179
/* Mark that we didn't succeed allocating a table. */
1180
convd->conv_tab = (char **) -1;
1181
1182
if (__builtin_expect (convd->conv_tab == (char **) -1, 0))
1183
/* Nothing we can do, no more memory. We cannot use the
1184
translation because it might be encoded incorrectly. */
1185
return (char *) -1;
1186
1187
if (convd->conv_tab[act] == NULL)
1188
{
1189
/* We haven't used this string so far, so it is not
1190
translated yet. Do this now. */
1191
/* We use a bit more efficient memory handling.
1192
We allocate always larger blocks which get used over
1193
time. This is faster than many small allocations. */
1194
__libc_lock_define_initialized (static, lock)
1195
# define INITIAL_BLOCK_SIZE 4080
1196
static unsigned char *freemem;
1197
static size_t freemem_size;
1198
1199
const unsigned char *inbuf;
1200
unsigned char *outbuf;
1201
int malloc_count;
1202
# ifndef _LIBC
1203
transmem_block_t *transmem_list = NULL;
1204
# endif
1205
1206
__libc_lock_lock (lock);
1207
1208
inbuf = (const unsigned char *) result;
1209
outbuf = freemem + sizeof (size_t);
1210
1211
malloc_count = 0;
1212
while (1)
1213
{
1214
transmem_block_t *newmem;
1215
# ifdef _LIBC
1216
size_t non_reversible;
1217
int res;
1218
1219
if (freemem_size < sizeof (size_t))
1220
goto resize_freemem;
1221
1222
res = __gconv (convd->conv,
1223
&inbuf, inbuf + resultlen,
1224
&outbuf,
1225
outbuf + freemem_size - sizeof (size_t),
1226
&non_reversible);
1227
1228
if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
1229
break;
1230
1231
if (res != __GCONV_FULL_OUTPUT)
1232
{
1233
/* We should not use the translation at all, it
1234
is incorrectly encoded. */
1235
__libc_lock_unlock (lock);
1236
return NULL;
1237
}
1238
1239
inbuf = (const unsigned char *) result;
1240
# else
1241
# if HAVE_ICONV
1242
const char *inptr = (const char *) inbuf;
1243
size_t inleft = resultlen;
1244
char *outptr = (char *) outbuf;
1245
size_t outleft;
1246
1247
if (freemem_size < sizeof (size_t))
1248
goto resize_freemem;
1249
1250
outleft = freemem_size - sizeof (size_t);
1251
if (iconv (convd->conv,
1252
(ICONV_CONST char **) &inptr, &inleft,
1253
&outptr, &outleft)
1254
!= (size_t) (-1))
1255
{
1256
outbuf = (unsigned char *) outptr;
1257
break;
1258
}
1259
if (errno != E2BIG)
1260
{
1261
__libc_lock_unlock (lock);
1262
return NULL;
1263
}
1264
# endif
1265
# endif
1266
1267
resize_freemem:
1268
/* We must allocate a new buffer or resize the old one. */
1269
if (malloc_count > 0)
1270
{
1271
++malloc_count;
1272
freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
1273
newmem = (transmem_block_t *) realloc (transmem_list,
1274
freemem_size);
1275
# ifdef _LIBC
1276
if (newmem != NULL)
1277
transmem_list = transmem_list->next;
1278
else
1279
{
1280
struct transmem_list *old = transmem_list;
1281
1282
transmem_list = transmem_list->next;
1283
free (old);
1284
}
1285
# endif
1286
}
1287
else
1288
{
1289
malloc_count = 1;
1290
freemem_size = INITIAL_BLOCK_SIZE;
1291
newmem = (transmem_block_t *) malloc (freemem_size);
1292
}
1293
if (__builtin_expect (newmem == NULL, 0))
1294
{
1295
freemem = NULL;
1296
freemem_size = 0;
1297
__libc_lock_unlock (lock);
1298
return (char *) -1;
1299
}
1300
1301
# ifdef _LIBC
1302
/* Add the block to the list of blocks we have to free
1303
at some point. */
1304
newmem->next = transmem_list;
1305
transmem_list = newmem;
1306
1307
freemem = (unsigned char *) newmem->data;
1308
freemem_size -= offsetof (struct transmem_list, data);
1309
# else
1310
transmem_list = newmem;
1311
freemem = newmem;
1312
# endif
1313
1314
outbuf = freemem + sizeof (size_t);
1315
}
1316
1317
/* We have now in our buffer a converted string. Put this
1318
into the table of conversions. */
1319
*(size_t *) freemem = outbuf - freemem - sizeof (size_t);
1320
convd->conv_tab[act] = (char *) freemem;
1321
/* Shrink freemem, but keep it aligned. */
1322
freemem_size -= outbuf - freemem;
1323
freemem = outbuf;
1324
freemem += freemem_size & (alignof (size_t) - 1);
1325
freemem_size = freemem_size & ~ (alignof (size_t) - 1);
1326
1327
__libc_lock_unlock (lock);
1328
}
1329
1330
/* Now convd->conv_tab[act] contains the translation of all
1331
the plural variants. */
1332
result = convd->conv_tab[act] + sizeof (size_t);
1333
resultlen = *(size_t *) convd->conv_tab[act];
1334
}
1335
}
1336
1337
/* The result string is converted. */
1338
1339
#endif /* _LIBC || HAVE_ICONV */
1340
1341
*lengthp = resultlen;
1342
return result;
1343
}
1344
1345
1346
/* Look up a plural variant. */
1347
static char *
1348
internal_function
1349
plural_lookup (struct loaded_l10nfile *domain, unsigned long int n,
1350
const char *translation, size_t translation_len)
1351
{
1352
struct loaded_domain *domaindata = (struct loaded_domain *) domain->data;
1353
unsigned long int index;
1354
const char *p;
1355
1356
index = plural_eval (domaindata->plural, n);
1357
if (index >= domaindata->nplurals)
1358
/* This should never happen. It means the plural expression and the
1359
given maximum value do not match. */
1360
index = 0;
1361
1362
/* Skip INDEX strings at TRANSLATION. */
1363
p = translation;
1364
while (index-- > 0)
1365
{
1366
#ifdef _LIBC
1367
p = __rawmemchr (p, '\0');
1368
#else
1369
p = strchr (p, '\0');
1370
#endif
1371
/* And skip over the NUL byte. */
1372
p++;
1373
1374
if (p >= translation + translation_len)
1375
/* This should never happen. It means the plural expression
1376
evaluated to a value larger than the number of variants
1377
available for MSGID1. */
1378
return (char *) translation;
1379
}
1380
return (char *) p;
1381
}
1382
1383
#ifndef _LIBC
1384
/* Return string representation of locale CATEGORY. */
1385
static const char *
1386
internal_function
1387
category_to_name (int category)
1388
{
1389
const char *retval;
1390
1391
switch (category)
1392
{
1393
#ifdef LC_COLLATE
1394
case LC_COLLATE:
1395
retval = "LC_COLLATE";
1396
break;
1397
#endif
1398
#ifdef LC_CTYPE
1399
case LC_CTYPE:
1400
retval = "LC_CTYPE";
1401
break;
1402
#endif
1403
#ifdef LC_MONETARY
1404
case LC_MONETARY:
1405
retval = "LC_MONETARY";
1406
break;
1407
#endif
1408
#ifdef LC_NUMERIC
1409
case LC_NUMERIC:
1410
retval = "LC_NUMERIC";
1411
break;
1412
#endif
1413
#ifdef LC_TIME
1414
case LC_TIME:
1415
retval = "LC_TIME";
1416
break;
1417
#endif
1418
#ifdef LC_MESSAGES
1419
case LC_MESSAGES:
1420
retval = "LC_MESSAGES";
1421
break;
1422
#endif
1423
#ifdef LC_RESPONSE
1424
case LC_RESPONSE:
1425
retval = "LC_RESPONSE";
1426
break;
1427
#endif
1428
#ifdef LC_ALL
1429
case LC_ALL:
1430
/* This might not make sense but is perhaps better than any other
1431
value. */
1432
retval = "LC_ALL";
1433
break;
1434
#endif
1435
default:
1436
/* If you have a better idea for a default value let me know. */
1437
retval = "LC_XXX";
1438
}
1439
1440
return retval;
1441
}
1442
#endif
1443
1444
/* Guess value of current locale from value of the environment variables
1445
or system-dependent defaults. */
1446
static const char *
1447
internal_function
1448
#ifdef IN_LIBGLOCALE
1449
guess_category_value (int category, const char *categoryname,
1450
const char *locale)
1451
1452
#else
1453
guess_category_value (int category, const char *categoryname)
1454
#endif
1455
{
1456
const char *language;
1457
#ifndef IN_LIBGLOCALE
1458
const char *locale;
1459
# ifndef _LIBC
1460
const char *language_default;
1461
int locale_defaulted;
1462
# endif
1463
#endif
1464
1465
/* We use the settings in the following order:
1466
1. The value of the environment variable 'LANGUAGE'. This is a GNU
1467
extension. Its value can be a colon-separated list of locale names.
1468
2. The value of the environment variable 'LC_ALL', 'LC_xxx', or 'LANG'.
1469
More precisely, the first among these that is set to a non-empty value.
1470
This is how POSIX specifies it. The value is a single locale name.
1471
3. A system-dependent preference list of languages. Its value can be a
1472
colon-separated list of locale names.
1473
4. A system-dependent default locale name.
1474
This way:
1475
- System-dependent settings can be overridden by environment variables.
1476
- If the system provides both a list of languages and a default locale,
1477
the former is used. */
1478
1479
#ifndef IN_LIBGLOCALE
1480
/* Fetch the locale name, through the POSIX method of looking to `LC_ALL',
1481
`LC_xxx', and `LANG'. On some systems this can be done by the
1482
`setlocale' function itself. */
1483
# ifdef _LIBC
1484
locale = __current_locale_name (category);
1485
# else
1486
# if HAVE_STRUCT___LOCALE_STRUCT___NAMES && defined USE_IN_GETTEXT_TESTS
1487
/* The __names field is not public glibc API and must therefore not be used
1488
in code that is installed in public locations. */
1489
locale_t thread_locale = uselocale (NULL);
1490
if (thread_locale != LC_GLOBAL_LOCALE)
1491
{
1492
locale = thread_locale->__names[category];
1493
locale_defaulted = 0;
1494
}
1495
else
1496
# endif
1497
{
1498
locale = _nl_locale_name_posix (category, categoryname);
1499
locale_defaulted = 0;
1500
if (locale == NULL)
1501
{
1502
locale = _nl_locale_name_default ();
1503
locale_defaulted = 1;
1504
}
1505
}
1506
# endif
1507
#endif
1508
1509
/* Ignore LANGUAGE and its system-dependent analogon if the locale is set
1510
to "C" because
1511
1. "C" locale usually uses the ASCII encoding, and most international
1512
messages use non-ASCII characters. These characters get displayed
1513
as question marks (if using glibc's iconv()) or as invalid 8-bit
1514
characters (because other iconv()s refuse to convert most non-ASCII
1515
characters to ASCII). In any case, the output is ugly.
1516
2. The precise output of some programs in the "C" locale is specified
1517
by POSIX and should not depend on environment variables like
1518
"LANGUAGE" or system-dependent information. We allow such programs
1519
to use gettext(). */
1520
if (strcmp (locale, "C") == 0)
1521
return locale;
1522
1523
/* The highest priority value is the value of the 'LANGUAGE' environment
1524
variable. */
1525
language = getenv ("LANGUAGE");
1526
if (language != NULL && language[0] != '\0')
1527
return language;
1528
#if !defined IN_LIBGLOCALE && !defined _LIBC
1529
/* The next priority value is the locale name, if not defaulted. */
1530
if (locale_defaulted)
1531
{
1532
/* The next priority value is the default language preferences list. */
1533
language_default = _nl_language_preferences_default ();
1534
if (language_default != NULL)
1535
return language_default;
1536
}
1537
/* The least priority value is the locale name, if defaulted. */
1538
#endif
1539
return locale;
1540
}
1541
1542
#if (defined _LIBC || HAVE_ICONV) && !defined IN_LIBGLOCALE
1543
/* Returns the output charset. */
1544
static const char *
1545
internal_function
1546
get_output_charset (struct binding *domainbinding)
1547
{
1548
/* The output charset should normally be determined by the locale. But
1549
sometimes the locale is not used or not correctly set up, so we provide
1550
a possibility for the user to override this: the OUTPUT_CHARSET
1551
environment variable. Moreover, the value specified through
1552
bind_textdomain_codeset overrides both. */
1553
if (domainbinding != NULL && domainbinding->codeset != NULL)
1554
return domainbinding->codeset;
1555
else
1556
{
1557
/* For speed reasons, we look at the value of OUTPUT_CHARSET only
1558
once. This is a user variable that is not supposed to change
1559
during a program run. */
1560
static char *output_charset_cache;
1561
static int output_charset_cached;
1562
1563
if (!output_charset_cached)
1564
{
1565
const char *value = getenv ("OUTPUT_CHARSET");
1566
1567
if (value != NULL && value[0] != '\0')
1568
{
1569
size_t len = strlen (value) + 1;
1570
char *value_copy = (char *) malloc (len);
1571
1572
if (value_copy != NULL)
1573
memcpy (value_copy, value, len);
1574
output_charset_cache = value_copy;
1575
}
1576
output_charset_cached = 1;
1577
}
1578
1579
if (output_charset_cache != NULL)
1580
return output_charset_cache;
1581
else
1582
{
1583
# ifdef _LIBC
1584
return _NL_CURRENT (LC_CTYPE, CODESET);
1585
# else
1586
# if HAVE_ICONV
1587
extern const char *locale_charset (void);
1588
return locale_charset ();
1589
# endif
1590
# endif
1591
}
1592
}
1593
}
1594
#endif
1595
1596
/* @@ begin of epilog @@ */
1597
1598
/* We don't want libintl.a to depend on any other library. So we
1599
avoid the non-standard function stpcpy. In GNU C Library this
1600
function is available, though. Also allow the symbol HAVE_STPCPY
1601
to be defined. */
1602
#if !_LIBC && !HAVE_STPCPY
1603
static char *
1604
stpcpy (char *dest, const char *src)
1605
{
1606
while ((*dest++ = *src++) != '\0')
1607
/* Do nothing. */ ;
1608
return dest - 1;
1609
}
1610
#endif
1611
1612
#if !_LIBC && !HAVE_MEMPCPY
1613
static void *
1614
mempcpy (void *dest, const void *src, size_t n)
1615
{
1616
return (void *) ((char *) memcpy (dest, src, n) + n);
1617
}
1618
#endif
1619
1620
1621
#ifdef _LIBC
1622
/* If we want to free all resources we have to do some work at
1623
program's end. */
1624
libc_freeres_fn (free_mem)
1625
{
1626
void *old;
1627
1628
while (_nl_domain_bindings != NULL)
1629
{
1630
struct binding *oldp = _nl_domain_bindings;
1631
_nl_domain_bindings = _nl_domain_bindings->next;
1632
if (oldp->dirname != _nl_default_dirname)
1633
/* Yes, this is a pointer comparison. */
1634
free (oldp->dirname);
1635
free (oldp->codeset);
1636
free (oldp);
1637
}
1638
1639
if (_nl_current_default_domain != _nl_default_default_domain)
1640
/* Yes, again a pointer comparison. */
1641
free ((char *) _nl_current_default_domain);
1642
1643
/* Remove the search tree with the known translations. */
1644
__tdestroy (root, free);
1645
root = NULL;
1646
1647
while (transmem_list != NULL)
1648
{
1649
old = transmem_list;
1650
transmem_list = transmem_list->next;
1651
free (old);
1652
}
1653
}
1654
#endif
Loggerhead is a web-based interface for Breezy
Version: 2.0.1