[thirdparty/binutils-gdb.git] / intl / localealias.c

/* Handle aliases for locale names.
   Copyright (C) 1995, 1996, 1997, 1998 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

# define mempcpy __mempcpy
# define HAVE_MEMPCPY	1

/* We need locking here since we can be called from different places.  */
# include <bits/libc-lock.h>

__libc_lock_define_initialized (static, lock);
#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 char *string_space = NULL;
static size_t string_space_act = 0;
static size_t string_space_max = 0;
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))
     internal_function;
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;
  const char *result = NULL;
  size_t added;

#ifdef _LIBC
  __libc_lock_lock (lock);
#endif

  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)
	{
	  result = retval->value;
	  break;
	}

      /* 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);

#ifdef _LIBC
  __libc_lock_unlock (lock);
#endif

  return result;
}


static size_t
internal_function
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);
#ifdef HAVE_MEMPCPY
  mempcpy (mempcpy (full_fname, fname, fname_len),
	   aliasfile, sizeof aliasfile);
#else
  memcpy (full_fname, fname, fname_len);
  memcpy (&full_fname[fname_len], aliasfile, sizeof aliasfile);
#endif

  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
       */
      unsigned char buf[BUFSIZ];
      unsigned char *alias;
      unsigned char *value;
      unsigned char *cp;

      if (fgets (buf, sizeof buf, fp) == NULL)
	/* EOF reached.  */
	break;

      /* Possibly not the whole line fits into the buffer.  Ignore
	 the rest of the line.  */
      if (strchr (buf, '\n') == NULL)
	{
	  char altbuf[BUFSIZ];
	  do
	    if (fgets (altbuf, sizeof altbuf, fp) == NULL)
	      /* Make sure the inner loop will be left.  The outer loop
		 will exit at the `feof' test.  */
	      break;
	  while (strchr (altbuf, '\n') == NULL);
	}

      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')
	    {
	      size_t alias_len;
	      size_t value_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 ();

	      alias_len = strlen (alias) + 1;
	      value_len = strlen (value) + 1;

	      if (string_space_act + alias_len + value_len > string_space_max)
		{
		  /* Increase size of memory pool.  */
		  size_t new_size = (string_space_max
				     + (alias_len + value_len > 1024
					? alias_len + value_len : 1024));
		  char *new_pool = (char *) realloc (string_space, new_size);
		  if (new_pool == NULL)
		    {
		      FREE_BLOCKS (block_list);
		      return added;
		    }
		  string_space = new_pool;
		  string_space_max = new_size;
		}

	      map[nmap].alias = memcpy (&string_space[string_space_act],
					alias, alias_len);
	      string_space_act += alias_len;

	      map[nmap].value = memcpy (&string_space[string_space_act],
					value, value_len);
	      string_space_act += value_len;

	      ++nmap;
	      ++added;
	    }
	}
    }

  /* 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 *) realloc (map, (new_size
						* sizeof (struct alias_map)));
  if (new_map == NULL)
    /* Simply don't extend: we don't have any more core.  */
    return;

  map = new_map;
  maxmap = new_size;
}


#ifdef _LIBC
static void __attribute__ ((unused))
free_mem (void)
{
  if (string_space != NULL)
    free (string_space);
  if (map != NULL)
    free (map);
}
text_set_element (__libc_subfreeres, free_mem);
#endif


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
}
Commit	Line	Data
1491f078 BE	1	/* Handle aliases for locale names.
1491f078 BE	2	Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
252b5132 RH	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
1491f078 BE	82
	83	# define mempcpy __mempcpy
	84	# define HAVE_MEMPCPY 1
	85
	86	/* We need locking here since we can be called from different places. */
	87	# include <bits/libc-lock.h>
	88
	89	__libc_lock_define_initialized (static, lock);
252b5132 RH	90	#endif
	91
	92
	93	/* For those loosing systems which don't have `alloca' we have to add
	94	some additional code emulating it. */
	95	#ifdef HAVE_ALLOCA
	96	/* Nothing has to be done. */
	97	# define ADD_BLOCK(list, address) /* nothing */
	98	# define FREE_BLOCKS(list) /* nothing */
	99	#else
	100	struct block_list
	101	{
	102	void *address;
	103	struct block_list *next;
	104	};
	105	# define ADD_BLOCK(list, addr) \
	106	do { \
	107	struct block_list newp = (struct block_list ) malloc (sizeof (*newp)); \
	108	/* If we cannot get a free block we cannot add the new element to \
	109	the list. */ \
	110	if (newp != NULL) { \
	111	newp->address = (addr); \
	112	newp->next = (list); \
	113	(list) = newp; \
	114	} \
	115	} while (0)
	116	# define FREE_BLOCKS(list) \
	117	do { \
	118	while (list != NULL) { \
	119	struct block_list *old = list; \
	120	list = list->next; \
	121	free (old); \
	122	} \
	123	} while (0)
	124	# undef alloca
	125	# define alloca(size) (malloc (size))
	126	#endif /* have alloca */
	127
	128
	129	struct alias_map
	130	{
	131	const char *alias;
	132	const char *value;
	133	};
	134
	135
1491f078 BE	136	static char *string_space = NULL;
	137	static size_t string_space_act = 0;
	138	static size_t string_space_max = 0;
252b5132 RH	139	static struct alias_map *map;
	140	static size_t nmap = 0;
	141	static size_t maxmap = 0;
	142
	143
	144	/* Prototypes for local functions. */
1491f078 BE	145	static size_t read_alias_file PARAMS ((const char *fname, int fname_len))
1491f078 BE	146	internal_function;
252b5132 RH	147	static void extend_alias_table PARAMS ((void));
	148	static int alias_compare PARAMS ((const struct alias_map *map1,
	149	const struct alias_map *map2));
	150
	151
	152	const char *
	153	_nl_expand_alias (name)
	154	const char *name;
	155	{
	156	static const char *locale_alias_path = LOCALE_ALIAS_PATH;
	157	struct alias_map *retval;
1491f078	158	const char *result = NULL;
252b5132 RH	159	size_t added;
252b5132 RH	160
1491f078 BE	161	#ifdef _LIBC
	162	__libc_lock_lock (lock);
	163	#endif
	164
252b5132 RH	165	do
	166	{
	167	struct alias_map item;
	168
	169	item.alias = name;
	170
	171	if (nmap > 0)
	172	retval = (struct alias_map *) bsearch (&item, map, nmap,
	173	sizeof (struct alias_map),
	174	(int () PARAMS ((const void ,
	175	const void *))
	176	) alias_compare);
	177	else
	178	retval = NULL;
	179
	180	/* We really found an alias. Return the value. */
	181	if (retval != NULL)
1491f078 BE	182	{
	183	result = retval->value;
	184	break;
	185	}
252b5132 RH	186
	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;
	192
	193	while (locale_alias_path[0] == ':')
	194	++locale_alias_path;
	195	start = locale_alias_path;
	196
	197	while (locale_alias_path[0] != '\0' && locale_alias_path[0] != ':')
	198	++locale_alias_path;
	199
	200	if (start < locale_alias_path)
	201	added = read_alias_file (start, locale_alias_path - start);
	202	}
	203	}
	204	while (added != 0);
	205
1491f078 BE	206	#ifdef _LIBC
	207	__libc_lock_unlock (lock);
	208	#endif
	209
	210	return result;
252b5132 RH	211	}
	212
	213
	214	static size_t
1491f078	215	internal_function
252b5132 RH	216	read_alias_file (fname, fname_len)
	217	const char *fname;
	218	int fname_len;
	219	{
	220	#ifndef HAVE_ALLOCA
	221	struct block_list *block_list = NULL;
	222	#endif
	223	FILE *fp;
	224	char *full_fname;
	225	size_t added;
	226	static const char aliasfile[] = "/locale.alias";
	227
	228	full_fname = (char *) alloca (fname_len + sizeof aliasfile);
	229	ADD_BLOCK (block_list, full_fname);
1491f078 BE	230	#ifdef HAVE_MEMPCPY
	231	mempcpy (mempcpy (full_fname, fname, fname_len),
	232	aliasfile, sizeof aliasfile);
	233	#else
252b5132 RH	234	memcpy (full_fname, fname, fname_len);
252b5132 RH	235	memcpy (&full_fname[fname_len], aliasfile, sizeof aliasfile);
1491f078	236	#endif
252b5132 RH	237
	238	fp = fopen (full_fname, "r");
	239	if (fp == NULL)
	240	{
	241	FREE_BLOCKS (block_list);
	242	return 0;
	243	}
	244
	245	added = 0;
	246	while (!feof (fp))
	247	{
	248	/* It is a reasonable approach to use a fix buffer here because
	249	a) we are only interested in the first two fields
	250	b) these fields must be usable as file names and so must not
	251	be that long
	252	*/
1491f078 BE	253	unsigned char buf[BUFSIZ];
	254	unsigned char *alias;
	255	unsigned char *value;
	256	unsigned char *cp;
252b5132	257
1491f078	258	if (fgets (buf, sizeof buf, fp) == NULL)
252b5132 RH	259	/* EOF reached. */
	260	break;
	261
1491f078 BE	262	/* Possibly not the whole line fits into the buffer. Ignore
	263	the rest of the line. */
	264	if (strchr (buf, '\n') == NULL)
	265	{
	266	char altbuf[BUFSIZ];
	267	do
	268	if (fgets (altbuf, sizeof altbuf, fp) == NULL)
	269	/* Make sure the inner loop will be left. The outer loop
	270	will exit at the `feof' test. */
	271	break;
	272	while (strchr (altbuf, '\n') == NULL);
	273	}
	274
252b5132 RH	275	cp = buf;
	276	/* Ignore leading white space. */
	277	while (isspace (cp[0]))
	278	++cp;
	279
	280	/* A leading '#' signals a comment line. */
	281	if (cp[0] != '\0' && cp[0] != '#')
	282	{
	283	alias = cp++;
	284	while (cp[0] != '\0' && !isspace (cp[0]))
	285	++cp;
	286	/* Terminate alias name. */
	287	if (cp[0] != '\0')
	288	*cp++ = '\0';
	289
	290	/* Now look for the beginning of the value. */
	291	while (isspace (cp[0]))
	292	++cp;
	293
	294	if (cp[0] != '\0')
	295	{
1491f078 BE	296	size_t alias_len;
1491f078 BE	297	size_t value_len;
252b5132 RH	298
	299	value = cp++;
	300	while (cp[0] != '\0' && !isspace (cp[0]))
	301	++cp;
	302	/* Terminate value. */
	303	if (cp[0] == '\n')
	304	{
	305	/* This has to be done to make the following test
	306	for the end of line possible. We are looking for
	307	the terminating '\n' which do not overwrite here. */
	308	*cp++ = '\0';
	309	*cp = '\n';
	310	}
	311	else if (cp[0] != '\0')
	312	*cp++ = '\0';
	313
	314	if (nmap >= maxmap)
	315	extend_alias_table ();
	316
1491f078 BE	317	alias_len = strlen (alias) + 1;
1491f078 BE	318	value_len = strlen (value) + 1;
252b5132	319
1491f078	320	if (string_space_act + alias_len + value_len > string_space_max)
252b5132	321	{
1491f078 BE	322	/* Increase size of memory pool. */
	323	size_t new_size = (string_space_max
	324	+ (alias_len + value_len > 1024
	325	? alias_len + value_len : 1024));
	326	char new_pool = (char ) realloc (string_space, new_size);
	327	if (new_pool == NULL)
	328	{
	329	FREE_BLOCKS (block_list);
	330	return added;
	331	}
	332	string_space = new_pool;
	333	string_space_max = new_size;
252b5132	334	}
1491f078 BE	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;
252b5132 RH	343
	344	++nmap;
	345	++added;
	346	}
	347	}
252b5132 RH	348	}
	349
	350	/* Should we test for ferror()? I think we have to silently ignore
	351	errors. --drepper */
	352	fclose (fp);
	353
	354	if (added > 0)
	355	qsort (map, nmap, sizeof (struct alias_map),
	356	(int () PARAMS ((const void , const void *))) alias_compare);
	357
	358	FREE_BLOCKS (block_list);
	359	return added;
	360	}
	361
	362
	363	static void
	364	extend_alias_table ()
	365	{
	366	size_t new_size;
	367	struct alias_map *new_map;
	368
	369	new_size = maxmap == 0 ? 100 : 2 * maxmap;
1491f078 BE	370	new_map = (struct alias_map *) realloc (map, (new_size
1491f078 BE	371	* sizeof (struct alias_map)));
252b5132 RH	372	if (new_map == NULL)
	373	/* Simply don't extend: we don't have any more core. */
	374	return;
	375
252b5132 RH	376	map = new_map;
	377	maxmap = new_size;
	378	}
	379
	380
1491f078 BE	381	#ifdef _LIBC
	382	static void __attribute__ ((unused))
	383	free_mem (void)
	384	{
	385	if (string_space != NULL)
	386	free (string_space);
	387	if (map != NULL)
	388	free (map);
	389	}
	390	text_set_element (__libc_subfreeres, free_mem);
	391	#endif
	392
	393
252b5132 RH	394	static int
	395	alias_compare (map1, map2)
	396	const struct alias_map *map1;
	397	const struct alias_map *map2;
	398	{
	399	#if defined _LIBC \|\| defined HAVE_STRCASECMP
	400	return strcasecmp (map1->alias, map2->alias);
	401	#else
	402	const unsigned char p1 = (const unsigned char ) map1->alias;
	403	const unsigned char p2 = (const unsigned char ) map2->alias;
	404	unsigned char c1, c2;
	405
	406	if (p1 == p2)
	407	return 0;
	408
	409	do
	410	{
	411	/* I know this seems to be odd but the tolower() function in
	412	some systems libc cannot handle nonalpha characters. */
	413	c1 = isupper (p1) ? tolower (p1) : *p1;
	414	c2 = isupper (p2) ? tolower (p2) : *p2;
	415	if (c1 == '\0')
	416	break;
	417	++p1;
	418	++p2;
	419	}
	420	while (c1 == c2);
	421
	422	return c1 - c2;
	423	#endif
	424	}