Mercurial > audlegacy
annotate intl/localealias.c @ 1458:f12d7e208b43 trunk
[svn] Update FSF address in copyright notices. Update autotools templates.
author | chainsaw |
---|---|
date | Wed, 02 Aug 2006 15:44:07 -0700 |
parents | cb178e5ad177 |
children | 705d4c089fce |
rev | line source |
---|---|
0 | 1 /* 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 | |
1458
f12d7e208b43
[svn] Update FSF address in copyright notices. Update autotools templates.
chainsaw
parents:
0
diff
changeset
|
16 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307, |
0 | 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 || defined HAVE_FGETS_UNLOCKED | |
114 # undef fgets | |
115 # define fgets(buf, len, s) fgets_unlocked (buf, len, s) | |
116 #endif | |
117 #if defined _LIBC_REENTRANT || defined HAVE_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 PARAMS ((const char *fname, int fname_len)) | |
144 internal_function; | |
145 static int extend_alias_table PARAMS ((void)); | |
146 static int alias_compare PARAMS ((const struct alias_map *map1, | |
147 const struct alias_map *map2)); | |
148 | |
149 | |
150 const char * | |
151 _nl_expand_alias (name) | |
152 const char *name; | |
153 { | |
154 static const char *locale_alias_path; | |
155 struct alias_map *retval; | |
156 const char *result = NULL; | |
157 size_t added; | |
158 | |
159 #ifdef _LIBC | |
160 __libc_lock_lock (lock); | |
161 #endif | |
162 | |
163 if (locale_alias_path == NULL) | |
164 locale_alias_path = LOCALE_ALIAS_PATH; | |
165 | |
166 do | |
167 { | |
168 struct alias_map item; | |
169 | |
170 item.alias = name; | |
171 | |
172 if (nmap > 0) | |
173 retval = (struct alias_map *) bsearch (&item, map, nmap, | |
174 sizeof (struct alias_map), | |
175 (int (*) PARAMS ((const void *, | |
176 const void *)) | |
177 ) alias_compare); | |
178 else | |
179 retval = NULL; | |
180 | |
181 /* We really found an alias. Return the value. */ | |
182 if (retval != NULL) | |
183 { | |
184 result = retval->value; | |
185 break; | |
186 } | |
187 | |
188 /* Perhaps we can find another alias file. */ | |
189 added = 0; | |
190 while (added == 0 && locale_alias_path[0] != '\0') | |
191 { | |
192 const char *start; | |
193 | |
194 while (locale_alias_path[0] == PATH_SEPARATOR) | |
195 ++locale_alias_path; | |
196 start = locale_alias_path; | |
197 | |
198 while (locale_alias_path[0] != '\0' | |
199 && locale_alias_path[0] != PATH_SEPARATOR) | |
200 ++locale_alias_path; | |
201 | |
202 if (start < locale_alias_path) | |
203 added = read_alias_file (start, locale_alias_path - start); | |
204 } | |
205 } | |
206 while (added != 0); | |
207 | |
208 #ifdef _LIBC | |
209 __libc_lock_unlock (lock); | |
210 #endif | |
211 | |
212 return result; | |
213 } | |
214 | |
215 | |
216 static size_t | |
217 internal_function | |
218 read_alias_file (fname, fname_len) | |
219 const char *fname; | |
220 int fname_len; | |
221 { | |
222 FILE *fp; | |
223 char *full_fname; | |
224 size_t added; | |
225 static const char aliasfile[] = "/locale.alias"; | |
226 | |
227 full_fname = (char *) alloca (fname_len + sizeof aliasfile); | |
228 #ifdef HAVE_MEMPCPY | |
229 mempcpy (mempcpy (full_fname, fname, fname_len), | |
230 aliasfile, sizeof aliasfile); | |
231 #else | |
232 memcpy (full_fname, fname, fname_len); | |
233 memcpy (&full_fname[fname_len], aliasfile, sizeof aliasfile); | |
234 #endif | |
235 | |
236 fp = fopen (relocate (full_fname), "r"); | |
237 freea (full_fname); | |
238 if (fp == NULL) | |
239 return 0; | |
240 | |
241 #ifdef HAVE___FSETLOCKING | |
242 /* No threads present. */ | |
243 __fsetlocking (fp, FSETLOCKING_BYCALLER); | |
244 #endif | |
245 | |
246 added = 0; | |
247 while (!FEOF (fp)) | |
248 { | |
249 /* It is a reasonable approach to use a fix buffer here because | |
250 a) we are only interested in the first two fields | |
251 b) these fields must be usable as file names and so must not | |
252 be that long | |
253 We avoid a multi-kilobyte buffer here since this would use up | |
254 stack space which we might not have if the program ran out of | |
255 memory. */ | |
256 char buf[400]; | |
257 char *alias; | |
258 char *value; | |
259 char *cp; | |
260 | |
261 if (FGETS (buf, sizeof buf, fp) == NULL) | |
262 /* EOF reached. */ | |
263 break; | |
264 | |
265 cp = buf; | |
266 /* Ignore leading white space. */ | |
267 while (isspace ((unsigned char) cp[0])) | |
268 ++cp; | |
269 | |
270 /* A leading '#' signals a comment line. */ | |
271 if (cp[0] != '\0' && cp[0] != '#') | |
272 { | |
273 alias = cp++; | |
274 while (cp[0] != '\0' && !isspace ((unsigned char) cp[0])) | |
275 ++cp; | |
276 /* Terminate alias name. */ | |
277 if (cp[0] != '\0') | |
278 *cp++ = '\0'; | |
279 | |
280 /* Now look for the beginning of the value. */ | |
281 while (isspace ((unsigned char) cp[0])) | |
282 ++cp; | |
283 | |
284 if (cp[0] != '\0') | |
285 { | |
286 size_t alias_len; | |
287 size_t value_len; | |
288 | |
289 value = cp++; | |
290 while (cp[0] != '\0' && !isspace ((unsigned char) cp[0])) | |
291 ++cp; | |
292 /* Terminate value. */ | |
293 if (cp[0] == '\n') | |
294 { | |
295 /* This has to be done to make the following test | |
296 for the end of line possible. We are looking for | |
297 the terminating '\n' which do not overwrite here. */ | |
298 *cp++ = '\0'; | |
299 *cp = '\n'; | |
300 } | |
301 else if (cp[0] != '\0') | |
302 *cp++ = '\0'; | |
303 | |
304 if (nmap >= maxmap) | |
305 if (__builtin_expect (extend_alias_table (), 0)) | |
306 return added; | |
307 | |
308 alias_len = strlen (alias) + 1; | |
309 value_len = strlen (value) + 1; | |
310 | |
311 if (string_space_act + alias_len + value_len > string_space_max) | |
312 { | |
313 /* Increase size of memory pool. */ | |
314 size_t new_size = (string_space_max | |
315 + (alias_len + value_len > 1024 | |
316 ? alias_len + value_len : 1024)); | |
317 char *new_pool = (char *) realloc (string_space, new_size); | |
318 if (new_pool == NULL) | |
319 return added; | |
320 | |
321 if (__builtin_expect (string_space != new_pool, 0)) | |
322 { | |
323 size_t i; | |
324 | |
325 for (i = 0; i < nmap; i++) | |
326 { | |
327 map[i].alias += new_pool - string_space; | |
328 map[i].value += new_pool - string_space; | |
329 } | |
330 } | |
331 | |
332 string_space = new_pool; | |
333 string_space_max = new_size; | |
334 } | |
335 | |
336 map[nmap].alias = memcpy (&string_space[string_space_act], | |
337 alias, alias_len); | |
338 string_space_act += alias_len; | |
339 | |
340 map[nmap].value = memcpy (&string_space[string_space_act], | |
341 value, value_len); | |
342 string_space_act += value_len; | |
343 | |
344 ++nmap; | |
345 ++added; | |
346 } | |
347 } | |
348 | |
349 /* Possibly not the whole line fits into the buffer. Ignore | |
350 the rest of the line. */ | |
351 while (strchr (buf, '\n') == NULL) | |
352 if (FGETS (buf, sizeof buf, fp) == NULL) | |
353 /* Make sure the inner loop will be left. The outer loop | |
354 will exit at the `feof' test. */ | |
355 break; | |
356 } | |
357 | |
358 /* Should we test for ferror()? I think we have to silently ignore | |
359 errors. --drepper */ | |
360 fclose (fp); | |
361 | |
362 if (added > 0) | |
363 qsort (map, nmap, sizeof (struct alias_map), | |
364 (int (*) PARAMS ((const void *, const void *))) alias_compare); | |
365 | |
366 return added; | |
367 } | |
368 | |
369 | |
370 static int | |
371 extend_alias_table () | |
372 { | |
373 size_t new_size; | |
374 struct alias_map *new_map; | |
375 | |
376 new_size = maxmap == 0 ? 100 : 2 * maxmap; | |
377 new_map = (struct alias_map *) realloc (map, (new_size | |
378 * sizeof (struct alias_map))); | |
379 if (new_map == NULL) | |
380 /* Simply don't extend: we don't have any more core. */ | |
381 return -1; | |
382 | |
383 map = new_map; | |
384 maxmap = new_size; | |
385 return 0; | |
386 } | |
387 | |
388 | |
389 static int | |
390 alias_compare (map1, map2) | |
391 const struct alias_map *map1; | |
392 const struct alias_map *map2; | |
393 { | |
394 #if defined _LIBC || defined HAVE_STRCASECMP | |
395 return strcasecmp (map1->alias, map2->alias); | |
396 #else | |
397 const unsigned char *p1 = (const unsigned char *) map1->alias; | |
398 const unsigned char *p2 = (const unsigned char *) map2->alias; | |
399 unsigned char c1, c2; | |
400 | |
401 if (p1 == p2) | |
402 return 0; | |
403 | |
404 do | |
405 { | |
406 /* I know this seems to be odd but the tolower() function in | |
407 some systems libc cannot handle nonalpha characters. */ | |
408 c1 = isupper (*p1) ? tolower (*p1) : *p1; | |
409 c2 = isupper (*p2) ? tolower (*p2) : *p2; | |
410 if (c1 == '\0') | |
411 break; | |
412 ++p1; | |
413 ++p2; | |
414 } | |
415 while (c1 == c2); | |
416 | |
417 return c1 - c2; | |
418 #endif | |
419 } |