/*      $NetBSD: plural_parser.c,v 1.5 2025/02/26 04:49:45 andvar Exp $ */

/*-
 * Copyright (c) 2005 Citrus Project,
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */

#include <sys/cdefs.h>
__RCSID("$NetBSD: plural_parser.c,v 1.5 2025/02/26 04:49:45 andvar Exp $");

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <citrus/citrus_namespace.h>
#include <citrus/citrus_region.h>
#include <citrus/citrus_memstream.h>
#include <citrus/citrus_bcs.h>
#include "plural_parser.h"

#if defined(TEST_TOKENIZER) || defined(TEST_PARSER)
#define ALLOW_EMPTY
#define ALLOW_ARBITRARY_IDENTIFIER
#endif

#define MAX_LEN_ATOM            10
#define MAX_NUM_OPERANDS        3

#define T_EOF                   EOF
#define T_NONE                  0x100
#define T_LAND                  0x101   /* && */
#define T_LOR                   0x102   /* || */
#define T_EQUALITY              0x103   /* == or != */
#define T_RELATIONAL            0x104   /* <, >, <= or >= */
#define T_ADDITIVE              0x105   /* + or - */
#define T_MULTIPLICATIVE        0x106   /* *, / or % */
#define T_IDENTIFIER            0x200
#define T_CONSTANT              0x201
#define T_ILCHAR                0x300
#define T_TOOLONG               0x301
#define T_ILTOKEN               0x302
#define T_ILEND                 0x303
#define T_NOMEM                 0x304
#define T_NOTFOUND              0x305
#define T_ILPLURAL              0x306
#define T_IS_OPERATOR(t)        ((t) < 0x200)
#define T_IS_ERROR(t)           ((t) >= 0x300)

#define OP_EQ                   ('='+'=')
#define OP_NEQ                  ('!'+'=')
#define OP_LTEQ                 ('<'+'=')
#define OP_GTEQ                 ('>'+'=')

#define PLURAL_NUMBER_SYMBOL    "n"
#define NPLURALS_SYMBOL         "nplurals"
#define LEN_NPLURAL_SYMBOL      (sizeof (NPLURALS_SYMBOL) -1)
#define PLURAL_SYMBOL           "plural"
#define LEN_PLURAL_SYMBOL       (sizeof (PLURAL_SYMBOL) -1)
#define PLURAL_FORMS            "Plural-Forms:"
#define LEN_PLURAL_FORMS        (sizeof (PLURAL_FORMS) -1)

/* ----------------------------------------------------------------------
 * tokenizer part
 */

union token_data
{
        unsigned long constant;
#ifdef ALLOW_ARBITRARY_IDENTIFIER
        char identifier[MAX_LEN_ATOM+1];
#endif
        char op;
};

struct tokenizer_context
{
        struct _memstream memstream;
        struct {
                int token;
                union token_data token_data;
        } token0;
};

/* initialize a tokenizer context */
static void
init_tokenizer_context(struct tokenizer_context *tcx)
{
        tcx->token0.token = T_NONE;
}

/* get an atom (identifier or constant) */
static int
tokenize_atom(struct tokenizer_context *tcx, union token_data *token_data)
{
        int ch, len;
        char buf[MAX_LEN_ATOM+1];

        len = 0;
        while (/*CONSTCOND*/1) {
                ch = _memstream_getc(&tcx->memstream);
                if (!(_bcs_isalnum(ch) || ch == '_')) {
                        _memstream_ungetc(&tcx->memstream, ch);
                        break;
                }
                if (len == MAX_LEN_ATOM)
                        return T_TOOLONG;
                buf[len++] = ch;
        }
        buf[len] = '\0';
        if (len == 0)
                return T_ILCHAR;

        if (_bcs_isdigit((int)(unsigned char)buf[0])) {
                unsigned long ul;
                char *post;
                ul = strtoul(buf, &post, 0);
                if (buf+len != post)
                        return T_ILCHAR;
                token_data->constant = ul;
                return T_CONSTANT;
        }

#ifdef ALLOW_ARBITRARY_IDENTIFIER
        strcpy(token_data->identifier, buf);
        return T_IDENTIFIER;
#else
        if (!strcmp(buf, PLURAL_NUMBER_SYMBOL))
                return T_IDENTIFIER;
        return T_ILCHAR;
#endif
}

/* tokenizer main routine */
static int
tokenize(struct tokenizer_context *tcx, union token_data *token_data)
{
        int ch, prevch;

retry:
        ch = _memstream_getc(&tcx->memstream);
        if (_bcs_isspace(ch))
                goto retry;

        switch (ch) {
        case T_EOF:
                return ch;
        case '+': case '-':
                token_data->op = ch;
                return T_ADDITIVE;
        case '*': case '/': case '%':
                token_data->op = ch;
                return T_MULTIPLICATIVE;
        case '?': case ':': case '(': case ')':
                token_data->op = ch;
                return ch;
        case '&': case '|':
                prevch = ch;
                ch = _memstream_getc(&tcx->memstream);
                if (ch != prevch) {
                        _memstream_ungetc(&tcx->memstream, ch);
                        return T_ILCHAR;
                }
                token_data->op = ch;
                switch (ch) {
                case '&':
                        return T_LAND;
                case '|':
                        return T_LOR;
                default:
                        return T_ILTOKEN;
                }
        case '=': case '!': case '<': case '>':
                prevch = ch;
                ch = _memstream_getc(&tcx->memstream);
                if (ch != '=') {
                        _memstream_ungetc(&tcx->memstream, ch);
                        switch (prevch) {
                        case '=':
                                return T_ILCHAR;
                        case '!':
                                return '!';
                        case '<':
                        case '>':
                                token_data->op = prevch; /* OP_LT or OP_GT */
                                return T_RELATIONAL;
                        }
                }
                /* '==', '!=', '<=' or '>=' */
                token_data->op = ch+prevch;
                switch (prevch) {
                case '=':
                case '!':
                        return T_EQUALITY;
                case '<':
                case '>':
                        return T_RELATIONAL;
                }
                /*NOTREACHED*/
        }

        _memstream_ungetc(&tcx->memstream, ch);
        return tokenize_atom(tcx, token_data);
}

/* get the next token */
static int
get_token(struct tokenizer_context *tcx, union token_data *token_data)
{
        if (tcx->token0.token != T_NONE) {
                int token = tcx->token0.token;
                tcx->token0.token = T_NONE;
                *token_data = tcx->token0.token_data;
                return token;
        }
        return tokenize(tcx, token_data);
}

/* push back the last token */
static void
unget_token(struct tokenizer_context *tcx,
            int token, union token_data *token_data)
{
        tcx->token0.token = token;
        tcx->token0.token_data = *token_data;
}

#ifdef TEST_TOKENIZER

int
main(int argc, char **argv)
{
        struct tokenizer_context tcx;
        union token_data token_data;
        int token;

        if (argc != 2) {
                fprintf(stderr, "usage: %s <expression>\n", argv[0]);
                return EXIT_FAILURE;
        }

        init_tokenizer_context(&tcx);
        _memstream_bind_ptr(&tcx.memstream, argv[1], strlen(argv[1]));

        while (1) {
                token = get_token(&tcx, &token_data);
                switch (token) {
                case T_EOF:
                        goto quit;
                case T_ILCHAR:
                        printf("illegal character.\n");
                        goto quit;
                case T_TOOLONG:
                        printf("too long atom.\n");
                        goto quit;
                case T_CONSTANT:
                        printf("constant: %lu\n", token_data.constant);
                        break;
                case T_IDENTIFIER:
                        printf("symbol: %s\n", token_data.identifier);
                        break;
                default:
                        printf("operator: ");
                        switch (token) {
                        case T_LAND:
                                printf("&&\n");
                                break;
                        case T_LOR:
                                printf("||\n");
                                break;
                        case T_EQUALITY:
                                printf("%c=\n", token_data.op-'=');
                                break;
                        case T_RELATIONAL:
                                switch(token_data.op) {
                                case OP_LTEQ:
                                case OP_GTEQ:
                                        printf("%c=\n", token_data.op-'=');
                                        break;
                                default:
                                        printf("%c\n", token_data.op);
                                        break;
                                }
                                break;
                        case T_ADDITIVE:
                        case T_MULTIPLICATIVE:
                                printf("%c\n", token_data.op);
                                break;
                        default:
                                printf("operator: %c\n", token);
                        }
                }
        }
quit:
        return 0;
}
#endif /* TEST_TOKENIZER */


/* ----------------------------------------------------------------------
 * parser part
 *
 * exp := cond
 *
 * cond := lor | lor '?' cond ':' cond
 *
 * lor := land ( '||' land )*
 *
 * land := equality ( '&&' equality )*
 *
 * equality := relational ( equalityops relational )*
 * equalityops := '==' | '!='
 *
 * relational := additive ( relationalops additive )*
 * relationalops := '<' | '>' | '<=' | '>='
 *
 * additive := multiplicative ( additiveops multiplicative )*
 * additiveops := '+' | '-'
 *
 * multiplicative := lnot ( multiplicativeops lnot )*
 * multiplicativeops := '*' | '/' | '%'
 *
 * lnot := '!' lnot | term
 *
 * term := literal | identifier | '(' exp ')'
 *
 */

#define T_ENSURE_OK(token, label)                                             \
do {                                                                          \
        if (T_IS_ERROR(token))                                                \
                goto label;                                                   \
} while (0)
#define T_ENSURE_SOMETHING(token, label)                                      \
do {                                                                          \
        if ((token) == T_EOF) {                                               \
                token = T_ILEND;                                              \
                goto label;                                                   \
        } else if (T_IS_ERROR(token))                                         \
                goto label;                                                   \
} while (0)

#define parser_element  plural_element

struct parser_element;
struct parser_op
{
        char op;
        struct parser_element *operands[MAX_NUM_OPERANDS];
};
struct parser_element
{
        int kind;
        union
        {
                struct parser_op parser_op;
                union token_data token_data;
        } u;
};

struct parser_op2_transition
{
        int                                     kind;
        const struct parser_op2_transition      *next;
};

/* prototypes */
static int parse_cond(struct tokenizer_context *, struct parser_element *);


/* transition table for the 2-operand operators */
#define DEF_TR(t, k, n)                                                       \
static struct parser_op2_transition exp_tr_##t = {                            \
        k, &exp_tr_##n                                                        \
}
#define DEF_TR0(t, k)                                                         \
static struct parser_op2_transition exp_tr_##t = {                            \
        k, NULL /* expect lnot */                                             \
}

DEF_TR0(multiplicative, T_MULTIPLICATIVE);
DEF_TR(additive, T_ADDITIVE, multiplicative);
DEF_TR(relational, T_RELATIONAL, additive);
DEF_TR(equality, T_EQUALITY, relational);
DEF_TR(land, T_LAND, equality);
DEF_TR(lor, T_LOR, land);

/* init a parser element structure */
static void
init_parser_element(struct parser_element *pe)
{
        int i;

        pe->kind = T_NONE;
        for (i=0; i<MAX_NUM_OPERANDS; i++)
                pe->u.parser_op.operands[i] = NULL;
}

/* uninitialize a parser element structure with freeing children */
static void free_parser_element(struct parser_element *);
static void
uninit_parser_element(struct parser_element *pe)
{
        int i;

        if (T_IS_OPERATOR(pe->kind))
                for (i=0; i<MAX_NUM_OPERANDS; i++)
                        if (pe->u.parser_op.operands[i])
                                free_parser_element(
                                        pe->u.parser_op.operands[i]);
}

/* free a parser element structure with freeing children */
static void
free_parser_element(struct parser_element *pe)
{
        if (pe) {
                uninit_parser_element(pe);
                free(pe);
        }
}


/* copy a parser element structure shallowly */
static void
copy_parser_element(struct parser_element *dpe,
                    const struct parser_element *spe)
{
        memcpy(dpe, spe, sizeof *dpe);
}

/* duplicate a parser element structure shallowly */
static struct parser_element *
dup_parser_element(const struct parser_element *pe)
{
        struct parser_element *dpe = malloc(sizeof *dpe);
        if (dpe)
                copy_parser_element(dpe, pe);
        return dpe;
}

/* term := identifier | constant | '(' exp ')' */
static int
parse_term(struct tokenizer_context *tcx, struct parser_element *pelem)
{
        struct parser_element pe0;
        int token;
        union token_data token_data;

        token = get_token(tcx, &token_data);
        switch (token) {
        case '(':
                /* '(' exp ')' */
                init_parser_element(&pe0);
                /* expect exp */
                token = parse_cond(tcx, &pe0);
                T_ENSURE_OK(token, err);
                /* expect ')' */
                token = get_token(tcx, &token_data);
                T_ENSURE_SOMETHING(token, err);
                if (token != ')') {
                        unget_token(tcx, token, &token_data);
                        token = T_ILTOKEN;
                        goto err;
                }
                copy_parser_element(pelem, &pe0);
                return token;
err:
                uninit_parser_element(&pe0);
                return token;
        case T_IDENTIFIER:
        case T_CONSTANT:
                pelem->kind = token;
                pelem->u.token_data = token_data;
                return token;
        case T_EOF:
                return T_ILEND;
        default:
                return T_ILTOKEN;
        }
}

/* lnot := '!' lnot | term */
static int
parse_lnot(struct tokenizer_context *tcx, struct parser_element *pelem)
{
        struct parser_element pe0;
        int token;
        union token_data token_data;

        init_parser_element(&pe0);

        /* '!' or not */
        token = get_token(tcx, &token_data);
        if (token != '!') {
                /* stop: term */
                unget_token(tcx, token, &token_data);
                return parse_term(tcx, pelem);
        }

        /* '!' term */
        token = parse_lnot(tcx, &pe0);
        T_ENSURE_OK(token, err);

        pelem->kind = '!';
        pelem->u.parser_op.operands[0] = dup_parser_element(&pe0);
        return pelem->kind;
err:
        uninit_parser_element(&pe0);
        return token;
}

/* ext_op := ext_next ( op ext_next )* */
static int
parse_op2(struct tokenizer_context *tcx, struct parser_element *pelem,
          const struct parser_op2_transition *tr)
{
        struct parser_element pe0, pe1, peop;
        int token;
        union token_data token_data;
        char op;

        /* special case: expect lnot */
        if (tr == NULL)
                return parse_lnot(tcx, pelem);

        init_parser_element(&pe0);
        init_parser_element(&pe1);
        token = parse_op2(tcx, &pe0, tr->next);
        T_ENSURE_OK(token, err);

        while (/*CONSTCOND*/1) {
                /* expect op or empty */
                token = get_token(tcx, &token_data);
                if (token != tr->kind) {
                        /* stop */
                        unget_token(tcx, token, &token_data);
                        copy_parser_element(pelem, &pe0);
                        break;
                }
                op = token_data.op;
                /* right hand */
                token = parse_op2(tcx, &pe1, tr->next);
                T_ENSURE_OK(token, err);

                init_parser_element(&peop);
                peop.kind = tr->kind;
                peop.u.parser_op.op = op;
                peop.u.parser_op.operands[0] = dup_parser_element(&pe0);
                init_parser_element(&pe0);
                peop.u.parser_op.operands[1] = dup_parser_element(&pe1);
                init_parser_element(&pe1);
                copy_parser_element(&pe0, &peop);
        }
        return pelem->kind;
err:
        uninit_parser_element(&pe1);
        uninit_parser_element(&pe0);
        return token;
}

/* cond := lor | lor '?' cond ':' cond */
static int
parse_cond(struct tokenizer_context *tcx, struct parser_element *pelem)
{
        struct parser_element pe0, pe1, pe2;
        int token;
        union token_data token_data;

        init_parser_element(&pe0);
        init_parser_element(&pe1);
        init_parser_element(&pe2);

        /* expect lor or empty */
        token = parse_op2(tcx, &pe0, &exp_tr_lor);
        T_ENSURE_OK(token, err);

        /* '?' or not */
        token = get_token(tcx, &token_data);
        if (token != '?') {
                /* stop: lor */
                unget_token(tcx, token, &token_data);
                copy_parser_element(pelem, &pe0);
                return pe0.kind;
        }

        /* lor '?' cond ':' cond */
        /* expect cond */
        token = parse_cond(tcx, &pe1);
        T_ENSURE_OK(token, err);

        /* expect ':' */
        token = get_token(tcx, &token_data);
        T_ENSURE_OK(token, err);
        if (token != ':') {
                unget_token(tcx, token, &token_data);
                token = T_ILTOKEN;
                goto err;
        }

        /* expect cond */
        token = parse_cond(tcx, &pe2);
        T_ENSURE_OK(token, err);

        pelem->kind = '?';
        pelem->u.parser_op.operands[0] = dup_parser_element(&pe0);
        pelem->u.parser_op.operands[1] = dup_parser_element(&pe1);
        pelem->u.parser_op.operands[2] = dup_parser_element(&pe2);
        return pelem->kind;
err:
        uninit_parser_element(&pe2);
        uninit_parser_element(&pe1);
        uninit_parser_element(&pe0);
        return token;
}

static int
parse_exp(struct tokenizer_context *tcx, struct parser_element *pelem)
{
        int token, token1;
        union token_data token_data;

#ifdef ALLOW_EMPTY
        /* empty check */
        token = get_token(tcx, &token_data);
        if (token == T_EOF)
                return token;
        unget_token(tcx, token, &token_data);
#endif

        token = parse_cond(tcx, pelem);
        if (!T_IS_ERROR(token)) {
                /* termination check */
                token1 = get_token(tcx, &token_data);
                if (token1 == T_EOF)
                        return token;
                else if (!T_IS_ERROR(token))
                         unget_token(tcx, token1, &token_data);
                return T_ILTOKEN;
        }
        return token;
}


#if defined(TEST_PARSER) || defined(TEST_PARSE_PLURAL)
#include <stdio.h>

static void dump_elem(struct parser_element *);

static void
dump_op2(struct parser_element *pelem)
{
        dump_elem(pelem->u.parser_op.operands[0]);
        printf(" ");
        dump_elem(pelem->u.parser_op.operands[1]);
        printf(")");
}

static void
dump_op3(struct parser_element *pelem)
{
        dump_elem(pelem->u.parser_op.operands[0]);
        printf(" ");
        dump_elem(pelem->u.parser_op.operands[1]);
        printf(" ");
        dump_elem(pelem->u.parser_op.operands[2]);
        printf(")");
}

static void
dump_elem(struct parser_element *pelem)
{
        switch (pelem->kind) {
        case T_LAND:
                printf("(&& ");
                dump_op2(pelem);
                break;
        case T_LOR:
                printf("(|| ");
                dump_op2(pelem);
                break;
        case T_EQUALITY:
                switch (pelem->u.parser_op.op) {
                case OP_EQ:
                        printf("(== ");
                        break;
                case OP_NEQ:
                        printf("(!= ");
                        break;
                }
                dump_op2(pelem);
                break;
        case T_RELATIONAL:
                switch (pelem->u.parser_op.op) {
                case '<':
                case '>':
                        printf("(%c ", pelem->u.parser_op.op);
                        break;
                case OP_LTEQ:
                case OP_GTEQ:
                        printf("(%c= ", pelem->u.parser_op.op-'=');
                        break;
                }
                dump_op2(pelem);
                break;
        case T_ADDITIVE:
        case T_MULTIPLICATIVE:
                printf("(%c ", pelem->u.parser_op.op);
                dump_op2(pelem);
                break;
        case '!':
                printf("(! ");
                dump_elem(pelem->u.parser_op.operands[0]);
                printf(")");
                break;
        case '?':
                printf("(? ");
                dump_op3(pelem);
                break;
        case T_CONSTANT:
                printf("%d", pelem->u.token_data.constant);
                break;
        case T_IDENTIFIER:
#ifdef ALLOW_ARBITRARY_IDENTIFIER
                printf("%s", pelem->u.token_data.identifier);
#else
                printf(PLURAL_NUMBER_SYMBOL);
#endif
                break;
        }
}
#endif
#ifdef TEST_PARSER
int
main(int argc, char **argv)
{
        struct tokenizer_context tcx;
        struct parser_element pelem;
        int token;

        if (argc != 2) {
                fprintf(stderr, "usage: %s <expression>\n", argv[0]);
                return EXIT_FAILURE;
        }

        init_tokenizer_context(&tcx);
        _memstream_bind_ptr(&tcx.memstream, argv[1], strlen(argv[1]));

        init_parser_element(&pelem);
        token = parse_exp(&tcx, &pelem);

        if (token == T_EOF)
                printf("none");
        else if (T_IS_ERROR(token))
                printf("error: 0x%X", token);
        else
                dump_elem(&pelem);
        printf("\n");

        uninit_parser_element(&pelem);

        return EXIT_SUCCESS;
}
#endif /* TEST_PARSER */

/* ----------------------------------------------------------------------
 * calculate plural number
 */
static unsigned long
calculate_plural(const struct parser_element *pe, unsigned long n)
{
        unsigned long val0, val1;
        switch (pe->kind) {
        case T_IDENTIFIER:
                return n;
        case T_CONSTANT:
                return pe->u.token_data.constant;
        case '?':
                val0 = calculate_plural(pe->u.parser_op.operands[0], n);
                if (val0)
                        val1=calculate_plural(pe->u.parser_op.operands[1], n);
                else
                        val1=calculate_plural(pe->u.parser_op.operands[2], n);
                return val1;
        case '!':
                return !calculate_plural(pe->u.parser_op.operands[0], n);
        case T_MULTIPLICATIVE:
        case T_ADDITIVE:
        case T_RELATIONAL:
        case T_EQUALITY:
        case T_LOR:
        case T_LAND:
                val0 = calculate_plural(pe->u.parser_op.operands[0], n);
                val1 = calculate_plural(pe->u.parser_op.operands[1], n);
                switch (pe->u.parser_op.op) {
                case '*':
                        return val0*val1;
                case '/':
                        return val0/val1;
                case '%':
                        return val0%val1;
                case '+':
                        return val0+val1;
                case '-':
                        return val0-val1;
                case '<':
                        return val0<val1;
                case '>':
                        return val0>val1;
                case OP_LTEQ:
                        return val0<=val1;
                case OP_GTEQ:
                        return val0>=val1;
                case OP_EQ:
                        return val0==val1;
                case OP_NEQ:
                        return val0!=val1;
                case '|':
                        return val0||val1;
                case '&':
                        return val0&&val1;
                }
        }
        return 0;
}

#ifdef TEST_CALC_PLURAL
#include <stdio.h>

int
main(int argc, char **argv)
{
        struct tokenizer_context tcx;
        struct parser_element pelem;
        int token;

        if (argc != 3) {
                fprintf(stderr, "usage: %s <expression> <n>\n", argv[0]);
                return EXIT_FAILURE;
        }

        init_tokenizer_context(&tcx);
        _memstream_bind_ptr(&tcx.memstream, argv[1], strlen(argv[1]));

        init_parser_element(&pelem);
        token = parse_exp(&tcx, &pelem);

        if (token == T_EOF)
                printf("none");
        else if (T_IS_ERROR(token))
                printf("error: 0x%X", token);
        else {
                printf("plural = %lu",
                       calculate_plural(&pelem, atoi(argv[2])));
        }
        printf("\n");

        uninit_parser_element(&pelem);

        return EXIT_SUCCESS;
}
#endif /* TEST_CALC_PLURAL */


/* ----------------------------------------------------------------------
 * parse plural forms
 */

static void
region_skip_ws(struct _region *r)
{
        const char *str = _region_head(r);
        size_t len = _region_size(r);

        str = _bcs_skip_ws_len(str, &len);
        _region_init(r, __UNCONST(str), len);
}

static void
region_trunc_rws(struct _region *r)
{
        const char *str = _region_head(r);
        size_t len = _region_size(r);

        _bcs_trunc_rws_len(str, &len);
        _region_init(r, __UNCONST(str), len);
}

static int
region_check_prefix(struct _region *r, const char *pre, size_t prelen,
                    int ignorecase)
{
        if (_region_size(r) < prelen)
                return -1;

        if (ignorecase) {
                if (_bcs_strncasecmp(_region_head(r), pre, prelen))
                        return -1;
        } else {
                if (memcmp(_region_head(r), pre, prelen))
                        return -1;
        }
        return 0;
}

static int
cut_trailing_semicolon(struct _region *r)
{

        region_trunc_rws(r);
        if (_region_size(r) == 0 || _region_peek8(r, _region_size(r)-1) != ';')
                return -1;
        _region_get_subregion(r, r, 0, _region_size(r)-1);
        return 0;
}

static int
find_plural_forms(struct _region *r)
{
        struct _memstream ms;
        struct _region rr;

        _memstream_bind(&ms, r);

        while (!_memstream_getln_region(&ms, &rr)) {
                if (!region_check_prefix(&rr,
                                         PLURAL_FORMS, LEN_PLURAL_FORMS, 1)) {
                        _region_get_subregion(
                                r, &rr, LEN_PLURAL_FORMS,
                                _region_size(&rr)-LEN_PLURAL_FORMS);
                        region_skip_ws(r);
                        region_trunc_rws(r);
                        return 0;
                }
        }
        return -1;
}

static int
skip_assignment(struct _region *r, const char *sym, size_t symlen)
{
        region_skip_ws(r);
        if (region_check_prefix(r, sym, symlen, 0))
                return -1;
        _region_get_subregion(r, r, symlen, _region_size(r)-symlen);
        region_skip_ws(r);
        if (_region_size(r) == 0 || _region_peek8(r, 0) != '=')
                return -1;
        _region_get_subregion(r, r, 1, _region_size(r)-1);
        region_skip_ws(r);
        return 0;
}

static int
skip_nplurals(struct _region *r, unsigned long *rnp)
{
        unsigned long np;
        char buf[MAX_LEN_ATOM+2], *endptr;
        const char *endptrconst;
        size_t ofs;

        if (skip_assignment(r, NPLURALS_SYMBOL, LEN_NPLURAL_SYMBOL))
                return -1;
        if (_region_size(r) == 0 || !_bcs_isdigit(_region_peek8(r, 0)))
                return -1;
        strlcpy(buf, _region_head(r), sizeof (buf));
        np = strtoul(buf, &endptr, 0);
        endptrconst = _bcs_skip_ws(endptr);
        if (*endptrconst != ';')
                return -1;
        ofs = endptrconst+1-buf;
        if (_region_get_subregion(r, r, ofs, _region_size(r)-ofs))
                return -1;
        if (rnp)
                *rnp = np;
        return 0;
}

static int
parse_plural_body(struct _region *r, struct parser_element **rpe)
{
        int token;
        struct tokenizer_context tcx;
        struct parser_element pelem, *ppe;

        init_tokenizer_context(&tcx);
        _memstream_bind(&tcx.memstream, r);

        init_parser_element(&pelem);
        token = parse_exp(&tcx, &pelem);
        if (T_IS_ERROR(token))
                return token;

        ppe = dup_parser_element(&pelem);
        if (ppe == NULL) {
                uninit_parser_element(&pelem);
                return T_NOMEM;
        }

        *rpe = ppe;

        return 0;
}

static int
parse_plural(struct parser_element **rpe, unsigned long *rnp,
             const char *str, size_t len)
{
        struct _region r;

        _region_init(&r, __UNCONST(str), len);

        if (find_plural_forms(&r))
                return T_NOTFOUND;
        if (skip_nplurals(&r, rnp))
                return T_ILPLURAL;
        if (skip_assignment(&r, PLURAL_SYMBOL, LEN_PLURAL_SYMBOL))
                return T_ILPLURAL;
        if (cut_trailing_semicolon(&r))
                return T_ILPLURAL;
        return parse_plural_body(&r, rpe);
}

#ifdef TEST_PARSE_PLURAL
int
main(int argc, char **argv)
{
        int ret;
        struct parser_element *pelem;
        unsigned long np;

        if (argc != 2 && argc != 3) {
                fprintf(stderr, "usage: %s <mime-header> [n]\n", argv[0]);
                return EXIT_FAILURE;
        }

        ret = parse_plural(&pelem, &np, argv[1], strlen(argv[1]));

        if (ret == T_EOF)
                printf("none");
        else if (T_IS_ERROR(ret))
                printf("error: 0x%X", ret);
        else {
                printf("syntax tree: ");
                dump_elem(pelem);
                printf("\nnplurals = %lu", np);
                if (argv[2])
                        printf(", plural = %lu",
                               calculate_plural(pelem, atoi(argv[2])));
                free_parser_element(pelem);
        }
        printf("\n");


        return EXIT_SUCCESS;
}
#endif /* TEST_PARSE_PLURAL */

/*
 * external interface
 */

int
_gettext_parse_plural(struct gettext_plural **rpe, unsigned long *rnp,
                      const char *str, size_t len)
{
        return parse_plural((struct parser_element **)rpe, rnp, str, len);
}

unsigned long
_gettext_calculate_plural(const struct gettext_plural *pe, unsigned long n)
{
        return calculate_plural((void *)__UNCONST(pe), n);
}

void
_gettext_free_plural(struct gettext_plural *pe)
{
        free_parser_element((void *)pe);
}

#ifdef TEST_PLURAL
#include <libintl.h>
#include <locale.h>

#define PR(n)   printf("n=%d: \"%s\"\n", n, dngettext("test", "1", "2", n))

int
main(void)
{
        bindtextdomain("test", "."); /* ./LANG/LC_MESSAGES/test.mo */
        PR(1);
        PR(2);
        PR(3);
        PR(4);

        return 0;
}
#endif