OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [intl/] [localealias.c] - Diff between revs 156 and 816

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 156 Rev 816
/* Handle aliases for locale names.
/* Handle aliases for locale names.
   Copyright (C) 1995-1999, 2000-2001, 2003 Free Software Foundation, Inc.
   Copyright (C) 1995-1999, 2000-2001, 2003 Free Software Foundation, Inc.
 
 
   This program is free software; you can redistribute it and/or modify it
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU Library General Public License as published
   under the terms of the GNU Library General Public License as published
   by the Free Software Foundation; either version 2, or (at your option)
   by the Free Software Foundation; either version 2, or (at your option)
   any later version.
   any later version.
 
 
   This program is distributed in the hope that it will be useful,
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
   Library General Public License for more details.
 
 
   You should have received a copy of the GNU Library General Public
   You should have received a copy of the GNU Library General Public
   License along with this program; if not, write to the Free Software
   License along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
   USA.  */
   USA.  */
 
 
/* Tell glibc's <string.h> to provide a prototype for mempcpy().
/* Tell glibc's <string.h> to provide a prototype for mempcpy().
   This must come before <config.h> because <config.h> may include
   This must come before <config.h> because <config.h> may include
   <features.h>, and once <features.h> has been included, it's too late.  */
   <features.h>, and once <features.h> has been included, it's too late.  */
#ifndef _GNU_SOURCE
#ifndef _GNU_SOURCE
# define _GNU_SOURCE    1
# define _GNU_SOURCE    1
#endif
#endif
 
 
#ifdef HAVE_CONFIG_H
#ifdef HAVE_CONFIG_H
# include <config.h>
# include <config.h>
#endif
#endif
 
 
#include <ctype.h>
#include <ctype.h>
#include <stdio.h>
#include <stdio.h>
#if defined _LIBC || defined HAVE___FSETLOCKING
#if defined _LIBC || defined HAVE___FSETLOCKING
# include <stdio_ext.h>
# include <stdio_ext.h>
#endif
#endif
#include <sys/types.h>
#include <sys/types.h>
 
 
#ifdef __GNUC__
#ifdef __GNUC__
# undef alloca
# undef alloca
# define alloca __builtin_alloca
# define alloca __builtin_alloca
# define HAVE_ALLOCA 1
# define HAVE_ALLOCA 1
#else
#else
# ifdef _MSC_VER
# ifdef _MSC_VER
#  include <malloc.h>
#  include <malloc.h>
#  define alloca _alloca
#  define alloca _alloca
# else
# else
#  if defined HAVE_ALLOCA_H || defined _LIBC
#  if defined HAVE_ALLOCA_H || defined _LIBC
#   include <alloca.h>
#   include <alloca.h>
#  else
#  else
#   ifdef _AIX
#   ifdef _AIX
 #pragma alloca
 #pragma alloca
#   else
#   else
#    ifndef alloca
#    ifndef alloca
char *alloca ();
char *alloca ();
#    endif
#    endif
#   endif
#   endif
#  endif
#  endif
# endif
# endif
#endif
#endif
 
 
#include <stdlib.h>
#include <stdlib.h>
#include <string.h>
#include <string.h>
 
 
#include "gettextP.h"
#include "gettextP.h"
 
 
#if ENABLE_RELOCATABLE
#if ENABLE_RELOCATABLE
# include "relocatable.h"
# include "relocatable.h"
#else
#else
# define relocate(pathname) (pathname)
# define relocate(pathname) (pathname)
#endif
#endif
 
 
/* @@ end of prolog @@ */
/* @@ end of prolog @@ */
 
 
#ifdef _LIBC
#ifdef _LIBC
/* Rename the non ANSI C functions.  This is required by the standard
/* Rename the non ANSI C functions.  This is required by the standard
   because some ANSI C functions will require linking with this object
   because some ANSI C functions will require linking with this object
   file and the name space must not be polluted.  */
   file and the name space must not be polluted.  */
# define strcasecmp __strcasecmp
# define strcasecmp __strcasecmp
 
 
# ifndef mempcpy
# ifndef mempcpy
#  define mempcpy __mempcpy
#  define mempcpy __mempcpy
# endif
# endif
# define HAVE_MEMPCPY   1
# define HAVE_MEMPCPY   1
# define HAVE___FSETLOCKING     1
# define HAVE___FSETLOCKING     1
 
 
/* We need locking here since we can be called from different places.  */
/* We need locking here since we can be called from different places.  */
# include <bits/libc-lock.h>
# include <bits/libc-lock.h>
 
 
__libc_lock_define_initialized (static, lock);
__libc_lock_define_initialized (static, lock);
#endif
#endif
 
 
#ifndef internal_function
#ifndef internal_function
# define internal_function
# define internal_function
#endif
#endif
 
 
/* Some optimizations for glibc.  */
/* Some optimizations for glibc.  */
#ifdef _LIBC
#ifdef _LIBC
# define FEOF(fp)               feof_unlocked (fp)
# define FEOF(fp)               feof_unlocked (fp)
# define FGETS(buf, n, fp)      fgets_unlocked (buf, n, fp)
# define FGETS(buf, n, fp)      fgets_unlocked (buf, n, fp)
#else
#else
# define FEOF(fp)               feof (fp)
# define FEOF(fp)               feof (fp)
# define FGETS(buf, n, fp)      fgets (buf, n, fp)
# define FGETS(buf, n, fp)      fgets (buf, n, fp)
#endif
#endif
 
 
/* For those losing systems which don't have `alloca' we have to add
/* For those losing systems which don't have `alloca' we have to add
   some additional code emulating it.  */
   some additional code emulating it.  */
#ifdef HAVE_ALLOCA
#ifdef HAVE_ALLOCA
# define freea(p) /* nothing */
# define freea(p) /* nothing */
#else
#else
# define alloca(n) malloc (n)
# define alloca(n) malloc (n)
# define freea(p) free (p)
# define freea(p) free (p)
#endif
#endif
 
 
#if defined _LIBC_REENTRANT || defined HAVE_FGETS_UNLOCKED
#if defined _LIBC_REENTRANT || defined HAVE_FGETS_UNLOCKED
# undef fgets
# undef fgets
# define fgets(buf, len, s) fgets_unlocked (buf, len, s)
# define fgets(buf, len, s) fgets_unlocked (buf, len, s)
#endif
#endif
#if defined _LIBC_REENTRANT || defined HAVE_FEOF_UNLOCKED
#if defined _LIBC_REENTRANT || defined HAVE_FEOF_UNLOCKED
# undef feof
# undef feof
# define feof(s) feof_unlocked (s)
# define feof(s) feof_unlocked (s)
#endif
#endif
 
 
 
 
struct alias_map
struct alias_map
{
{
  const char *alias;
  const char *alias;
  const char *value;
  const char *value;
};
};
 
 
 
 
#ifndef _LIBC
#ifndef _LIBC
# define libc_freeres_ptr(decl) decl
# define libc_freeres_ptr(decl) decl
#endif
#endif
 
 
libc_freeres_ptr (static char *string_space);
libc_freeres_ptr (static char *string_space);
static size_t string_space_act;
static size_t string_space_act;
static size_t string_space_max;
static size_t string_space_max;
libc_freeres_ptr (static struct alias_map *map);
libc_freeres_ptr (static struct alias_map *map);
static size_t nmap;
static size_t nmap;
static size_t maxmap;
static size_t maxmap;
 
 
 
 
/* Prototypes for local functions.  */
/* Prototypes for local functions.  */
static size_t read_alias_file PARAMS ((const char *fname, int fname_len))
static size_t read_alias_file PARAMS ((const char *fname, int fname_len))
     internal_function;
     internal_function;
static int extend_alias_table PARAMS ((void));
static int extend_alias_table PARAMS ((void));
static int alias_compare PARAMS ((const struct alias_map *map1,
static int alias_compare PARAMS ((const struct alias_map *map1,
                                  const struct alias_map *map2));
                                  const struct alias_map *map2));
 
 
 
 
const char *
const char *
_nl_expand_alias (name)
_nl_expand_alias (name)
    const char *name;
    const char *name;
{
{
  static const char *locale_alias_path;
  static const char *locale_alias_path;
  struct alias_map *retval;
  struct alias_map *retval;
  const char *result = NULL;
  const char *result = NULL;
  size_t added;
  size_t added;
 
 
#ifdef _LIBC
#ifdef _LIBC
  __libc_lock_lock (lock);
  __libc_lock_lock (lock);
#endif
#endif
 
 
  if (locale_alias_path == NULL)
  if (locale_alias_path == NULL)
    locale_alias_path = LOCALE_ALIAS_PATH;
    locale_alias_path = LOCALE_ALIAS_PATH;
 
 
  do
  do
    {
    {
      struct alias_map item;
      struct alias_map item;
 
 
      item.alias = name;
      item.alias = name;
 
 
      if (nmap > 0)
      if (nmap > 0)
        retval = (struct alias_map *) bsearch (&item, map, nmap,
        retval = (struct alias_map *) bsearch (&item, map, nmap,
                                               sizeof (struct alias_map),
                                               sizeof (struct alias_map),
                                               (int (*) PARAMS ((const void *,
                                               (int (*) PARAMS ((const void *,
                                                                 const void *))
                                                                 const void *))
                                                ) alias_compare);
                                                ) alias_compare);
      else
      else
        retval = NULL;
        retval = NULL;
 
 
      /* We really found an alias.  Return the value.  */
      /* We really found an alias.  Return the value.  */
      if (retval != NULL)
      if (retval != NULL)
        {
        {
          result = retval->value;
          result = retval->value;
          break;
          break;
        }
        }
 
 
      /* Perhaps we can find another alias file.  */
      /* Perhaps we can find another alias file.  */
      added = 0;
      added = 0;
      while (added == 0 && locale_alias_path[0] != '\0')
      while (added == 0 && locale_alias_path[0] != '\0')
        {
        {
          const char *start;
          const char *start;
 
 
          while (locale_alias_path[0] == PATH_SEPARATOR)
          while (locale_alias_path[0] == PATH_SEPARATOR)
            ++locale_alias_path;
            ++locale_alias_path;
          start = locale_alias_path;
          start = locale_alias_path;
 
 
          while (locale_alias_path[0] != '\0'
          while (locale_alias_path[0] != '\0'
                 && locale_alias_path[0] != PATH_SEPARATOR)
                 && locale_alias_path[0] != PATH_SEPARATOR)
            ++locale_alias_path;
            ++locale_alias_path;
 
 
          if (start < locale_alias_path)
          if (start < locale_alias_path)
            added = read_alias_file (start, locale_alias_path - start);
            added = read_alias_file (start, locale_alias_path - start);
        }
        }
    }
    }
  while (added != 0);
  while (added != 0);
 
 
#ifdef _LIBC
#ifdef _LIBC
  __libc_lock_unlock (lock);
  __libc_lock_unlock (lock);
#endif
#endif
 
 
  return result;
  return result;
}
}
 
 
 
 
static size_t
static size_t
internal_function
internal_function
read_alias_file (fname, fname_len)
read_alias_file (fname, fname_len)
     const char *fname;
     const char *fname;
     int fname_len;
     int fname_len;
{
{
  FILE *fp;
  FILE *fp;
  char *full_fname;
  char *full_fname;
  size_t added;
  size_t added;
  static const char aliasfile[] = "/locale.alias";
  static const char aliasfile[] = "/locale.alias";
 
 
  full_fname = (char *) alloca (fname_len + sizeof aliasfile);
  full_fname = (char *) alloca (fname_len + sizeof aliasfile);
#ifdef HAVE_MEMPCPY
#ifdef HAVE_MEMPCPY
  mempcpy (mempcpy (full_fname, fname, fname_len),
  mempcpy (mempcpy (full_fname, fname, fname_len),
           aliasfile, sizeof aliasfile);
           aliasfile, sizeof aliasfile);
#else
#else
  memcpy (full_fname, fname, fname_len);
  memcpy (full_fname, fname, fname_len);
  memcpy (&full_fname[fname_len], aliasfile, sizeof aliasfile);
  memcpy (&full_fname[fname_len], aliasfile, sizeof aliasfile);
#endif
#endif
 
 
  fp = fopen (relocate (full_fname), "r");
  fp = fopen (relocate (full_fname), "r");
  freea (full_fname);
  freea (full_fname);
  if (fp == NULL)
  if (fp == NULL)
    return 0;
    return 0;
 
 
#ifdef HAVE___FSETLOCKING
#ifdef HAVE___FSETLOCKING
  /* No threads present.  */
  /* No threads present.  */
  __fsetlocking (fp, FSETLOCKING_BYCALLER);
  __fsetlocking (fp, FSETLOCKING_BYCALLER);
#endif
#endif
 
 
  added = 0;
  added = 0;
  while (!FEOF (fp))
  while (!FEOF (fp))
    {
    {
      /* It is a reasonable approach to use a fix buffer here because
      /* It is a reasonable approach to use a fix buffer here because
         a) we are only interested in the first two fields
         a) we are only interested in the first two fields
         b) these fields must be usable as file names and so must not
         b) these fields must be usable as file names and so must not
            be that long
            be that long
         We avoid a multi-kilobyte buffer here since this would use up
         We avoid a multi-kilobyte buffer here since this would use up
         stack space which we might not have if the program ran out of
         stack space which we might not have if the program ran out of
         memory.  */
         memory.  */
      char buf[400];
      char buf[400];
      char *alias;
      char *alias;
      char *value;
      char *value;
      char *cp;
      char *cp;
 
 
      if (FGETS (buf, sizeof buf, fp) == NULL)
      if (FGETS (buf, sizeof buf, fp) == NULL)
        /* EOF reached.  */
        /* EOF reached.  */
        break;
        break;
 
 
      cp = buf;
      cp = buf;
      /* Ignore leading white space.  */
      /* Ignore leading white space.  */
      while (isspace ((unsigned char) cp[0]))
      while (isspace ((unsigned char) cp[0]))
        ++cp;
        ++cp;
 
 
      /* A leading '#' signals a comment line.  */
      /* A leading '#' signals a comment line.  */
      if (cp[0] != '\0' && cp[0] != '#')
      if (cp[0] != '\0' && cp[0] != '#')
        {
        {
          alias = cp++;
          alias = cp++;
          while (cp[0] != '\0' && !isspace ((unsigned char) cp[0]))
          while (cp[0] != '\0' && !isspace ((unsigned char) cp[0]))
            ++cp;
            ++cp;
          /* Terminate alias name.  */
          /* Terminate alias name.  */
          if (cp[0] != '\0')
          if (cp[0] != '\0')
            *cp++ = '\0';
            *cp++ = '\0';
 
 
          /* Now look for the beginning of the value.  */
          /* Now look for the beginning of the value.  */
          while (isspace ((unsigned char) cp[0]))
          while (isspace ((unsigned char) cp[0]))
            ++cp;
            ++cp;
 
 
          if (cp[0] != '\0')
          if (cp[0] != '\0')
            {
            {
              size_t alias_len;
              size_t alias_len;
              size_t value_len;
              size_t value_len;
 
 
              value = cp++;
              value = cp++;
              while (cp[0] != '\0' && !isspace ((unsigned char) cp[0]))
              while (cp[0] != '\0' && !isspace ((unsigned char) cp[0]))
                ++cp;
                ++cp;
              /* Terminate value.  */
              /* Terminate value.  */
              if (cp[0] == '\n')
              if (cp[0] == '\n')
                {
                {
                  /* This has to be done to make the following test
                  /* This has to be done to make the following test
                     for the end of line possible.  We are looking for
                     for the end of line possible.  We are looking for
                     the terminating '\n' which do not overwrite here.  */
                     the terminating '\n' which do not overwrite here.  */
                  *cp++ = '\0';
                  *cp++ = '\0';
                  *cp = '\n';
                  *cp = '\n';
                }
                }
              else if (cp[0] != '\0')
              else if (cp[0] != '\0')
                *cp++ = '\0';
                *cp++ = '\0';
 
 
              if (nmap >= maxmap)
              if (nmap >= maxmap)
                if (__builtin_expect (extend_alias_table (), 0))
                if (__builtin_expect (extend_alias_table (), 0))
                  return added;
                  return added;
 
 
              alias_len = strlen (alias) + 1;
              alias_len = strlen (alias) + 1;
              value_len = strlen (value) + 1;
              value_len = strlen (value) + 1;
 
 
              if (string_space_act + alias_len + value_len > string_space_max)
              if (string_space_act + alias_len + value_len > string_space_max)
                {
                {
                  /* Increase size of memory pool.  */
                  /* Increase size of memory pool.  */
                  size_t new_size = (string_space_max
                  size_t new_size = (string_space_max
                                     + (alias_len + value_len > 1024
                                     + (alias_len + value_len > 1024
                                        ? alias_len + value_len : 1024));
                                        ? alias_len + value_len : 1024));
                  char *new_pool = (char *) realloc (string_space, new_size);
                  char *new_pool = (char *) realloc (string_space, new_size);
                  if (new_pool == NULL)
                  if (new_pool == NULL)
                    return added;
                    return added;
 
 
                  if (__builtin_expect (string_space != new_pool, 0))
                  if (__builtin_expect (string_space != new_pool, 0))
                    {
                    {
                      size_t i;
                      size_t i;
 
 
                      for (i = 0; i < nmap; i++)
                      for (i = 0; i < nmap; i++)
                        {
                        {
                          map[i].alias += new_pool - string_space;
                          map[i].alias += new_pool - string_space;
                          map[i].value += new_pool - string_space;
                          map[i].value += new_pool - string_space;
                        }
                        }
                    }
                    }
 
 
                  string_space = new_pool;
                  string_space = new_pool;
                  string_space_max = new_size;
                  string_space_max = new_size;
                }
                }
 
 
              map[nmap].alias = memcpy (&string_space[string_space_act],
              map[nmap].alias = memcpy (&string_space[string_space_act],
                                        alias, alias_len);
                                        alias, alias_len);
              string_space_act += alias_len;
              string_space_act += alias_len;
 
 
              map[nmap].value = memcpy (&string_space[string_space_act],
              map[nmap].value = memcpy (&string_space[string_space_act],
                                        value, value_len);
                                        value, value_len);
              string_space_act += value_len;
              string_space_act += value_len;
 
 
              ++nmap;
              ++nmap;
              ++added;
              ++added;
            }
            }
        }
        }
 
 
      /* Possibly not the whole line fits into the buffer.  Ignore
      /* Possibly not the whole line fits into the buffer.  Ignore
         the rest of the line.  */
         the rest of the line.  */
      while (strchr (buf, '\n') == NULL)
      while (strchr (buf, '\n') == NULL)
        if (FGETS (buf, sizeof buf, fp) == NULL)
        if (FGETS (buf, sizeof buf, fp) == NULL)
          /* Make sure the inner loop will be left.  The outer loop
          /* Make sure the inner loop will be left.  The outer loop
             will exit at the `feof' test.  */
             will exit at the `feof' test.  */
          break;
          break;
    }
    }
 
 
  /* Should we test for ferror()?  I think we have to silently ignore
  /* Should we test for ferror()?  I think we have to silently ignore
     errors.  --drepper  */
     errors.  --drepper  */
  fclose (fp);
  fclose (fp);
 
 
  if (added > 0)
  if (added > 0)
    qsort (map, nmap, sizeof (struct alias_map),
    qsort (map, nmap, sizeof (struct alias_map),
           (int (*) PARAMS ((const void *, const void *))) alias_compare);
           (int (*) PARAMS ((const void *, const void *))) alias_compare);
 
 
  return added;
  return added;
}
}
 
 
 
 
static int
static int
extend_alias_table ()
extend_alias_table ()
{
{
  size_t new_size;
  size_t new_size;
  struct alias_map *new_map;
  struct alias_map *new_map;
 
 
  new_size = maxmap == 0 ? 100 : 2 * maxmap;
  new_size = maxmap == 0 ? 100 : 2 * maxmap;
  new_map = (struct alias_map *) realloc (map, (new_size
  new_map = (struct alias_map *) realloc (map, (new_size
                                                * sizeof (struct alias_map)));
                                                * sizeof (struct alias_map)));
  if (new_map == NULL)
  if (new_map == NULL)
    /* Simply don't extend: we don't have any more core.  */
    /* Simply don't extend: we don't have any more core.  */
    return -1;
    return -1;
 
 
  map = new_map;
  map = new_map;
  maxmap = new_size;
  maxmap = new_size;
  return 0;
  return 0;
}
}
 
 
 
 
static int
static int
alias_compare (map1, map2)
alias_compare (map1, map2)
     const struct alias_map *map1;
     const struct alias_map *map1;
     const struct alias_map *map2;
     const struct alias_map *map2;
{
{
#if defined _LIBC || defined HAVE_STRCASECMP
#if defined _LIBC || defined HAVE_STRCASECMP
  return strcasecmp (map1->alias, map2->alias);
  return strcasecmp (map1->alias, map2->alias);
#else
#else
  const unsigned char *p1 = (const unsigned char *) map1->alias;
  const unsigned char *p1 = (const unsigned char *) map1->alias;
  const unsigned char *p2 = (const unsigned char *) map2->alias;
  const unsigned char *p2 = (const unsigned char *) map2->alias;
  unsigned char c1, c2;
  unsigned char c1, c2;
 
 
  if (p1 == p2)
  if (p1 == p2)
    return 0;
    return 0;
 
 
  do
  do
    {
    {
      /* I know this seems to be odd but the tolower() function in
      /* I know this seems to be odd but the tolower() function in
         some systems libc cannot handle nonalpha characters.  */
         some systems libc cannot handle nonalpha characters.  */
      c1 = isupper (*p1) ? tolower (*p1) : *p1;
      c1 = isupper (*p1) ? tolower (*p1) : *p1;
      c2 = isupper (*p2) ? tolower (*p2) : *p2;
      c2 = isupper (*p2) ? tolower (*p2) : *p2;
      if (c1 == '\0')
      if (c1 == '\0')
        break;
        break;
      ++p1;
      ++p1;
      ++p2;
      ++p2;
    }
    }
  while (c1 == c2);
  while (c1 == c2);
 
 
  return c1 - c2;
  return c1 - c2;
#endif
#endif
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.