source: vendor/glibc/current/intl/localealias.c

Last change on this file was 1836, checked in by bird, 20 years ago

Initial revision
  • Property cvs2svn:cvs-rev set to 1.1
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 9.9 KB
Line 
1/* Handle aliases for locale names.
2 Copyright (C) 1995-2002, 2003 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18 02111-1307 USA. */
19
20/* Tell glibc's <string.h> to provide a prototype for mempcpy().
21 This must come before <config.h> because <config.h> may include
22 <features.h>, and once <features.h> has been included, it's too late. */
23#ifndef _GNU_SOURCE
24# define _GNU_SOURCE 1
25#endif
26
27#ifdef HAVE_CONFIG_H
28# include <config.h>
29#endif
30
31#include <ctype.h>
32#include <stdio.h>
33#if defined _LIBC || defined HAVE___FSETLOCKING
34# include <stdio_ext.h>
35#endif
36#include <sys/types.h>
37
38#ifdef __GNUC__
39# undef alloca
40# define alloca __builtin_alloca
41# define HAVE_ALLOCA 1
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
50char *alloca ();
51# endif
52# endif
53# endif
54#endif
55
56#include <stdlib.h>
57#include <string.h>
58
59#include "gettextP.h"
60
61/* @@ end of prolog @@ */
62
63#ifdef _LIBC
64/* Rename the non ANSI C functions. This is required by the standard
65 because some ANSI C functions will require linking with this object
66 file and the name space must not be polluted. */
67# define strcasecmp __strcasecmp
68
69# ifndef mempcpy
70# define mempcpy __mempcpy
71# endif
72# define HAVE_MEMPCPY 1
73# define HAVE___FSETLOCKING 1
74
75/* We need locking here since we can be called from different places. */
76# include <bits/libc-lock.h>
77
78__libc_lock_define_initialized (static, lock);
79#endif
80
81#ifndef internal_function
82# define internal_function
83#endif
84
85/* Some optimizations for glibc. */
86#ifdef _LIBC
87# define FEOF(fp) feof_unlocked (fp)
88# define FGETS(buf, n, fp) fgets_unlocked (buf, n, fp)
89#else
90# define FEOF(fp) feof (fp)
91# define FGETS(buf, n, fp) fgets (buf, n, fp)
92#endif
93
94/* For those losing systems which don't have `alloca' we have to add
95 some additional code emulating it. */
96#ifdef HAVE_ALLOCA
97# define freea(p) /* nothing */
98#else
99# define alloca(n) malloc (n)
100# define freea(p) free (p)
101#endif
102
103#if defined _LIBC_REENTRANT || defined HAVE_FGETS_UNLOCKED
104# undef fgets
105# define fgets(buf, len, s) fgets_unlocked (buf, len, s)
106#endif
107#if defined _LIBC_REENTRANT || defined HAVE_FEOF_UNLOCKED
108# undef feof
109# define feof(s) feof_unlocked (s)
110#endif
111
112
113struct alias_map
114{
115 const char *alias;
116 const char *value;
117};
118
119
120#ifndef _LIBC
121# define libc_freeres_ptr(decl) decl
122#endif
123
124libc_freeres_ptr (static char *string_space);
125static size_t string_space_act;
126static size_t string_space_max;
127libc_freeres_ptr (static struct alias_map *map);
128static size_t nmap;
129static size_t maxmap;
130
131
132/* Prototypes for local functions. */
133static size_t read_alias_file PARAMS ((const char *fname, int fname_len))
134 internal_function;
135static int extend_alias_table PARAMS ((void));
136static int alias_compare PARAMS ((const struct alias_map *map1,
137 const struct alias_map *map2));
138
139
140const char *
141_nl_expand_alias (name)
142 const char *name;
143{
144 static const char *locale_alias_path = LOCALE_ALIAS_PATH;
145 struct alias_map *retval;
146 const char *result = NULL;
147 size_t added;
148
149#ifdef _LIBC
150 __libc_lock_lock (lock);
151#endif
152
153 do
154 {
155 struct alias_map item;
156
157 item.alias = name;
158
159 if (nmap > 0)
160 retval = (struct alias_map *) bsearch (&item, map, nmap,
161 sizeof (struct alias_map),
162 (int (*) PARAMS ((const void *,
163 const void *))
164 ) alias_compare);
165 else
166 retval = NULL;
167
168 /* We really found an alias. Return the value. */
169 if (retval != NULL)
170 {
171 result = retval->value;
172 break;
173 }
174
175 /* Perhaps we can find another alias file. */
176 added = 0;
177 while (added == 0 && locale_alias_path[0] != '\0')
178 {
179 const char *start;
180
181 while (locale_alias_path[0] == ':')
182 ++locale_alias_path;
183 start = locale_alias_path;
184
185 while (locale_alias_path[0] != '\0' && locale_alias_path[0] != ':')
186 ++locale_alias_path;
187
188 if (start < locale_alias_path)
189 added = read_alias_file (start, locale_alias_path - start);
190 }
191 }
192 while (added != 0);
193
194#ifdef _LIBC
195 __libc_lock_unlock (lock);
196#endif
197
198 return result;
199}
200
201
202static size_t
203internal_function
204read_alias_file (fname, fname_len)
205 const char *fname;
206 int fname_len;
207{
208 FILE *fp;
209 char *full_fname;
210 size_t added;
211 static const char aliasfile[] = "/locale.alias";
212
213 full_fname = (char *) alloca (fname_len + sizeof aliasfile);
214#ifdef HAVE_MEMPCPY
215 mempcpy (mempcpy (full_fname, fname, fname_len),
216 aliasfile, sizeof aliasfile);
217#else
218 memcpy (full_fname, fname, fname_len);
219 memcpy (&full_fname[fname_len], aliasfile, sizeof aliasfile);
220#endif
221
222 /* Note the file is opened with cancellation in the I/O functions
223 disabled. */
224 fp = fopen (full_fname, "rc");
225 freea (full_fname);
226 if (fp == NULL)
227 return 0;
228
229#ifdef HAVE___FSETLOCKING
230 /* No threads present. */
231 __fsetlocking (fp, FSETLOCKING_BYCALLER);
232#endif
233
234 added = 0;
235 while (!FEOF (fp))
236 {
237 /* It is a reasonable approach to use a fix buffer here because
238 a) we are only interested in the first two fields
239 b) these fields must be usable as file names and so must not
240 be that long
241 We avoid a multi-kilobyte buffer here since this would use up
242 stack space which we might not have if the program ran out of
243 memory. */
244 char buf[400];
245 char *alias;
246 char *value;
247 char *cp;
248 int complete_line;
249
250 if (FGETS (buf, sizeof buf, fp) == NULL)
251 /* EOF reached. */
252 break;
253
254 /* Determine whether the line is complete. */
255 complete_line = strchr (buf, '\n') != NULL;
256
257 cp = buf;
258 /* Ignore leading white space. */
259 while (isspace ((unsigned char) cp[0]))
260 ++cp;
261
262 /* A leading '#' signals a comment line. */
263 if (cp[0] != '\0' && cp[0] != '#')
264 {
265 alias = cp++;
266 while (cp[0] != '\0' && !isspace ((unsigned char) cp[0]))
267 ++cp;
268 /* Terminate alias name. */
269 if (cp[0] != '\0')
270 *cp++ = '\0';
271
272 /* Now look for the beginning of the value. */
273 while (isspace ((unsigned char) cp[0]))
274 ++cp;
275
276 if (cp[0] != '\0')
277 {
278 size_t alias_len;
279 size_t value_len;
280
281 value = cp++;
282 while (cp[0] != '\0' && !isspace ((unsigned char) cp[0]))
283 ++cp;
284 /* Terminate value. */
285 if (cp[0] == '\n')
286 {
287 /* This has to be done to make the following test
288 for the end of line possible. We are looking for
289 the terminating '\n' which do not overwrite here. */
290 *cp++ = '\0';
291 *cp = '\n';
292 }
293 else if (cp[0] != '\0')
294 *cp++ = '\0';
295
296 if (nmap >= maxmap)
297 if (__builtin_expect (extend_alias_table (), 0))
298 return added;
299
300 alias_len = strlen (alias) + 1;
301 value_len = strlen (value) + 1;
302
303 if (string_space_act + alias_len + value_len > string_space_max)
304 {
305 /* Increase size of memory pool. */
306 size_t new_size = (string_space_max
307 + (alias_len + value_len > 1024
308 ? alias_len + value_len : 1024));
309 char *new_pool = (char *) realloc (string_space, new_size);
310 if (new_pool == NULL)
311 return added;
312
313 if (__builtin_expect (string_space != new_pool, 0))
314 {
315 size_t i;
316
317 for (i = 0; i < nmap; i++)
318 {
319 map[i].alias += new_pool - string_space;
320 map[i].value += new_pool - string_space;
321 }
322 }
323
324 string_space = new_pool;
325 string_space_max = new_size;
326 }
327
328 map[nmap].alias = memcpy (&string_space[string_space_act],
329 alias, alias_len);
330 string_space_act += alias_len;
331
332 map[nmap].value = memcpy (&string_space[string_space_act],
333 value, value_len);
334 string_space_act += value_len;
335
336 ++nmap;
337 ++added;
338 }
339 }
340
341 /* Possibly not the whole line fits into the buffer. Ignore
342 the rest of the line. */
343 if (! complete_line)
344 do
345 if (FGETS (buf, sizeof buf, fp) == NULL)
346 /* Make sure the inner loop will be left. The outer loop
347 will exit at the `feof' test. */
348 break;
349 while (strchr (buf, '\n') == NULL);
350 }
351
352 /* Should we test for ferror()? I think we have to silently ignore
353 errors. --drepper */
354 fclose (fp);
355
356 if (added > 0)
357 qsort (map, nmap, sizeof (struct alias_map),
358 (int (*) PARAMS ((const void *, const void *))) alias_compare);
359
360 return added;
361}
362
363
364static int
365extend_alias_table ()
366{
367 size_t new_size;
368 struct alias_map *new_map;
369
370 new_size = maxmap == 0 ? 100 : 2 * maxmap;
371 new_map = (struct alias_map *) realloc (map, (new_size
372 * sizeof (struct alias_map)));
373 if (new_map == NULL)
374 /* Simply don't extend: we don't have any more core. */
375 return -1;
376
377 map = new_map;
378 maxmap = new_size;
379 return 0;
380}
381
382
383static int
384alias_compare (map1, map2)
385 const struct alias_map *map1;
386 const struct alias_map *map2;
387{
388#if defined _LIBC || defined HAVE_STRCASECMP
389 return strcasecmp (map1->alias, map2->alias);
390#else
391 const unsigned char *p1 = (const unsigned char *) map1->alias;
392 const unsigned char *p2 = (const unsigned char *) map2->alias;
393 unsigned char c1, c2;
394
395 if (p1 == p2)
396 return 0;
397
398 do
399 {
400 /* I know this seems to be odd but the tolower() function in
401 some systems libc cannot handle nonalpha characters. */
402 c1 = isupper (*p1) ? tolower (*p1) : *p1;
403 c2 = isupper (*p2) ? tolower (*p2) : *p2;
404 if (c1 == '\0')
405 break;
406 ++p1;
407 ++p2;
408 }
409 while (c1 == c2);
410
411 return c1 - c2;
412#endif
413}
Note: See TracBrowser for help on using the repository browser.