/*
 * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
 * SPDX-License-Identifier: BSD-1-Clause
 */
#include <asn_system.h>
#include <xer_support.h>

/* Parser states */
typedef enum
{
    ST_TEXT,
    ST_TAG_START,
    ST_TAG_BODY,
    ST_TAG_QUOTE_WAIT,
    ST_TAG_QUOTED_STRING,
    ST_TAG_UNQUOTED_STRING,
    ST_COMMENT_WAIT_DASH1, /* "<!--"[1] */
    ST_COMMENT_WAIT_DASH2, /* "<!--"[2] */
    ST_COMMENT,
    ST_COMMENT_CLO_DASH2, /* "-->"[0] */
    ST_COMMENT_CLO_RT     /* "-->"[1] */
} pstate_e;

static pxml_chunk_type_e final_chunk_type[] = {
    PXML_TEXT,
    PXML_TAG_END,
    PXML_COMMENT_END,
    PXML_TAG_END,
    PXML_COMMENT_END,
};

static int _charclass[256] = {
    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, /* 01234567 89
                                                                 */
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,             /*  ABCDEFG HIJKLMNO */
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0,             /* PQRSTUVW XYZ      */
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,             /*  abcdefg hijklmno */
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0              /* pqrstuvw xyz      */
};
#define WHITESPACE(c) (_charclass[(unsigned char)(c)] == 1)
#define ALNUM(c) (_charclass[(unsigned char)(c)] >= 2)
#define ALPHA(c) (_charclass[(unsigned char)(c)] == 3)

/* Aliases for characters, ASCII/UTF-8 */
// clang-format off
#define EXCLAM 0x21 /* '!' */
#define CQUOTE 0x22 /* '"' */
#define CDASH 0x2d  /* '-' */
#define CSLASH 0x2f /* '/' */
#define LANGLE 0x3c /* '<' */
#define CEQUAL 0x3d /* '=' */
#define RANGLE 0x3e /* '>' */
#define CQUEST 0x3f /* '?' */
// clang-format on

/* Invoke token callback */
#define TOKEN_CB_CALL(type, _ns, _current_too, _final)            \
    do                                                            \
        {                                                         \
            int _ret;                                             \
            pstate_e ns = _ns;                                    \
            ssize_t _sz = (p - chunk_start) + (_current_too);     \
            if (!_sz)                                             \
                {                                                 \
                    /* Shortcut */                                \
                    state = _ns;                                  \
                    break;                                        \
                }                                                 \
            _ret = cb(type, chunk_start, _sz, key);               \
            if (_ret < _sz)                                       \
                {                                                 \
                    if ((_current_too) && _ret == -1) state = ns; \
                    goto finish;                                  \
                }                                                 \
            chunk_start = p + (_current_too);                     \
            state = ns;                                           \
        }                                                         \
    while (0)

#define TOKEN_CB(_type, _ns, _current_too) \
    TOKEN_CB_CALL(_type, _ns, _current_too, 0)

#define TOKEN_CB_FINAL(_type, _ns, _current_too) \
    TOKEN_CB_CALL(final_chunk_type[_type], _ns, _current_too, 1)

/*
 * Parser itself
 */
ssize_t pxml_parse(int *stateContext, const void *xmlbuf, size_t size,
    pxml_callback_f *cb, void *key)
{
    pstate_e state = (pstate_e)*stateContext;
    const char *chunk_start = (const char *)xmlbuf;
    const char *p = chunk_start;
    const char *end = p + size;

    for (; p < end; p++)
        {
            int C = *(const unsigned char *)p;
            switch (state)
                {
                case ST_TEXT:
                    /*
                     * Initial state: we're in the middle of some text,
                     * or just have started.
                     */
                    if (C == LANGLE)
                        { /* We're now in the tag, probably */
                            TOKEN_CB(PXML_TEXT, ST_TAG_START, 0);
                        }
                    break;
                case ST_TAG_START:
                    if (ALPHA(C) || (C == CSLASH))
                        {
                            state = ST_TAG_BODY;
                        }
                    else if (C == EXCLAM)
                        {
                            state = ST_COMMENT_WAIT_DASH1;
                        }
                    else
                        {
                            /*
                             * Not characters and not whitespace.
                             * Must be something like "3 < 4".
                             */
                            TOKEN_CB(PXML_TEXT, ST_TEXT, 1); /* Flush as data */
                        }
                    break;
                case ST_TAG_BODY:
                    switch (C)
                        {
                        case RANGLE:
                            /* End of the tag */
                            TOKEN_CB_FINAL(PXML_TAG, ST_TEXT, 1);
                            break;
                        case LANGLE:
                            /*
                             * The previous tag wasn't completed, but
                             * still recognized as valid.
                             * (Mozilla-compatible)
                             */
                            TOKEN_CB_FINAL(PXML_TAG, ST_TAG_START, 0);
                            break;
                        case CEQUAL:
                            state = ST_TAG_QUOTE_WAIT;
                            break;
                        }
                    break;
                case ST_TAG_QUOTE_WAIT:
                    /*
                     * State after the equal sign ("=") in the tag.
                     */
                    switch (C)
                        {
                        case CQUOTE:
                            state = ST_TAG_QUOTED_STRING;
                            break;
                        case RANGLE:
                            /* End of the tag */
                            TOKEN_CB_FINAL(PXML_TAG, ST_TEXT, 1);
                            break;
                        default:
                            if (!WHITESPACE(
                                    C))
                                { /* Unquoted string value */
                                    state = ST_TAG_UNQUOTED_STRING;
                                }
                        }
                    break;
                case ST_TAG_QUOTED_STRING:
                    /*
                     * Tag attribute's string value in quotes.
                     */
                    if (C == CQUOTE)
                        {
                            /* Return back to the tag state */
                            state = ST_TAG_BODY;
                        }
                    break;
                case ST_TAG_UNQUOTED_STRING:
                    if (C == RANGLE)
                        {
                            /* End of the tag */
                            TOKEN_CB_FINAL(PXML_TAG, ST_TEXT, 1);
                        }
                    else if (WHITESPACE(C))
                        {
                            /* Return back to the tag state */
                            state = ST_TAG_BODY;
                        }
                    break;
                case ST_COMMENT_WAIT_DASH1:
                    if (C == CDASH)
                        {
                            state = ST_COMMENT_WAIT_DASH2;
                        }
                    else
                        {
                            /* Some ordinary tag. */
                            state = ST_TAG_BODY;
                        }
                    break;
                case ST_COMMENT_WAIT_DASH2:
                    if (C == CDASH)
                        {
                            /* Seen "<--" */
                            state = ST_COMMENT;
                        }
                    else
                        {
                            /* Some ordinary tag */
                            state = ST_TAG_BODY;
                        }
                    break;
                case ST_COMMENT:
                    if (C == CDASH)
                        {
                            state = ST_COMMENT_CLO_DASH2;
                        }
                    break;
                case ST_COMMENT_CLO_DASH2:
                    if (C == CDASH)
                        {
                            state = ST_COMMENT_CLO_RT;
                        }
                    else
                        {
                            /* This is not an end of a comment */
                            state = ST_COMMENT;
                        }
                    break;
                case ST_COMMENT_CLO_RT:
                    if (C == RANGLE)
                        {
                            TOKEN_CB_FINAL(PXML_COMMENT, ST_TEXT, 1);
                        }
                    else if (C == CDASH)
                        {
                            /* Maintain current state, still waiting for '>'
                             */
                        }
                    else
                        {
                            state = ST_COMMENT;
                        }
                    break;
                } /* switch(*ptr) */
        }         /* for() */

    /*
     * Flush the partially processed chunk, state permitting.
     */
    if (p - chunk_start)
        {
            switch (state)
                {
                case ST_COMMENT:
                    TOKEN_CB(PXML_COMMENT, state, 0);
                    break;
                case ST_TEXT:
                    TOKEN_CB(PXML_TEXT, state, 0);
                    break;
                default:
                    break; /* a no-op */
                }
        }

finish:
    *stateContext = (int)state;
    return chunk_start - (const char *)xmlbuf;
}
