Work around ld bug: don't weakify refs to _nl_{current,C}_*.
[kopensolaris-gnu/glibc.git] / locale / setlocale.c
1 /* Copyright (C) 1991, 1992, 1995 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
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
16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
17 Cambridge, MA 02139, USA.  */
18
19 #include <errno.h>
20 #include <string.h>
21 #include <stdlib.h>
22 #include <locale.h>
23 #include <langinfo.h>
24 #include "localeinfo.h"
25
26 /* For each category declare two external variables (with weak references):
27      extern const struct locale_data *_nl_current_CATEGORY;
28    This points to the current locale's in-core data for CATEGORY.
29      extern const struct locale_data _nl_C_CATEGORY;
30    This contains the built-in "C"/"POSIX" locale's data for CATEGORY.
31    Both are weak references; if &_nl_current_CATEGORY is zero,
32    then nothing is using the locale data.  */
33 #define DEFINE_CATEGORY(category, category_name, items, a, b, c, d) \
34 extern const struct locale_data *_nl_current_##category;                      \
35 extern const struct locale_data _nl_C_##category;                             \
36 /* XXX The linker is broken so we cannot do the weak symbols right just now. */
37 /* weak_symbol (_nl_current_##category) weak_symbol (_nl_C_##category) */
38 #include "categories.def"
39 #undef  DEFINE_CATEGORY
40
41 /* Array indexed by category of pointers to _nl_current_CATEGORY slots.
42    Elements are zero for categories whose data is never used.  */
43 const struct locale_data * *const _nl_current[] =
44 {
45 #define DEFINE_CATEGORY(category, category_name, items, a, b, c, d) \
46   [category] = &_nl_current_##category,
47 #include "categories.def"
48 #undef  DEFINE_CATEGORY
49 };
50
51 /* Array indexed by category of pointers to _nl_C_CATEGORY slots.
52    Elements are zero for categories whose data is never used.  */
53 const struct locale_data *const _nl_C[] =
54 {
55 #define DEFINE_CATEGORY(category, category_name, items, a, b, c, d) \
56   [category] = &_nl_C_##category,
57 #include "categories.def"
58 #undef  DEFINE_CATEGORY
59 };
60
61
62 /* Define an array of category names (also the environment variable names),
63    indexed by integral category.  */
64 const char *const _nl_category_names[] =
65   {
66 #define DEFINE_CATEGORY(category, category_name, items, a, b, c, d) \
67     [category] = category_name,
68 #include "categories.def"
69 #undef  DEFINE_CATEGORY
70   };
71 /* An array of their lengths, for convenience.  */
72 const size_t _nl_category_name_sizes[] =
73   {
74 #define DEFINE_CATEGORY(category, category_name, items, a, b, c, d) \
75     [category] = sizeof (category_name) - 1,
76 #include "categories.def"
77 #undef  DEFINE_CATEGORY
78   };
79
80
81 /* Declare the postload functions used below.  */
82 #undef  NO_POSTLOAD
83 #define NO_POSTLOAD _nl_postload_ctype /* Harmless thing known to exist.  */
84 #define DEFINE_CATEGORY(category, category_name, items, postload, b, c, d) \
85 extern void postload (void);
86 #include "categories.def"
87 #undef  DEFINE_CATEGORY
88 #undef  NO_POSTLOAD
89
90 /* Define an array indexed by category of postload functions to call after
91    loading and installing that category's data.  */
92 void (*const _nl_category_postload[]) (void) =
93   {
94 #define DEFINE_CATEGORY(category, category_name, items, postload, b, c, d) \
95     [category] = postload,
96 #include "categories.def"
97 #undef  DEFINE_CATEGORY
98   };
99
100
101 const char _nl_C_name[] = "C";
102
103 /* Name of current locale for each individual category.
104    Each is malloc'd unless it is nl_C_name.  */
105 const char *_nl_current_names[] =
106   {
107 #define DEFINE_CATEGORY(category, category_name, items, a, b, c, d) \
108     _nl_C_name,
109 #include "categories.def"
110 #undef  DEFINE_CATEGORY
111   };
112
113 /* Composite LC_ALL name for current locale.
114    This is malloc'd unless it's _nl_C_name.  */
115 char *_nl_current_composite_name = (char *) _nl_C_name;
116
117
118 /* Switch to the locale called NAME in CATEGORY.  Return a string
119    describing the locale.  This string can be used as the NAME argument in
120    a later call.  If NAME is NULL, don't switch locales, but return the
121    current one.  If NAME is "", switch to a locale based on the environment
122    variables, as per POSIX.  Return NULL on error.  */
123
124 char *
125 setlocale (int category, const char *name)
126 {
127   /* Return a malloc'd copy of STRING.  */
128   char *copy (const char *string)
129     {
130       size_t len = strlen (string) + 1;
131       char *new = malloc (len);
132       return new ? memcpy (new, string, len) : NULL;
133     }
134
135   /* Construct a new composite name.  */
136   char *new_composite_name (int category, char *newnames[LC_ALL])
137   {
138     size_t lens[LC_ALL], cumlen = 0;
139     int i;
140     char *new, *p;
141     int same = 1;
142
143     for (i = 0; i < LC_ALL; ++i)
144       {
145         char *name = (category == LC_ALL ? newnames[i] :
146                       category == i ? newnames[0] :
147                       (char *) _nl_current_names[i]);
148         lens[i] = strlen (name);
149         cumlen += _nl_category_name_sizes[i] + 1 + lens[i] + 1;
150         if (i > 0 && same && strcmp (name, newnames[0]))
151           same = 0;
152       }
153
154     if (same)
155       {
156         /* All the categories use the same name.  */
157         new = malloc (lens[0] + 1);
158         if (! new)
159           {
160             if (!strcmp (newnames[0], "C") || !strcmp (newnames[0], "POSIX"))
161               return (char *) _nl_C_name;
162             return NULL;
163           }
164         memcpy (new, newnames[0], lens[0] + 1);
165         return new;
166       }
167
168     new = malloc (cumlen);
169     if (! new)
170       return NULL;
171     p = new;
172     for (i = 0; i < LC_ALL; ++i)
173       {
174         /* Add "CATEGORY=NAME;" to the string.  */
175         char *name = (category == LC_ALL ? newnames[i] :
176                       category == i ? newnames[0] :
177                       (char *) _nl_current_names[i]);
178         memcpy (p, _nl_category_names[i], _nl_category_name_sizes[i]);
179         p += _nl_category_name_sizes[i];
180         *p++ = '=';
181         memcpy (p, name, lens[i]);
182         p += lens[i];
183         *p++ = ';';
184       }
185     p[-1] = '\0';               /* Clobber the last ';'.  */
186     return new;
187   }
188   /* Put COMPOSITE in _nl_current_composite_name and free the old value.  */
189   void setcomposite (char *composite)
190     {
191       char *old = _nl_current_composite_name;
192       _nl_current_composite_name = composite;
193       if (old != _nl_C_name)
194         free (old);
195     }
196   /* Put NAME in _nl_current_names and free the old value.  */
197   void setname (int category, const char *name)
198     {
199       const char *oldname = _nl_current_names[category];
200       _nl_current_names[category] = name;
201       if (oldname != _nl_C_name)
202         free ((char *) oldname);
203     }
204   /* Put DATA in *_nl_current[CATEGORY] and free the old value.  */
205   void setdata (int category, struct locale_data *data)
206     {
207       if (_nl_current[category])
208         {
209           const struct locale_data *olddata = *_nl_current[category];
210           *_nl_current[category] = data;
211           if (_nl_category_postload[category])
212             (*_nl_category_postload[category]) ();
213           if (olddata != _nl_C[category])
214             _nl_free_locale ((struct locale_data *) olddata);
215         }
216     }
217
218   const char *current_name;
219   char *composite;
220
221   if (category < 0 || category > LC_ALL)
222     {
223       errno = EINVAL;
224       return NULL;
225     }
226
227   if (category == LC_ALL)
228     current_name = _nl_current_composite_name;
229   else
230     current_name = _nl_current_names[category];
231
232   if (name == NULL)
233     /* Return the name of the current locale.  */
234     return (char *) current_name;
235
236   if (name == current_name)
237     /* Changing to the same thing.  */
238     return (char *) current_name;
239
240   if (category == LC_ALL)
241     {
242       const size_t len = strlen (name) + 1;
243       char *newnames[LC_ALL];
244       char *p;
245       struct locale_data *newdata[LC_ALL];
246
247       /* Set all name pointers to the argument name.  */
248       for (category = 0; category < LC_ALL; ++category)
249         newnames[category] = (char *) name;
250
251       p = strchr (name, ';');
252       if (p)
253         {
254           /* This is a composite name.  Make a local copy and split it up.  */
255           int i;
256           char *n = alloca (len);
257           memcpy (n, name, len);
258
259           while ((p = strchr (n, '=')) != NULL)
260             {
261               for (i = 0; i < LC_ALL; ++i)
262                 if (_nl_category_name_sizes[i] == p - n &&
263                     !memcmp (_nl_category_names[i], n, p - n))
264                   break;
265               if (i == LC_ALL)
266                 {
267                   /* Bogus category name.  */
268                   errno = EINVAL;
269                   return NULL;
270                 }
271               if (i < LC_ALL)
272                 {
273                   /* Found the category this clause sets.  */
274                   char *end = strchr (++p, ';');
275                   newnames[i] = p;
276                   if (end)
277                     {
278                       /* Examine the next clause.  */
279                       *end = '\0';
280                       n = end + 1;
281                     }
282                   else
283                     /* This was the last clause.  We are done.  */
284                     break;
285                 }
286             }
287
288           for (i = 0; i < LC_ALL; ++i)
289             if (newnames[i] == name)
290               /* The composite name did not specify all categories.  */
291               return NULL;
292         }
293         
294       /* Load the new data for each category.  */
295       while (category-- > 0)
296         /* Only actually load the data if anything will use it.  */
297         if (_nl_current[category])
298           {
299             newdata[category] = _nl_load_locale (category,
300                                                  &newnames[category]);
301             if (newdata[category])
302               newnames[category] = copy (newnames[category]);
303             if (! newdata[category] || ! newnames[category])
304               {
305                 if (!strcmp (newnames[category], "C") ||
306                     !strcmp (newnames[category], "POSIX"))
307                   {
308                     /* Loading from a file failed, but this is a request
309                        for the default locale.  Use the built-in data.  */
310                     if (! newdata[category])
311                       newdata[category]
312                         = (struct locale_data *) _nl_C[category];
313                     newnames[category] = (char *) _nl_C_name;
314                   }
315                 else
316                   {
317                     /* Loading this part of the locale failed.
318                        Abort the composite load.  */
319                   abort_composite:
320                     while (++category < LC_ALL)
321                       {
322                         if (_nl_current[category])
323                           _nl_free_locale (newdata[category]);
324                         if (newnames[category] != _nl_C_name)
325                           free (newnames[category]);
326                       }
327                     return NULL;
328                   }
329               }
330           }
331         else
332           {
333             /* The data is never used; just change the name.  */
334             newnames[category] = copy (newnames[category]);
335             if (! newnames[category])
336               {
337                 if (!strcmp (newnames[category], "C") ||
338                     !strcmp (newnames[category], "POSIX"))
339                   newnames[category] = (char *) _nl_C_name;
340                 else
341                   {
342                     while (++category < LC_ALL)
343                       if (newnames[category] != _nl_C_name)
344                         free (newnames[category]);
345                   }
346               }
347           }
348
349       composite = new_composite_name (LC_ALL, newnames);
350       if (! composite)
351         {
352           category = -1;
353           goto abort_composite;
354         }
355
356       /* Now we have loaded all the new data.  Put it in place.  */
357       for (category = 0; category < LC_ALL; ++category)
358         {
359           setdata (category, newdata[category]);
360           setname (category, newnames[category]);
361         }
362       setcomposite (composite);
363
364       return composite;
365     }
366   else
367     {
368       char *newname = copy (name);
369       if (! newname)
370         {
371           if (!strcmp (name, "C") || !strcmp (name, "POSIX"))
372             newname = (char *) _nl_C_name;
373           else
374             return NULL;
375         }
376
377       composite = new_composite_name (category, &newname);
378       if (! composite)
379         {
380           if (newname != _nl_C_name)
381             free (newname);
382           return NULL;
383         }
384
385       /* Only actually load the data if anything will use it.  */
386       if (_nl_current[category])
387         {
388           struct locale_data *newdata = _nl_load_locale (category,
389                                                          (char **) &name);
390           if (! newdata)
391             {
392               if (!strcmp (name, "C") || !strcmp (name, "POSIX"))
393                 newdata = (struct locale_data *) _nl_C[category];
394               else
395                 return NULL;
396             }
397           setdata (category, newdata);
398         }
399
400       setname (category, newname);
401       setcomposite (composite);
402
403       return newname;
404     }
405 }