URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [tags/] [final_interface/] [gdb-5.0/] [intl/] [localealias.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/* Handle aliases for locale names
   Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
   Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
 
#include <ctype.h>
#include <stdio.h>
#include <sys/types.h>
 
#ifdef __GNUC__
# define alloca __builtin_alloca
# define HAVE_ALLOCA 1
#else
# if defined HAVE_ALLOCA_H || defined _LIBC
#  include <alloca.h>
# else
#  ifdef _AIX
 #pragma alloca
#  else
#   ifndef alloca
char *alloca ();
#   endif
#  endif
# endif
#endif
 
#if defined STDC_HEADERS || defined _LIBC
# include <stdlib.h>
#else
char *getenv ();
# ifdef HAVE_MALLOC_H
#  include <malloc.h>
# else
void free ();
# endif
#endif
 
#if defined HAVE_STRING_H || defined _LIBC
# ifndef _GNU_SOURCE
#  define _GNU_SOURCE   1
# endif
# include <string.h>
#else
# include <strings.h>
# ifndef memcpy
#  define memcpy(Dst, Src, Num) bcopy (Src, Dst, Num)
# endif
#endif
#if !HAVE_STRCHR && !defined _LIBC
# ifndef strchr
#  define strchr index
# endif
#endif
 
#include "gettext.h"
#include "gettextP.h"
 
/* @@ end of prolog @@ */
 
#ifdef _LIBC
/* Rename the non ANSI C functions.  This is required by the standard
   because some ANSI C functions will require linking with this object
   file and the name space must not be polluted.  */
# define strcasecmp __strcasecmp
#endif
 
 
/* For those loosing systems which don't have `alloca' we have to add
   some additional code emulating it.  */
#ifdef HAVE_ALLOCA
/* Nothing has to be done.  */
# define ADD_BLOCK(list, address) /* nothing */
# define FREE_BLOCKS(list) /* nothing */
#else
struct block_list
{
  void *address;
  struct block_list *next;
};
# define ADD_BLOCK(list, addr)                                                \
  do {                                                                        \
    struct block_list *newp = (struct block_list *) malloc (sizeof (*newp));  \
    /* If we cannot get a free block we cannot add the new element to         \
       the list.  */                                                          \
    if (newp != NULL) {                                                       \
      newp->address = (addr);                                                 \
      newp->next = (list);                                                    \
      (list) = newp;                                                          \
    }                                                                         \
  } while (0)
# define FREE_BLOCKS(list)                                                    \
  do {                                                                        \
    while (list != NULL) {                                                    \
      struct block_list *old = list;                                          \
      list = list->next;                                                      \
      free (old);                                                             \
    }                                                                         \
  } while (0)
# undef alloca
# define alloca(size) (malloc (size))
#endif  /* have alloca */
 
 
struct alias_map
{
  const char *alias;
  const char *value;
};
 
 
static struct alias_map *map;
static size_t nmap = 0;
static size_t maxmap = 0;
 
 
/* Prototypes for local functions.  */
static size_t read_alias_file PARAMS ((const char *fname, int fname_len));
static void extend_alias_table PARAMS ((void));
static int alias_compare PARAMS ((const struct alias_map *map1,
                                  const struct alias_map *map2));
 
 
const char *
_nl_expand_alias (name)
    const char *name;
{
  static const char *locale_alias_path = LOCALE_ALIAS_PATH;
  struct alias_map *retval;
  size_t added;
 
  do
    {
      struct alias_map item;
 
      item.alias = name;
 
      if (nmap > 0)
        retval = (struct alias_map *) bsearch (&item, map, nmap,
                                               sizeof (struct alias_map),
                                               (int (*) PARAMS ((const void *,
                                                                 const void *))
                                                ) alias_compare);
      else
        retval = NULL;
 
      /* We really found an alias.  Return the value.  */
      if (retval != NULL)
        return retval->value;
 
      /* Perhaps we can find another alias file.  */
      added = 0;
      while (added == 0 && locale_alias_path[0] != '\0')
        {
          const char *start;
 
          while (locale_alias_path[0] == ':')
            ++locale_alias_path;
          start = locale_alias_path;
 
          while (locale_alias_path[0] != '\0' && locale_alias_path[0] != ':')
            ++locale_alias_path;
 
          if (start < locale_alias_path)
            added = read_alias_file (start, locale_alias_path - start);
        }
    }
  while (added != 0);
 
  return NULL;
}
 
 
static size_t
read_alias_file (fname, fname_len)
     const char *fname;
     int fname_len;
{
#ifndef HAVE_ALLOCA
  struct block_list *block_list = NULL;
#endif
  FILE *fp;
  char *full_fname;
  size_t added;
  static const char aliasfile[] = "/locale.alias";
 
  full_fname = (char *) alloca (fname_len + sizeof aliasfile);
  ADD_BLOCK (block_list, full_fname);
  memcpy (full_fname, fname, fname_len);
  memcpy (&full_fname[fname_len], aliasfile, sizeof aliasfile);
 
  fp = fopen (full_fname, "r");
  if (fp == NULL)
    {
      FREE_BLOCKS (block_list);
      return 0;
    }
 
  added = 0;
  while (!feof (fp))
    {
      /* It is a reasonable approach to use a fix buffer here because
         a) we are only interested in the first two fields
         b) these fields must be usable as file names and so must not
            be that long
       */
      char buf[BUFSIZ];
      char *alias;
      char *value;
      char *cp;
 
      if (fgets (buf, BUFSIZ, fp) == NULL)
        /* EOF reached.  */
        break;
 
      cp = buf;
      /* Ignore leading white space.  */
      while (isspace (cp[0]))
        ++cp;
 
      /* A leading '#' signals a comment line.  */
      if (cp[0] != '\0' && cp[0] != '#')
        {
          alias = cp++;
          while (cp[0] != '\0' && !isspace (cp[0]))
            ++cp;
          /* Terminate alias name.  */
          if (cp[0] != '\0')
            *cp++ = '\0';
 
          /* Now look for the beginning of the value.  */
          while (isspace (cp[0]))
            ++cp;
 
          if (cp[0] != '\0')
            {
              char *tp;
              size_t len;
 
              value = cp++;
              while (cp[0] != '\0' && !isspace (cp[0]))
                ++cp;
              /* Terminate value.  */
              if (cp[0] == '\n')
                {
                  /* This has to be done to make the following test
                     for the end of line possible.  We are looking for
                     the terminating '\n' which do not overwrite here.  */
                  *cp++ = '\0';
                  *cp = '\n';
                }
              else if (cp[0] != '\0')
                *cp++ = '\0';
 
              if (nmap >= maxmap)
                extend_alias_table ();
 
              /* We cannot depend on strdup available in the libc.  Sigh!  */
              len = strlen (alias) + 1;
              tp = (char *) malloc (len);
              if (tp == NULL)
                {
                  FREE_BLOCKS (block_list);
                  return added;
                }
              memcpy (tp, alias, len);
              map[nmap].alias = tp;
 
              len = strlen (value) + 1;
              tp = (char *) malloc (len);
              if (tp == NULL)
                {
                  FREE_BLOCKS (block_list);
                  return added;
                }
              memcpy (tp, value, len);
              map[nmap].value = tp;
 
              ++nmap;
              ++added;
            }
        }
 
      /* Possibly not the whole line fits into the buffer.  Ignore
         the rest of the line.  */
      while (strchr (cp, '\n') == NULL)
        {
          cp = buf;
          if (fgets (buf, BUFSIZ, fp) == NULL)
            /* Make sure the inner loop will be left.  The outer loop
               will exit at the `feof' test.  */
            *cp = '\n';
        }
    }
 
  /* Should we test for ferror()?  I think we have to silently ignore
     errors.  --drepper  */
  fclose (fp);
 
  if (added > 0)
    qsort (map, nmap, sizeof (struct alias_map),
           (int (*) PARAMS ((const void *, const void *))) alias_compare);
 
  FREE_BLOCKS (block_list);
  return added;
}
 
 
static void
extend_alias_table ()
{
  size_t new_size;
  struct alias_map *new_map;
 
  new_size = maxmap == 0 ? 100 : 2 * maxmap;
  new_map = (struct alias_map *) malloc (new_size
                                         * sizeof (struct alias_map));
  if (new_map == NULL)
    /* Simply don't extend: we don't have any more core.  */
    return;
 
  memcpy (new_map, map, nmap * sizeof (struct alias_map));
 
  if (maxmap != 0)
    free (map);
 
  map = new_map;
  maxmap = new_size;
}
 
 
static int
alias_compare (map1, map2)
     const struct alias_map *map1;
     const struct alias_map *map2;
{
#if defined _LIBC || defined HAVE_STRCASECMP
  return strcasecmp (map1->alias, map2->alias);
#else
  const unsigned char *p1 = (const unsigned char *) map1->alias;
  const unsigned char *p2 = (const unsigned char *) map2->alias;
  unsigned char c1, c2;
 
  if (p1 == p2)
    return 0;
 
  do
    {
      /* I know this seems to be odd but the tolower() function in
         some systems libc cannot handle nonalpha characters.  */
      c1 = isupper (*p1) ? tolower (*p1) : *p1;
      c2 = isupper (*p2) ? tolower (*p2) : *p2;
      if (c1 == '\0')
        break;
      ++p1;
      ++p2;
    }
  while (c1 == c2);
 
  return c1 - c2;
#endif
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [tags/] [final_interface/] [gdb-5.0/] [intl/] [localealias.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	106	markom	`/* Handle aliases for locale names`
2			`Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.`
3			`Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.`
4
5			`This program is free software; you can redistribute it and/or modify`
6			`it under the terms of the GNU General Public License as published by`
7			`the Free Software Foundation; either version 2, or (at your option)`
8			`any later version.`
9
10			`This program 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`
13			`GNU General Public License for more details.`
14
15			`You should have received a copy of the GNU General Public License`
16			`along with this program; if not, write to the Free Software Foundation,`
17			`Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */`
18
19			`#ifdef HAVE_CONFIG_H`
20			`# include <config.h>`
21			`#endif`
22
23			`#include <ctype.h>`
24			`#include <stdio.h>`
25			`#include <sys/types.h>`
26
27			`#ifdef __GNUC__`
28			`# define alloca __builtin_alloca`
29			`# define HAVE_ALLOCA 1`
30			`#else`
31			`# if defined HAVE_ALLOCA_H \|\| defined _LIBC`
32			`# include <alloca.h>`
33			`# else`
34			`# ifdef _AIX`
35			`#pragma alloca`
36			`# else`
37			`# ifndef alloca`
38			`char *alloca ();`
39			`# endif`
40			`# endif`
41			`# endif`
42			`#endif`
43
44			`#if defined STDC_HEADERS \|\| defined _LIBC`
45			`# include <stdlib.h>`
46			`#else`
47			`char *getenv ();`
48			`# ifdef HAVE_MALLOC_H`
49			`# include <malloc.h>`
50			`# else`
51			`void free ();`
52			`# endif`
53			`#endif`
54
55			`#if defined HAVE_STRING_H \|\| defined _LIBC`
56			`# ifndef _GNU_SOURCE`
57			`# define _GNU_SOURCE 1`
58			`# endif`
59			`# include <string.h>`
60			`#else`
61			`# include <strings.h>`
62			`# ifndef memcpy`
63			`# define memcpy(Dst, Src, Num) bcopy (Src, Dst, Num)`
64			`# endif`
65			`#endif`
66			`#if !HAVE_STRCHR && !defined _LIBC`
67			`# ifndef strchr`
68			`# define strchr index`
69			`# endif`
70			`#endif`
71
72			`#include "gettext.h"`
73			`#include "gettextP.h"`
74
75			`/* @@ end of prolog @@ */`
76
77			`#ifdef _LIBC`
78			`/* Rename the non ANSI C functions. This is required by the standard`
79			`because some ANSI C functions will require linking with this object`
80			`file and the name space must not be polluted. */`
81			`# define strcasecmp __strcasecmp`
82			`#endif`
83
84
85			/* For those loosing systems which don't have `alloca' we have to add
86			`some additional code emulating it. */`
87			`#ifdef HAVE_ALLOCA`
88			`/* Nothing has to be done. */`
89			`# define ADD_BLOCK(list, address) /* nothing */`
90			`# define FREE_BLOCKS(list) /* nothing */`
91			`#else`
92			`struct block_list`
93			`{`
94			`void *address;`
95			`struct block_list *next;`
96			`};`
97			`# define ADD_BLOCK(list, addr) \`
98			`do { \`
99			`struct block_list newp = (struct block_list ) malloc (sizeof (*newp)); \`
100			`/* If we cannot get a free block we cannot add the new element to \`
101			`the list. */ \`
102			`if (newp != NULL) { \`
103			`newp->address = (addr); \`
104			`newp->next = (list); \`
105			`(list) = newp; \`
106			`} \`
107			`} while (0)`
108			`# define FREE_BLOCKS(list) \`
109			`do { \`
110			`while (list != NULL) { \`
111			`struct block_list *old = list; \`
112			`list = list->next; \`
113			`free (old); \`
114			`} \`
115			`} while (0)`
116			`# undef alloca`
117			`# define alloca(size) (malloc (size))`
118			`#endif /* have alloca */`
119
120
121			`struct alias_map`
122			`{`
123			`const char *alias;`
124			`const char *value;`
125			`};`
126
127
128			`static struct alias_map *map;`
129			`static size_t nmap = 0;`
130			`static size_t maxmap = 0;`
131
132
133			`/* Prototypes for local functions. */`
134			`static size_t read_alias_file PARAMS ((const char *fname, int fname_len));`
135			`static void extend_alias_table PARAMS ((void));`
136			`static int alias_compare PARAMS ((const struct alias_map *map1,`
137			`const struct alias_map *map2));`
138
139
140			`const 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			`size_t added;`
147
148			`do`
149			`{`
150			`struct alias_map item;`
151
152			`item.alias = name;`
153
154			`if (nmap > 0)`
155			`retval = (struct alias_map *) bsearch (&item, map, nmap,`
156			`sizeof (struct alias_map),`
157			`(int () PARAMS ((const void ,`
158			`const void *))`
159			`) alias_compare);`
160			`else`
161			`retval = NULL;`
162
163			`/* We really found an alias. Return the value. */`
164			`if (retval != NULL)`
165			`return retval->value;`
166
167			`/* Perhaps we can find another alias file. */`
168			`added = 0;`
169			`while (added == 0 && locale_alias_path[0] != '\0')`
170			`{`
171			`const char *start;`
172
173			`while (locale_alias_path[0] == ':')`
174			`++locale_alias_path;`
175			`start = locale_alias_path;`
176
177			`while (locale_alias_path[0] != '\0' && locale_alias_path[0] != ':')`
178			`++locale_alias_path;`
179
180			`if (start < locale_alias_path)`
181			`added = read_alias_file (start, locale_alias_path - start);`
182			`}`
183			`}`
184			`while (added != 0);`
185
186			`return NULL;`
187			`}`
188
189
190			`static size_t`
191			`read_alias_file (fname, fname_len)`
192			`const char *fname;`
193			`int fname_len;`
194			`{`
195			`#ifndef HAVE_ALLOCA`
196			`struct block_list *block_list = NULL;`
197			`#endif`
198			`FILE *fp;`
199			`char *full_fname;`
200			`size_t added;`
201			`static const char aliasfile[] = "/locale.alias";`
202
203			`full_fname = (char *) alloca (fname_len + sizeof aliasfile);`
204			`ADD_BLOCK (block_list, full_fname);`
205			`memcpy (full_fname, fname, fname_len);`
206			`memcpy (&full_fname[fname_len], aliasfile, sizeof aliasfile);`
207
208			`fp = fopen (full_fname, "r");`
209			`if (fp == NULL)`
210			`{`
211			`FREE_BLOCKS (block_list);`
212			`return 0;`
213			`}`
214
215			`added = 0;`
216			`while (!feof (fp))`
217			`{`
218			`/* It is a reasonable approach to use a fix buffer here because`
219			`a) we are only interested in the first two fields`
220			`b) these fields must be usable as file names and so must not`
221			`be that long`
222			`*/`
223			`char buf[BUFSIZ];`
224			`char *alias;`
225			`char *value;`
226			`char *cp;`
227
228			`if (fgets (buf, BUFSIZ, fp) == NULL)`
229			`/* EOF reached. */`
230			`break;`
231
232			`cp = buf;`
233			`/* Ignore leading white space. */`
234			`while (isspace (cp[0]))`
235			`++cp;`
236
237			`/* A leading '#' signals a comment line. */`
238			`if (cp[0] != '\0' && cp[0] != '#')`
239			`{`
240			`alias = cp++;`
241			`while (cp[0] != '\0' && !isspace (cp[0]))`
242			`++cp;`
243			`/* Terminate alias name. */`
244			`if (cp[0] != '\0')`
245			`*cp++ = '\0';`
246
247			`/* Now look for the beginning of the value. */`
248			`while (isspace (cp[0]))`
249			`++cp;`
250
251			`if (cp[0] != '\0')`
252			`{`
253			`char *tp;`
254			`size_t len;`
255
256			`value = cp++;`
257			`while (cp[0] != '\0' && !isspace (cp[0]))`
258			`++cp;`
259			`/* Terminate value. */`
260			`if (cp[0] == '\n')`
261			`{`
262			`/* This has to be done to make the following test`
263			`for the end of line possible. We are looking for`
264			`the terminating '\n' which do not overwrite here. */`
265			`*cp++ = '\0';`
266			`*cp = '\n';`
267			`}`
268			`else if (cp[0] != '\0')`
269			`*cp++ = '\0';`
270
271			`if (nmap >= maxmap)`
272			`extend_alias_table ();`
273
274			`/* We cannot depend on strdup available in the libc. Sigh! */`
275			`len = strlen (alias) + 1;`
276			`tp = (char *) malloc (len);`
277			`if (tp == NULL)`
278			`{`
279			`FREE_BLOCKS (block_list);`
280			`return added;`
281			`}`
282			`memcpy (tp, alias, len);`
283			`map[nmap].alias = tp;`
284
285			`len = strlen (value) + 1;`
286			`tp = (char *) malloc (len);`
287			`if (tp == NULL)`
288			`{`
289			`FREE_BLOCKS (block_list);`
290			`return added;`
291			`}`
292			`memcpy (tp, value, len);`
293			`map[nmap].value = tp;`
294
295			`++nmap;`
296			`++added;`
297			`}`
298			`}`
299
300			`/* Possibly not the whole line fits into the buffer. Ignore`
301			`the rest of the line. */`
302			`while (strchr (cp, '\n') == NULL)`
303			`{`
304			`cp = buf;`
305			`if (fgets (buf, BUFSIZ, fp) == NULL)`
306			`/* Make sure the inner loop will be left. The outer loop`
307			will exit at the `feof' test. */
308			`*cp = '\n';`
309			`}`
310			`}`
311
312			`/* Should we test for ferror()? I think we have to silently ignore`
313			`errors. --drepper */`
314			`fclose (fp);`
315
316			`if (added > 0)`
317			`qsort (map, nmap, sizeof (struct alias_map),`
318			`(int () PARAMS ((const void , const void *))) alias_compare);`
319
320			`FREE_BLOCKS (block_list);`
321			`return added;`
322			`}`
323
324
325			`static void`
326			`extend_alias_table ()`
327			`{`
328			`size_t new_size;`
329			`struct alias_map *new_map;`
330
331			`new_size = maxmap == 0 ? 100 : 2 * maxmap;`
332			`new_map = (struct alias_map *) malloc (new_size`
333			`* sizeof (struct alias_map));`
334			`if (new_map == NULL)`
335			`/* Simply don't extend: we don't have any more core. */`
336			`return;`
337
338			`memcpy (new_map, map, nmap * sizeof (struct alias_map));`
339
340			`if (maxmap != 0)`
341			`free (map);`
342
343			`map = new_map;`
344			`maxmap = new_size;`
345			`}`
346
347
348			`static int`
349			`alias_compare (map1, map2)`
350			`const struct alias_map *map1;`
351			`const struct alias_map *map2;`
352			`{`
353			`#if defined _LIBC \|\| defined HAVE_STRCASECMP`
354			`return strcasecmp (map1->alias, map2->alias);`
355			`#else`
356			`const unsigned char p1 = (const unsigned char ) map1->alias;`
357			`const unsigned char p2 = (const unsigned char ) map2->alias;`
358			`unsigned char c1, c2;`
359
360			`if (p1 == p2)`
361			`return 0;`
362
363			`do`
364			`{`
365			`/* I know this seems to be odd but the tolower() function in`
366			`some systems libc cannot handle nonalpha characters. */`
367			`c1 = isupper (p1) ? tolower (p1) : *p1;`
368			`c2 = isupper (p2) ? tolower (p2) : *p2;`
369			`if (c1 == '\0')`
370			`break;`
371			`++p1;`
372			`++p2;`
373			`}`
374			`while (c1 == c2);`
375
376			`return c1 - c2;`
377			`#endif`
378			`}`