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