Add a "fork" of musl as //fusl.

fusl/src/locale/dcngettext.c

+#include <libintl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <limits.h>
+#include <sys/stat.h>
+#include <ctype.h>
+#include "locale_impl.h"
+#include "libc.h"
+#include "atomic.h"
+
+struct binding {
+        struct binding *next;
+        int dirlen;
+        volatile int active;
+        char *domainname;
+        char *dirname;
+        char buf[];
+};
+
+static void *volatile bindings;
+
+static char *gettextdir(const char *domainname, size_t *dirlen)
+{
+        struct binding *p;
+        for (p=bindings; p; p=p->next) {
+                if (!strcmp(p->domainname, domainname) && p->active) {
+                        *dirlen = p->dirlen;
+                        return (char *)p->dirname;
+                }
+        }
+        return 0;
+}
+
+char *bindtextdomain(const char *domainname, const char *dirname)
+{
+        static volatile int lock[2];
+        struct binding *p, *q;
+
+        if (!domainname) return 0;
+        if (!dirname) return gettextdir(domainname, &(size_t){0});
+
+        size_t domlen = strlen(domainname);
+        size_t dirlen = strlen(dirname);
+        if (domlen > NAME_MAX || dirlen >= PATH_MAX) {
+                errno = EINVAL;
+                return 0;
+        }
+
+        LOCK(lock);
+
+        for (p=bindings; p; p=p->next) {
+                if (!strcmp(p->domainname, domainname) &&
+                    !strcmp(p->dirname, dirname)) {
+                        break;
+                }
+        }
+
+        if (!p) {
+                p = malloc(sizeof *p + domlen + dirlen + 2);
+                if (!p) {
+                        UNLOCK(lock);
+                        return 0;
+                }
+                p->next = bindings;
+                p->dirlen = dirlen;
+                p->domainname = p->buf;
+                p->dirname = p->buf + domlen + 1;
+                memcpy(p->domainname, domainname, domlen+1);
+                memcpy(p->dirname, dirname, dirlen+1);
+                a_cas_p(&bindings, bindings, p);
+        }
+
+        a_store(&p->active, 1);
+
+        for (q=bindings; q; q=q->next) {
+                if (!strcmp(p->domainname, domainname) && q != p)
+                        a_store(&q->active, 0);
+        }
+
+        UNLOCK(lock);
+        
+        return (char *)p->dirname;
+}
+
+static const char catnames[][12] = {
+        "LC_CTYPE",
+        "LC_NUMERIC",
+        "LC_TIME",
+        "LC_COLLATE",
+        "LC_MONETARY",
+        "LC_MESSAGES",
+};
+
+static const char catlens[] = { 8, 10, 7, 10, 11, 11 };
+
+struct msgcat {
+        struct msgcat *next;
+        const void *map;
+        size_t map_size;
+        void *volatile plural_rule;
+        volatile int nplurals;
+        char name[];
+};
+
+static char *dummy_gettextdomain()
+{
+        return "messages";
+}
+
+weak_alias(dummy_gettextdomain, __gettextdomain);
+
+const unsigned char *__map_file(const char *, size_t *);
+int __munmap(void *, size_t);
+unsigned long __pleval(const char *, unsigned long);
+
+char *dcngettext(const char *domainname, const char *msgid1, const char *msgid2, unsigned long int n, int category)
+{
+        static struct msgcat *volatile cats;
+        struct msgcat *p;
+        struct __locale_struct *loc = CURRENT_LOCALE;
+        const struct __locale_map *lm;
+        const char *dirname, *locname, *catname;
+        size_t dirlen, loclen, catlen, domlen;
+
+        if ((unsigned)category >= LC_ALL) goto notrans;
+
+        if (!domainname) domainname = __gettextdomain();
+
+        domlen = strlen(domainname);
+        if (domlen > NAME_MAX) goto notrans;
+
+        dirname = gettextdir(domainname, &dirlen);
+        if (!dirname) goto notrans;
+
+        lm = loc->cat[category];
+        if (!lm) {
+notrans:
+                return (char *) ((n == 1) ? msgid1 : msgid2);
+        }
+        locname = lm->name;
+
+        catname = catnames[category];
+        catlen = catlens[category];
+        loclen = strlen(locname);
+
+        size_t namelen = dirlen+1 + loclen+1 + catlen+1 + domlen+3;
+        char name[namelen+1], *s = name;
+
+        memcpy(s, dirname, dirlen);
+        s[dirlen] = '/';
+        s += dirlen + 1;
+        memcpy(s, locname, loclen);
+        s[loclen] = '/';
+        s += loclen + 1;
+        memcpy(s, catname, catlen);
+        s[catlen] = '/';
+        s += catlen + 1;
+        memcpy(s, domainname, domlen);
+        s[domlen] = '.';
+        s[domlen+1] = 'm';
+        s[domlen+2] = 'o';
+        s[domlen+3] = 0;
+
+        for (p=cats; p; p=p->next)
+                if (!strcmp(p->name, name))
+                        break;
+
+        if (!p) {
+                void *old_cats;
+                size_t map_size;
+                const void *map = __map_file(name, &map_size);
+                if (!map) goto notrans;
+                p = malloc(sizeof *p + namelen + 1);
+                if (!p) {
+                        __munmap((void *)map, map_size);
+                        goto notrans;
+                }
+                p->map = map;
+                p->map_size = map_size;
+                memcpy(p->name, name, namelen+1);
+                do {
+                        old_cats = cats;
+                        p->next = old_cats;
+                } while (a_cas_p(&cats, old_cats, p) != old_cats);
+        }
+
+        const char *trans = __mo_lookup(p->map, p->map_size, msgid1);
+        if (!trans) goto notrans;
+
+        /* Non-plural-processing gettext forms pass a null pointer as
+         * msgid2 to request that dcngettext suppress plural processing. */
+        if (!msgid2) return (char *)trans;
+
+        if (!p->plural_rule) {
+                const char *rule = "n!=1;";
+                unsigned long np = 2;
+                const char *r = __mo_lookup(p->map, p->map_size, "");
+                char *z;
+                while (r && strncmp(r, "Plural-Forms:", 13)) {
+                        z = strchr(r, '\n');
+                        r = z ? z+1 : 0;
+                }
+                if (r) {
+                        r += 13;
+                        while (isspace(*r)) r++;
+                        if (!strncmp(r, "nplurals=", 9)) {
+                                np = strtoul(r+9, &z, 10);
+                                r = z;
+                        }
+                        while (*r && *r != ';') r++;
+                        if (*r) {
+                                r++;
+                                while (isspace(*r)) r++;
+                                if (!strncmp(r, "plural=", 7))
+                                        rule = r+7;
+                        }
+                }
+                a_store(&p->nplurals, np);
+                a_cas_p(&p->plural_rule, 0, (void *)rule);
+        }
+        if (p->nplurals) {
+                unsigned long plural = __pleval(p->plural_rule, n);
+                if (plural > p->nplurals) goto notrans;
+                while (plural--) {
+                        size_t rem = p->map_size - (trans - (char *)p->map);
+                        size_t l = strnlen(trans, rem);
+                        if (l+1 >= rem)
+                                goto notrans;
+                        trans += l+1;
+                }
+        }
+        return (char *)trans;
+}
+
+char *dcgettext(const char *domainname, const char *msgid, int category)
+{
+        return dcngettext(domainname, msgid, 0, 1, category);
+}
+
+char *dngettext(const char *domainname, const char *msgid1, const char *msgid2, unsigned long int n)
+{
+        return dcngettext(domainname, msgid1, msgid2, n, LC_MESSAGES);
+}
+
+char *dgettext(const char *domainname, const char *msgid)
+{
+        return dcngettext(domainname, msgid, 0, 1, LC_MESSAGES);
+}