make all objects used with atomic operations volatile
[musl] / src / locale / __setlocalecat.c
1 #include <locale.h>
2 #include <string.h>
3 #include "locale_impl.h"
4 #include "libc.h"
5 #include "atomic.h"
6
7 const char *__lctrans_impl(const char *msg, const struct __locale_map *lm)
8 {
9         const char *trans = 0;
10         if (lm) trans = __mo_lookup(lm->map, lm->map_size, msg);
11         return trans ? trans : msg;
12 }
13
14 const unsigned char *__map_file(const char *, size_t *);
15 int __munmap(void *, size_t);
16 char *__strchrnul(const char *, int);
17
18 static struct __locale_map *findlocale(const char *name, size_t n)
19 {
20         static void *volatile loc_head;
21         struct __locale_map *p, *new, *old_head;
22         const char *path = 0, *z;
23         char buf[256];
24         size_t l;
25         const void *map;
26         size_t map_size;
27
28         for (p=loc_head; p; p=p->next)
29                 if (!strcmp(name, p->name)) return p;
30
31         if (!libc.secure) path = getenv("MUSL_LOCPATH");
32         /* FIXME: add a default path? */
33         if (!path) return 0;
34
35         for (; *path; path=z+!!*z) {
36                 z = __strchrnul(path, ':');
37                 l = z - path - !!*z;
38                 if (l >= sizeof buf - n - 2) continue;
39                 memcpy(buf, path, l);
40                 buf[l] = '/';
41                 memcpy(buf+l+1, name, n);
42                 buf[l+1+n] = 0;
43                 map = __map_file(buf, &map_size);
44                 if (map) {
45                         new = malloc(sizeof *new);
46                         if (!new) {
47                                 __munmap((void *)map, map_size);
48                                 return 0;
49                         }
50                         new->map = map;
51                         new->map_size = map_size;
52                         memcpy(new->name, name, n);
53                         new->name[n] = 0;
54                         do {
55                                 old_head = loc_head;
56                                 new->next = old_head;
57                         } while (a_cas_p(&loc_head, old_head, new) != old_head);
58                         return new;
59                 }
60         }
61         return 0;
62 }
63
64 static const char envvars[][12] = {
65         "LC_CTYPE",
66         "LC_NUMERIC",
67         "LC_TIME",
68         "LC_COLLATE",
69         "LC_MONETARY",
70         "LC_MESSAGES",
71 };
72
73 int __setlocalecat(locale_t loc, int cat, const char *val)
74 {
75         if (!*val) {
76                 (val = getenv("LC_ALL")) && *val ||
77                 (val = getenv(envvars[cat])) && *val ||
78                 (val = getenv("LANG")) && *val ||
79                 (val = "C.UTF-8");
80         }
81
82         size_t n;
83         for (n=0; n<LOCALE_NAME_MAX && val[n] && val[n]!='/'; n++);
84         if (val[0]=='.' || val[n]) val = "C.UTF-8";
85         int builtin = (val[0]=='C' && !val[1])
86                 || !strcmp(val, "C.UTF-8")
87                 || !strcmp(val, "POSIX");
88         struct __locale_map *data, *old;
89
90         switch (cat) {
91         case LC_CTYPE:
92                 a_store(&loc->ctype_utf8, !builtin || val[1]=='.');
93                 break;
94         case LC_MESSAGES:
95                 if (builtin) {
96                         loc->messages_name[0] = 0;
97                 } else {
98                         memcpy(loc->messages_name, val, n);
99                         loc->messages_name[n] = 0;
100                 }
101                 /* fall through */
102         default:
103                 data = builtin ? 0 : findlocale(val, n);
104                 if (data == loc->cat[cat-2]) break;
105                 do old = loc->cat[cat-2];
106                 while (a_cas_p(&loc->cat[cat-2], old, data) != old);
107         case LC_NUMERIC:
108                 break;
109         }
110         return 0;
111 }