Context Navigation

dcigettext.c

Visit:

Last change on this file was 2617, checked in by bird, 19 years ago
GNU Texinfo 4.8
File size: 32.7 KB

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

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/essentials/sys-apps/texinfo/intl/dcigettext.c

Download in other formats: