[bison.git] / intl / l10nflist.c

/* Copyright (C) 1995-1999, 2000, 2001 Free Software Foundation, Inc.
   Contributed 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.  */

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

#include <string.h>
#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>
#include <stdlib.h>

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