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