dcigettext.c

Last change on this file was 599, checked in by bird, 18 years ago
GNU sed 4.1.5.
File size: 31.2 KB

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

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

source: kBuild/vendor/sed/current/intl/dcigettext.c

Download in other formats: