/**

 * @file parser_stmt.c

 * @author Radek Krejčí <rkrejci@cesnet.cz>

 * @brief Parser of the extension substatements.

 *

 * Copyright (c) 2019 CESNET, z.s.p.o.

 *

 * This source code is licensed under BSD 3-Clause License (the "License").

 * You may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     https://opensource.org/licenses/BSD-3-Clause

 */

#include <assert.h>

#include <ctype.h>

#include <errno.h>

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include "common.h"

#include "dict.h"

#include "log.h"

#include "parser_schema.h"

#include "path.h"

#include "schema_compile.h"

#include "set.h"

#include "tree.h"

#include "tree_edit.h"

#include "tree_schema.h"

#include "tree_schema_internal.h"

static LY_ERR lysp_stmt_container(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, struct lysp_node *parent,

        struct lysp_node **siblings);

static LY_ERR lysp_stmt_choice(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, struct lysp_node *parent,

        struct lysp_node **siblings);

static LY_ERR lysp_stmt_case(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, struct lysp_node *parent,

        struct lysp_node **siblings);

static LY_ERR lysp_stmt_uses(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, struct lysp_node *parent,

        struct lysp_node **siblings);

static LY_ERR lysp_stmt_grouping(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, struct lysp_node *parent,

        struct lysp_node_grp **groupings);

static LY_ERR lysp_stmt_list(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, struct lysp_node *parent,

        struct lysp_node **siblings);

static LY_ERR

lysp_stmt_validate_value(struct lys_parser_ctx *ctx, enum yang_arg val_type, const char *val)

{

    uint8_t prefix = 0;

    ly_bool first = 1;

    uint32_t c;

    size_t utf8_char_len;

    while (*val) {

        LY_CHECK_ERR_RET(ly_getutf8(&val, &c, &utf8_char_len),

                LOGVAL_PARSER(ctx, LY_VCODE_INCHAR, (val)[-utf8_char_len]), LY_EVALID);

        switch (val_type) {

        case Y_IDENTIF_ARG:

            LY_CHECK_RET(lysp_check_identifierchar(ctx, c, first, NULL));

            break;

        case Y_PREF_IDENTIF_ARG:

            LY_CHECK_RET(lysp_check_identifierchar(ctx, c, first, &prefix));

            break;

        case Y_STR_ARG:

        case Y_MAYBE_STR_ARG:

            LY_CHECK_RET(lysp_check_stringchar(ctx, c));

            break;

        }

        first = 0;

    }

    return LY_SUCCESS;

}

/**

 * @brief Parse extension instance.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in] insubstmt The statement this extension instance is a substatement of.

 * @param[in] insubstmt_index Index of the keyword instance this extension instance is a substatement of.

 * @param[in,out] exts Extension instances to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_ext(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, enum ly_stmt insubstmt,

        LY_ARRAY_COUNT_TYPE insubstmt_index, struct lysp_ext_instance **exts)

{

    struct lysp_ext_instance *e;

    LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *exts, e, LY_EMEM);

    /* store name and insubstmt info */

    LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), stmt->stmt, 0, &e->name));

    e->parent_stmt = insubstmt;

    e->parent_stmt_index = insubstmt_index;

    e->parsed = NULL;

    /* TODO (duplicate) e->child = stmt->child; */

    /* get optional argument */

    if (stmt->arg) {

        LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), stmt->arg, 0, &e->argument));

    }

    return LY_SUCCESS;

}

/**

 * @brief Parse a generic text field without specific constraints. Those are contact, organization,

 * description, etc...

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in] substmt_index Index of this substatement.

 * @param[in,out] value Place to store the parsed value.

 * @param[in] arg Type of the YANG keyword argument (of the value).

 * @param[in,out] exts Extension instances to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_text_field(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, uint32_t substmt_index,

        const char **value, enum yang_arg arg, struct lysp_ext_instance **exts)

{

    if (*value) {

        LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, ly_stmt2str(stmt->kw));

        return LY_EVALID;

    }

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, arg, stmt->arg));

    LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), stmt->arg, 0, value));

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, stmt->kw, substmt_index, exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), ly_stmt2str(stmt->kw));

            return LY_EVALID;

        }

    }

    return LY_SUCCESS;

}

/**

 * @brief Parse a qname that can have more instances such as if-feature.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] qnames Parsed qnames to add to.

 * @param[in] arg Type of the expected argument.

 * @param[in,out] exts Extension instances to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_qnames(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt,

        struct lysp_qname **qnames, enum yang_arg arg, struct lysp_ext_instance **exts)

{

    struct lysp_qname *item;

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, arg, stmt->arg));

    /* allocate new pointer */

    LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *qnames, item, LY_EMEM);

    LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), stmt->arg, 0, &item->str));

    item->mod = ctx->parsed_mod;

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, stmt->kw, LY_ARRAY_COUNT(*qnames) - 1, exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), ly_stmt2str(stmt->kw));

            return LY_EVALID;

        }

    }

    return LY_SUCCESS;

}

/**

 * @brief Parse a generic text field that can have more instances such as base.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] texts Parsed values to add to.

 * @param[in] arg Type of the expected argument.

 * @param[in,out] exts Extension instances to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_text_fields(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt,

        const char ***texts, enum yang_arg arg, struct lysp_ext_instance **exts)

{

    const char **item;

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, arg, stmt->arg));

    /* allocate new pointer */

    LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *texts, item, LY_EMEM);

    LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), stmt->arg, 0, item));

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, stmt->kw, LY_ARRAY_COUNT(*texts) - 1, exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), ly_stmt2str(stmt->kw));

            return LY_EVALID;

        }

    }

    return LY_SUCCESS;

}

/**

 * @brief Parse the status statement.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] flags Flags to add to.

 * @param[in,out] exts Extension instances to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_status(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, uint16_t *flags, struct lysp_ext_instance **exts)

{

    size_t arg_len;

    if (*flags & LYS_STATUS_MASK) {

        LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "status");

        return LY_EVALID;

    }

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, Y_STR_ARG, stmt->arg));

    arg_len = strlen(stmt->arg);

    if ((arg_len == ly_strlen_const("current")) && !strncmp(stmt->arg, "current", arg_len)) {

        *flags |= LYS_STATUS_CURR;

    } else if ((arg_len == ly_strlen_const("deprecated")) && !strncmp(stmt->arg, "deprecated", arg_len)) {

        *flags |= LYS_STATUS_DEPRC;

    } else if ((arg_len == ly_strlen_const("obsolete")) && !strncmp(stmt->arg, "obsolete", arg_len)) {

        *flags |= LYS_STATUS_OBSLT;

    } else {

        LOGVAL_PARSER(ctx, LY_VCODE_INVAL, arg_len, stmt->arg, "status");

        return LY_EVALID;

    }

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_STATUS, 0, exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "status");

            return LY_EVALID;

        }

    }

    return LY_SUCCESS;

}

/**

 * @brief Parse the when statement.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] when_p When pointer to parse to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_when(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, struct lysp_when **when_p)

{

    LY_ERR ret = LY_SUCCESS;

    struct lysp_when *when;

    if (*when_p) {

        LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "when");

        return LY_EVALID;

    }

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, Y_STR_ARG, stmt->arg));

    when = calloc(1, sizeof *when);

    LY_CHECK_ERR_RET(!when, LOGMEM(PARSER_CTX(ctx)), LY_EMEM);

    *when_p = when;

    LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), stmt->arg, 0, &when->cond));

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_DESCRIPTION:

            LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &when->dsc, Y_STR_ARG, &when->exts));

            break;

        case LY_STMT_REFERENCE:

            LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &when->ref, Y_STR_ARG, &when->exts));

            break;

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_WHEN, 0, &when->exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "when");

            return LY_EVALID;

        }

    }

    return ret;

}

/**

 * @brief Parse the config statement.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] flags Flags to add to.

 * @param[in,out] exts Extension instances to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_config(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, uint16_t *flags, struct lysp_ext_instance **exts)

{

    size_t arg_len;

    if (*flags & LYS_CONFIG_MASK) {

        LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "config");

        return LY_EVALID;

    }

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, Y_STR_ARG, stmt->arg));

    arg_len = strlen(stmt->arg);

    if ((arg_len == ly_strlen_const("true")) && !strncmp(stmt->arg, "true", arg_len)) {

        *flags |= LYS_CONFIG_W;

    } else if ((arg_len == ly_strlen_const("false")) && !strncmp(stmt->arg, "false", arg_len)) {

        *flags |= LYS_CONFIG_R;

    } else {

        LOGVAL_PARSER(ctx, LY_VCODE_INVAL, arg_len, stmt->arg, "config");

        return LY_EVALID;

    }

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_CONFIG, 0, exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "config");

            return LY_EVALID;

        }

    }

    return LY_SUCCESS;

}

/**

 * @brief Parse the mandatory statement.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] flags Flags to add to.

 * @param[in,out] exts Extension instances to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_mandatory(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, uint16_t *flags, struct lysp_ext_instance **exts)

{

    size_t arg_len;

    if (*flags & LYS_MAND_MASK) {

        LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "mandatory");

        return LY_EVALID;

    }

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, Y_STR_ARG, stmt->arg));

    arg_len = strlen(stmt->arg);

    if ((arg_len == ly_strlen_const("true")) && !strncmp(stmt->arg, "true", arg_len)) {

        *flags |= LYS_MAND_TRUE;

    } else if ((arg_len == ly_strlen_const("false")) && !strncmp(stmt->arg, "false", arg_len)) {

        *flags |= LYS_MAND_FALSE;

    } else {

        LOGVAL_PARSER(ctx, LY_VCODE_INVAL, arg_len, stmt->arg, "mandatory");

        return LY_EVALID;

    }

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_MANDATORY, 0, exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "mandatory");

            return LY_EVALID;

        }

    }

    return LY_SUCCESS;

}

/**

 * @brief Parse a restriction such as range or length.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] exts Extension instances to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_restr(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, struct lysp_restr *restr)

{

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, Y_STR_ARG, stmt->arg));

    LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), stmt->arg, 0, &restr->arg.str));

    restr->arg.mod = ctx->parsed_mod;

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_DESCRIPTION:

            LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &restr->dsc, Y_STR_ARG, &restr->exts));

            break;

        case LY_STMT_REFERENCE:

            LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &restr->ref, Y_STR_ARG, &restr->exts));

            break;

        case LY_STMT_ERROR_APP_TAG:

            LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &restr->eapptag, Y_STR_ARG, &restr->exts));

            break;

        case LY_STMT_ERROR_MESSAGE:

            LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &restr->emsg, Y_STR_ARG, &restr->exts));

            break;

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, stmt->kw, 0, &restr->exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), ly_stmt2str(stmt->kw));

            return LY_EVALID;

        }

    }

    return LY_SUCCESS;

}

/**

 * @brief Parse a restriction that can have more instances such as must.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] restrs Restrictions to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_restrs(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, struct lysp_restr **restrs)

{

    struct lysp_restr *restr;

    LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *restrs, restr, LY_EMEM);

    return lysp_stmt_restr(ctx, stmt, restr);

}

/**

 * @brief Parse the anydata or anyxml statement.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] siblings Siblings to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_any(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, struct lysp_node *parent, struct lysp_node **siblings)

{

    struct lysp_node_anydata *any;

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, Y_IDENTIF_ARG, stmt->arg));

    /* create new structure and insert into siblings */

    LY_LIST_NEW_RET(PARSER_CTX(ctx), siblings, any, next, LY_EMEM);

    any->nodetype = stmt->kw == LY_STMT_ANYDATA ? LYS_ANYDATA : LYS_ANYXML;

    any->parent = parent;

    LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), stmt->arg, 0, &any->name));

    /* parse substatements */

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_CONFIG:

            LY_CHECK_RET(lysp_stmt_config(ctx, child, &any->flags, &any->exts));

            break;

        case LY_STMT_DESCRIPTION:

            LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &any->dsc, Y_STR_ARG, &any->exts));

            break;

        case LY_STMT_IF_FEATURE:

            LY_CHECK_RET(lysp_stmt_qnames(ctx, child, &any->iffeatures, Y_STR_ARG, &any->exts));

            break;

        case LY_STMT_MANDATORY:

            LY_CHECK_RET(lysp_stmt_mandatory(ctx, child, &any->flags, &any->exts));

            break;

        case LY_STMT_MUST:

            LY_CHECK_RET(lysp_stmt_restrs(ctx, child, &any->musts));

            break;

        case LY_STMT_REFERENCE:

            LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &any->ref, Y_STR_ARG, &any->exts));

            break;

        case LY_STMT_STATUS:

            LY_CHECK_RET(lysp_stmt_status(ctx, child, &any->flags, &any->exts));

            break;

        case LY_STMT_WHEN:

            LY_CHECK_RET(lysp_stmt_when(ctx, child, &any->when));

            break;

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, stmt->kw, 0, &any->exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw),

                    (any->nodetype & LYS_ANYDATA) == LYS_ANYDATA ? ly_stmt2str(LY_STMT_ANYDATA) : ly_stmt2str(LY_STMT_ANYXML));

            return LY_EVALID;

        }

    }

    return LY_SUCCESS;

}

/**

 * @brief Parse the value or position statement. Substatement of type enum statement.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] value Value to write to.

 * @param[in,out] flags Flags to write to.

 * @param[in,out] exts Extension instances to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_type_enum_value_pos(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, int64_t *value, uint16_t *flags,

        struct lysp_ext_instance **exts)

{

    size_t arg_len;

    char *ptr = NULL;

    long int num = 0;

    unsigned long int unum = 0;

    if (*flags & LYS_SET_VALUE) {

        LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, ly_stmt2str(stmt->kw));

        return LY_EVALID;

    }

    *flags |= LYS_SET_VALUE;

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, Y_STR_ARG, stmt->arg));

    arg_len = strlen(stmt->arg);

    if (!arg_len || (stmt->arg[0] == '+') || ((stmt->arg[0] == '0') && (arg_len > 1)) ||

            ((stmt->kw == LY_STMT_POSITION) && !strncmp(stmt->arg, "-0", 2))) {

        LOGVAL_PARSER(ctx, LY_VCODE_INVAL, arg_len, stmt->arg, ly_stmt2str(stmt->kw));

        goto error;

    }

    errno = 0;

    if (stmt->kw == LY_STMT_VALUE) {

        num = strtol(stmt->arg, &ptr, LY_BASE_DEC);

        if ((num < INT64_C(-2147483648)) || (num > INT64_C(2147483647))) {

            LOGVAL_PARSER(ctx, LY_VCODE_INVAL, arg_len, stmt->arg, ly_stmt2str(stmt->kw));

            goto error;

        }

    } else {

        unum = strtoul(stmt->arg, &ptr, LY_BASE_DEC);

        if (unum > UINT64_C(4294967295)) {

            LOGVAL_PARSER(ctx, LY_VCODE_INVAL, arg_len, stmt->arg, ly_stmt2str(stmt->kw));

            goto error;

        }

    }

    /* we have not parsed the whole argument */

    if ((size_t)(ptr - stmt->arg) != arg_len) {

        LOGVAL_PARSER(ctx, LY_VCODE_INVAL, arg_len, stmt->arg, ly_stmt2str(stmt->kw));

        goto error;

    }

    if (errno == ERANGE) {

        LOGVAL_PARSER(ctx, LY_VCODE_OOB, arg_len, stmt->arg, ly_stmt2str(stmt->kw));

        goto error;

    }

    if (stmt->kw == LY_STMT_VALUE) {

        *value = num;

    } else {

        *value = unum;

    }

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, stmt->kw == LY_STMT_VALUE ? LY_STMT_VALUE : LY_STMT_POSITION, 0, exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), ly_stmt2str(stmt->kw));

            return LY_EVALID;

        }

    }

    return LY_SUCCESS;

error:

    return LY_EVALID;

}

/**

 * @brief Parse the enum or bit statement. Substatement of type statement.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] enums Enums or bits to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_type_enum(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, struct lysp_type_enum **enums)

{

    struct lysp_type_enum *enm;

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, stmt->kw == LY_STMT_ENUM ? Y_STR_ARG : Y_IDENTIF_ARG, stmt->arg));

    LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *enums, enm, LY_EMEM);

    if (stmt->kw == LY_STMT_ENUM) {

        LY_CHECK_RET(lysp_check_enum_name(ctx, stmt->arg, strlen(stmt->arg)));

    } /* else nothing specific for YANG_BIT */

    LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), stmt->arg, 0, &enm->name));

    CHECK_UNIQUENESS(ctx, *enums, name, ly_stmt2str(stmt->kw), enm->name);

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_DESCRIPTION:

            LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &enm->dsc, Y_STR_ARG, &enm->exts));

            break;

        case LY_STMT_IF_FEATURE:

            PARSER_CHECK_STMTVER2_RET(ctx, "if-feature", ly_stmt2str(stmt->kw));

            LY_CHECK_RET(lysp_stmt_qnames(ctx, child, &enm->iffeatures, Y_STR_ARG, &enm->exts));

            break;

        case LY_STMT_REFERENCE:

            LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &enm->ref, Y_STR_ARG, &enm->exts));

            break;

        case LY_STMT_STATUS:

            LY_CHECK_RET(lysp_stmt_status(ctx, child, &enm->flags, &enm->exts));

            break;

        case LY_STMT_VALUE:

            LY_CHECK_ERR_RET(stmt->kw == LY_STMT_BIT, LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw),

                    ly_stmt2str(stmt->kw)), LY_EVALID);

            LY_CHECK_RET(lysp_stmt_type_enum_value_pos(ctx, child, &enm->value, &enm->flags, &enm->exts));

            break;

        case LY_STMT_POSITION:

            LY_CHECK_ERR_RET(stmt->kw == LY_STMT_ENUM, LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw),

                    ly_stmt2str(stmt->kw)), LY_EVALID);

            LY_CHECK_RET(lysp_stmt_type_enum_value_pos(ctx, child, &enm->value, &enm->flags, &enm->exts));

            break;

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, stmt->kw, 0, &enm->exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), ly_stmt2str(stmt->kw));

            return LY_EVALID;

        }

    }

    return LY_SUCCESS;

}

/**

 * @brief Parse the fraction-digits statement. Substatement of type statement.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] fracdig Value to write to.

 * @param[in,out] exts Extension instances to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_type_fracdigits(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, uint8_t *fracdig, struct lysp_ext_instance **exts)

{

    char *ptr;

    size_t arg_len;

    unsigned long int num;

    if (*fracdig) {

        LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "fraction-digits");

        return LY_EVALID;

    }

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, Y_STR_ARG, stmt->arg));

    arg_len = strlen(stmt->arg);

    if (!arg_len || (stmt->arg[0] == '0') || !isdigit(stmt->arg[0])) {

        LOGVAL_PARSER(ctx, LY_VCODE_INVAL, arg_len, stmt->arg, "fraction-digits");

        return LY_EVALID;

    }

    errno = 0;

    num = strtoul(stmt->arg, &ptr, LY_BASE_DEC);

    /* we have not parsed the whole argument */

    if ((size_t)(ptr - stmt->arg) != arg_len) {

        LOGVAL_PARSER(ctx, LY_VCODE_INVAL, arg_len, stmt->arg, "fraction-digits");

        return LY_EVALID;

    }

    if ((errno == ERANGE) || (num > LY_TYPE_DEC64_FD_MAX)) {

        LOGVAL_PARSER(ctx, LY_VCODE_OOB, arg_len, stmt->arg, "fraction-digits");

        return LY_EVALID;

    }

    *fracdig = num;

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_FRACTION_DIGITS, 0, exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "fraction-digits");

            return LY_EVALID;

        }

    }

    return LY_SUCCESS;

}

/**

 * @brief Parse the require-instance statement. Substatement of type statement.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] reqinst Value to write to.

 * @param[in,out] flags Flags to write to.

 * @param[in,out] exts Extension instances to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_type_reqinstance(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, uint8_t *reqinst, uint16_t *flags,

        struct lysp_ext_instance **exts)

{

    size_t arg_len;

    if (*flags & LYS_SET_REQINST) {

        LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "require-instance");

        return LY_EVALID;

    }

    *flags |= LYS_SET_REQINST;

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, Y_STR_ARG, stmt->arg));

    arg_len = strlen(stmt->arg);

    if ((arg_len == ly_strlen_const("true")) && !strncmp(stmt->arg, "true", arg_len)) {

        *reqinst = 1;

    } else if ((arg_len != ly_strlen_const("false")) || strncmp(stmt->arg, "false", arg_len)) {

        LOGVAL_PARSER(ctx, LY_VCODE_INVAL, arg_len, stmt->arg, "require-instance");

        return LY_EVALID;

    }

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_REQUIRE_INSTANCE, 0, exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "require-instance");

            return LY_EVALID;

        }

    }

    return LY_SUCCESS;

}

/**

 * @brief Parse the modifier statement. Substatement of type pattern statement.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] pat Value to write to.

 * @param[in,out] exts Extension instances to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_type_pattern_modifier(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, const char **pat, struct lysp_ext_instance **exts)

{

    size_t arg_len;

    char *buf;

    if ((*pat)[0] == LYSP_RESTR_PATTERN_NACK) {

        LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "modifier");

        return LY_EVALID;

    }

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, Y_STR_ARG, stmt->arg));

    arg_len = strlen(stmt->arg);

    if ((arg_len != ly_strlen_const("invert-match")) || strncmp(stmt->arg, "invert-match", arg_len)) {

        LOGVAL_PARSER(ctx, LY_VCODE_INVAL, arg_len, stmt->arg, "modifier");

        return LY_EVALID;

    }

    /* replace the value in the dictionary */

    buf = malloc(strlen(*pat) + 1);

    LY_CHECK_ERR_RET(!buf, LOGMEM(PARSER_CTX(ctx)), LY_EMEM);

    strcpy(buf, *pat);

    lydict_remove(PARSER_CTX(ctx), *pat);

    assert(buf[0] == LYSP_RESTR_PATTERN_ACK);

    buf[0] = LYSP_RESTR_PATTERN_NACK;

    LY_CHECK_RET(lydict_insert_zc(PARSER_CTX(ctx), buf, pat));

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_MODIFIER, 0, exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "modifier");

            return LY_EVALID;

        }

    }

    return LY_SUCCESS;

}

/**

 * @brief Parse the pattern statement. Substatement of type statement.

 *

 * @param[in] ctx parser context.

 * @param[in] stmt Source statement data from the parsed extension instance.

 * @param[in,out] patterns Restrictions to add to.

 *

 * @return LY_ERR values.

 */

static LY_ERR

lysp_stmt_type_pattern(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, struct lysp_restr **patterns)

{

    char *buf;

    size_t arg_len;

    struct lysp_restr *restr;

    LY_CHECK_RET(lysp_stmt_validate_value(ctx, Y_STR_ARG, stmt->arg));

    LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *patterns, restr, LY_EMEM);

    arg_len = strlen(stmt->arg);

    /* add special meaning first byte */

    buf = malloc(arg_len + 2);

    LY_CHECK_ERR_RET(!buf, LOGMEM(PARSER_CTX(ctx)), LY_EMEM);

    memmove(buf + 1, stmt->arg, arg_len);

    buf[0] = LYSP_RESTR_PATTERN_ACK; /* pattern's default regular-match flag */

    buf[arg_len + 1] = '\0'; /* terminating NULL byte */

    LY_CHECK_RET(lydict_insert_zc(PARSER_CTX(ctx), buf, &restr->arg.str));

    restr->arg.mod = ctx->parsed_mod;

    for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {

        switch (child->kw) {

        case LY_STMT_DESCRIPTION:

            LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &restr->dsc, Y_STR_ARG, &restr->exts));

            break;

        case LY_STMT_REFERENCE:

            LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &restr->ref, Y_STR_ARG, &restr->exts));

            break;

        case LY_STMT_ERROR_APP_TAG:

            LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &restr->eapptag, Y_STR_ARG, &restr->exts));

            break;

        case LY_STMT_ERROR_MESSAGE:

            LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &restr->emsg, Y_STR_ARG, &restr->exts));

            break;

        case LY_STMT_MODIFIER:

            PARSER_CHECK_STMTVER2_RET(ctx, "modifier", "pattern");

            LY_CHECK_RET(lysp_stmt_type_pattern_modifier(ctx, child, &restr->arg.str, &restr->exts));

            break;

        case LY_STMT_EXTENSION_INSTANCE:

            LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_PATTERN, 0, &restr->exts));

            break;

        default:

            LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "pattern");

            return LY_EVALID;

        }

    }

    return LY_SUCCESS;

}

/**