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