Handle allow-header correctly.
[kopensolaris-gnu/glibc.git] / intl / l10nflist.c
1 /* Copyright (C) 1995-1999, 2000 Free Software Foundation, Inc.
2    Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
3
4    The GNU C Library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Library General Public License as
6    published by the Free Software Foundation; either version 2 of the
7    License, or (at your option) any later version.
8
9    The GNU C Library 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 the GNU C Library; see the file COPYING.LIB.  If not,
16    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17    Boston, MA 02111-1307, 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
31 #if defined HAVE_STRING_H || defined _LIBC
32 # include <string.h>
33 #else
34 # include <strings.h>
35 # ifndef memcpy
36 #  define memcpy(Dst, Src, Num) (bcopy (Src, Dst, Num), (Dst))
37 # endif
38 #endif
39 #if !HAVE_STRCHR && !defined _LIBC
40 # ifndef strchr
41 #  define strchr index
42 # endif
43 #endif
44
45 #if defined _LIBC || defined HAVE_ARGZ_H
46 # include <argz.h>
47 #endif
48 #include <ctype.h>
49 #include <sys/types.h>
50
51 #if defined STDC_HEADERS || defined _LIBC
52 # include <stdlib.h>
53 #endif
54
55 #include "loadinfo.h"
56
57 /* On some strange systems still no definition of NULL is found.  Sigh!  */
58 #ifndef NULL
59 # if defined __STDC__ && __STDC__
60 #  define NULL ((void *) 0)
61 # else
62 #  define NULL 0
63 # endif
64 #endif
65
66 /* @@ end of prolog @@ */
67
68 #ifdef _LIBC
69 /* Rename the non ANSI C functions.  This is required by the standard
70    because some ANSI C functions will require linking with this object
71    file and the name space must not be polluted.  */
72 # ifndef stpcpy
73 #  define stpcpy(dest, src) __stpcpy(dest, src)
74 # endif
75 #else
76 # ifndef HAVE_STPCPY
77 static char *stpcpy PARAMS ((char *dest, const char *src));
78 # endif
79 #endif
80
81 /* Define function which are usually not available.  */
82
83 #if !defined _LIBC && !defined HAVE___ARGZ_COUNT
84 /* Returns the number of strings in ARGZ.  */
85 static size_t argz_count__ PARAMS ((const char *argz, size_t len));
86
87 static size_t
88 argz_count__ (argz, len)
89      const char *argz;
90      size_t len;
91 {
92   size_t count = 0;
93   while (len > 0)
94     {
95       size_t part_len = strlen (argz);
96       argz += part_len + 1;
97       len -= part_len + 1;
98       count++;
99     }
100   return count;
101 }
102 # undef __argz_count
103 # define __argz_count(argz, len) argz_count__ (argz, len)
104 #endif  /* !_LIBC && !HAVE___ARGZ_COUNT */
105
106 #if !defined _LIBC && !defined HAVE___ARGZ_STRINGIFY
107 /* Make '\0' separated arg vector ARGZ printable by converting all the '\0's
108    except the last into the character SEP.  */
109 static void argz_stringify__ PARAMS ((char *argz, size_t len, int sep));
110
111 static void
112 argz_stringify__ (argz, len, sep)
113      char *argz;
114      size_t len;
115      int sep;
116 {
117   while (len > 0)
118     {
119       size_t part_len = strlen (argz);
120       argz += part_len;
121       len -= part_len + 1;
122       if (len > 0)
123         *argz++ = sep;
124     }
125 }
126 # undef __argz_stringify
127 # define __argz_stringify(argz, len, sep) argz_stringify__ (argz, len, sep)
128 #endif  /* !_LIBC && !HAVE___ARGZ_STRINGIFY */
129
130 #if !defined _LIBC && !defined HAVE___ARGZ_NEXT
131 static char *argz_next__ PARAMS ((char *argz, size_t argz_len,
132                                   const char *entry));
133
134 static char *
135 argz_next__ (argz, argz_len, entry)
136      char *argz;
137      size_t argz_len;
138      const char *entry;
139 {
140   if (entry)
141     {
142       if (entry < argz + argz_len)
143         entry = strchr (entry, '\0') + 1;
144
145       return entry >= argz + argz_len ? NULL : (char *) entry;
146     }
147   else
148     if (argz_len > 0)
149       return argz;
150     else
151       return 0;
152 }
153 # undef __argz_next
154 # define __argz_next(argz, len, entry) argz_next__ (argz, len, entry)
155 #endif  /* !_LIBC && !HAVE___ARGZ_NEXT */
156
157
158 /* Return number of bits set in X.  */
159 static int pop PARAMS ((int x));
160
161 static inline int
162 pop (x)
163      int x;
164 {
165   /* We assume that no more than 16 bits are used.  */
166   x = ((x & ~0x5555) >> 1) + (x & 0x5555);
167   x = ((x & ~0x3333) >> 2) + (x & 0x3333);
168   x = ((x >> 4) + x) & 0x0f0f;
169   x = ((x >> 8) + x) & 0xff;
170
171   return x;
172 }
173
174 \f
175 struct loaded_l10nfile *
176 _nl_make_l10nflist (l10nfile_list, dirlist, dirlist_len, mask, language,
177                     territory, codeset, normalized_codeset, modifier, special,
178                     sponsor, revision, filename, domainbinding, do_allocate)
179      struct loaded_l10nfile **l10nfile_list;
180      const char *dirlist;
181      size_t dirlist_len;
182      int mask;
183      const char *language;
184      const char *territory;
185      const char *codeset;
186      const char *normalized_codeset;
187      const char *modifier;
188      const char *special;
189      const char *sponsor;
190      const char *revision;
191      const char *filename;
192      struct binding *domainbinding;
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
212                                       || (mask & CEN_AUDIENCE) != 0)
213                                      ? strlen (modifier) + 1 : 0)
214                                   + ((mask & CEN_SPECIAL) != 0
215                                      ? strlen (special) + 1 : 0)
216                                   + (((mask & CEN_SPONSOR) != 0
217                                       || (mask & CEN_REVISION) != 0)
218                                      ? (1 + ((mask & CEN_SPONSOR) != 0
219                                              ? strlen (sponsor) + 1 : 0)
220                                         + ((mask & CEN_REVISION) != 0
221                                            ? strlen (revision) + 1 : 0)) : 0)
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     }
264   if ((mask & (CEN_SPONSOR | CEN_REVISION)) != 0)
265     {
266       *cp++ = ',';
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         }
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->domainbinding = domainbinding;
314   retval->decided = (__argz_count (dirlist, dirlist_len) != 1
315                      || ((mask & XPG_CODESET) != 0
316                          && (mask & XPG_NORM_CODESET) != 0));
317   retval->data = NULL;
318
319   if (last == NULL)
320     {
321       retval->next = *l10nfile_list;
322       *l10nfile_list = retval;
323     }
324   else
325     {
326       retval->next = last->next;
327       last->next = retval;
328     }
329
330   entries = 0;
331   /* If the DIRLIST is a real list the RETVAL entry corresponds not to
332      a real file.  So we have to use the DIRLIST separation mechanism
333      of the inner loop.  */
334   cnt = __argz_count (dirlist, dirlist_len) == 1 ? mask - 1 : mask;
335   for (; cnt >= 0; --cnt)
336     if ((cnt & ~mask) == 0
337         && ((cnt & CEN_SPECIFIC) == 0 || (cnt & XPG_SPECIFIC) == 0)
338         && ((cnt & XPG_CODESET) == 0 || (cnt & XPG_NORM_CODESET) == 0))
339       {
340         /* Iterate over all elements of the DIRLIST.  */
341         char *dir = NULL;
342
343         while ((dir = __argz_next ((char *) dirlist, dirlist_len, dir))
344                != NULL)
345           retval->successor[entries++]
346             = _nl_make_l10nflist (l10nfile_list, dir, strlen (dir) + 1, cnt,
347                                   language, territory, codeset,
348                                   normalized_codeset, modifier, special,
349                                   sponsor, revision, filename, domainbinding,
350                                   1);
351       }
352   retval->successor[entries] = NULL;
353
354   return retval;
355 }
356 \f
357 /* Normalize codeset name.  There is no standard for the codeset
358    names.  Normalization allows the user to use any of the common
359    names.  The return value is dynamically allocated and has to be
360    freed by the caller.  */
361 const char *
362 _nl_normalize_codeset (codeset, name_len)
363      const char *codeset;
364      size_t name_len;
365 {
366   int len = 0;
367   int only_digit = 1;
368   char *retval;
369   char *wp;
370   size_t cnt;
371
372   for (cnt = 0; cnt < name_len; ++cnt)
373     if (isalnum (codeset[cnt]))
374       {
375         ++len;
376
377         if (isalpha (codeset[cnt]))
378           only_digit = 0;
379       }
380
381   retval = (char *) malloc ((only_digit ? 3 : 0) + len + 1);
382
383   if (retval != NULL)
384     {
385       if (only_digit)
386         wp = stpcpy (retval, "iso");
387       else
388         wp = retval;
389
390       for (cnt = 0; cnt < name_len; ++cnt)
391         if (isalpha (codeset[cnt]))
392           *wp++ = _tolower (codeset[cnt]);
393         else if (isdigit (codeset[cnt]))
394           *wp++ = codeset[cnt];
395
396       *wp = '\0';
397     }
398
399   return (const char *) retval;
400 }
401
402
403 /* @@ begin of epilog @@ */
404
405 /* We don't want libintl.a to depend on any other library.  So we
406    avoid the non-standard function stpcpy.  In GNU C Library this
407    function is available, though.  Also allow the symbol HAVE_STPCPY
408    to be defined.  */
409 #if !_LIBC && !HAVE_STPCPY
410 static char *
411 stpcpy (dest, src)
412      char *dest;
413      const char *src;
414 {
415   while ((*dest++ = *src++) != '\0')
416     /* Do nothing. */ ;
417   return dest - 1;
418 }
419 #endif