/[zanavi_public1]/navit/intl/localealias.c
ZANavi

Contents of /navit/intl/localealias.c

Parent Directory Parent Directory | Revision Log Revision Log


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

   
Visit the ZANavi Wiki