[glibc.git] / intl / l10nflist.c

/* Copyright (C) 1995-1999, 2000, 2001 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

/* Tell glibc's <string.h> to provide a prototype for stpcpy().
   This must come before <config.h> because <config.h> may include
   <features.h>, and once <features.h> has been included, it's too late.  */
#ifndef _GNU_SOURCE
# define _GNU_SOURCE	1
#endif

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif


#if defined HAVE_STRING_H || defined _LIBC
# include <string.h>
#else
# include <strings.h>
# ifndef memcpy
#  define memcpy(Dst, Src, Num) (bcopy (Src, Dst, Num), (Dst))
# endif
#endif
#if !HAVE_STRCHR && !defined _LIBC
# ifndef strchr
#  define strchr index
# endif
#endif

#if defined _LIBC || defined HAVE_ARGZ_H
# include <argz.h>
#endif
#include <ctype.h>
#include <sys/types.h>

#if defined STDC_HEADERS || defined _LIBC
# include <stdlib.h>
#endif

#include "loadinfo.h"

/* On some strange systems still no definition of NULL is found.  Sigh!  */
#ifndef NULL
# if defined __STDC__ && __STDC__
#  define NULL ((void *) 0)
# else
#  define NULL 0
# endif
#endif

/* @@ 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.  */
# ifndef stpcpy
#  define stpcpy(dest, src) __stpcpy(dest, src)
# endif
#else
# ifndef HAVE_STPCPY
static char *stpcpy PARAMS ((char *dest, const char *src));
# endif
#endif

/* Define function which are usually not available.  */

#if !defined _LIBC && !defined HAVE___ARGZ_COUNT
/* Returns the number of strings in ARGZ.  */
static size_t argz_count__ PARAMS ((const char *argz, size_t len));

static size_t
argz_count__ (argz, len)
     const char *argz;
     size_t len;
{
  size_t count = 0;
  while (len > 0)
    {
      size_t part_len = strlen (argz);
      argz += part_len + 1;
      len -= part_len + 1;
      count++;
    }
  return count;
}
# undef __argz_count
# define __argz_count(argz, len) argz_count__ (argz, len)
#endif	/* !_LIBC && !HAVE___ARGZ_COUNT */

#if !defined _LIBC && !defined HAVE___ARGZ_STRINGIFY
/* Make '\0' separated arg vector ARGZ printable by converting all the '\0's
   except the last into the character SEP.  */
static void argz_stringify__ PARAMS ((char *argz, size_t len, int sep));

static void
argz_stringify__ (argz, len, sep)
     char *argz;
     size_t len;
     int sep;
{
  while (len > 0)
    {
      size_t part_len = strlen (argz);
      argz += part_len;
      len -= part_len + 1;
      if (len > 0)
	*argz++ = sep;
    }
}
# undef __argz_stringify
# define __argz_stringify(argz, len, sep) argz_stringify__ (argz, len, sep)
#endif	/* !_LIBC && !HAVE___ARGZ_STRINGIFY */

#if !defined _LIBC && !defined HAVE___ARGZ_NEXT
static char *argz_next__ PARAMS ((char *argz, size_t argz_len,
				  const char *entry));

static char *
argz_next__ (argz, argz_len, entry)
     char *argz;
     size_t argz_len;
     const char *entry;
{
  if (entry)
    {
      if (entry < argz + argz_len)
        entry = strchr (entry, '\0') + 1;

      return entry >= argz + argz_len ? NULL : (char *) entry;
    }
  else
    if (argz_len > 0)
      return argz;
    else
      return 0;
}
# undef __argz_next
# define __argz_next(argz, len, entry) argz_next__ (argz, len, entry)
#endif	/* !_LIBC && !HAVE___ARGZ_NEXT */


/* Return number of bits set in X.  */
static int pop PARAMS ((int x));

static inline int
pop (x)
     int x;
{
  /* We assume that no more than 16 bits are used.  */
  x = ((x & ~0x5555) >> 1) + (x & 0x5555);
  x = ((x & ~0x3333) >> 2) + (x & 0x3333);
  x = ((x >> 4) + x) & 0x0f0f;
  x = ((x >> 8) + x) & 0xff;

  return x;
}

\f
struct loaded_l10nfile *
_nl_make_l10nflist (l10nfile_list, dirlist, dirlist_len, mask, language,
		    territory, codeset, normalized_codeset, modifier, special,
		    sponsor, revision, filename, do_allocate)
     struct loaded_l10nfile **l10nfile_list;
     const char *dirlist;
     size_t dirlist_len;
     int mask;
     const char *language;
     const char *territory;
     const char *codeset;
     const char *normalized_codeset;
     const char *modifier;
     const char *special;
     const char *sponsor;
     const char *revision;
     const char *filename;
     int do_allocate;
{
  char *abs_filename;
  struct loaded_l10nfile *last = NULL;
  struct loaded_l10nfile *retval;
  char *cp;
  size_t entries;
  int cnt;

  /* Allocate room for the full file name.  */
  abs_filename = (char *) malloc (dirlist_len
				  + strlen (language)
				  + ((mask & TERRITORY) != 0
				     ? strlen (territory) + 1 : 0)
				  + ((mask & XPG_CODESET) != 0
				     ? strlen (codeset) + 1 : 0)
				  + ((mask & XPG_NORM_CODESET) != 0
				     ? strlen (normalized_codeset) + 1 : 0)
				  + (((mask & XPG_MODIFIER) != 0
				      || (mask & CEN_AUDIENCE) != 0)
				     ? strlen (modifier) + 1 : 0)
				  + ((mask & CEN_SPECIAL) != 0
				     ? strlen (special) + 1 : 0)
				  + (((mask & CEN_SPONSOR) != 0
				      || (mask & CEN_REVISION) != 0)
				     ? (1 + ((mask & CEN_SPONSOR) != 0
					     ? strlen (sponsor) + 1 : 0)
					+ ((mask & CEN_REVISION) != 0
					   ? strlen (revision) + 1 : 0)) : 0)
				  + 1 + strlen (filename) + 1);

  if (abs_filename == NULL)
    return NULL;

  retval = NULL;
  last = NULL;

  /* Construct file name.  */
  memcpy (abs_filename, dirlist, dirlist_len);
  __argz_stringify (abs_filename, dirlist_len, ':');
  cp = abs_filename + (dirlist_len - 1);
  *cp++ = '/';
  cp = stpcpy (cp, language);

  if ((mask & TERRITORY) != 0)
    {
      *cp++ = '_';
      cp = stpcpy (cp, territory);
    }
  if ((mask & XPG_CODESET) != 0)
    {
      *cp++ = '.';
      cp = stpcpy (cp, codeset);
    }
  if ((mask & XPG_NORM_CODESET) != 0)
    {
      *cp++ = '.';
      cp = stpcpy (cp, normalized_codeset);
    }
  if ((mask & (XPG_MODIFIER | CEN_AUDIENCE)) != 0)
    {
      /* This component can be part of both syntaces but has different
	 leading characters.  For CEN we use `+', else `@'.  */
      *cp++ = (mask & CEN_AUDIENCE) != 0 ? '+' : '@';
      cp = stpcpy (cp, modifier);
    }
  if ((mask & CEN_SPECIAL) != 0)
    {
      *cp++ = '+';
      cp = stpcpy (cp, special);
    }
  if ((mask & (CEN_SPONSOR | CEN_REVISION)) != 0)
    {
      *cp++ = ',';
      if ((mask & CEN_SPONSOR) != 0)
	cp = stpcpy (cp, sponsor);
      if ((mask & CEN_REVISION) != 0)
	{
	  *cp++ = '_';
	  cp = stpcpy (cp, revision);
	}
    }

  *cp++ = '/';
  stpcpy (cp, filename);

  /* Look in list of already loaded domains whether it is already
     available.  */
  last = NULL;
  for (retval = *l10nfile_list; retval != NULL; retval = retval->next)
    if (retval->filename != NULL)
      {
	int compare = strcmp (retval->filename, abs_filename);
	if (compare == 0)
	  /* We found it!  */
	  break;
	if (compare < 0)
	  {
	    /* It's not in the list.  */
	    retval = NULL;
	    break;
	  }

	last = retval;
      }

  if (retval != NULL || do_allocate == 0)
    {
      free (abs_filename);
      return retval;
    }

  retval = (struct loaded_l10nfile *)
    malloc (sizeof (*retval) + (__argz_count (dirlist, dirlist_len)
				* (1 << pop (mask))
				* sizeof (struct loaded_l10nfile *)));
  if (retval == NULL)
    return NULL;

  retval->filename = abs_filename;
  retval->decided = (__argz_count (dirlist, dirlist_len) != 1
		     || ((mask & XPG_CODESET) != 0
			 && (mask & XPG_NORM_CODESET) != 0));
  retval->data = NULL;

  if (last == NULL)
    {
      retval->next = *l10nfile_list;
      *l10nfile_list = retval;
    }
  else
    {
      retval->next = last->next;
      last->next = retval;
    }

  entries = 0;
  /* If the DIRLIST is a real list the RETVAL entry corresponds not to
     a real file.  So we have to use the DIRLIST separation mechanism
     of the inner loop.  */
  cnt = __argz_count (dirlist, dirlist_len) == 1 ? mask - 1 : mask;
  for (; cnt >= 0; --cnt)
    if ((cnt & ~mask) == 0
	&& ((cnt & CEN_SPECIFIC) == 0 || (cnt & XPG_SPECIFIC) == 0)
	&& ((cnt & XPG_CODESET) == 0 || (cnt & XPG_NORM_CODESET) == 0))
      {
	/* Iterate over all elements of the DIRLIST.  */
	char *dir = NULL;

	while ((dir = __argz_next ((char *) dirlist, dirlist_len, dir))
	       != NULL)
	  retval->successor[entries++]
	    = _nl_make_l10nflist (l10nfile_list, dir, strlen (dir) + 1, cnt,
				  language, territory, codeset,
				  normalized_codeset, modifier, special,
				  sponsor, revision, filename, 1);
      }
  retval->successor[entries] = NULL;

  return retval;
}
\f
/* Normalize codeset name.  There is no standard for the codeset
   names.  Normalization allows the user to use any of the common
   names.  The return value is dynamically allocated and has to be
   freed by the caller.  */
const char *
_nl_normalize_codeset (codeset, name_len)
     const char *codeset;
     size_t name_len;
{
  int len = 0;
  int only_digit = 1;
  char *retval;
  char *wp;
  size_t cnt;

  for (cnt = 0; cnt < name_len; ++cnt)
    if (isalnum (codeset[cnt]))
      {
	++len;

	if (isalpha (codeset[cnt]))
	  only_digit = 0;
      }

  retval = (char *) malloc ((only_digit ? 3 : 0) + len + 1);

  if (retval != NULL)
    {
      if (only_digit)
	wp = stpcpy (retval, "iso");
      else
	wp = retval;

      for (cnt = 0; cnt < name_len; ++cnt)
	if (isalpha (codeset[cnt]))
	  *wp++ = tolower (codeset[cnt]);
	else if (isdigit (codeset[cnt]))
	  *wp++ = codeset[cnt];

      *wp = '\0';
    }

  return (const char *) retval;
}


/* @@ begin of epilog @@ */

/* We don't want libintl.a to depend on any other library.  So we
   avoid the non-standard function stpcpy.  In GNU C Library this
   function is available, though.  Also allow the symbol HAVE_STPCPY
   to be defined.  */
#if !_LIBC && !HAVE_STPCPY
static char *
stpcpy (dest, src)
     char *dest;
     const char *src;
{
  while ((*dest++ = *src++) != '\0')
    /* Do nothing. */ ;
  return dest - 1;
}
#endif
Commit	Line	Data
4a4d50f3	1	/* Copyright (C) 1995-1999, 2000, 2001 Free Software Foundation, Inc.
41bdb6e2	2	This file is part of the GNU C Library.
e4cf5070	3	Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
7a12c6bb	4
e4cf5070	5	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
7a12c6bb	9
e4cf5070 UD	10	The GNU C Library 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 GNU
41bdb6e2	13	Lesser General Public License for more details.
7a12c6bb	14
41bdb6e2 AJ	15	You should have received a copy of the GNU Lesser General Public
	16	License along with the GNU C Library; if not, write to the Free
	17	Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
	18	02111-1307 USA. */
7a12c6bb	19
0a55a284 UD	20	/* Tell glibc's <string.h> to provide a prototype for stpcpy().
	21	This must come before <config.h> because <config.h> may include
	22	<features.h>, and once <features.h> has been included, it's too late. */
	23	#ifndef _GNU_SOURCE
	24	# define _GNU_SOURCE 1
	25	#endif
	26
92f3773b RM	27	#ifdef HAVE_CONFIG_H
	28	# include <config.h>
	29	#endif
	30
92f3773b RM	31
	32	#if defined HAVE_STRING_H \|\| defined _LIBC
	33	# include <string.h>
	34	#else
	35	# include <strings.h>
8f2ece69	36	# ifndef memcpy
61402fd6	37	# define memcpy(Dst, Src, Num) (bcopy (Src, Dst, Num), (Dst))
8f2ece69	38	# endif
92f3773b RM	39	#endif
	40	#if !HAVE_STRCHR && !defined _LIBC
	41	# ifndef strchr
	42	# define strchr index
	43	# endif
	44	#endif
7a12c6bb	45
96e1bff2 RM	46	#if defined _LIBC \|\| defined HAVE_ARGZ_H
	47	# include <argz.h>
	48	#endif
	49	#include <ctype.h>
0c5ecdc4	50	#include <sys/types.h>
96e1bff2 RM	51
	52	#if defined STDC_HEADERS \|\| defined _LIBC
	53	# include <stdlib.h>
	54	#endif
	55
7a12c6bb RM	56	#include "loadinfo.h"
7a12c6bb RM	57
842907c6 RM	58	/* On some strange systems still no definition of NULL is found. Sigh! */
	59	#ifndef NULL
	60	# if defined __STDC__ && __STDC__
	61	# define NULL ((void *) 0)
	62	# else
	63	# define NULL 0
	64	# endif
	65	#endif
	66
92f3773b RM	67	/* @@ end of prolog @@ */
	68
	69	#ifdef _LIBC
	70	/* Rename the non ANSI C functions. This is required by the standard
	71	because some ANSI C functions will require linking with this object
	72	file and the name space must not be polluted. */
9a0a462c UD	73	# ifndef stpcpy
	74	# define stpcpy(dest, src) __stpcpy(dest, src)
	75	# endif
92f3773b RM	76	#else
	77	# ifndef HAVE_STPCPY
	78	static char stpcpy PARAMS ((char dest, const char *src));
	79	# endif
	80	#endif
	81
5f2eab42 RM	82	/* Define function which are usually not available. */
5f2eab42 RM	83
842907c6	84	#if !defined _LIBC && !defined HAVE___ARGZ_COUNT
5f2eab42	85	/* Returns the number of strings in ARGZ. */
842907c6	86	static size_t argz_count__ PARAMS ((const char *argz, size_t len));
5f2eab42 RM	87
5f2eab42 RM	88	static size_t
842907c6	89	argz_count__ (argz, len)
5f2eab42 RM	90	const char *argz;
	91	size_t len;
	92	{
	93	size_t count = 0;
	94	while (len > 0)
	95	{
92f3773b	96	size_t part_len = strlen (argz);
5f2eab42 RM	97	argz += part_len + 1;
	98	len -= part_len + 1;
	99	count++;
	100	}
	101	return count;
	102	}
842907c6 RM	103	# undef __argz_count
	104	# define __argz_count(argz, len) argz_count__ (argz, len)
	105	#endif /* !_LIBC && !HAVE___ARGZ_COUNT */
5f2eab42	106
842907c6	107	#if !defined _LIBC && !defined HAVE___ARGZ_STRINGIFY
5f2eab42 RM	108	/* Make '\0' separated arg vector ARGZ printable by converting all the '\0's
5f2eab42 RM	109	except the last into the character SEP. */
842907c6	110	static void argz_stringify__ PARAMS ((char *argz, size_t len, int sep));
5f2eab42 RM	111
5f2eab42 RM	112	static void
842907c6	113	argz_stringify__ (argz, len, sep)
5f2eab42 RM	114	char *argz;
	115	size_t len;
	116	int sep;
	117	{
	118	while (len > 0)
	119	{
92f3773b	120	size_t part_len = strlen (argz);
5f2eab42 RM	121	argz += part_len;
	122	len -= part_len + 1;
	123	if (len > 0)
	124	*argz++ = sep;
	125	}
	126	}
842907c6 RM	127	# undef __argz_stringify
	128	# define __argz_stringify(argz, len, sep) argz_stringify__ (argz, len, sep)
	129	#endif /* !_LIBC && !HAVE___ARGZ_STRINGIFY */
	130
	131	#if !defined _LIBC && !defined HAVE___ARGZ_NEXT
	132	static char argz_next__ PARAMS ((char argz, size_t argz_len,
	133	const char *entry));
5f2eab42	134
5f2eab42	135	static char *
842907c6	136	argz_next__ (argz, argz_len, entry)
92f3773b RM	137	char *argz;
	138	size_t argz_len;
	139	const char *entry;
5f2eab42 RM	140	{
	141	if (entry)
	142	{
	143	if (entry < argz + argz_len)
	144	entry = strchr (entry, '\0') + 1;
	145
	146	return entry >= argz + argz_len ? NULL : (char *) entry;
	147	}
	148	else
	149	if (argz_len > 0)
	150	return argz;
	151	else
	152	return 0;
	153	}
842907c6 RM	154	# undef __argz_next
	155	# define __argz_next(argz, len, entry) argz_next__ (argz, len, entry)
	156	#endif /* !_LIBC && !HAVE___ARGZ_NEXT */
5f2eab42 RM	157
5f2eab42 RM	158
7a12c6bb	159	/* Return number of bits set in X. */
92f3773b	160	static int pop PARAMS ((int x));
7a12c6bb RM	161
	162	static inline int
	163	pop (x)
	164	int x;
	165	{
	166	/* We assume that no more than 16 bits are used. */
	167	x = ((x & ~0x5555) >> 1) + (x & 0x5555);
	168	x = ((x & ~0x3333) >> 2) + (x & 0x3333);
	169	x = ((x >> 4) + x) & 0x0f0f;
	170	x = ((x >> 8) + x) & 0xff;
	171
	172	return x;
	173	}
	174
5f2eab42	175	\f
7a12c6bb RM	176	struct loaded_l10nfile *
	177	_nl_make_l10nflist (l10nfile_list, dirlist, dirlist_len, mask, language,
	178	territory, codeset, normalized_codeset, modifier, special,
c44a663d	179	sponsor, revision, filename, do_allocate)
7a12c6bb RM	180	struct loaded_l10nfile **l10nfile_list;
	181	const char *dirlist;
	182	size_t dirlist_len;
	183	int mask;
	184	const char *language;
	185	const char *territory;
	186	const char *codeset;
	187	const char *normalized_codeset;
	188	const char *modifier;
	189	const char *special;
	190	const char *sponsor;
	191	const char *revision;
	192	const char *filename;
	193	int do_allocate;
	194	{
	195	char *abs_filename;
	196	struct loaded_l10nfile *last = NULL;
	197	struct loaded_l10nfile *retval;
	198	char *cp;
	199	size_t entries;
	200	int cnt;
	201
	202	/* Allocate room for the full file name. */
	203	abs_filename = (char *) malloc (dirlist_len
	204	+ strlen (language)
	205	+ ((mask & TERRITORY) != 0
	206	? strlen (territory) + 1 : 0)
	207	+ ((mask & XPG_CODESET) != 0
	208	? strlen (codeset) + 1 : 0)
	209	+ ((mask & XPG_NORM_CODESET) != 0
	210	? strlen (normalized_codeset) + 1 : 0)
	211	+ (((mask & XPG_MODIFIER) != 0
47707456 UD	212	\|\| (mask & CEN_AUDIENCE) != 0)
47707456 UD	213	? strlen (modifier) + 1 : 0)
7a12c6bb RM	214	+ ((mask & CEN_SPECIAL) != 0
7a12c6bb RM	215	? strlen (special) + 1 : 0)
1fb05e3d UD	216	+ (((mask & CEN_SPONSOR) != 0
1fb05e3d UD	217	\|\| (mask & CEN_REVISION) != 0)
e4cf5070 UD	218	? (1 + ((mask & CEN_SPONSOR) != 0
	219	? strlen (sponsor) + 1 : 0)
	220	+ ((mask & CEN_REVISION) != 0
	221	? strlen (revision) + 1 : 0)) : 0)
7a12c6bb RM	222	+ 1 + strlen (filename) + 1);
	223
	224	if (abs_filename == NULL)
	225	return NULL;
	226
	227	retval = NULL;
	228	last = NULL;
	229
	230	/* Construct file name. */
	231	memcpy (abs_filename, dirlist, dirlist_len);
	232	__argz_stringify (abs_filename, dirlist_len, ':');
	233	cp = abs_filename + (dirlist_len - 1);
	234	*cp++ = '/';
	235	cp = stpcpy (cp, language);
	236
	237	if ((mask & TERRITORY) != 0)
	238	{
	239	*cp++ = '_';
	240	cp = stpcpy (cp, territory);
	241	}
	242	if ((mask & XPG_CODESET) != 0)
	243	{
	244	*cp++ = '.';
	245	cp = stpcpy (cp, codeset);
	246	}
	247	if ((mask & XPG_NORM_CODESET) != 0)
	248	{
	249	*cp++ = '.';
	250	cp = stpcpy (cp, normalized_codeset);
	251	}
	252	if ((mask & (XPG_MODIFIER \| CEN_AUDIENCE)) != 0)
	253	{
	254	/* This component can be part of both syntaces but has different
	255	leading characters. For CEN we use `+', else `@'. */
	256	*cp++ = (mask & CEN_AUDIENCE) != 0 ? '+' : '@';
	257	cp = stpcpy (cp, modifier);
	258	}
	259	if ((mask & CEN_SPECIAL) != 0)
	260	{
	261	*cp++ = '+';
	262	cp = stpcpy (cp, special);
	263	}
e4cf5070	264	if ((mask & (CEN_SPONSOR \| CEN_REVISION)) != 0)
7a12c6bb RM	265	{
7a12c6bb RM	266	*cp++ = ',';
e4cf5070 UD	267	if ((mask & CEN_SPONSOR) != 0)
	268	cp = stpcpy (cp, sponsor);
	269	if ((mask & CEN_REVISION) != 0)
	270	{
	271	*cp++ = '_';
	272	cp = stpcpy (cp, revision);
	273	}
7a12c6bb RM	274	}
	275
	276	*cp++ = '/';
	277	stpcpy (cp, filename);
	278
	279	/* Look in list of already loaded domains whether it is already
	280	available. */
	281	last = NULL;
	282	for (retval = *l10nfile_list; retval != NULL; retval = retval->next)
	283	if (retval->filename != NULL)
	284	{
	285	int compare = strcmp (retval->filename, abs_filename);
	286	if (compare == 0)
	287	/* We found it! */
	288	break;
	289	if (compare < 0)
	290	{
	291	/* It's not in the list. */
	292	retval = NULL;
	293	break;
	294	}
	295
	296	last = retval;
	297	}
	298
	299	if (retval != NULL \|\| do_allocate == 0)
	300	{
	301	free (abs_filename);
	302	return retval;
	303	}
	304
	305	retval = (struct loaded_l10nfile *)
	306	malloc (sizeof (*retval) + (__argz_count (dirlist, dirlist_len)
	307	* (1 << pop (mask))
	308	* sizeof (struct loaded_l10nfile *)));
	309	if (retval == NULL)
	310	return NULL;
	311
	312	retval->filename = abs_filename;
	313	retval->decided = (__argz_count (dirlist, dirlist_len) != 1
	314	\|\| ((mask & XPG_CODESET) != 0
	315	&& (mask & XPG_NORM_CODESET) != 0));
	316	retval->data = NULL;
	317
	318	if (last == NULL)
	319	{
	320	retval->next = *l10nfile_list;
	321	*l10nfile_list = retval;
	322	}
	323	else
	324	{
	325	retval->next = last->next;
	326	last->next = retval;
	327	}
	328
	329	entries = 0;
6d52618b UD	330	/* If the DIRLIST is a real list the RETVAL entry corresponds not to
6d52618b UD	331	a real file. So we have to use the DIRLIST separation mechanism
7a12c6bb RM	332	of the inner loop. */
	333	cnt = __argz_count (dirlist, dirlist_len) == 1 ? mask - 1 : mask;
	334	for (; cnt >= 0; --cnt)
	335	if ((cnt & ~mask) == 0
	336	&& ((cnt & CEN_SPECIFIC) == 0 \|\| (cnt & XPG_SPECIFIC) == 0)
	337	&& ((cnt & XPG_CODESET) == 0 \|\| (cnt & XPG_NORM_CODESET) == 0))
	338	{
	339	/* Iterate over all elements of the DIRLIST. */
	340	char *dir = NULL;
	341
	342	while ((dir = __argz_next ((char *) dirlist, dirlist_len, dir))
	343	!= NULL)
	344	retval->successor[entries++]
	345	= _nl_make_l10nflist (l10nfile_list, dir, strlen (dir) + 1, cnt,
	346	language, territory, codeset,
	347	normalized_codeset, modifier, special,
c44a663d	348	sponsor, revision, filename, 1);
7a12c6bb RM	349	}
	350	retval->successor[entries] = NULL;
	351
	352	return retval;
	353	}
	354	\f
	355	/* Normalize codeset name. There is no standard for the codeset
	356	names. Normalization allows the user to use any of the common
727211c4 UD	357	names. The return value is dynamically allocated and has to be
727211c4 UD	358	freed by the caller. */
7a12c6bb RM	359	const char *
7a12c6bb RM	360	_nl_normalize_codeset (codeset, name_len)
8cb569b7	361	const char *codeset;
7a12c6bb RM	362	size_t name_len;
	363	{
	364	int len = 0;
	365	int only_digit = 1;
	366	char *retval;
	367	char *wp;
	368	size_t cnt;
	369
	370	for (cnt = 0; cnt < name_len; ++cnt)
	371	if (isalnum (codeset[cnt]))
	372	{
	373	++len;
	374
	375	if (isalpha (codeset[cnt]))
	376	only_digit = 0;
	377	}
	378
	379	retval = (char *) malloc ((only_digit ? 3 : 0) + len + 1);
	380
	381	if (retval != NULL)
	382	{
	383	if (only_digit)
57ba7bb4	384	wp = stpcpy (retval, "iso");
7a12c6bb RM	385	else
	386	wp = retval;
	387
	388	for (cnt = 0; cnt < name_len; ++cnt)
	389	if (isalpha (codeset[cnt]))
4a4d50f3	390	*wp++ = tolower (codeset[cnt]);
7a12c6bb RM	391	else if (isdigit (codeset[cnt]))
	392	*wp++ = codeset[cnt];
	393
	394	*wp = '\0';
	395	}
	396
	397	return (const char *) retval;
	398	}
92f3773b RM	399
	400
	401	/* @@ begin of epilog @@ */
	402
	403	/* We don't want libintl.a to depend on any other library. So we
	404	avoid the non-standard function stpcpy. In GNU C Library this
	405	function is available, though. Also allow the symbol HAVE_STPCPY
	406	to be defined. */
	407	#if !_LIBC && !HAVE_STPCPY
	408	static char *
	409	stpcpy (dest, src)
	410	char *dest;
	411	const char *src;
	412	{
	413	while ((dest++ = src++) != '\0')
	414	/* Do nothing. */ ;
	415	return dest - 1;
	416	}
	417	#endif