Code

changelog: Updated to 1.4~rc2+20091004-1.
[pkg-rrdtool.git] / intl / localealias.c
1 /* Handle aliases for locale names.
2    Copyright (C) 1995-1999, 2000-2001, 2003 Free Software Foundation, Inc.
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.
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.
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.  */
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
26 #ifdef HAVE_CONFIG_H
27 # include <config.h>
28 #endif
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>
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
60 #include <stdlib.h>
61 #include <string.h>
63 #include "gettextP.h"
65 #if ENABLE_RELOCATABLE
66 # include "relocatable.h"
67 #else
68 # define relocate(pathname) (pathname)
69 #endif
71 /* @@ end of prolog @@ */
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
79 # ifndef mempcpy
80 #  define mempcpy __mempcpy
81 # endif
82 # define HAVE_MEMPCPY   1
83 # define HAVE___FSETLOCKING     1
85 /* We need locking here since we can be called from different places.  */
86 # include <bits/libc-lock.h>
88 __libc_lock_define_initialized (static, lock);
89 #endif
91 #ifndef internal_function
92 # define internal_function
93 #endif
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
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
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
123 struct alias_map
125   const char *alias;
126   const char *value;
127 };
130 #ifndef _LIBC
131 # define libc_freeres_ptr(decl) decl
132 #endif
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;
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);
150 const char *
151 _nl_expand_alias (const char *name)
153   static const char *locale_alias_path;
154   struct alias_map *retval;
155   const char *result = NULL;
156   size_t added;
158 #ifdef _LIBC
159   __libc_lock_lock (lock);
160 #endif
162   if (locale_alias_path == NULL)
163     locale_alias_path = LOCALE_ALIAS_PATH;
165   do
166     {
167       struct alias_map item;
169       item.alias = name;
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;
180       /* We really found an alias.  Return the value.  */
181       if (retval != NULL)
182         {
183           result = retval->value;
184           break;
185         }
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;
193           while (locale_alias_path[0] == PATH_SEPARATOR)
194             ++locale_alias_path;
195           start = locale_alias_path;
197           while (locale_alias_path[0] != '\0'
198                  && locale_alias_path[0] != PATH_SEPARATOR)
199             ++locale_alias_path;
201           if (start < locale_alias_path)
202             added = read_alias_file (start, locale_alias_path - start);
203         }
204     }
205   while (added != 0);
207 #ifdef _LIBC
208   __libc_lock_unlock (lock);
209 #endif
211   return result;
215 static size_t
216 internal_function
217 read_alias_file (const char *fname, int fname_len)
219   FILE *fp;
220   char *full_fname;
221   size_t added;
222   static const char aliasfile[] = "/locale.alias";
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
233   fp = fopen (relocate (full_fname), "r");
234   freea (full_fname);
235   if (fp == NULL)
236     return 0;
238 #ifdef HAVE___FSETLOCKING
239   /* No threads present.  */
240   __fsetlocking (fp, FSETLOCKING_BYCALLER);
241 #endif
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;
258       if (FGETS (buf, sizeof buf, fp) == NULL)
259         /* EOF reached.  */
260         break;
262       cp = buf;
263       /* Ignore leading white space.  */
264       while (isspace ((unsigned char) cp[0]))
265         ++cp;
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';
277           /* Now look for the beginning of the value.  */
278           while (isspace ((unsigned char) cp[0]))
279             ++cp;
281           if (cp[0] != '\0')
282             {
283               size_t alias_len;
284               size_t value_len;
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';
301               if (nmap >= maxmap)
302                 if (__builtin_expect (extend_alias_table (), 0))
303                   return added;
305               alias_len = strlen (alias) + 1;
306               value_len = strlen (value) + 1;
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;
318                   if (__builtin_expect (string_space != new_pool, 0))
319                     {
320                       size_t i;
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                     }
329                   string_space = new_pool;
330                   string_space_max = new_size;
331                 }
333               map[nmap].alias = memcpy (&string_space[string_space_act],
334                                         alias, alias_len);
335               string_space_act += alias_len;
337               map[nmap].value = memcpy (&string_space[string_space_act],
338                                         value, value_len);
339               string_space_act += value_len;
341               ++nmap;
342               ++added;
343             }
344         }
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     }
355   /* Should we test for ferror()?  I think we have to silently ignore
356      errors.  --drepper  */
357   fclose (fp);
359   if (added > 0)
360     qsort (map, nmap, sizeof (struct alias_map),
361            (int (*) (const void *, const void *)) alias_compare);
363   return added;
367 static int
368 extend_alias_table ()
370   size_t new_size;
371   struct alias_map *new_map;
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;
380   map = new_map;
381   maxmap = new_size;
382   return 0;
386 static int
387 alias_compare (const struct alias_map *map1, const struct alias_map *map2)
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;
396   if (p1 == p2)
397     return 0;
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);
412   return c1 - c2;
413 #endif