gnu/dist/grep/intl/localealias.c

   1 /*      $NetBSD$        */
   2
   3 /* Handle aliases for locale names.
   4    Copyright (C) 1995-1999, 2000, 2001 Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU Library General Public License as published
   8    by the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Library General Public License for more details.
  15
  16    You should have received a copy of the GNU Library General Public
  17    License along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19    USA.  */
  20
  21 /* Tell glibc's <string.h> to provide a prototype for mempcpy().
  22    This must come before <config.h> because <config.h> may include
  23    <features.h>, and once <features.h> has been included, it's too late.  */
  24 #ifndef _GNU_SOURCE
  25 # define _GNU_SOURCE    1
  26 #endif
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include <config.h>
  30 #endif
  31
  32 #include <ctype.h>
  33 #include <stdio.h>
  34 #if defined _LIBC || defined HAVE___FSETLOCKING
  35 # include <stdio_ext.h>
  36 #endif
  37 #include <sys/types.h>
  38
  39 #ifdef __GNUC__
  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
  50 char *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
 113 struct alias_map
 114 {
 115   const char *alias;
 116   const char *value;
 117 };
 118
 119
 120 static char *string_space;
 121 static size_t string_space_act;
 122 static size_t string_space_max;
 123 static struct alias_map *map;
 124 static size_t nmap;
 125 static size_t maxmap;
 126
 127
 128 /* Prototypes for local functions.  */
 129 static size_t read_alias_file PARAMS ((const char *fname, int fname_len))
 130      internal_function;
 131 static int extend_alias_table PARAMS ((void));
 132 static int alias_compare PARAMS ((const struct alias_map *map1,
 133                                   const struct alias_map *map2));
 134
 135
 136 const char *
 137 _nl_expand_alias (name)
 138     const char *name;
 139 {
 140   static const char *locale_alias_path;
 141   struct alias_map *retval;
 142   const char *result = NULL;
 143   size_t added;
 144
 145 #ifdef _LIBC
 146   __libc_lock_lock (lock);
 147 #endif
 148
 149   if (locale_alias_path == NULL)
 150     locale_alias_path = LOCALE_ALIAS_PATH;
 151
 152   do
 153     {
 154       struct alias_map item;
 155
 156       item.alias = name;
 157
 158       if (nmap > 0)
 159         retval = (struct alias_map *) bsearch (&item, map, nmap,
 160                                                sizeof (struct alias_map),
 161                                                (int (*) PARAMS ((const void *,
 162                                                                  const void *))
 163                                                 ) alias_compare);
 164       else
 165         retval = NULL;
 166
 167       /* We really found an alias.  Return the value.  */
 168       if (retval != NULL)
 169         {
 170           result = retval->value;
 171           break;
 172         }
 173
 174       /* Perhaps we can find another alias file.  */
 175       added = 0;
 176       while (added == 0 && locale_alias_path[0] != '\0')
 177         {
 178           const char *start;
 179
 180           while (locale_alias_path[0] == PATH_SEPARATOR)
 181             ++locale_alias_path;
 182           start = locale_alias_path;
 183
 184           while (locale_alias_path[0] != '\0'
 185                  && locale_alias_path[0] != PATH_SEPARATOR)
 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
 202 static size_t
 203 internal_function
 204 read_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   fp = fopen (full_fname, "r");
 223   freea (full_fname);
 224   if (fp == NULL)
 225     return 0;
 226
 227 #ifdef HAVE___FSETLOCKING
 228   /* No threads present.  */
 229   __fsetlocking (fp, FSETLOCKING_BYCALLER);
 230 #endif
 231
 232   added = 0;
 233   while (!FEOF (fp))
 234     {
 235       /* It is a reasonable approach to use a fix buffer here because
 236          a) we are only interested in the first two fields
 237          b) these fields must be usable as file names and so must not
 238             be that long
 239        */
 240       char buf[BUFSIZ];
 241       char *alias;
 242       char *value;
 243       char *cp;
 244
 245       if (FGETS (buf, sizeof buf, fp) == NULL)
 246         /* EOF reached.  */
 247         break;
 248
 249       /* Possibly not the whole line fits into the buffer.  Ignore
 250          the rest of the line.  */
 251       if (strchr (buf, '\n') == NULL)
 252         {
 253           char altbuf[BUFSIZ];
 254           do
 255             if (FGETS (altbuf, sizeof altbuf, fp) == NULL)
 256               /* Make sure the inner loop will be left.  The outer loop
 257                  will exit at the `feof' test.  */
 258               break;
 259           while (strchr (altbuf, '\n') == NULL);
 260         }
 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
 347   /* Should we test for ferror()?  I think we have to silently ignore
 348      errors.  --drepper  */
 349   fclose (fp);
 350
 351   if (added > 0)
 352     qsort (map, nmap, sizeof (struct alias_map),
 353            (int (*) PARAMS ((const void *, const void *))) alias_compare);
 354
 355   return added;
 356 }
 357
 358
 359 static int
 360 extend_alias_table ()
 361 {
 362   size_t new_size;
 363   struct alias_map *new_map;
 364
 365   new_size = maxmap == 0 ? 100 : 2 * maxmap;
 366   new_map = (struct alias_map *) realloc (map, (new_size
 367                                                 * sizeof (struct alias_map)));
 368   if (new_map == NULL)
 369     /* Simply don't extend: we don't have any more core.  */
 370     return -1;
 371
 372   map = new_map;
 373   maxmap = new_size;
 374   return 0;
 375 }
 376
 377
 378 #ifdef _LIBC
 379 static void __attribute__ ((unused))
 380 free_mem (void)
 381 {
 382   if (string_space != NULL)
 383     free (string_space);
 384   if (map != NULL)
 385     free (map);
 386 }
 387 text_set_element (__libc_subfreeres, free_mem);
 388 #endif
 389
 390
 391 static int
 392 alias_compare (map1, map2)
 393      const struct alias_map *map1;
 394      const struct alias_map *map2;
 395 {
 396 #if defined _LIBC || defined HAVE_STRCASECMP
 397   return strcasecmp (map1->alias, map2->alias);
 398 #else
 399   const unsigned char *p1 = (const unsigned char *) map1->alias;
 400   const unsigned char *p2 = (const unsigned char *) map2->alias;
 401   unsigned char c1, c2;
 402
 403   if (p1 == p2)
 404     return 0;
 405
 406   do
 407     {
 408       /* I know this seems to be odd but the tolower() function in
 409          some systems libc cannot handle nonalpha characters.  */
 410       c1 = isupper (*p1) ? tolower (*p1) : *p1;
 411       c2 = isupper (*p2) ? tolower (*p2) : *p2;
 412       if (c1 == '\0')
 413         break;
 414       ++p1;
 415       ++p2;
 416     }
 417   while (c1 == c2);
 418
 419   return c1 - c2;
 420 #endif
 421 }