nsz Git - musl/blob - src/locale/dcngettext.c

   1 #include <libintl.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <errno.h>
   5 #include <limits.h>
   6 #include <sys/stat.h>
   7 #include <ctype.h>
   8 #include "locale_impl.h"
   9 #include "libc.h"
  10 #include "atomic.h"
  11
  12 struct binding {
  13         struct binding *next;
  14         int dirlen;
  15         int active;
  16         char *domainname;
  17         char *dirname;
  18         char buf[];
  19 };
  20
  21 static void *volatile bindings;
  22
  23 static char *gettextdir(const char *domainname, size_t *dirlen)
  24 {
  25         struct binding *p;
  26         for (p=bindings; p; p=p->next) {
  27                 if (!strcmp(p->domainname, domainname) && p->active) {
  28                         *dirlen = p->dirlen;
  29                         return (char *)p->dirname;
  30                 }
  31         }
  32         return 0;
  33 }
  34
  35 char *bindtextdomain(const char *domainname, const char *dirname)
  36 {
  37         static int lock[2];
  38         struct binding *p, *q;
  39
  40         if (!domainname) return 0;
  41         if (!dirname) return gettextdir(domainname, &(size_t){0});
  42
  43         size_t domlen = strlen(domainname);
  44         size_t dirlen = strlen(dirname);
  45         if (domlen > NAME_MAX || dirlen >= PATH_MAX) {
  46                 errno = EINVAL;
  47                 return 0;
  48         }
  49
  50         LOCK(lock);
  51
  52         for (p=bindings; p; p=p->next) {
  53                 if (!strcmp(p->domainname, domainname) &&
  54                     !strcmp(p->dirname, dirname)) {
  55                         break;
  56                 }
  57         }
  58
  59         if (!p) {
  60                 p = malloc(sizeof *p + domlen + dirlen + 2);
  61                 if (!p) {
  62                         UNLOCK(lock);
  63                         return 0;
  64                 }
  65                 p->next = bindings;
  66                 p->dirlen = dirlen;
  67                 p->domainname = p->buf;
  68                 p->dirname = p->buf + domlen + 1;
  69                 memcpy(p->domainname, domainname, domlen+1);
  70                 memcpy(p->dirname, dirname, dirlen+1);
  71                 a_cas_p(&bindings, bindings, p);
  72         }
  73
  74         a_store(&p->active, 1);
  75
  76         for (q=bindings; q; q=q->next) {
  77                 if (!strcmp(p->domainname, domainname) && q != p)
  78                         a_store(&q->active, 0);
  79         }
  80
  81         UNLOCK(lock);
  82
  83         return (char *)p->dirname;
  84 }
  85
  86 static const char catnames[][12] = {
  87         "LC_TIME",
  88         "LC_COLLATE",
  89         "LC_MONETARY",
  90         "LC_MESSAGES",
  91 };
  92
  93 static const char catlens[] = { 7, 10, 11, 11 };
  94
  95 struct msgcat {
  96         struct msgcat *next;
  97         const void *map;
  98         size_t map_size;
  99         void *plural_rule;
 100         int nplurals;
 101         char name[];
 102 };
 103
 104 static char *dummy_gettextdomain()
 105 {
 106         return "messages";
 107 }
 108
 109 weak_alias(dummy_gettextdomain, __gettextdomain);
 110
 111 const unsigned char *__map_file(const char *, size_t *);
 112 int __munmap(void *, size_t);
 113 unsigned long __pleval(const char *, unsigned long);
 114
 115 char *dcngettext(const char *domainname, const char *msgid1, const char *msgid2, unsigned long int n, int category)
 116 {
 117         static struct msgcat *volatile cats;
 118         struct msgcat *p;
 119         struct __locale_struct *loc = CURRENT_LOCALE;
 120         struct __locale_map *lm;
 121         const char *dirname, *locname, *catname;
 122         size_t dirlen, loclen, catlen, domlen;
 123
 124         if (!domainname) domainname = __gettextdomain();
 125
 126         domlen = strlen(domainname);
 127         if (domlen > NAME_MAX) goto notrans;
 128
 129         dirname = gettextdir(domainname, &dirlen);
 130         if (!dirname) goto notrans;
 131
 132         switch (category) {
 133         case LC_MESSAGES:
 134                 locname = loc->messages_name;
 135                 if (!*locname) goto notrans;
 136                 break;
 137         case LC_TIME:
 138         case LC_MONETARY:
 139         case LC_COLLATE:
 140                 lm = loc->cat[category-2];
 141                 if (!lm) goto notrans;
 142                 locname = lm->name;
 143                 break;
 144         default:
 145 notrans:
 146                 return (char *) ((n == 1) ? msgid1 : msgid2);
 147         }
 148
 149         catname = catnames[category-2];
 150         catlen = catlens[category-2];
 151         loclen = strlen(locname);
 152
 153         size_t namelen = dirlen+1 + loclen+1 + catlen+1 + domlen+3;
 154         char name[namelen+1], *s = name;
 155
 156         memcpy(s, dirname, dirlen);
 157         s[dirlen] = '/';
 158         s += dirlen + 1;
 159         memcpy(s, locname, loclen);
 160         s[loclen] = '/';
 161         s += loclen + 1;
 162         memcpy(s, catname, catlen);
 163         s[catlen] = '/';
 164         s += catlen + 1;
 165         memcpy(s, domainname, domlen);
 166         s[domlen] = '.';
 167         s[domlen+1] = 'm';
 168         s[domlen+2] = 'o';
 169         s[domlen+3] = 0;
 170
 171         for (p=cats; p; p=p->next)
 172                 if (!strcmp(p->name, name))
 173                         break;
 174
 175         if (!p) {
 176                 void *old_cats;
 177                 size_t map_size;
 178                 const void *map = __map_file(name, &map_size);
 179                 if (!map) goto notrans;
 180                 p = malloc(sizeof *p + namelen + 1);
 181                 if (!p) {
 182                         __munmap((void *)map, map_size);
 183                         goto notrans;
 184                 }
 185                 p->map = map;
 186                 p->map_size = map_size;
 187                 memcpy(p->name, name, namelen+1);
 188                 do {
 189                         old_cats = cats;
 190                         p->next = old_cats;
 191                 } while (a_cas_p(&cats, old_cats, p) != old_cats);
 192         }
 193
 194         const char *trans = __mo_lookup(p->map, p->map_size, msgid1);
 195         if (!trans) goto notrans;
 196
 197         /* Non-plural-processing gettext forms pass a null pointer as
 198          * msgid2 to request that dcngettext suppress plural processing. */
 199         if (!msgid2) return (char *)trans;
 200
 201         if (!p->plural_rule) {
 202                 const char *rule = "n!=1;";
 203                 unsigned long np = 2;
 204                 const char *r = __mo_lookup(p->map, p->map_size, "");
 205                 char *z;
 206                 while (r && strncmp(r, "Plural-Forms:", 13)) {
 207                         z = strchr(r, '\n');
 208                         r = z ? z+1 : 0;
 209                 }
 210                 if (r) {
 211                         r += 13;
 212                         while (isspace(*r)) r++;
 213                         if (!strncmp(r, "nplurals=", 9)) {
 214                                 np = strtoul(r+9, &z, 10);
 215                                 r = z;
 216                         }
 217                         while (*r && *r != ';') r++;
 218                         if (*r) {
 219                                 r++;
 220                                 while (isspace(*r)) r++;
 221                                 if (!strncmp(r, "plural=", 7))
 222                                         rule = r+7;
 223                         }
 224                 }
 225                 a_store(&p->nplurals, np);
 226                 a_cas_p(&p->plural_rule, 0, (void *)rule);
 227         }
 228         if (p->nplurals) {
 229                 unsigned long plural = __pleval(p->plural_rule, n);
 230                 if (plural > p->nplurals) goto notrans;
 231                 while (plural--) {
 232                         size_t rem = p->map_size - (trans - (char *)p->map);
 233                         size_t l = strnlen(trans, rem);
 234                         if (l+1 >= rem)
 235                                 goto notrans;
 236                         trans += l+1;
 237                 }
 238         }
 239         return (char *)trans;
 240 }
 241
 242 char *dcgettext(const char *domainname, const char *msgid, int category)
 243 {
 244         return dcngettext(domainname, msgid, 0, 1, category);
 245 }
 246
 247 char *dngettext(const char *domainname, const char *msgid1, const char *msgid2, unsigned long int n)
 248 {
 249         return dcngettext(domainname, msgid1, msgid2, n, LC_MESSAGES);
 250 }
 251
 252 char *dgettext(const char *domainname, const char *msgid)
 253 {
 254         return dcngettext(domainname, msgid, 0, 1, LC_MESSAGES);
 255 }