diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2e80117..cca4d5a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -115,9 +115,11 @@
     src/printer_xml.c
     src/printer_json.c
     src/printer_lyb.c
+    src/schema_compile.c
+    src/schema_compile_node.c
+    src/schema_compile_amend.c
     src/tree_schema.c
     src/tree_schema_free.c
-    src/tree_schema_compile.c
     src/tree_schema_helpers.c
     src/parser.c
     src/parser_yang.c
diff --git a/src/parser_stmt.c b/src/parser_stmt.c
index 94b97f7..c694fe9 100644
--- a/src/parser_stmt.c
+++ b/src/parser_stmt.c
@@ -25,6 +25,7 @@
 #include "parser.h"
 #include "parser_schema.h"
 #include "path.h"
+#include "schema_compile.h"
 #include "tree.h"
 #include "tree_schema.h"
 #include "tree_schema_internal.h"
diff --git a/src/plugins_exts_metadata.c b/src/plugins_exts_metadata.c
index 1e8364c..ceae257 100644
--- a/src/plugins_exts_metadata.c
+++ b/src/plugins_exts_metadata.c
@@ -17,6 +17,7 @@
 
 #include "plugins_exts.h"
 #include "plugins_exts_metadata.h"
+#include "schema_compile.h"
 #include "tree_schema.h"
 
 /**
diff --git a/src/schema_compile.c b/src/schema_compile.c
new file mode 100644
index 0000000..4b0e796
--- /dev/null
+++ b/src/schema_compile.c
@@ -0,0 +1,2147 @@
+/**
+ * @file schema_compile.c
+ * @author Radek Krejci <rkrejci@cesnet.cz>
+ * @brief Schema compilation.
+ *
+ * Copyright (c) 2015 - 2020 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
+ */
+
+#define _GNU_SOURCE
+
+#include "schema_compile.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+#include "compat.h"
+#include "context.h"
+#include "dict.h"
+#include "log.h"
+#include "parser.h"
+#include "parser_schema.h"
+#include "path.h"
+#include "plugins_exts.h"
+#include "plugins_exts_internal.h"
+#include "plugins_types.h"
+#include "schema_compile_amend.h"
+#include "schema_compile_node.h"
+#include "set.h"
+#include "tree.h"
+#include "tree_data.h"
+#include "tree_data_internal.h"
+#include "tree_schema.h"
+#include "tree_schema_internal.h"
+#include "xpath.h"
+
+#define COMPILE_CHECK_UNIQUENESS_ARRAY(CTX, ARRAY, MEMBER, EXCL, STMT, IDENT) \
+    if (ARRAY) { \
+        for (LY_ARRAY_COUNT_TYPE u__ = 0; u__ < LY_ARRAY_COUNT(ARRAY); ++u__) { \
+            if (&(ARRAY)[u__] != EXCL && (void*)((ARRAY)[u__].MEMBER) == (void*)(IDENT)) { \
+                LOGVAL((CTX)->ctx, LY_VLOG_STR, (CTX)->path, LY_VCODE_DUPIDENT, IDENT, STMT); \
+                return LY_EVALID; \
+            } \
+        } \
+    }
+
+/**
+ * @brief Fill in the prepared compiled extensions definition structure according to the parsed extension definition.
+ */
+static LY_ERR
+lys_compile_extension(struct lysc_ctx *ctx, const struct lys_module *ext_mod, struct lysp_ext *ext_p, struct lysc_ext **ext)
+{
+    LY_ERR ret = LY_SUCCESS;
+
+    if (!ext_p->compiled) {
+        lysc_update_path(ctx, NULL, "{extension}");
+        lysc_update_path(ctx, NULL, ext_p->name);
+
+        /* compile the extension definition */
+        ext_p->compiled = calloc(1, sizeof **ext);
+        ext_p->compiled->refcount = 1;
+        DUP_STRING_GOTO(ctx->ctx, ext_p->name, ext_p->compiled->name, ret, done);
+        DUP_STRING_GOTO(ctx->ctx, ext_p->argument, ext_p->compiled->argument, ret, done);
+        ext_p->compiled->module = (struct lys_module *)ext_mod;
+        COMPILE_EXTS_GOTO(ctx, ext_p->exts, ext_p->compiled->exts, *ext, LYEXT_PAR_EXT, ret, done);
+
+        lysc_update_path(ctx, NULL, NULL);
+        lysc_update_path(ctx, NULL, NULL);
+
+        /* find extension definition plugin */
+        ext_p->compiled->plugin = lyext_get_plugin(ext_p->compiled);
+    }
+
+    *ext = lysc_ext_dup(ext_p->compiled);
+
+done:
+    return ret;
+}
+
+LY_ERR
+lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext, void *parent,
+        LYEXT_PARENT parent_type, const struct lys_module *ext_mod)
+{
+    LY_ERR ret = LY_SUCCESS;
+    const char *name;
+    size_t u;
+    LY_ARRAY_COUNT_TYPE v;
+    const char *prefixed_name = NULL;
+
+    DUP_STRING(ctx->ctx, ext_p->argument, ext->argument, ret);
+    LY_CHECK_RET(ret);
+
+    ext->insubstmt = ext_p->insubstmt;
+    ext->insubstmt_index = ext_p->insubstmt_index;
+    ext->module = ctx->cur_mod;
+    ext->parent = parent;
+    ext->parent_type = parent_type;
+
+    lysc_update_path(ctx, ext->parent_type == LYEXT_PAR_NODE ? (struct lysc_node *)ext->parent : NULL, "{extension}");
+
+    /* get module where the extension definition should be placed */
+    for (u = strlen(ext_p->name); u && ext_p->name[u - 1] != ':'; --u) {}
+    if (ext_p->yin) {
+        /* YIN parser has to replace prefixes by the namespace - XML namespace/prefix pairs may differs form the YANG schema's
+         * namespace/prefix pair. YIN parser does not have the imports available, so mapping from XML namespace to the
+         * YANG (import) prefix must be done here. */
+        if (!ly_strncmp(ctx->pmod->mod->ns, ext_p->name, u - 1)) {
+            LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, &ext_p->name[u], 0, &prefixed_name), cleanup);
+            u = 0;
+        } else {
+            LY_ARRAY_FOR(ctx->pmod->imports, v) {
+                if (!ly_strncmp(ctx->pmod->imports[v].module->ns, ext_p->name, u - 1)) {
+                    char *s;
+                    LY_CHECK_ERR_GOTO(asprintf(&s, "%s:%s", ctx->pmod->imports[v].prefix, &ext_p->name[u]) == -1,
+                            ret = LY_EMEM, cleanup);
+                    LY_CHECK_GOTO(ret = lydict_insert_zc(ctx->ctx, s, &prefixed_name), cleanup);
+                    u = strlen(ctx->pmod->imports[v].prefix) + 1; /* add semicolon */
+                    break;
+                }
+            }
+        }
+        if (!prefixed_name) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid XML prefix of \"%.*s\" namespace used for extension instance identifier.", u, ext_p->name);
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+    } else {
+        prefixed_name = ext_p->name;
+    }
+    lysc_update_path(ctx, NULL, prefixed_name);
+
+    if (!ext_mod) {
+        ext_mod = u ? lysp_module_find_prefix(ctx->pmod, prefixed_name, u - 1) : ctx->pmod->mod;
+        if (!ext_mod) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid prefix \"%.*s\" used for extension instance identifier.", u, prefixed_name);
+            ret = LY_EVALID;
+            goto cleanup;
+        } else if (!ext_mod->parsed->extensions) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Extension instance \"%s\" refers \"%s\" module that does not contain extension definitions.",
+                    prefixed_name, ext_mod->name);
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+    }
+    name = &prefixed_name[u];
+
+    /* find the parsed extension definition there */
+    LY_ARRAY_FOR(ext_mod->parsed->extensions, v) {
+        if (!strcmp(name, ext_mod->parsed->extensions[v].name)) {
+            /* compile extension definition and assign it */
+            LY_CHECK_GOTO(ret = lys_compile_extension(ctx, ext_mod, &ext_mod->parsed->extensions[v], &ext->def), cleanup);
+            break;
+        }
+    }
+    if (!ext->def) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                "Extension definition of extension instance \"%s\" not found.", prefixed_name);
+        ret = LY_EVALID;
+        goto cleanup;
+    }
+
+    /* unify the parsed extension from YIN and YANG sources. Without extension definition, it is not possible
+     * to get extension's argument from YIN source, so it is stored as one of the substatements. Here we have
+     * to find it, mark it with LYS_YIN_ARGUMENT and store it in the compiled structure. */
+    if (ext_p->yin && ext->def->argument && !ext->argument) {
+        /* Schema was parsed from YIN and an argument is expected, ... */
+        struct lysp_stmt *stmt = NULL;
+
+        if (ext->def->flags & LYS_YINELEM_TRUE) {
+            /* ... argument was the first XML child element */
+            if (ext_p->child && !(ext_p->child->flags & LYS_YIN_ATTR)) {
+                /* TODO check namespace of the statement */
+                if (!strcmp(ext_p->child->stmt, ext->def->argument)) {
+                    stmt = ext_p->child;
+                }
+            }
+        } else {
+            /* ... argument was one of the XML attributes which are represented as child stmt
+             * with LYS_YIN_ATTR flag */
+            for (stmt = ext_p->child; stmt && (stmt->flags & LYS_YIN_ATTR); stmt = stmt->next) {
+                if (!strcmp(stmt->stmt, ext->def->argument)) {
+                    /* this is the extension's argument */
+                    break;
+                }
+            }
+        }
+        if (!stmt) {
+            /* missing extension's argument */
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Extension instance \"%s\" misses argument \"%s\".", prefixed_name, ext->def->argument);
+            ret = LY_EVALID;
+            goto cleanup;
+
+        }
+        LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, stmt->arg, 0, &ext->argument), cleanup);
+        stmt->flags |= LYS_YIN_ARGUMENT;
+    }
+    if (prefixed_name != ext_p->name) {
+        lydict_remove(ctx->ctx, ext_p->name);
+        ext_p->name = prefixed_name;
+        if (!ext_p->argument && ext->argument) {
+            LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, ext->argument, 0, &ext_p->argument), cleanup);
+        }
+    }
+
+    if (ext->def->plugin && ext->def->plugin->compile) {
+        if (ext->argument) {
+            lysc_update_path(ctx, (struct lysc_node *)ext, ext->argument);
+        }
+        LY_CHECK_GOTO(ret = ext->def->plugin->compile(ctx, ext_p, ext), cleanup);
+        if (ext->argument) {
+            lysc_update_path(ctx, NULL, NULL);
+        }
+    }
+    ext_p->compiled = ext;
+
+cleanup:
+    if (prefixed_name && (prefixed_name != ext_p->name)) {
+        lydict_remove(ctx->ctx, prefixed_name);
+    }
+
+    lysc_update_path(ctx, NULL, NULL);
+    lysc_update_path(ctx, NULL, NULL);
+
+    return ret;
+}
+
+struct lysc_ext *
+lysc_ext_dup(struct lysc_ext *orig)
+{
+    ++orig->refcount;
+    return orig;
+}
+
+static void
+lysc_unres_dflt_free(const struct ly_ctx *ctx, struct lysc_unres_dflt *r)
+{
+    assert(!r->dflt || !r->dflts);
+    if (r->dflt) {
+        lysp_qname_free((struct ly_ctx *)ctx, r->dflt);
+        free(r->dflt);
+    } else {
+        FREE_ARRAY((struct ly_ctx *)ctx, r->dflts, lysp_qname_free);
+    }
+    free(r);
+}
+
+void
+lysc_update_path(struct lysc_ctx *ctx, struct lysc_node *parent, const char *name)
+{
+    int len;
+    uint8_t nextlevel = 0; /* 0 - no starttag, 1 - '/' starttag, 2 - '=' starttag + '}' endtag */
+
+    if (!name) {
+        /* removing last path segment */
+        if (ctx->path[ctx->path_len - 1] == '}') {
+            for ( ; ctx->path[ctx->path_len] != '=' && ctx->path[ctx->path_len] != '{'; --ctx->path_len) {}
+            if (ctx->path[ctx->path_len] == '=') {
+                ctx->path[ctx->path_len++] = '}';
+            } else {
+                /* not a top-level special tag, remove also preceiding '/' */
+                goto remove_nodelevel;
+            }
+        } else {
+remove_nodelevel:
+            for ( ; ctx->path[ctx->path_len] != '/'; --ctx->path_len) {}
+            if (ctx->path_len == 0) {
+                /* top-level (last segment) */
+                ctx->path_len = 1;
+            }
+        }
+        /* set new terminating NULL-byte */
+        ctx->path[ctx->path_len] = '\0';
+    } else {
+        if (ctx->path_len > 1) {
+            if (!parent && (ctx->path[ctx->path_len - 1] == '}') && (ctx->path[ctx->path_len - 2] != '\'')) {
+                /* extension of the special tag */
+                nextlevel = 2;
+                --ctx->path_len;
+            } else {
+                /* there is already some path, so add next level */
+                nextlevel = 1;
+            }
+        } /* else the path is just initiated with '/', so do not add additional slash in case of top-level nodes */
+
+        if (nextlevel != 2) {
+            if ((parent && (parent->module == ctx->cur_mod)) || (!parent && (ctx->path_len > 1) && (name[0] == '{'))) {
+                /* module not changed, print the name unprefixed */
+                len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s", nextlevel ? "/" : "", name);
+            } else {
+                len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s:%s", nextlevel ? "/" : "", ctx->cur_mod->name, name);
+            }
+        } else {
+            len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "='%s'}", name);
+        }
+        if (len >= LYSC_CTX_BUFSIZE - (int)ctx->path_len) {
+            /* output truncated */
+            ctx->path_len = LYSC_CTX_BUFSIZE - 1;
+        } else {
+            ctx->path_len += len;
+        }
+    }
+}
+
+/**
+ * @brief Stack for processing if-feature expressions.
+ */
+struct iff_stack {
+    size_t size;    /**< number of items in the stack */
+    size_t index;   /**< first empty item */
+    uint8_t *stack; /**< stack - array of @ref ifftokens to create the if-feature expression in prefix format */
+};
+
+/**
+ * @brief Add @ref ifftokens into the stack.
+ * @param[in] stack The if-feature stack to use.
+ * @param[in] value One of the @ref ifftokens to store in the stack.
+ * @return LY_EMEM in case of memory allocation error
+ * @return LY_ESUCCESS if the value successfully stored.
+ */
+static LY_ERR
+iff_stack_push(struct iff_stack *stack, uint8_t value)
+{
+    if (stack->index == stack->size) {
+        stack->size += 4;
+        stack->stack = ly_realloc(stack->stack, stack->size * sizeof *stack->stack);
+        LY_CHECK_ERR_RET(!stack->stack, LOGMEM(NULL); stack->size = 0, LY_EMEM);
+    }
+    stack->stack[stack->index++] = value;
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Get (and remove) the last item form the stack.
+ * @param[in] stack The if-feature stack to use.
+ * @return The value from the top of the stack.
+ */
+static uint8_t
+iff_stack_pop(struct iff_stack *stack)
+{
+    assert(stack && stack->index);
+
+    stack->index--;
+    return stack->stack[stack->index];
+}
+
+/**
+ * @brief Clean up the stack.
+ * @param[in] stack The if-feature stack to use.
+ */
+static void
+iff_stack_clean(struct iff_stack *stack)
+{
+    stack->size = 0;
+    free(stack->stack);
+}
+
+/**
+ * @brief Store the @ref ifftokens (@p op) on the given position in the 2bits array
+ * (libyang format of the if-feature expression).
+ * @param[in,out] list The 2bits array to modify.
+ * @param[in] op The operand (@ref ifftokens) to store.
+ * @param[in] pos Position (0-based) where to store the given @p op.
+ */
+static void
+iff_setop(uint8_t *list, uint8_t op, size_t pos)
+{
+    uint8_t *item;
+    uint8_t mask = 3;
+
+    assert(op <= 3); /* max 2 bits */
+
+    item = &list[pos / 4];
+    mask = mask << 2 * (pos % 4);
+    *item = (*item) & ~mask;
+    *item = (*item) | (op << 2 * (pos % 4));
+}
+
+#define LYS_IFF_LP 0x04 /**< Additional, temporary, value of @ref ifftokens: ( */
+#define LYS_IFF_RP 0x08 /**< Additional, temporary, value of @ref ifftokens: ) */
+
+/**
+ * @brief Find a feature of the given name and referenced in the given module.
+ *
+ * If the compiled schema is available (the schema is implemented), the feature from the compiled schema is
+ * returned. Otherwise, the special array of pre-compiled features is used to search for the feature. Such
+ * features are always disabled (feature from not implemented schema cannot be enabled), but in case the schema
+ * will be made implemented in future (no matter if implicitly via augmenting/deviating it or explicitly via
+ * ly_ctx_module_implement()), the compilation of these feature structure is finished, but the pointers
+ * assigned till that time will be still valid.
+ *
+ * @param[in] pmod Module where the feature was referenced (used to resolve prefix of the feature).
+ * @param[in] name Name of the feature including possible prefix.
+ * @param[in] len Length of the string representing the feature identifier in the name variable (mandatory!).
+ * @return Pointer to the feature structure if found, NULL otherwise.
+ */
+static struct lysc_feature *
+lys_feature_find(const struct lysp_module *pmod, const char *name, size_t len)
+{
+    LY_ARRAY_COUNT_TYPE u;
+    struct lysc_feature *f;
+    const struct lys_module *mod;
+    const char *ptr;
+
+    assert(pmod);
+
+    if ((ptr = ly_strnchr(name, ':', len))) {
+        /* we have a prefixed feature */
+        mod = lysp_module_find_prefix(pmod, name, ptr - name);
+        LY_CHECK_RET(!mod, NULL);
+
+        len = len - (ptr - name) - 1;
+        name = ptr + 1;
+    } else {
+        /* local feature */
+        mod = pmod->mod;
+    }
+
+    /* we have the correct module, get the feature */
+    LY_ARRAY_FOR(mod->features, u) {
+        f = &mod->features[u];
+        if (!ly_strncmp(f->name, name, len)) {
+            return f;
+        }
+    }
+
+    return NULL;
+}
+
+LY_ERR
+lys_compile_iffeature(struct lysc_ctx *ctx, struct lysp_qname *qname, struct lysc_iffeature *iff)
+{
+    LY_ERR rc = LY_SUCCESS;
+    const char *c = qname->str;
+    int64_t i, j;
+    int8_t op_len, last_not = 0, checkversion = 0;
+    LY_ARRAY_COUNT_TYPE f_size = 0, expr_size = 0, f_exp = 1;
+    uint8_t op;
+    struct iff_stack stack = {0, 0, NULL};
+    struct lysc_feature *f;
+
+    assert(c);
+
+    /* pre-parse the expression to get sizes for arrays, also do some syntax checks of the expression */
+    for (i = j = 0; c[i]; i++) {
+        if (c[i] == '(') {
+            j++;
+            checkversion = 1;
+            continue;
+        } else if (c[i] == ')') {
+            j--;
+            continue;
+        } else if (isspace(c[i])) {
+            checkversion = 1;
+            continue;
+        }
+
+        if (!strncmp(&c[i], "not", op_len = 3) || !strncmp(&c[i], "and", op_len = 3) || !strncmp(&c[i], "or", op_len = 2)) {
+            uint64_t spaces;
+            for (spaces = 0; c[i + op_len + spaces] && isspace(c[i + op_len + spaces]); spaces++) {}
+            if (c[i + op_len + spaces] == '\0') {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                        "Invalid value \"%s\" of if-feature - unexpected end of expression.", qname->str);
+                return LY_EVALID;
+            } else if (!isspace(c[i + op_len])) {
+                /* feature name starting with the not/and/or */
+                last_not = 0;
+                f_size++;
+            } else if (c[i] == 'n') { /* not operation */
+                if (last_not) {
+                    /* double not */
+                    expr_size = expr_size - 2;
+                    last_not = 0;
+                } else {
+                    last_not = 1;
+                }
+            } else { /* and, or */
+                if (f_exp != f_size) {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                            "Invalid value \"%s\" of if-feature - missing feature/expression before \"%.*s\" operation.",
+                            qname->str, op_len, &c[i]);
+                    return LY_EVALID;
+                }
+                f_exp++;
+
+                /* not a not operation */
+                last_not = 0;
+            }
+            i += op_len;
+        } else {
+            f_size++;
+            last_not = 0;
+        }
+        expr_size++;
+
+        while (!isspace(c[i])) {
+            if (!c[i] || (c[i] == ')') || (c[i] == '(')) {
+                i--;
+                break;
+            }
+            i++;
+        }
+    }
+    if (j) {
+        /* not matching count of ( and ) */
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                "Invalid value \"%s\" of if-feature - non-matching opening and closing parentheses.", qname->str);
+        return LY_EVALID;
+    }
+    if (f_exp != f_size) {
+        /* features do not match the needed arguments for the logical operations */
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                "Invalid value \"%s\" of if-feature - number of features in expression does not match "
+                "the required number of operands for the operations.", qname->str);
+        return LY_EVALID;
+    }
+
+    if (checkversion || (expr_size > 1)) {
+        /* check that we have 1.1 module */
+        if (qname->mod->version != LYS_VERSION_1_1) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                    "Invalid value \"%s\" of if-feature - YANG 1.1 expression in YANG 1.0 module.", qname->str);
+            return LY_EVALID;
+        }
+    }
+
+    /* allocate the memory */
+    LY_ARRAY_CREATE_RET(ctx->ctx, iff->features, f_size, LY_EMEM);
+    iff->expr = calloc((j = (expr_size / 4) + ((expr_size % 4) ? 1 : 0)), sizeof *iff->expr);
+    stack.stack = malloc(expr_size * sizeof *stack.stack);
+    LY_CHECK_ERR_GOTO(!stack.stack || !iff->expr, LOGMEM(ctx->ctx); rc = LY_EMEM, error);
+
+    stack.size = expr_size;
+    f_size--; expr_size--; /* used as indexes from now */
+
+    for (i--; i >= 0; i--) {
+        if (c[i] == ')') {
+            /* push it on stack */
+            iff_stack_push(&stack, LYS_IFF_RP);
+            continue;
+        } else if (c[i] == '(') {
+            /* pop from the stack into result all operators until ) */
+            while ((op = iff_stack_pop(&stack)) != LYS_IFF_RP) {
+                iff_setop(iff->expr, op, expr_size--);
+            }
+            continue;
+        } else if (isspace(c[i])) {
+            continue;
+        }
+
+        /* end of operator or operand -> find beginning and get what is it */
+        j = i + 1;
+        while (i >= 0 && !isspace(c[i]) && c[i] != '(') {
+            i--;
+        }
+        i++; /* go back by one step */
+
+        if (!strncmp(&c[i], "not", 3) && isspace(c[i + 3])) {
+            if (stack.index && (stack.stack[stack.index - 1] == LYS_IFF_NOT)) {
+                /* double not */
+                iff_stack_pop(&stack);
+            } else {
+                /* not has the highest priority, so do not pop from the stack
+                 * as in case of AND and OR */
+                iff_stack_push(&stack, LYS_IFF_NOT);
+            }
+        } else if (!strncmp(&c[i], "and", 3) && isspace(c[i + 3])) {
+            /* as for OR - pop from the stack all operators with the same or higher
+             * priority and store them to the result, then push the AND to the stack */
+            while (stack.index && stack.stack[stack.index - 1] <= LYS_IFF_AND) {
+                op = iff_stack_pop(&stack);
+                iff_setop(iff->expr, op, expr_size--);
+            }
+            iff_stack_push(&stack, LYS_IFF_AND);
+        } else if (!strncmp(&c[i], "or", 2) && isspace(c[i + 2])) {
+            while (stack.index && stack.stack[stack.index - 1] <= LYS_IFF_OR) {
+                op = iff_stack_pop(&stack);
+                iff_setop(iff->expr, op, expr_size--);
+            }
+            iff_stack_push(&stack, LYS_IFF_OR);
+        } else {
+            /* feature name, length is j - i */
+
+            /* add it to the expression */
+            iff_setop(iff->expr, LYS_IFF_F, expr_size--);
+
+            /* now get the link to the feature definition */
+            f = lys_feature_find(qname->mod, &c[i], j - i);
+            LY_CHECK_ERR_GOTO(!f, LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                    "Invalid value \"%s\" of if-feature - unable to find feature \"%.*s\".", qname->str, j - i, &c[i]);
+                    rc = LY_EVALID, error)
+            iff->features[f_size] = f;
+            LY_ARRAY_INCREMENT(iff->features);
+            f_size--;
+        }
+    }
+    while (stack.index) {
+        op = iff_stack_pop(&stack);
+        iff_setop(iff->expr, op, expr_size--);
+    }
+
+    if (++expr_size || ++f_size) {
+        /* not all expected operators and operands found */
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                "Invalid value \"%s\" of if-feature - processing error.", qname->str);
+        rc = LY_EINT;
+    } else {
+        rc = LY_SUCCESS;
+    }
+
+error:
+    /* cleanup */
+    iff_stack_clean(&stack);
+
+    return rc;
+}
+
+/**
+ * @brief Compile information in the import statement - make sure there is the target module
+ * @param[in] ctx Compile context.
+ * @param[in] imp_p The parsed import statement structure to fill the module to.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_import(struct lysc_ctx *ctx, struct lysp_import *imp_p)
+{
+    const struct lys_module *mod = NULL;
+    LY_ERR ret = LY_SUCCESS;
+
+    /* make sure that we have the parsed version (lysp_) of the imported module to import groupings or typedefs.
+     * The compiled version is needed only for augments, deviates and leafrefs, so they are checked (and added,
+     * if needed) when these nodes are finally being instantiated and validated at the end of schema compilation. */
+    if (!imp_p->module->parsed) {
+        /* try to use filepath if present */
+        if (imp_p->module->filepath) {
+            struct ly_in *in;
+            if (ly_in_new_filepath(imp_p->module->filepath, 0, &in)) {
+                LOGINT(ctx->ctx);
+            } else {
+                LY_CHECK_RET(lys_parse(ctx->ctx, in, !strcmp(&imp_p->module->filepath[strlen(imp_p->module->filepath - 4)],
+                        ".yin") ? LYS_IN_YIN : LYS_IN_YANG, &mod));
+                if (mod != imp_p->module) {
+                    LOGERR(ctx->ctx, LY_EINT, "Filepath \"%s\" of the module \"%s\" does not match.",
+                            imp_p->module->filepath, imp_p->module->name);
+                    mod = NULL;
+                }
+            }
+            ly_in_free(in, 1);
+        }
+        if (!mod) {
+            if (lysp_load_module(ctx->ctx, imp_p->module->name, imp_p->module->revision, 0, 1, (struct lys_module **)&mod)) {
+                LOGERR(ctx->ctx, LY_ENOTFOUND, "Unable to reload \"%s\" module to import it into \"%s\", source data not found.",
+                        imp_p->module->name, ctx->cur_mod->name);
+                return LY_ENOTFOUND;
+            }
+        }
+    }
+
+    return ret;
+}
+
+LY_ERR
+lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
+        struct lysp_ident *identities_p, struct lysc_ident **identities)
+{
+    LY_ARRAY_COUNT_TYPE offset = 0, u, v;
+    struct lysc_ctx context = {0};
+    LY_ERR ret = LY_SUCCESS;
+
+    assert(ctx_sc || ctx);
+
+    if (!ctx_sc) {
+        context.ctx = ctx;
+        context.cur_mod = parsed_mod->mod;
+        context.pmod = parsed_mod;
+        context.path_len = 1;
+        context.path[0] = '/';
+        ctx_sc = &context;
+    }
+
+    if (!identities_p) {
+        return LY_SUCCESS;
+    }
+    if (*identities) {
+        offset = LY_ARRAY_COUNT(*identities);
+    }
+
+    lysc_update_path(ctx_sc, NULL, "{identity}");
+    LY_ARRAY_CREATE_RET(ctx_sc->ctx, *identities, LY_ARRAY_COUNT(identities_p), LY_EMEM);
+    LY_ARRAY_FOR(identities_p, u) {
+        lysc_update_path(ctx_sc, NULL, identities_p[u].name);
+
+        LY_ARRAY_INCREMENT(*identities);
+        COMPILE_CHECK_UNIQUENESS_ARRAY(ctx_sc, *identities, name, &(*identities)[offset + u], "identity", identities_p[u].name);
+        DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].name, (*identities)[offset + u].name, ret, done);
+        DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].dsc, (*identities)[offset + u].dsc, ret, done);
+        DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].ref, (*identities)[offset + u].ref, ret, done);
+        (*identities)[offset + u].module = ctx_sc->cur_mod;
+        COMPILE_ARRAY_GOTO(ctx_sc, identities_p[u].iffeatures, (*identities)[offset + u].iffeatures, v,
+                lys_compile_iffeature, ret, done);
+        /* backlinks (derived) can be added no sooner than when all the identities in the current module are present */
+        COMPILE_EXTS_GOTO(ctx_sc, identities_p[u].exts, (*identities)[offset + u].exts, &(*identities)[offset + u],
+                LYEXT_PAR_IDENT, ret, done);
+        (*identities)[offset + u].flags = identities_p[u].flags;
+
+        lysc_update_path(ctx_sc, NULL, NULL);
+    }
+    lysc_update_path(ctx_sc, NULL, NULL);
+done:
+    return ret;
+}
+
+/**
+ * @brief Check circular dependency of identities - identity MUST NOT reference itself (via their base statement).
+ *
+ * The function works in the same way as lys_compile_feature_circular_check() with different structures and error messages.
+ *
+ * @param[in] ctx Compile context for logging.
+ * @param[in] ident The base identity (its derived list is being extended by the identity being currently processed).
+ * @param[in] derived The list of derived identities of the identity being currently processed (not the one provided as @p ident)
+ * @return LY_SUCCESS if everything is ok.
+ * @return LY_EVALID if the identity is derived from itself.
+ */
+static LY_ERR
+lys_compile_identity_circular_check(struct lysc_ctx *ctx, struct lysc_ident *ident, struct lysc_ident **derived)
+{
+    LY_ERR ret = LY_SUCCESS;
+    LY_ARRAY_COUNT_TYPE u, v;
+    struct ly_set recursion = {0};
+    struct lysc_ident *drv;
+
+    if (!derived) {
+        return LY_SUCCESS;
+    }
+
+    for (u = 0; u < LY_ARRAY_COUNT(derived); ++u) {
+        if (ident == derived[u]) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Identity \"%s\" is indirectly derived from itself.", ident->name);
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+        ret = ly_set_add(&recursion, derived[u], 0, NULL);
+        LY_CHECK_GOTO(ret, cleanup);
+    }
+
+    for (v = 0; v < recursion.count; ++v) {
+        drv = recursion.objs[v];
+        if (!drv->derived) {
+            continue;
+        }
+        for (u = 0; u < LY_ARRAY_COUNT(drv->derived); ++u) {
+            if (ident == drv->derived[u]) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                        "Identity \"%s\" is indirectly derived from itself.", ident->name);
+                ret = LY_EVALID;
+                goto cleanup;
+            }
+            ret = ly_set_add(&recursion, drv->derived[u], 0, NULL);
+            LY_CHECK_GOTO(ret, cleanup);
+        }
+    }
+
+cleanup:
+    ly_set_erase(&recursion, NULL);
+    return ret;
+}
+
+LY_ERR
+lys_compile_identity_bases(struct lysc_ctx *ctx, const struct lysp_module *base_pmod, const char **bases_p,
+        struct lysc_ident *ident, struct lysc_ident ***bases)
+{
+    LY_ARRAY_COUNT_TYPE u, v;
+    const char *s, *name;
+    const struct lys_module *mod;
+    struct lysc_ident **idref;
+
+    assert(ident || bases);
+
+    if ((LY_ARRAY_COUNT(bases_p) > 1) && (ctx->pmod->version < LYS_VERSION_1_1)) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                "Multiple bases in %s are allowed only in YANG 1.1 modules.", ident ? "identity" : "identityref type");
+        return LY_EVALID;
+    }
+
+    LY_ARRAY_FOR(bases_p, u) {
+        s = strchr(bases_p[u], ':');
+        if (s) {
+            /* prefixed identity */
+            name = &s[1];
+            mod = lysp_module_find_prefix(base_pmod, bases_p[u], s - bases_p[u]);
+        } else {
+            name = bases_p[u];
+            mod = base_pmod->mod;
+        }
+        if (!mod) {
+            if (ident) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                        "Invalid prefix used for base (%s) of identity \"%s\".", bases_p[u], ident->name);
+            } else {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                        "Invalid prefix used for base (%s) of identityref.", bases_p[u]);
+            }
+            return LY_EVALID;
+        }
+
+        idref = NULL;
+        LY_ARRAY_FOR(mod->identities, v) {
+            if (!strcmp(name, mod->identities[v].name)) {
+                if (ident) {
+                    if (ident == &mod->identities[v]) {
+                        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                                "Identity \"%s\" is derived from itself.", ident->name);
+                        return LY_EVALID;
+                    }
+                    LY_CHECK_RET(lys_compile_identity_circular_check(ctx, &mod->identities[v], ident->derived));
+                    /* we have match! store the backlink */
+                    LY_ARRAY_NEW_RET(ctx->ctx, mod->identities[v].derived, idref, LY_EMEM);
+                    *idref = ident;
+                } else {
+                    /* we have match! store the found identity */
+                    LY_ARRAY_NEW_RET(ctx->ctx, *bases, idref, LY_EMEM);
+                    *idref = &mod->identities[v];
+                }
+                break;
+            }
+        }
+        if (!idref || !(*idref)) {
+            if (ident) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                        "Unable to find base (%s) of identity \"%s\".", bases_p[u], ident->name);
+            } else {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                        "Unable to find base (%s) of identityref.", bases_p[u]);
+            }
+            return LY_EVALID;
+        }
+    }
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief For the given array of identities, set the backlinks from all their base identities.
+ * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
+ * @param[in] idents_p Array of identities definitions from the parsed schema structure.
+ * @param[in] idents Array of referencing identities to which the backlinks are supposed to be set.
+ * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
+ */
+static LY_ERR
+lys_compile_identities_derived(struct lysc_ctx *ctx, struct lysp_ident *idents_p, struct lysc_ident *idents)
+{
+    LY_ARRAY_COUNT_TYPE u;
+
+    lysc_update_path(ctx, NULL, "{identity}");
+    for (u = 0; u < LY_ARRAY_COUNT(idents_p); ++u) {
+        if (!idents_p[u].bases) {
+            continue;
+        }
+        lysc_update_path(ctx, NULL, idents[u].name);
+        LY_CHECK_RET(lys_compile_identity_bases(ctx, idents[u].module->parsed, idents_p[u].bases, &idents[u], NULL));
+        lysc_update_path(ctx, NULL, NULL);
+    }
+    lysc_update_path(ctx, NULL, NULL);
+    return LY_SUCCESS;
+}
+
+LY_ERR
+lys_feature_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
+        struct lysp_feature *features_p, struct lysc_feature **features)
+{
+    LY_ERR ret = LY_SUCCESS;
+    LY_ARRAY_COUNT_TYPE offset = 0, u;
+    struct lysc_ctx context = {0};
+
+    assert(ctx_sc || ctx);
+
+    if (!ctx_sc) {
+        context.ctx = ctx;
+        context.cur_mod = parsed_mod->mod;
+        context.pmod = parsed_mod;
+        context.path_len = 1;
+        context.path[0] = '/';
+        ctx_sc = &context;
+    }
+
+    if (!features_p) {
+        return LY_SUCCESS;
+    }
+    if (*features) {
+        offset = LY_ARRAY_COUNT(*features);
+    }
+
+    lysc_update_path(ctx_sc, NULL, "{feature}");
+    LY_ARRAY_CREATE_RET(ctx_sc->ctx, *features, LY_ARRAY_COUNT(features_p), LY_EMEM);
+    LY_ARRAY_FOR(features_p, u) {
+        lysc_update_path(ctx_sc, NULL, features_p[u].name);
+
+        LY_ARRAY_INCREMENT(*features);
+        COMPILE_CHECK_UNIQUENESS_ARRAY(ctx_sc, *features, name, &(*features)[offset + u], "feature", features_p[u].name);
+        DUP_STRING_GOTO(ctx_sc->ctx, features_p[u].name, (*features)[offset + u].name, ret, done);
+        DUP_STRING_GOTO(ctx_sc->ctx, features_p[u].dsc, (*features)[offset + u].dsc, ret, done);
+        DUP_STRING_GOTO(ctx_sc->ctx, features_p[u].ref, (*features)[offset + u].ref, ret, done);
+        (*features)[offset + u].flags = features_p[u].flags;
+        (*features)[offset + u].module = ctx_sc->cur_mod;
+
+        lysc_update_path(ctx_sc, NULL, NULL);
+    }
+    lysc_update_path(ctx_sc, NULL, NULL);
+
+done:
+    return ret;
+}
+
+/**
+ * @brief Check circular dependency of features - feature MUST NOT reference itself (via their if-feature statement).
+ *
+ * The function works in the same way as lys_compile_identity_circular_check() with different structures and error messages.
+ *
+ * @param[in] ctx Compile context for logging.
+ * @param[in] feature The feature referenced in if-feature statement (its depfeatures list is being extended by the feature
+ *            being currently processed).
+ * @param[in] depfeatures The list of depending features of the feature being currently processed (not the one provided as @p feature)
+ * @return LY_SUCCESS if everything is ok.
+ * @return LY_EVALID if the feature references indirectly itself.
+ */
+static LY_ERR
+lys_compile_feature_circular_check(struct lysc_ctx *ctx, struct lysc_feature *feature, struct lysc_feature **depfeatures)
+{
+    LY_ERR ret = LY_SUCCESS;
+    LY_ARRAY_COUNT_TYPE u, v;
+    struct ly_set recursion = {0};
+    struct lysc_feature *drv;
+
+    if (!depfeatures) {
+        return LY_SUCCESS;
+    }
+
+    for (u = 0; u < LY_ARRAY_COUNT(depfeatures); ++u) {
+        if (feature == depfeatures[u]) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Feature \"%s\" is indirectly referenced from itself.", feature->name);
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+        ret = ly_set_add(&recursion, depfeatures[u], 0, NULL);
+        LY_CHECK_GOTO(ret, cleanup);
+    }
+
+    for (v = 0; v < recursion.count; ++v) {
+        drv = recursion.objs[v];
+        if (!drv->depfeatures) {
+            continue;
+        }
+        for (u = 0; u < LY_ARRAY_COUNT(drv->depfeatures); ++u) {
+            if (feature == drv->depfeatures[u]) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                        "Feature \"%s\" is indirectly referenced from itself.", feature->name);
+                ret = LY_EVALID;
+                goto cleanup;
+            }
+            ly_set_add(&recursion, drv->depfeatures[u], 0, NULL);
+            LY_CHECK_GOTO(ret, cleanup);
+        }
+    }
+
+cleanup:
+    ly_set_erase(&recursion, NULL);
+    return ret;
+}
+
+/**
+ * @brief Create pre-compiled features array.
+ *
+ * See lys_feature_precompile() for more details.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] feature_p Parsed feature definition to compile.
+ * @param[in,out] features List of already (pre)compiled features to find the corresponding precompiled feature structure.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_feature_precompile_finish(struct lysc_ctx *ctx, struct lysp_feature *feature_p, struct lysc_feature *features)
+{
+    LY_ARRAY_COUNT_TYPE u, v, x;
+    struct lysc_feature *feature, **df;
+    LY_ERR ret = LY_SUCCESS;
+
+    /* find the preprecompiled feature */
+    LY_ARRAY_FOR(features, x) {
+        if (strcmp(features[x].name, feature_p->name)) {
+            continue;
+        }
+        feature = &features[x];
+        lysc_update_path(ctx, NULL, "{feature}");
+        lysc_update_path(ctx, NULL, feature_p->name);
+
+        /* finish compilation started in lys_feature_precompile() */
+        COMPILE_EXTS_GOTO(ctx, feature_p->exts, feature->exts, feature, LYEXT_PAR_FEATURE, ret, done);
+        COMPILE_ARRAY_GOTO(ctx, feature_p->iffeatures, feature->iffeatures, u, lys_compile_iffeature, ret, done);
+        if (feature->iffeatures) {
+            for (u = 0; u < LY_ARRAY_COUNT(feature->iffeatures); ++u) {
+                if (feature->iffeatures[u].features) {
+                    for (v = 0; v < LY_ARRAY_COUNT(feature->iffeatures[u].features); ++v) {
+                        /* check for circular dependency - direct reference first,... */
+                        if (feature == feature->iffeatures[u].features[v]) {
+                            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                                    "Feature \"%s\" is referenced from itself.", feature->name);
+                            return LY_EVALID;
+                        }
+                        /* ... and indirect circular reference */
+                        LY_CHECK_RET(lys_compile_feature_circular_check(ctx, feature->iffeatures[u].features[v], feature->depfeatures));
+
+                        /* add itself into the dependants list */
+                        LY_ARRAY_NEW_RET(ctx->ctx, feature->iffeatures[u].features[v]->depfeatures, df, LY_EMEM);
+                        *df = feature;
+                    }
+                }
+            }
+        }
+        lysc_update_path(ctx, NULL, NULL);
+        lysc_update_path(ctx, NULL, NULL);
+done:
+        return ret;
+    }
+
+    LOGINT(ctx->ctx);
+    return LY_EINT;
+}
+
+void
+lys_feature_precompile_revert(struct lysc_ctx *ctx, struct lys_module *mod)
+{
+    LY_ARRAY_COUNT_TYPE u, v;
+
+    /* in the dis_features list, remove all the parts (from finished compiling process)
+     * which may points into the data being freed here */
+    LY_ARRAY_FOR(mod->features, u) {
+        LY_ARRAY_FOR(mod->features[u].iffeatures, v) {
+            lysc_iffeature_free(ctx->ctx, &mod->features[u].iffeatures[v]);
+        }
+        LY_ARRAY_FREE(mod->features[u].iffeatures);
+        mod->features[u].iffeatures = NULL;
+
+        LY_ARRAY_FOR(mod->features[u].exts, v) {
+            lysc_ext_instance_free(ctx->ctx, &(mod->features[u].exts)[v]);
+        }
+        LY_ARRAY_FREE(mod->features[u].exts);
+        mod->features[u].exts = NULL;
+    }
+}
+
+/**
+ * @brief Check the features used in if-feature statements applicable to the leafref and its target.
+ *
+ * The set of features used for target must be a subset of features used for the leafref.
+ * This is not a perfect, we should compare the truth tables but it could require too much resources
+ * and RFC 7950 does not require it explicitely, so we simplify that.
+ *
+ * @param[in] refnode The leafref node.
+ * @param[in] target Tha target node of the leafref.
+ * @return LY_SUCCESS or LY_EVALID;
+ */
+static LY_ERR
+lys_compile_leafref_features_validate(const struct lysc_node *refnode, const struct lysc_node *target)
+{
+    LY_ERR ret = LY_EVALID;
+    const struct lysc_node *iter;
+    LY_ARRAY_COUNT_TYPE u, v;
+    struct ly_set features = {0};
+
+    for (iter = refnode; iter; iter = iter->parent) {
+        if (iter->iffeatures) {
+            LY_ARRAY_FOR(iter->iffeatures, u) {
+                LY_ARRAY_FOR(iter->iffeatures[u].features, v) {
+                    LY_CHECK_GOTO(ly_set_add(&features, iter->iffeatures[u].features[v], 0, NULL), cleanup);
+                }
+            }
+        }
+    }
+
+    /* we should have, in features set, a superset of features applicable to the target node.
+     * If the feature is not present, we don;t have a subset of features applicable
+     * to the leafref itself. */
+    for (iter = target; iter; iter = iter->parent) {
+        if (iter->iffeatures) {
+            LY_ARRAY_FOR(iter->iffeatures, u) {
+                LY_ARRAY_FOR(iter->iffeatures[u].features, v) {
+                    if (!ly_set_contains(&features, iter->iffeatures[u].features[v], NULL)) {
+                        /* feature not present */
+                        goto cleanup;
+                    }
+                }
+            }
+        }
+    }
+    ret = LY_SUCCESS;
+
+cleanup:
+    ly_set_erase(&features, NULL);
+    return ret;
+}
+
+static void *
+lys_compile_extension_instance_storage(enum ly_stmt stmt, struct lysc_ext_substmt *substmts)
+{
+    for (LY_ARRAY_COUNT_TYPE u = 0; substmts[u].stmt; ++u) {
+        if (substmts[u].stmt == stmt) {
+            return substmts[u].storage;
+        }
+    }
+    return NULL;
+}
+
+LY_ERR
+lys_compile_extension_instance(struct lysc_ctx *ctx, const struct lysp_ext_instance *ext, struct lysc_ext_substmt *substmts)
+{
+    LY_ERR ret = LY_EVALID, r;
+    LY_ARRAY_COUNT_TYPE u;
+    struct lysp_stmt *stmt;
+    struct lysp_qname qname;
+    void *parsed = NULL, **compiled = NULL;
+
+    /* check for invalid substatements */
+    for (stmt = ext->child; stmt; stmt = stmt->next) {
+        if (stmt->flags & (LYS_YIN_ATTR | LYS_YIN_ARGUMENT)) {
+            continue;
+        }
+        for (u = 0; substmts[u].stmt; ++u) {
+            if (substmts[u].stmt == stmt->kw) {
+                break;
+            }
+        }
+        if (!substmts[u].stmt) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid keyword \"%s\" as a child of \"%s%s%s\" extension instance.",
+                    stmt->stmt, ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
+            goto cleanup;
+        }
+    }
+
+    /* TODO store inherited data, e.g. status first, but mark them somehow to allow to overwrite them and not detect duplicity */
+
+    /* keep order of the processing the same as the order in the defined substmts,
+     * the order is important for some of the statements depending on others (e.g. type needs status and units) */
+    for (u = 0; substmts[u].stmt; ++u) {
+        ly_bool stmt_present = 0;
+
+        for (stmt = ext->child; stmt; stmt = stmt->next) {
+            if (substmts[u].stmt != stmt->kw) {
+                continue;
+            }
+
+            stmt_present = 1;
+            if (substmts[u].storage) {
+                switch (stmt->kw) {
+                case LY_STMT_STATUS:
+                    assert(substmts[u].cardinality < LY_STMT_CARD_SOME);
+                    LY_CHECK_ERR_GOTO(r = lysp_stmt_parse(ctx, stmt, stmt->kw, &substmts[u].storage, /* TODO */ NULL), ret = r, cleanup);
+                    break;
+                case LY_STMT_UNITS: {
+                    const char **units;
+
+                    if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
+                        /* single item */
+                        if (*((const char **)substmts[u].storage)) {
+                            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPSTMT, stmt->stmt);
+                            goto cleanup;
+                        }
+                        units = (const char **)substmts[u].storage;
+                    } else {
+                        /* sized array */
+                        const char ***units_array = (const char ***)substmts[u].storage;
+                        LY_ARRAY_NEW_GOTO(ctx->ctx, *units_array, units, ret, cleanup);
+                    }
+                    r = lydict_insert(ctx->ctx, stmt->arg, 0, units);
+                    LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
+                    break;
+                }
+                case LY_STMT_TYPE: {
+                    uint16_t *flags = lys_compile_extension_instance_storage(LY_STMT_STATUS, substmts);
+                    const char **units = lys_compile_extension_instance_storage(LY_STMT_UNITS, substmts);
+
+                    if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
+                        /* single item */
+                        if (*(struct lysc_type **)substmts[u].storage) {
+                            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPSTMT, stmt->stmt);
+                            goto cleanup;
+                        }
+                        compiled = substmts[u].storage;
+                    } else {
+                        /* sized array */
+                        struct lysc_type ***types = (struct lysc_type ***)substmts[u].storage, **type = NULL;
+                        LY_ARRAY_NEW_GOTO(ctx->ctx, *types, type, ret, cleanup);
+                        compiled = (void *)type;
+                    }
+
+                    r = lysp_stmt_parse(ctx, stmt, stmt->kw, &parsed, NULL);
+                    LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
+                    r = lys_compile_type(ctx, ext->parent_type == LYEXT_PAR_NODE ? ((struct lysc_node *)ext->parent)->sp : NULL,
+                            flags ? *flags : 0, ctx->pmod, ext->name, parsed, (struct lysc_type **)compiled,
+                            units && !*units ? units : NULL, NULL);
+                    lysp_type_free(ctx->ctx, parsed);
+                    free(parsed);
+                    LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
+                    break;
+                }
+                case LY_STMT_IF_FEATURE: {
+                    struct lysc_iffeature *iff = NULL;
+
+                    if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
+                        /* single item */
+                        if (((struct lysc_iffeature *)substmts[u].storage)->features) {
+                            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPSTMT, stmt->stmt);
+                            goto cleanup;
+                        }
+                        iff = (struct lysc_iffeature *)substmts[u].storage;
+                    } else {
+                        /* sized array */
+                        struct lysc_iffeature **iffs = (struct lysc_iffeature **)substmts[u].storage;
+                        LY_ARRAY_NEW_GOTO(ctx->ctx, *iffs, iff, ret, cleanup);
+                    }
+                    qname.str = stmt->arg;
+                    qname.mod = ctx->pmod;
+                    LY_CHECK_ERR_GOTO(r = lys_compile_iffeature(ctx, &qname, iff), ret = r, cleanup);
+                    break;
+                }
+                /* TODO support other substatements (parse stmt to lysp and then compile lysp to lysc),
+                 * also note that in many statements their extensions are not taken into account  */
+                default:
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Statement \"%s\" is not supported as an extension (found in \"%s%s%s\") substatement.",
+                            stmt->stmt, ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
+                    goto cleanup;
+                }
+            }
+        }
+
+        if (((substmts[u].cardinality == LY_STMT_CARD_MAND) || (substmts[u].cardinality == LY_STMT_CARD_SOME)) && !stmt_present) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Missing mandatory keyword \"%s\" as a child of \"%s%s%s\".",
+                    ly_stmt2str(substmts[u].stmt), ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
+            goto cleanup;
+        }
+    }
+
+    ret = LY_SUCCESS;
+
+cleanup:
+    return ret;
+}
+
+/**
+ * @brief Check when for cyclic dependencies.
+ *
+ * @param[in] set Set with all the referenced nodes.
+ * @param[in] node Node whose "when" referenced nodes are in @p set.
+ * @return LY_ERR value
+ */
+static LY_ERR
+lys_compile_unres_when_cyclic(struct lyxp_set *set, const struct lysc_node *node)
+{
+    struct lyxp_set tmp_set;
+    struct lyxp_set_scnode *xp_scnode;
+    uint32_t i, j;
+    LY_ARRAY_COUNT_TYPE u;
+    struct lysc_when *when;
+    LY_ERR ret = LY_SUCCESS;
+
+    memset(&tmp_set, 0, sizeof tmp_set);
+
+    /* prepare in_ctx of the set */
+    for (i = 0; i < set->used; ++i) {
+        xp_scnode = &set->val.scnodes[i];
+
+        if (xp_scnode->in_ctx != -1) {
+            /* check node when, skip the context node (it was just checked) */
+            xp_scnode->in_ctx = 1;
+        }
+    }
+
+    for (i = 0; i < set->used; ++i) {
+        xp_scnode = &set->val.scnodes[i];
+        if (xp_scnode->in_ctx != 1) {
+            /* already checked */
+            continue;
+        }
+
+        if ((xp_scnode->type != LYXP_NODE_ELEM) || (xp_scnode->scnode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) ||
+                !xp_scnode->scnode->when) {
+            /* no when to check */
+            xp_scnode->in_ctx = 0;
+            continue;
+        }
+
+        node = xp_scnode->scnode;
+        do {
+            LY_ARRAY_FOR(node->when, u) {
+                when = node->when[u];
+                ret = lyxp_atomize(when->cond, node->module, LY_PREF_SCHEMA_RESOLVED, when->prefixes, when->context,
+                        &tmp_set, LYXP_SCNODE_SCHEMA);
+                if (ret != LY_SUCCESS) {
+                    LOGVAL(set->ctx, LY_VLOG_LYSC, node, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when->cond->expr);
+                    goto cleanup;
+                }
+
+                for (j = 0; j < tmp_set.used; ++j) {
+                    /* skip roots'n'stuff */
+                    if (tmp_set.val.scnodes[j].type == LYXP_NODE_ELEM) {
+                        /* try to find this node in our set */
+                        uint32_t idx;
+                        if (lyxp_set_scnode_contains(set, tmp_set.val.scnodes[j].scnode, LYXP_NODE_ELEM, -1, &idx) && (set->val.scnodes[idx].in_ctx == -1)) {
+                            LOGVAL(set->ctx, LY_VLOG_LYSC, node, LY_VCODE_CIRC_WHEN, node->name, set->val.scnodes[idx].scnode->name);
+                            ret = LY_EVALID;
+                            goto cleanup;
+                        }
+
+                        /* needs to be checked, if in both sets, will be ignored */
+                        tmp_set.val.scnodes[j].in_ctx = 1;
+                    } else {
+                        /* no when, nothing to check */
+                        tmp_set.val.scnodes[j].in_ctx = 0;
+                    }
+                }
+
+                /* merge this set into the global when set */
+                lyxp_set_scnode_merge(set, &tmp_set);
+            }
+
+            /* check when of non-data parents as well */
+            node = node->parent;
+        } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE)));
+
+        /* this node when was checked (xp_scnode could have been reallocd) */
+        set->val.scnodes[i].in_ctx = -1;
+    }
+
+cleanup:
+    lyxp_set_free_content(&tmp_set);
+    return ret;
+}
+
+LY_ERR
+lysc_check_status(struct lysc_ctx *ctx, uint16_t flags1, void *mod1, const char *name1, uint16_t flags2, void *mod2,
+        const char *name2)
+{
+    uint16_t flg1, flg2;
+
+    flg1 = (flags1 & LYS_STATUS_MASK) ? (flags1 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
+    flg2 = (flags2 & LYS_STATUS_MASK) ? (flags2 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
+
+    if ((flg1 < flg2) && (mod1 == mod2)) {
+        if (ctx) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "A %s definition \"%s\" is not allowed to reference %s definition \"%s\".",
+                    flg1 == LYS_STATUS_CURR ? "current" : "deprecated", name1,
+                    flg2 == LYS_STATUS_OBSLT ? "obsolete" : "deprecated", name2);
+        }
+        return LY_EVALID;
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Check when/must expressions of a node on a complete compiled schema tree.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] node Node to check.
+ * @return LY_ERR value
+ */
+static LY_ERR
+lys_compile_unres_xpath(struct lysc_ctx *ctx, const struct lysc_node *node)
+{
+    struct lyxp_set tmp_set;
+    uint32_t i, opts;
+    LY_ARRAY_COUNT_TYPE u;
+    ly_bool input_done = 0;
+    struct lysc_when **when = NULL;
+    struct lysc_must *musts = NULL;
+    LY_ERR ret = LY_SUCCESS;
+    const struct lysc_node *op;
+
+    memset(&tmp_set, 0, sizeof tmp_set);
+    opts = LYXP_SCNODE_SCHEMA;
+    if (node->flags & LYS_CONFIG_R) {
+        for (op = node->parent; op && !(op->nodetype & (LYS_RPC | LYS_ACTION)); op = op->parent) {}
+        if (op) {
+            /* we are actually in output */
+            opts = LYXP_SCNODE_OUTPUT;
+        }
+    }
+
+    switch (node->nodetype) {
+    case LYS_CONTAINER:
+        when = ((struct lysc_node_container *)node)->when;
+        musts = ((struct lysc_node_container *)node)->musts;
+        break;
+    case LYS_CHOICE:
+        when = ((struct lysc_node_choice *)node)->when;
+        break;
+    case LYS_LEAF:
+        when = ((struct lysc_node_leaf *)node)->when;
+        musts = ((struct lysc_node_leaf *)node)->musts;
+        break;
+    case LYS_LEAFLIST:
+        when = ((struct lysc_node_leaflist *)node)->when;
+        musts = ((struct lysc_node_leaflist *)node)->musts;
+        break;
+    case LYS_LIST:
+        when = ((struct lysc_node_list *)node)->when;
+        musts = ((struct lysc_node_list *)node)->musts;
+        break;
+    case LYS_ANYXML:
+    case LYS_ANYDATA:
+        when = ((struct lysc_node_anydata *)node)->when;
+        musts = ((struct lysc_node_anydata *)node)->musts;
+        break;
+    case LYS_CASE:
+        when = ((struct lysc_node_case *)node)->when;
+        break;
+    case LYS_NOTIF:
+        when = ((struct lysc_notif *)node)->when;
+        musts = ((struct lysc_notif *)node)->musts;
+        break;
+    case LYS_RPC:
+    case LYS_ACTION:
+        /* first process when and input musts */
+        when = ((struct lysc_action *)node)->when;
+        musts = ((struct lysc_action *)node)->input.musts;
+        break;
+    default:
+        /* nothing to check */
+        break;
+    }
+
+    /* check "when" */
+    LY_ARRAY_FOR(when, u) {
+        ret = lyxp_atomize(when[u]->cond, node->module, LY_PREF_SCHEMA_RESOLVED, when[u]->prefixes, when[u]->context,
+                &tmp_set, opts);
+        if (ret != LY_SUCCESS) {
+            LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when[u]->cond->expr);
+            goto cleanup;
+        }
+
+        ctx->path[0] = '\0';
+        lysc_path((struct lysc_node *)node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
+        for (i = 0; i < tmp_set.used; ++i) {
+            /* skip roots'n'stuff */
+            if ((tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (tmp_set.val.scnodes[i].in_ctx != -1)) {
+                struct lysc_node *schema = tmp_set.val.scnodes[i].scnode;
+
+                /* XPath expression cannot reference "lower" status than the node that has the definition */
+                ret = lysc_check_status(ctx, when[u]->flags, node->module, node->name, schema->flags, schema->module,
+                        schema->name);
+                LY_CHECK_GOTO(ret, cleanup);
+
+                /* check dummy node accessing */
+                if (schema == node) {
+                    LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LY_VCODE_DUMMY_WHEN, node->name);
+                    ret = LY_EVALID;
+                    goto cleanup;
+                }
+            }
+        }
+
+        /* check cyclic dependencies */
+        ret = lys_compile_unres_when_cyclic(&tmp_set, node);
+        LY_CHECK_GOTO(ret, cleanup);
+
+        lyxp_set_free_content(&tmp_set);
+    }
+
+check_musts:
+    /* check "must" */
+    LY_ARRAY_FOR(musts, u) {
+        ret = lyxp_atomize(musts[u].cond, node->module, LY_PREF_SCHEMA_RESOLVED, musts[u].prefixes, node, &tmp_set, opts);
+        if (ret != LY_SUCCESS) {
+            LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_SEMANTICS, "Invalid must restriction \"%s\".", musts[u].cond->expr);
+            goto cleanup;
+        }
+
+        ctx->path[0] = '\0';
+        lysc_path((struct lysc_node *)node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
+        for (i = 0; i < tmp_set.used; ++i) {
+            /* skip roots'n'stuff */
+            if (tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
+                /* XPath expression cannot reference "lower" status than the node that has the definition */
+                ret = lysc_check_status(ctx, node->flags, node->module, node->name, tmp_set.val.scnodes[i].scnode->flags,
+                        tmp_set.val.scnodes[i].scnode->module, tmp_set.val.scnodes[i].scnode->name);
+                LY_CHECK_GOTO(ret, cleanup);
+            }
+        }
+
+        lyxp_set_free_content(&tmp_set);
+    }
+
+    if ((node->nodetype & (LYS_RPC | LYS_ACTION)) && !input_done) {
+        /* now check output musts */
+        input_done = 1;
+        when = NULL;
+        musts = ((struct lysc_action *)node)->output.musts;
+        opts = LYXP_SCNODE_OUTPUT;
+        goto check_musts;
+    }
+
+cleanup:
+    lyxp_set_free_content(&tmp_set);
+    return ret;
+}
+
+/**
+ * @brief Check leafref for its target existence on a complete compiled schema tree.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] node Context node for the leafref.
+ * @param[in] lref Leafref to check/resolve.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, struct lysc_type_leafref *lref)
+{
+    const struct lysc_node *target = NULL, *siter;
+    struct ly_path *p;
+    struct lysc_type *type;
+
+    assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
+
+    /* try to find the target */
+    LY_CHECK_RET(ly_path_compile(ctx->ctx, node->module, node, lref->path, LY_PATH_LREF_TRUE, lysc_is_output(node) ?
+            LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY, LY_PREF_SCHEMA_RESOLVED, lref->prefixes, &p));
+
+    /* get the target node */
+    target = p[LY_ARRAY_COUNT(p) - 1].node;
+    ly_path_free(node->module->ctx, p);
+
+    if (!(target->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+        LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_REFERENCE,
+                "Invalid leafref path \"%s\" - target node is %s instead of leaf or leaf-list.",
+                lref->path->expr, lys_nodetype2str(target->nodetype));
+        return LY_EVALID;
+    }
+
+    /* check status */
+    ctx->path[0] = '\0';
+    lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
+    ctx->path_len = strlen(ctx->path);
+    if (lysc_check_status(ctx, node->flags, node->module, node->name, target->flags, target->module, target->name)) {
+        return LY_EVALID;
+    }
+    ctx->path_len = 1;
+    ctx->path[1] = '\0';
+
+    /* check config */
+    if (lref->require_instance) {
+        for (siter = node->parent; siter && !(siter->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); siter = siter->parent) {}
+        if (!siter && (node->flags & LYS_CONFIG_W) && (target->flags & LYS_CONFIG_R)) {
+            LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target is supposed"
+                    " to represent configuration data (as the leafref does), but it does not.", lref->path->expr);
+            return LY_EVALID;
+        }
+    }
+
+    /* store the target's type and check for circular chain of leafrefs */
+    lref->realtype = ((struct lysc_node_leaf *)target)->type;
+    for (type = lref->realtype; type && type->basetype == LY_TYPE_LEAFREF; type = ((struct lysc_type_leafref *)type)->realtype) {
+        if (type == (struct lysc_type *)lref) {
+            /* circular chain detected */
+            LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_REFERENCE,
+                    "Invalid leafref path \"%s\" - circular chain of leafrefs detected.", lref->path->expr);
+            return LY_EVALID;
+        }
+    }
+
+    /* check if leafref and its target are under common if-features */
+    if (lys_compile_leafref_features_validate(node, target)) {
+        LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_REFERENCE,
+                "Invalid leafref path \"%s\" - set of features applicable to the leafref target is not a subset of"
+                " features applicable to the leafref itself.", lref->path->expr);
+        return LY_EVALID;
+    }
+
+    return LY_SUCCESS;
+}
+
+static LY_ERR
+lys_compile_ietf_netconf_wd_annotation(struct lysc_ctx *ctx, struct lys_module *mod)
+{
+    struct lysc_ext_instance *ext;
+    struct lysp_ext_instance *ext_p = NULL;
+    struct lysp_stmt *stmt;
+    const struct lys_module *ext_mod;
+    LY_ERR ret = LY_SUCCESS;
+
+    /* create the parsed extension instance manually */
+    ext_p = calloc(1, sizeof *ext_p);
+    LY_CHECK_ERR_GOTO(!ext_p, LOGMEM(ctx->ctx); ret = LY_EMEM, cleanup);
+    LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, "md:annotation", 0, &ext_p->name), cleanup);
+    LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, "default", 0, &ext_p->argument), cleanup);
+    ext_p->insubstmt = LYEXT_SUBSTMT_SELF;
+    ext_p->insubstmt_index = 0;
+
+    ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
+    LY_CHECK_ERR_GOTO(!stmt, LOGMEM(ctx->ctx); ret = LY_EMEM, cleanup);
+    LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, "type", 0, &stmt->stmt), cleanup);
+    LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, "boolean", 0, &stmt->arg), cleanup);
+    stmt->kw = LY_STMT_TYPE;
+
+    /* allocate new extension instance */
+    LY_ARRAY_NEW_GOTO(mod->ctx, mod->compiled->exts, ext, ret, cleanup);
+
+    /* manually get extension definition module */
+    ext_mod = ly_ctx_get_module_latest(ctx->ctx, "ietf-yang-metadata");
+
+    /* compile the extension instance */
+    LY_CHECK_GOTO(ret = lys_compile_ext(ctx, ext_p, ext, mod->compiled, LYEXT_PAR_MODULE, ext_mod), cleanup);
+
+cleanup:
+    lysp_ext_instance_free(ctx->ctx, ext_p);
+    free(ext_p);
+    return ret;
+}
+
+/**
+ * @brief Compile default value(s) for leaf or leaf-list expecting a complete compiled schema tree.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] node Leaf or leaf-list to compile the default value(s) for.
+ * @param[in] type Type of the default value.
+ * @param[in] dflt Default value.
+ * @param[in] dflt_pmod Parsed module of the @p dflt to resolve possible prefixes.
+ * @param[in,out] storage Storage for the compiled default value.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_unres_dflt(struct lysc_ctx *ctx, struct lysc_node *node, struct lysc_type *type, const char *dflt,
+        const struct lysp_module *dflt_pmod, struct lyd_value *storage)
+{
+    LY_ERR ret;
+    struct ly_err_item *err = NULL;
+
+    ret = type->plugin->store(ctx->ctx, type, dflt, strlen(dflt), 0, LY_PREF_SCHEMA, (void *)dflt_pmod,
+            LYD_HINT_SCHEMA, node, storage, &err);
+    if (ret == LY_EINCOMPLETE) {
+        /* we have no data so we will not be resolving it */
+        ret = LY_SUCCESS;
+    }
+
+    if (ret) {
+        ctx->path[0] = '\0';
+        lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
+        if (err) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                    "Invalid default - value does not fit the type (%s).", err->msg);
+            ly_err_free(err);
+        } else {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                    "Invalid default - value does not fit the type.");
+        }
+        return ret;
+    }
+
+    ++((struct lysc_type *)storage->realtype)->refcount;
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Compile default value of a leaf expecting a complete compiled schema tree.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] leaf Leaf that the default value is for.
+ * @param[in] dflt Default value to compile.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_unres_leaf_dlft(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf, struct lysp_qname *dflt)
+{
+    LY_ERR ret;
+
+    assert(!leaf->dflt);
+
+    if (leaf->flags & (LYS_MAND_TRUE | LYS_KEY)) {
+        /* ignore default values for keys and mandatory leaves */
+        return LY_SUCCESS;
+    }
+
+    /* allocate the default value */
+    leaf->dflt = calloc(1, sizeof *leaf->dflt);
+    LY_CHECK_ERR_RET(!leaf->dflt, LOGMEM(ctx->ctx), LY_EMEM);
+
+    /* store the default value */
+    ret = lys_compile_unres_dflt(ctx, (struct lysc_node *)leaf, leaf->type, dflt->str, dflt->mod, leaf->dflt);
+    if (ret) {
+        free(leaf->dflt);
+        leaf->dflt = NULL;
+    }
+
+    return ret;
+}
+
+/**
+ * @brief Compile default values of a leaf-list expecting a complete compiled schema tree.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] llist Leaf-list that the default value(s) are for.
+ * @param[in] dflt Default value to compile, in case of a single value.
+ * @param[in] dflts Sized array of default values, in case of more values.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_unres_llist_dflts(struct lysc_ctx *ctx, struct lysc_node_leaflist *llist, struct lysp_qname *dflt,
+        struct lysp_qname *dflts)
+{
+    LY_ERR ret;
+    LY_ARRAY_COUNT_TYPE orig_count, u, v;
+
+    assert(dflt || dflts);
+
+    if (llist->dflts) {
+        /* there were already some defaults and we are adding new by deviations */
+        assert(dflts);
+        orig_count = LY_ARRAY_COUNT(llist->dflts);
+    } else {
+        orig_count = 0;
+    }
+
+    /* allocate new items */
+    if (dflts) {
+        LY_ARRAY_CREATE_RET(ctx->ctx, llist->dflts, orig_count + LY_ARRAY_COUNT(dflts), LY_EMEM);
+    } else {
+        LY_ARRAY_CREATE_RET(ctx->ctx, llist->dflts, orig_count + 1, LY_EMEM);
+    }
+
+    /* fill each new default value */
+    if (dflts) {
+        LY_ARRAY_FOR(dflts, u) {
+            llist->dflts[orig_count + u] = calloc(1, sizeof **llist->dflts);
+            ret = lys_compile_unres_dflt(ctx, (struct lysc_node *)llist, llist->type, dflts[u].str, dflts[u].mod,
+                    llist->dflts[orig_count + u]);
+            LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count + u]), ret);
+            LY_ARRAY_INCREMENT(llist->dflts);
+        }
+    } else {
+        llist->dflts[orig_count] = calloc(1, sizeof **llist->dflts);
+        ret = lys_compile_unres_dflt(ctx, (struct lysc_node *)llist, llist->type, dflt->str, dflt->mod,
+                llist->dflts[orig_count]);
+        LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count]), ret);
+        LY_ARRAY_INCREMENT(llist->dflts);
+    }
+
+    /* check default value uniqueness */
+    if (llist->flags & LYS_CONFIG_W) {
+        /* configuration data values must be unique - so check the default values */
+        for (u = orig_count; u < LY_ARRAY_COUNT(llist->dflts); ++u) {
+            for (v = 0; v < u; ++v) {
+                if (!llist->dflts[u]->realtype->plugin->compare(llist->dflts[u], llist->dflts[v])) {
+                    lysc_update_path(ctx, llist->parent, llist->name);
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                            "Configuration leaf-list has multiple defaults of the same value \"%s\".",
+                            llist->dflts[u]->canonical);
+                    lysc_update_path(ctx, NULL, NULL);
+                    return LY_EVALID;
+                }
+            }
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Finish compilation of all the unres sets of a compile context.
+ *
+ * @param[in] ctx Compile context with unres sets.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_unres(struct lysc_ctx *ctx)
+{
+    struct lysc_node *node;
+    struct lysc_type *type, *typeiter;
+    struct lysc_type_leafref *lref;
+    struct lysc_augment *aug;
+    struct lysc_deviation *dev;
+    LY_ARRAY_COUNT_TYPE v;
+    uint32_t i;
+
+    /* for leafref, we need 2 rounds - first detects circular chain by storing the first referred type (which
+     * can be also leafref, in case it is already resolved, go through the chain and check that it does not
+     * point to the starting leafref type). The second round stores the first non-leafref type for later data validation. */
+    for (i = 0; i < ctx->leafrefs.count; ++i) {
+        node = ctx->leafrefs.objs[i];
+        assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
+        type = ((struct lysc_node_leaf *)node)->type;
+        if (type->basetype == LY_TYPE_LEAFREF) {
+            LY_CHECK_RET(lys_compile_unres_leafref(ctx, node, (struct lysc_type_leafref *)type));
+        } else if (type->basetype == LY_TYPE_UNION) {
+            LY_ARRAY_FOR(((struct lysc_type_union *)type)->types, v) {
+                if (((struct lysc_type_union *)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
+                    lref = (struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v];
+                    LY_CHECK_RET(lys_compile_unres_leafref(ctx, node, lref));
+                }
+            }
+        }
+    }
+    for (i = 0; i < ctx->leafrefs.count; ++i) {
+        /* store pointer to the real type */
+        type = ((struct lysc_node_leaf *)ctx->leafrefs.objs[i])->type;
+        if (type->basetype == LY_TYPE_LEAFREF) {
+            for (typeiter = ((struct lysc_type_leafref *)type)->realtype;
+                    typeiter->basetype == LY_TYPE_LEAFREF;
+                    typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
+            ((struct lysc_type_leafref *)type)->realtype = typeiter;
+        } else if (type->basetype == LY_TYPE_UNION) {
+            LY_ARRAY_FOR(((struct lysc_type_union *)type)->types, v) {
+                if (((struct lysc_type_union *)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
+                    for (typeiter = ((struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v])->realtype;
+                            typeiter->basetype == LY_TYPE_LEAFREF;
+                            typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
+                    ((struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v])->realtype = typeiter;
+                }
+            }
+        }
+    }
+
+    /* check xpath */
+    for (i = 0; i < ctx->xpath.count; ++i) {
+        LY_CHECK_RET(lys_compile_unres_xpath(ctx, ctx->xpath.objs[i]));
+    }
+
+    /* finish incomplete default values compilation */
+    for (i = 0; i < ctx->dflts.count; ++i) {
+        struct lysc_unres_dflt *r = ctx->dflts.objs[i];
+        if (r->leaf->nodetype == LYS_LEAF) {
+            LY_CHECK_RET(lys_compile_unres_leaf_dlft(ctx, r->leaf, r->dflt));
+        } else {
+            LY_CHECK_RET(lys_compile_unres_llist_dflts(ctx, r->llist, r->dflt, r->dflts));
+        }
+    }
+
+    /* check that all augments were applied */
+    for (i = 0; i < ctx->augs.count; ++i) {
+        aug = ctx->augs.objs[i];
+        LOGVAL(ctx->ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE,
+                "Augment target node \"%s\" from module \"%s\" was not found.", aug->nodeid->expr,
+                LYSP_MODULE_NAME(aug->nodeid_pmod));
+    }
+    if (ctx->augs.count) {
+        return LY_ENOTFOUND;
+    }
+
+    /* check that all deviations were applied */
+    for (i = 0; i < ctx->devs.count; ++i) {
+        dev = ctx->devs.objs[i];
+        LOGVAL(ctx->ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE,
+                "Deviation(s) target node \"%s\" from module \"%s\" was not found.", dev->nodeid->expr,
+                LYSP_MODULE_NAME(dev->dev_pmods[0]));
+    }
+    if (ctx->devs.count) {
+        return LY_ENOTFOUND;
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Compile features in the current module and all its submodules.
+ *
+ * @param[in] ctx Compile context.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_features(struct lysc_ctx *ctx)
+{
+    struct lysp_submodule *submod;
+    LY_ARRAY_COUNT_TYPE u, v;
+
+    if (!ctx->cur_mod->features) {
+        /* features are compiled directly into the module structure,
+         * but it must be done in two steps to allow forward references (via if-feature) between the features themselves */
+        LY_CHECK_RET(lys_feature_precompile(ctx, NULL, NULL, ctx->cur_mod->parsed->features, &ctx->cur_mod->features));
+        LY_ARRAY_FOR(ctx->cur_mod->parsed->includes, v) {
+            submod = ctx->cur_mod->parsed->includes[v].submodule;
+            LY_CHECK_RET(lys_feature_precompile(ctx, NULL, NULL, submod->features, &ctx->cur_mod->features));
+        }
+    }
+
+    /* finish feature compilation, not only for the main module, but also for the submodules.
+     * Due to possible forward references, it must be done when all the features (including submodules)
+     * are present. */
+    LY_ARRAY_FOR(ctx->cur_mod->parsed->features, u) {
+        LY_CHECK_RET(lys_feature_precompile_finish(ctx, &ctx->cur_mod->parsed->features[u], ctx->cur_mod->features));
+    }
+
+    lysc_update_path(ctx, NULL, "{submodule}");
+    LY_ARRAY_FOR(ctx->cur_mod->parsed->includes, v) {
+        submod = ctx->cur_mod->parsed->includes[v].submodule;
+
+        lysc_update_path(ctx, NULL, submod->name);
+        LY_ARRAY_FOR(submod->features, u) {
+            LY_CHECK_RET(lys_feature_precompile_finish(ctx, &submod->features[u], ctx->cur_mod->features));
+        }
+        lysc_update_path(ctx, NULL, NULL);
+    }
+    lysc_update_path(ctx, NULL, NULL);
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Compile identites in the current module and all its submodules.
+ *
+ * @param[in] ctx Compile context.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_identities(struct lysc_ctx *ctx)
+{
+    struct lysp_submodule *submod;
+    LY_ARRAY_COUNT_TYPE u;
+
+    if (!ctx->cur_mod->identities) {
+        LY_CHECK_RET(lys_identity_precompile(ctx, NULL, NULL, ctx->cur_mod->parsed->identities, &ctx->cur_mod->identities));
+        LY_ARRAY_FOR(ctx->cur_mod->parsed->includes, u) {
+            submod = ctx->cur_mod->parsed->includes[u].submodule;
+            LY_CHECK_RET(lys_identity_precompile(ctx, NULL, NULL, submod->identities, &ctx->cur_mod->identities));
+        }
+    }
+
+    if (ctx->cur_mod->parsed->identities) {
+        LY_CHECK_RET(lys_compile_identities_derived(ctx, ctx->cur_mod->parsed->identities, ctx->cur_mod->identities));
+    }
+    lysc_update_path(ctx, NULL, "{submodule}");
+    LY_ARRAY_FOR(ctx->cur_mod->parsed->includes, u) {
+
+        submod = ctx->cur_mod->parsed->includes[u].submodule;
+        if (submod->identities) {
+            lysc_update_path(ctx, NULL, submod->name);
+            LY_CHECK_RET(lys_compile_identities_derived(ctx, submod->identities, ctx->cur_mod->identities));
+            lysc_update_path(ctx, NULL, NULL);
+        }
+    }
+    lysc_update_path(ctx, NULL, NULL);
+
+    return LY_SUCCESS;
+}
+
+LY_ERR
+lys_compile(struct lys_module *mod, uint32_t options)
+{
+    struct lysc_ctx ctx = {0};
+    struct lysc_module *mod_c;
+    struct lysp_module *sp;
+    struct lysp_submodule *submod;
+    struct lysp_node *pnode;
+    struct lysp_grp *grps;
+    LY_ARRAY_COUNT_TYPE u, v;
+    uint32_t i;
+    LY_ERR ret = LY_SUCCESS;
+
+    LY_CHECK_ARG_RET(NULL, mod, mod->parsed, !mod->compiled, mod->ctx, LY_EINVAL);
+
+    if (!mod->implemented) {
+        /* just imported modules are not compiled */
+        return LY_SUCCESS;
+    }
+
+    /* context will be changed */
+    ++mod->ctx->module_set_id;
+
+    sp = mod->parsed;
+
+    ctx.ctx = mod->ctx;
+    ctx.cur_mod = mod;
+    ctx.pmod = sp;
+    ctx.options = options;
+    ctx.path_len = 1;
+    ctx.path[0] = '/';
+
+    mod->compiled = mod_c = calloc(1, sizeof *mod_c);
+    LY_CHECK_ERR_RET(!mod_c, LOGMEM(mod->ctx), LY_EMEM);
+    mod_c->mod = mod;
+
+    /* process imports */
+    LY_ARRAY_FOR(sp->imports, u) {
+        LY_CHECK_GOTO(ret = lys_compile_import(&ctx, &sp->imports[u]), error);
+    }
+
+    /* features */
+    LY_CHECK_GOTO(ret = lys_compile_features(&ctx), error);
+
+    /* identities, work similarly to features with the precompilation */
+    LY_CHECK_GOTO(ret = lys_compile_identities(&ctx), error);
+
+    /* augments and deviations */
+    LY_CHECK_GOTO(ret = lys_precompile_augments_deviations(&ctx), error);
+
+    /* compile augments and deviations of our module from other modules so they can be applied during compilation */
+    LY_CHECK_GOTO(ret = lys_precompile_own_augments(&ctx), error);
+    LY_CHECK_GOTO(ret = lys_precompile_own_deviations(&ctx), error);
+
+    /* data nodes */
+    LY_LIST_FOR(sp->data, pnode) {
+        LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), error);
+    }
+
+    /* top-level RPCs and notifications */
+    COMPILE_OP_ARRAY_GOTO(&ctx, sp->rpcs, mod_c->rpcs, NULL, u, lys_compile_action, 0, ret, error);
+    COMPILE_OP_ARRAY_GOTO(&ctx, sp->notifs, mod_c->notifs, NULL, u, lys_compile_notif, 0, ret, error);
+
+    /* extension instances */
+    COMPILE_EXTS_GOTO(&ctx, sp->exts, mod_c->exts, mod_c, LYEXT_PAR_MODULE, ret, error);
+
+    /* the same for submodules */
+    LY_ARRAY_FOR(sp->includes, u) {
+        submod = sp->includes[u].submodule;
+        ctx.pmod = (struct lysp_module *)submod;
+
+        LY_LIST_FOR(submod->data, pnode) {
+            ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
+            LY_CHECK_GOTO(ret, error);
+        }
+
+        COMPILE_OP_ARRAY_GOTO(&ctx, submod->rpcs, mod_c->rpcs, NULL, v, lys_compile_action, 0, ret, error);
+        COMPILE_OP_ARRAY_GOTO(&ctx, submod->notifs, mod_c->notifs, NULL, v, lys_compile_notif, 0, ret, error);
+
+        COMPILE_EXTS_GOTO(&ctx, submod->exts, mod_c->exts, mod_c, LYEXT_PAR_MODULE, ret, error);
+    }
+
+    /* finish compilation for all unresolved items in the context */
+    LY_CHECK_GOTO(ret = lys_compile_unres(&ctx), error);
+
+    /* validate non-instantiated groupings from the parsed schema,
+     * without it we would accept even the schemas with invalid grouping specification */
+    ctx.pmod = sp;
+    ctx.options |= LYS_COMPILE_GROUPING;
+    LY_ARRAY_FOR(sp->groupings, u) {
+        if (!(sp->groupings[u].flags & LYS_USED_GRP)) {
+            LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, &sp->groupings[u]), error);
+        }
+    }
+    LY_LIST_FOR(sp->data, pnode) {
+        grps = (struct lysp_grp *)lysp_node_groupings(pnode);
+        LY_ARRAY_FOR(grps, u) {
+            if (!(grps[u].flags & LYS_USED_GRP)) {
+                LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, &grps[u]), error);
+            }
+        }
+    }
+    LY_ARRAY_FOR(sp->includes, u) {
+        submod = sp->includes[u].submodule;
+        ctx.pmod = (struct lysp_module *)submod;
+
+        LY_ARRAY_FOR(submod->groupings, u) {
+            if (!(submod->groupings[u].flags & LYS_USED_GRP)) {
+                LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, &submod->groupings[u]), error);
+            }
+        }
+        LY_LIST_FOR(submod->data, pnode) {
+            grps = (struct lysp_grp *)lysp_node_groupings(pnode);
+            LY_ARRAY_FOR(grps, u) {
+                if (!(grps[u].flags & LYS_USED_GRP)) {
+                    LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, &grps[u]), error);
+                }
+            }
+        }
+    }
+    ctx.pmod = sp;
+
+#if 0
+    /* hack for NETCONF's edit-config's operation attribute. It is not defined in the schema, but since libyang
+     * implements YANG metadata (annotations), we need its definition. Because the ietf-netconf schema is not the
+     * internal part of libyang, we cannot add the annotation into the schema source, but we do it here to have
+     * the anotation definitions available in the internal schema structure. */
+    if (ly_strequal(mod->name, "ietf-netconf", 0)) {
+        if (lyp_add_ietf_netconf_annotations(mod)) {
+            lys_free(mod, NULL, 1, 1);
+            return NULL;
+        }
+    }
+#endif
+
+    /* add ietf-netconf-with-defaults "default" metadata to the compiled module */
+    if (!strcmp(mod->name, "ietf-netconf-with-defaults")) {
+        LY_CHECK_GOTO(ret = lys_compile_ietf_netconf_wd_annotation(&ctx, mod), error);
+    }
+
+    /* there can be no leftover deviations */
+    LY_CHECK_ERR_GOTO(ctx.devs.count, LOGINT(ctx.ctx); ret = LY_EINT, error);
+
+    for (i = 0; i < ctx.dflts.count; ++i) {
+        lysc_unres_dflt_free(ctx.ctx, ctx.dflts.objs[i]);
+    }
+    ly_set_erase(&ctx.dflts, NULL);
+    ly_set_erase(&ctx.xpath, NULL);
+    ly_set_erase(&ctx.leafrefs, NULL);
+    ly_set_erase(&ctx.groupings, NULL);
+    ly_set_erase(&ctx.tpdf_chain, NULL);
+    ly_set_erase(&ctx.augs, NULL);
+    ly_set_erase(&ctx.devs, NULL);
+    ly_set_erase(&ctx.uses_augs, NULL);
+    ly_set_erase(&ctx.uses_rfns, NULL);
+
+    return LY_SUCCESS;
+
+error:
+    lys_precompile_augments_deviations_revert(ctx.ctx, mod);
+    lys_feature_precompile_revert(&ctx, mod);
+    for (i = 0; i < ctx.dflts.count; ++i) {
+        lysc_unres_dflt_free(ctx.ctx, ctx.dflts.objs[i]);
+    }
+    ly_set_erase(&ctx.dflts, NULL);
+    ly_set_erase(&ctx.xpath, NULL);
+    ly_set_erase(&ctx.leafrefs, NULL);
+    ly_set_erase(&ctx.groupings, NULL);
+    ly_set_erase(&ctx.tpdf_chain, NULL);
+    for (i = 0; i < ctx.augs.count; ++i) {
+        lysc_augment_free(ctx.ctx, ctx.augs.objs[i]);
+    }
+    ly_set_erase(&ctx.augs, NULL);
+    for (i = 0; i < ctx.devs.count; ++i) {
+        lysc_deviation_free(ctx.ctx, ctx.devs.objs[i]);
+    }
+    ly_set_erase(&ctx.devs, NULL);
+    for (i = 0; i < ctx.uses_augs.count; ++i) {
+        lysc_augment_free(ctx.ctx, ctx.uses_augs.objs[i]);
+    }
+    ly_set_erase(&ctx.uses_augs, NULL);
+    for (i = 0; i < ctx.uses_rfns.count; ++i) {
+        lysc_refine_free(ctx.ctx, ctx.uses_rfns.objs[i]);
+    }
+    ly_set_erase(&ctx.uses_rfns, NULL);
+    lysc_module_free(mod_c, NULL);
+    mod->compiled = NULL;
+
+    return ret;
+}
diff --git a/src/schema_compile.h b/src/schema_compile.h
new file mode 100644
index 0000000..a233116
--- /dev/null
+++ b/src/schema_compile.h
@@ -0,0 +1,253 @@
+/**
+ * @file schema_compile.h
+ * @author Radek Krejci <rkrejci@cesnet.cz>
+ * @brief Header for schema compilation.
+ *
+ * Copyright (c) 2015 - 2020 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
+ */
+
+#ifndef LY_SCHEMA_COMPILE_H_
+#define LY_SCHEMA_COMPILE_H_
+
+#include "log.h"
+#include "schema_compile_node.h"
+#include "set.h"
+#include "tree_schema.h"
+
+/**
+ * @defgroup scflags Schema compile flags
+ *
+ * Flags are currently used only internally - the compilation process does not have a public interface and it is
+ * integrated in the schema parsers. The current options set does not make sense for public used, but it can be a way
+ * to modify behavior of the compilation process in future.
+ *
+ * @{
+ */
+#define LYS_COMPILE_RPC_INPUT  LYS_CONFIG_W       /**< Internal option when compiling schema tree of RPC/action input */
+#define LYS_COMPILE_RPC_OUTPUT LYS_CONFIG_R       /**< Internal option when compiling schema tree of RPC/action output */
+#define LYS_COMPILE_RPC_MASK   LYS_CONFIG_MASK    /**< mask for the internal RPC options */
+#define LYS_COMPILE_NOTIFICATION 0x08             /**< Internal option when compiling schema tree of Notification */
+
+#define LYS_COMPILE_GROUPING   0x10               /** Compiling (validation) of a non-instantiated grouping.
+                                                      In this case not all the restrictions are checked since they can be valid only
+                                                      in the real placement of the grouping. TODO - what specifically is not done */
+/** @} scflags */
+
+/**
+ * @brief internal context for compilation
+ */
+struct lysc_ctx {
+    struct ly_ctx *ctx;
+    struct lys_module *cur_mod; /**< module currently being compiled, used as the current module for unprefixed nodes */
+    struct lysp_module *pmod;   /**< parsed module being processed, used for searching imports to resolve prefixed nodes */
+    struct ly_set groupings;    /**< stack for groupings circular check */
+    struct ly_set xpath;        /**< when/must to check */
+    struct ly_set leafrefs;     /**< to validate leafref's targets */
+    struct ly_set dflts;        /**< set of incomplete default values */
+    struct ly_set tpdf_chain;
+    struct ly_set augs;         /**< set of compiled non-applied top-level augments */
+    struct ly_set devs;         /**< set of compiled non-applied deviations */
+    struct ly_set uses_augs;    /**< set of compiled non-applied uses augments */
+    struct ly_set uses_rfns;    /**< set of compiled non-applied uses refines */
+    uint32_t path_len;
+    uint32_t options;           /**< various @ref scflags. */
+#define LYSC_CTX_BUFSIZE 4078
+    char path[LYSC_CTX_BUFSIZE];
+};
+
+/**
+ * @brief Structure for remembering default values of leaves and leaf-lists. They are resolved at schema compilation
+ * end when the whole schema tree is available.
+ */
+struct lysc_unres_dflt {
+    union {
+        struct lysc_node_leaf *leaf;
+        struct lysc_node_leaflist *llist;
+    };
+    struct lysp_qname *dflt;
+    struct lysp_qname *dflts;           /**< this is a sized array */
+};
+
+/**
+ * @brief Duplicate string into dictionary
+ * @param[in] CTX libyang context of the dictionary.
+ * @param[in] ORIG String to duplicate.
+ * @param[out] DUP Where to store the result.
+ */
+#define DUP_STRING(CTX, ORIG, DUP, RET) if (ORIG) {RET = lydict_insert(CTX, ORIG, 0, &DUP);}
+
+#define DUP_STRING_GOTO(CTX, ORIG, DUP, RET, GOTO) if (ORIG) {LY_CHECK_GOTO(RET = lydict_insert(CTX, ORIG, 0, &DUP), GOTO);}
+
+#define DUP_ARRAY(CTX, ORIG_ARRAY, NEW_ARRAY, DUP_FUNC) \
+    if (ORIG_ARRAY) { \
+        LY_ARRAY_COUNT_TYPE u; \
+        LY_ARRAY_CREATE_RET(CTX, NEW_ARRAY, LY_ARRAY_COUNT(ORIG_ARRAY), LY_EMEM); \
+        LY_ARRAY_FOR(ORIG_ARRAY, u) { \
+            LY_ARRAY_INCREMENT(NEW_ARRAY); \
+            LY_CHECK_RET(DUP_FUNC(CTX, &(NEW_ARRAY)[u], &(ORIG_ARRAY)[u])); \
+        } \
+    }
+
+#define COMPILE_OP_ARRAY_GOTO(CTX, ARRAY_P, ARRAY_C, PARENT, ITER, FUNC, USES_STATUS, RET, GOTO) \
+    if (ARRAY_P) { \
+        LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, LY_ARRAY_COUNT(ARRAY_P), RET, GOTO); \
+        LY_ARRAY_COUNT_TYPE __array_offset = LY_ARRAY_COUNT(ARRAY_C); \
+        for (ITER = 0; ITER < LY_ARRAY_COUNT(ARRAY_P); ++ITER) { \
+            LY_ARRAY_INCREMENT(ARRAY_C); \
+            RET = FUNC(CTX, &(ARRAY_P)[ITER], PARENT, &(ARRAY_C)[ITER + __array_offset], USES_STATUS); \
+            if (RET == LY_EDENIED) { \
+                LY_ARRAY_DECREMENT(ARRAY_C); \
+            } else if (RET != LY_SUCCESS) { \
+                goto GOTO; \
+            } \
+        } \
+    }
+
+#define COMPILE_ARRAY_GOTO(CTX, ARRAY_P, ARRAY_C, ITER, FUNC, RET, GOTO) \
+    if (ARRAY_P) { \
+        LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, LY_ARRAY_COUNT(ARRAY_P), RET, GOTO); \
+        LY_ARRAY_COUNT_TYPE __array_offset = LY_ARRAY_COUNT(ARRAY_C); \
+        for (ITER = 0; ITER < LY_ARRAY_COUNT(ARRAY_P); ++ITER) { \
+            LY_ARRAY_INCREMENT(ARRAY_C); \
+            RET = FUNC(CTX, &(ARRAY_P)[ITER], &(ARRAY_C)[ITER + __array_offset]); \
+            LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
+        } \
+    }
+
+#define COMPILE_EXTS_GOTO(CTX, EXTS_P, EXT_C, PARENT, PARENT_TYPE, RET, GOTO) \
+    if (EXTS_P) { \
+        LY_ARRAY_CREATE_GOTO((CTX)->ctx, EXT_C, LY_ARRAY_COUNT(EXTS_P), RET, GOTO); \
+        for (LY_ARRAY_COUNT_TYPE __exts_iter = 0, __array_offset = LY_ARRAY_COUNT(EXT_C); __exts_iter < LY_ARRAY_COUNT(EXTS_P); ++__exts_iter) { \
+            LY_ARRAY_INCREMENT(EXT_C); \
+            RET = lys_compile_ext(CTX, &(EXTS_P)[__exts_iter], &(EXT_C)[__exts_iter + __array_offset], PARENT, PARENT_TYPE, NULL); \
+            LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
+        } \
+    }
+
+/**
+ * @brief Fill in the prepared compiled extension instance structure according to the parsed extension instance.
+ *
+ * @param[in] ctx Compilation context.
+ * @param[in] ext_p Parsed extension instance.
+ * @param[in,out] ext Prepared compiled extension instance.
+ * @param[in] parent Extension instance parent.
+ * @param[in] parent_type Extension instance parent type.
+ * @param[in] ext_mod Optional module with the extension instance extension definition, set only for internal annotations.
+ * @return LY_ERR value.
+ */
+LY_ERR lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext, void *parent,
+        LYEXT_PARENT parent_type, const struct lys_module *ext_mod);
+
+/**
+ * @brief Compile information from the if-feature statement
+ * @param[in] ctx Compile context.
+ * @param[in] qname The if-feature argument to process. It is pointer-to-qname just to unify the compile functions.
+ * @param[in,out] iff Prepared (empty) compiled if-feature structure to fill.
+ * @return LY_ERR value.
+ */
+LY_ERR lys_compile_iffeature(struct lysc_ctx *ctx, struct lysp_qname *qname, struct lysc_iffeature *iff);
+
+/**
+ * @brief Compile information from the identity statement
+ *
+ * The backlinks to the identities derived from this one are supposed to be filled later via lys_compile_identity_bases().
+ *
+ * @param[in] ctx_sc Compile context - alternative to the combination of @p ctx and @p parsed_mod.
+ * @param[in] ctx libyang context.
+ * @param[in] parsed_mod Module with the identities.
+ * @param[in] identities_p Array of the parsed identity definitions to precompile.
+ * @param[in,out] identities Pointer to the storage of the (pre)compiled identities array where the new identities are
+ * supposed to be added. The storage is supposed to be initiated to NULL when the first parsed identities are going
+ * to be processed.
+ * @return LY_ERR value.
+ */
+LY_ERR lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
+        struct lysp_ident *identities_p, struct lysc_ident **identities);
+
+/**
+ * @brief Find and process the referenced base identities from another identity or identityref
+ *
+ * For bases in identity set backlinks to them from the base identities. For identityref, store
+ * the array of pointers to the base identities. So one of the ident or bases parameter must be set
+ * to distinguish these two use cases.
+ *
+ * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
+ * @param[in] base_pmod Module where to resolve @p bases_p prefixes.
+ * @param[in] bases_p Array of names (including prefix if necessary) of base identities.
+ * @param[in] ident Referencing identity to work with, NULL for identityref.
+ * @param[in] bases Array of bases of identityref to fill in.
+ * @return LY_ERR value.
+ */
+LY_ERR lys_compile_identity_bases(struct lysc_ctx *ctx, const struct lysp_module *base_pmod, const char **bases_p,
+        struct lysc_ident *ident, struct lysc_ident ***bases);
+
+/**
+ * @brief Create pre-compiled features array.
+ *
+ * Features are compiled in two steps to allow forward references between them via their if-feature statements.
+ * In case of not implemented schemas, the precompiled list of features is stored in lys_module structure and
+ * the compilation is not finished (if-feature and extensions are missing) and all the features are permanently
+ * disabled without a chance to change it. The list is used as target for any if-feature statement in any
+ * implemented module to get valid data to evaluate its result. The compilation is finished via
+ * lys_feature_precompile_finish() in implemented modules. In case a not implemented module becomes implemented,
+ * the precompiled list is reused to finish the compilation to preserve pointers already used in various compiled
+ * if-feature structures.
+ *
+ * @param[in] ctx_sc Compile context - alternative to the combination of @p ctx and @p parsed_mod.
+ * @param[in] ctx libyang context.
+ * @param[in] parsed_mod Module with the features.
+ * @param[in] features_p Array of the parsed features definitions to precompile.
+ * @param[in,out] features Pointer to the storage of the (pre)compiled features array where the new features are
+ * supposed to be added. The storage is supposed to be initiated to NULL when the first parsed features are going
+ * to be processed.
+ * @return LY_ERR value.
+ */
+LY_ERR lys_feature_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
+        struct lysp_feature *features_p, struct lysc_feature **features);
+
+/**
+ * @brief Revert compiled list of features back to the precompiled state.
+ *
+ * Function is needed in case the compilation failed and the schema is expected to revert back to the non-compiled status.
+ *
+ * @param[in] ctx Compilation context.
+ * @param[in] mod The module structure with the features to decompile.
+ */
+void lys_feature_precompile_revert(struct lysc_ctx *ctx, struct lys_module *mod);
+
+/**
+ * @brief Check statement's status for invalid combination.
+ *
+ * The modX parameters are used just to determine if both flags are in the same module,
+ * so any of the schema module structure can be used, but both modules must be provided
+ * in the same type.
+ *
+ * @param[in] ctx Compile context for logging.
+ * @param[in] flags1 Flags of the referencing node.
+ * @param[in] mod1 Module of the referencing node,
+ * @param[in] name1 Schema node name of the referencing node.
+ * @param[in] flags2 Flags of the referenced node.
+ * @param[in] mod2 Module of the referenced node,
+ * @param[in] name2 Schema node name of the referenced node.
+ * @return LY_ERR value
+ */
+LY_ERR lysc_check_status(struct lysc_ctx *ctx, uint16_t flags1, void *mod1, const char *name1, uint16_t flags2,
+        void *mod2, const char *name2);
+
+/**
+ * @brief Compile printable schema into a validated schema linking all the references.
+ *
+ * @param[in] mod Pointer to the schema structure holding pointers to both schema structure types. The ::lys_module#parsed
+ * member is used as input and ::lys_module#compiled is used to hold the result of the compilation.
+ * @param[in] options Various options to modify compiler behavior, see [compile flags](@ref scflags).
+ * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
+ */
+LY_ERR lys_compile(struct lys_module *mod, uint32_t options);
+
+#endif /* LY_SCHEMA_COMPILE_H_ */
diff --git a/src/schema_compile_amend.c b/src/schema_compile_amend.c
new file mode 100644
index 0000000..904e8be
--- /dev/null
+++ b/src/schema_compile_amend.c
@@ -0,0 +1,2430 @@
+/**
+ * @file schema_compile_amend.c
+ * @author Radek Krejci <rkrejci@cesnet.cz>
+ * @brief Schema compilation of augments, deviations, and refines.
+ *
+ * Copyright (c) 2015 - 2020 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
+ */
+
+#define _GNU_SOURCE
+
+#include "schema_compile_amend.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+#include "compat.h"
+#include "context.h"
+#include "dict.h"
+#include "log.h"
+#include "parser.h"
+#include "parser_schema.h"
+#include "path.h"
+#include "plugins_exts.h"
+#include "plugins_exts_internal.h"
+#include "plugins_types.h"
+#include "schema_compile.h"
+#include "schema_compile_node.h"
+#include "set.h"
+#include "tree.h"
+#include "tree_data.h"
+#include "tree_data_internal.h"
+#include "tree_schema.h"
+#include "tree_schema_internal.h"
+#include "xpath.h"
+
+static const struct lys_module *lys_schema_node_get_module(const struct ly_ctx *ctx, const char *nametest,
+        size_t nametest_len, const struct lysp_module *mod, const char **name, size_t *name_len);
+
+static LY_ERR
+lys_nodeid_check(struct lysc_ctx *ctx, const char *nodeid, ly_bool abs, struct lys_module **target_mod,
+        struct lyxp_expr **expr)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lyxp_expr *e = NULL;
+    struct lys_module *tmod = NULL, *mod;
+    const char *nodeid_type = abs ? "absolute-schema-nodeid" : "descendant-schema-nodeid";
+    uint32_t i;
+
+    /* parse */
+    ret = lyxp_expr_parse(ctx->ctx, nodeid, strlen(nodeid), 0, &e);
+    if (ret) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid %s value \"%s\" - invalid syntax.",
+                nodeid_type, nodeid);
+        ret = LY_EVALID;
+        goto cleanup;
+    }
+
+    if (abs) {
+        /* absolute schema nodeid */
+        i = 0;
+    } else {
+        /* descendant schema nodeid */
+        if (e->tokens[0] != LYXP_TOKEN_NAMETEST) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Invalid %s value \"%s\" - name test expected instead of \"%.*s\".",
+                    nodeid_type, nodeid, e->tok_len[0], e->expr + e->tok_pos[0]);
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+        i = 1;
+    }
+
+    /* check all the tokens */
+    for ( ; i < e->used; i += 2) {
+        if (e->tokens[i] != LYXP_TOKEN_OPER_PATH) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Invalid %s value \"%s\" - \"/\" expected instead of \"%.*s\".",
+                    nodeid_type, nodeid, e->tok_len[i], e->expr + e->tok_pos[i]);
+            ret = LY_EVALID;
+            goto cleanup;
+        } else if (e->used == i + 1) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid %s value \"%s\" - unexpected end of expression.", nodeid_type, e->expr);
+            ret = LY_EVALID;
+            goto cleanup;
+        } else if (e->tokens[i + 1] != LYXP_TOKEN_NAMETEST) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Invalid %s value \"%s\" - name test expected instead of \"%.*s\".",
+                    nodeid_type, nodeid, e->tok_len[i + 1], e->expr + e->tok_pos[i + 1]);
+            ret = LY_EVALID;
+            goto cleanup;
+        } else if (abs) {
+            mod = (struct lys_module *)lys_schema_node_get_module(ctx->ctx, e->expr + e->tok_pos[i + 1],
+                    e->tok_len[i + 1], ctx->pmod, NULL, NULL);
+            LY_CHECK_ERR_GOTO(!mod, ret = LY_EVALID, cleanup);
+
+            /* only keep the first module */
+            if (!tmod) {
+                tmod = mod;
+            }
+
+            /* all the modules must be implemented */
+            if (!mod->implemented) {
+                ret = lys_set_implemented(mod);
+                LY_CHECK_GOTO(ret, cleanup);
+            }
+        }
+    }
+
+cleanup:
+    if (ret || !expr) {
+        lyxp_expr_free(ctx->ctx, e);
+        e = NULL;
+    }
+    if (expr) {
+        *expr = ret ? NULL : e;
+    }
+    if (target_mod) {
+        *target_mod = ret ? NULL : tmod;
+    }
+    return ret;
+}
+
+/**
+ * @brief Check whether 2 schema nodeids match.
+ *
+ * @param[in] ctx libyang context.
+ * @param[in] exp1 First schema nodeid.
+ * @param[in] exp1p_mod Module of @p exp1 nodes without any prefix.
+ * @param[in] exp2 Second schema nodeid.
+ * @param[in] exp2_pmod Module of @p exp2 nodes without any prefix.
+ * @return Whether the schema nodeids match or not.
+ */
+static ly_bool
+lys_abs_schema_nodeid_match(const struct ly_ctx *ctx, const struct lyxp_expr *exp1, const struct lysp_module *exp1_pmod,
+        const struct lyxp_expr *exp2, const struct lysp_module *exp2_pmod)
+{
+    uint32_t i;
+    const struct lys_module *mod1, *mod2;
+    const char *name1, *name2;
+    size_t name1_len, name2_len;
+
+    if (exp1->used != exp2->used) {
+        return 0;
+    }
+
+    for (i = 0; i < exp1->used; ++i) {
+        assert(exp1->tokens[i] == exp2->tokens[i]);
+
+        if (exp1->tokens[i] == LYXP_TOKEN_NAMETEST) {
+            /* check modules of all the nodes in the node ID */
+            mod1 = lys_schema_node_get_module(ctx, exp1->expr + exp1->tok_pos[i], exp1->tok_len[i], exp1_pmod,
+                    &name1, &name1_len);
+            assert(mod1);
+            mod2 = lys_schema_node_get_module(ctx, exp2->expr + exp2->tok_pos[i], exp2->tok_len[i], exp2_pmod,
+                    &name2, &name2_len);
+            assert(mod2);
+
+            /* compare modules */
+            if (mod1 != mod2) {
+                return 0;
+            }
+
+            /* compare names */
+            if ((name1_len != name2_len) || strncmp(name1, name2, name1_len)) {
+                return 0;
+            }
+        }
+    }
+
+    return 1;
+}
+
+LY_ERR
+lys_precompile_uses_augments_refines(struct lysc_ctx *ctx, struct lysp_node_uses *uses_p, const struct lysc_node *ctx_node)
+{
+    LY_ERR ret = LY_SUCCESS;
+    LY_ARRAY_COUNT_TYPE u;
+    struct lyxp_expr *exp = NULL;
+    struct lysc_augment *aug;
+    struct lysc_refine *rfn;
+    struct lysp_refine **new_rfn;
+    uint32_t i;
+
+    LY_ARRAY_FOR(uses_p->augments, u) {
+        lysc_update_path(ctx, NULL, "{augment}");
+        lysc_update_path(ctx, NULL, uses_p->augments[u].nodeid);
+
+        /* parse the nodeid */
+        LY_CHECK_GOTO(ret = lys_nodeid_check(ctx, uses_p->augments[u].nodeid, 0, NULL, &exp), cleanup);
+
+        /* allocate new compiled augment and store it in the set */
+        aug = calloc(1, sizeof *aug);
+        LY_CHECK_ERR_GOTO(!aug, LOGMEM(ctx->ctx); ret = LY_EMEM, cleanup);
+        LY_CHECK_GOTO(ret = ly_set_add(&ctx->uses_augs, aug, 1, NULL), cleanup);
+
+        aug->nodeid = exp;
+        exp = NULL;
+        aug->nodeid_pmod = ctx->pmod;
+        aug->nodeid_ctx_node = ctx_node;
+        aug->aug_p = &uses_p->augments[u];
+
+        lysc_update_path(ctx, NULL, NULL);
+        lysc_update_path(ctx, NULL, NULL);
+    }
+
+    LY_ARRAY_FOR(uses_p->refines, u) {
+        lysc_update_path(ctx, NULL, "{refine}");
+        lysc_update_path(ctx, NULL, uses_p->refines[u].nodeid);
+
+        /* parse the nodeid */
+        LY_CHECK_GOTO(ret = lys_nodeid_check(ctx, uses_p->refines[u].nodeid, 0, NULL, &exp), cleanup);
+
+        /* try to find the node in already compiled refines */
+        rfn = NULL;
+        for (i = 0; i < ctx->uses_rfns.count; ++i) {
+            if (lys_abs_schema_nodeid_match(ctx->ctx, exp, ctx->pmod, ((struct lysc_refine *)ctx->uses_rfns.objs[i])->nodeid,
+                    ctx->pmod)) {
+                rfn = ctx->uses_rfns.objs[i];
+                break;
+            }
+        }
+
+        if (!rfn) {
+            /* allocate new compiled refine */
+            rfn = calloc(1, sizeof *rfn);
+            LY_CHECK_ERR_GOTO(!rfn, LOGMEM(ctx->ctx); ret = LY_EMEM, cleanup);
+            LY_CHECK_GOTO(ret = ly_set_add(&ctx->uses_rfns, rfn, 1, NULL), cleanup);
+
+            rfn->nodeid = exp;
+            exp = NULL;
+            rfn->nodeid_pmod = ctx->pmod;
+            rfn->nodeid_ctx_node = ctx_node;
+        } else {
+            /* just free exp */
+            lyxp_expr_free(ctx->ctx, exp);
+            exp = NULL;
+        }
+
+        /* add new parsed refine structure */
+        LY_ARRAY_NEW_GOTO(ctx->ctx, rfn->rfns, new_rfn, ret, cleanup);
+        *new_rfn = &uses_p->refines[u];
+
+        lysc_update_path(ctx, NULL, NULL);
+        lysc_update_path(ctx, NULL, NULL);
+    }
+
+cleanup:
+    lyxp_expr_free(ctx->ctx, exp);
+    return ret;
+}
+
+static LY_ERR
+lysp_ext_dup(const struct ly_ctx *ctx, struct lysp_ext_instance *ext, const struct lysp_ext_instance *orig_ext)
+{
+    LY_ERR ret = LY_SUCCESS;
+
+    *ext = *orig_ext;
+    DUP_STRING(ctx, orig_ext->name, ext->name, ret);
+    DUP_STRING(ctx, orig_ext->argument, ext->argument, ret);
+
+    return ret;
+}
+
+static LY_ERR
+lysp_restr_dup(const struct ly_ctx *ctx, struct lysp_restr *restr, const struct lysp_restr *orig_restr)
+{
+    LY_ERR ret = LY_SUCCESS;
+
+    if (orig_restr) {
+        DUP_STRING(ctx, orig_restr->arg.str, restr->arg.str, ret);
+        restr->arg.mod = orig_restr->arg.mod;
+        DUP_STRING(ctx, orig_restr->emsg, restr->emsg, ret);
+        DUP_STRING(ctx, orig_restr->eapptag, restr->eapptag, ret);
+        DUP_STRING(ctx, orig_restr->dsc, restr->dsc, ret);
+        DUP_STRING(ctx, orig_restr->ref, restr->ref, ret);
+        DUP_ARRAY(ctx, orig_restr->exts, restr->exts, lysp_ext_dup);
+    }
+
+    return ret;
+}
+
+static LY_ERR
+lysp_string_dup(const struct ly_ctx *ctx, const char **str, const char **orig_str)
+{
+    LY_ERR ret = LY_SUCCESS;
+
+    DUP_STRING(ctx, *orig_str, *str, ret);
+
+    return ret;
+}
+
+LY_ERR
+lysp_qname_dup(const struct ly_ctx *ctx, struct lysp_qname *qname, const struct lysp_qname *orig_qname)
+{
+    LY_ERR ret = LY_SUCCESS;
+
+    if (!orig_qname->str) {
+        return LY_SUCCESS;
+    }
+
+    DUP_STRING(ctx, orig_qname->str, qname->str, ret);
+    assert(orig_qname->mod);
+    qname->mod = orig_qname->mod;
+
+    return ret;
+}
+
+static LY_ERR
+lysp_type_enum_dup(const struct ly_ctx *ctx, struct lysp_type_enum *enm, const struct lysp_type_enum *orig_enm)
+{
+    LY_ERR ret = LY_SUCCESS;
+
+    DUP_STRING(ctx, orig_enm->name, enm->name, ret);
+    DUP_STRING(ctx, orig_enm->dsc, enm->dsc, ret);
+    DUP_STRING(ctx, orig_enm->ref, enm->ref, ret);
+    enm->value = orig_enm->value;
+    DUP_ARRAY(ctx, orig_enm->iffeatures, enm->iffeatures, lysp_qname_dup);
+    DUP_ARRAY(ctx, orig_enm->exts, enm->exts, lysp_ext_dup);
+    enm->flags = orig_enm->flags;
+
+    return ret;
+}
+
+static LY_ERR
+lysp_type_dup(const struct ly_ctx *ctx, struct lysp_type *type, const struct lysp_type *orig_type)
+{
+    LY_ERR ret = LY_SUCCESS;
+
+    DUP_STRING_GOTO(ctx, orig_type->name, type->name, ret, done);
+
+    if (orig_type->range) {
+        type->range = calloc(1, sizeof *type->range);
+        LY_CHECK_ERR_RET(!type->range, LOGMEM(ctx), LY_EMEM);
+        LY_CHECK_RET(lysp_restr_dup(ctx, type->range, orig_type->range));
+    }
+
+    if (orig_type->length) {
+        type->length = calloc(1, sizeof *type->length);
+        LY_CHECK_ERR_RET(!type->length, LOGMEM(ctx), LY_EMEM);
+        LY_CHECK_RET(lysp_restr_dup(ctx, type->length, orig_type->length));
+    }
+
+    DUP_ARRAY(ctx, orig_type->patterns, type->patterns, lysp_restr_dup);
+    DUP_ARRAY(ctx, orig_type->enums, type->enums, lysp_type_enum_dup);
+    DUP_ARRAY(ctx, orig_type->bits, type->bits, lysp_type_enum_dup);
+    LY_CHECK_GOTO(ret = lyxp_expr_dup(ctx, orig_type->path, &type->path), done);
+    DUP_ARRAY(ctx, orig_type->bases, type->bases, lysp_string_dup);
+    DUP_ARRAY(ctx, orig_type->types, type->types, lysp_type_dup);
+    DUP_ARRAY(ctx, orig_type->exts, type->exts, lysp_ext_dup);
+
+    type->pmod = orig_type->pmod;
+    type->compiled = orig_type->compiled;
+
+    type->fraction_digits = orig_type->fraction_digits;
+    type->require_instance = orig_type->require_instance;
+    type->flags = orig_type->flags;
+
+done:
+    return ret;
+}
+
+static LY_ERR
+lysp_when_dup(const struct ly_ctx *ctx, struct lysp_when *when, const struct lysp_when *orig_when)
+{
+    LY_ERR ret = LY_SUCCESS;
+
+    DUP_STRING(ctx, orig_when->cond, when->cond, ret);
+    DUP_STRING(ctx, orig_when->dsc, when->dsc, ret);
+    DUP_STRING(ctx, orig_when->ref, when->ref, ret);
+    DUP_ARRAY(ctx, orig_when->exts, when->exts, lysp_ext_dup);
+
+    return ret;
+}
+
+static LY_ERR
+lysp_node_common_dup(const struct ly_ctx *ctx, struct lysp_node *node, const struct lysp_node *orig)
+{
+    LY_ERR ret = LY_SUCCESS;
+
+    node->parent = NULL;
+    node->nodetype = orig->nodetype;
+    node->flags = orig->flags;
+    node->next = NULL;
+    DUP_STRING(ctx, orig->name, node->name, ret);
+    DUP_STRING(ctx, orig->dsc, node->dsc, ret);
+    DUP_STRING(ctx, orig->ref, node->ref, ret);
+
+    if (orig->when) {
+        node->when = calloc(1, sizeof *node->when);
+        LY_CHECK_ERR_RET(!node->when, LOGMEM(ctx), LY_EMEM);
+        LY_CHECK_RET(lysp_when_dup(ctx, node->when, orig->when));
+    }
+
+    DUP_ARRAY(ctx, orig->iffeatures, node->iffeatures, lysp_qname_dup);
+    DUP_ARRAY(ctx, orig->exts, node->exts, lysp_ext_dup);
+
+    return ret;
+}
+
+static LY_ERR
+lysp_node_dup(const struct ly_ctx *ctx, struct lysp_node *node, const struct lysp_node *orig)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lysp_node_container *cont;
+    const struct lysp_node_container *orig_cont;
+    struct lysp_node_leaf *leaf;
+    const struct lysp_node_leaf *orig_leaf;
+    struct lysp_node_leaflist *llist;
+    const struct lysp_node_leaflist *orig_llist;
+    struct lysp_node_list *list;
+    const struct lysp_node_list *orig_list;
+    struct lysp_node_choice *choice;
+    const struct lysp_node_choice *orig_choice;
+    struct lysp_node_case *cas;
+    const struct lysp_node_case *orig_cas;
+    struct lysp_node_anydata *any;
+    const struct lysp_node_anydata *orig_any;
+
+    assert(orig->nodetype & (LYS_CONTAINER | LYS_LEAF | LYS_LEAFLIST | LYS_LIST | LYS_CHOICE | LYS_CASE | LYS_ANYDATA));
+
+    /* common part */
+    LY_CHECK_RET(lysp_node_common_dup(ctx, node, orig));
+
+    /* specific part */
+    switch (node->nodetype) {
+    case LYS_CONTAINER:
+        cont = (struct lysp_node_container *)node;
+        orig_cont = (const struct lysp_node_container *)orig;
+
+        DUP_ARRAY(ctx, orig_cont->musts, cont->musts, lysp_restr_dup);
+        DUP_STRING(ctx, orig_cont->presence, cont->presence, ret);
+        /* we do not need the rest */
+        break;
+    case LYS_LEAF:
+        leaf = (struct lysp_node_leaf *)node;
+        orig_leaf = (const struct lysp_node_leaf *)orig;
+
+        DUP_ARRAY(ctx, orig_leaf->musts, leaf->musts, lysp_restr_dup);
+        LY_CHECK_RET(lysp_type_dup(ctx, &leaf->type, &orig_leaf->type));
+        DUP_STRING(ctx, orig_leaf->units, leaf->units, ret);
+        LY_CHECK_RET(lysp_qname_dup(ctx, &leaf->dflt, &orig_leaf->dflt));
+        break;
+    case LYS_LEAFLIST:
+        llist = (struct lysp_node_leaflist *)node;
+        orig_llist = (const struct lysp_node_leaflist *)orig;
+
+        DUP_ARRAY(ctx, orig_llist->musts, llist->musts, lysp_restr_dup);
+        LY_CHECK_RET(lysp_type_dup(ctx, &llist->type, &orig_llist->type));
+        DUP_STRING(ctx, orig_llist->units, llist->units, ret);
+        DUP_ARRAY(ctx, orig_llist->dflts, llist->dflts, lysp_qname_dup);
+        llist->min = orig_llist->min;
+        llist->max = orig_llist->max;
+        break;
+    case LYS_LIST:
+        list = (struct lysp_node_list *)node;
+        orig_list = (const struct lysp_node_list *)orig;
+
+        DUP_ARRAY(ctx, orig_list->musts, list->musts, lysp_restr_dup);
+        DUP_STRING(ctx, orig_list->key, list->key, ret);
+        /* we do not need these arrays */
+        DUP_ARRAY(ctx, orig_list->uniques, list->uniques, lysp_qname_dup);
+        list->min = orig_list->min;
+        list->max = orig_list->max;
+        break;
+    case LYS_CHOICE:
+        choice = (struct lysp_node_choice *)node;
+        orig_choice = (const struct lysp_node_choice *)orig;
+
+        /* we do not need children */
+        LY_CHECK_RET(lysp_qname_dup(ctx, &choice->dflt, &orig_choice->dflt));
+        break;
+    case LYS_CASE:
+        cas = (struct lysp_node_case *)node;
+        orig_cas = (const struct lysp_node_case *)orig;
+
+        /* we do not need children */
+        (void)cas;
+        (void)orig_cas;
+        break;
+    case LYS_ANYDATA:
+    case LYS_ANYXML:
+        any = (struct lysp_node_anydata *)node;
+        orig_any = (const struct lysp_node_anydata *)orig;
+
+        DUP_ARRAY(ctx, orig_any->musts, any->musts, lysp_restr_dup);
+        break;
+    default:
+        LOGINT_RET(ctx);
+    }
+
+    return ret;
+}
+
+static LY_ERR
+lysp_action_inout_dup(const struct ly_ctx *ctx, struct lysp_action_inout *inout, const struct lysp_action_inout *orig)
+{
+    inout->parent = NULL;
+    inout->nodetype = orig->nodetype;
+    DUP_ARRAY(ctx, orig->musts, inout->musts, lysp_restr_dup);
+    /* we dot need these arrays */
+    DUP_ARRAY(ctx, orig->exts, inout->exts, lysp_ext_dup);
+
+    return LY_SUCCESS;
+}
+
+static LY_ERR
+lysp_action_dup(const struct ly_ctx *ctx, struct lysp_action *act, const struct lysp_action *orig)
+{
+    LY_ERR ret = LY_SUCCESS;
+
+    act->parent = NULL;
+    act->nodetype = orig->nodetype;
+    act->flags = orig->flags;
+    DUP_STRING(ctx, orig->name, act->name, ret);
+    DUP_STRING(ctx, orig->dsc, act->dsc, ret);
+    DUP_STRING(ctx, orig->ref, act->ref, ret);
+    DUP_ARRAY(ctx, orig->iffeatures, act->iffeatures, lysp_qname_dup);
+
+    act->input.nodetype = orig->input.nodetype;
+    act->output.nodetype = orig->output.nodetype;
+    /* we do not need choldren of in/out */
+    DUP_ARRAY(ctx, orig->exts, act->exts, lysp_ext_dup);
+
+    return ret;
+}
+
+static LY_ERR
+lysp_notif_dup(const struct ly_ctx *ctx, struct lysp_notif *notif, const struct lysp_notif *orig)
+{
+    LY_ERR ret = LY_SUCCESS;
+
+    notif->parent = NULL;
+    notif->nodetype = orig->nodetype;
+    notif->flags = orig->flags;
+    DUP_STRING(ctx, orig->name, notif->name, ret);
+    DUP_STRING(ctx, orig->dsc, notif->dsc, ret);
+    DUP_STRING(ctx, orig->ref, notif->ref, ret);
+    DUP_ARRAY(ctx, orig->iffeatures, notif->iffeatures, lysp_qname_dup);
+    DUP_ARRAY(ctx, orig->musts, notif->musts, lysp_restr_dup);
+    /* we do not need these arrays */
+    DUP_ARRAY(ctx, orig->exts, notif->exts, lysp_ext_dup);
+
+    return ret;
+}
+
+/**
+ * @brief Duplicate a single parsed node. Only attributes that are used in compilation are copied.
+ *
+ * @param[in] ctx libyang context.
+ * @param[in] pnode Node to duplicate.
+ * @param[in] with_links Whether to also copy any links (child, parent pointers).
+ * @param[out] dup_p Duplicated parsed node.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lysp_dup_single(const struct ly_ctx *ctx, const struct lysp_node *pnode, ly_bool with_links, struct lysp_node **dup_p)
+{
+    LY_ERR ret = LY_SUCCESS;
+    void *mem = NULL;
+
+    if (!pnode) {
+        *dup_p = NULL;
+        return LY_SUCCESS;
+    }
+
+    switch (pnode->nodetype) {
+    case LYS_CONTAINER:
+        mem = calloc(1, sizeof(struct lysp_node_container));
+        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+        LY_CHECK_GOTO(ret = lysp_node_dup(ctx, mem, pnode), cleanup);
+        break;
+    case LYS_LEAF:
+        mem = calloc(1, sizeof(struct lysp_node_leaf));
+        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+        LY_CHECK_GOTO(ret = lysp_node_dup(ctx, mem, pnode), cleanup);
+        break;
+    case LYS_LEAFLIST:
+        mem = calloc(1, sizeof(struct lysp_node_leaflist));
+        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+        LY_CHECK_GOTO(ret = lysp_node_dup(ctx, mem, pnode), cleanup);
+        break;
+    case LYS_LIST:
+        mem = calloc(1, sizeof(struct lysp_node_list));
+        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+        LY_CHECK_GOTO(ret = lysp_node_dup(ctx, mem, pnode), cleanup);
+        break;
+    case LYS_CHOICE:
+        mem = calloc(1, sizeof(struct lysp_node_choice));
+        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+        LY_CHECK_GOTO(ret = lysp_node_dup(ctx, mem, pnode), cleanup);
+        break;
+    case LYS_CASE:
+        mem = calloc(1, sizeof(struct lysp_node_case));
+        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+        LY_CHECK_GOTO(ret = lysp_node_dup(ctx, mem, pnode), cleanup);
+        break;
+    case LYS_ANYDATA:
+    case LYS_ANYXML:
+        mem = calloc(1, sizeof(struct lysp_node_anydata));
+        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+        LY_CHECK_GOTO(ret = lysp_node_dup(ctx, mem, pnode), cleanup);
+        break;
+    case LYS_INPUT:
+    case LYS_OUTPUT:
+        mem = calloc(1, sizeof(struct lysp_action_inout));
+        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+        LY_CHECK_GOTO(ret = lysp_action_inout_dup(ctx, mem, (struct lysp_action_inout *)pnode), cleanup);
+        break;
+    case LYS_ACTION:
+    case LYS_RPC:
+        mem = calloc(1, sizeof(struct lysp_action));
+        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+        LY_CHECK_GOTO(ret = lysp_action_dup(ctx, mem, (struct lysp_action *)pnode), cleanup);
+        break;
+    case LYS_NOTIF:
+        mem = calloc(1, sizeof(struct lysp_notif));
+        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+        LY_CHECK_GOTO(ret = lysp_notif_dup(ctx, mem, (struct lysp_notif *)pnode), cleanup);
+        break;
+    default:
+        LOGINT_RET(ctx);
+    }
+
+    if (with_links) {
+        /* copy also parent and child pointers */
+        ((struct lysp_node *)mem)->parent = pnode->parent;
+        switch (pnode->nodetype) {
+        case LYS_CONTAINER:
+            ((struct lysp_node_container *)mem)->child = ((struct lysp_node_container *)pnode)->child;
+            break;
+        case LYS_LIST:
+            ((struct lysp_node_list *)mem)->child = ((struct lysp_node_list *)pnode)->child;
+            break;
+        case LYS_CHOICE:
+            ((struct lysp_node_choice *)mem)->child = ((struct lysp_node_choice *)pnode)->child;
+            break;
+        case LYS_CASE:
+            ((struct lysp_node_case *)mem)->child = ((struct lysp_node_case *)pnode)->child;
+            break;
+        default:
+            break;
+        }
+    }
+
+cleanup:
+    if (ret) {
+        free(mem);
+    } else {
+        *dup_p = mem;
+    }
+    return ret;
+}
+
+#define AMEND_WRONG_NODETYPE(AMEND_STR, OP_STR, PROPERTY) \
+    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Invalid %s of %s node - it is not possible to %s \"%s\" property.", \
+            AMEND_STR, lys_nodetype2str(target->nodetype), OP_STR, PROPERTY);\
+    ret = LY_EVALID; \
+    goto cleanup;
+
+#define AMEND_CHECK_CARDINALITY(ARRAY, MAX, AMEND_STR, PROPERTY) \
+    if (LY_ARRAY_COUNT(ARRAY) > MAX) { \
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Invalid %s of %s with too many (%"LY_PRI_ARRAY_COUNT_TYPE") %s properties.", \
+               AMEND_STR, lys_nodetype2str(target->nodetype), LY_ARRAY_COUNT(ARRAY), PROPERTY); \
+        ret = LY_EVALID; \
+        goto cleanup; \
+    }
+
+/**
+ * @brief Apply refine.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] rfn Refine to apply.
+ * @param[in,out] target Refine target.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_apply_refine(struct lysc_ctx *ctx, struct lysp_refine *rfn, struct lysp_node *target)
+{
+    LY_ERR ret = LY_SUCCESS;
+    LY_ARRAY_COUNT_TYPE u;
+    struct lysp_qname *qname;
+    struct lysp_restr **musts, *must;
+    uint32_t *num;
+
+    /* default value */
+    if (rfn->dflts) {
+        switch (target->nodetype) {
+        case LYS_LEAF:
+            AMEND_CHECK_CARDINALITY(rfn->dflts, 1, "refine", "default");
+
+            FREE_STRING(ctx->ctx, ((struct lysp_node_leaf *)target)->dflt.str);
+            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, &((struct lysp_node_leaf *)target)->dflt, &rfn->dflts[0]), cleanup);
+            break;
+        case LYS_LEAFLIST:
+            if (rfn->dflts[0].mod->version < LYS_VERSION_1_1) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                        "Invalid refine of default in leaf-list - the default statement is allowed only in YANG 1.1 modules.");
+                ret = LY_EVALID;
+                goto cleanup;
+            }
+
+            FREE_ARRAY(ctx->ctx, ((struct lysp_node_leaflist *)target)->dflts, lysp_qname_free);
+            ((struct lysp_node_leaflist *)target)->dflts = NULL;
+            LY_ARRAY_FOR(rfn->dflts, u) {
+                LY_ARRAY_NEW_GOTO(ctx->ctx, ((struct lysp_node_leaflist *)target)->dflts, qname, ret, cleanup);
+                LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, qname, &rfn->dflts[u]), cleanup);
+            }
+            break;
+        case LYS_CHOICE:
+            AMEND_CHECK_CARDINALITY(rfn->dflts, 1, "refine", "default");
+
+            FREE_STRING(ctx->ctx, ((struct lysp_node_choice *)target)->dflt.str);
+            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, &((struct lysp_node_choice *)target)->dflt, &rfn->dflts[0]), cleanup);
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("refine", "replace", "default");
+        }
+    }
+
+    /* description */
+    if (rfn->dsc) {
+        FREE_STRING(ctx->ctx, target->dsc);
+        DUP_STRING_GOTO(ctx->ctx, rfn->dsc, target->dsc, ret, cleanup);
+    }
+
+    /* reference */
+    if (rfn->ref) {
+        FREE_STRING(ctx->ctx, target->ref);
+        DUP_STRING_GOTO(ctx->ctx, rfn->ref, target->ref, ret, cleanup);
+    }
+
+    /* config */
+    if (rfn->flags & LYS_CONFIG_MASK) {
+        if (ctx->options & (LYS_COMPILE_NOTIFICATION | LYS_COMPILE_RPC_INPUT | LYS_COMPILE_RPC_OUTPUT)) {
+            LOGWRN(ctx->ctx, "Refining config inside %s has no effect (%s).",
+                    ctx->options & LYS_COMPILE_NOTIFICATION ? "notification" : "RPC/action", ctx->path);
+        } else {
+            target->flags &= ~LYS_CONFIG_MASK;
+            target->flags |= rfn->flags & LYS_CONFIG_MASK;
+        }
+    }
+
+    /* mandatory */
+    if (rfn->flags & LYS_MAND_MASK) {
+        switch (target->nodetype) {
+        case LYS_LEAF:
+        case LYS_CHOICE:
+        case LYS_ANYDATA:
+        case LYS_ANYXML:
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("refine", "replace", "mandatory");
+        }
+
+        target->flags &= ~LYS_MAND_MASK;
+        target->flags |= rfn->flags & LYS_MAND_MASK;
+    }
+
+    /* presence */
+    if (rfn->presence) {
+        switch (target->nodetype) {
+        case LYS_CONTAINER:
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("refine", "replace", "presence");
+        }
+
+        FREE_STRING(ctx->ctx, ((struct lysp_node_container *)target)->presence);
+        DUP_STRING_GOTO(ctx->ctx, rfn->presence, ((struct lysp_node_container *)target)->presence, ret, cleanup);
+    }
+
+    /* must */
+    if (rfn->musts) {
+        switch (target->nodetype) {
+        case LYS_CONTAINER:
+        case LYS_LIST:
+        case LYS_LEAF:
+        case LYS_LEAFLIST:
+        case LYS_ANYDATA:
+        case LYS_ANYXML:
+            musts = &((struct lysp_node_container *)target)->musts;
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("refine", "add", "must");
+        }
+
+        LY_ARRAY_FOR(rfn->musts, u) {
+            LY_ARRAY_NEW_GOTO(ctx->ctx, *musts, must, ret, cleanup);
+            LY_CHECK_GOTO(ret = lysp_restr_dup(ctx->ctx, must, &rfn->musts[u]), cleanup);
+        }
+    }
+
+    /* min-elements */
+    if (rfn->flags & LYS_SET_MIN) {
+        switch (target->nodetype) {
+        case LYS_LEAFLIST:
+            num = &((struct lysp_node_leaflist *)target)->min;
+            break;
+        case LYS_LIST:
+            num = &((struct lysp_node_list *)target)->min;
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("refine", "replace", "min-elements");
+        }
+
+        *num = rfn->min;
+    }
+
+    /* max-elements */
+    if (rfn->flags & LYS_SET_MAX) {
+        switch (target->nodetype) {
+        case LYS_LEAFLIST:
+            num = &((struct lysp_node_leaflist *)target)->max;
+            break;
+        case LYS_LIST:
+            num = &((struct lysp_node_list *)target)->max;
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("refine", "replace", "max-elements");
+        }
+
+        *num = rfn->max;
+    }
+
+    /* if-feature */
+    if (rfn->iffeatures) {
+        switch (target->nodetype) {
+        case LYS_LEAF:
+        case LYS_LEAFLIST:
+        case LYS_LIST:
+        case LYS_CONTAINER:
+        case LYS_CHOICE:
+        case LYS_CASE:
+        case LYS_ANYDATA:
+        case LYS_ANYXML:
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("refine", "add", "if-feature");
+        }
+
+        LY_ARRAY_FOR(rfn->iffeatures, u) {
+            LY_ARRAY_NEW_GOTO(ctx->ctx, target->iffeatures, qname, ret, cleanup);
+            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, qname, &rfn->iffeatures[u]), cleanup);
+        }
+    }
+
+    /* extension */
+    /* TODO refine extensions */
+
+cleanup:
+    return ret;
+}
+
+/**
+ * @brief Apply deviate add.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] d Deviate add to apply.
+ * @param[in,out] target Deviation target.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_apply_deviate_add(struct lysc_ctx *ctx, struct lysp_deviate_add *d, struct lysp_node *target)
+{
+    LY_ERR ret = LY_SUCCESS;
+    LY_ARRAY_COUNT_TYPE u;
+    struct lysp_qname *qname;
+    uint32_t *num;
+    struct lysp_restr **musts, *must;
+
+#define DEV_CHECK_NONPRESENCE(TYPE, MEMBER, PROPERTY, VALUEMEMBER) \
+    if (((TYPE)target)->MEMBER) { \
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
+                "Invalid deviation adding \"%s\" property which already exists (with value \"%s\").", \
+                PROPERTY, ((TYPE)target)->VALUEMEMBER); \
+        ret = LY_EVALID; \
+        goto cleanup; \
+    }
+
+    /* [units-stmt] */
+    if (d->units) {
+        switch (target->nodetype) {
+        case LYS_LEAF:
+        case LYS_LEAFLIST:
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "add", "units");
+        }
+
+        DEV_CHECK_NONPRESENCE(struct lysp_node_leaf *, units, "units", units);
+        DUP_STRING_GOTO(ctx->ctx, d->units, ((struct lysp_node_leaf *)target)->units, ret, cleanup);
+    }
+
+    /* *must-stmt */
+    if (d->musts) {
+        switch (target->nodetype) {
+        case LYS_CONTAINER:
+        case LYS_LIST:
+        case LYS_LEAF:
+        case LYS_LEAFLIST:
+        case LYS_ANYDATA:
+        case LYS_ANYXML:
+            musts = &((struct lysp_node_container *)target)->musts;
+            break;
+        case LYS_NOTIF:
+            musts = &((struct lysp_notif *)target)->musts;
+            break;
+        case LYS_INPUT:
+        case LYS_OUTPUT:
+            musts = &((struct lysp_action_inout *)target)->musts;
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "add", "must");
+        }
+
+        LY_ARRAY_FOR(d->musts, u) {
+            LY_ARRAY_NEW_GOTO(ctx->ctx, *musts, must, ret, cleanup);
+            LY_CHECK_GOTO(ret = lysp_restr_dup(ctx->ctx, must, &d->musts[u]), cleanup);
+        }
+    }
+
+    /* *unique-stmt */
+    if (d->uniques) {
+        switch (target->nodetype) {
+        case LYS_LIST:
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "add", "unique");
+        }
+
+        LY_ARRAY_FOR(d->uniques, u) {
+            LY_ARRAY_NEW_GOTO(ctx->ctx, ((struct lysp_node_list *)target)->uniques, qname, ret, cleanup);
+            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, qname, &d->uniques[u]), cleanup);
+        }
+    }
+
+    /* *default-stmt */
+    if (d->dflts) {
+        switch (target->nodetype) {
+        case LYS_LEAF:
+            AMEND_CHECK_CARDINALITY(d->dflts, 1, "deviation", "default");
+            DEV_CHECK_NONPRESENCE(struct lysp_node_leaf *, dflt.str, "default", dflt.str);
+
+            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, &((struct lysp_node_leaf *)target)->dflt, &d->dflts[0]), cleanup);
+            break;
+        case LYS_LEAFLIST:
+            LY_ARRAY_FOR(d->dflts, u) {
+                LY_ARRAY_NEW_GOTO(ctx->ctx, ((struct lysp_node_leaflist *)target)->dflts, qname, ret, cleanup);
+                LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, qname, &d->dflts[u]), cleanup);
+            }
+            break;
+        case LYS_CHOICE:
+            AMEND_CHECK_CARDINALITY(d->dflts, 1, "deviation", "default");
+            DEV_CHECK_NONPRESENCE(struct lysp_node_choice *, dflt.str, "default", dflt.str);
+
+            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, &((struct lysp_node_choice *)target)->dflt, &d->dflts[0]), cleanup);
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "add", "default");
+        }
+    }
+
+    /* [config-stmt] */
+    if (d->flags & LYS_CONFIG_MASK) {
+        switch (target->nodetype) {
+        case LYS_CONTAINER:
+        case LYS_LEAF:
+        case LYS_LEAFLIST:
+        case LYS_LIST:
+        case LYS_CHOICE:
+        case LYS_ANYDATA:
+        case LYS_ANYXML:
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "add", "config");
+        }
+
+        if (target->flags & LYS_CONFIG_MASK) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid deviation adding \"config\" property which already exists (with value \"config %s\").",
+                    target->flags & LYS_CONFIG_W ? "true" : "false");
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+
+        target->flags |= d->flags & LYS_CONFIG_MASK;
+    }
+
+    /* [mandatory-stmt] */
+    if (d->flags & LYS_MAND_MASK) {
+        switch (target->nodetype) {
+        case LYS_LEAF:
+        case LYS_CHOICE:
+        case LYS_ANYDATA:
+        case LYS_ANYXML:
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "add", "mandatory");
+        }
+
+        if (target->flags & LYS_MAND_MASK) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid deviation adding \"mandatory\" property which already exists (with value \"mandatory %s\").",
+                    target->flags & LYS_MAND_TRUE ? "true" : "false");
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+
+        target->flags |= d->flags & LYS_MAND_MASK;
+    }
+
+    /* [min-elements-stmt] */
+    if (d->flags & LYS_SET_MIN) {
+        switch (target->nodetype) {
+        case LYS_LEAFLIST:
+            num = &((struct lysp_node_leaflist *)target)->min;
+            break;
+        case LYS_LIST:
+            num = &((struct lysp_node_list *)target)->min;
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "add", "min-elements");
+        }
+
+        if (target->flags & LYS_SET_MIN) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid deviation adding \"min-elements\" property which already exists (with value \"%u\").", *num);
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+
+        *num = d->min;
+    }
+
+    /* [max-elements-stmt] */
+    if (d->flags & LYS_SET_MAX) {
+        switch (target->nodetype) {
+        case LYS_LEAFLIST:
+            num = &((struct lysp_node_leaflist *)target)->max;
+            break;
+        case LYS_LIST:
+            num = &((struct lysp_node_list *)target)->max;
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "add", "max-elements");
+        }
+
+        if (target->flags & LYS_SET_MAX) {
+            if (*num) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                        "Invalid deviation adding \"max-elements\" property which already exists (with value \"%u\").",
+                        *num);
+            } else {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                        "Invalid deviation adding \"max-elements\" property which already exists (with value \"unbounded\").");
+            }
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+
+        *num = d->max;
+    }
+
+cleanup:
+    return ret;
+}
+
+/**
+ * @brief Apply deviate delete.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] d Deviate delete to apply.
+ * @param[in,out] target Deviation target.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_apply_deviate_delete(struct lysc_ctx *ctx, struct lysp_deviate_del *d, struct lysp_node *target)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lysp_restr **musts;
+    LY_ARRAY_COUNT_TYPE u, v;
+    struct lysp_qname **uniques, **dflts;
+
+#define DEV_DEL_ARRAY(DEV_ARRAY, ORIG_ARRAY, DEV_MEMBER, ORIG_MEMBER, FREE_FUNC, PROPERTY) \
+    LY_ARRAY_FOR(d->DEV_ARRAY, u) { \
+        int found = 0; \
+        LY_ARRAY_FOR(ORIG_ARRAY, v) { \
+            if (!strcmp(d->DEV_ARRAY[u]DEV_MEMBER, (ORIG_ARRAY)[v]ORIG_MEMBER)) { \
+                found = 1; \
+                break; \
+            } \
+        } \
+        if (!found) { \
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
+                    "Invalid deviation deleting \"%s\" property \"%s\" which does not match any of the target's property values.", \
+                    PROPERTY, d->DEV_ARRAY[u]DEV_MEMBER); \
+            ret = LY_EVALID; \
+            goto cleanup; \
+        } \
+        LY_ARRAY_DECREMENT(ORIG_ARRAY); \
+        FREE_FUNC(ctx->ctx, &(ORIG_ARRAY)[v]); \
+        memmove(&(ORIG_ARRAY)[v], &(ORIG_ARRAY)[v + 1], (LY_ARRAY_COUNT(ORIG_ARRAY) - v) * sizeof *(ORIG_ARRAY)); \
+    } \
+    if (!LY_ARRAY_COUNT(ORIG_ARRAY)) { \
+        LY_ARRAY_FREE(ORIG_ARRAY); \
+        ORIG_ARRAY = NULL; \
+    }
+
+#define DEV_CHECK_PRESENCE_VALUE(TYPE, MEMBER, DEVTYPE, PROPERTY, VALUE) \
+    if (!((TYPE)target)->MEMBER) { \
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NOT_PRESENT, DEVTYPE, PROPERTY, VALUE); \
+        ret = LY_EVALID; \
+        goto cleanup; \
+    } else if (strcmp(((TYPE)target)->MEMBER, VALUE)) { \
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
+                "Invalid deviation deleting \"%s\" property \"%s\" which does not match the target's property value \"%s\".", \
+                PROPERTY, VALUE, ((TYPE)target)->MEMBER); \
+        ret = LY_EVALID; \
+        goto cleanup; \
+    }
+
+    /* [units-stmt] */
+    if (d->units) {
+        switch (target->nodetype) {
+        case LYS_LEAF:
+        case LYS_LEAFLIST:
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "delete", "units");
+        }
+
+        DEV_CHECK_PRESENCE_VALUE(struct lysp_node_leaf *, units, "deleting", "units", d->units);
+        FREE_STRING(ctx->ctx, ((struct lysp_node_leaf *)target)->units);
+        ((struct lysp_node_leaf *)target)->units = NULL;
+    }
+
+    /* *must-stmt */
+    if (d->musts) {
+        switch (target->nodetype) {
+        case LYS_CONTAINER:
+        case LYS_LIST:
+        case LYS_LEAF:
+        case LYS_LEAFLIST:
+        case LYS_ANYDATA:
+        case LYS_ANYXML:
+            musts = &((struct lysp_node_container *)target)->musts;
+            break;
+        case LYS_NOTIF:
+            musts = &((struct lysp_notif *)target)->musts;
+            break;
+        case LYS_INPUT:
+        case LYS_OUTPUT:
+            musts = &((struct lysp_action_inout *)target)->musts;
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "delete", "must");
+        }
+
+        DEV_DEL_ARRAY(musts, *musts, .arg.str, .arg.str, lysp_restr_free, "must");
+    }
+
+    /* *unique-stmt */
+    if (d->uniques) {
+        switch (target->nodetype) {
+        case LYS_LIST:
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "delete", "unique");
+        }
+
+        uniques = &((struct lysp_node_list *)target)->uniques;
+        DEV_DEL_ARRAY(uniques, *uniques, .str, .str, lysp_qname_free, "unique");
+    }
+
+    /* *default-stmt */
+    if (d->dflts) {
+        switch (target->nodetype) {
+        case LYS_LEAF:
+            AMEND_CHECK_CARDINALITY(d->dflts, 1, "deviation", "default");
+            DEV_CHECK_PRESENCE_VALUE(struct lysp_node_leaf *, dflt.str, "deleting", "default", d->dflts[0].str);
+
+            FREE_STRING(ctx->ctx, ((struct lysp_node_leaf *)target)->dflt.str);
+            ((struct lysp_node_leaf *)target)->dflt.str = NULL;
+            break;
+        case LYS_LEAFLIST:
+            dflts = &((struct lysp_node_leaflist *)target)->dflts;
+            DEV_DEL_ARRAY(dflts, *dflts, .str, .str, lysp_qname_free, "default");
+            break;
+        case LYS_CHOICE:
+            AMEND_CHECK_CARDINALITY(d->dflts, 1, "deviation", "default");
+            DEV_CHECK_PRESENCE_VALUE(struct lysp_node_choice *, dflt.str, "deleting", "default", d->dflts[0].str);
+
+            FREE_STRING(ctx->ctx, ((struct lysp_node_choice *)target)->dflt.str);
+            ((struct lysp_node_choice *)target)->dflt.str = NULL;
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "delete", "default");
+        }
+    }
+
+cleanup:
+    return ret;
+}
+
+/**
+ * @brief Apply deviate replace.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] d Deviate replace to apply.
+ * @param[in,out] target Deviation target.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_apply_deviate_replace(struct lysc_ctx *ctx, struct lysp_deviate_rpl *d, struct lysp_node *target)
+{
+    LY_ERR ret = LY_SUCCESS;
+    uint32_t *num;
+
+#define DEV_CHECK_PRESENCE(TYPE, MEMBER, DEVTYPE, PROPERTY, VALUE) \
+    if (!((TYPE)target)->MEMBER) { \
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NOT_PRESENT, DEVTYPE, PROPERTY, VALUE); \
+        ret = LY_EVALID; \
+        goto cleanup; \
+    }
+
+    /* [type-stmt] */
+    if (d->type) {
+        switch (target->nodetype) {
+        case LYS_LEAF:
+        case LYS_LEAFLIST:
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "replace", "type");
+        }
+
+        lysp_type_free(ctx->ctx, &((struct lysp_node_leaf *)target)->type);
+        lysp_type_dup(ctx->ctx, &((struct lysp_node_leaf *)target)->type, d->type);
+    }
+
+    /* [units-stmt] */
+    if (d->units) {
+        switch (target->nodetype) {
+        case LYS_LEAF:
+        case LYS_LEAFLIST:
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "replace", "units");
+        }
+
+        DEV_CHECK_PRESENCE(struct lysp_node_leaf *, units, "replacing", "units", d->units);
+        FREE_STRING(ctx->ctx, ((struct lysp_node_leaf *)target)->units);
+        DUP_STRING_GOTO(ctx->ctx, d->units, ((struct lysp_node_leaf *)target)->units, ret, cleanup);
+    }
+
+    /* [default-stmt] */
+    if (d->dflt.str) {
+        switch (target->nodetype) {
+        case LYS_LEAF:
+            DEV_CHECK_PRESENCE(struct lysp_node_leaf *, dflt.str, "replacing", "default", d->dflt.str);
+
+            FREE_STRING(ctx->ctx, ((struct lysp_node_leaf *)target)->dflt.str);
+            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, &((struct lysp_node_leaf *)target)->dflt, &d->dflt), cleanup);
+            break;
+        case LYS_CHOICE:
+            DEV_CHECK_PRESENCE(struct lysp_node_choice *, dflt.str, "replacing", "default", d->dflt);
+
+            FREE_STRING(ctx->ctx, ((struct lysp_node_choice *)target)->dflt.str);
+            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, &((struct lysp_node_choice *)target)->dflt, &d->dflt), cleanup);
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "replace", "default");
+        }
+    }
+
+    /* [config-stmt] */
+    if (d->flags & LYS_CONFIG_MASK) {
+        switch (target->nodetype) {
+        case LYS_CONTAINER:
+        case LYS_LEAF:
+        case LYS_LEAFLIST:
+        case LYS_LIST:
+        case LYS_CHOICE:
+        case LYS_ANYDATA:
+        case LYS_ANYXML:
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "replace", "config");
+        }
+
+        if (!(target->flags & LYS_CONFIG_MASK)) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NOT_PRESENT,
+                    "replacing", "config", d->flags & LYS_CONFIG_W ? "config true" : "config false");
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+
+        target->flags &= ~LYS_CONFIG_MASK;
+        target->flags |= d->flags & LYS_CONFIG_MASK;
+    }
+
+    /* [mandatory-stmt] */
+    if (d->flags & LYS_MAND_MASK) {
+        switch (target->nodetype) {
+        case LYS_LEAF:
+        case LYS_CHOICE:
+        case LYS_ANYDATA:
+        case LYS_ANYXML:
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "replace", "mandatory");
+        }
+
+        if (!(target->flags & LYS_MAND_MASK)) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NOT_PRESENT,
+                    "replacing", "mandatory", d->flags & LYS_MAND_TRUE ? "mandatory true" : "mandatory false");
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+
+        target->flags &= ~LYS_MAND_MASK;
+        target->flags |= d->flags & LYS_MAND_MASK;
+    }
+
+    /* [min-elements-stmt] */
+    if (d->flags & LYS_SET_MIN) {
+        switch (target->nodetype) {
+        case LYS_LEAFLIST:
+            num = &((struct lysp_node_leaflist *)target)->min;
+            break;
+        case LYS_LIST:
+            num = &((struct lysp_node_list *)target)->min;
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "replace", "min-elements");
+        }
+
+        if (!(target->flags & LYS_SET_MIN)) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid deviation replacing \"min-elements\" property which is not present.");
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+
+        *num = d->min;
+    }
+
+    /* [max-elements-stmt] */
+    if (d->flags & LYS_SET_MAX) {
+        switch (target->nodetype) {
+        case LYS_LEAFLIST:
+            num = &((struct lysp_node_leaflist *)target)->max;
+            break;
+        case LYS_LIST:
+            num = &((struct lysp_node_list *)target)->max;
+            break;
+        default:
+            AMEND_WRONG_NODETYPE("deviation", "replace", "max-elements");
+        }
+
+        if (!(target->flags & LYS_SET_MAX)) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid deviation replacing \"max-elements\" property which is not present.");
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+
+        *num = d->max;
+    }
+
+cleanup:
+    return ret;
+}
+
+/**
+ * @brief Get module of a single nodeid node name test.
+ *
+ * @param[in] ctx libyang context.
+ * @param[in] nametest Nametest with an optional prefix.
+ * @param[in] nametest_len Length of @p nametest.
+ * @param[in] mod Both current and prefix module for resolving prefixes and to return in case of no prefix.
+ * @param[out] name Optional pointer to the name test without the prefix.
+ * @param[out] name_len Length of @p name.
+ * @return Resolved module.
+ */
+static const struct lys_module *
+lys_schema_node_get_module(const struct ly_ctx *ctx, const char *nametest, size_t nametest_len,
+        const struct lysp_module *mod, const char **name, size_t *name_len)
+{
+    const struct lys_module *target_mod;
+    const char *ptr;
+
+    ptr = ly_strnchr(nametest, ':', nametest_len);
+    if (ptr) {
+        target_mod = ly_resolve_prefix(ctx, nametest, ptr - nametest, LY_PREF_SCHEMA, (void *)mod);
+        if (!target_mod) {
+            LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE,
+                    "Invalid absolute-schema-nodeid nametest \"%.*s\" - prefix \"%.*s\" not defined in module \"%s\".",
+                    nametest_len, nametest, ptr - nametest, nametest, LYSP_MODULE_NAME(mod));
+            return NULL;
+        }
+
+        if (name) {
+            *name = ptr + 1;
+            *name_len = nametest_len - ((ptr - nametest) + 1);
+        }
+    } else {
+        target_mod = mod->mod;
+        if (name) {
+            *name = nametest;
+            *name_len = nametest_len;
+        }
+    }
+
+    return target_mod;
+}
+
+/**
+ * @brief Check whether a parsed node matches a single schema nodeid name test.
+ *
+ * @param[in] pnode Parsed node to consider.
+ * @param[in] pnode_mod Compiled @p pnode to-be module.
+ * @param[in] mod Expected module.
+ * @param[in] name Expected name.
+ * @param[in] name_len Length of @p name.
+ * @return Whether it is a match or not.
+ */
+static ly_bool
+lysp_schema_nodeid_match_pnode(const struct lysp_node *pnode, const struct lys_module *pnode_mod,
+        const struct lys_module *mod, const char *name, size_t name_len)
+{
+    const char *pname;
+
+    /* compare with the module of the node */
+    if (pnode_mod != mod) {
+        return 0;
+    }
+
+    /* compare names */
+    if (pnode->nodetype & (LYS_ACTION | LYS_RPC)) {
+        pname = ((struct lysp_action *)pnode)->name;
+    } else if (pnode->nodetype & (LYS_INPUT | LYS_OUTPUT)) {
+        pname = (pnode->nodetype & LYS_INPUT) ? "input" : "output";
+    } else {
+        pname = pnode->name;
+    }
+    if (ly_strncmp(pname, name, name_len)) {
+        return 0;
+    }
+
+    return 1;
+}
+
+/**
+ * @brief Check whether a compiled node matches a single schema nodeid name test.
+ *
+ * @param[in,out] node Compiled node to consider. On a match it is moved to its parent.
+ * @param[in] mod Expected module.
+ * @param[in] name Expected name.
+ * @param[in] name_len Length of @p name.
+ * @return Whether it is a match or not.
+ */
+static ly_bool
+lysp_schema_nodeid_match_node(const struct lysc_node **node, const struct lys_module *mod, const char *name,
+        size_t name_len)
+{
+    const struct lys_module *node_mod;
+    const char *node_name;
+
+    /* compare with the module of the node */
+    if ((*node)->nodetype == LYS_INPUT) {
+        node_mod = ((struct lysc_node *)(((char *)*node) - offsetof(struct lysc_action, input)))->module;
+    } else if ((*node)->nodetype == LYS_OUTPUT) {
+        node_mod = ((struct lysc_node *)(((char *)*node) - offsetof(struct lysc_action, output)))->module;
+    } else {
+        node_mod = (*node)->module;
+    }
+    if (node_mod != mod) {
+        return 0;
+    }
+
+    /* compare names */
+    if ((*node)->nodetype == LYS_INPUT) {
+        node_name = "input";
+    } else if ((*node)->nodetype == LYS_OUTPUT) {
+        node_name = "output";
+    } else {
+        node_name = (*node)->name;
+    }
+    if (ly_strncmp(node_name, name, name_len)) {
+        return 0;
+    }
+
+    if ((*node)->nodetype & (LYS_INPUT | LYS_OUTPUT)) {
+        /* move up from input/output */
+        if ((*node)->nodetype == LYS_INPUT) {
+            (*node) = (struct lysc_node *)(((char *)*node) - offsetof(struct lysc_action, input));
+        } else {
+            (*node) = (struct lysc_node *)(((char *)*node) - offsetof(struct lysc_action, output));
+        }
+    } else if ((*node)->parent && ((*node)->parent->nodetype & (LYS_RPC | LYS_ACTION))) {
+        /* move to the input/output */
+        if ((*node)->flags & LYS_CONFIG_W) {
+            *node = (struct lysc_node *)&((struct lysc_action *)(*node)->parent)->input;
+        } else {
+            *node = (struct lysc_node *)&((struct lysc_action *)(*node)->parent)->output;
+        }
+    } else {
+        /* move to next parent */
+        *node = (*node)->parent;
+    }
+
+    return 1;
+}
+
+/**
+ * @brief Check whether a node matches specific schema nodeid.
+ *
+ * @param[in] exp Parsed nodeid to match.
+ * @param[in] exp_pmod Module to use for nodes in @p exp without a prefix.
+ * @param[in] ctx_node Initial context node that should match, only for descendant paths.
+ * @param[in] parent First compiled parent to consider. If @p pnode is NULL, it is condered the node to be matched.
+ * @param[in] pnode Parsed node to be matched. May be NULL if the target node was already compiled.
+ * @param[in] pnode_mod Compiled @p pnode to-be module.
+ * @return Whether it is a match or not.
+ */
+static ly_bool
+lysp_schema_nodeid_match(const struct lyxp_expr *exp, const struct lysp_module *exp_pmod, const struct lysc_node *ctx_node,
+        const struct lysc_node *parent, const struct lysp_node *pnode, const struct lys_module *pnode_mod)
+{
+    uint32_t i;
+    const struct lys_module *mod;
+    const char *name;
+    size_t name_len;
+
+    /* compare last node in the node ID */
+    i = exp->used - 1;
+
+    /* get exp node ID module */
+    mod = lys_schema_node_get_module(exp_pmod->mod->ctx, exp->expr + exp->tok_pos[i], exp->tok_len[i], exp_pmod, &name, &name_len);
+    assert(mod);
+
+    if (pnode) {
+        /* compare on the last parsed-only node */
+        if (!lysp_schema_nodeid_match_pnode(pnode, pnode_mod, mod, name, name_len)) {
+            return 0;
+        }
+    } else {
+        /* using parent directly */
+        if (!lysp_schema_nodeid_match_node(&parent, mod, name, name_len)) {
+            return 0;
+        }
+    }
+
+    /* now compare all the compiled parents */
+    while (i > 1) {
+        i -= 2;
+        assert(exp->tokens[i] == LYXP_TOKEN_NAMETEST);
+
+        if (!parent) {
+            /* no more parents but path continues */
+            return 0;
+        }
+
+        /* get exp node ID module */
+        mod = lys_schema_node_get_module(exp_pmod->mod->ctx, exp->expr + exp->tok_pos[i], exp->tok_len[i], exp_pmod, &name,
+                &name_len);
+        assert(mod);
+
+        /* compare with the parent */
+        if (!lysp_schema_nodeid_match_node(&parent, mod, name, name_len)) {
+            return 0;
+        }
+    }
+
+    if (ctx_node && (ctx_node != parent)) {
+        /* descendant path has not finished in the context node */
+        return 0;
+    } else if (!ctx_node && parent) {
+        /* some parent was not matched */
+        return 0;
+    }
+
+    return 1;
+}
+
+void
+lysc_augment_free(const struct ly_ctx *ctx, struct lysc_augment *aug)
+{
+    if (aug) {
+        lyxp_expr_free(ctx, aug->nodeid);
+
+        free(aug);
+    }
+}
+
+void
+lysc_deviation_free(const struct ly_ctx *ctx, struct lysc_deviation *dev)
+{
+    if (dev) {
+        lyxp_expr_free(ctx, dev->nodeid);
+        LY_ARRAY_FREE(dev->devs);
+        LY_ARRAY_FREE(dev->dev_pmods);
+
+        free(dev);
+    }
+}
+
+void
+lysc_refine_free(const struct ly_ctx *ctx, struct lysc_refine *rfn)
+{
+    if (rfn) {
+        lyxp_expr_free(ctx, rfn->nodeid);
+        LY_ARRAY_FREE(rfn->rfns);
+
+        free(rfn);
+    }
+}
+
+void
+lysp_dev_node_free(const struct ly_ctx *ctx, struct lysp_node *dev_pnode)
+{
+    if (!dev_pnode) {
+        return;
+    }
+
+    switch (dev_pnode->nodetype) {
+    case LYS_CONTAINER:
+        ((struct lysp_node_container *)dev_pnode)->child = NULL;
+        break;
+    case LYS_LIST:
+        ((struct lysp_node_list *)dev_pnode)->child = NULL;
+        break;
+    case LYS_CHOICE:
+        ((struct lysp_node_choice *)dev_pnode)->child = NULL;
+        break;
+    case LYS_CASE:
+        ((struct lysp_node_case *)dev_pnode)->child = NULL;
+        break;
+    case LYS_LEAF:
+    case LYS_LEAFLIST:
+    case LYS_ANYXML:
+    case LYS_ANYDATA:
+        /* no children */
+        break;
+    case LYS_NOTIF:
+        ((struct lysp_notif *)dev_pnode)->data = NULL;
+        lysp_notif_free((struct ly_ctx *)ctx, (struct lysp_notif *)dev_pnode);
+        free(dev_pnode);
+        return;
+    case LYS_RPC:
+    case LYS_ACTION:
+        ((struct lysp_action *)dev_pnode)->input.data = NULL;
+        ((struct lysp_action *)dev_pnode)->output.data = NULL;
+        lysp_action_free((struct ly_ctx *)ctx, (struct lysp_action *)dev_pnode);
+        free(dev_pnode);
+        return;
+    case LYS_INPUT:
+    case LYS_OUTPUT:
+        ((struct lysp_action_inout *)dev_pnode)->data = NULL;
+        lysp_action_inout_free((struct ly_ctx *)ctx, (struct lysp_action_inout *)dev_pnode);
+        free(dev_pnode);
+        return;
+    default:
+        LOGINT(ctx);
+        return;
+    }
+
+    lysp_node_free((struct ly_ctx *)ctx, dev_pnode);
+}
+
+LY_ERR
+lys_compile_node_deviations_refines(struct lysc_ctx *ctx, const struct lysp_node *pnode, const struct lysc_node *parent,
+        struct lysp_node **dev_pnode, ly_bool *not_supported)
+{
+    LY_ERR ret = LY_SUCCESS;
+    uint32_t i;
+    LY_ARRAY_COUNT_TYPE u;
+    struct lys_module *orig_mod = ctx->cur_mod;
+    struct lysp_module *orig_pmod = ctx->pmod;
+    char orig_path[LYSC_CTX_BUFSIZE];
+    struct lysc_refine *rfn;
+    struct lysc_deviation *dev;
+    struct lysp_deviation *dev_p;
+    struct lysp_deviate *d;
+
+    *dev_pnode = NULL;
+    *not_supported = 0;
+
+    for (i = 0; i < ctx->uses_rfns.count; ++i) {
+        rfn = ctx->uses_rfns.objs[i];
+
+        if (!lysp_schema_nodeid_match(rfn->nodeid, rfn->nodeid_pmod, rfn->nodeid_ctx_node, parent, pnode, ctx->cur_mod)) {
+            /* not our target node */
+            continue;
+        }
+
+        if (!*dev_pnode) {
+            /* first refine on this node, create a copy first */
+            LY_CHECK_GOTO(ret = lysp_dup_single(ctx->ctx, pnode, 1, dev_pnode), cleanup);
+        }
+
+        /* apply all the refines by changing (the copy of) the parsed node */
+        LY_ARRAY_FOR(rfn->rfns, u) {
+            /* apply refine, keep the current path and add to it */
+            lysc_update_path(ctx, NULL, "{refine}");
+            lysc_update_path(ctx, NULL, rfn->rfns[u]->nodeid);
+            ret = lys_apply_refine(ctx, rfn->rfns[u], *dev_pnode);
+            lysc_update_path(ctx, NULL, NULL);
+            lysc_update_path(ctx, NULL, NULL);
+            LY_CHECK_GOTO(ret, cleanup);
+        }
+
+        /* refine was applied, remove it */
+        lysc_refine_free(ctx->ctx, rfn);
+        ly_set_rm_index(&ctx->uses_rfns, i, NULL);
+
+        /* all the refines for one target node are in one structure, we are done */
+        break;
+    }
+
+    for (i = 0; i < ctx->devs.count; ++i) {
+        dev = ctx->devs.objs[i];
+
+        if (!lysp_schema_nodeid_match(dev->nodeid, dev->dev_pmods[0], NULL, parent, pnode, ctx->cur_mod)) {
+            /* not our target node */
+            continue;
+        }
+
+        if (dev->not_supported) {
+            /* it is not supported, no more deviations */
+            *not_supported = 1;
+            goto dev_applied;
+        }
+
+        if (!*dev_pnode) {
+            /* first deviation on this node, create a copy first */
+            LY_CHECK_GOTO(ret = lysp_dup_single(ctx->ctx, pnode, 1, dev_pnode), cleanup);
+        }
+
+        /* apply all the deviates by changing (the copy of) the parsed node */
+        LY_ARRAY_FOR(dev->devs, u) {
+            dev_p = dev->devs[u];
+            LY_LIST_FOR(dev_p->deviates, d) {
+                /* generate correct path */
+                strcpy(orig_path, ctx->path);
+                ctx->path_len = 1;
+                ctx->cur_mod = dev->dev_pmods[u]->mod;
+                ctx->pmod = (struct lysp_module *)dev->dev_pmods[u];
+                lysc_update_path(ctx, NULL, "{deviation}");
+                lysc_update_path(ctx, NULL, dev_p->nodeid);
+
+                switch (d->mod) {
+                case LYS_DEV_ADD:
+                    ret = lys_apply_deviate_add(ctx, (struct lysp_deviate_add *)d, *dev_pnode);
+                    break;
+                case LYS_DEV_DELETE:
+                    ret = lys_apply_deviate_delete(ctx, (struct lysp_deviate_del *)d, *dev_pnode);
+                    break;
+                case LYS_DEV_REPLACE:
+                    ret = lys_apply_deviate_replace(ctx, (struct lysp_deviate_rpl *)d, *dev_pnode);
+                    break;
+                default:
+                    LOGINT(ctx->ctx);
+                    ret = LY_EINT;
+                }
+
+                /* restore previous path */
+                strcpy(ctx->path, orig_path);
+                ctx->path_len = strlen(ctx->path);
+                ctx->cur_mod = orig_mod;
+                ctx->pmod = orig_pmod;
+
+                LY_CHECK_GOTO(ret, cleanup);
+            }
+        }
+
+dev_applied:
+        /* deviation was applied, remove it */
+        lysc_deviation_free(ctx->ctx, dev);
+        ly_set_rm_index(&ctx->devs, i, NULL);
+
+        /* all the deviations for one target node are in one structure, we are done */
+        break;
+    }
+
+cleanup:
+    if (ret) {
+        lysp_dev_node_free(ctx->ctx, *dev_pnode);
+        *dev_pnode = NULL;
+        *not_supported = 0;
+    }
+    return ret;
+}
+
+/**
+ * @brief Compile the parsed augment connecting it into its target.
+ *
+ * It is expected that all the data referenced in path are present - augments are ordered so that augment B
+ * targeting data from augment A is being compiled after augment A. Also the modules referenced in the path
+ * are already implemented and compiled.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] aug_p Parsed augment to compile.
+ * @param[in] target Target node of the augment.
+ * @return LY_SUCCESS on success.
+ * @return LY_EVALID on failure.
+ */
+static LY_ERR
+lys_compile_augment(struct lysc_ctx *ctx, struct lysp_augment *aug_p, struct lysc_node *target)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lysp_node *pnode;
+    struct lysc_node *node;
+    struct lysc_when *when_shared = NULL;
+    struct lysc_action **actions;
+    struct lysc_notif **notifs;
+    ly_bool allow_mandatory = 0;
+    LY_ARRAY_COUNT_TYPE u;
+    struct ly_set child_set = {0};
+    uint32_t i;
+
+    if (!(target->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_CHOICE | LYS_CASE | LYS_INPUT | LYS_OUTPUT | LYS_NOTIF))) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                "Augment's %s-schema-nodeid \"%s\" refers to a %s node which is not an allowed augment's target.",
+                aug_p->nodeid[0] == '/' ? "absolute" : "descendant", aug_p->nodeid, lys_nodetype2str(target->nodetype));
+        ret = LY_EVALID;
+        goto cleanup;
+    }
+
+    /* check for mandatory nodes
+     * - new cases augmenting some choice can have mandatory nodes
+     * - mandatory nodes are allowed only in case the augmentation is made conditional with a when statement
+     */
+    if (aug_p->when || (target->nodetype == LYS_CHOICE) || (ctx->cur_mod == target->module)) {
+        allow_mandatory = 1;
+    }
+
+    LY_LIST_FOR(aug_p->child, pnode) {
+        /* check if the subnode can be connected to the found target (e.g. case cannot be inserted into container) */
+        if (((pnode->nodetype == LYS_CASE) && (target->nodetype != LYS_CHOICE)) ||
+                ((pnode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) && !(target->nodetype & (LYS_CONTAINER | LYS_LIST))) ||
+                ((pnode->nodetype == LYS_USES) && (target->nodetype == LYS_CHOICE))) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid augment of %s node which is not allowed to contain %s node \"%s\".",
+                    lys_nodetype2str(target->nodetype), lys_nodetype2str(pnode->nodetype), pnode->name);
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+
+        /* compile the children */
+        if (target->nodetype == LYS_CHOICE) {
+            LY_CHECK_GOTO(ret = lys_compile_node_choice_child(ctx, pnode, target, &child_set), cleanup);
+        } else {
+            LY_CHECK_GOTO(ret = lys_compile_node(ctx, pnode, target, 0, &child_set), cleanup);
+        }
+
+        /* since the augment node is not present in the compiled tree, we need to pass some of its
+         * statements to all its children */
+        for (i = 0; i < child_set.count; ++i) {
+            node = child_set.snodes[i];
+            if (!allow_mandatory && (node->flags & LYS_CONFIG_W) && (node->flags & LYS_MAND_TRUE)) {
+                node->flags &= ~LYS_MAND_TRUE;
+                lys_compile_mandatory_parents(target, 0);
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                        "Invalid augment adding mandatory node \"%s\" without making it conditional via when statement.", node->name);
+                ret = LY_EVALID;
+                goto cleanup;
+            }
+
+            if (aug_p->when) {
+                /* pass augment's when to all the children */
+                ret = lys_compile_when(ctx, aug_p->when, aug_p->flags, lysc_xpath_context(target), node, &when_shared);
+                LY_CHECK_GOTO(ret, cleanup);
+            }
+        }
+        ly_set_erase(&child_set, NULL);
+    }
+
+    switch (target->nodetype) {
+    case LYS_CONTAINER:
+        actions = &((struct lysc_node_container *)target)->actions;
+        notifs = &((struct lysc_node_container *)target)->notifs;
+        break;
+    case LYS_LIST:
+        actions = &((struct lysc_node_list *)target)->actions;
+        notifs = &((struct lysc_node_list *)target)->notifs;
+        break;
+    default:
+        actions = NULL;
+        notifs = NULL;
+        break;
+    }
+
+    if (aug_p->actions) {
+        if (!actions) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid augment of %s node which is not allowed to contain RPC/action node \"%s\".",
+                    lys_nodetype2str(target->nodetype), aug_p->actions[0].name);
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+
+        /* compile actions into the target */
+        COMPILE_OP_ARRAY_GOTO(ctx, aug_p->actions, *actions, target, u, lys_compile_action, 0, ret, cleanup);
+
+        if (aug_p->when) {
+            /* inherit when */
+            LY_ARRAY_FOR(*actions, u) {
+                ret = lys_compile_when(ctx, aug_p->when, aug_p->flags, lysc_xpath_context(target),
+                        (struct lysc_node *)&(*actions)[u], &when_shared);
+                LY_CHECK_GOTO(ret, cleanup);
+            }
+        }
+    }
+    if (aug_p->notifs) {
+        if (!notifs) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid augment of %s node which is not allowed to contain notification node \"%s\".",
+                    lys_nodetype2str(target->nodetype), aug_p->notifs[0].name);
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+
+        /* compile notifications into the target */
+        COMPILE_OP_ARRAY_GOTO(ctx, aug_p->notifs, *notifs, target, u, lys_compile_notif, 0, ret, cleanup);
+
+        if (aug_p->when) {
+            /* inherit when */
+            LY_ARRAY_FOR(*notifs, u) {
+                ret = lys_compile_when(ctx, aug_p->when, aug_p->flags, lysc_xpath_context(target),
+                        (struct lysc_node *)&(*notifs)[u], &when_shared);
+                LY_CHECK_GOTO(ret, cleanup);
+            }
+        }
+    }
+
+cleanup:
+    ly_set_erase(&child_set, NULL);
+    return ret;
+}
+
+LY_ERR
+lys_compile_node_augments(struct lysc_ctx *ctx, struct lysc_node *node)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lys_module *orig_mod = ctx->cur_mod;
+    struct lysp_module *orig_pmod = ctx->pmod;
+    uint32_t i;
+    char orig_path[LYSC_CTX_BUFSIZE];
+    struct lysc_augment *aug;
+
+    /* uses augments */
+    for (i = 0; i < ctx->uses_augs.count; ) {
+        aug = ctx->uses_augs.objs[i];
+
+        if (!lysp_schema_nodeid_match(aug->nodeid, aug->nodeid_pmod, aug->nodeid_ctx_node, node, NULL, NULL)) {
+            /* not our target node */
+            ++i;
+            continue;
+        }
+
+        /* apply augment, keep the current path and add to it */
+        lysc_update_path(ctx, NULL, "{augment}");
+        lysc_update_path(ctx, NULL, aug->aug_p->nodeid);
+        ret = lys_compile_augment(ctx, aug->aug_p, node);
+        lysc_update_path(ctx, NULL, NULL);
+        lysc_update_path(ctx, NULL, NULL);
+        LY_CHECK_GOTO(ret, cleanup);
+
+        /* augment was applied, remove it (index may have changed because other augments could have been applied) */
+        ly_set_rm(&ctx->uses_augs, aug, NULL);
+        lysc_augment_free(ctx->ctx, aug);
+    }
+
+    /* top-level augments */
+    for (i = 0; i < ctx->augs.count; ) {
+        aug = ctx->augs.objs[i];
+
+        if (!lysp_schema_nodeid_match(aug->nodeid, aug->nodeid_pmod, NULL, node, NULL, NULL)) {
+            /* not our target node */
+            ++i;
+            continue;
+        }
+
+        /* apply augment, use the path and modules from the augment */
+        strcpy(orig_path, ctx->path);
+        ctx->path_len = 1;
+        lysc_update_path(ctx, NULL, "{augment}");
+        lysc_update_path(ctx, NULL, aug->aug_p->nodeid);
+        ctx->cur_mod = aug->nodeid_pmod->mod;
+        ctx->pmod = (struct lysp_module *)aug->nodeid_pmod;
+        ret = lys_compile_augment(ctx, aug->aug_p, node);
+        strcpy(ctx->path, orig_path);
+        ctx->path_len = strlen(ctx->path);
+        LY_CHECK_GOTO(ret, cleanup);
+
+        /* augment was applied, remove it */
+        ly_set_rm(&ctx->augs, aug, NULL);
+        lysc_augment_free(ctx->ctx, aug);
+    }
+
+cleanup:
+    ctx->cur_mod = orig_mod;
+    ctx->pmod = orig_pmod;
+    return ret;
+}
+
+/**
+ * @brief Prepare a top-level augment to be applied during data nodes compilation.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] aug_p Parsed augment to be applied.
+ * @param[in] pmod Both current and prefix module for @p aug_p.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_precompile_own_augment(struct lysc_ctx *ctx, struct lysp_augment *aug_p, const struct lysp_module *pmod)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lyxp_expr *exp = NULL;
+    struct lysc_augment *aug;
+    const struct lys_module *mod;
+
+    /* parse its target, it was already parsed and fully checked (except for the existence of the nodes) */
+    ret = lyxp_expr_parse(ctx->ctx, aug_p->nodeid, strlen(aug_p->nodeid), 0, &exp);
+    LY_CHECK_GOTO(ret, cleanup);
+
+    mod = lys_schema_node_get_module(ctx->ctx, exp->expr + exp->tok_pos[1], exp->tok_len[1], pmod, NULL, NULL);
+    LY_CHECK_ERR_GOTO(!mod, LOGINT(ctx->ctx); ret = LY_EINT, cleanup);
+    if (mod != ctx->cur_mod) {
+        /* augment for another module, ignore */
+        goto cleanup;
+    }
+
+    /* allocate new compiled augment and store it in the set */
+    aug = calloc(1, sizeof *aug);
+    LY_CHECK_ERR_GOTO(!aug, LOGMEM(ctx->ctx); ret = LY_EMEM, cleanup);
+    LY_CHECK_GOTO(ret = ly_set_add(&ctx->augs, aug, 1, NULL), cleanup);
+
+    aug->nodeid = exp;
+    exp = NULL;
+    aug->nodeid_pmod = pmod;
+    aug->aug_p = aug_p;
+
+cleanup:
+    lyxp_expr_free(ctx->ctx, exp);
+    return ret;
+}
+
+LY_ERR
+lys_precompile_own_augments(struct lysc_ctx *ctx)
+{
+    LY_ARRAY_COUNT_TYPE u, v, w;
+    const struct lys_module *aug_mod;
+
+    LY_ARRAY_FOR(ctx->cur_mod->augmented_by, u) {
+        aug_mod = ctx->cur_mod->augmented_by[u];
+
+        /* collect all module augments */
+        LY_ARRAY_FOR(aug_mod->parsed->augments, v) {
+            LY_CHECK_RET(lys_precompile_own_augment(ctx, &aug_mod->parsed->augments[v], aug_mod->parsed));
+        }
+
+        /* collect all submodules augments */
+        LY_ARRAY_FOR(aug_mod->parsed->includes, v) {
+            LY_ARRAY_FOR(aug_mod->parsed->includes[v].submodule->augments, w) {
+                LY_CHECK_RET(lys_precompile_own_augment(ctx, &aug_mod->parsed->includes[v].submodule->augments[w],
+                        (struct lysp_module *)aug_mod->parsed->includes[v].submodule));
+            }
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Prepare a deviation to be applied during data nodes compilation.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] dev_p Parsed deviation to be applied.
+ * @param[in] pmod Both current and prefix module for @p dev_p.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_precompile_own_deviation(struct lysc_ctx *ctx, struct lysp_deviation *dev_p, const struct lysp_module *pmod)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lysc_deviation *dev = NULL;
+    struct lyxp_expr *exp = NULL;
+    struct lysp_deviation **new_dev;
+    const struct lys_module *mod;
+    const struct lysp_module **new_dev_pmod;
+    uint32_t i;
+
+    /* parse its target, it was already parsed and fully checked (except for the existence of the nodes) */
+    ret = lyxp_expr_parse(ctx->ctx, dev_p->nodeid, strlen(dev_p->nodeid), 0, &exp);
+    LY_CHECK_GOTO(ret, cleanup);
+
+    mod = lys_schema_node_get_module(ctx->ctx, exp->expr + exp->tok_pos[1], exp->tok_len[1], pmod, NULL, NULL);
+    LY_CHECK_ERR_GOTO(!mod, LOGINT(ctx->ctx); ret = LY_EINT, cleanup);
+    if (mod != ctx->cur_mod) {
+        /* deviation for another module, ignore */
+        goto cleanup;
+    }
+
+    /* try to find the node in already compiled deviations */
+    for (i = 0; i < ctx->devs.count; ++i) {
+        if (lys_abs_schema_nodeid_match(ctx->ctx, exp, pmod, ((struct lysc_deviation *)ctx->devs.objs[i])->nodeid,
+                ((struct lysc_deviation *)ctx->devs.objs[i])->dev_pmods[0])) {
+            dev = ctx->devs.objs[i];
+            break;
+        }
+    }
+
+    if (!dev) {
+        /* allocate new compiled deviation */
+        dev = calloc(1, sizeof *dev);
+        LY_CHECK_ERR_GOTO(!dev, LOGMEM(ctx->ctx); ret = LY_EMEM, cleanup);
+        LY_CHECK_GOTO(ret = ly_set_add(&ctx->devs, dev, 1, NULL), cleanup);
+
+        dev->nodeid = exp;
+        exp = NULL;
+    }
+
+    /* add new parsed deviation structure */
+    LY_ARRAY_NEW_GOTO(ctx->ctx, dev->devs, new_dev, ret, cleanup);
+    *new_dev = dev_p;
+    LY_ARRAY_NEW_GOTO(ctx->ctx, dev->dev_pmods, new_dev_pmod, ret, cleanup);
+    *new_dev_pmod = pmod;
+
+cleanup:
+    lyxp_expr_free(ctx->ctx, exp);
+    return ret;
+}
+
+LY_ERR
+lys_precompile_own_deviations(struct lysc_ctx *ctx)
+{
+    LY_ARRAY_COUNT_TYPE u, v, w;
+    const struct lys_module *dev_mod;
+    struct lysc_deviation *dev;
+    struct lysp_deviate *d;
+    int not_supported;
+    uint32_t i;
+
+    LY_ARRAY_FOR(ctx->cur_mod->deviated_by, u) {
+        dev_mod = ctx->cur_mod->deviated_by[u];
+
+        /* compile all module deviations */
+        LY_ARRAY_FOR(dev_mod->parsed->deviations, v) {
+            LY_CHECK_RET(lys_precompile_own_deviation(ctx, &dev_mod->parsed->deviations[v], dev_mod->parsed));
+        }
+
+        /* compile all submodules deviations */
+        LY_ARRAY_FOR(dev_mod->parsed->includes, v) {
+            LY_ARRAY_FOR(dev_mod->parsed->includes[v].submodule->deviations, w) {
+                LY_CHECK_RET(lys_precompile_own_deviation(ctx, &dev_mod->parsed->includes[v].submodule->deviations[w],
+                        (struct lysp_module *)dev_mod->parsed->includes[v].submodule));
+            }
+        }
+    }
+
+    /* set not-supported flags for all the deviations */
+    for (i = 0; i < ctx->devs.count; ++i) {
+        dev = ctx->devs.objs[i];
+        not_supported = 0;
+
+        LY_ARRAY_FOR(dev->devs, u) {
+            LY_LIST_FOR(dev->devs[u]->deviates, d) {
+                if (d->mod == LYS_DEV_NOT_SUPPORTED) {
+                    not_supported = 1;
+                    break;
+                }
+            }
+            if (not_supported) {
+                break;
+            }
+        }
+        if (not_supported && (LY_ARRAY_COUNT(dev->devs) > 1)) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                    "Multiple deviations of \"%s\" with one of them being \"not-supported\".", dev->nodeid->expr);
+            return LY_EVALID;
+        }
+
+        dev->not_supported = not_supported;
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Add a module reference into an array, checks for duplicities.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] mod Module reference to add.
+ * @param[in,out] mod_array Module sized array to add to.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_array_add_mod_ref(struct lysc_ctx *ctx, struct lys_module *mod, struct lys_module ***mod_array)
+{
+    LY_ARRAY_COUNT_TYPE u;
+    struct lys_module **new_mod;
+
+    LY_ARRAY_FOR(*mod_array, u) {
+        if ((*mod_array)[u] == mod) {
+            /* already there */
+            return LY_EEXIST;
+        }
+    }
+
+    /* add the new module ref */
+    LY_ARRAY_NEW_RET(ctx->ctx, *mod_array, new_mod, LY_EMEM);
+    *new_mod = mod;
+
+    return LY_SUCCESS;
+}
+
+LY_ERR
+lys_precompile_augments_deviations(struct lysc_ctx *ctx)
+{
+    LY_ERR ret = LY_SUCCESS;
+    LY_ARRAY_COUNT_TYPE u, v;
+    const struct lysp_module *mod_p;
+    const struct lysc_node *target;
+    struct lys_module *mod;
+    struct lysp_submodule *submod;
+    ly_bool has_dev = 0;
+    uint16_t flags;
+    uint32_t idx, opt_prev = ctx->options;
+
+    for (idx = 0; idx < ctx->ctx->implementing.count; ++idx) {
+        if (ctx->cur_mod == ctx->ctx->implementing.objs[idx]) {
+            break;
+        }
+    }
+    if (idx == ctx->ctx->implementing.count) {
+        /* it was already implemented and all the augments and deviations fully applied */
+        return LY_SUCCESS;
+    }
+
+    mod_p = ctx->cur_mod->parsed;
+
+    LY_ARRAY_FOR(mod_p->augments, u) {
+        lysc_update_path(ctx, NULL, "{augment}");
+        lysc_update_path(ctx, NULL, mod_p->augments[u].nodeid);
+
+        /* get target module */
+        ret = lys_nodeid_check(ctx, mod_p->augments[u].nodeid, 1, &mod, NULL);
+        LY_CHECK_RET(ret);
+
+        /* add this module into the target module augmented_by, if not there already from previous augments */
+        lys_array_add_mod_ref(ctx, ctx->cur_mod, &mod->augmented_by);
+
+        /* if we are compiling this module, we cannot add augments to it yet */
+        if (mod != ctx->cur_mod) {
+            /* apply the augment, find the target node first */
+            flags = 0;
+            ret = lysc_resolve_schema_nodeid(ctx, mod_p->augments[u].nodeid, 0, NULL, ctx->cur_mod, LY_PREF_SCHEMA,
+                    (void *)mod_p, 0, &target, &flags);
+            LY_CHECK_RET(ret);
+
+            /* apply the augment */
+            ctx->options |= flags;
+            ret = lys_compile_augment(ctx, &mod_p->augments[u], (struct lysc_node *)target);
+            ctx->options = opt_prev;
+            LY_CHECK_RET(ret);
+        }
+
+        lysc_update_path(ctx, NULL, NULL);
+        lysc_update_path(ctx, NULL, NULL);
+    }
+
+    LY_ARRAY_FOR(mod_p->deviations, u) {
+        /* get target module */
+        lysc_update_path(ctx, NULL, "{deviation}");
+        lysc_update_path(ctx, NULL, mod_p->deviations[u].nodeid);
+        ret = lys_nodeid_check(ctx, mod_p->deviations[u].nodeid, 1, &mod, NULL);
+        lysc_update_path(ctx, NULL, NULL);
+        lysc_update_path(ctx, NULL, NULL);
+        LY_CHECK_RET(ret);
+
+        /* add this module into the target module deviated_by, if not there already from previous deviations */
+        lys_array_add_mod_ref(ctx, ctx->cur_mod, &mod->deviated_by);
+
+        /* new deviation added to the target module */
+        has_dev = 1;
+    }
+
+    /* the same for augments and deviations in submodules */
+    LY_ARRAY_FOR(mod_p->includes, v) {
+        submod = mod_p->includes[v].submodule;
+        LY_ARRAY_FOR(submod->augments, u) {
+            lysc_update_path(ctx, NULL, "{augment}");
+            lysc_update_path(ctx, NULL, submod->augments[u].nodeid);
+
+            ret = lys_nodeid_check(ctx, submod->augments[u].nodeid, 1, &mod, NULL);
+            LY_CHECK_RET(ret);
+
+            lys_array_add_mod_ref(ctx, ctx->cur_mod, &mod->augmented_by);
+            if (mod != ctx->cur_mod) {
+                flags = 0;
+                ret = lysc_resolve_schema_nodeid(ctx, mod_p->augments[u].nodeid, 0, NULL, ctx->cur_mod, LY_PREF_SCHEMA,
+                        submod, 0, &target, &flags);
+                LY_CHECK_RET(ret);
+
+                ctx->options |= flags;
+                ret = lys_compile_augment(ctx, &submod->augments[u], (struct lysc_node *)target);
+                ctx->options = opt_prev;
+                LY_CHECK_RET(ret);
+            }
+
+            lysc_update_path(ctx, NULL, NULL);
+            lysc_update_path(ctx, NULL, NULL);
+        }
+
+        LY_ARRAY_FOR(submod->deviations, u) {
+            lysc_update_path(ctx, NULL, "{deviation}");
+            lysc_update_path(ctx, NULL, submod->deviations[u].nodeid);
+            ret = lys_nodeid_check(ctx, submod->deviations[u].nodeid, 1, &mod, NULL);
+            lysc_update_path(ctx, NULL, NULL);
+            lysc_update_path(ctx, NULL, NULL);
+            LY_CHECK_RET(ret);
+
+            lys_array_add_mod_ref(ctx, ctx->cur_mod, &mod->deviated_by);
+            has_dev = 1;
+        }
+    }
+
+    if (!has_dev) {
+        /* no need to recompile any modules */
+        return LY_SUCCESS;
+    }
+
+    /* free all the modules in descending order */
+    idx = ctx->ctx->list.count;
+    do {
+        --idx;
+        mod = ctx->ctx->list.objs[idx];
+        /* skip this module */
+        if (mod == mod_p->mod) {
+            continue;
+        }
+
+        if (mod->implemented && mod->compiled) {
+            /* keep information about features state in the module */
+            lys_feature_precompile_revert(ctx, mod);
+
+            /* free the module */
+            lysc_module_free(mod->compiled, NULL);
+            mod->compiled = NULL;
+        }
+    } while (idx);
+
+    /* recompile all the modules in ascending order */
+    for (idx = 0; idx < ctx->ctx->list.count; ++idx) {
+        mod = ctx->ctx->list.objs[idx];
+
+        /* skip this module */
+        if (mod == mod_p->mod) {
+            continue;
+        }
+
+        if (mod->implemented) {
+            /* compile */
+            LY_CHECK_GOTO(ret = lys_compile(mod, 0), cleanup);
+        }
+    }
+
+cleanup:
+    return ret;
+}
+
+void
+lys_precompile_augments_deviations_revert(struct ly_ctx *ctx, const struct lys_module *mod)
+{
+    uint32_t i;
+    LY_ARRAY_COUNT_TYPE u, count;
+    struct lys_module *m;
+
+    for (i = 0; i < ctx->list.count; ++i) {
+        m = ctx->list.objs[i];
+
+        if (m->augmented_by) {
+            count = LY_ARRAY_COUNT(m->augmented_by);
+            for (u = 0; u < count; ++u) {
+                if (m->augmented_by[u] == mod) {
+                    /* keep the order */
+                    if (u < count - 1) {
+                        memmove(m->augmented_by + u, m->augmented_by + u + 1, (count - u) * sizeof *m->augmented_by);
+                    }
+                    LY_ARRAY_DECREMENT(m->augmented_by);
+                    break;
+                }
+            }
+            if (!LY_ARRAY_COUNT(m->augmented_by)) {
+                LY_ARRAY_FREE(m->augmented_by);
+                m->augmented_by = NULL;
+            }
+        }
+
+        if (m->deviated_by) {
+            count = LY_ARRAY_COUNT(m->deviated_by);
+            for (u = 0; u < count; ++u) {
+                if (m->deviated_by[u] == mod) {
+                    /* keep the order */
+                    if (u < count - 1) {
+                        memmove(m->deviated_by + u, m->deviated_by + u + 1, (count - u) * sizeof *m->deviated_by);
+                    }
+                    LY_ARRAY_DECREMENT(m->deviated_by);
+                    break;
+                }
+            }
+            if (!LY_ARRAY_COUNT(m->deviated_by)) {
+                LY_ARRAY_FREE(m->deviated_by);
+                m->deviated_by = NULL;
+            }
+        }
+    }
+}
diff --git a/src/schema_compile_amend.h b/src/schema_compile_amend.h
new file mode 100644
index 0000000..97d3cd0
--- /dev/null
+++ b/src/schema_compile_amend.h
@@ -0,0 +1,176 @@
+/**
+ * @file schema_compile_amend.h
+ * @author Radek Krejci <rkrejci@cesnet.cz>
+ * @brief Header for schema compilation of augments, deviations, and refines.
+ *
+ * Copyright (c) 2015 - 2020 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
+ */
+
+#ifndef LY_SCHEMA_COMPILE_AMEND_H_
+#define LY_SCHEMA_COMPILE_AMEND_H_
+
+#include "log.h"
+
+struct lysp_qname;
+struct lysc_augment;
+struct lysc_deviation;
+struct lysc_refine;
+struct lysp_node;
+struct lysc_node;
+struct lysc_ctx;
+struct lysp_node_uses;
+struct lys_module;
+
+/**
+ * @brief Compiled parsed augment structure. Just a temporary storage for applying the augment to data.
+ */
+struct lysc_augment {
+    struct lyxp_expr *nodeid;                    /**< augment target */
+    const struct lysp_module *nodeid_pmod;       /**< module where the nodeid is defined, used to resolve prefixes */
+    const struct lysc_node *nodeid_ctx_node;     /**< nodeid context node for relative targets */
+
+    struct lysp_augment *aug_p;                  /**< pointer to the parsed augment to apply */
+};
+
+/**
+ * @brief Compiled parsed deviation structure. Just a temporary storage for applying the deviation to data.
+ */
+struct lysc_deviation {
+    struct lyxp_expr *nodeid;                    /**< deviation target, taken from the first deviation in
+                                                      ::lysc_deviation.dev_pmods array, this module is used for resolving
+                                                      prefixes used in the nodeid. */
+
+    struct lysp_deviation **devs;                /**< sized array of all the parsed deviations for one target node */
+    const struct lysp_module **dev_pmods;        /**< sized array of parsed modules of @p devs (where the specific deviations
+                                                      are defined). */
+    ly_bool not_supported;                       /**< whether this is a not-supported deviation */
+};
+
+/**
+ * @brief Compiled parsed refine structure. Just a temporary storage for applying the refine to data.
+ */
+struct lysc_refine {
+    struct lyxp_expr *nodeid;                    /**< refine target */
+    const struct lysp_module *nodeid_pmod;       /**< module where the nodeid is defined, used to resolve prefixes */
+    const struct lysc_node *nodeid_ctx_node;     /**< nodeid context node */
+
+    struct lysp_refine **rfns;                   /**< sized array of parsed refines to apply */
+};
+
+/**
+ * @brief Prepare any uses augments and refines in the context to be applied during uses descendant node compilation.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] uses_p Parsed uses structure with augments and refines.
+ * @param[in] ctx_node Context node of @p uses_p meaning its first data definiition parent.
+ * @return LY_ERR value.
+ */
+LY_ERR lys_precompile_uses_augments_refines(struct lysc_ctx *ctx, struct lysp_node_uses *uses_p,
+        const struct lysc_node *ctx_node);
+
+/**
+ * @brief Duplicate qname structure.
+ *
+ * @param[in] ctx libyang context.
+ * @param[in,out] qname Structure to fill.
+ * @param[in] orig_qname Structure to read from.
+ * @return LY_ERR value.
+ */
+LY_ERR lysp_qname_dup(const struct ly_ctx *ctx, struct lysp_qname *qname, const struct lysp_qname *orig_qname);
+
+/**
+ * @brief Free a compiled augment temporary structure.
+ *
+ * @param[in] ctx libyang context.
+ * @param[in] aug Structure to free.
+ */
+void lysc_augment_free(const struct ly_ctx *ctx, struct lysc_augment *aug);
+
+/**
+ * @brief Free a compiled deviation temporary structure.
+ *
+ * @param[in] ctx libyang context.
+ * @param[in] dev Structure to free.
+ */
+void lysc_deviation_free(const struct ly_ctx *ctx, struct lysc_deviation *dev);
+
+/**
+ * @brief Free a compiled refine temporary structure.
+ *
+ * @param[in] ctx libyang context.
+ * @param[in] rfn Structure to free.
+ */
+void lysc_refine_free(const struct ly_ctx *ctx, struct lysc_refine *rfn);
+
+/**
+ * @brief Free a duplicate of parsed node. It is returned by ::lys_compile_node_deviations_refines().
+ *
+ * @param[in] ctx libyang context.
+ * @param[in] dev_pnode Parsed node to free.
+ */
+void lysp_dev_node_free(const struct ly_ctx *ctx, struct lysp_node *dev_pnode);
+
+/**
+ * @brief Compile and apply any precompiled deviations and refines targetting a node.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] pnode Parsed node to consider.
+ * @param[in] parent First compiled parent of @p pnode.
+ * @param[out] dev_pnode Copy of parsed node @p pnode with deviations and refines, if any. NULL if there are none.
+ * @param[out] no_supported Whether a not-supported deviation is defined for the node.
+ * @return LY_ERR value.
+ */
+LY_ERR lys_compile_node_deviations_refines(struct lysc_ctx *ctx, const struct lysp_node *pnode,
+        const struct lysc_node *parent, struct lysp_node **dev_pnode, ly_bool *not_supported);
+
+/**
+ * @brief Compile and apply any precompiled top-level or uses augments targetting a node.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] node Compiled node to consider.
+ * @return LY_ERR value.
+ */
+LY_ERR lys_compile_node_augments(struct lysc_ctx *ctx, struct lysc_node *node);
+
+/**
+ * @brief Prepare all top-level augments for the current module to be applied during data nodes compilation.
+ *
+ * @param[in] ctx Compile context.
+ * @return LY_ERR value.
+ */
+LY_ERR lys_precompile_own_augments(struct lysc_ctx *ctx);
+
+/**
+ * @brief Prepare all deviations for the current module to be applied during data nodes compilation.
+ *
+ * @param[in] ctx Compile context.
+ * @return LY_ERR value.
+ */
+LY_ERR lys_precompile_own_deviations(struct lysc_ctx *ctx);
+
+/**
+ * @brief Compile top-level augments and deviations defined in the current module.
+ * Generally, just add the module refence to the target modules. But in case
+ * of foreign augments, they are directly applied.
+ *
+ * @param[in] ctx Compile context.
+ * @return LY_ERR value.
+ */
+LY_ERR lys_precompile_augments_deviations(struct lysc_ctx *ctx);
+
+/**
+ * @brief Revert precompilation of module augments and deviations. Meaning remove its reference from
+ * all the target modules.
+ *
+ * @param[in] ctx libyang context.
+ * @param[in] mod Mod whose precompilation to revert.
+ */
+void lys_precompile_augments_deviations_revert(struct ly_ctx *ctx, const struct lys_module *mod);
+
+#endif /* LY_SCHEMA_COMPILE_AMEND_H_ */
diff --git a/src/schema_compile_node.c b/src/schema_compile_node.c
new file mode 100644
index 0000000..de343d7
--- /dev/null
+++ b/src/schema_compile_node.c
@@ -0,0 +1,3742 @@
+/**
+ * @file schema_compile_node.c
+ * @author Radek Krejci <rkrejci@cesnet.cz>
+ * @brief Schema compilation of common nodes.
+ *
+ * Copyright (c) 2015 - 2020 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
+ */
+
+#define _GNU_SOURCE
+
+#include "schema_compile_node.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+#include "compat.h"
+#include "context.h"
+#include "dict.h"
+#include "log.h"
+#include "parser.h"
+#include "parser_schema.h"
+#include "path.h"
+#include "plugins_exts.h"
+#include "plugins_exts_internal.h"
+#include "plugins_types.h"
+#include "schema_compile.h"
+#include "schema_compile_amend.h"
+#include "set.h"
+#include "tree.h"
+#include "tree_data.h"
+#include "tree_data_internal.h"
+#include "tree_schema.h"
+#include "tree_schema_internal.h"
+#include "xpath.h"
+
+static struct lysc_ext_instance *
+lysc_ext_instance_dup(struct ly_ctx *ctx, struct lysc_ext_instance *orig)
+{
+    /* TODO - extensions, increase refcount */
+    (void) ctx;
+    (void) orig;
+    return NULL;
+}
+
+/**
+ * @brief Add/replace a leaf default value in unres.
+ * Can also be used for a single leaf-list default value.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] leaf Leaf with the default value.
+ * @param[in] dflt Default value to use.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lysc_unres_leaf_dflt_add(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf, struct lysp_qname *dflt)
+{
+    struct lysc_unres_dflt *r = NULL;
+    uint32_t i;
+
+    for (i = 0; i < ctx->dflts.count; ++i) {
+        if (((struct lysc_unres_dflt *)ctx->dflts.objs[i])->leaf == leaf) {
+            /* just replace the default */
+            r = ctx->dflts.objs[i];
+            lysp_qname_free(ctx->ctx, r->dflt);
+            free(r->dflt);
+            break;
+        }
+    }
+    if (!r) {
+        /* add new unres item */
+        r = calloc(1, sizeof *r);
+        LY_CHECK_ERR_RET(!r, LOGMEM(ctx->ctx), LY_EMEM);
+        r->leaf = leaf;
+
+        LY_CHECK_RET(ly_set_add(&ctx->dflts, r, 1, NULL));
+    }
+
+    r->dflt = malloc(sizeof *r->dflt);
+    LY_CHECK_GOTO(!r->dflt, error);
+    LY_CHECK_GOTO(lysp_qname_dup(ctx->ctx, r->dflt, dflt), error);
+
+    return LY_SUCCESS;
+
+error:
+    free(r->dflt);
+    LOGMEM(ctx->ctx);
+    return LY_EMEM;
+}
+
+/**
+ * @brief Add/replace a leaf-list default value(s) in unres.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] llist Leaf-list with the default value.
+ * @param[in] dflts Sized array of the default values.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lysc_unres_llist_dflts_add(struct lysc_ctx *ctx, struct lysc_node_leaflist *llist, struct lysp_qname *dflts)
+{
+    struct lysc_unres_dflt *r = NULL;
+    uint32_t i;
+
+    for (i = 0; i < ctx->dflts.count; ++i) {
+        if (((struct lysc_unres_dflt *)ctx->dflts.objs[i])->llist == llist) {
+            /* just replace the defaults */
+            r = ctx->dflts.objs[i];
+            lysp_qname_free(ctx->ctx, r->dflt);
+            free(r->dflt);
+            r->dflt = NULL;
+            FREE_ARRAY(ctx->ctx, r->dflts, lysp_qname_free);
+            r->dflts = NULL;
+            break;
+        }
+    }
+    if (!r) {
+        r = calloc(1, sizeof *r);
+        LY_CHECK_ERR_RET(!r, LOGMEM(ctx->ctx), LY_EMEM);
+        r->llist = llist;
+
+        LY_CHECK_RET(ly_set_add(&ctx->dflts, r, 1, NULL));
+    }
+
+    DUP_ARRAY(ctx->ctx, dflts, r->dflts, lysp_qname_dup);
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Duplicate the compiled pattern structure.
+ *
+ * Instead of duplicating memory, the reference counter in the @p orig is increased.
+ *
+ * @param[in] orig The pattern structure to duplicate.
+ * @return The duplicated structure to use.
+ */
+static struct lysc_pattern *
+lysc_pattern_dup(struct lysc_pattern *orig)
+{
+    ++orig->refcount;
+    return orig;
+}
+
+/**
+ * @brief Duplicate the array of compiled patterns.
+ *
+ * The sized array itself is duplicated, but the pattern structures are just shadowed by increasing their reference counter.
+ *
+ * @param[in] ctx Libyang context for logging.
+ * @param[in] orig The patterns sized array to duplicate.
+ * @return New sized array as a copy of @p orig.
+ * @return NULL in case of memory allocation error.
+ */
+static struct lysc_pattern **
+lysc_patterns_dup(struct ly_ctx *ctx, struct lysc_pattern **orig)
+{
+    struct lysc_pattern **dup = NULL;
+    LY_ARRAY_COUNT_TYPE u;
+
+    assert(orig);
+
+    LY_ARRAY_CREATE_RET(ctx, dup, LY_ARRAY_COUNT(orig), NULL);
+    LY_ARRAY_FOR(orig, u) {
+        dup[u] = lysc_pattern_dup(orig[u]);
+        LY_ARRAY_INCREMENT(dup);
+    }
+    return dup;
+}
+
+/**
+ * @brief Duplicate compiled range structure.
+ *
+ * @param[in] ctx Libyang context for logging.
+ * @param[in] orig The range structure to be duplicated.
+ * @return New compiled range structure as a copy of @p orig.
+ * @return NULL in case of memory allocation error.
+ */
+static struct lysc_range *
+lysc_range_dup(struct ly_ctx *ctx, const struct lysc_range *orig)
+{
+    struct lysc_range *dup;
+    LY_ERR ret;
+
+    assert(orig);
+
+    dup = calloc(1, sizeof *dup);
+    LY_CHECK_ERR_RET(!dup, LOGMEM(ctx), NULL);
+    if (orig->parts) {
+        LY_ARRAY_CREATE_GOTO(ctx, dup->parts, LY_ARRAY_COUNT(orig->parts), ret, cleanup);
+        LY_ARRAY_COUNT(dup->parts) = LY_ARRAY_COUNT(orig->parts);
+        memcpy(dup->parts, orig->parts, LY_ARRAY_COUNT(dup->parts) * sizeof *dup->parts);
+    }
+    DUP_STRING_GOTO(ctx, orig->eapptag, dup->eapptag, ret, cleanup);
+    DUP_STRING_GOTO(ctx, orig->emsg, dup->emsg, ret, cleanup);
+    dup->exts = lysc_ext_instance_dup(ctx, orig->exts);
+
+    return dup;
+cleanup:
+    free(dup);
+    (void) ret; /* set but not used due to the return type */
+    return NULL;
+}
+
+struct lysc_node *
+lysc_xpath_context(struct lysc_node *start)
+{
+    for (; start && !(start->nodetype & (LYS_CONTAINER | LYS_LEAF | LYS_LEAFLIST | LYS_LIST | LYS_ANYDATA | LYS_RPC | LYS_ACTION | LYS_NOTIF));
+            start = start->parent) {}
+    return start;
+}
+
+/**
+ * @brief Compile information from the when statement
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] when_p Parsed when structure.
+ * @param[in] flags Flags of the parsed node with the when statement.
+ * @param[in] ctx_node Context node for the when statement.
+ * @param[out] when Pointer where to store pointer to the created compiled when structure.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_when_(struct lysc_ctx *ctx, struct lysp_when *when_p, uint16_t flags, const struct lysc_node *ctx_node,
+        struct lysc_when **when)
+{
+    LY_ERR ret = LY_SUCCESS;
+
+    *when = calloc(1, sizeof **when);
+    LY_CHECK_ERR_RET(!(*when), LOGMEM(ctx->ctx), LY_EMEM);
+    (*when)->refcount = 1;
+    LY_CHECK_RET(lyxp_expr_parse(ctx->ctx, when_p->cond, 0, 1, &(*when)->cond));
+    LY_CHECK_RET(lysc_prefixes_compile(when_p->cond, strlen(when_p->cond), ctx->pmod, &(*when)->prefixes));
+    (*when)->context = (struct lysc_node *)ctx_node;
+    DUP_STRING_GOTO(ctx->ctx, when_p->dsc, (*when)->dsc, ret, done);
+    DUP_STRING_GOTO(ctx->ctx, when_p->ref, (*when)->ref, ret, done);
+    COMPILE_EXTS_GOTO(ctx, when_p->exts, (*when)->exts, (*when), LYEXT_PAR_WHEN, ret, done);
+    (*when)->flags = flags & LYS_STATUS_MASK;
+
+done:
+    return ret;
+}
+
+LY_ERR
+lys_compile_when(struct lysc_ctx *ctx, struct lysp_when *when_p, uint16_t flags, const struct lysc_node *ctx_node,
+        struct lysc_node *node, struct lysc_when **when_c)
+{
+    struct lysc_when **new_when, ***node_when;
+
+    assert(when_p);
+
+    /* get the when array */
+    if (node->nodetype & LYS_ACTION) {
+        node_when = &((struct lysc_action *)node)->when;
+    } else if (node->nodetype == LYS_NOTIF) {
+        node_when = &((struct lysc_notif *)node)->when;
+    } else {
+        node_when = &node->when;
+    }
+
+    /* create new when pointer */
+    LY_ARRAY_NEW_RET(ctx->ctx, *node_when, new_when, LY_EMEM);
+    if (!when_c || !(*when_c)) {
+        /* compile when */
+        LY_CHECK_RET(lys_compile_when_(ctx, when_p, flags, ctx_node, new_when));
+
+        if (!(ctx->options & LYS_COMPILE_GROUPING)) {
+            /* do not check "when" semantics in a grouping */
+            LY_CHECK_RET(ly_set_add(&ctx->xpath, node, 0, NULL));
+        }
+
+        /* remember the compiled when for sharing */
+        if (when_c) {
+            *when_c = *new_when;
+        }
+    } else {
+        /* use the previously compiled when */
+        ++(*when_c)->refcount;
+        *new_when = *when_c;
+
+        if (!(ctx->options & LYS_COMPILE_GROUPING)) {
+            /* in this case check "when" again for all children because of dummy node check */
+            LY_CHECK_RET(ly_set_add(&ctx->xpath, node, 0, NULL));
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Compile information from the must statement
+ * @param[in] ctx Compile context.
+ * @param[in] must_p The parsed must statement structure.
+ * @param[in,out] must Prepared (empty) compiled must structure to fill.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_must(struct lysc_ctx *ctx, struct lysp_restr *must_p, struct lysc_must *must)
+{
+    LY_ERR ret = LY_SUCCESS;
+
+    LY_CHECK_RET(lyxp_expr_parse(ctx->ctx, must_p->arg.str, 0, 1, &must->cond));
+    LY_CHECK_RET(lysc_prefixes_compile(must_p->arg.str, strlen(must_p->arg.str), must_p->arg.mod, &must->prefixes));
+    DUP_STRING_GOTO(ctx->ctx, must_p->eapptag, must->eapptag, ret, done);
+    DUP_STRING_GOTO(ctx->ctx, must_p->emsg, must->emsg, ret, done);
+    DUP_STRING_GOTO(ctx->ctx, must_p->dsc, must->dsc, ret, done);
+    DUP_STRING_GOTO(ctx->ctx, must_p->ref, must->ref, ret, done);
+    COMPILE_EXTS_GOTO(ctx, must_p->exts, must->exts, must, LYEXT_PAR_MUST, ret, done);
+
+done:
+    return ret;
+}
+
+/**
+ * @brief Validate and normalize numeric value from a range definition.
+ * @param[in] ctx Compile context.
+ * @param[in] basetype Base YANG built-in type of the node connected with the range restriction. Actually only LY_TYPE_DEC64 is important to
+ * allow processing of the fractions. The fraction point is extracted from the value which is then normalize according to given frdigits into
+ * valcopy to allow easy parsing and storing of the value. libyang stores decimal number without the decimal point which is always recovered from
+ * the known fraction-digits value. So, with fraction-digits 2, number 3.14 is stored as 314 and number 1 is stored as 100.
+ * @param[in] frdigits The fraction-digits of the type in case of LY_TYPE_DEC64.
+ * @param[in] value String value of the range boundary.
+ * @param[out] len Number of the processed bytes from the value. Processing stops on the first character which is not part of the number boundary.
+ * @param[out] valcopy NULL-terminated string with the numeric value to parse and store.
+ * @return LY_ERR value - LY_SUCCESS, LY_EMEM, LY_EVALID (no number) or LY_EINVAL (decimal64 not matching fraction-digits value).
+ */
+static LY_ERR
+range_part_check_value_syntax(struct lysc_ctx *ctx, LY_DATA_TYPE basetype, uint8_t frdigits, const char *value,
+        size_t *len, char **valcopy)
+{
+    size_t fraction = 0, size;
+
+    *len = 0;
+
+    assert(value);
+    /* parse value */
+    if (!isdigit(value[*len]) && (value[*len] != '-') && (value[*len] != '+')) {
+        return LY_EVALID;
+    }
+
+    if ((value[*len] == '-') || (value[*len] == '+')) {
+        ++(*len);
+    }
+
+    while (isdigit(value[*len])) {
+        ++(*len);
+    }
+
+    if ((basetype != LY_TYPE_DEC64) || (value[*len] != '.') || !isdigit(value[*len + 1])) {
+        if (basetype == LY_TYPE_DEC64) {
+            goto decimal;
+        } else {
+            *valcopy = strndup(value, *len);
+            return LY_SUCCESS;
+        }
+    }
+    fraction = *len;
+
+    ++(*len);
+    while (isdigit(value[*len])) {
+        ++(*len);
+    }
+
+    if (basetype == LY_TYPE_DEC64) {
+decimal:
+        assert(frdigits);
+        if (fraction && (*len - 1 - fraction > frdigits)) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                    "Range boundary \"%.*s\" of decimal64 type exceeds defined number (%u) of fraction digits.",
+                    *len, value, frdigits);
+            return LY_EINVAL;
+        }
+        if (fraction) {
+            size = (*len) + (frdigits - ((*len) - 1 - fraction));
+        } else {
+            size = (*len) + frdigits + 1;
+        }
+        *valcopy = malloc(size * sizeof **valcopy);
+        LY_CHECK_ERR_RET(!(*valcopy), LOGMEM(ctx->ctx), LY_EMEM);
+
+        (*valcopy)[size - 1] = '\0';
+        if (fraction) {
+            memcpy(&(*valcopy)[0], &value[0], fraction);
+            memcpy(&(*valcopy)[fraction], &value[fraction + 1], (*len) - 1 - (fraction));
+            memset(&(*valcopy)[(*len) - 1], '0', frdigits - ((*len) - 1 - fraction));
+        } else {
+            memcpy(&(*valcopy)[0], &value[0], *len);
+            memset(&(*valcopy)[*len], '0', frdigits);
+        }
+    }
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Check that values in range are in ascendant order.
+ * @param[in] unsigned_value Flag to note that we are working with unsigned values.
+ * @param[in] max Flag to distinguish if checking min or max value. min value must be strictly higher than previous,
+ * max can be also equal.
+ * @param[in] value Current value to check.
+ * @param[in] prev_value The last seen value.
+ * @return LY_SUCCESS or LY_EEXIST for invalid order.
+ */
+static LY_ERR
+range_part_check_ascendancy(ly_bool unsigned_value, ly_bool max, int64_t value, int64_t prev_value)
+{
+    if (unsigned_value) {
+        if ((max && ((uint64_t)prev_value > (uint64_t)value)) || (!max && ((uint64_t)prev_value >= (uint64_t)value))) {
+            return LY_EEXIST;
+        }
+    } else {
+        if ((max && (prev_value > value)) || (!max && (prev_value >= value))) {
+            return LY_EEXIST;
+        }
+    }
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Set min/max value of the range part.
+ * @param[in] ctx Compile context.
+ * @param[in] part Range part structure to fill.
+ * @param[in] max Flag to distinguish if storing min or max value.
+ * @param[in] prev The last seen value to check that all values in range are specified in ascendant order.
+ * @param[in] basetype Type of the value to get know implicit min/max values and other checking rules.
+ * @param[in] first Flag for the first value of the range to avoid ascendancy order.
+ * @param[in] length_restr Flag to distinguish between range and length restrictions. Only for logging.
+ * @param[in] frdigits The fraction-digits value in case of LY_TYPE_DEC64 basetype.
+ * @param[in] base_range Range from the type from which the current type is derived (if not built-in) to get type's min and max values.
+ * @param[in,out] value Numeric range value to be stored, if not provided the type's min/max value is set.
+ * @return LY_ERR value - LY_SUCCESS, LY_EDENIED (value brokes type's boundaries), LY_EVALID (not a number),
+ * LY_EEXIST (value is smaller than the previous one), LY_EINVAL (decimal64 value does not corresponds with the
+ * frdigits value), LY_EMEM.
+ */
+static LY_ERR
+range_part_minmax(struct lysc_ctx *ctx, struct lysc_range_part *part, ly_bool max, int64_t prev, LY_DATA_TYPE basetype,
+        ly_bool first, ly_bool length_restr, uint8_t frdigits, struct lysc_range *base_range, const char **value)
+{
+    LY_ERR ret = LY_SUCCESS;
+    char *valcopy = NULL;
+    size_t len;
+
+    if (value) {
+        ret = range_part_check_value_syntax(ctx, basetype, frdigits, *value, &len, &valcopy);
+        LY_CHECK_GOTO(ret, finalize);
+    }
+    if (!valcopy && base_range) {
+        if (max) {
+            part->max_64 = base_range->parts[LY_ARRAY_COUNT(base_range->parts) - 1].max_64;
+        } else {
+            part->min_64 = base_range->parts[0].min_64;
+        }
+        if (!first) {
+            ret = range_part_check_ascendancy(basetype <= LY_TYPE_STRING ? 1 : 0, max, max ? part->max_64 : part->min_64, prev);
+        }
+        goto finalize;
+    }
+
+    switch (basetype) {
+    case LY_TYPE_INT8: /* range */
+        if (valcopy) {
+            ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-128), INT64_C(127), 10, max ? &part->max_64 : &part->min_64);
+        } else if (max) {
+            part->max_64 = INT64_C(127);
+        } else {
+            part->min_64 = INT64_C(-128);
+        }
+        if (!ret && !first) {
+            ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
+        }
+        break;
+    case LY_TYPE_INT16: /* range */
+        if (valcopy) {
+            ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-32768), INT64_C(32767), 10, max ? &part->max_64 : &part->min_64);
+        } else if (max) {
+            part->max_64 = INT64_C(32767);
+        } else {
+            part->min_64 = INT64_C(-32768);
+        }
+        if (!ret && !first) {
+            ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
+        }
+        break;
+    case LY_TYPE_INT32: /* range */
+        if (valcopy) {
+            ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-2147483648), INT64_C(2147483647), 10, max ? &part->max_64 : &part->min_64);
+        } else if (max) {
+            part->max_64 = INT64_C(2147483647);
+        } else {
+            part->min_64 = INT64_C(-2147483648);
+        }
+        if (!ret && !first) {
+            ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
+        }
+        break;
+    case LY_TYPE_INT64: /* range */
+    case LY_TYPE_DEC64: /* range */
+        if (valcopy) {
+            ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-9223372036854775807) - INT64_C(1), INT64_C(9223372036854775807), 10,
+                    max ? &part->max_64 : &part->min_64);
+        } else if (max) {
+            part->max_64 = INT64_C(9223372036854775807);
+        } else {
+            part->min_64 = INT64_C(-9223372036854775807) - INT64_C(1);
+        }
+        if (!ret && !first) {
+            ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
+        }
+        break;
+    case LY_TYPE_UINT8: /* range */
+        if (valcopy) {
+            ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(255), 10, max ? &part->max_u64 : &part->min_u64);
+        } else if (max) {
+            part->max_u64 = UINT64_C(255);
+        } else {
+            part->min_u64 = UINT64_C(0);
+        }
+        if (!ret && !first) {
+            ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
+        }
+        break;
+    case LY_TYPE_UINT16: /* range */
+        if (valcopy) {
+            ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(65535), 10, max ? &part->max_u64 : &part->min_u64);
+        } else if (max) {
+            part->max_u64 = UINT64_C(65535);
+        } else {
+            part->min_u64 = UINT64_C(0);
+        }
+        if (!ret && !first) {
+            ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
+        }
+        break;
+    case LY_TYPE_UINT32: /* range */
+        if (valcopy) {
+            ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(4294967295), 10, max ? &part->max_u64 : &part->min_u64);
+        } else if (max) {
+            part->max_u64 = UINT64_C(4294967295);
+        } else {
+            part->min_u64 = UINT64_C(0);
+        }
+        if (!ret && !first) {
+            ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
+        }
+        break;
+    case LY_TYPE_UINT64: /* range */
+    case LY_TYPE_STRING: /* length */
+    case LY_TYPE_BINARY: /* length */
+        if (valcopy) {
+            ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(18446744073709551615), 10, max ? &part->max_u64 : &part->min_u64);
+        } else if (max) {
+            part->max_u64 = UINT64_C(18446744073709551615);
+        } else {
+            part->min_u64 = UINT64_C(0);
+        }
+        if (!ret && !first) {
+            ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
+        }
+        break;
+    default:
+        LOGINT(ctx->ctx);
+        ret = LY_EINT;
+    }
+
+finalize:
+    if (ret == LY_EDENIED) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                "Invalid %s restriction - value \"%s\" does not fit the type limitations.",
+                length_restr ? "length" : "range", valcopy ? valcopy : *value);
+    } else if (ret == LY_EVALID) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                "Invalid %s restriction - invalid value \"%s\".",
+                length_restr ? "length" : "range", valcopy ? valcopy : *value);
+    } else if (ret == LY_EEXIST) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                "Invalid %s restriction - values are not in ascending order (%s).",
+                length_restr ? "length" : "range",
+                (valcopy && basetype != LY_TYPE_DEC64) ? valcopy : value ? *value : max ? "max" : "min");
+    } else if (!ret && value) {
+        *value = *value + len;
+    }
+    free(valcopy);
+    return ret;
+}
+
+/**
+ * @brief Compile the parsed range restriction.
+ * @param[in] ctx Compile context.
+ * @param[in] range_p Parsed range structure to compile.
+ * @param[in] basetype Base YANG built-in type of the node with the range restriction.
+ * @param[in] length_restr Flag to distinguish between range and length restrictions. Only for logging.
+ * @param[in] frdigits The fraction-digits value in case of LY_TYPE_DEC64 basetype.
+ * @param[in] base_range Range restriction of the type from which the current type is derived. The current
+ * range restriction must be more restrictive than the base_range.
+ * @param[in,out] range Pointer to the created current range structure.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_type_range(struct lysc_ctx *ctx, struct lysp_restr *range_p, LY_DATA_TYPE basetype, ly_bool length_restr,
+        uint8_t frdigits, struct lysc_range *base_range, struct lysc_range **range)
+{
+    LY_ERR ret = LY_EVALID;
+    const char *expr;
+    struct lysc_range_part *parts = NULL, *part;
+    ly_bool range_expected = 0, uns;
+    LY_ARRAY_COUNT_TYPE parts_done = 0, u, v;
+
+    assert(range);
+    assert(range_p);
+
+    expr = range_p->arg.str;
+    while (1) {
+        if (isspace(*expr)) {
+            ++expr;
+        } else if (*expr == '\0') {
+            if (range_expected) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                        "Invalid %s restriction - unexpected end of the expression after \"..\" (%s).",
+                        length_restr ? "length" : "range", range_p->arg);
+                goto cleanup;
+            } else if (!parts || (parts_done == LY_ARRAY_COUNT(parts))) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                        "Invalid %s restriction - unexpected end of the expression (%s).",
+                        length_restr ? "length" : "range", range_p->arg);
+                goto cleanup;
+            }
+            parts_done++;
+            break;
+        } else if (!strncmp(expr, "min", 3)) {
+            if (parts) {
+                /* min cannot be used elsewhere than in the first part */
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                        "Invalid %s restriction - unexpected data before min keyword (%.*s).", length_restr ? "length" : "range",
+                        expr - range_p->arg.str, range_p->arg.str);
+                goto cleanup;
+            }
+            expr += 3;
+
+            LY_ARRAY_NEW_GOTO(ctx->ctx, parts, part, ret, cleanup);
+            LY_CHECK_GOTO(range_part_minmax(ctx, part, 0, 0, basetype, 1, length_restr, frdigits, base_range, NULL), cleanup);
+            part->max_64 = part->min_64;
+        } else if (*expr == '|') {
+            if (!parts || range_expected) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                        "Invalid %s restriction - unexpected beginning of the expression (%s).", length_restr ? "length" : "range", expr);
+                goto cleanup;
+            }
+            expr++;
+            parts_done++;
+            /* process next part of the expression */
+        } else if (!strncmp(expr, "..", 2)) {
+            expr += 2;
+            while (isspace(*expr)) {
+                expr++;
+            }
+            if (!parts || (LY_ARRAY_COUNT(parts) == parts_done)) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                        "Invalid %s restriction - unexpected \"..\" without a lower bound.", length_restr ? "length" : "range");
+                goto cleanup;
+            }
+            /* continue expecting the upper boundary */
+            range_expected = 1;
+        } else if (isdigit(*expr) || (*expr == '-') || (*expr == '+')) {
+            /* number */
+            if (range_expected) {
+                part = &parts[LY_ARRAY_COUNT(parts) - 1];
+                LY_CHECK_GOTO(range_part_minmax(ctx, part, 1, part->min_64, basetype, 0, length_restr, frdigits, NULL, &expr), cleanup);
+                range_expected = 0;
+            } else {
+                LY_ARRAY_NEW_GOTO(ctx->ctx, parts, part, ret, cleanup);
+                LY_CHECK_GOTO(range_part_minmax(ctx, part, 0, parts_done ? parts[LY_ARRAY_COUNT(parts) - 2].max_64 : 0,
+                        basetype, parts_done ? 0 : 1, length_restr, frdigits, NULL, &expr), cleanup);
+                part->max_64 = part->min_64;
+            }
+
+            /* continue with possible another expression part */
+        } else if (!strncmp(expr, "max", 3)) {
+            expr += 3;
+            while (isspace(*expr)) {
+                expr++;
+            }
+            if (*expr != '\0') {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid %s restriction - unexpected data after max keyword (%s).",
+                        length_restr ? "length" : "range", expr);
+                goto cleanup;
+            }
+            if (range_expected) {
+                part = &parts[LY_ARRAY_COUNT(parts) - 1];
+                LY_CHECK_GOTO(range_part_minmax(ctx, part, 1, part->min_64, basetype, 0, length_restr, frdigits, base_range, NULL), cleanup);
+                range_expected = 0;
+            } else {
+                LY_ARRAY_NEW_GOTO(ctx->ctx, parts, part, ret, cleanup);
+                LY_CHECK_GOTO(range_part_minmax(ctx, part, 1, parts_done ? parts[LY_ARRAY_COUNT(parts) - 2].max_64 : 0,
+                        basetype, parts_done ? 0 : 1, length_restr, frdigits, base_range, NULL), cleanup);
+                part->min_64 = part->max_64;
+            }
+        } else {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid %s restriction - unexpected data (%s).",
+                    length_restr ? "length" : "range", expr);
+            goto cleanup;
+        }
+    }
+
+    /* check with the previous range/length restriction */
+    if (base_range) {
+        switch (basetype) {
+        case LY_TYPE_BINARY:
+        case LY_TYPE_UINT8:
+        case LY_TYPE_UINT16:
+        case LY_TYPE_UINT32:
+        case LY_TYPE_UINT64:
+        case LY_TYPE_STRING:
+            uns = 1;
+            break;
+        case LY_TYPE_DEC64:
+        case LY_TYPE_INT8:
+        case LY_TYPE_INT16:
+        case LY_TYPE_INT32:
+        case LY_TYPE_INT64:
+            uns = 0;
+            break;
+        default:
+            LOGINT(ctx->ctx);
+            ret = LY_EINT;
+            goto cleanup;
+        }
+        for (u = v = 0; u < parts_done && v < LY_ARRAY_COUNT(base_range->parts); ++u) {
+            if ((uns && (parts[u].min_u64 < base_range->parts[v].min_u64)) || (!uns && (parts[u].min_64 < base_range->parts[v].min_64))) {
+                goto baseerror;
+            }
+            /* current lower bound is not lower than the base */
+            if (base_range->parts[v].min_64 == base_range->parts[v].max_64) {
+                /* base has single value */
+                if (base_range->parts[v].min_64 == parts[u].min_64) {
+                    /* both lower bounds are the same */
+                    if (parts[u].min_64 != parts[u].max_64) {
+                        /* current continues with a range */
+                        goto baseerror;
+                    } else {
+                        /* equal single values, move both forward */
+                        ++v;
+                        continue;
+                    }
+                } else {
+                    /* base is single value lower than current range, so the
+                     * value from base range is removed in the current,
+                     * move only base and repeat checking */
+                    ++v;
+                    --u;
+                    continue;
+                }
+            } else {
+                /* base is the range */
+                if (parts[u].min_64 == parts[u].max_64) {
+                    /* current is a single value */
+                    if ((uns && (parts[u].max_u64 > base_range->parts[v].max_u64)) || (!uns && (parts[u].max_64 > base_range->parts[v].max_64))) {
+                        /* current is behind the base range, so base range is omitted,
+                         * move the base and keep the current for further check */
+                        ++v;
+                        --u;
+                    } /* else it is within the base range, so move the current, but keep the base */
+                    continue;
+                } else {
+                    /* both are ranges - check the higher bound, the lower was already checked */
+                    if ((uns && (parts[u].max_u64 > base_range->parts[v].max_u64)) || (!uns && (parts[u].max_64 > base_range->parts[v].max_64))) {
+                        /* higher bound is higher than the current higher bound */
+                        if ((uns && (parts[u].min_u64 > base_range->parts[v].max_u64)) || (!uns && (parts[u].min_64 > base_range->parts[v].max_64))) {
+                            /* but the current lower bound is also higher, so the base range is omitted,
+                             * continue with the same current, but move the base */
+                            --u;
+                            ++v;
+                            continue;
+                        }
+                        /* current range starts within the base range but end behind it */
+                        goto baseerror;
+                    } else {
+                        /* current range is smaller than the base,
+                         * move current, but stay with the base */
+                        continue;
+                    }
+                }
+            }
+        }
+        if (u != parts_done) {
+baseerror:
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                    "Invalid %s restriction - the derived restriction (%s) is not equally or more limiting.",
+                    length_restr ? "length" : "range", range_p->arg);
+            goto cleanup;
+        }
+    }
+
+    if (!(*range)) {
+        *range = calloc(1, sizeof **range);
+        LY_CHECK_ERR_RET(!(*range), LOGMEM(ctx->ctx), LY_EMEM);
+    }
+
+    /* we rewrite the following values as the types chain is being processed */
+    if (range_p->eapptag) {
+        lydict_remove(ctx->ctx, (*range)->eapptag);
+        LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, range_p->eapptag, 0, &(*range)->eapptag), cleanup);
+    }
+    if (range_p->emsg) {
+        lydict_remove(ctx->ctx, (*range)->emsg);
+        LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, range_p->emsg, 0, &(*range)->emsg), cleanup);
+    }
+    if (range_p->dsc) {
+        lydict_remove(ctx->ctx, (*range)->dsc);
+        LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, range_p->dsc, 0, &(*range)->dsc), cleanup);
+    }
+    if (range_p->ref) {
+        lydict_remove(ctx->ctx, (*range)->ref);
+        LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, range_p->ref, 0, &(*range)->ref), cleanup);
+    }
+    /* extensions are taken only from the last range by the caller */
+
+    (*range)->parts = parts;
+    parts = NULL;
+    ret = LY_SUCCESS;
+cleanup:
+    LY_ARRAY_FREE(parts);
+
+    return ret;
+}
+
+LY_ERR
+lys_compile_type_pattern_check(struct ly_ctx *ctx, const char *log_path, const char *pattern, pcre2_code **code)
+{
+    size_t idx, idx2, start, end, size, brack;
+    char *perl_regex, *ptr;
+    int err_code;
+    const char *orig_ptr;
+    PCRE2_SIZE err_offset;
+    pcre2_code *code_local;
+
+#define URANGE_LEN 19
+    char *ublock2urange[][2] = {
+        {"BasicLatin", "[\\x{0000}-\\x{007F}]"},
+        {"Latin-1Supplement", "[\\x{0080}-\\x{00FF}]"},
+        {"LatinExtended-A", "[\\x{0100}-\\x{017F}]"},
+        {"LatinExtended-B", "[\\x{0180}-\\x{024F}]"},
+        {"IPAExtensions", "[\\x{0250}-\\x{02AF}]"},
+        {"SpacingModifierLetters", "[\\x{02B0}-\\x{02FF}]"},
+        {"CombiningDiacriticalMarks", "[\\x{0300}-\\x{036F}]"},
+        {"Greek", "[\\x{0370}-\\x{03FF}]"},
+        {"Cyrillic", "[\\x{0400}-\\x{04FF}]"},
+        {"Armenian", "[\\x{0530}-\\x{058F}]"},
+        {"Hebrew", "[\\x{0590}-\\x{05FF}]"},
+        {"Arabic", "[\\x{0600}-\\x{06FF}]"},
+        {"Syriac", "[\\x{0700}-\\x{074F}]"},
+        {"Thaana", "[\\x{0780}-\\x{07BF}]"},
+        {"Devanagari", "[\\x{0900}-\\x{097F}]"},
+        {"Bengali", "[\\x{0980}-\\x{09FF}]"},
+        {"Gurmukhi", "[\\x{0A00}-\\x{0A7F}]"},
+        {"Gujarati", "[\\x{0A80}-\\x{0AFF}]"},
+        {"Oriya", "[\\x{0B00}-\\x{0B7F}]"},
+        {"Tamil", "[\\x{0B80}-\\x{0BFF}]"},
+        {"Telugu", "[\\x{0C00}-\\x{0C7F}]"},
+        {"Kannada", "[\\x{0C80}-\\x{0CFF}]"},
+        {"Malayalam", "[\\x{0D00}-\\x{0D7F}]"},
+        {"Sinhala", "[\\x{0D80}-\\x{0DFF}]"},
+        {"Thai", "[\\x{0E00}-\\x{0E7F}]"},
+        {"Lao", "[\\x{0E80}-\\x{0EFF}]"},
+        {"Tibetan", "[\\x{0F00}-\\x{0FFF}]"},
+        {"Myanmar", "[\\x{1000}-\\x{109F}]"},
+        {"Georgian", "[\\x{10A0}-\\x{10FF}]"},
+        {"HangulJamo", "[\\x{1100}-\\x{11FF}]"},
+        {"Ethiopic", "[\\x{1200}-\\x{137F}]"},
+        {"Cherokee", "[\\x{13A0}-\\x{13FF}]"},
+        {"UnifiedCanadianAboriginalSyllabics", "[\\x{1400}-\\x{167F}]"},
+        {"Ogham", "[\\x{1680}-\\x{169F}]"},
+        {"Runic", "[\\x{16A0}-\\x{16FF}]"},
+        {"Khmer", "[\\x{1780}-\\x{17FF}]"},
+        {"Mongolian", "[\\x{1800}-\\x{18AF}]"},
+        {"LatinExtendedAdditional", "[\\x{1E00}-\\x{1EFF}]"},
+        {"GreekExtended", "[\\x{1F00}-\\x{1FFF}]"},
+        {"GeneralPunctuation", "[\\x{2000}-\\x{206F}]"},
+        {"SuperscriptsandSubscripts", "[\\x{2070}-\\x{209F}]"},
+        {"CurrencySymbols", "[\\x{20A0}-\\x{20CF}]"},
+        {"CombiningMarksforSymbols", "[\\x{20D0}-\\x{20FF}]"},
+        {"LetterlikeSymbols", "[\\x{2100}-\\x{214F}]"},
+        {"NumberForms", "[\\x{2150}-\\x{218F}]"},
+        {"Arrows", "[\\x{2190}-\\x{21FF}]"},
+        {"MathematicalOperators", "[\\x{2200}-\\x{22FF}]"},
+        {"MiscellaneousTechnical", "[\\x{2300}-\\x{23FF}]"},
+        {"ControlPictures", "[\\x{2400}-\\x{243F}]"},
+        {"OpticalCharacterRecognition", "[\\x{2440}-\\x{245F}]"},
+        {"EnclosedAlphanumerics", "[\\x{2460}-\\x{24FF}]"},
+        {"BoxDrawing", "[\\x{2500}-\\x{257F}]"},
+        {"BlockElements", "[\\x{2580}-\\x{259F}]"},
+        {"GeometricShapes", "[\\x{25A0}-\\x{25FF}]"},
+        {"MiscellaneousSymbols", "[\\x{2600}-\\x{26FF}]"},
+        {"Dingbats", "[\\x{2700}-\\x{27BF}]"},
+        {"BraillePatterns", "[\\x{2800}-\\x{28FF}]"},
+        {"CJKRadicalsSupplement", "[\\x{2E80}-\\x{2EFF}]"},
+        {"KangxiRadicals", "[\\x{2F00}-\\x{2FDF}]"},
+        {"IdeographicDescriptionCharacters", "[\\x{2FF0}-\\x{2FFF}]"},
+        {"CJKSymbolsandPunctuation", "[\\x{3000}-\\x{303F}]"},
+        {"Hiragana", "[\\x{3040}-\\x{309F}]"},
+        {"Katakana", "[\\x{30A0}-\\x{30FF}]"},
+        {"Bopomofo", "[\\x{3100}-\\x{312F}]"},
+        {"HangulCompatibilityJamo", "[\\x{3130}-\\x{318F}]"},
+        {"Kanbun", "[\\x{3190}-\\x{319F}]"},
+        {"BopomofoExtended", "[\\x{31A0}-\\x{31BF}]"},
+        {"EnclosedCJKLettersandMonths", "[\\x{3200}-\\x{32FF}]"},
+        {"CJKCompatibility", "[\\x{3300}-\\x{33FF}]"},
+        {"CJKUnifiedIdeographsExtensionA", "[\\x{3400}-\\x{4DB5}]"},
+        {"CJKUnifiedIdeographs", "[\\x{4E00}-\\x{9FFF}]"},
+        {"YiSyllables", "[\\x{A000}-\\x{A48F}]"},
+        {"YiRadicals", "[\\x{A490}-\\x{A4CF}]"},
+        {"HangulSyllables", "[\\x{AC00}-\\x{D7A3}]"},
+        {"PrivateUse", "[\\x{E000}-\\x{F8FF}]"},
+        {"CJKCompatibilityIdeographs", "[\\x{F900}-\\x{FAFF}]"},
+        {"AlphabeticPresentationForms", "[\\x{FB00}-\\x{FB4F}]"},
+        {"ArabicPresentationForms-A", "[\\x{FB50}-\\x{FDFF}]"},
+        {"CombiningHalfMarks", "[\\x{FE20}-\\x{FE2F}]"},
+        {"CJKCompatibilityForms", "[\\x{FE30}-\\x{FE4F}]"},
+        {"SmallFormVariants", "[\\x{FE50}-\\x{FE6F}]"},
+        {"ArabicPresentationForms-B", "[\\x{FE70}-\\x{FEFE}]"},
+        {"HalfwidthandFullwidthForms", "[\\x{FF00}-\\x{FFEF}]"},
+        {NULL, NULL}
+    };
+
+    /* adjust the expression to a Perl equivalent
+     * http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#regexs */
+
+    /* allocate space for the transformed pattern */
+    size = strlen(pattern) + 1;
+    perl_regex = malloc(size);
+    LY_CHECK_ERR_RET(!perl_regex, LOGMEM(ctx), LY_EMEM);
+    perl_regex[0] = '\0';
+
+    /* we need to replace all "$" and "^" (that are not in "[]") with "\$" and "\^" */
+    brack = 0;
+    idx = 0;
+    orig_ptr = pattern;
+    while (orig_ptr[0]) {
+        switch (orig_ptr[0]) {
+        case '$':
+        case '^':
+            if (!brack) {
+                /* make space for the extra character */
+                ++size;
+                perl_regex = ly_realloc(perl_regex, size);
+                LY_CHECK_ERR_RET(!perl_regex, LOGMEM(ctx), LY_EMEM);
+
+                /* print escape slash */
+                perl_regex[idx] = '\\';
+                ++idx;
+            }
+            break;
+        case '[':
+            /* must not be escaped */
+            if ((orig_ptr == pattern) || (orig_ptr[-1] != '\\')) {
+                ++brack;
+            }
+            break;
+        case ']':
+            if ((orig_ptr == pattern) || (orig_ptr[-1] != '\\')) {
+                /* pattern was checked and compiled already */
+                assert(brack);
+                --brack;
+            }
+            break;
+        default:
+            break;
+        }
+
+        /* copy char */
+        perl_regex[idx] = orig_ptr[0];
+
+        ++idx;
+        ++orig_ptr;
+    }
+    perl_regex[idx] = '\0';
+
+    /* substitute Unicode Character Blocks with exact Character Ranges */
+    while ((ptr = strstr(perl_regex, "\\p{Is"))) {
+        start = ptr - perl_regex;
+
+        ptr = strchr(ptr, '}');
+        if (!ptr) {
+            LOGVAL(ctx, LY_VLOG_STR, log_path, LY_VCODE_INREGEXP,
+                    pattern, perl_regex + start + 2, "unterminated character property");
+            free(perl_regex);
+            return LY_EVALID;
+        }
+        end = (ptr - perl_regex) + 1;
+
+        /* need more space */
+        if (end - start < URANGE_LEN) {
+            perl_regex = ly_realloc(perl_regex, strlen(perl_regex) + (URANGE_LEN - (end - start)) + 1);
+            LY_CHECK_ERR_RET(!perl_regex, LOGMEM(ctx); free(perl_regex), LY_EMEM);
+        }
+
+        /* find our range */
+        for (idx = 0; ublock2urange[idx][0]; ++idx) {
+            if (!strncmp(perl_regex + start + 5, ublock2urange[idx][0], strlen(ublock2urange[idx][0]))) {
+                break;
+            }
+        }
+        if (!ublock2urange[idx][0]) {
+            LOGVAL(ctx, LY_VLOG_STR, log_path, LY_VCODE_INREGEXP,
+                    pattern, perl_regex + start + 5, "unknown block name");
+            free(perl_regex);
+            return LY_EVALID;
+        }
+
+        /* make the space in the string and replace the block (but we cannot include brackets if it was already enclosed in them) */
+        for (idx2 = 0, idx = 0; idx2 < start; ++idx2) {
+            if ((perl_regex[idx2] == '[') && (!idx2 || (perl_regex[idx2 - 1] != '\\'))) {
+                ++idx;
+            }
+            if ((perl_regex[idx2] == ']') && (!idx2 || (perl_regex[idx2 - 1] != '\\'))) {
+                --idx;
+            }
+        }
+        if (idx) {
+            /* skip brackets */
+            memmove(perl_regex + start + (URANGE_LEN - 2), perl_regex + end, strlen(perl_regex + end) + 1);
+            memcpy(perl_regex + start, ublock2urange[idx][1] + 1, URANGE_LEN - 2);
+        } else {
+            memmove(perl_regex + start + URANGE_LEN, perl_regex + end, strlen(perl_regex + end) + 1);
+            memcpy(perl_regex + start, ublock2urange[idx][1], URANGE_LEN);
+        }
+    }
+
+    /* must return 0, already checked during parsing */
+    code_local = pcre2_compile((PCRE2_SPTR)perl_regex, PCRE2_ZERO_TERMINATED,
+            PCRE2_UTF | PCRE2_ANCHORED | PCRE2_ENDANCHORED | PCRE2_DOLLAR_ENDONLY | PCRE2_NO_AUTO_CAPTURE,
+            &err_code, &err_offset, NULL);
+    if (!code_local) {
+        PCRE2_UCHAR err_msg[256] = {0};
+        pcre2_get_error_message(err_code, err_msg, 256);
+        LOGVAL(ctx, LY_VLOG_STR, log_path, LY_VCODE_INREGEXP, pattern, perl_regex + err_offset, err_msg);
+        free(perl_regex);
+        return LY_EVALID;
+    }
+    free(perl_regex);
+
+    if (code) {
+        *code = code_local;
+    } else {
+        free(code_local);
+    }
+
+    return LY_SUCCESS;
+
+#undef URANGE_LEN
+}
+
+/**
+ * @brief Compile parsed pattern restriction in conjunction with the patterns from base type.
+ * @param[in] ctx Compile context.
+ * @param[in] patterns_p Array of parsed patterns from the current type to compile.
+ * @param[in] base_patterns Compiled patterns from the type from which the current type is derived.
+ * Patterns from the base type are inherited to have all the patterns that have to match at one place.
+ * @param[out] patterns Pointer to the storage for the patterns of the current type.
+ * @return LY_ERR LY_SUCCESS, LY_EMEM, LY_EVALID.
+ */
+static LY_ERR
+lys_compile_type_patterns(struct lysc_ctx *ctx, struct lysp_restr *patterns_p,
+        struct lysc_pattern **base_patterns, struct lysc_pattern ***patterns)
+{
+    struct lysc_pattern **pattern;
+    LY_ARRAY_COUNT_TYPE u;
+    LY_ERR ret = LY_SUCCESS;
+
+    /* first, copy the patterns from the base type */
+    if (base_patterns) {
+        *patterns = lysc_patterns_dup(ctx->ctx, base_patterns);
+        LY_CHECK_ERR_RET(!(*patterns), LOGMEM(ctx->ctx), LY_EMEM);
+    }
+
+    LY_ARRAY_FOR(patterns_p, u) {
+        LY_ARRAY_NEW_RET(ctx->ctx, (*patterns), pattern, LY_EMEM);
+        *pattern = calloc(1, sizeof **pattern);
+        ++(*pattern)->refcount;
+
+        ret = lys_compile_type_pattern_check(ctx->ctx, ctx->path, &patterns_p[u].arg.str[1], &(*pattern)->code);
+        LY_CHECK_RET(ret);
+
+        if (patterns_p[u].arg.str[0] == 0x15) {
+            (*pattern)->inverted = 1;
+        }
+        DUP_STRING_GOTO(ctx->ctx, &patterns_p[u].arg.str[1], (*pattern)->expr, ret, done);
+        DUP_STRING_GOTO(ctx->ctx, patterns_p[u].eapptag, (*pattern)->eapptag, ret, done);
+        DUP_STRING_GOTO(ctx->ctx, patterns_p[u].emsg, (*pattern)->emsg, ret, done);
+        DUP_STRING_GOTO(ctx->ctx, patterns_p[u].dsc, (*pattern)->dsc, ret, done);
+        DUP_STRING_GOTO(ctx->ctx, patterns_p[u].ref, (*pattern)->ref, ret, done);
+        COMPILE_EXTS_GOTO(ctx, patterns_p[u].exts, (*pattern)->exts, (*pattern), LYEXT_PAR_PATTERN, ret, done);
+    }
+done:
+    return ret;
+}
+
+/**
+ * @brief map of the possible restrictions combination for the specific built-in type.
+ */
+static uint16_t type_substmt_map[LY_DATA_TYPE_COUNT] = {
+    0 /* LY_TYPE_UNKNOWN */,
+    LYS_SET_LENGTH /* LY_TYPE_BINARY */,
+    LYS_SET_RANGE /* LY_TYPE_UINT8 */,
+    LYS_SET_RANGE /* LY_TYPE_UINT16 */,
+    LYS_SET_RANGE /* LY_TYPE_UINT32 */,
+    LYS_SET_RANGE /* LY_TYPE_UINT64 */,
+    LYS_SET_LENGTH | LYS_SET_PATTERN /* LY_TYPE_STRING */,
+    LYS_SET_BIT /* LY_TYPE_BITS */,
+    0 /* LY_TYPE_BOOL */,
+    LYS_SET_FRDIGITS | LYS_SET_RANGE /* LY_TYPE_DEC64 */,
+    0 /* LY_TYPE_EMPTY */,
+    LYS_SET_ENUM /* LY_TYPE_ENUM */,
+    LYS_SET_BASE /* LY_TYPE_IDENT */,
+    LYS_SET_REQINST /* LY_TYPE_INST */,
+    LYS_SET_REQINST | LYS_SET_PATH /* LY_TYPE_LEAFREF */,
+    LYS_SET_TYPE /* LY_TYPE_UNION */,
+    LYS_SET_RANGE /* LY_TYPE_INT8 */,
+    LYS_SET_RANGE /* LY_TYPE_INT16 */,
+    LYS_SET_RANGE /* LY_TYPE_INT32 */,
+    LYS_SET_RANGE /* LY_TYPE_INT64 */
+};
+
+/**
+ * @brief stringification of the YANG built-in data types
+ */
+const char *ly_data_type2str[LY_DATA_TYPE_COUNT] = {
+    "unknown", "binary", "8bit unsigned integer", "16bit unsigned integer",
+    "32bit unsigned integer", "64bit unsigned integer", "string", "bits", "boolean", "decimal64", "empty", "enumeration",
+    "identityref", "instance-identifier", "leafref", "union", "8bit integer", "16bit integer", "32bit integer", "64bit integer"
+};
+
+/**
+ * @brief Compile parsed type's enum structures (for enumeration and bits types).
+ * @param[in] ctx Compile context.
+ * @param[in] enums_p Array of the parsed enum structures to compile.
+ * @param[in] basetype Base YANG built-in type from which the current type is derived. Only LY_TYPE_ENUM and LY_TYPE_BITS are expected.
+ * @param[in] base_enums Array of the compiled enums information from the (latest) base type to check if the current enums are compatible.
+ * @param[out] enums Newly created array of the compiled enums information for the current type.
+ * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
+ */
+static LY_ERR
+lys_compile_type_enums(struct lysc_ctx *ctx, struct lysp_type_enum *enums_p, LY_DATA_TYPE basetype,
+        struct lysc_type_bitenum_item *base_enums, struct lysc_type_bitenum_item **enums)
+{
+    LY_ERR ret = LY_SUCCESS;
+    LY_ARRAY_COUNT_TYPE u, v, match = 0;
+    int32_t value = 0;
+    uint32_t position = 0;
+    struct lysc_type_bitenum_item *e, storage;
+
+    if (base_enums && (ctx->pmod->version < LYS_VERSION_1_1)) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "%s type can be subtyped only in YANG 1.1 modules.",
+                basetype == LY_TYPE_ENUM ? "Enumeration" : "Bits");
+        return LY_EVALID;
+    }
+
+    LY_ARRAY_FOR(enums_p, u) {
+        LY_ARRAY_NEW_RET(ctx->ctx, *enums, e, LY_EMEM);
+        DUP_STRING_GOTO(ctx->ctx, enums_p[u].name, e->name, ret, done);
+        DUP_STRING_GOTO(ctx->ctx, enums_p[u].ref, e->dsc, ret, done);
+        DUP_STRING_GOTO(ctx->ctx, enums_p[u].ref, e->ref, ret, done);
+        e->flags = enums_p[u].flags & LYS_FLAGS_COMPILED_MASK;
+        if (base_enums) {
+            /* check the enum/bit presence in the base type - the set of enums/bits in the derived type must be a subset */
+            LY_ARRAY_FOR(base_enums, v) {
+                if (!strcmp(e->name, base_enums[v].name)) {
+                    break;
+                }
+            }
+            if (v == LY_ARRAY_COUNT(base_enums)) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                        "Invalid %s - derived type adds new item \"%s\".",
+                        basetype == LY_TYPE_ENUM ? "enumeration" : "bits", e->name);
+                return LY_EVALID;
+            }
+            match = v;
+        }
+
+        if (basetype == LY_TYPE_ENUM) {
+            e->flags |= LYS_ISENUM;
+            if (enums_p[u].flags & LYS_SET_VALUE) {
+                e->value = (int32_t)enums_p[u].value;
+                if (!u || (e->value >= value)) {
+                    value = e->value + 1;
+                }
+                /* check collision with other values */
+                for (v = 0; v < LY_ARRAY_COUNT(*enums) - 1; ++v) {
+                    if (e->value == (*enums)[v].value) {
+                        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                                "Invalid enumeration - value %d collide in items \"%s\" and \"%s\".",
+                                e->value, e->name, (*enums)[v].name);
+                        return LY_EVALID;
+                    }
+                }
+            } else if (base_enums) {
+                /* inherit the assigned value */
+                e->value = base_enums[match].value;
+                if (!u || (e->value >= value)) {
+                    value = e->value + 1;
+                }
+            } else {
+                /* assign value automatically */
+                if (u && (value == INT32_MIN)) {
+                    /* counter overflow */
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                            "Invalid enumeration - it is not possible to auto-assign enum value for "
+                            "\"%s\" since the highest value is already 2147483647.", e->name);
+                    return LY_EVALID;
+                }
+                e->value = value++;
+            }
+        } else { /* LY_TYPE_BITS */
+            if (enums_p[u].flags & LYS_SET_VALUE) {
+                e->value = (int32_t)enums_p[u].value;
+                if (!u || ((uint32_t)e->value >= position)) {
+                    position = (uint32_t)e->value + 1;
+                }
+                /* check collision with other values */
+                for (v = 0; v < LY_ARRAY_COUNT(*enums) - 1; ++v) {
+                    if (e->value == (*enums)[v].value) {
+                        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                                "Invalid bits - position %u collide in items \"%s\" and \"%s\".",
+                                (uint32_t)e->value, e->name, (*enums)[v].name);
+                        return LY_EVALID;
+                    }
+                }
+            } else if (base_enums) {
+                /* inherit the assigned value */
+                e->value = base_enums[match].value;
+                if (!u || ((uint32_t)e->value >= position)) {
+                    position = (uint32_t)e->value + 1;
+                }
+            } else {
+                /* assign value automatically */
+                if (u && (position == 0)) {
+                    /* counter overflow */
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                            "Invalid bits - it is not possible to auto-assign bit position for "
+                            "\"%s\" since the highest value is already 4294967295.", e->name);
+                    return LY_EVALID;
+                }
+                e->value = position++;
+            }
+        }
+
+        if (base_enums) {
+            /* the assigned values must not change from the derived type */
+            if (e->value != base_enums[match].value) {
+                if (basetype == LY_TYPE_ENUM) {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                            "Invalid enumeration - value of the item \"%s\" has changed from %d to %d in the derived type.",
+                            e->name, base_enums[match].value, e->value);
+                } else {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                            "Invalid bits - position of the item \"%s\" has changed from %u to %u in the derived type.",
+                            e->name, (uint32_t)base_enums[match].value, (uint32_t)e->value);
+                }
+                return LY_EVALID;
+            }
+        }
+
+        COMPILE_ARRAY_GOTO(ctx, enums_p[u].iffeatures, e->iffeatures, v, lys_compile_iffeature, ret, done);
+        COMPILE_EXTS_GOTO(ctx, enums_p[u].exts, e->exts, e, basetype == LY_TYPE_ENUM ? LYEXT_PAR_TYPE_ENUM : LYEXT_PAR_TYPE_BIT, ret, done);
+
+        if (basetype == LY_TYPE_BITS) {
+            /* keep bits ordered by position */
+            for (v = u; v && (*enums)[v - 1].value > e->value; --v) {}
+            if (v != u) {
+                memcpy(&storage, e, sizeof *e);
+                memmove(&(*enums)[v + 1], &(*enums)[v], (u - v) * sizeof **enums);
+                memcpy(&(*enums)[v], &storage, sizeof storage);
+            }
+        }
+    }
+
+done:
+    return ret;
+}
+
+/**
+ * @brief The core of the lys_compile_type() - compile information about the given type (from typedef or leaf/leaf-list).
+ * @param[in] ctx Compile context.
+ * @param[in] context_pnode Schema node where the type/typedef is placed to correctly find the base types.
+ * @param[in] context_flags Flags of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
+ * @param[in] context_mod Module of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
+ * @param[in] context_name Name of the context node or referencing typedef for logging.
+ * @param[in] type_p Parsed type to compile.
+ * @param[in] basetype Base YANG built-in type of the type to compile.
+ * @param[in] tpdfname Name of the type's typedef, serves as a flag - if it is leaf/leaf-list's type, it is NULL.
+ * @param[in] base The latest base (compiled) type from which the current type is being derived.
+ * @param[out] type Newly created type structure with the filled information about the type.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_type_(struct lysc_ctx *ctx, struct lysp_node *context_pnode, uint16_t context_flags,
+        struct lysp_module *context_mod, const char *context_name, struct lysp_type *type_p, LY_DATA_TYPE basetype,
+        const char *tpdfname, struct lysc_type *base, struct lysc_type **type)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lysc_type_bin *bin;
+    struct lysc_type_num *num;
+    struct lysc_type_str *str;
+    struct lysc_type_bits *bits;
+    struct lysc_type_enum *enumeration;
+    struct lysc_type_dec *dec;
+    struct lysc_type_identityref *idref;
+    struct lysc_type_leafref *lref;
+    struct lysc_type_union *un, *un_aux;
+
+    switch (basetype) {
+    case LY_TYPE_BINARY:
+        bin = (struct lysc_type_bin *)(*type);
+
+        /* RFC 7950 9.8.1, 9.4.4 - length, number of octets it contains */
+        if (type_p->length) {
+            LY_CHECK_RET(lys_compile_type_range(ctx, type_p->length, basetype, 1, 0,
+                    base ? ((struct lysc_type_bin *)base)->length : NULL, &bin->length));
+            if (!tpdfname) {
+                COMPILE_EXTS_GOTO(ctx, type_p->length->exts, bin->length->exts, bin->length, LYEXT_PAR_LENGTH, ret, cleanup);
+            }
+        }
+        break;
+    case LY_TYPE_BITS:
+        /* RFC 7950 9.7 - bits */
+        bits = (struct lysc_type_bits *)(*type);
+        if (type_p->bits) {
+            LY_CHECK_RET(lys_compile_type_enums(ctx, type_p->bits, basetype,
+                    base ? (struct lysc_type_bitenum_item *)((struct lysc_type_bits *)base)->bits : NULL,
+                    (struct lysc_type_bitenum_item **)&bits->bits));
+        }
+
+        if (!base && !type_p->flags) {
+            /* type derived from bits built-in type must contain at least one bit */
+            if (tpdfname) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "bit", "bits type ", tpdfname);
+            } else {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "bit", "bits type", "");
+            }
+            return LY_EVALID;
+        }
+        break;
+    case LY_TYPE_DEC64:
+        dec = (struct lysc_type_dec *)(*type);
+
+        /* RFC 7950 9.3.4 - fraction-digits */
+        if (!base) {
+            if (!type_p->fraction_digits) {
+                if (tpdfname) {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "fraction-digits", "decimal64 type ", tpdfname);
+                } else {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "fraction-digits", "decimal64 type", "");
+                }
+                return LY_EVALID;
+            }
+            dec->fraction_digits = type_p->fraction_digits;
+        } else {
+            if (type_p->fraction_digits) {
+                /* fraction digits is prohibited in types not directly derived from built-in decimal64 */
+                if (tpdfname) {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                            "Invalid fraction-digits substatement for type \"%s\" not directly derived from decimal64 built-in type.",
+                            tpdfname);
+                } else {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                            "Invalid fraction-digits substatement for type not directly derived from decimal64 built-in type.");
+                }
+                return LY_EVALID;
+            }
+            dec->fraction_digits = ((struct lysc_type_dec *)base)->fraction_digits;
+        }
+
+        /* RFC 7950 9.2.4 - range */
+        if (type_p->range) {
+            LY_CHECK_RET(lys_compile_type_range(ctx, type_p->range, basetype, 0, dec->fraction_digits,
+                    base ? ((struct lysc_type_dec *)base)->range : NULL, &dec->range));
+            if (!tpdfname) {
+                COMPILE_EXTS_GOTO(ctx, type_p->range->exts, dec->range->exts, dec->range, LYEXT_PAR_RANGE, ret, cleanup);
+            }
+        }
+        break;
+    case LY_TYPE_STRING:
+        str = (struct lysc_type_str *)(*type);
+
+        /* RFC 7950 9.4.4 - length */
+        if (type_p->length) {
+            LY_CHECK_RET(lys_compile_type_range(ctx, type_p->length, basetype, 1, 0,
+                    base ? ((struct lysc_type_str *)base)->length : NULL, &str->length));
+            if (!tpdfname) {
+                COMPILE_EXTS_GOTO(ctx, type_p->length->exts, str->length->exts, str->length, LYEXT_PAR_LENGTH, ret, cleanup);
+            }
+        } else if (base && ((struct lysc_type_str *)base)->length) {
+            str->length = lysc_range_dup(ctx->ctx, ((struct lysc_type_str *)base)->length);
+        }
+
+        /* RFC 7950 9.4.5 - pattern */
+        if (type_p->patterns) {
+            LY_CHECK_RET(lys_compile_type_patterns(ctx, type_p->patterns,
+                    base ? ((struct lysc_type_str *)base)->patterns : NULL, &str->patterns));
+        } else if (base && ((struct lysc_type_str *)base)->patterns) {
+            str->patterns = lysc_patterns_dup(ctx->ctx, ((struct lysc_type_str *)base)->patterns);
+        }
+        break;
+    case LY_TYPE_ENUM:
+        enumeration = (struct lysc_type_enum *)(*type);
+
+        /* RFC 7950 9.6 - enum */
+        if (type_p->enums) {
+            LY_CHECK_RET(lys_compile_type_enums(ctx, type_p->enums, basetype,
+                    base ? ((struct lysc_type_enum *)base)->enums : NULL, &enumeration->enums));
+        }
+
+        if (!base && !type_p->flags) {
+            /* type derived from enumerations built-in type must contain at least one enum */
+            if (tpdfname) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "enum", "enumeration type ", tpdfname);
+            } else {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "enum", "enumeration type", "");
+            }
+            return LY_EVALID;
+        }
+        break;
+    case LY_TYPE_INT8:
+    case LY_TYPE_UINT8:
+    case LY_TYPE_INT16:
+    case LY_TYPE_UINT16:
+    case LY_TYPE_INT32:
+    case LY_TYPE_UINT32:
+    case LY_TYPE_INT64:
+    case LY_TYPE_UINT64:
+        num = (struct lysc_type_num *)(*type);
+
+        /* RFC 6020 9.2.4 - range */
+        if (type_p->range) {
+            LY_CHECK_RET(lys_compile_type_range(ctx, type_p->range, basetype, 0, 0,
+                    base ? ((struct lysc_type_num *)base)->range : NULL, &num->range));
+            if (!tpdfname) {
+                COMPILE_EXTS_GOTO(ctx, type_p->range->exts, num->range->exts, num->range, LYEXT_PAR_RANGE, ret, cleanup);
+            }
+        }
+        break;
+    case LY_TYPE_IDENT:
+        idref = (struct lysc_type_identityref *)(*type);
+
+        /* RFC 7950 9.10.2 - base */
+        if (type_p->bases) {
+            if (base) {
+                /* only the directly derived identityrefs can contain base specification */
+                if (tpdfname) {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                            "Invalid base substatement for the type \"%s\" not directly derived from identityref built-in type.",
+                            tpdfname);
+                } else {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                            "Invalid base substatement for the type not directly derived from identityref built-in type.");
+                }
+                return LY_EVALID;
+            }
+            LY_CHECK_RET(lys_compile_identity_bases(ctx, type_p->pmod, type_p->bases, NULL, &idref->bases));
+        }
+
+        if (!base && !type_p->flags) {
+            /* type derived from identityref built-in type must contain at least one base */
+            if (tpdfname) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "base", "identityref type ", tpdfname);
+            } else {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "base", "identityref type", "");
+            }
+            return LY_EVALID;
+        }
+        break;
+    case LY_TYPE_LEAFREF:
+        lref = (struct lysc_type_leafref *)*type;
+
+        /* RFC 7950 9.9.3 - require-instance */
+        if (type_p->flags & LYS_SET_REQINST) {
+            if (context_mod->version < LYS_VERSION_1_1) {
+                if (tpdfname) {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                            "Leafref type \"%s\" can be restricted by require-instance statement only in YANG 1.1 modules.", tpdfname);
+                } else {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                            "Leafref type can be restricted by require-instance statement only in YANG 1.1 modules.");
+                }
+                return LY_EVALID;
+            }
+            lref->require_instance = type_p->require_instance;
+        } else if (base) {
+            /* inherit */
+            lref->require_instance = ((struct lysc_type_leafref *)base)->require_instance;
+        } else {
+            /* default is true */
+            lref->require_instance = 1;
+        }
+        if (type_p->path) {
+            LY_CHECK_RET(lyxp_expr_dup(ctx->ctx, type_p->path, &lref->path));
+            LY_CHECK_RET(lysc_prefixes_compile(type_p->path->expr, strlen(type_p->path->expr), type_p->pmod,
+                    &lref->prefixes));
+        } else if (base) {
+            LY_CHECK_RET(lyxp_expr_dup(ctx->ctx, ((struct lysc_type_leafref *)base)->path, &lref->path));
+            LY_CHECK_RET(lysc_prefixes_dup(((struct lysc_type_leafref *)base)->prefixes, &lref->prefixes));
+        } else if (tpdfname) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "path", "leafref type ", tpdfname);
+            return LY_EVALID;
+        } else {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "path", "leafref type", "");
+            return LY_EVALID;
+        }
+        break;
+    case LY_TYPE_INST:
+        /* RFC 7950 9.9.3 - require-instance */
+        if (type_p->flags & LYS_SET_REQINST) {
+            ((struct lysc_type_instanceid *)(*type))->require_instance = type_p->require_instance;
+        } else {
+            /* default is true */
+            ((struct lysc_type_instanceid *)(*type))->require_instance = 1;
+        }
+        break;
+    case LY_TYPE_UNION:
+        un = (struct lysc_type_union *)(*type);
+
+        /* RFC 7950 7.4 - type */
+        if (type_p->types) {
+            if (base) {
+                /* only the directly derived union can contain types specification */
+                if (tpdfname) {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                            "Invalid type substatement for the type \"%s\" not directly derived from union built-in type.",
+                            tpdfname);
+                } else {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
+                            "Invalid type substatement for the type not directly derived from union built-in type.");
+                }
+                return LY_EVALID;
+            }
+            /* compile the type */
+            LY_ARRAY_CREATE_RET(ctx->ctx, un->types, LY_ARRAY_COUNT(type_p->types), LY_EVALID);
+            for (LY_ARRAY_COUNT_TYPE u = 0, additional = 0; u < LY_ARRAY_COUNT(type_p->types); ++u) {
+                LY_CHECK_RET(lys_compile_type(ctx, context_pnode, context_flags, context_mod, context_name,
+                        &type_p->types[u], &un->types[u + additional], NULL, NULL));
+                if (un->types[u + additional]->basetype == LY_TYPE_UNION) {
+                    /* add space for additional types from the union subtype */
+                    un_aux = (struct lysc_type_union *)un->types[u + additional];
+                    LY_ARRAY_RESIZE_ERR_RET(ctx->ctx, un->types, (*((uint64_t *)(type_p->types) - 1)) + additional + LY_ARRAY_COUNT(un_aux->types) - 1,
+                            lysc_type_free(ctx->ctx, (struct lysc_type *)un_aux), LY_EMEM);
+
+                    /* copy subtypes of the subtype union */
+                    for (LY_ARRAY_COUNT_TYPE v = 0; v < LY_ARRAY_COUNT(un_aux->types); ++v) {
+                        if (un_aux->types[v]->basetype == LY_TYPE_LEAFREF) {
+                            /* duplicate the whole structure because of the instance-specific path resolving for realtype */
+                            un->types[u + additional] = calloc(1, sizeof(struct lysc_type_leafref));
+                            LY_CHECK_ERR_RET(!un->types[u + additional], LOGMEM(ctx->ctx); lysc_type_free(ctx->ctx, (struct lysc_type *)un_aux), LY_EMEM);
+                            lref = (struct lysc_type_leafref *)un->types[u + additional];
+
+                            lref->basetype = LY_TYPE_LEAFREF;
+                            LY_CHECK_RET(lyxp_expr_dup(ctx->ctx, ((struct lysc_type_leafref *)un_aux->types[v])->path, &lref->path));
+                            lref->refcount = 1;
+                            lref->require_instance = ((struct lysc_type_leafref *)un_aux->types[v])->require_instance;
+                            LY_CHECK_RET(lysc_prefixes_dup(((struct lysc_type_leafref *)un_aux->types[v])->prefixes,
+                                    &lref->prefixes));
+                            /* TODO extensions */
+
+                        } else {
+                            un->types[u + additional] = un_aux->types[v];
+                            ++un_aux->types[v]->refcount;
+                        }
+                        ++additional;
+                        LY_ARRAY_INCREMENT(un->types);
+                    }
+                    /* compensate u increment in main loop */
+                    --additional;
+
+                    /* free the replaced union subtype */
+                    lysc_type_free(ctx->ctx, (struct lysc_type *)un_aux);
+                } else {
+                    LY_ARRAY_INCREMENT(un->types);
+                }
+            }
+        }
+
+        if (!base && !type_p->flags) {
+            /* type derived from union built-in type must contain at least one type */
+            if (tpdfname) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "type", "union type ", tpdfname);
+            } else {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "type", "union type", "");
+            }
+            return LY_EVALID;
+        }
+        break;
+    case LY_TYPE_BOOL:
+    case LY_TYPE_EMPTY:
+    case LY_TYPE_UNKNOWN: /* just to complete switch */
+        break;
+    }
+
+    if (tpdfname) {
+        switch (basetype) {
+        case LY_TYPE_BINARY:
+            type_p->compiled = *type;
+            *type = calloc(1, sizeof(struct lysc_type_bin));
+            break;
+        case LY_TYPE_BITS:
+            type_p->compiled = *type;
+            *type = calloc(1, sizeof(struct lysc_type_bits));
+            break;
+        case LY_TYPE_DEC64:
+            type_p->compiled = *type;
+            *type = calloc(1, sizeof(struct lysc_type_dec));
+            break;
+        case LY_TYPE_STRING:
+            type_p->compiled = *type;
+            *type = calloc(1, sizeof(struct lysc_type_str));
+            break;
+        case LY_TYPE_ENUM:
+            type_p->compiled = *type;
+            *type = calloc(1, sizeof(struct lysc_type_enum));
+            break;
+        case LY_TYPE_INT8:
+        case LY_TYPE_UINT8:
+        case LY_TYPE_INT16:
+        case LY_TYPE_UINT16:
+        case LY_TYPE_INT32:
+        case LY_TYPE_UINT32:
+        case LY_TYPE_INT64:
+        case LY_TYPE_UINT64:
+            type_p->compiled = *type;
+            *type = calloc(1, sizeof(struct lysc_type_num));
+            break;
+        case LY_TYPE_IDENT:
+            type_p->compiled = *type;
+            *type = calloc(1, sizeof(struct lysc_type_identityref));
+            break;
+        case LY_TYPE_LEAFREF:
+            type_p->compiled = *type;
+            *type = calloc(1, sizeof(struct lysc_type_leafref));
+            break;
+        case LY_TYPE_INST:
+            type_p->compiled = *type;
+            *type = calloc(1, sizeof(struct lysc_type_instanceid));
+            break;
+        case LY_TYPE_UNION:
+            type_p->compiled = *type;
+            *type = calloc(1, sizeof(struct lysc_type_union));
+            break;
+        case LY_TYPE_BOOL:
+        case LY_TYPE_EMPTY:
+        case LY_TYPE_UNKNOWN: /* just to complete switch */
+            break;
+        }
+    }
+    LY_CHECK_ERR_RET(!(*type), LOGMEM(ctx->ctx), LY_EMEM);
+
+cleanup:
+    return ret;
+}
+
+LY_ERR
+lys_compile_type(struct lysc_ctx *ctx, struct lysp_node *context_pnode, uint16_t context_flags,
+        struct lysp_module *context_mod, const char *context_name, struct lysp_type *type_p,
+        struct lysc_type **type, const char **units, struct lysp_qname **dflt)
+{
+    LY_ERR ret = LY_SUCCESS;
+    ly_bool dummyloops = 0;
+    struct type_context {
+        const struct lysp_tpdf *tpdf;
+        struct lysp_node *node;
+        struct lysp_module *mod;
+    } *tctx, *tctx_prev = NULL, *tctx_iter;
+    LY_DATA_TYPE basetype = LY_TYPE_UNKNOWN;
+    struct lysc_type *base = NULL, *prev_type;
+    struct ly_set tpdf_chain = {0};
+
+    (*type) = NULL;
+    if (dflt) {
+        *dflt = NULL;
+    }
+
+    tctx = calloc(1, sizeof *tctx);
+    LY_CHECK_ERR_RET(!tctx, LOGMEM(ctx->ctx), LY_EMEM);
+    for (ret = lysp_type_find(type_p->name, context_pnode, ctx->pmod, &basetype, &tctx->tpdf, &tctx->node, &tctx->mod);
+            ret == LY_SUCCESS;
+            ret = lysp_type_find(tctx_prev->tpdf->type.name, tctx_prev->node, tctx_prev->mod,
+                    &basetype, &tctx->tpdf, &tctx->node, &tctx->mod)) {
+        if (basetype) {
+            break;
+        }
+
+        /* check status */
+        ret = lysc_check_status(ctx, context_flags, context_mod, context_name,
+                tctx->tpdf->flags, tctx->mod, tctx->node ? tctx->node->name : tctx->tpdf->name);
+        LY_CHECK_ERR_GOTO(ret, free(tctx), cleanup);
+
+        if (units && !*units) {
+            /* inherit units */
+            DUP_STRING(ctx->ctx, tctx->tpdf->units, *units, ret);
+            LY_CHECK_ERR_GOTO(ret, free(tctx), cleanup);
+        }
+        if (dflt && !*dflt && tctx->tpdf->dflt.str) {
+            /* inherit default */
+            *dflt = (struct lysp_qname *)&tctx->tpdf->dflt;
+        }
+        if (dummyloops && (!units || *units) && dflt && *dflt) {
+            basetype = ((struct type_context *)tpdf_chain.objs[tpdf_chain.count - 1])->tpdf->type.compiled->basetype;
+            break;
+        }
+
+        if (tctx->tpdf->type.compiled) {
+            /* it is not necessary to continue, the rest of the chain was already compiled,
+             * but we still may need to inherit default and units values, so start dummy loops */
+            basetype = tctx->tpdf->type.compiled->basetype;
+            ret = ly_set_add(&tpdf_chain, tctx, 1, NULL);
+            LY_CHECK_ERR_GOTO(ret, free(tctx), cleanup);
+
+            if ((units && !*units) || (dflt && !*dflt)) {
+                dummyloops = 1;
+                goto preparenext;
+            } else {
+                tctx = NULL;
+                break;
+            }
+        }
+
+        /* circular typedef reference detection */
+        for (uint32_t u = 0; u < tpdf_chain.count; u++) {
+            /* local part */
+            tctx_iter = (struct type_context *)tpdf_chain.objs[u];
+            if ((tctx_iter->mod == tctx->mod) && (tctx_iter->node == tctx->node) && (tctx_iter->tpdf == tctx->tpdf)) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                        "Invalid \"%s\" type reference - circular chain of types detected.", tctx->tpdf->name);
+                free(tctx);
+                ret = LY_EVALID;
+                goto cleanup;
+            }
+        }
+        for (uint32_t u = 0; u < ctx->tpdf_chain.count; u++) {
+            /* global part for unions corner case */
+            tctx_iter = (struct type_context *)ctx->tpdf_chain.objs[u];
+            if ((tctx_iter->mod == tctx->mod) && (tctx_iter->node == tctx->node) && (tctx_iter->tpdf == tctx->tpdf)) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                        "Invalid \"%s\" type reference - circular chain of types detected.", tctx->tpdf->name);
+                free(tctx);
+                ret = LY_EVALID;
+                goto cleanup;
+            }
+        }
+
+        /* store information for the following processing */
+        ret = ly_set_add(&tpdf_chain, tctx, 1, NULL);
+        LY_CHECK_ERR_GOTO(ret, free(tctx), cleanup);
+
+preparenext:
+        /* prepare next loop */
+        tctx_prev = tctx;
+        tctx = calloc(1, sizeof *tctx);
+        LY_CHECK_ERR_RET(!tctx, LOGMEM(ctx->ctx), LY_EMEM);
+    }
+    free(tctx);
+
+    /* allocate type according to the basetype */
+    switch (basetype) {
+    case LY_TYPE_BINARY:
+        *type = calloc(1, sizeof(struct lysc_type_bin));
+        break;
+    case LY_TYPE_BITS:
+        *type = calloc(1, sizeof(struct lysc_type_bits));
+        break;
+    case LY_TYPE_BOOL:
+    case LY_TYPE_EMPTY:
+        *type = calloc(1, sizeof(struct lysc_type));
+        break;
+    case LY_TYPE_DEC64:
+        *type = calloc(1, sizeof(struct lysc_type_dec));
+        break;
+    case LY_TYPE_ENUM:
+        *type = calloc(1, sizeof(struct lysc_type_enum));
+        break;
+    case LY_TYPE_IDENT:
+        *type = calloc(1, sizeof(struct lysc_type_identityref));
+        break;
+    case LY_TYPE_INST:
+        *type = calloc(1, sizeof(struct lysc_type_instanceid));
+        break;
+    case LY_TYPE_LEAFREF:
+        *type = calloc(1, sizeof(struct lysc_type_leafref));
+        break;
+    case LY_TYPE_STRING:
+        *type = calloc(1, sizeof(struct lysc_type_str));
+        break;
+    case LY_TYPE_UNION:
+        *type = calloc(1, sizeof(struct lysc_type_union));
+        break;
+    case LY_TYPE_INT8:
+    case LY_TYPE_UINT8:
+    case LY_TYPE_INT16:
+    case LY_TYPE_UINT16:
+    case LY_TYPE_INT32:
+    case LY_TYPE_UINT32:
+    case LY_TYPE_INT64:
+    case LY_TYPE_UINT64:
+        *type = calloc(1, sizeof(struct lysc_type_num));
+        break;
+    case LY_TYPE_UNKNOWN:
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                "Referenced type \"%s\" not found.", tctx_prev ? tctx_prev->tpdf->type.name : type_p->name);
+        ret = LY_EVALID;
+        goto cleanup;
+    }
+    LY_CHECK_ERR_GOTO(!(*type), LOGMEM(ctx->ctx), cleanup);
+    if (~type_substmt_map[basetype] & type_p->flags) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid type restrictions for %s type.",
+                ly_data_type2str[basetype]);
+        free(*type);
+        (*type) = NULL;
+        ret = LY_EVALID;
+        goto cleanup;
+    }
+
+    /* get restrictions from the referred typedefs */
+    for (uint32_t u = tpdf_chain.count - 1; u + 1 > 0; --u) {
+        tctx = (struct type_context *)tpdf_chain.objs[u];
+
+        /* remember the typedef context for circular check */
+        ret = ly_set_add(&ctx->tpdf_chain, tctx, 1, NULL);
+        LY_CHECK_GOTO(ret, cleanup);
+
+        if (tctx->tpdf->type.compiled) {
+            base = tctx->tpdf->type.compiled;
+            continue;
+        } else if ((basetype != LY_TYPE_LEAFREF) && (u != tpdf_chain.count - 1) && !(tctx->tpdf->type.flags)) {
+            /* no change, just use the type information from the base */
+            base = ((struct lysp_tpdf *)tctx->tpdf)->type.compiled = ((struct type_context *)tpdf_chain.objs[u + 1])->tpdf->type.compiled;
+            ++base->refcount;
+            continue;
+        }
+
+        ++(*type)->refcount;
+        if (~type_substmt_map[basetype] & tctx->tpdf->type.flags) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid type \"%s\" restriction(s) for %s type.",
+                    tctx->tpdf->name, ly_data_type2str[basetype]);
+            ret = LY_EVALID;
+            goto cleanup;
+        } else if ((basetype == LY_TYPE_EMPTY) && tctx->tpdf->dflt.str) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                    "Invalid type \"%s\" - \"empty\" type must not have a default value (%s).",
+                    tctx->tpdf->name, tctx->tpdf->dflt.str);
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+
+        (*type)->basetype = basetype;
+        /* TODO user type plugins */
+        (*type)->plugin = &ly_builtin_type_plugins[basetype];
+        prev_type = *type;
+        ret = lys_compile_type_(ctx, tctx->node, tctx->tpdf->flags, tctx->mod, tctx->tpdf->name,
+                &((struct lysp_tpdf *)tctx->tpdf)->type, basetype, tctx->tpdf->name, base, type);
+        LY_CHECK_GOTO(ret, cleanup);
+        base = prev_type;
+    }
+    /* remove the processed typedef contexts from the stack for circular check */
+    ctx->tpdf_chain.count = ctx->tpdf_chain.count - tpdf_chain.count;
+
+    /* process the type definition in leaf */
+    if (type_p->flags || !base || (basetype == LY_TYPE_LEAFREF)) {
+        /* get restrictions from the node itself */
+        (*type)->basetype = basetype;
+        /* TODO user type plugins */
+        (*type)->plugin = &ly_builtin_type_plugins[basetype];
+        ++(*type)->refcount;
+        ret = lys_compile_type_(ctx, context_pnode, context_flags, context_mod, context_name, type_p, basetype, NULL,
+                base, type);
+        LY_CHECK_GOTO(ret, cleanup);
+    } else if ((basetype != LY_TYPE_BOOL) && (basetype != LY_TYPE_EMPTY)) {
+        /* no specific restriction in leaf's type definition, copy from the base */
+        free(*type);
+        (*type) = base;
+        ++(*type)->refcount;
+    }
+
+    COMPILE_EXTS_GOTO(ctx, type_p->exts, (*type)->exts, (*type), LYEXT_PAR_TYPE, ret, cleanup);
+
+cleanup:
+    ly_set_erase(&tpdf_chain, free);
+    return ret;
+}
+
+/**
+ * @brief Compile status information of the given node.
+ *
+ * To simplify getting status of the node, the flags are set following inheritance rules, so all the nodes
+ * has the status correctly set during the compilation.
+ *
+ * @param[in] ctx Compile context
+ * @param[in,out] node_flags Flags of the compiled node which status is supposed to be resolved.
+ * If the status was set explicitly on the node, it is already set in the flags value and we just check
+ * the compatibility with the parent's status value.
+ * @param[in] parent_flags Flags of the parent node to check/inherit the status value.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_status(struct lysc_ctx *ctx, uint16_t *node_flags, uint16_t parent_flags)
+{
+    /* status - it is not inherited by specification, but it does not make sense to have
+     * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
+    if (!((*node_flags) & LYS_STATUS_MASK)) {
+        if (parent_flags & (LYS_STATUS_DEPRC | LYS_STATUS_OBSLT)) {
+            if ((parent_flags & 0x3) != 0x3) {
+                /* do not print the warning when inheriting status from uses - the uses_status value has a special
+                 * combination of bits (0x3) which marks the uses_status value */
+                LOGWRN(ctx->ctx, "Missing explicit \"%s\" status that was already specified in parent, inheriting.",
+                        (parent_flags & LYS_STATUS_DEPRC) ? "deprecated" : "obsolete");
+            }
+            (*node_flags) |= parent_flags & LYS_STATUS_MASK;
+        } else {
+            (*node_flags) |= LYS_STATUS_CURR;
+        }
+    } else if (parent_flags & LYS_STATUS_MASK) {
+        /* check status compatibility with the parent */
+        if ((parent_flags & LYS_STATUS_MASK) > ((*node_flags) & LYS_STATUS_MASK)) {
+            if ((*node_flags) & LYS_STATUS_CURR) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                        "A \"current\" status is in conflict with the parent's \"%s\" status.",
+                        (parent_flags & LYS_STATUS_DEPRC) ? "deprecated" : "obsolete");
+            } else { /* LYS_STATUS_DEPRC */
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                        "A \"deprecated\" status is in conflict with the parent's \"obsolete\" status.");
+            }
+            return LY_EVALID;
+        }
+    }
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Check uniqness of the node/action/notification name.
+ *
+ * Data nodes, actions/RPCs and Notifications are stored separately (in distinguish lists) in the schema
+ * structures, but they share the namespace so we need to check their name collisions.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] parent Parent of the nodes to check, can be NULL.
+ * @param[in] name Name of the item to find in the given lists.
+ * @param[in] exclude Node that was just added that should be excluded from the name checking.
+ * @return LY_SUCCESS in case of unique name, LY_EEXIST otherwise.
+ */
+static LY_ERR
+lys_compile_node_uniqness(struct lysc_ctx *ctx, const struct lysc_node *parent, const char *name,
+        const struct lysc_node *exclude)
+{
+    const struct lysc_node *iter, *iter2;
+    const struct lysc_action *actions;
+    const struct lysc_notif *notifs;
+    uint32_t getnext_flags;
+    LY_ARRAY_COUNT_TYPE u;
+
+#define CHECK_NODE(iter, exclude, name) (iter != (void *)exclude && (iter)->module == exclude->module && !strcmp(name, (iter)->name))
+
+    if (exclude->nodetype == LYS_CASE) {
+        /* check restricted only to all the cases */
+        assert(parent->nodetype == LYS_CHOICE);
+        LY_LIST_FOR(lysc_node_children(parent, 0), iter) {
+            if (CHECK_NODE(iter, exclude, name)) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPIDENT, name, "case");
+                return LY_EEXIST;
+            }
+        }
+
+        return LY_SUCCESS;
+    }
+
+    /* no reason for our parent to be choice anymore */
+    assert(!parent || (parent->nodetype != LYS_CHOICE));
+
+    if (parent && (parent->nodetype == LYS_CASE)) {
+        /* move to the first data definition parent */
+        parent = lysc_data_parent(parent);
+    }
+
+    getnext_flags = LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCHOICE;
+    if (parent && (parent->nodetype & (LYS_RPC | LYS_ACTION)) && (exclude->flags & LYS_CONFIG_R)) {
+        getnext_flags |= LYS_GETNEXT_OUTPUT;
+    }
+
+    iter = NULL;
+    while ((iter = lys_getnext(iter, parent, ctx->cur_mod->compiled, getnext_flags))) {
+        if (CHECK_NODE(iter, exclude, name)) {
+            goto error;
+        }
+
+        /* we must compare with both the choice and all its nested data-definiition nodes (but not recursively) */
+        if (iter->nodetype == LYS_CHOICE) {
+            iter2 = NULL;
+            while ((iter2 = lys_getnext(iter2, iter, NULL, LYS_GETNEXT_NOSTATECHECK))) {
+                if (CHECK_NODE(iter2, exclude, name)) {
+                    goto error;
+                }
+            }
+        }
+    }
+
+    actions = parent ? lysc_node_actions(parent) : ctx->cur_mod->compiled->rpcs;
+    LY_ARRAY_FOR(actions, u) {
+        if (CHECK_NODE(&actions[u], exclude, name)) {
+            goto error;
+        }
+    }
+
+    notifs = parent ? lysc_node_notifs(parent) : ctx->cur_mod->compiled->notifs;
+    LY_ARRAY_FOR(notifs, u) {
+        if (CHECK_NODE(&notifs[u], exclude, name)) {
+            goto error;
+        }
+    }
+    return LY_SUCCESS;
+
+error:
+    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPIDENT, name, "data definition/RPC/action/notification");
+    return LY_EEXIST;
+
+#undef CHECK_NODE
+}
+
+LY_ERR
+lys_compile_action(struct lysc_ctx *ctx, struct lysp_action *action_p, struct lysc_node *parent,
+        struct lysc_action *action, uint16_t uses_status)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lysp_node *child_p, *dev_pnode = NULL, *dev_input_p = NULL, *dev_output_p = NULL;
+    struct lysp_action *orig_action_p = action_p;
+    struct lysp_action_inout *inout_p;
+    LY_ARRAY_COUNT_TYPE u;
+    ly_bool not_supported;
+    uint32_t opt_prev = ctx->options;
+
+    lysc_update_path(ctx, parent, action_p->name);
+
+    /* apply deviation on the action/RPC */
+    LY_CHECK_RET(lys_compile_node_deviations_refines(ctx, (struct lysp_node *)action_p, parent, &dev_pnode, &not_supported));
+    if (not_supported) {
+        lysc_update_path(ctx, NULL, NULL);
+        return LY_EDENIED;
+    } else if (dev_pnode) {
+        action_p = (struct lysp_action *)dev_pnode;
+    }
+
+    /* member needed for uniqueness check lys_getnext() */
+    action->nodetype = parent ? LYS_ACTION : LYS_RPC;
+    action->module = ctx->cur_mod;
+    action->parent = parent;
+
+    LY_CHECK_RET(lys_compile_node_uniqness(ctx, parent, action_p->name, (struct lysc_node *)action));
+
+    if (ctx->options & (LYS_COMPILE_RPC_MASK | LYS_COMPILE_NOTIFICATION)) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                "Action \"%s\" is placed inside %s.", action_p->name,
+                ctx->options & LYS_COMPILE_RPC_MASK ? "another RPC/action" : "notification");
+        return LY_EVALID;
+    }
+
+    action->sp = orig_action_p;
+    action->flags = action_p->flags & LYS_FLAGS_COMPILED_MASK;
+
+    /* status - it is not inherited by specification, but it does not make sense to have
+     * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
+    LY_CHECK_RET(lys_compile_status(ctx, &action->flags, uses_status ? uses_status : (parent ? parent->flags : 0)));
+
+    DUP_STRING_GOTO(ctx->ctx, action_p->name, action->name, ret, cleanup);
+    DUP_STRING_GOTO(ctx->ctx, action_p->dsc, action->dsc, ret, cleanup);
+    DUP_STRING_GOTO(ctx->ctx, action_p->ref, action->ref, ret, cleanup);
+    COMPILE_ARRAY_GOTO(ctx, action_p->iffeatures, action->iffeatures, u, lys_compile_iffeature, ret, cleanup);
+    COMPILE_EXTS_GOTO(ctx, action_p->exts, action->exts, action, LYEXT_PAR_NODE, ret, cleanup);
+
+    /* connect any action augments */
+    LY_CHECK_RET(lys_compile_node_augments(ctx, (struct lysc_node *)action));
+
+    /* input */
+    lysc_update_path(ctx, (struct lysc_node *)action, "input");
+
+    /* apply deviations on input */
+    LY_CHECK_RET(lys_compile_node_deviations_refines(ctx, (struct lysp_node *)&action_p->input, (struct lysc_node *)action,
+            &dev_input_p, &not_supported));
+    if (not_supported) {
+        inout_p = NULL;
+    } else if (dev_input_p) {
+        inout_p = (struct lysp_action_inout *)dev_input_p;
+    } else {
+        inout_p = &action_p->input;
+    }
+
+    if (inout_p) {
+        action->input.nodetype = LYS_INPUT;
+        COMPILE_ARRAY_GOTO(ctx, inout_p->musts, action->input.musts, u, lys_compile_must, ret, cleanup);
+        COMPILE_EXTS_GOTO(ctx, inout_p->exts, action->input_exts, &action->input, LYEXT_PAR_INPUT, ret, cleanup);
+        ctx->options |= LYS_COMPILE_RPC_INPUT;
+
+        /* connect any input augments */
+        LY_CHECK_RET(lys_compile_node_augments(ctx, (struct lysc_node *)&action->input));
+
+        LY_LIST_FOR(inout_p->data, child_p) {
+            LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node *)action, uses_status, NULL));
+        }
+        ctx->options = opt_prev;
+    }
+
+    lysc_update_path(ctx, NULL, NULL);
+
+    /* output */
+    lysc_update_path(ctx, (struct lysc_node *)action, "output");
+
+    /* apply deviations on output */
+    LY_CHECK_RET(lys_compile_node_deviations_refines(ctx, (struct lysp_node *)&action_p->output, (struct lysc_node *)action,
+            &dev_output_p, &not_supported));
+    if (not_supported) {
+        inout_p = NULL;
+    } else if (dev_output_p) {
+        inout_p = (struct lysp_action_inout *)dev_output_p;
+    } else {
+        inout_p = &action_p->output;
+    }
+
+    if (inout_p) {
+        action->output.nodetype = LYS_OUTPUT;
+        COMPILE_ARRAY_GOTO(ctx, inout_p->musts, action->output.musts, u, lys_compile_must, ret, cleanup);
+        COMPILE_EXTS_GOTO(ctx, inout_p->exts, action->output_exts, &action->output, LYEXT_PAR_OUTPUT, ret, cleanup);
+        ctx->options |= LYS_COMPILE_RPC_OUTPUT;
+
+        /* connect any output augments */
+        LY_CHECK_RET(lys_compile_node_augments(ctx, (struct lysc_node *)&action->output));
+
+        LY_LIST_FOR(inout_p->data, child_p) {
+            LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node *)action, uses_status, NULL));
+        }
+        ctx->options = opt_prev;
+    }
+
+    lysc_update_path(ctx, NULL, NULL);
+
+    if ((action->input.musts || action->output.musts) && !(ctx->options & LYS_COMPILE_GROUPING)) {
+        /* do not check "must" semantics in a grouping */
+        ret = ly_set_add(&ctx->xpath, action, 0, NULL);
+        LY_CHECK_GOTO(ret, cleanup);
+    }
+
+    lysc_update_path(ctx, NULL, NULL);
+
+cleanup:
+    lysp_dev_node_free(ctx->ctx, dev_pnode);
+    lysp_dev_node_free(ctx->ctx, dev_input_p);
+    lysp_dev_node_free(ctx->ctx, dev_output_p);
+    ctx->options = opt_prev;
+    return ret;
+}
+
+LY_ERR
+lys_compile_notif(struct lysc_ctx *ctx, struct lysp_notif *notif_p, struct lysc_node *parent, struct lysc_notif *notif,
+        uint16_t uses_status)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lysp_node *child_p, *dev_pnode = NULL;
+    struct lysp_notif *orig_notif_p = notif_p;
+    LY_ARRAY_COUNT_TYPE u;
+    ly_bool not_supported;
+    uint32_t opt_prev = ctx->options;
+
+    lysc_update_path(ctx, parent, notif_p->name);
+
+    LY_CHECK_RET(lys_compile_node_deviations_refines(ctx, (struct lysp_node *)notif_p, parent, &dev_pnode, &not_supported));
+    if (not_supported) {
+        lysc_update_path(ctx, NULL, NULL);
+        return LY_EDENIED;
+    } else if (dev_pnode) {
+        notif_p = (struct lysp_notif *)dev_pnode;
+    }
+
+    /* member needed for uniqueness check lys_getnext() */
+    notif->nodetype = LYS_NOTIF;
+    notif->module = ctx->cur_mod;
+    notif->parent = parent;
+
+    LY_CHECK_RET(lys_compile_node_uniqness(ctx, parent, notif_p->name, (struct lysc_node *)notif));
+
+    if (ctx->options & (LYS_COMPILE_RPC_MASK | LYS_COMPILE_NOTIFICATION)) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                "Notification \"%s\" is placed inside %s.", notif_p->name,
+                ctx->options & LYS_COMPILE_RPC_MASK ? "RPC/action" : "another notification");
+        return LY_EVALID;
+    }
+
+    notif->sp = orig_notif_p;
+    notif->flags = notif_p->flags & LYS_FLAGS_COMPILED_MASK;
+
+    /* status - it is not inherited by specification, but it does not make sense to have
+     * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
+    ret = lys_compile_status(ctx, &notif->flags, uses_status ? uses_status : (parent ? parent->flags : 0));
+    LY_CHECK_GOTO(ret, cleanup);
+
+    DUP_STRING_GOTO(ctx->ctx, notif_p->name, notif->name, ret, cleanup);
+    DUP_STRING_GOTO(ctx->ctx, notif_p->dsc, notif->dsc, ret, cleanup);
+    DUP_STRING_GOTO(ctx->ctx, notif_p->ref, notif->ref, ret, cleanup);
+    COMPILE_ARRAY_GOTO(ctx, notif_p->iffeatures, notif->iffeatures, u, lys_compile_iffeature, ret, cleanup);
+    COMPILE_ARRAY_GOTO(ctx, notif_p->musts, notif->musts, u, lys_compile_must, ret, cleanup);
+    if (notif_p->musts && !(ctx->options & LYS_COMPILE_GROUPING)) {
+        /* do not check "must" semantics in a grouping */
+        ret = ly_set_add(&ctx->xpath, notif, 0, NULL);
+        LY_CHECK_GOTO(ret, cleanup);
+    }
+    COMPILE_EXTS_GOTO(ctx, notif_p->exts, notif->exts, notif, LYEXT_PAR_NODE, ret, cleanup);
+
+    ctx->options |= LYS_COMPILE_NOTIFICATION;
+
+    /* connect any notification augments */
+    LY_CHECK_RET(lys_compile_node_augments(ctx, (struct lysc_node *)notif));
+
+    LY_LIST_FOR(notif_p->data, child_p) {
+        ret = lys_compile_node(ctx, child_p, (struct lysc_node *)notif, uses_status, NULL);
+        LY_CHECK_GOTO(ret, cleanup);
+    }
+
+    lysc_update_path(ctx, NULL, NULL);
+
+cleanup:
+    lysp_dev_node_free(ctx->ctx, dev_pnode);
+    ctx->options = opt_prev;
+    return ret;
+}
+
+/**
+ * @brief Compile parsed container node information.
+ * @param[in] ctx Compile context
+ * @param[in] pnode Parsed container node.
+ * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
+ * is enriched with the container-specific information.
+ * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
+ */
+static LY_ERR
+lys_compile_node_container(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *node)
+{
+    struct lysp_node_container *cont_p = (struct lysp_node_container *)pnode;
+    struct lysc_node_container *cont = (struct lysc_node_container *)node;
+    struct lysp_node *child_p;
+    LY_ARRAY_COUNT_TYPE u;
+    LY_ERR ret = LY_SUCCESS;
+
+    if (cont_p->presence) {
+        /* explicit presence */
+        cont->flags |= LYS_PRESENCE;
+    } else if (cont_p->musts) {
+        /* container with a must condition */
+        LOGWRN(ctx->ctx, "Container \"%s\" changed to presence because it has a meaning from its \"must\" condition.", cont_p->name);
+        cont->flags |= LYS_PRESENCE;
+    } else if (cont_p->when) {
+        /* container with a when condition */
+        LOGWRN(ctx->ctx, "Container \"%s\" changed to presence because it has a meaning from its \"when\" condition.", cont_p->name);
+        cont->flags |= LYS_PRESENCE;
+    } else if (cont_p->parent) {
+        if (cont_p->parent->nodetype == LYS_CHOICE) {
+            /* container is an implicit case, so its existence decides the existence of the whole case */
+            LOGWRN(ctx->ctx, "Container \"%s\" changed to presence because it has a meaning as a case of choice \"%s\".",
+                    cont_p->name, cont_p->parent->name);
+            cont->flags |= LYS_PRESENCE;
+        } else if ((cont_p->parent->nodetype == LYS_CASE) &&
+                (((struct lysp_node_case *)cont_p->parent)->child == pnode) && !cont_p->next) {
+            /* container is the only node in a case, so its existence decides the existence of the whole case */
+            LOGWRN(ctx->ctx, "Container \"%s\" changed to presence because it has a meaning as a case of choice \"%s\".",
+                    cont_p->name, cont_p->parent->name);
+            cont->flags |= LYS_PRESENCE;
+        }
+    }
+
+    /* more cases when the container has meaning but is kept NP for convenience:
+     *   - when condition
+     *   - direct child action/notification
+     */
+
+    LY_LIST_FOR(cont_p->child, child_p) {
+        ret = lys_compile_node(ctx, child_p, node, 0, NULL);
+        LY_CHECK_GOTO(ret, done);
+    }
+
+    COMPILE_ARRAY_GOTO(ctx, cont_p->musts, cont->musts, u, lys_compile_must, ret, done);
+    if (cont_p->musts && !(ctx->options & LYS_COMPILE_GROUPING)) {
+        /* do not check "must" semantics in a grouping */
+        ret = ly_set_add(&ctx->xpath, cont, 0, NULL);
+        LY_CHECK_GOTO(ret, done);
+    }
+    COMPILE_OP_ARRAY_GOTO(ctx, cont_p->actions, cont->actions, node, u, lys_compile_action, 0, ret, done);
+    COMPILE_OP_ARRAY_GOTO(ctx, cont_p->notifs, cont->notifs, node, u, lys_compile_notif, 0, ret, done);
+
+done:
+    return ret;
+}
+
+/*
+ * @brief Compile type in leaf/leaf-list node and do all the necessary checks.
+ * @param[in] ctx Compile context.
+ * @param[in] context_node Schema node where the type/typedef is placed to correctly find the base types.
+ * @param[in] type_p Parsed type to compile.
+ * @param[in,out] leaf Compiled leaf structure (possibly cast leaf-list) to provide node information and to store the compiled type information.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_node_type(struct lysc_ctx *ctx, struct lysp_node *context_node, struct lysp_type *type_p,
+        struct lysc_node_leaf *leaf)
+{
+    struct lysp_qname *dflt;
+
+    LY_CHECK_RET(lys_compile_type(ctx, context_node, leaf->flags, ctx->pmod, leaf->name, type_p, &leaf->type,
+            leaf->units ? NULL : &leaf->units, &dflt));
+
+    /* store default value, if any */
+    if (dflt && !(leaf->flags & LYS_SET_DFLT)) {
+        LY_CHECK_RET(lysc_unres_leaf_dflt_add(ctx, leaf, dflt));
+    }
+
+    if (leaf->type->basetype == LY_TYPE_LEAFREF) {
+        /* store to validate the path in the current context at the end of schema compiling when all the nodes are present */
+        LY_CHECK_RET(ly_set_add(&ctx->leafrefs, leaf, 0, NULL));
+    } else if (leaf->type->basetype == LY_TYPE_UNION) {
+        LY_ARRAY_COUNT_TYPE u;
+        LY_ARRAY_FOR(((struct lysc_type_union *)leaf->type)->types, u) {
+            if (((struct lysc_type_union *)leaf->type)->types[u]->basetype == LY_TYPE_LEAFREF) {
+                /* store to validate the path in the current context at the end of schema compiling when all the nodes are present */
+                LY_CHECK_RET(ly_set_add(&ctx->leafrefs, leaf, 0, NULL));
+            }
+        }
+    } else if (leaf->type->basetype == LY_TYPE_EMPTY) {
+        if ((leaf->nodetype == LYS_LEAFLIST) && (ctx->pmod->version < LYS_VERSION_1_1)) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                    "Leaf-list of type \"empty\" is allowed only in YANG 1.1 modules.");
+            return LY_EVALID;
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Compile parsed leaf node information.
+ * @param[in] ctx Compile context
+ * @param[in] pnode Parsed leaf node.
+ * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
+ * is enriched with the leaf-specific information.
+ * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
+ */
+static LY_ERR
+lys_compile_node_leaf(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *node)
+{
+    struct lysp_node_leaf *leaf_p = (struct lysp_node_leaf *)pnode;
+    struct lysc_node_leaf *leaf = (struct lysc_node_leaf *)node;
+    LY_ARRAY_COUNT_TYPE u;
+    LY_ERR ret = LY_SUCCESS;
+
+    COMPILE_ARRAY_GOTO(ctx, leaf_p->musts, leaf->musts, u, lys_compile_must, ret, done);
+    if (leaf_p->musts && !(ctx->options & LYS_COMPILE_GROUPING)) {
+        /* do not check "must" semantics in a grouping */
+        ret = ly_set_add(&ctx->xpath, leaf, 0, NULL);
+        LY_CHECK_GOTO(ret, done);
+    }
+    if (leaf_p->units) {
+        LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, leaf_p->units, 0, &leaf->units), done);
+        leaf->flags |= LYS_SET_UNITS;
+    }
+
+    /* compile type */
+    ret = lys_compile_node_type(ctx, pnode, &leaf_p->type, leaf);
+    LY_CHECK_GOTO(ret, done);
+
+    /* store/update default value */
+    if (leaf_p->dflt.str) {
+        LY_CHECK_RET(lysc_unres_leaf_dflt_add(ctx, leaf, &leaf_p->dflt));
+        leaf->flags |= LYS_SET_DFLT;
+    }
+
+    /* checks */
+    if ((leaf->flags & LYS_SET_DFLT) && (leaf->flags & LYS_MAND_TRUE)) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                "Invalid mandatory leaf with a default value.");
+        return LY_EVALID;
+    }
+
+done:
+    return ret;
+}
+
+/**
+ * @brief Compile parsed leaf-list node information.
+ * @param[in] ctx Compile context
+ * @param[in] pnode Parsed leaf-list node.
+ * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
+ * is enriched with the leaf-list-specific information.
+ * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
+ */
+static LY_ERR
+lys_compile_node_leaflist(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *node)
+{
+    struct lysp_node_leaflist *llist_p = (struct lysp_node_leaflist *)pnode;
+    struct lysc_node_leaflist *llist = (struct lysc_node_leaflist *)node;
+    LY_ARRAY_COUNT_TYPE u;
+    LY_ERR ret = LY_SUCCESS;
+
+    COMPILE_ARRAY_GOTO(ctx, llist_p->musts, llist->musts, u, lys_compile_must, ret, done);
+    if (llist_p->musts && !(ctx->options & LYS_COMPILE_GROUPING)) {
+        /* do not check "must" semantics in a grouping */
+        ret = ly_set_add(&ctx->xpath, llist, 0, NULL);
+        LY_CHECK_GOTO(ret, done);
+    }
+    if (llist_p->units) {
+        LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, llist_p->units, 0, &llist->units), done);
+        llist->flags |= LYS_SET_UNITS;
+    }
+
+    /* compile type */
+    ret = lys_compile_node_type(ctx, pnode, &llist_p->type, (struct lysc_node_leaf *)llist);
+    LY_CHECK_GOTO(ret, done);
+
+    /* store/update default values */
+    if (llist_p->dflts) {
+        if (ctx->pmod->version < LYS_VERSION_1_1) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                    "Leaf-list default values are allowed only in YANG 1.1 modules.");
+            return LY_EVALID;
+        }
+
+        LY_CHECK_GOTO(lysc_unres_llist_dflts_add(ctx, llist, llist_p->dflts), done);
+        llist->flags |= LYS_SET_DFLT;
+    }
+
+    llist->min = llist_p->min;
+    if (llist->min) {
+        llist->flags |= LYS_MAND_TRUE;
+    }
+    llist->max = llist_p->max ? llist_p->max : (uint32_t)-1;
+
+    /* checks */
+    if ((llist->flags & LYS_SET_DFLT) && (llist->flags & LYS_MAND_TRUE)) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                "Invalid mandatory leaf-list with default value(s).");
+        return LY_EVALID;
+    }
+
+    if (llist->min > llist->max) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Leaf-list min-elements %u is bigger than max-elements %u.",
+                llist->min, llist->max);
+        return LY_EVALID;
+    }
+
+done:
+    return ret;
+}
+
+LY_ERR
+lysc_resolve_schema_nodeid(struct lysc_ctx *ctx, const char *nodeid, size_t nodeid_len, const struct lysc_node *ctx_node,
+        const struct lys_module *cur_mod, LY_PREFIX_FORMAT format, void *prefix_data, uint16_t nodetype,
+        const struct lysc_node **target, uint16_t *result_flag)
+{
+    LY_ERR ret = LY_EVALID;
+    const char *name, *prefix, *id;
+    size_t name_len, prefix_len;
+    const struct lys_module *mod;
+    const char *nodeid_type;
+    uint32_t getnext_extra_flag = 0;
+    uint16_t current_nodetype = 0;
+
+    assert(nodeid);
+    assert(target);
+    assert(result_flag);
+    *target = NULL;
+    *result_flag = 0;
+
+    id = nodeid;
+
+    if (ctx_node) {
+        /* descendant-schema-nodeid */
+        nodeid_type = "descendant";
+
+        if (*id == '/') {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid descendant-schema-nodeid value \"%.*s\" - absolute-schema-nodeid used.",
+                    nodeid_len ? nodeid_len : strlen(nodeid), nodeid);
+            return LY_EVALID;
+        }
+    } else {
+        /* absolute-schema-nodeid */
+        nodeid_type = "absolute";
+
+        if (*id != '/') {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid absolute-schema-nodeid value \"%.*s\" - missing starting \"/\".",
+                    nodeid_len ? nodeid_len : strlen(nodeid), nodeid);
+            return LY_EVALID;
+        }
+        ++id;
+    }
+
+    while (*id && (ret = ly_parse_nodeid(&id, &prefix, &prefix_len, &name, &name_len)) == LY_SUCCESS) {
+        if (prefix) {
+            mod = ly_resolve_prefix(ctx->ctx, prefix, prefix_len, format, prefix_data);
+            if (!mod) {
+                /* module must always be found */
+                assert(prefix);
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                        "Invalid %s-schema-nodeid value \"%.*s\" - prefix \"%.*s\" not defined in module \"%s\".",
+                        nodeid_type, id - nodeid, nodeid, prefix_len, prefix, LYSP_MODULE_NAME(ctx->pmod));
+                return LY_ENOTFOUND;
+            }
+        } else {
+            switch (format) {
+            case LY_PREF_SCHEMA:
+            case LY_PREF_SCHEMA_RESOLVED:
+                /* use the current module */
+                mod = cur_mod;
+                break;
+            case LY_PREF_JSON:
+                if (!ctx_node) {
+                    LOGINT_RET(ctx->ctx);
+                }
+                /* inherit the module of the previous context node */
+                mod = ctx_node->module;
+                break;
+            case LY_PREF_XML:
+                /* not really defined */
+                LOGINT_RET(ctx->ctx);
+            }
+        }
+
+        if (ctx_node && (ctx_node->nodetype & (LYS_RPC | LYS_ACTION))) {
+            /* move through input/output manually */
+            if (mod != ctx_node->module) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                        "Invalid %s-schema-nodeid value \"%.*s\" - target node not found.", nodeid_type, id - nodeid, nodeid);
+                return LY_ENOTFOUND;
+            }
+            if (!ly_strncmp("input", name, name_len)) {
+                ctx_node = (struct lysc_node *)&((struct lysc_action *)ctx_node)->input;
+            } else if (!ly_strncmp("output", name, name_len)) {
+                ctx_node = (struct lysc_node *)&((struct lysc_action *)ctx_node)->output;
+                getnext_extra_flag = LYS_GETNEXT_OUTPUT;
+            } else {
+                /* only input or output is valid */
+                ctx_node = NULL;
+            }
+        } else {
+            ctx_node = lys_find_child(ctx_node, mod, name, name_len, 0,
+                    getnext_extra_flag | LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCHOICE | LYS_GETNEXT_WITHCASE);
+            getnext_extra_flag = 0;
+        }
+        if (!ctx_node) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid %s-schema-nodeid value \"%.*s\" - target node not found.", nodeid_type, id - nodeid, nodeid);
+            return LY_ENOTFOUND;
+        }
+        current_nodetype = ctx_node->nodetype;
+
+        if (current_nodetype == LYS_NOTIF) {
+            (*result_flag) |= LYS_COMPILE_NOTIFICATION;
+        } else if (current_nodetype == LYS_INPUT) {
+            (*result_flag) |= LYS_COMPILE_RPC_INPUT;
+        } else if (current_nodetype == LYS_OUTPUT) {
+            (*result_flag) |= LYS_COMPILE_RPC_OUTPUT;
+        }
+
+        if (!*id || (nodeid_len && ((size_t)(id - nodeid) >= nodeid_len))) {
+            break;
+        }
+        if (*id != '/') {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid %s-schema-nodeid value \"%.*s\" - missing \"/\" as node-identifier separator.",
+                    nodeid_type, id - nodeid + 1, nodeid);
+            return LY_EVALID;
+        }
+        ++id;
+    }
+
+    if (ret == LY_SUCCESS) {
+        *target = ctx_node;
+        if (nodetype && !(current_nodetype & nodetype)) {
+            return LY_EDENIED;
+        }
+    } else {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                "Invalid %s-schema-nodeid value \"%.*s\" - unexpected end of expression.",
+                nodeid_type, nodeid_len ? nodeid_len : strlen(nodeid), nodeid);
+    }
+
+    return ret;
+}
+
+/**
+ * @brief Compile information about list's uniques.
+ * @param[in] ctx Compile context.
+ * @param[in] uniques Sized array list of unique statements.
+ * @param[in] list Compiled list where the uniques are supposed to be resolved and stored.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_node_list_unique(struct lysc_ctx *ctx, struct lysp_qname *uniques, struct lysc_node_list *list)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lysc_node_leaf **key, ***unique;
+    struct lysc_node *parent;
+    const char *keystr, *delim;
+    size_t len;
+    LY_ARRAY_COUNT_TYPE v;
+    int8_t config; /* -1 - not yet seen; 0 - LYS_CONFIG_R; 1 - LYS_CONFIG_W */
+    uint16_t flags;
+
+    LY_ARRAY_FOR(uniques, v) {
+        config = -1;
+        LY_ARRAY_NEW_RET(ctx->ctx, list->uniques, unique, LY_EMEM);
+        keystr = uniques[v].str;
+        while (keystr) {
+            delim = strpbrk(keystr, " \t\n");
+            if (delim) {
+                len = delim - keystr;
+                while (isspace(*delim)) {
+                    ++delim;
+                }
+            } else {
+                len = strlen(keystr);
+            }
+
+            /* unique node must be present */
+            LY_ARRAY_NEW_RET(ctx->ctx, *unique, key, LY_EMEM);
+            ret = lysc_resolve_schema_nodeid(ctx, keystr, len, (struct lysc_node *)list, uniques[v].mod->mod,
+                    LY_PREF_SCHEMA, (void *)uniques[v].mod, LYS_LEAF, (const struct lysc_node **)key, &flags);
+            if (ret != LY_SUCCESS) {
+                if (ret == LY_EDENIED) {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                            "Unique's descendant-schema-nodeid \"%.*s\" refers to %s node instead of a leaf.",
+                            len, keystr, lys_nodetype2str((*key)->nodetype));
+                }
+                return LY_EVALID;
+            } else if (flags) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                        "Unique's descendant-schema-nodeid \"%.*s\" refers into %s node.",
+                        len, keystr, flags & LYS_COMPILE_NOTIFICATION ? "notification" : "RPC/action");
+                return LY_EVALID;
+            }
+
+            /* all referenced leafs must be of the same config type */
+            if ((config != -1) && ((((*key)->flags & LYS_CONFIG_W) && (config == 0)) ||
+                    (((*key)->flags & LYS_CONFIG_R) && (config == 1)))) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                        "Unique statement \"%s\" refers to leaves with different config type.", uniques[v].str);
+                return LY_EVALID;
+            } else if ((*key)->flags & LYS_CONFIG_W) {
+                config = 1;
+            } else { /* LYS_CONFIG_R */
+                config = 0;
+            }
+
+            /* we forbid referencing nested lists because it is unspecified what instance of such a list to use */
+            for (parent = (*key)->parent; parent != (struct lysc_node *)list; parent = parent->parent) {
+                if (parent->nodetype == LYS_LIST) {
+                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                            "Unique statement \"%s\" refers to a leaf in nested list \"%s\".", uniques[v].str, parent->name);
+                    return LY_EVALID;
+                }
+            }
+
+            /* check status */
+            LY_CHECK_RET(lysc_check_status(ctx, list->flags, list->module, list->name,
+                    (*key)->flags, (*key)->module, (*key)->name));
+
+            /* mark leaf as unique */
+            (*key)->flags |= LYS_UNIQUE;
+
+            /* next unique value in line */
+            keystr = delim;
+        }
+        /* next unique definition */
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Compile parsed list node information.
+ * @param[in] ctx Compile context
+ * @param[in] pnode Parsed list node.
+ * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
+ * is enriched with the list-specific information.
+ * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
+ */
+static LY_ERR
+lys_compile_node_list(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *node)
+{
+    struct lysp_node_list *list_p = (struct lysp_node_list *)pnode;
+    struct lysc_node_list *list = (struct lysc_node_list *)node;
+    struct lysp_node *child_p;
+    struct lysc_node_leaf *key, *prev_key = NULL;
+    size_t len;
+    LY_ARRAY_COUNT_TYPE u;
+    const char *keystr, *delim;
+    LY_ERR ret = LY_SUCCESS;
+
+    list->min = list_p->min;
+    if (list->min) {
+        list->flags |= LYS_MAND_TRUE;
+    }
+    list->max = list_p->max ? list_p->max : (uint32_t)-1;
+
+    LY_LIST_FOR(list_p->child, child_p) {
+        LY_CHECK_RET(lys_compile_node(ctx, child_p, node, 0, NULL));
+    }
+
+    COMPILE_ARRAY_GOTO(ctx, list_p->musts, list->musts, u, lys_compile_must, ret, done);
+    if (list_p->musts && !(ctx->options & LYS_COMPILE_GROUPING)) {
+        /* do not check "must" semantics in a grouping */
+        LY_CHECK_RET(ly_set_add(&ctx->xpath, list, 0, NULL));
+    }
+
+    /* keys */
+    if ((list->flags & LYS_CONFIG_W) && (!list_p->key || !list_p->key[0])) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Missing key in list representing configuration data.");
+        return LY_EVALID;
+    }
+
+    /* find all the keys (must be direct children) */
+    keystr = list_p->key;
+    if (!keystr) {
+        /* keyless list */
+        list->flags |= LYS_KEYLESS;
+    }
+    while (keystr) {
+        delim = strpbrk(keystr, " \t\n");
+        if (delim) {
+            len = delim - keystr;
+            while (isspace(*delim)) {
+                ++delim;
+            }
+        } else {
+            len = strlen(keystr);
+        }
+
+        /* key node must be present */
+        key = (struct lysc_node_leaf *)lys_find_child(node, node->module, keystr, len, LYS_LEAF, LYS_GETNEXT_NOCHOICE | LYS_GETNEXT_NOSTATECHECK);
+        if (!(key)) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "The list's key \"%.*s\" not found.", len, keystr);
+            return LY_EVALID;
+        }
+        /* keys must be unique */
+        if (key->flags & LYS_KEY) {
+            /* the node was already marked as a key */
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                    "Duplicated key identifier \"%.*s\".", len, keystr);
+            return LY_EVALID;
+        }
+
+        lysc_update_path(ctx, (struct lysc_node *)list, key->name);
+        /* key must have the same config flag as the list itself */
+        if ((list->flags & LYS_CONFIG_MASK) != (key->flags & LYS_CONFIG_MASK)) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Key of the configuration list must not be status leaf.");
+            return LY_EVALID;
+        }
+        if (ctx->pmod->version < LYS_VERSION_1_1) {
+            /* YANG 1.0 denies key to be of empty type */
+            if (key->type->basetype == LY_TYPE_EMPTY) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                        "List's key cannot be of \"empty\" type until it is in YANG 1.1 module.");
+                return LY_EVALID;
+            }
+        } else {
+            /* when and if-feature are illegal on list keys */
+            if (key->when) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                        "List's key must not have any \"when\" statement.");
+                return LY_EVALID;
+            }
+            if (key->iffeatures) {
+                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                        "List's key must not have any \"if-feature\" statement.");
+                return LY_EVALID;
+            }
+        }
+
+        /* check status */
+        LY_CHECK_RET(lysc_check_status(ctx, list->flags, list->module, list->name,
+                key->flags, key->module, key->name));
+
+        /* ignore default values of the key */
+        if (key->dflt) {
+            key->dflt->realtype->plugin->free(ctx->ctx, key->dflt);
+            lysc_type_free(ctx->ctx, (struct lysc_type *)key->dflt->realtype);
+            free(key->dflt);
+            key->dflt = NULL;
+        }
+        /* mark leaf as key */
+        key->flags |= LYS_KEY;
+
+        /* move it to the correct position */
+        if ((prev_key && ((struct lysc_node *)prev_key != key->prev)) || (!prev_key && key->prev->next)) {
+            /* fix links in closest previous siblings of the key */
+            if (key->next) {
+                key->next->prev = key->prev;
+            } else {
+                /* last child */
+                list->child->prev = key->prev;
+            }
+            if (key->prev->next) {
+                key->prev->next = key->next;
+            }
+            /* fix links in the key */
+            if (prev_key) {
+                key->prev = (struct lysc_node *)prev_key;
+                key->next = prev_key->next;
+            } else {
+                key->prev = list->child->prev;
+                key->next = list->child;
+            }
+            /* fix links in closes future siblings of the key */
+            if (prev_key) {
+                if (prev_key->next) {
+                    prev_key->next->prev = (struct lysc_node *)key;
+                } else {
+                    list->child->prev = (struct lysc_node *)key;
+                }
+                prev_key->next = (struct lysc_node *)key;
+            } else {
+                list->child->prev = (struct lysc_node *)key;
+            }
+            /* fix links in parent */
+            if (!key->prev->next) {
+                list->child = (struct lysc_node *)key;
+            }
+        }
+
+        /* next key value */
+        prev_key = key;
+        keystr = delim;
+        lysc_update_path(ctx, NULL, NULL);
+    }
+
+    /* uniques */
+    if (list_p->uniques) {
+        LY_CHECK_RET(lys_compile_node_list_unique(ctx, list_p->uniques, list));
+    }
+
+    COMPILE_OP_ARRAY_GOTO(ctx, list_p->actions, list->actions, node, u, lys_compile_action, 0, ret, done);
+    COMPILE_OP_ARRAY_GOTO(ctx, list_p->notifs, list->notifs, node, u, lys_compile_notif, 0, ret, done);
+
+    /* checks */
+    if (list->min > list->max) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "List min-elements %u is bigger than max-elements %u.",
+                list->min, list->max);
+        return LY_EVALID;
+    }
+
+done:
+    return ret;
+}
+
+/**
+ * @brief Do some checks and set the default choice's case.
+ *
+ * Selects (and stores into ::lysc_node_choice#dflt) the default case and set LYS_SET_DFLT flag on it.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] dflt Name of the default branch. Can even contain a prefix.
+ * @param[in,out] ch The compiled choice node, its dflt member is filled to point to the default case node of the choice.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_node_choice_dflt(struct lysc_ctx *ctx, struct lysp_qname *dflt, struct lysc_node_choice *ch)
+{
+    struct lysc_node *iter, *node = (struct lysc_node *)ch;
+    const struct lys_module *mod;
+    const char *prefix = NULL, *name;
+    size_t prefix_len = 0;
+
+    /* could use lys_parse_nodeid(), but it checks syntax which is already done in this case by the parsers */
+    name = strchr(dflt->str, ':');
+    if (name) {
+        prefix = dflt->str;
+        prefix_len = name - prefix;
+        ++name;
+    } else {
+        name = dflt->str;
+    }
+    if (prefix) {
+        mod = ly_resolve_prefix(ctx->ctx, prefix, prefix_len, LY_PREF_SCHEMA, (void *)dflt->mod);
+        if (!mod) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Default case prefix \"%.*s\" not found "
+                    "in imports of \"%s\".", prefix_len, prefix, LYSP_MODULE_NAME(dflt->mod));
+            return LY_EVALID;
+        }
+    } else {
+        mod = node->module;
+    }
+
+    ch->dflt = (struct lysc_node_case *)lys_find_child(node, mod, name, 0, LYS_CASE, LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCASE);
+    if (!ch->dflt) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                "Default case \"%s\" not found.", dflt->str);
+        return LY_EVALID;
+    }
+
+    /* no mandatory nodes directly under the default case */
+    LY_LIST_FOR(ch->dflt->child, iter) {
+        if (iter->parent != (struct lysc_node *)ch->dflt) {
+            break;
+        }
+        if (iter->flags & LYS_MAND_TRUE) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                    "Mandatory node \"%s\" under the default case \"%s\".", iter->name, dflt->str);
+            return LY_EVALID;
+        }
+    }
+
+    if (ch->flags & LYS_MAND_TRUE) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Invalid mandatory choice with a default case.");
+        return LY_EVALID;
+    }
+
+    ch->dflt->flags |= LYS_SET_DFLT;
+    return LY_SUCCESS;
+}
+
+LY_ERR
+lys_compile_node_choice_child(struct lysc_ctx *ctx, struct lysp_node *child_p, struct lysc_node *node,
+        struct ly_set *child_set)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lysp_node *child_p_next = child_p->next;
+    struct lysp_node_case *cs_p;
+
+    if (child_p->nodetype == LYS_CASE) {
+        /* standard case under choice */
+        ret = lys_compile_node(ctx, child_p, node, 0, child_set);
+    } else {
+        /* we need the implicit case first, so create a fake parsed case */
+        cs_p = calloc(1, sizeof *cs_p);
+        cs_p->nodetype = LYS_CASE;
+        DUP_STRING_GOTO(ctx->ctx, child_p->name, cs_p->name, ret, free_fake_node);
+        cs_p->child = child_p;
+
+        /* make the child the only case child */
+        child_p->next = NULL;
+
+        /* compile it normally */
+        ret = lys_compile_node(ctx, (struct lysp_node *)cs_p, node, 0, child_set);
+
+free_fake_node:
+        /* free the fake parsed node and correct pointers back */
+        cs_p->child = NULL;
+        lysp_node_free(ctx->ctx, (struct lysp_node *)cs_p);
+        child_p->next = child_p_next;
+    }
+
+    return ret;
+}
+
+/**
+ * @brief Compile parsed choice node information.
+ *
+ * @param[in] ctx Compile context
+ * @param[in] pnode Parsed choice node.
+ * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
+ * is enriched with the choice-specific information.
+ * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
+ */
+static LY_ERR
+lys_compile_node_choice(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *node)
+{
+    struct lysp_node_choice *ch_p = (struct lysp_node_choice *)pnode;
+    struct lysc_node_choice *ch = (struct lysc_node_choice *)node;
+    struct lysp_node *child_p;
+    LY_ERR ret = LY_SUCCESS;
+
+    assert(node->nodetype == LYS_CHOICE);
+
+    LY_LIST_FOR(ch_p->child, child_p) {
+        LY_CHECK_RET(lys_compile_node_choice_child(ctx, child_p, node, NULL));
+    }
+
+    /* default branch */
+    if (ch_p->dflt.str) {
+        LY_CHECK_RET(lys_compile_node_choice_dflt(ctx, &ch_p->dflt, ch));
+    }
+
+    return ret;
+}
+
+/**
+ * @brief Compile parsed anydata or anyxml node information.
+ * @param[in] ctx Compile context
+ * @param[in] pnode Parsed anydata or anyxml node.
+ * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
+ * is enriched with the any-specific information.
+ * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
+ */
+static LY_ERR
+lys_compile_node_any(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *node)
+{
+    struct lysp_node_anydata *any_p = (struct lysp_node_anydata *)pnode;
+    struct lysc_node_anydata *any = (struct lysc_node_anydata *)node;
+    LY_ARRAY_COUNT_TYPE u;
+    LY_ERR ret = LY_SUCCESS;
+
+    COMPILE_ARRAY_GOTO(ctx, any_p->musts, any->musts, u, lys_compile_must, ret, done);
+    if (any_p->musts && !(ctx->options & LYS_COMPILE_GROUPING)) {
+        /* do not check "must" semantics in a grouping */
+        ret = ly_set_add(&ctx->xpath, any, 0, NULL);
+        LY_CHECK_GOTO(ret, done);
+    }
+
+    if (any->flags & LYS_CONFIG_W) {
+        LOGWRN(ctx->ctx, "Use of %s to define configuration data is not recommended. %s",
+                ly_stmt2str(any->nodetype == LYS_ANYDATA ? LY_STMT_ANYDATA : LY_STMT_ANYXML), ctx->path);
+    }
+done:
+    return ret;
+}
+
+/**
+ * @brief Connect the node into the siblings list and check its name uniqueness. Also,
+ * keep specific order of augments targetting the same node.
+ *
+ * @param[in] ctx Compile context
+ * @param[in] parent Parent node holding the children list, in case of node from a choice's case,
+ * the choice itself is expected instead of a specific case node.
+ * @param[in] node Schema node to connect into the list.
+ * @return LY_ERR value - LY_SUCCESS or LY_EEXIST.
+ * In case of LY_EEXIST, the node is actually kept in the tree, so do not free it directly.
+ */
+static LY_ERR
+lys_compile_node_connect(struct lysc_ctx *ctx, struct lysc_node *parent, struct lysc_node *node)
+{
+    struct lysc_node **children, *anchor = NULL;
+    int insert_after = 0;
+
+    node->parent = parent;
+
+    if (parent) {
+        if (parent->nodetype == LYS_CHOICE) {
+            assert(node->nodetype == LYS_CASE);
+            children = (struct lysc_node **)&((struct lysc_node_choice *)parent)->cases;
+        } else {
+            children = lysc_node_children_p(parent, ctx->options);
+        }
+        assert(children);
+
+        if (!(*children)) {
+            /* first child */
+            *children = node;
+        } else if (node->flags & LYS_KEY) {
+            /* special handling of adding keys */
+            assert(node->module == parent->module);
+            anchor = *children;
+            if (anchor->flags & LYS_KEY) {
+                while ((anchor->flags & LYS_KEY) && anchor->next) {
+                    anchor = anchor->next;
+                }
+                /* insert after the last key */
+                insert_after = 1;
+            } /* else insert before anchor (at the beginning) */
+        } else if ((*children)->prev->module == node->module) {
+            /* last child is from the same module, keep the order and insert at the end */
+            anchor = (*children)->prev;
+            insert_after = 1;
+        } else if (parent->module == node->module) {
+            /* adding module child after some augments were connected */
+            for (anchor = *children; anchor->module == node->module; anchor = anchor->next) {}
+        } else {
+            /* some augments are already connected and we are connecting new ones,
+             * keep module name order and insert the node into the children list */
+            anchor = *children;
+            do {
+                anchor = anchor->prev;
+
+                /* check that we have not found the last augment node from our module or
+                 * the first augment node from a "smaller" module or
+                 * the first node from a local module */
+                if ((anchor->module == node->module) || (strcmp(anchor->module->name, node->module->name) < 0) ||
+                        (anchor->module == parent->module)) {
+                    /* insert after */
+                    insert_after = 1;
+                    break;
+                }
+
+                /* we have traversed all the nodes, insert before anchor (as the first node) */
+            } while (anchor->prev->next);
+        }
+
+        /* insert */
+        if (anchor) {
+            if (insert_after) {
+                node->next = anchor->next;
+                node->prev = anchor;
+                anchor->next = node;
+                if (node->next) {
+                    /* middle node */
+                    node->next->prev = node;
+                } else {
+                    /* last node */
+                    (*children)->prev = node;
+                }
+            } else {
+                node->next = anchor;
+                node->prev = anchor->prev;
+                anchor->prev = node;
+                if (anchor == *children) {
+                    /* first node */
+                    *children = node;
+                } else {
+                    /* middle node */
+                    node->prev->next = node;
+                }
+            }
+        }
+
+        /* check the name uniqueness (even for an only child, it may be in case) */
+        if (lys_compile_node_uniqness(ctx, parent, node->name, node)) {
+            return LY_EEXIST;
+        }
+    } else {
+        /* top-level element */
+        if (!ctx->cur_mod->compiled->data) {
+            ctx->cur_mod->compiled->data = node;
+        } else {
+            /* insert at the end of the module's top-level nodes list */
+            ctx->cur_mod->compiled->data->prev->next = node;
+            node->prev = ctx->cur_mod->compiled->data->prev;
+            ctx->cur_mod->compiled->data->prev = node;
+        }
+
+        /* check the name uniqueness on top-level */
+        if (lys_compile_node_uniqness(ctx, NULL, node->name, node)) {
+            return LY_EEXIST;
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Prepare the case structure in choice node for the new data node.
+ *
+ * It is able to handle implicit as well as explicit cases and the situation when the case has multiple data nodes and the case was already
+ * created in the choice when the first child was processed.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] pnode Node image from the parsed tree. If the case is explicit, it is the LYS_CASE node, but in case of implicit case,
+ *                   it is the LYS_CHOICE, LYS_AUGMENT or LYS_GROUPING node.
+ * @param[in] ch The compiled choice structure where the new case structures are created (if needed).
+ * @param[in] child The new data node being part of a case (no matter if explicit or implicit).
+ * @return The case structure where the child node belongs to, NULL in case of error. Note that the child is not connected into the siblings list,
+ * it is linked from the case structure only in case it is its first child.
+ */
+static LY_ERR
+lys_compile_node_case(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *node)
+{
+    struct lysp_node *child_p;
+    struct lysp_node_case *cs_p = (struct lysp_node_case *)pnode;
+
+    if (pnode->nodetype & (LYS_CHOICE | LYS_AUGMENT | LYS_GROUPING)) {
+        /* we have to add an implicit case node into the parent choice */
+    } else if (pnode->nodetype == LYS_CASE) {
+        /* explicit parent case */
+        LY_LIST_FOR(cs_p->child, child_p) {
+            LY_CHECK_RET(lys_compile_node(ctx, child_p, node, 0, NULL));
+        }
+    } else {
+        LOGINT_RET(ctx->ctx);
+    }
+
+    return LY_SUCCESS;
+}
+
+void
+lys_compile_mandatory_parents(struct lysc_node *parent, ly_bool add)
+{
+    struct lysc_node *iter;
+
+    if (add) { /* set flag */
+        for ( ; parent && parent->nodetype == LYS_CONTAINER && !(parent->flags & LYS_MAND_TRUE) && !(parent->flags & LYS_PRESENCE);
+                parent = parent->parent) {
+            parent->flags |= LYS_MAND_TRUE;
+        }
+    } else { /* unset flag */
+        for ( ; parent && parent->nodetype == LYS_CONTAINER && (parent->flags & LYS_MAND_TRUE); parent = parent->parent) {
+            for (iter = (struct lysc_node *)lysc_node_children(parent, 0); iter; iter = iter->next) {
+                if (iter->flags & LYS_MAND_TRUE) {
+                    /* there is another mandatory node */
+                    return;
+                }
+            }
+            /* unset mandatory flag - there is no mandatory children in the non-presence container */
+            parent->flags &= ~LYS_MAND_TRUE;
+        }
+    }
+}
+
+/**
+ * @brief Find grouping for a uses.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] uses_p Parsed uses node.
+ * @param[out] gpr_p Found grouping on success.
+ * @param[out] grp_pmod Module of @p grp_p on success.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_uses_find_grouping(struct lysc_ctx *ctx, struct lysp_node_uses *uses_p, struct lysp_grp **grp_p,
+        struct lysp_module **grp_pmod)
+{
+    struct lysp_node *pnode;
+    struct lysp_grp *grp;
+    LY_ARRAY_COUNT_TYPE u, v;
+    const char *id, *name, *prefix, *local_pref;
+    size_t prefix_len, name_len;
+    struct lysp_module *pmod, *found = NULL;
+    struct lys_module *mod;
+
+    *grp_p = NULL;
+    *grp_pmod = NULL;
+
+    /* search for the grouping definition */
+    id = uses_p->name;
+    LY_CHECK_RET(ly_parse_nodeid(&id, &prefix, &prefix_len, &name, &name_len), LY_EVALID);
+    local_pref = ctx->pmod->is_submod ? ((struct lysp_submodule *)ctx->pmod)->prefix : ctx->pmod->mod->prefix;
+    if (!prefix || !ly_strncmp(local_pref, prefix, prefix_len)) {
+        /* current module, search local groupings first */
+        pmod = ctx->pmod;
+        for (pnode = uses_p->parent; !found && pnode; pnode = pnode->parent) {
+            grp = (struct lysp_grp *)lysp_node_groupings(pnode);
+            LY_ARRAY_FOR(grp, u) {
+                if (!strcmp(grp[u].name, name)) {
+                    grp = &grp[u];
+                    found = ctx->pmod;
+                    break;
+                }
+            }
+        }
+    } else {
+        /* foreign module, find it first */
+        mod = lysp_module_find_prefix(ctx->pmod, prefix, prefix_len);
+        if (!mod) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                    "Invalid prefix used for grouping reference.", uses_p->name);
+            return LY_EVALID;
+        }
+        pmod = mod->parsed;
+    }
+
+    if (!found) {
+        /* search in top-level groupings of the main module ... */
+        grp = pmod->groupings;
+        LY_ARRAY_FOR(grp, u) {
+            if (!strcmp(grp[u].name, name)) {
+                grp = &grp[u];
+                found = pmod;
+                break;
+            }
+        }
+        if (!found) {
+            /* ... and all the submodules */
+            LY_ARRAY_FOR(pmod->includes, u) {
+                grp = pmod->includes[u].submodule->groupings;
+                LY_ARRAY_FOR(grp, v) {
+                    if (!strcmp(grp[v].name, name)) {
+                        grp = &grp[v];
+                        found = (struct lysp_module *)pmod->includes[u].submodule;
+                        break;
+                    }
+                }
+                if (found) {
+                    break;
+                }
+            }
+        }
+    }
+    if (!found) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                "Grouping \"%s\" referenced by a uses statement not found.", uses_p->name);
+        return LY_EVALID;
+    }
+
+    if (!(ctx->options & LYS_COMPILE_GROUPING)) {
+        /* remember that the grouping is instantiated to avoid its standalone validation */
+        grp->flags |= LYS_USED_GRP;
+    }
+
+    *grp_p = grp;
+    *grp_pmod = found;
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Compile parsed uses statement - resolve target grouping and connect its content into parent.
+ * If present, also apply uses's modificators.
+ *
+ * @param[in] ctx Compile context
+ * @param[in] uses_p Parsed uses schema node.
+ * @param[in] parent Compiled parent node where the content of the referenced grouping is supposed to be connected. It is
+ * NULL for top-level nodes, in such a case the module where the node will be connected is taken from
+ * the compile context.
+ * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
+ */
+static LY_ERR
+lys_compile_uses(struct lysc_ctx *ctx, struct lysp_node_uses *uses_p, struct lysc_node *parent, struct ly_set *child_set)
+{
+    struct lysp_node *pnode;
+    struct lysc_node *child;
+    struct lysp_grp *grp = NULL;
+    uint32_t i, grp_stack_count;
+    struct lysp_module *grp_mod, *mod_old = ctx->pmod;
+    LY_ERR ret = LY_SUCCESS;
+    struct lysc_when *when_shared = NULL;
+    LY_ARRAY_COUNT_TYPE u;
+    struct lysc_notif **notifs = NULL;
+    struct lysc_action **actions = NULL;
+    struct ly_set uses_child_set = {0};
+
+    /* find the referenced grouping */
+    LY_CHECK_RET(lys_compile_uses_find_grouping(ctx, uses_p, &grp, &grp_mod));
+
+    /* grouping must not reference themselves - stack in ctx maintains list of groupings currently being applied */
+    grp_stack_count = ctx->groupings.count;
+    LY_CHECK_RET(ly_set_add(&ctx->groupings, (void *)grp, 0, NULL));
+    if (grp_stack_count == ctx->groupings.count) {
+        /* the target grouping is already in the stack, so we are already inside it -> circular dependency */
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                "Grouping \"%s\" references itself through a uses statement.", grp->name);
+        return LY_EVALID;
+    }
+
+    /* check status */
+    ret = lysc_check_status(ctx, uses_p->flags, ctx->pmod, uses_p->name, grp->flags, grp_mod, grp->name);
+    LY_CHECK_GOTO(ret, cleanup);
+
+    /* compile any augments and refines so they can be applied during the grouping nodes compilation */
+    ret = lys_precompile_uses_augments_refines(ctx, uses_p, parent);
+    LY_CHECK_GOTO(ret, cleanup);
+
+    /* switch context's parsed module being processed */
+    ctx->pmod = grp_mod;
+
+    /* compile data nodes */
+    LY_LIST_FOR(grp->data, pnode) {
+        /* 0x3 in uses_status is a special bits combination to be able to detect status flags from uses */
+        ret = lys_compile_node(ctx, pnode, parent, (uses_p->flags & LYS_STATUS_MASK) | 0x3, &uses_child_set);
+        LY_CHECK_GOTO(ret, cleanup);
+    }
+
+    if (child_set) {
+        /* add these children to our compiled child_set as well since uses is a schema-only node */
+        LY_CHECK_GOTO(ret = ly_set_merge(child_set, &uses_child_set, 1, NULL), cleanup);
+    }
+
+    if (uses_p->when) {
+        /* pass uses's when to all the data children */
+        for (i = 0; i < uses_child_set.count; ++i) {
+            child = uses_child_set.snodes[i];
+
+            ret = lys_compile_when(ctx, uses_p->when, uses_p->flags, lysc_xpath_context(parent), child, &when_shared);
+            LY_CHECK_GOTO(ret, cleanup);
+        }
+    }
+
+    /* compile actions */
+    if (grp->actions) {
+        actions = parent ? lysc_node_actions_p(parent) : &ctx->cur_mod->compiled->rpcs;
+        if (!actions) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Invalid child %s \"%s\" of uses parent %s \"%s\" node.",
+                    grp->actions[0].name, lys_nodetype2str(grp->actions[0].nodetype), parent->name,
+                    lys_nodetype2str(parent->nodetype));
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+        COMPILE_OP_ARRAY_GOTO(ctx, grp->actions, *actions, parent, u, lys_compile_action, 0, ret, cleanup);
+
+        if (uses_p->when) {
+            /* inherit when */
+            LY_ARRAY_FOR(*actions, u) {
+                ret = lys_compile_when(ctx, uses_p->when, uses_p->flags, lysc_xpath_context(parent),
+                        (struct lysc_node *)&(*actions)[u], &when_shared);
+                LY_CHECK_GOTO(ret, cleanup);
+            }
+        }
+    }
+
+    /* compile notifications */
+    if (grp->notifs) {
+        notifs = parent ? lysc_node_notifs_p(parent) : &ctx->cur_mod->compiled->notifs;
+        if (!notifs) {
+            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Invalid child %s \"%s\" of uses parent %s \"%s\" node.",
+                    grp->notifs[0].name, lys_nodetype2str(grp->notifs[0].nodetype), parent->name,
+                    lys_nodetype2str(parent->nodetype));
+            ret = LY_EVALID;
+            goto cleanup;
+        }
+        COMPILE_OP_ARRAY_GOTO(ctx, grp->notifs, *notifs, parent, u, lys_compile_notif, 0, ret, cleanup);
+
+        if (uses_p->when) {
+            /* inherit when */
+            LY_ARRAY_FOR(*notifs, u) {
+                ret = lys_compile_when(ctx, uses_p->when, uses_p->flags, lysc_xpath_context(parent),
+                        (struct lysc_node *)&(*notifs)[u], &when_shared);
+                LY_CHECK_GOTO(ret, cleanup);
+            }
+        }
+    }
+
+    /* check that all augments were applied */
+    for (i = 0; i < ctx->uses_augs.count; ++i) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                "Augment target node \"%s\" in grouping \"%s\" was not found.",
+                ((struct lysc_augment *)ctx->uses_augs.objs[i])->nodeid->expr, grp->name);
+        ret = LY_ENOTFOUND;
+    }
+    LY_CHECK_GOTO(ret, cleanup);
+
+    /* check that all refines were applied */
+    for (i = 0; i < ctx->uses_rfns.count; ++i) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
+                "Refine(s) target node \"%s\" in grouping \"%s\" was not found.",
+                ((struct lysc_refine *)ctx->uses_rfns.objs[i])->nodeid->expr, grp->name);
+        ret = LY_ENOTFOUND;
+    }
+    LY_CHECK_GOTO(ret, cleanup);
+
+cleanup:
+    /* reload previous context's parsed module being processed */
+    ctx->pmod = mod_old;
+
+    /* remove the grouping from the stack for circular groupings dependency check */
+    ly_set_rm_index(&ctx->groupings, ctx->groupings.count - 1, NULL);
+    assert(ctx->groupings.count == grp_stack_count);
+
+    ly_set_erase(&uses_child_set, NULL);
+    return ret;
+}
+
+static int
+lys_compile_grouping_pathlog(struct lysc_ctx *ctx, struct lysp_node *node, char **path)
+{
+    struct lysp_node *iter;
+    int len = 0;
+
+    *path = NULL;
+    for (iter = node; iter && len >= 0; iter = iter->parent) {
+        char *s = *path;
+        char *id;
+
+        switch (iter->nodetype) {
+        case LYS_USES:
+            LY_CHECK_RET(asprintf(&id, "{uses='%s'}", iter->name) == -1, -1);
+            break;
+        case LYS_GROUPING:
+            LY_CHECK_RET(asprintf(&id, "{grouping='%s'}", iter->name) == -1, -1);
+            break;
+        case LYS_AUGMENT:
+            LY_CHECK_RET(asprintf(&id, "{augment='%s'}", iter->name) == -1, -1);
+            break;
+        default:
+            id = strdup(iter->name);
+            break;
+        }
+
+        if (!iter->parent) {
+            /* print prefix */
+            len = asprintf(path, "/%s:%s%s", ctx->cur_mod->name, id, s ? s : "");
+        } else {
+            /* prefix is the same as in parent */
+            len = asprintf(path, "/%s%s", id, s ? s : "");
+        }
+        free(s);
+        free(id);
+    }
+
+    if (len < 0) {
+        free(*path);
+        *path = NULL;
+    } else if (len == 0) {
+        *path = strdup("/");
+        len = 1;
+    }
+    return len;
+}
+
+LY_ERR
+lys_compile_grouping(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysp_grp *grp)
+{
+    LY_ERR ret;
+    char *path;
+    int len;
+
+    struct lysp_node_uses fake_uses = {
+        .parent = pnode,
+        .nodetype = LYS_USES,
+        .flags = 0, .next = NULL,
+        .name = grp->name,
+        .dsc = NULL, .ref = NULL, .when = NULL, .iffeatures = NULL, .exts = NULL,
+        .refines = NULL, .augments = NULL
+    };
+    struct lysc_node_container fake_container = {
+        .nodetype = LYS_CONTAINER,
+        .flags = pnode ? (pnode->flags & LYS_FLAGS_COMPILED_MASK) : 0,
+        .module = ctx->cur_mod,
+        .sp = NULL, .parent = NULL, .next = NULL,
+        .prev = (struct lysc_node *)&fake_container,
+        .name = "fake",
+        .dsc = NULL, .ref = NULL, .exts = NULL, .iffeatures = NULL, .when = NULL,
+        .child = NULL, .musts = NULL, .actions = NULL, .notifs = NULL
+    };
+
+    if (grp->parent) {
+        LOGWRN(ctx->ctx, "Locally scoped grouping \"%s\" not used.", grp->name);
+    }
+
+    len = lys_compile_grouping_pathlog(ctx, grp->parent, &path);
+    if (len < 0) {
+        LOGMEM(ctx->ctx);
+        return LY_EMEM;
+    }
+    strncpy(ctx->path, path, LYSC_CTX_BUFSIZE - 1);
+    ctx->path_len = (uint32_t)len;
+    free(path);
+
+    lysc_update_path(ctx, NULL, "{grouping}");
+    lysc_update_path(ctx, NULL, grp->name);
+    ret = lys_compile_uses(ctx, &fake_uses, (struct lysc_node *)&fake_container, NULL);
+    lysc_update_path(ctx, NULL, NULL);
+    lysc_update_path(ctx, NULL, NULL);
+
+    ctx->path_len = 1;
+    ctx->path[1] = '\0';
+
+    /* cleanup */
+    lysc_node_container_free(ctx->ctx, &fake_container);
+
+    return ret;
+}
+
+/**
+ * @brief Set config flags for a node.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] node Compiled node config to set.
+ * @param[in] parent Parent of @p node.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_config(struct lysc_ctx *ctx, struct lysc_node *node, struct lysc_node *parent)
+{
+    if (node->nodetype == LYS_CASE) {
+        /* case never has any config */
+        assert(!(node->flags & LYS_CONFIG_MASK));
+        return LY_SUCCESS;
+    }
+
+    /* adjust parent to always get the ancestor with config */
+    if (parent && (parent->nodetype == LYS_CASE)) {
+        parent = parent->parent;
+        assert(parent);
+    }
+
+    if (ctx->options & (LYS_COMPILE_RPC_INPUT | LYS_COMPILE_RPC_OUTPUT)) {
+        /* ignore config statements inside RPC/action data */
+        node->flags &= ~LYS_CONFIG_MASK;
+        node->flags |= (ctx->options & LYS_COMPILE_RPC_INPUT) ? LYS_CONFIG_W : LYS_CONFIG_R;
+    } else if (ctx->options & LYS_COMPILE_NOTIFICATION) {
+        /* ignore config statements inside Notification data */
+        node->flags &= ~LYS_CONFIG_MASK;
+        node->flags |= LYS_CONFIG_R;
+    } else if (!(node->flags & LYS_CONFIG_MASK)) {
+        /* config not explicitely set, inherit it from parent */
+        if (parent) {
+            node->flags |= parent->flags & LYS_CONFIG_MASK;
+        } else {
+            /* default is config true */
+            node->flags |= LYS_CONFIG_W;
+        }
+    } else {
+        /* config set explicitely */
+        node->flags |= LYS_SET_CONFIG;
+    }
+
+    if (parent && (parent->flags & LYS_CONFIG_R) && (node->flags & LYS_CONFIG_W)) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
+                "Configuration node cannot be child of any state data node.");
+        return LY_EVALID;
+    }
+
+    return LY_SUCCESS;
+}
+
+LY_ERR
+lys_compile_node(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *parent, uint16_t uses_status,
+        struct ly_set *child_set)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lysc_node *node = NULL;
+    struct lysp_node *dev_pnode = NULL, *orig_pnode = pnode;
+    LY_ARRAY_COUNT_TYPE u;
+    ly_bool not_supported;
+
+    LY_ERR (*node_compile_spec)(struct lysc_ctx *, struct lysp_node *, struct lysc_node *);
+
+    if (pnode->nodetype != LYS_USES) {
+        lysc_update_path(ctx, parent, pnode->name);
+    } else {
+        lysc_update_path(ctx, NULL, "{uses}");
+        lysc_update_path(ctx, NULL, pnode->name);
+    }
+
+    switch (pnode->nodetype) {
+    case LYS_CONTAINER:
+        node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_container));
+        node_compile_spec = lys_compile_node_container;
+        break;
+    case LYS_LEAF:
+        node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_leaf));
+        node_compile_spec = lys_compile_node_leaf;
+        break;
+    case LYS_LIST:
+        node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_list));
+        node_compile_spec = lys_compile_node_list;
+        break;
+    case LYS_LEAFLIST:
+        node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_leaflist));
+        node_compile_spec = lys_compile_node_leaflist;
+        break;
+    case LYS_CHOICE:
+        node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_choice));
+        node_compile_spec = lys_compile_node_choice;
+        break;
+    case LYS_CASE:
+        node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_case));
+        node_compile_spec = lys_compile_node_case;
+        break;
+    case LYS_ANYXML:
+    case LYS_ANYDATA:
+        node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_anydata));
+        node_compile_spec = lys_compile_node_any;
+        break;
+    case LYS_USES:
+        ret = lys_compile_uses(ctx, (struct lysp_node_uses *)pnode, parent, child_set);
+        lysc_update_path(ctx, NULL, NULL);
+        lysc_update_path(ctx, NULL, NULL);
+        return ret;
+    default:
+        LOGINT(ctx->ctx);
+        return LY_EINT;
+    }
+    LY_CHECK_ERR_RET(!node, LOGMEM(ctx->ctx), LY_EMEM);
+
+    /* compile any deviations for this node */
+    LY_CHECK_ERR_RET(ret = lys_compile_node_deviations_refines(ctx, pnode, parent, &dev_pnode, &not_supported),
+            free(node), ret);
+    if (not_supported) {
+        free(node);
+        lysc_update_path(ctx, NULL, NULL);
+        return LY_SUCCESS;
+    } else if (dev_pnode) {
+        pnode = dev_pnode;
+    }
+
+    node->nodetype = pnode->nodetype;
+    node->module = ctx->cur_mod;
+    node->prev = node;
+    node->flags = pnode->flags & LYS_FLAGS_COMPILED_MASK;
+
+    /* config */
+    ret = lys_compile_config(ctx, node, parent);
+    LY_CHECK_GOTO(ret, error);
+
+    /* list ordering */
+    if (node->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
+        if ((node->flags & LYS_CONFIG_R) && (node->flags & LYS_ORDBY_MASK)) {
+            LOGWRN(ctx->ctx, "The ordered-by statement is ignored in lists representing %s (%s).",
+                    (ctx->options & LYS_COMPILE_RPC_OUTPUT) ? "RPC/action output parameters" :
+                    (ctx->options & LYS_COMPILE_NOTIFICATION) ? "notification content" : "state data", ctx->path);
+            node->flags &= ~LYS_ORDBY_MASK;
+            node->flags |= LYS_ORDBY_SYSTEM;
+        } else if (!(node->flags & LYS_ORDBY_MASK)) {
+            /* default ordering is system */
+            node->flags |= LYS_ORDBY_SYSTEM;
+        }
+    }
+
+    /* status - it is not inherited by specification, but it does not make sense to have
+     * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
+    LY_CHECK_GOTO(ret = lys_compile_status(ctx, &node->flags, uses_status ? uses_status : (parent ? parent->flags : 0)), error);
+
+    node->sp = orig_pnode;
+    DUP_STRING_GOTO(ctx->ctx, pnode->name, node->name, ret, error);
+    DUP_STRING_GOTO(ctx->ctx, pnode->dsc, node->dsc, ret, error);
+    DUP_STRING_GOTO(ctx->ctx, pnode->ref, node->ref, ret, error);
+    COMPILE_ARRAY_GOTO(ctx, pnode->iffeatures, node->iffeatures, u, lys_compile_iffeature, ret, error);
+
+    /* insert into parent's children/compiled module (we can no longer free the node separately on error) */
+    LY_CHECK_GOTO(ret = lys_compile_node_connect(ctx, parent, node), cleanup);
+
+    if (pnode->when) {
+        /* compile when */
+        ret = lys_compile_when(ctx, pnode->when, pnode->flags, lysc_xpath_context(node), node, NULL);
+        LY_CHECK_GOTO(ret, cleanup);
+    }
+
+    /* connect any augments */
+    LY_CHECK_GOTO(ret = lys_compile_node_augments(ctx, node), cleanup);
+
+    /* nodetype-specific part */
+    LY_CHECK_GOTO(ret = node_compile_spec(ctx, pnode, node), cleanup);
+
+    /* final compilation tasks that require the node to be connected */
+    COMPILE_EXTS_GOTO(ctx, pnode->exts, node->exts, node, LYEXT_PAR_NODE, ret, cleanup);
+    if (node->flags & LYS_MAND_TRUE) {
+        /* inherit LYS_MAND_TRUE in parent containers */
+        lys_compile_mandatory_parents(parent, 1);
+    }
+
+    if (child_set) {
+        /* add the new node into set */
+        LY_CHECK_GOTO(ret = ly_set_add(child_set, node, 1, NULL), cleanup);
+    }
+
+    lysc_update_path(ctx, NULL, NULL);
+    lysp_dev_node_free(ctx->ctx, dev_pnode);
+    return LY_SUCCESS;
+
+error:
+    lysc_node_free(ctx->ctx, node);
+cleanup:
+    if (dev_pnode) {
+        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_OTHER, "Compilation of a deviated and/or refined node failed.");
+        lysp_dev_node_free(ctx->ctx, dev_pnode);
+    }
+    return ret;
+}
diff --git a/src/schema_compile_node.h b/src/schema_compile_node.h
new file mode 100644
index 0000000..8606373
--- /dev/null
+++ b/src/schema_compile_node.h
@@ -0,0 +1,187 @@
+/**
+ * @file schema_compile_node.h
+ * @author Radek Krejci <rkrejci@cesnet.cz>
+ * @brief Header for schema compilation of common nodes.
+ *
+ * Copyright (c) 2015 - 2020 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
+ */
+
+#ifndef LY_SCHEMA_COMPILE_NODE_H_
+#define LY_SCHEMA_COMPILE_NODE_H_
+
+#include <stddef.h>
+
+#include "log.h"
+#include "tree_data.h"
+#include "tree_schema.h"
+
+struct ly_set;
+struct lysc_ctx;
+
+/**
+ * @brief Get the XPath context node for the given schema node.
+ * @param[in] start The schema node where the XPath expression appears.
+ * @return The context node to evaluate XPath expression in given schema node.
+ * @return NULL in case the context node is the root node.
+ */
+struct lysc_node *lysc_xpath_context(struct lysc_node *start);
+
+/**
+ * @brief Compile information from the when statement by either standard compilation or by reusing
+ * another compiled when structure.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] when_p Parsed when structure.
+ * @param[in] flags Flags of the parsed node with the when statement.
+ * @param[in] ctx_node Context node for the when statement.
+ * @param[in] node Compiled node to which add the compiled when.
+ * @param[in,out] when_c Optional, pointer to the previously compiled @p when_p to be reused. Set to NULL
+ * for the first call.
+ * @return LY_ERR value.
+ */
+LY_ERR lys_compile_when(struct lysc_ctx *ctx, struct lysp_when *when_p, uint16_t flags, const struct lysc_node *ctx_node,
+        struct lysc_node *node, struct lysc_when **when_c);
+
+/**
+ * @brief Checks pattern syntax.
+ *
+ * @param[in] ctx Context.
+ * @param[in] log_path Path for logging errors.
+ * @param[in] pattern Pattern to check.
+ * @param[in,out] pcre2_code Compiled PCRE2 pattern. If NULL, the compiled information used to validate pattern are freed.
+ * @return LY_ERR value - LY_SUCCESS, LY_EMEM, LY_EVALID.
+ */
+LY_ERR lys_compile_type_pattern_check(struct ly_ctx *ctx, const char *log_path, const char *pattern, pcre2_code **code);
+
+/**
+ * @brief Compile information about the leaf/leaf-list's type.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] context_pnode Schema node where the type/typedef is placed to correctly find the base types.
+ * @param[in] context_flags Flags of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
+ * @param[in] context_mod Module of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
+ * @param[in] context_name Name of the context node or referencing typedef for logging.
+ * @param[in] type_p Parsed type to compile.
+ * @param[out] type Newly created (or reused with increased refcount) type structure with the filled information about the type.
+ * @param[out] units Storage for inheriting units value from the typedefs the current type derives from.
+ * @param[out] dflt Default value for the type.
+ * @return LY_ERR value.
+ */
+LY_ERR lys_compile_type(struct lysc_ctx *ctx, struct lysp_node *context_pnode, uint16_t context_flags,
+        struct lysp_module *context_mod, const char *context_name, struct lysp_type *type_p,
+        struct lysc_type **type, const char **units, struct lysp_qname **dflt);
+
+/**
+ * @brief Compile parsed RPC/action schema node information.
+ *
+ * @param[in] ctx Compile context
+ * @param[in] action_p Parsed RPC/action schema node.
+ * @param[in] parent Parent node of the action, NULL in case of RPC (top-level action)
+ * @param[in,out] action Prepared (empty) compiled action structure to fill.
+ * @param[in] uses_status If the RPC/action is being placed instead of uses, here we have the uses's status value (as node's flags).
+ * Zero means no uses, non-zero value with no status bit set mean the default status.
+ * @return LY_SUCCESS on success,
+ * @return LY_EVALID on validation error,
+ * @return LY_EDENIED on not-supported deviation.
+ */
+LY_ERR lys_compile_action(struct lysc_ctx *ctx, struct lysp_action *action_p, struct lysc_node *parent,
+        struct lysc_action *action, uint16_t uses_status);
+
+/**
+ * @brief Compile parsed Notification schema node information.
+ *
+ * @param[in] ctx Compile context
+ * @param[in] notif_p Parsed Notification schema node.
+ * @param[in] parent Parent node of the Notification, NULL in case of top-level Notification
+ * @param[in,out] notif Prepared (empty) compiled notification structure to fill.
+ * @param[in] uses_status If the Notification is being placed instead of uses, here we have the uses's status value (as node's flags).
+ * Zero means no uses, non-zero value with no status bit set mean the default status.
+ * @return LY_SUCCESS on success,
+ * @return LY_EVALID on validation error,
+ * @return LY_EDENIED on not-supported deviation.
+ */
+LY_ERR lys_compile_notif(struct lysc_ctx *ctx, struct lysp_notif *notif_p, struct lysc_node *parent,
+        struct lysc_notif *notif, uint16_t uses_status);
+
+/**
+ * @brief Find the node according to the given descendant/absolute schema nodeid.
+ * Used in unique, refine and augment statements.
+ *
+ * @param[in] ctx Compile context
+ * @param[in] nodeid Descendant-schema-nodeid (according to the YANG grammar)
+ * @param[in] nodeid_len Length of the given nodeid, if it is not NULL-terminated string.
+ * @param[in] ctx_node Context node for a relative nodeid.
+ * @param[in] cur_mod Current module for the nodeid (where it was "instantiated").
+ * @param[in] format Format of any prefixes.
+ * @param[in] prefix_data Format-specific prefix data (see ::ly_resolve_prefix).
+ * @param[in] nodetype Optional (can be 0) restriction for target's nodetype. If target exists, but does not match
+ * the given nodetype, LY_EDENIED is returned (and target is provided), but no error message is printed.
+ * The value can be even an ORed value to allow multiple nodetypes.
+ * @param[out] target Found target node if any.
+ * @param[out] result_flag Output parameter to announce if the schema nodeid goes through the action's input/output or a Notification.
+ * The LYSC_OPT_RPC_INPUT, LYSC_OPT_RPC_OUTPUT and LYSC_OPT_NOTIFICATION are used as flags.
+ * @return LY_ERR values - LY_ENOTFOUND, LY_EVALID, LY_EDENIED or LY_SUCCESS.
+ */
+LY_ERR lysc_resolve_schema_nodeid(struct lysc_ctx *ctx, const char *nodeid, size_t nodeid_len,
+        const struct lysc_node *ctx_node, const struct lys_module *cur_mod, LY_PREFIX_FORMAT format, void *prefix_data,
+        uint16_t nodetype, const struct lysc_node **target, uint16_t *result_flag);
+
+/**
+ * @brief Compile choice children.
+ *
+ * @param[in] ctx Compile context
+ * @param[in] child_p Parsed choice children nodes.
+ * @param[in] node Compiled choice node to compile and add children to.
+ * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
+ */
+LY_ERR lys_compile_node_choice_child(struct lysc_ctx *ctx, struct lysp_node *child_p, struct lysc_node *node,
+        struct ly_set *child_set);
+
+/**
+ * @brief Set LYS_MAND_TRUE flag for the non-presence container parents.
+ *
+ * A non-presence container is mandatory in case it has at least one mandatory children. This function propagate
+ * the flag to such parents from a mandatory children.
+ *
+ * @param[in] parent A schema node to be examined if the mandatory child make it also mandatory.
+ * @param[in] add Flag to distinguish adding the mandatory flag (new mandatory children appeared) or removing the flag
+ * (mandatory children was removed).
+ */
+void lys_compile_mandatory_parents(struct lysc_node *parent, ly_bool add);
+
+/**
+ * @brief Validate grouping that was defined but not used in the schema itself.
+ *
+ * The grouping does not need to be compiled (and it is compiled here, but the result is forgotten immediately),
+ * but to have the complete result of the schema validity, even such groupings are supposed to be checked.
+ *
+ * @param[in] ctx Compile context.
+ * @param[in] pnode Parsed parent node of the grouping, NULL for top-level.
+ * @param[in] grp Parsed grouping node to check.
+ * @return LY_ERR value.
+ */
+LY_ERR lys_compile_grouping(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysp_grp *grp);
+
+/**
+ * @brief Compile parsed schema node information.
+ *
+ * @param[in] ctx Compile context
+ * @param[in] pnode Parsed schema node.
+ * @param[in] parent Compiled parent node where the current node is supposed to be connected. It is
+ * NULL for top-level nodes, in such a case the module where the node will be connected is taken from
+ * the compile context.
+ * @param[in] uses_status If the node is being placed instead of uses, here we have the uses's status value (as node's flags).
+ * Zero means no uses, non-zero value with no status bit set mean the default status.
+ * @param[in,out] child_set Optional set to add all the compiled nodes into (can be more in case of uses).
+ * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
+ */
+LY_ERR lys_compile_node(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *parent, uint16_t uses_status,
+        struct ly_set *child_set);
+
+#endif /* LY_SCHEMA_COMPILE_NODE_H_ */
diff --git a/src/tree_schema.c b/src/tree_schema.c
index 98c9e5b..f1a170f 100644
--- a/src/tree_schema.c
+++ b/src/tree_schema.c
@@ -34,6 +34,8 @@
 #include "parser.h"
 #include "parser_internal.h"
 #include "parser_schema.h"
+#include "schema_compile.h"
+#include "schema_compile_amend.h"
 #include "set.h"
 #include "tree.h"
 #include "tree_schema_internal.h"
diff --git a/src/tree_schema_compile.c b/src/tree_schema_compile.c
deleted file mode 100644
index 5016286..0000000
--- a/src/tree_schema_compile.c
+++ /dev/null
@@ -1,8535 +0,0 @@
-/**
- * @file tree_schema.c
- * @author Radek Krejci <rkrejci@cesnet.cz>
- * @brief Schema tree implementation
- *
- * Copyright (c) 2015 - 2018 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
- */
-
-#define _GNU_SOURCE
-
-#include <assert.h>
-#include <ctype.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "common.h"
-#include "compat.h"
-#include "context.h"
-#include "dict.h"
-#include "log.h"
-#include "parser.h"
-#include "parser_schema.h"
-#include "path.h"
-#include "plugins_exts.h"
-#include "plugins_exts_internal.h"
-#include "plugins_types.h"
-#include "set.h"
-#include "tree.h"
-#include "tree_data.h"
-#include "tree_data_internal.h"
-#include "tree_schema.h"
-#include "tree_schema_internal.h"
-#include "xpath.h"
-
-static LY_ERR lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext,
-        void *parent, LYEXT_PARENT parent_type, const struct lys_module *ext_mod);
-
-static LY_ERR lysp_qname_dup(const struct ly_ctx *ctx, struct lysp_qname *qname, const struct lysp_qname *orig_qname);
-
-/**
- * @defgroup scflags Schema compile flags
- *
- * Flags are currently used only internally - the compilation process does not have a public interface and it is
- * integrated in the schema parsers. The current options set does not make sense for public used, but it can be a way
- * to modify behavior of the compilation process in future.
- *
- * @{
- */
-#define LYS_COMPILE_RPC_INPUT  LYS_CONFIG_W       /**< Internal option when compiling schema tree of RPC/action input */
-#define LYS_COMPILE_RPC_OUTPUT LYS_CONFIG_R       /**< Internal option when compiling schema tree of RPC/action output */
-#define LYS_COMPILE_RPC_MASK   LYS_CONFIG_MASK    /**< mask for the internal RPC options */
-#define LYS_COMPILE_NOTIFICATION 0x08             /**< Internal option when compiling schema tree of Notification */
-
-#define LYS_COMPILE_GROUPING   0x10               /** Compiling (validation) of a non-instantiated grouping.
-                                                      In this case not all the restrictions are checked since they can be valid only
-                                                      in the real placement of the grouping. TODO - what specifically is not done */
-/** @} scflags */
-
-/**
- * @brief Duplicate string into dictionary
- * @param[in] CTX libyang context of the dictionary.
- * @param[in] ORIG String to duplicate.
- * @param[out] DUP Where to store the result.
- */
-#define DUP_STRING(CTX, ORIG, DUP, RET) if (ORIG) {RET = lydict_insert(CTX, ORIG, 0, &DUP);}
-
-#define DUP_STRING_GOTO(CTX, ORIG, DUP, RET, GOTO) if (ORIG) {LY_CHECK_GOTO(RET = lydict_insert(CTX, ORIG, 0, &DUP), GOTO);}
-
-#define DUP_ARRAY(CTX, ORIG_ARRAY, NEW_ARRAY, DUP_FUNC) \
-    if (ORIG_ARRAY) { \
-        LY_ARRAY_COUNT_TYPE u; \
-        LY_ARRAY_CREATE_RET(CTX, NEW_ARRAY, LY_ARRAY_COUNT(ORIG_ARRAY), LY_EMEM); \
-        LY_ARRAY_FOR(ORIG_ARRAY, u) { \
-            LY_ARRAY_INCREMENT(NEW_ARRAY); \
-            LY_CHECK_RET(DUP_FUNC(CTX, &(NEW_ARRAY)[u], &(ORIG_ARRAY)[u])); \
-        } \
-    }
-
-#define COMPILE_ARRAY_GOTO(CTX, ARRAY_P, ARRAY_C, ITER, FUNC, RET, GOTO) \
-    if (ARRAY_P) { \
-        LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, LY_ARRAY_COUNT(ARRAY_P), RET, GOTO); \
-        LY_ARRAY_COUNT_TYPE __array_offset = LY_ARRAY_COUNT(ARRAY_C); \
-        for (ITER = 0; ITER < LY_ARRAY_COUNT(ARRAY_P); ++ITER) { \
-            LY_ARRAY_INCREMENT(ARRAY_C); \
-            RET = FUNC(CTX, &(ARRAY_P)[ITER], &(ARRAY_C)[ITER + __array_offset]); \
-            LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
-        } \
-    }
-
-#define COMPILE_OP_ARRAY_GOTO(CTX, ARRAY_P, ARRAY_C, PARENT, ITER, FUNC, USES_STATUS, RET, GOTO) \
-    if (ARRAY_P) { \
-        LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, LY_ARRAY_COUNT(ARRAY_P), RET, GOTO); \
-        LY_ARRAY_COUNT_TYPE __array_offset = LY_ARRAY_COUNT(ARRAY_C); \
-        for (ITER = 0; ITER < LY_ARRAY_COUNT(ARRAY_P); ++ITER) { \
-            LY_ARRAY_INCREMENT(ARRAY_C); \
-            RET = FUNC(CTX, &(ARRAY_P)[ITER], PARENT, &(ARRAY_C)[ITER + __array_offset], USES_STATUS); \
-            if (RET == LY_EDENIED) { \
-                LY_ARRAY_DECREMENT(ARRAY_C); \
-            } else if (RET != LY_SUCCESS) { \
-                goto GOTO; \
-            } \
-        } \
-    }
-
-#define COMPILE_EXTS_GOTO(CTX, EXTS_P, EXT_C, PARENT, PARENT_TYPE, RET, GOTO) \
-    if (EXTS_P) { \
-        LY_ARRAY_CREATE_GOTO((CTX)->ctx, EXT_C, LY_ARRAY_COUNT(EXTS_P), RET, GOTO); \
-        for (LY_ARRAY_COUNT_TYPE __exts_iter = 0, __array_offset = LY_ARRAY_COUNT(EXT_C); __exts_iter < LY_ARRAY_COUNT(EXTS_P); ++__exts_iter) { \
-            LY_ARRAY_INCREMENT(EXT_C); \
-            RET = lys_compile_ext(CTX, &(EXTS_P)[__exts_iter], &(EXT_C)[__exts_iter + __array_offset], PARENT, PARENT_TYPE, NULL); \
-            LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
-        } \
-    }
-
-#define COMPILE_ARRAY_UNIQUE_GOTO(CTX, ARRAY_P, ARRAY_C, ITER, FUNC, RET, GOTO) \
-    if (ARRAY_P) { \
-        LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, LY_ARRAY_COUNT(ARRAY_P), RET, GOTO); \
-        LY_ARRAY_COUNT_TYPE __array_offset = LY_ARRAY_COUNT(ARRAY_C); \
-        for (ITER = 0; ITER < LY_ARRAY_COUNT(ARRAY_P); ++ITER) { \
-            LY_ARRAY_INCREMENT(ARRAY_C); \
-            RET = FUNC(CTX, &(ARRAY_P)[ITER], ARRAY_C, &(ARRAY_C)[ITER + __array_offset]); \
-            LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
-        } \
-    }
-
-#define COMPILE_MEMBER_GOTO(CTX, MEMBER_P, MEMBER_C, FUNC, RET, GOTO) \
-    if (MEMBER_P) { \
-        MEMBER_C = calloc(1, sizeof *(MEMBER_C)); \
-        LY_CHECK_ERR_GOTO(!(MEMBER_C), LOGMEM((CTX)->ctx); RET = LY_EMEM, GOTO); \
-        RET = FUNC(CTX, MEMBER_P, MEMBER_C); \
-        LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
-    }
-
-#define COMPILE_MEMBER_ARRAY_GOTO(CTX, MEMBER_P, ARRAY_C, FUNC, RET, GOTO) \
-    if (MEMBER_P) { \
-        LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, 1, RET, GOTO); \
-        LY_ARRAY_COUNT_TYPE __array_offset = LY_ARRAY_COUNT(ARRAY_C); \
-        LY_ARRAY_INCREMENT(ARRAY_C); \
-        RET = FUNC(CTX, MEMBER_P, &(ARRAY_C)[__array_offset]); \
-        LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
-    }
-
-#define COMPILE_CHECK_UNIQUENESS_ARRAY(CTX, ARRAY, MEMBER, EXCL, STMT, IDENT) \
-    if (ARRAY) { \
-        for (LY_ARRAY_COUNT_TYPE u__ = 0; u__ < LY_ARRAY_COUNT(ARRAY); ++u__) { \
-            if (&(ARRAY)[u__] != EXCL && (void*)((ARRAY)[u__].MEMBER) == (void*)(IDENT)) { \
-                LOGVAL((CTX)->ctx, LY_VLOG_STR, (CTX)->path, LY_VCODE_DUPIDENT, IDENT, STMT); \
-                return LY_EVALID; \
-            } \
-        } \
-    }
-
-#define COMPILE_CHECK_UNIQUENESS_PARRAY(CTX, ARRAY, MEMBER, EXCL, STMT, IDENT) \
-    if (ARRAY) { \
-        for (LY_ARRAY_COUNT_TYPE u__ = 0; u__ < LY_ARRAY_COUNT(ARRAY); ++u__) { \
-            if (&(ARRAY)[u__] != EXCL && (void*)((ARRAY)[u__]->MEMBER) == (void*)(IDENT)) { \
-                LOGVAL((CTX)->ctx, LY_VLOG_STR, (CTX)->path, LY_VCODE_DUPIDENT, IDENT, STMT); \
-                return LY_EVALID; \
-            } \
-        } \
-    }
-
-struct lysc_ext *
-lysc_ext_dup(struct lysc_ext *orig)
-{
-    ++orig->refcount;
-    return orig;
-}
-
-static struct lysc_ext_instance *
-lysc_ext_instance_dup(struct ly_ctx *ctx, struct lysc_ext_instance *orig)
-{
-    /* TODO - extensions, increase refcount */
-    (void) ctx;
-    (void) orig;
-    return NULL;
-}
-
-/**
- * @brief Add/replace a leaf default value in unres.
- * Can also be used for a single leaf-list default value.
- *
- * @param[in] ctx Compile context.
- * @param[in] leaf Leaf with the default value.
- * @param[in] dflt Default value to use.
- * @return LY_ERR value.
- */
-static LY_ERR
-lysc_unres_leaf_dflt_add(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf, struct lysp_qname *dflt)
-{
-    struct lysc_unres_dflt *r = NULL;
-    uint32_t i;
-
-    for (i = 0; i < ctx->dflts.count; ++i) {
-        if (((struct lysc_unres_dflt *)ctx->dflts.objs[i])->leaf == leaf) {
-            /* just replace the default */
-            r = ctx->dflts.objs[i];
-            lysp_qname_free(ctx->ctx, r->dflt);
-            free(r->dflt);
-            break;
-        }
-    }
-    if (!r) {
-        /* add new unres item */
-        r = calloc(1, sizeof *r);
-        LY_CHECK_ERR_RET(!r, LOGMEM(ctx->ctx), LY_EMEM);
-        r->leaf = leaf;
-
-        LY_CHECK_RET(ly_set_add(&ctx->dflts, r, 1, NULL));
-    }
-
-    r->dflt = malloc(sizeof *r->dflt);
-    LY_CHECK_GOTO(!r->dflt, error);
-    LY_CHECK_GOTO(lysp_qname_dup(ctx->ctx, r->dflt, dflt), error);
-
-    return LY_SUCCESS;
-
-error:
-    free(r->dflt);
-    LOGMEM(ctx->ctx);
-    return LY_EMEM;
-}
-
-/**
- * @brief Add/replace a leaf-list default value(s) in unres.
- *
- * @param[in] ctx Compile context.
- * @param[in] llist Leaf-list with the default value.
- * @param[in] dflts Sized array of the default values.
- * @return LY_ERR value.
- */
-static LY_ERR
-lysc_unres_llist_dflts_add(struct lysc_ctx *ctx, struct lysc_node_leaflist *llist, struct lysp_qname *dflts)
-{
-    struct lysc_unres_dflt *r = NULL;
-    uint32_t i;
-
-    for (i = 0; i < ctx->dflts.count; ++i) {
-        if (((struct lysc_unres_dflt *)ctx->dflts.objs[i])->llist == llist) {
-            /* just replace the defaults */
-            r = ctx->dflts.objs[i];
-            lysp_qname_free(ctx->ctx, r->dflt);
-            free(r->dflt);
-            r->dflt = NULL;
-            FREE_ARRAY(ctx->ctx, r->dflts, lysp_qname_free);
-            r->dflts = NULL;
-            break;
-        }
-    }
-    if (!r) {
-        r = calloc(1, sizeof *r);
-        LY_CHECK_ERR_RET(!r, LOGMEM(ctx->ctx), LY_EMEM);
-        r->llist = llist;
-
-        LY_CHECK_RET(ly_set_add(&ctx->dflts, r, 1, NULL));
-    }
-
-    DUP_ARRAY(ctx->ctx, dflts, r->dflts, lysp_qname_dup);
-
-    return LY_SUCCESS;
-}
-
-static void
-lysc_unres_dflt_free(const struct ly_ctx *ctx, struct lysc_unres_dflt *r)
-{
-    assert(!r->dflt || !r->dflts);
-    if (r->dflt) {
-        lysp_qname_free((struct ly_ctx *)ctx, r->dflt);
-        free(r->dflt);
-    } else {
-        FREE_ARRAY((struct ly_ctx *)ctx, r->dflts, lysp_qname_free);
-    }
-    free(r);
-}
-
-void
-lysc_update_path(struct lysc_ctx *ctx, struct lysc_node *parent, const char *name)
-{
-    int len;
-    uint8_t nextlevel = 0; /* 0 - no starttag, 1 - '/' starttag, 2 - '=' starttag + '}' endtag */
-
-    if (!name) {
-        /* removing last path segment */
-        if (ctx->path[ctx->path_len - 1] == '}') {
-            for ( ; ctx->path[ctx->path_len] != '=' && ctx->path[ctx->path_len] != '{'; --ctx->path_len) {}
-            if (ctx->path[ctx->path_len] == '=') {
-                ctx->path[ctx->path_len++] = '}';
-            } else {
-                /* not a top-level special tag, remove also preceiding '/' */
-                goto remove_nodelevel;
-            }
-        } else {
-remove_nodelevel:
-            for ( ; ctx->path[ctx->path_len] != '/'; --ctx->path_len) {}
-            if (ctx->path_len == 0) {
-                /* top-level (last segment) */
-                ctx->path_len = 1;
-            }
-        }
-        /* set new terminating NULL-byte */
-        ctx->path[ctx->path_len] = '\0';
-    } else {
-        if (ctx->path_len > 1) {
-            if (!parent && (ctx->path[ctx->path_len - 1] == '}') && (ctx->path[ctx->path_len - 2] != '\'')) {
-                /* extension of the special tag */
-                nextlevel = 2;
-                --ctx->path_len;
-            } else {
-                /* there is already some path, so add next level */
-                nextlevel = 1;
-            }
-        } /* else the path is just initiated with '/', so do not add additional slash in case of top-level nodes */
-
-        if (nextlevel != 2) {
-            if ((parent && (parent->module == ctx->cur_mod)) || (!parent && (ctx->path_len > 1) && (name[0] == '{'))) {
-                /* module not changed, print the name unprefixed */
-                len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s", nextlevel ? "/" : "", name);
-            } else {
-                len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s:%s", nextlevel ? "/" : "", ctx->cur_mod->name, name);
-            }
-        } else {
-            len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "='%s'}", name);
-        }
-        if (len >= LYSC_CTX_BUFSIZE - (int)ctx->path_len) {
-            /* output truncated */
-            ctx->path_len = LYSC_CTX_BUFSIZE - 1;
-        } else {
-            ctx->path_len += len;
-        }
-    }
-}
-
-/**
- * @brief Duplicate the compiled pattern structure.
- *
- * Instead of duplicating memory, the reference counter in the @p orig is increased.
- *
- * @param[in] orig The pattern structure to duplicate.
- * @return The duplicated structure to use.
- */
-static struct lysc_pattern *
-lysc_pattern_dup(struct lysc_pattern *orig)
-{
-    ++orig->refcount;
-    return orig;
-}
-
-/**
- * @brief Duplicate the array of compiled patterns.
- *
- * The sized array itself is duplicated, but the pattern structures are just shadowed by increasing their reference counter.
- *
- * @param[in] ctx Libyang context for logging.
- * @param[in] orig The patterns sized array to duplicate.
- * @return New sized array as a copy of @p orig.
- * @return NULL in case of memory allocation error.
- */
-static struct lysc_pattern **
-lysc_patterns_dup(struct ly_ctx *ctx, struct lysc_pattern **orig)
-{
-    struct lysc_pattern **dup = NULL;
-    LY_ARRAY_COUNT_TYPE u;
-
-    assert(orig);
-
-    LY_ARRAY_CREATE_RET(ctx, dup, LY_ARRAY_COUNT(orig), NULL);
-    LY_ARRAY_FOR(orig, u) {
-        dup[u] = lysc_pattern_dup(orig[u]);
-        LY_ARRAY_INCREMENT(dup);
-    }
-    return dup;
-}
-
-/**
- * @brief Duplicate compiled range structure.
- *
- * @param[in] ctx Libyang context for logging.
- * @param[in] orig The range structure to be duplicated.
- * @return New compiled range structure as a copy of @p orig.
- * @return NULL in case of memory allocation error.
- */
-struct lysc_range *
-lysc_range_dup(struct ly_ctx *ctx, const struct lysc_range *orig)
-{
-    struct lysc_range *dup;
-    LY_ERR ret;
-
-    assert(orig);
-
-    dup = calloc(1, sizeof *dup);
-    LY_CHECK_ERR_RET(!dup, LOGMEM(ctx), NULL);
-    if (orig->parts) {
-        LY_ARRAY_CREATE_GOTO(ctx, dup->parts, LY_ARRAY_COUNT(orig->parts), ret, cleanup);
-        LY_ARRAY_COUNT(dup->parts) = LY_ARRAY_COUNT(orig->parts);
-        memcpy(dup->parts, orig->parts, LY_ARRAY_COUNT(dup->parts) * sizeof *dup->parts);
-    }
-    DUP_STRING_GOTO(ctx, orig->eapptag, dup->eapptag, ret, cleanup);
-    DUP_STRING_GOTO(ctx, orig->emsg, dup->emsg, ret, cleanup);
-    dup->exts = lysc_ext_instance_dup(ctx, orig->exts);
-
-    return dup;
-cleanup:
-    free(dup);
-    (void) ret; /* set but not used due to the return type */
-    return NULL;
-}
-
-/**
- * @brief Stack for processing if-feature expressions.
- */
-struct iff_stack {
-    size_t size;    /**< number of items in the stack */
-    size_t index;   /**< first empty item */
-    uint8_t *stack; /**< stack - array of @ref ifftokens to create the if-feature expression in prefix format */
-};
-
-/**
- * @brief Add @ref ifftokens into the stack.
- * @param[in] stack The if-feature stack to use.
- * @param[in] value One of the @ref ifftokens to store in the stack.
- * @return LY_EMEM in case of memory allocation error
- * @return LY_ESUCCESS if the value successfully stored.
- */
-static LY_ERR
-iff_stack_push(struct iff_stack *stack, uint8_t value)
-{
-    if (stack->index == stack->size) {
-        stack->size += 4;
-        stack->stack = ly_realloc(stack->stack, stack->size * sizeof *stack->stack);
-        LY_CHECK_ERR_RET(!stack->stack, LOGMEM(NULL); stack->size = 0, LY_EMEM);
-    }
-    stack->stack[stack->index++] = value;
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Get (and remove) the last item form the stack.
- * @param[in] stack The if-feature stack to use.
- * @return The value from the top of the stack.
- */
-static uint8_t
-iff_stack_pop(struct iff_stack *stack)
-{
-    assert(stack && stack->index);
-
-    stack->index--;
-    return stack->stack[stack->index];
-}
-
-/**
- * @brief Clean up the stack.
- * @param[in] stack The if-feature stack to use.
- */
-static void
-iff_stack_clean(struct iff_stack *stack)
-{
-    stack->size = 0;
-    free(stack->stack);
-}
-
-/**
- * @brief Store the @ref ifftokens (@p op) on the given position in the 2bits array
- * (libyang format of the if-feature expression).
- * @param[in,out] list The 2bits array to modify.
- * @param[in] op The operand (@ref ifftokens) to store.
- * @param[in] pos Position (0-based) where to store the given @p op.
- */
-static void
-iff_setop(uint8_t *list, uint8_t op, size_t pos)
-{
-    uint8_t *item;
-    uint8_t mask = 3;
-
-    assert(op <= 3); /* max 2 bits */
-
-    item = &list[pos / 4];
-    mask = mask << 2 * (pos % 4);
-    *item = (*item) & ~mask;
-    *item = (*item) | (op << 2 * (pos % 4));
-}
-
-#define LYS_IFF_LP 0x04 /**< Additional, temporary, value of @ref ifftokens: ( */
-#define LYS_IFF_RP 0x08 /**< Additional, temporary, value of @ref ifftokens: ) */
-
-/**
- * @brief Find a feature of the given name and referenced in the given module.
- *
- * If the compiled schema is available (the schema is implemented), the feature from the compiled schema is
- * returned. Otherwise, the special array of pre-compiled features is used to search for the feature. Such
- * features are always disabled (feature from not implemented schema cannot be enabled), but in case the schema
- * will be made implemented in future (no matter if implicitly via augmenting/deviating it or explicitly via
- * ly_ctx_module_implement()), the compilation of these feature structure is finished, but the pointers
- * assigned till that time will be still valid.
- *
- * @param[in] pmod Module where the feature was referenced (used to resolve prefix of the feature).
- * @param[in] name Name of the feature including possible prefix.
- * @param[in] len Length of the string representing the feature identifier in the name variable (mandatory!).
- * @return Pointer to the feature structure if found, NULL otherwise.
- */
-static struct lysc_feature *
-lys_feature_find(const struct lysp_module *pmod, const char *name, size_t len)
-{
-    LY_ARRAY_COUNT_TYPE u;
-    struct lysc_feature *f;
-    const struct lys_module *mod;
-    const char *ptr;
-
-    assert(pmod);
-
-    if ((ptr = ly_strnchr(name, ':', len))) {
-        /* we have a prefixed feature */
-        mod = lysp_module_find_prefix(pmod, name, ptr - name);
-        LY_CHECK_RET(!mod, NULL);
-
-        len = len - (ptr - name) - 1;
-        name = ptr + 1;
-    } else {
-        /* local feature */
-        mod = pmod->mod;
-    }
-
-    /* we have the correct module, get the feature */
-    LY_ARRAY_FOR(mod->features, u) {
-        f = &mod->features[u];
-        if (!ly_strncmp(f->name, name, len)) {
-            return f;
-        }
-    }
-
-    return NULL;
-}
-
-/**
- * @brief Fill in the prepared compiled extensions definition structure according to the parsed extension definition.
- */
-static LY_ERR
-lys_compile_extension(struct lysc_ctx *ctx, const struct lys_module *ext_mod, struct lysp_ext *ext_p, struct lysc_ext **ext)
-{
-    LY_ERR ret = LY_SUCCESS;
-
-    if (!ext_p->compiled) {
-        lysc_update_path(ctx, NULL, "{extension}");
-        lysc_update_path(ctx, NULL, ext_p->name);
-
-        /* compile the extension definition */
-        ext_p->compiled = calloc(1, sizeof **ext);
-        ext_p->compiled->refcount = 1;
-        DUP_STRING_GOTO(ctx->ctx, ext_p->name, ext_p->compiled->name, ret, done);
-        DUP_STRING_GOTO(ctx->ctx, ext_p->argument, ext_p->compiled->argument, ret, done);
-        ext_p->compiled->module = (struct lys_module *)ext_mod;
-        COMPILE_EXTS_GOTO(ctx, ext_p->exts, ext_p->compiled->exts, *ext, LYEXT_PAR_EXT, ret, done);
-
-        lysc_update_path(ctx, NULL, NULL);
-        lysc_update_path(ctx, NULL, NULL);
-
-        /* find extension definition plugin */
-        ext_p->compiled->plugin = lyext_get_plugin(ext_p->compiled);
-    }
-
-    *ext = lysc_ext_dup(ext_p->compiled);
-
-done:
-    return ret;
-}
-
-/**
- * @brief Fill in the prepared compiled extension instance structure according to the parsed extension instance.
- *
- * @param[in] ctx Compilation context.
- * @param[in] ext_p Parsed extension instance.
- * @param[in,out] ext Prepared compiled extension instance.
- * @param[in] parent Extension instance parent.
- * @param[in] parent_type Extension instance parent type.
- * @param[in] ext_mod Optional module with the extension instance extension definition, set only for internal annotations.
- */
-static LY_ERR
-lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext, void *parent,
-        LYEXT_PARENT parent_type, const struct lys_module *ext_mod)
-{
-    LY_ERR ret = LY_SUCCESS;
-    const char *name;
-    size_t u;
-    LY_ARRAY_COUNT_TYPE v;
-    const char *prefixed_name = NULL;
-
-    DUP_STRING(ctx->ctx, ext_p->argument, ext->argument, ret);
-    LY_CHECK_RET(ret);
-
-    ext->insubstmt = ext_p->insubstmt;
-    ext->insubstmt_index = ext_p->insubstmt_index;
-    ext->module = ctx->cur_mod;
-    ext->parent = parent;
-    ext->parent_type = parent_type;
-
-    lysc_update_path(ctx, ext->parent_type == LYEXT_PAR_NODE ? (struct lysc_node *)ext->parent : NULL, "{extension}");
-
-    /* get module where the extension definition should be placed */
-    for (u = strlen(ext_p->name); u && ext_p->name[u - 1] != ':'; --u) {}
-    if (ext_p->yin) {
-        /* YIN parser has to replace prefixes by the namespace - XML namespace/prefix pairs may differs form the YANG schema's
-         * namespace/prefix pair. YIN parser does not have the imports available, so mapping from XML namespace to the
-         * YANG (import) prefix must be done here. */
-        if (!ly_strncmp(ctx->pmod->mod->ns, ext_p->name, u - 1)) {
-            LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, &ext_p->name[u], 0, &prefixed_name), cleanup);
-            u = 0;
-        } else {
-            LY_ARRAY_FOR(ctx->pmod->imports, v) {
-                if (!ly_strncmp(ctx->pmod->imports[v].module->ns, ext_p->name, u - 1)) {
-                    char *s;
-                    LY_CHECK_ERR_GOTO(asprintf(&s, "%s:%s", ctx->pmod->imports[v].prefix, &ext_p->name[u]) == -1,
-                            ret = LY_EMEM, cleanup);
-                    LY_CHECK_GOTO(ret = lydict_insert_zc(ctx->ctx, s, &prefixed_name), cleanup);
-                    u = strlen(ctx->pmod->imports[v].prefix) + 1; /* add semicolon */
-                    break;
-                }
-            }
-        }
-        if (!prefixed_name) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid XML prefix of \"%.*s\" namespace used for extension instance identifier.", u, ext_p->name);
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-    } else {
-        prefixed_name = ext_p->name;
-    }
-    lysc_update_path(ctx, NULL, prefixed_name);
-
-    if (!ext_mod) {
-        ext_mod = u ? lysp_module_find_prefix(ctx->pmod, prefixed_name, u - 1) : ctx->pmod->mod;
-        if (!ext_mod) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid prefix \"%.*s\" used for extension instance identifier.", u, prefixed_name);
-            ret = LY_EVALID;
-            goto cleanup;
-        } else if (!ext_mod->parsed->extensions) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Extension instance \"%s\" refers \"%s\" module that does not contain extension definitions.",
-                    prefixed_name, ext_mod->name);
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-    }
-    name = &prefixed_name[u];
-
-    /* find the parsed extension definition there */
-    LY_ARRAY_FOR(ext_mod->parsed->extensions, v) {
-        if (!strcmp(name, ext_mod->parsed->extensions[v].name)) {
-            /* compile extension definition and assign it */
-            LY_CHECK_GOTO(ret = lys_compile_extension(ctx, ext_mod, &ext_mod->parsed->extensions[v], &ext->def), cleanup);
-            break;
-        }
-    }
-    if (!ext->def) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                "Extension definition of extension instance \"%s\" not found.", prefixed_name);
-        ret = LY_EVALID;
-        goto cleanup;
-    }
-
-    /* unify the parsed extension from YIN and YANG sources. Without extension definition, it is not possible
-     * to get extension's argument from YIN source, so it is stored as one of the substatements. Here we have
-     * to find it, mark it with LYS_YIN_ARGUMENT and store it in the compiled structure. */
-    if (ext_p->yin && ext->def->argument && !ext->argument) {
-        /* Schema was parsed from YIN and an argument is expected, ... */
-        struct lysp_stmt *stmt = NULL;
-
-        if (ext->def->flags & LYS_YINELEM_TRUE) {
-            /* ... argument was the first XML child element */
-            if (ext_p->child && !(ext_p->child->flags & LYS_YIN_ATTR)) {
-                /* TODO check namespace of the statement */
-                if (!strcmp(ext_p->child->stmt, ext->def->argument)) {
-                    stmt = ext_p->child;
-                }
-            }
-        } else {
-            /* ... argument was one of the XML attributes which are represented as child stmt
-             * with LYS_YIN_ATTR flag */
-            for (stmt = ext_p->child; stmt && (stmt->flags & LYS_YIN_ATTR); stmt = stmt->next) {
-                if (!strcmp(stmt->stmt, ext->def->argument)) {
-                    /* this is the extension's argument */
-                    break;
-                }
-            }
-        }
-        if (!stmt) {
-            /* missing extension's argument */
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Extension instance \"%s\" misses argument \"%s\".", prefixed_name, ext->def->argument);
-            ret = LY_EVALID;
-            goto cleanup;
-
-        }
-        LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, stmt->arg, 0, &ext->argument), cleanup);
-        stmt->flags |= LYS_YIN_ARGUMENT;
-    }
-    if (prefixed_name != ext_p->name) {
-        lydict_remove(ctx->ctx, ext_p->name);
-        ext_p->name = prefixed_name;
-        if (!ext_p->argument && ext->argument) {
-            LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, ext->argument, 0, &ext_p->argument), cleanup);
-        }
-    }
-
-    if (ext->def->plugin && ext->def->plugin->compile) {
-        if (ext->argument) {
-            lysc_update_path(ctx, (struct lysc_node *)ext, ext->argument);
-        }
-        LY_CHECK_GOTO(ret = ext->def->plugin->compile(ctx, ext_p, ext), cleanup);
-        if (ext->argument) {
-            lysc_update_path(ctx, NULL, NULL);
-        }
-    }
-    ext_p->compiled = ext;
-
-cleanup:
-    if (prefixed_name && (prefixed_name != ext_p->name)) {
-        lydict_remove(ctx->ctx, prefixed_name);
-    }
-
-    lysc_update_path(ctx, NULL, NULL);
-    lysc_update_path(ctx, NULL, NULL);
-
-    return ret;
-}
-
-/**
- * @brief Compile information from the if-feature statement
- * @param[in] ctx Compile context.
- * @param[in] qname The if-feature argument to process. It is pointer-to-qname just to unify the compile functions.
- * @param[in,out] iff Prepared (empty) compiled if-feature structure to fill.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_iffeature(struct lysc_ctx *ctx, struct lysp_qname *qname, struct lysc_iffeature *iff)
-{
-    LY_ERR rc = LY_SUCCESS;
-    const char *c = qname->str;
-    int64_t i, j;
-    int8_t op_len, last_not = 0, checkversion = 0;
-    LY_ARRAY_COUNT_TYPE f_size = 0, expr_size = 0, f_exp = 1;
-    uint8_t op;
-    struct iff_stack stack = {0, 0, NULL};
-    struct lysc_feature *f;
-
-    assert(c);
-
-    /* pre-parse the expression to get sizes for arrays, also do some syntax checks of the expression */
-    for (i = j = 0; c[i]; i++) {
-        if (c[i] == '(') {
-            j++;
-            checkversion = 1;
-            continue;
-        } else if (c[i] == ')') {
-            j--;
-            continue;
-        } else if (isspace(c[i])) {
-            checkversion = 1;
-            continue;
-        }
-
-        if (!strncmp(&c[i], "not", op_len = 3) || !strncmp(&c[i], "and", op_len = 3) || !strncmp(&c[i], "or", op_len = 2)) {
-            uint64_t spaces;
-            for (spaces = 0; c[i + op_len + spaces] && isspace(c[i + op_len + spaces]); spaces++) {}
-            if (c[i + op_len + spaces] == '\0') {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                        "Invalid value \"%s\" of if-feature - unexpected end of expression.", qname->str);
-                return LY_EVALID;
-            } else if (!isspace(c[i + op_len])) {
-                /* feature name starting with the not/and/or */
-                last_not = 0;
-                f_size++;
-            } else if (c[i] == 'n') { /* not operation */
-                if (last_not) {
-                    /* double not */
-                    expr_size = expr_size - 2;
-                    last_not = 0;
-                } else {
-                    last_not = 1;
-                }
-            } else { /* and, or */
-                if (f_exp != f_size) {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                            "Invalid value \"%s\" of if-feature - missing feature/expression before \"%.*s\" operation.",
-                            qname->str, op_len, &c[i]);
-                    return LY_EVALID;
-                }
-                f_exp++;
-
-                /* not a not operation */
-                last_not = 0;
-            }
-            i += op_len;
-        } else {
-            f_size++;
-            last_not = 0;
-        }
-        expr_size++;
-
-        while (!isspace(c[i])) {
-            if (!c[i] || (c[i] == ')') || (c[i] == '(')) {
-                i--;
-                break;
-            }
-            i++;
-        }
-    }
-    if (j) {
-        /* not matching count of ( and ) */
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                "Invalid value \"%s\" of if-feature - non-matching opening and closing parentheses.", qname->str);
-        return LY_EVALID;
-    }
-    if (f_exp != f_size) {
-        /* features do not match the needed arguments for the logical operations */
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                "Invalid value \"%s\" of if-feature - number of features in expression does not match "
-                "the required number of operands for the operations.", qname->str);
-        return LY_EVALID;
-    }
-
-    if (checkversion || (expr_size > 1)) {
-        /* check that we have 1.1 module */
-        if (qname->mod->version != LYS_VERSION_1_1) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                    "Invalid value \"%s\" of if-feature - YANG 1.1 expression in YANG 1.0 module.", qname->str);
-            return LY_EVALID;
-        }
-    }
-
-    /* allocate the memory */
-    LY_ARRAY_CREATE_RET(ctx->ctx, iff->features, f_size, LY_EMEM);
-    iff->expr = calloc((j = (expr_size / 4) + ((expr_size % 4) ? 1 : 0)), sizeof *iff->expr);
-    stack.stack = malloc(expr_size * sizeof *stack.stack);
-    LY_CHECK_ERR_GOTO(!stack.stack || !iff->expr, LOGMEM(ctx->ctx); rc = LY_EMEM, error);
-
-    stack.size = expr_size;
-    f_size--; expr_size--; /* used as indexes from now */
-
-    for (i--; i >= 0; i--) {
-        if (c[i] == ')') {
-            /* push it on stack */
-            iff_stack_push(&stack, LYS_IFF_RP);
-            continue;
-        } else if (c[i] == '(') {
-            /* pop from the stack into result all operators until ) */
-            while ((op = iff_stack_pop(&stack)) != LYS_IFF_RP) {
-                iff_setop(iff->expr, op, expr_size--);
-            }
-            continue;
-        } else if (isspace(c[i])) {
-            continue;
-        }
-
-        /* end of operator or operand -> find beginning and get what is it */
-        j = i + 1;
-        while (i >= 0 && !isspace(c[i]) && c[i] != '(') {
-            i--;
-        }
-        i++; /* go back by one step */
-
-        if (!strncmp(&c[i], "not", 3) && isspace(c[i + 3])) {
-            if (stack.index && (stack.stack[stack.index - 1] == LYS_IFF_NOT)) {
-                /* double not */
-                iff_stack_pop(&stack);
-            } else {
-                /* not has the highest priority, so do not pop from the stack
-                 * as in case of AND and OR */
-                iff_stack_push(&stack, LYS_IFF_NOT);
-            }
-        } else if (!strncmp(&c[i], "and", 3) && isspace(c[i + 3])) {
-            /* as for OR - pop from the stack all operators with the same or higher
-             * priority and store them to the result, then push the AND to the stack */
-            while (stack.index && stack.stack[stack.index - 1] <= LYS_IFF_AND) {
-                op = iff_stack_pop(&stack);
-                iff_setop(iff->expr, op, expr_size--);
-            }
-            iff_stack_push(&stack, LYS_IFF_AND);
-        } else if (!strncmp(&c[i], "or", 2) && isspace(c[i + 2])) {
-            while (stack.index && stack.stack[stack.index - 1] <= LYS_IFF_OR) {
-                op = iff_stack_pop(&stack);
-                iff_setop(iff->expr, op, expr_size--);
-            }
-            iff_stack_push(&stack, LYS_IFF_OR);
-        } else {
-            /* feature name, length is j - i */
-
-            /* add it to the expression */
-            iff_setop(iff->expr, LYS_IFF_F, expr_size--);
-
-            /* now get the link to the feature definition */
-            f = lys_feature_find(qname->mod, &c[i], j - i);
-            LY_CHECK_ERR_GOTO(!f, LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                    "Invalid value \"%s\" of if-feature - unable to find feature \"%.*s\".", qname->str, j - i, &c[i]);
-                    rc = LY_EVALID, error)
-            iff->features[f_size] = f;
-            LY_ARRAY_INCREMENT(iff->features);
-            f_size--;
-        }
-    }
-    while (stack.index) {
-        op = iff_stack_pop(&stack);
-        iff_setop(iff->expr, op, expr_size--);
-    }
-
-    if (++expr_size || ++f_size) {
-        /* not all expected operators and operands found */
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                "Invalid value \"%s\" of if-feature - processing error.", qname->str);
-        rc = LY_EINT;
-    } else {
-        rc = LY_SUCCESS;
-    }
-
-error:
-    /* cleanup */
-    iff_stack_clean(&stack);
-
-    return rc;
-}
-
-/**
- * @brief Get the XPath context node for the given schema node.
- * @param[in] start The schema node where the XPath expression appears.
- * @return The context node to evaluate XPath expression in given schema node.
- * @return NULL in case the context node is the root node.
- */
-static struct lysc_node *
-lysc_xpath_context(struct lysc_node *start)
-{
-    for (; start && !(start->nodetype & (LYS_CONTAINER | LYS_LEAF | LYS_LEAFLIST | LYS_LIST | LYS_ANYDATA | LYS_RPC | LYS_ACTION | LYS_NOTIF));
-            start = start->parent) {}
-    return start;
-}
-
-/**
- * @brief Compile information from the when statement
- *
- * @param[in] ctx Compile context.
- * @param[in] when_p Parsed when structure.
- * @param[in] flags Flags of the parsed node with the when statement.
- * @param[in] ctx_node Context node for the when statement.
- * @param[out] when Pointer where to store pointer to the created compiled when structure.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_when_(struct lysc_ctx *ctx, struct lysp_when *when_p, uint16_t flags, const struct lysc_node *ctx_node,
-        struct lysc_when **when)
-{
-    LY_ERR ret = LY_SUCCESS;
-
-    *when = calloc(1, sizeof **when);
-    LY_CHECK_ERR_RET(!(*when), LOGMEM(ctx->ctx), LY_EMEM);
-    (*when)->refcount = 1;
-    LY_CHECK_RET(lyxp_expr_parse(ctx->ctx, when_p->cond, 0, 1, &(*when)->cond));
-    LY_CHECK_RET(lysc_prefixes_compile(when_p->cond, strlen(when_p->cond), ctx->pmod, &(*when)->prefixes));
-    (*when)->context = (struct lysc_node *)ctx_node;
-    DUP_STRING_GOTO(ctx->ctx, when_p->dsc, (*when)->dsc, ret, done);
-    DUP_STRING_GOTO(ctx->ctx, when_p->ref, (*when)->ref, ret, done);
-    COMPILE_EXTS_GOTO(ctx, when_p->exts, (*when)->exts, (*when), LYEXT_PAR_WHEN, ret, done);
-    (*when)->flags = flags & LYS_STATUS_MASK;
-
-done:
-    return ret;
-}
-
-/**
- * @brief Compile information from the when statement by either standard compilation or by reusing
- * another compiled when structure.
- *
- * @param[in] ctx Compile context.
- * @param[in] when_p Parsed when structure.
- * @param[in] flags Flags of the parsed node with the when statement.
- * @param[in] ctx_node Context node for the when statement.
- * @param[in] node Compiled node to which add the compiled when.
- * @param[in,out] when_c Optional, pointer to the previously compiled @p when_p to be reused. Set to NULL
- * for the first call.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_when(struct lysc_ctx *ctx, struct lysp_when *when_p, uint16_t flags, const struct lysc_node *ctx_node,
-        struct lysc_node *node, struct lysc_when **when_c)
-{
-    struct lysc_when **new_when, ***node_when;
-
-    assert(when_p);
-
-    /* get the when array */
-    if (node->nodetype & LYS_ACTION) {
-        node_when = &((struct lysc_action *)node)->when;
-    } else if (node->nodetype == LYS_NOTIF) {
-        node_when = &((struct lysc_notif *)node)->when;
-    } else {
-        node_when = &node->when;
-    }
-
-    /* create new when pointer */
-    LY_ARRAY_NEW_RET(ctx->ctx, *node_when, new_when, LY_EMEM);
-    if (!when_c || !(*when_c)) {
-        /* compile when */
-        LY_CHECK_RET(lys_compile_when_(ctx, when_p, flags, ctx_node, new_when));
-
-        if (!(ctx->options & LYS_COMPILE_GROUPING)) {
-            /* do not check "when" semantics in a grouping */
-            LY_CHECK_RET(ly_set_add(&ctx->xpath, node, 0, NULL));
-        }
-
-        /* remember the compiled when for sharing */
-        if (when_c) {
-            *when_c = *new_when;
-        }
-    } else {
-        /* use the previously compiled when */
-        ++(*when_c)->refcount;
-        *new_when = *when_c;
-
-        if (!(ctx->options & LYS_COMPILE_GROUPING)) {
-            /* in this case check "when" again for all children because of dummy node check */
-            LY_CHECK_RET(ly_set_add(&ctx->xpath, node, 0, NULL));
-        }
-    }
-
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Compile information from the must statement
- * @param[in] ctx Compile context.
- * @param[in] must_p The parsed must statement structure.
- * @param[in,out] must Prepared (empty) compiled must structure to fill.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_must(struct lysc_ctx *ctx, struct lysp_restr *must_p, struct lysc_must *must)
-{
-    LY_ERR ret = LY_SUCCESS;
-
-    LY_CHECK_RET(lyxp_expr_parse(ctx->ctx, must_p->arg.str, 0, 1, &must->cond));
-    LY_CHECK_RET(lysc_prefixes_compile(must_p->arg.str, strlen(must_p->arg.str), must_p->arg.mod, &must->prefixes));
-    DUP_STRING_GOTO(ctx->ctx, must_p->eapptag, must->eapptag, ret, done);
-    DUP_STRING_GOTO(ctx->ctx, must_p->emsg, must->emsg, ret, done);
-    DUP_STRING_GOTO(ctx->ctx, must_p->dsc, must->dsc, ret, done);
-    DUP_STRING_GOTO(ctx->ctx, must_p->ref, must->ref, ret, done);
-    COMPILE_EXTS_GOTO(ctx, must_p->exts, must->exts, must, LYEXT_PAR_MUST, ret, done);
-
-done:
-    return ret;
-}
-
-/**
- * @brief Compile information in the import statement - make sure there is the target module
- * @param[in] ctx Compile context.
- * @param[in] imp_p The parsed import statement structure to fill the module to.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_import(struct lysc_ctx *ctx, struct lysp_import *imp_p)
-{
-    const struct lys_module *mod = NULL;
-    LY_ERR ret = LY_SUCCESS;
-
-    /* make sure that we have the parsed version (lysp_) of the imported module to import groupings or typedefs.
-     * The compiled version is needed only for augments, deviates and leafrefs, so they are checked (and added,
-     * if needed) when these nodes are finally being instantiated and validated at the end of schema compilation. */
-    if (!imp_p->module->parsed) {
-        /* try to use filepath if present */
-        if (imp_p->module->filepath) {
-            struct ly_in *in;
-            if (ly_in_new_filepath(imp_p->module->filepath, 0, &in)) {
-                LOGINT(ctx->ctx);
-            } else {
-                LY_CHECK_RET(lys_parse(ctx->ctx, in, !strcmp(&imp_p->module->filepath[strlen(imp_p->module->filepath - 4)],
-                        ".yin") ? LYS_IN_YIN : LYS_IN_YANG, &mod));
-                if (mod != imp_p->module) {
-                    LOGERR(ctx->ctx, LY_EINT, "Filepath \"%s\" of the module \"%s\" does not match.",
-                            imp_p->module->filepath, imp_p->module->name);
-                    mod = NULL;
-                }
-            }
-            ly_in_free(in, 1);
-        }
-        if (!mod) {
-            if (lysp_load_module(ctx->ctx, imp_p->module->name, imp_p->module->revision, 0, 1, (struct lys_module **)&mod)) {
-                LOGERR(ctx->ctx, LY_ENOTFOUND, "Unable to reload \"%s\" module to import it into \"%s\", source data not found.",
-                        imp_p->module->name, ctx->cur_mod->name);
-                return LY_ENOTFOUND;
-            }
-        }
-    }
-
-    return ret;
-}
-
-LY_ERR
-lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
-        struct lysp_ident *identities_p, struct lysc_ident **identities)
-{
-    LY_ARRAY_COUNT_TYPE offset = 0, u, v;
-    struct lysc_ctx context = {0};
-    LY_ERR ret = LY_SUCCESS;
-
-    assert(ctx_sc || ctx);
-
-    if (!ctx_sc) {
-        context.ctx = ctx;
-        context.cur_mod = parsed_mod->mod;
-        context.pmod = parsed_mod;
-        context.path_len = 1;
-        context.path[0] = '/';
-        ctx_sc = &context;
-    }
-
-    if (!identities_p) {
-        return LY_SUCCESS;
-    }
-    if (*identities) {
-        offset = LY_ARRAY_COUNT(*identities);
-    }
-
-    lysc_update_path(ctx_sc, NULL, "{identity}");
-    LY_ARRAY_CREATE_RET(ctx_sc->ctx, *identities, LY_ARRAY_COUNT(identities_p), LY_EMEM);
-    LY_ARRAY_FOR(identities_p, u) {
-        lysc_update_path(ctx_sc, NULL, identities_p[u].name);
-
-        LY_ARRAY_INCREMENT(*identities);
-        COMPILE_CHECK_UNIQUENESS_ARRAY(ctx_sc, *identities, name, &(*identities)[offset + u], "identity", identities_p[u].name);
-        DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].name, (*identities)[offset + u].name, ret, done);
-        DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].dsc, (*identities)[offset + u].dsc, ret, done);
-        DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].ref, (*identities)[offset + u].ref, ret, done);
-        (*identities)[offset + u].module = ctx_sc->cur_mod;
-        COMPILE_ARRAY_GOTO(ctx_sc, identities_p[u].iffeatures, (*identities)[offset + u].iffeatures, v,
-                lys_compile_iffeature, ret, done);
-        /* backlinks (derived) can be added no sooner than when all the identities in the current module are present */
-        COMPILE_EXTS_GOTO(ctx_sc, identities_p[u].exts, (*identities)[offset + u].exts, &(*identities)[offset + u],
-                LYEXT_PAR_IDENT, ret, done);
-        (*identities)[offset + u].flags = identities_p[u].flags;
-
-        lysc_update_path(ctx_sc, NULL, NULL);
-    }
-    lysc_update_path(ctx_sc, NULL, NULL);
-done:
-    return ret;
-}
-
-/**
- * @brief Check circular dependency of identities - identity MUST NOT reference itself (via their base statement).
- *
- * The function works in the same way as lys_compile_feature_circular_check() with different structures and error messages.
- *
- * @param[in] ctx Compile context for logging.
- * @param[in] ident The base identity (its derived list is being extended by the identity being currently processed).
- * @param[in] derived The list of derived identities of the identity being currently processed (not the one provided as @p ident)
- * @return LY_SUCCESS if everything is ok.
- * @return LY_EVALID if the identity is derived from itself.
- */
-static LY_ERR
-lys_compile_identity_circular_check(struct lysc_ctx *ctx, struct lysc_ident *ident, struct lysc_ident **derived)
-{
-    LY_ERR ret = LY_SUCCESS;
-    LY_ARRAY_COUNT_TYPE u, v;
-    struct ly_set recursion = {0};
-    struct lysc_ident *drv;
-
-    if (!derived) {
-        return LY_SUCCESS;
-    }
-
-    for (u = 0; u < LY_ARRAY_COUNT(derived); ++u) {
-        if (ident == derived[u]) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Identity \"%s\" is indirectly derived from itself.", ident->name);
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-        ret = ly_set_add(&recursion, derived[u], 0, NULL);
-        LY_CHECK_GOTO(ret, cleanup);
-    }
-
-    for (v = 0; v < recursion.count; ++v) {
-        drv = recursion.objs[v];
-        if (!drv->derived) {
-            continue;
-        }
-        for (u = 0; u < LY_ARRAY_COUNT(drv->derived); ++u) {
-            if (ident == drv->derived[u]) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                        "Identity \"%s\" is indirectly derived from itself.", ident->name);
-                ret = LY_EVALID;
-                goto cleanup;
-            }
-            ret = ly_set_add(&recursion, drv->derived[u], 0, NULL);
-            LY_CHECK_GOTO(ret, cleanup);
-        }
-    }
-
-cleanup:
-    ly_set_erase(&recursion, NULL);
-    return ret;
-}
-
-/**
- * @brief Find and process the referenced base identities from another identity or identityref
- *
- * For bases in identity set backlinks to them from the base identities. For identityref, store
- * the array of pointers to the base identities. So one of the ident or bases parameter must be set
- * to distinguish these two use cases.
- *
- * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
- * @param[in] base_pmod Module where to resolve @p bases_p prefixes.
- * @param[in] bases_p Array of names (including prefix if necessary) of base identities.
- * @param[in] ident Referencing identity to work with, NULL for identityref.
- * @param[in] bases Array of bases of identityref to fill in.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_identity_bases(struct lysc_ctx *ctx, const struct lysp_module *base_pmod, const char **bases_p,
-        struct lysc_ident *ident, struct lysc_ident ***bases)
-{
-    LY_ARRAY_COUNT_TYPE u, v;
-    const char *s, *name;
-    const struct lys_module *mod;
-    struct lysc_ident **idref;
-
-    assert(ident || bases);
-
-    if ((LY_ARRAY_COUNT(bases_p) > 1) && (ctx->pmod->version < LYS_VERSION_1_1)) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                "Multiple bases in %s are allowed only in YANG 1.1 modules.", ident ? "identity" : "identityref type");
-        return LY_EVALID;
-    }
-
-    LY_ARRAY_FOR(bases_p, u) {
-        s = strchr(bases_p[u], ':');
-        if (s) {
-            /* prefixed identity */
-            name = &s[1];
-            mod = lysp_module_find_prefix(base_pmod, bases_p[u], s - bases_p[u]);
-        } else {
-            name = bases_p[u];
-            mod = base_pmod->mod;
-        }
-        if (!mod) {
-            if (ident) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                        "Invalid prefix used for base (%s) of identity \"%s\".", bases_p[u], ident->name);
-            } else {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                        "Invalid prefix used for base (%s) of identityref.", bases_p[u]);
-            }
-            return LY_EVALID;
-        }
-
-        idref = NULL;
-        LY_ARRAY_FOR(mod->identities, v) {
-            if (!strcmp(name, mod->identities[v].name)) {
-                if (ident) {
-                    if (ident == &mod->identities[v]) {
-                        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                                "Identity \"%s\" is derived from itself.", ident->name);
-                        return LY_EVALID;
-                    }
-                    LY_CHECK_RET(lys_compile_identity_circular_check(ctx, &mod->identities[v], ident->derived));
-                    /* we have match! store the backlink */
-                    LY_ARRAY_NEW_RET(ctx->ctx, mod->identities[v].derived, idref, LY_EMEM);
-                    *idref = ident;
-                } else {
-                    /* we have match! store the found identity */
-                    LY_ARRAY_NEW_RET(ctx->ctx, *bases, idref, LY_EMEM);
-                    *idref = &mod->identities[v];
-                }
-                break;
-            }
-        }
-        if (!idref || !(*idref)) {
-            if (ident) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                        "Unable to find base (%s) of identity \"%s\".", bases_p[u], ident->name);
-            } else {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                        "Unable to find base (%s) of identityref.", bases_p[u]);
-            }
-            return LY_EVALID;
-        }
-    }
-    return LY_SUCCESS;
-}
-
-/**
- * @brief For the given array of identities, set the backlinks from all their base identities.
- * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
- * @param[in] idents_p Array of identities definitions from the parsed schema structure.
- * @param[in] idents Array of referencing identities to which the backlinks are supposed to be set.
- * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
- */
-static LY_ERR
-lys_compile_identities_derived(struct lysc_ctx *ctx, struct lysp_ident *idents_p, struct lysc_ident *idents)
-{
-    LY_ARRAY_COUNT_TYPE u;
-
-    lysc_update_path(ctx, NULL, "{identity}");
-    for (u = 0; u < LY_ARRAY_COUNT(idents_p); ++u) {
-        if (!idents_p[u].bases) {
-            continue;
-        }
-        lysc_update_path(ctx, NULL, idents[u].name);
-        LY_CHECK_RET(lys_compile_identity_bases(ctx, idents[u].module->parsed, idents_p[u].bases, &idents[u], NULL));
-        lysc_update_path(ctx, NULL, NULL);
-    }
-    lysc_update_path(ctx, NULL, NULL);
-    return LY_SUCCESS;
-}
-
-LY_ERR
-lys_feature_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
-        struct lysp_feature *features_p, struct lysc_feature **features)
-{
-    LY_ERR ret = LY_SUCCESS;
-    LY_ARRAY_COUNT_TYPE offset = 0, u;
-    struct lysc_ctx context = {0};
-
-    assert(ctx_sc || ctx);
-
-    if (!ctx_sc) {
-        context.ctx = ctx;
-        context.cur_mod = parsed_mod->mod;
-        context.pmod = parsed_mod;
-        context.path_len = 1;
-        context.path[0] = '/';
-        ctx_sc = &context;
-    }
-
-    if (!features_p) {
-        return LY_SUCCESS;
-    }
-    if (*features) {
-        offset = LY_ARRAY_COUNT(*features);
-    }
-
-    lysc_update_path(ctx_sc, NULL, "{feature}");
-    LY_ARRAY_CREATE_RET(ctx_sc->ctx, *features, LY_ARRAY_COUNT(features_p), LY_EMEM);
-    LY_ARRAY_FOR(features_p, u) {
-        lysc_update_path(ctx_sc, NULL, features_p[u].name);
-
-        LY_ARRAY_INCREMENT(*features);
-        COMPILE_CHECK_UNIQUENESS_ARRAY(ctx_sc, *features, name, &(*features)[offset + u], "feature", features_p[u].name);
-        DUP_STRING_GOTO(ctx_sc->ctx, features_p[u].name, (*features)[offset + u].name, ret, done);
-        DUP_STRING_GOTO(ctx_sc->ctx, features_p[u].dsc, (*features)[offset + u].dsc, ret, done);
-        DUP_STRING_GOTO(ctx_sc->ctx, features_p[u].ref, (*features)[offset + u].ref, ret, done);
-        (*features)[offset + u].flags = features_p[u].flags;
-        (*features)[offset + u].module = ctx_sc->cur_mod;
-
-        lysc_update_path(ctx_sc, NULL, NULL);
-    }
-    lysc_update_path(ctx_sc, NULL, NULL);
-
-done:
-    return ret;
-}
-
-/**
- * @brief Check circular dependency of features - feature MUST NOT reference itself (via their if-feature statement).
- *
- * The function works in the same way as lys_compile_identity_circular_check() with different structures and error messages.
- *
- * @param[in] ctx Compile context for logging.
- * @param[in] feature The feature referenced in if-feature statement (its depfeatures list is being extended by the feature
- *            being currently processed).
- * @param[in] depfeatures The list of depending features of the feature being currently processed (not the one provided as @p feature)
- * @return LY_SUCCESS if everything is ok.
- * @return LY_EVALID if the feature references indirectly itself.
- */
-static LY_ERR
-lys_compile_feature_circular_check(struct lysc_ctx *ctx, struct lysc_feature *feature, struct lysc_feature **depfeatures)
-{
-    LY_ERR ret = LY_SUCCESS;
-    LY_ARRAY_COUNT_TYPE u, v;
-    struct ly_set recursion = {0};
-    struct lysc_feature *drv;
-
-    if (!depfeatures) {
-        return LY_SUCCESS;
-    }
-
-    for (u = 0; u < LY_ARRAY_COUNT(depfeatures); ++u) {
-        if (feature == depfeatures[u]) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Feature \"%s\" is indirectly referenced from itself.", feature->name);
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-        ret = ly_set_add(&recursion, depfeatures[u], 0, NULL);
-        LY_CHECK_GOTO(ret, cleanup);
-    }
-
-    for (v = 0; v < recursion.count; ++v) {
-        drv = recursion.objs[v];
-        if (!drv->depfeatures) {
-            continue;
-        }
-        for (u = 0; u < LY_ARRAY_COUNT(drv->depfeatures); ++u) {
-            if (feature == drv->depfeatures[u]) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                        "Feature \"%s\" is indirectly referenced from itself.", feature->name);
-                ret = LY_EVALID;
-                goto cleanup;
-            }
-            ly_set_add(&recursion, drv->depfeatures[u], 0, NULL);
-            LY_CHECK_GOTO(ret, cleanup);
-        }
-    }
-
-cleanup:
-    ly_set_erase(&recursion, NULL);
-    return ret;
-}
-
-/**
- * @brief Create pre-compiled features array.
- *
- * See lys_feature_precompile() for more details.
- *
- * @param[in] ctx Compile context.
- * @param[in] feature_p Parsed feature definition to compile.
- * @param[in,out] features List of already (pre)compiled features to find the corresponding precompiled feature structure.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_feature_precompile_finish(struct lysc_ctx *ctx, struct lysp_feature *feature_p, struct lysc_feature *features)
-{
-    LY_ARRAY_COUNT_TYPE u, v, x;
-    struct lysc_feature *feature, **df;
-    LY_ERR ret = LY_SUCCESS;
-
-    /* find the preprecompiled feature */
-    LY_ARRAY_FOR(features, x) {
-        if (strcmp(features[x].name, feature_p->name)) {
-            continue;
-        }
-        feature = &features[x];
-        lysc_update_path(ctx, NULL, "{feature}");
-        lysc_update_path(ctx, NULL, feature_p->name);
-
-        /* finish compilation started in lys_feature_precompile() */
-        COMPILE_EXTS_GOTO(ctx, feature_p->exts, feature->exts, feature, LYEXT_PAR_FEATURE, ret, done);
-        COMPILE_ARRAY_GOTO(ctx, feature_p->iffeatures, feature->iffeatures, u, lys_compile_iffeature, ret, done);
-        if (feature->iffeatures) {
-            for (u = 0; u < LY_ARRAY_COUNT(feature->iffeatures); ++u) {
-                if (feature->iffeatures[u].features) {
-                    for (v = 0; v < LY_ARRAY_COUNT(feature->iffeatures[u].features); ++v) {
-                        /* check for circular dependency - direct reference first,... */
-                        if (feature == feature->iffeatures[u].features[v]) {
-                            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                                    "Feature \"%s\" is referenced from itself.", feature->name);
-                            return LY_EVALID;
-                        }
-                        /* ... and indirect circular reference */
-                        LY_CHECK_RET(lys_compile_feature_circular_check(ctx, feature->iffeatures[u].features[v], feature->depfeatures));
-
-                        /* add itself into the dependants list */
-                        LY_ARRAY_NEW_RET(ctx->ctx, feature->iffeatures[u].features[v]->depfeatures, df, LY_EMEM);
-                        *df = feature;
-                    }
-                }
-            }
-        }
-        lysc_update_path(ctx, NULL, NULL);
-        lysc_update_path(ctx, NULL, NULL);
-done:
-        return ret;
-    }
-
-    LOGINT(ctx->ctx);
-    return LY_EINT;
-}
-
-/**
- * @brief Revert compiled list of features back to the precompiled state.
- *
- * Function is needed in case the compilation failed and the schema is expected to revert back to the non-compiled status.
- *
- * @param[in] ctx Compilation context.
- * @param[in] mod The module structure with the features to decompile.
- */
-static void
-lys_feature_precompile_revert(struct lysc_ctx *ctx, struct lys_module *mod)
-{
-    LY_ARRAY_COUNT_TYPE u, v;
-
-    /* in the dis_features list, remove all the parts (from finished compiling process)
-     * which may points into the data being freed here */
-    LY_ARRAY_FOR(mod->features, u) {
-        LY_ARRAY_FOR(mod->features[u].iffeatures, v) {
-            lysc_iffeature_free(ctx->ctx, &mod->features[u].iffeatures[v]);
-        }
-        LY_ARRAY_FREE(mod->features[u].iffeatures);
-        mod->features[u].iffeatures = NULL;
-
-        LY_ARRAY_FOR(mod->features[u].exts, v) {
-            lysc_ext_instance_free(ctx->ctx, &(mod->features[u].exts)[v]);
-        }
-        LY_ARRAY_FREE(mod->features[u].exts);
-        mod->features[u].exts = NULL;
-    }
-}
-
-/**
- * @brief Validate and normalize numeric value from a range definition.
- * @param[in] ctx Compile context.
- * @param[in] basetype Base YANG built-in type of the node connected with the range restriction. Actually only LY_TYPE_DEC64 is important to
- * allow processing of the fractions. The fraction point is extracted from the value which is then normalize according to given frdigits into
- * valcopy to allow easy parsing and storing of the value. libyang stores decimal number without the decimal point which is always recovered from
- * the known fraction-digits value. So, with fraction-digits 2, number 3.14 is stored as 314 and number 1 is stored as 100.
- * @param[in] frdigits The fraction-digits of the type in case of LY_TYPE_DEC64.
- * @param[in] value String value of the range boundary.
- * @param[out] len Number of the processed bytes from the value. Processing stops on the first character which is not part of the number boundary.
- * @param[out] valcopy NULL-terminated string with the numeric value to parse and store.
- * @return LY_ERR value - LY_SUCCESS, LY_EMEM, LY_EVALID (no number) or LY_EINVAL (decimal64 not matching fraction-digits value).
- */
-LY_ERR
-range_part_check_value_syntax(struct lysc_ctx *ctx, LY_DATA_TYPE basetype, uint8_t frdigits, const char *value, size_t *len, char **valcopy)
-{
-    size_t fraction = 0, size;
-
-    *len = 0;
-
-    assert(value);
-    /* parse value */
-    if (!isdigit(value[*len]) && (value[*len] != '-') && (value[*len] != '+')) {
-        return LY_EVALID;
-    }
-
-    if ((value[*len] == '-') || (value[*len] == '+')) {
-        ++(*len);
-    }
-
-    while (isdigit(value[*len])) {
-        ++(*len);
-    }
-
-    if ((basetype != LY_TYPE_DEC64) || (value[*len] != '.') || !isdigit(value[*len + 1])) {
-        if (basetype == LY_TYPE_DEC64) {
-            goto decimal;
-        } else {
-            *valcopy = strndup(value, *len);
-            return LY_SUCCESS;
-        }
-    }
-    fraction = *len;
-
-    ++(*len);
-    while (isdigit(value[*len])) {
-        ++(*len);
-    }
-
-    if (basetype == LY_TYPE_DEC64) {
-decimal:
-        assert(frdigits);
-        if (fraction && (*len - 1 - fraction > frdigits)) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                    "Range boundary \"%.*s\" of decimal64 type exceeds defined number (%u) of fraction digits.",
-                    *len, value, frdigits);
-            return LY_EINVAL;
-        }
-        if (fraction) {
-            size = (*len) + (frdigits - ((*len) - 1 - fraction));
-        } else {
-            size = (*len) + frdigits + 1;
-        }
-        *valcopy = malloc(size * sizeof **valcopy);
-        LY_CHECK_ERR_RET(!(*valcopy), LOGMEM(ctx->ctx), LY_EMEM);
-
-        (*valcopy)[size - 1] = '\0';
-        if (fraction) {
-            memcpy(&(*valcopy)[0], &value[0], fraction);
-            memcpy(&(*valcopy)[fraction], &value[fraction + 1], (*len) - 1 - (fraction));
-            memset(&(*valcopy)[(*len) - 1], '0', frdigits - ((*len) - 1 - fraction));
-        } else {
-            memcpy(&(*valcopy)[0], &value[0], *len);
-            memset(&(*valcopy)[*len], '0', frdigits);
-        }
-    }
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Check that values in range are in ascendant order.
- * @param[in] unsigned_value Flag to note that we are working with unsigned values.
- * @param[in] max Flag to distinguish if checking min or max value. min value must be strictly higher than previous,
- * max can be also equal.
- * @param[in] value Current value to check.
- * @param[in] prev_value The last seen value.
- * @return LY_SUCCESS or LY_EEXIST for invalid order.
- */
-static LY_ERR
-range_part_check_ascendancy(ly_bool unsigned_value, ly_bool max, int64_t value, int64_t prev_value)
-{
-    if (unsigned_value) {
-        if ((max && ((uint64_t)prev_value > (uint64_t)value)) || (!max && ((uint64_t)prev_value >= (uint64_t)value))) {
-            return LY_EEXIST;
-        }
-    } else {
-        if ((max && (prev_value > value)) || (!max && (prev_value >= value))) {
-            return LY_EEXIST;
-        }
-    }
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Set min/max value of the range part.
- * @param[in] ctx Compile context.
- * @param[in] part Range part structure to fill.
- * @param[in] max Flag to distinguish if storing min or max value.
- * @param[in] prev The last seen value to check that all values in range are specified in ascendant order.
- * @param[in] basetype Type of the value to get know implicit min/max values and other checking rules.
- * @param[in] first Flag for the first value of the range to avoid ascendancy order.
- * @param[in] length_restr Flag to distinguish between range and length restrictions. Only for logging.
- * @param[in] frdigits The fraction-digits value in case of LY_TYPE_DEC64 basetype.
- * @param[in] base_range Range from the type from which the current type is derived (if not built-in) to get type's min and max values.
- * @param[in,out] value Numeric range value to be stored, if not provided the type's min/max value is set.
- * @return LY_ERR value - LY_SUCCESS, LY_EDENIED (value brokes type's boundaries), LY_EVALID (not a number),
- * LY_EEXIST (value is smaller than the previous one), LY_EINVAL (decimal64 value does not corresponds with the
- * frdigits value), LY_EMEM.
- */
-static LY_ERR
-range_part_minmax(struct lysc_ctx *ctx, struct lysc_range_part *part, ly_bool max, int64_t prev, LY_DATA_TYPE basetype,
-        ly_bool first, ly_bool length_restr, uint8_t frdigits, struct lysc_range *base_range, const char **value)
-{
-    LY_ERR ret = LY_SUCCESS;
-    char *valcopy = NULL;
-    size_t len;
-
-    if (value) {
-        ret = range_part_check_value_syntax(ctx, basetype, frdigits, *value, &len, &valcopy);
-        LY_CHECK_GOTO(ret, finalize);
-    }
-    if (!valcopy && base_range) {
-        if (max) {
-            part->max_64 = base_range->parts[LY_ARRAY_COUNT(base_range->parts) - 1].max_64;
-        } else {
-            part->min_64 = base_range->parts[0].min_64;
-        }
-        if (!first) {
-            ret = range_part_check_ascendancy(basetype <= LY_TYPE_STRING ? 1 : 0, max, max ? part->max_64 : part->min_64, prev);
-        }
-        goto finalize;
-    }
-
-    switch (basetype) {
-    case LY_TYPE_INT8: /* range */
-        if (valcopy) {
-            ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-128), INT64_C(127), 10, max ? &part->max_64 : &part->min_64);
-        } else if (max) {
-            part->max_64 = INT64_C(127);
-        } else {
-            part->min_64 = INT64_C(-128);
-        }
-        if (!ret && !first) {
-            ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
-        }
-        break;
-    case LY_TYPE_INT16: /* range */
-        if (valcopy) {
-            ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-32768), INT64_C(32767), 10, max ? &part->max_64 : &part->min_64);
-        } else if (max) {
-            part->max_64 = INT64_C(32767);
-        } else {
-            part->min_64 = INT64_C(-32768);
-        }
-        if (!ret && !first) {
-            ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
-        }
-        break;
-    case LY_TYPE_INT32: /* range */
-        if (valcopy) {
-            ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-2147483648), INT64_C(2147483647), 10, max ? &part->max_64 : &part->min_64);
-        } else if (max) {
-            part->max_64 = INT64_C(2147483647);
-        } else {
-            part->min_64 = INT64_C(-2147483648);
-        }
-        if (!ret && !first) {
-            ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
-        }
-        break;
-    case LY_TYPE_INT64: /* range */
-    case LY_TYPE_DEC64: /* range */
-        if (valcopy) {
-            ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-9223372036854775807) - INT64_C(1), INT64_C(9223372036854775807), 10,
-                    max ? &part->max_64 : &part->min_64);
-        } else if (max) {
-            part->max_64 = INT64_C(9223372036854775807);
-        } else {
-            part->min_64 = INT64_C(-9223372036854775807) - INT64_C(1);
-        }
-        if (!ret && !first) {
-            ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
-        }
-        break;
-    case LY_TYPE_UINT8: /* range */
-        if (valcopy) {
-            ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(255), 10, max ? &part->max_u64 : &part->min_u64);
-        } else if (max) {
-            part->max_u64 = UINT64_C(255);
-        } else {
-            part->min_u64 = UINT64_C(0);
-        }
-        if (!ret && !first) {
-            ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
-        }
-        break;
-    case LY_TYPE_UINT16: /* range */
-        if (valcopy) {
-            ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(65535), 10, max ? &part->max_u64 : &part->min_u64);
-        } else if (max) {
-            part->max_u64 = UINT64_C(65535);
-        } else {
-            part->min_u64 = UINT64_C(0);
-        }
-        if (!ret && !first) {
-            ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
-        }
-        break;
-    case LY_TYPE_UINT32: /* range */
-        if (valcopy) {
-            ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(4294967295), 10, max ? &part->max_u64 : &part->min_u64);
-        } else if (max) {
-            part->max_u64 = UINT64_C(4294967295);
-        } else {
-            part->min_u64 = UINT64_C(0);
-        }
-        if (!ret && !first) {
-            ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
-        }
-        break;
-    case LY_TYPE_UINT64: /* range */
-    case LY_TYPE_STRING: /* length */
-    case LY_TYPE_BINARY: /* length */
-        if (valcopy) {
-            ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(18446744073709551615), 10, max ? &part->max_u64 : &part->min_u64);
-        } else if (max) {
-            part->max_u64 = UINT64_C(18446744073709551615);
-        } else {
-            part->min_u64 = UINT64_C(0);
-        }
-        if (!ret && !first) {
-            ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
-        }
-        break;
-    default:
-        LOGINT(ctx->ctx);
-        ret = LY_EINT;
-    }
-
-finalize:
-    if (ret == LY_EDENIED) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                "Invalid %s restriction - value \"%s\" does not fit the type limitations.",
-                length_restr ? "length" : "range", valcopy ? valcopy : *value);
-    } else if (ret == LY_EVALID) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                "Invalid %s restriction - invalid value \"%s\".",
-                length_restr ? "length" : "range", valcopy ? valcopy : *value);
-    } else if (ret == LY_EEXIST) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                "Invalid %s restriction - values are not in ascending order (%s).",
-                length_restr ? "length" : "range",
-                (valcopy && basetype != LY_TYPE_DEC64) ? valcopy : value ? *value : max ? "max" : "min");
-    } else if (!ret && value) {
-        *value = *value + len;
-    }
-    free(valcopy);
-    return ret;
-}
-
-/**
- * @brief Compile the parsed range restriction.
- * @param[in] ctx Compile context.
- * @param[in] range_p Parsed range structure to compile.
- * @param[in] basetype Base YANG built-in type of the node with the range restriction.
- * @param[in] length_restr Flag to distinguish between range and length restrictions. Only for logging.
- * @param[in] frdigits The fraction-digits value in case of LY_TYPE_DEC64 basetype.
- * @param[in] base_range Range restriction of the type from which the current type is derived. The current
- * range restriction must be more restrictive than the base_range.
- * @param[in,out] range Pointer to the created current range structure.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_type_range(struct lysc_ctx *ctx, struct lysp_restr *range_p, LY_DATA_TYPE basetype, ly_bool length_restr,
-        uint8_t frdigits, struct lysc_range *base_range, struct lysc_range **range)
-{
-    LY_ERR ret = LY_EVALID;
-    const char *expr;
-    struct lysc_range_part *parts = NULL, *part;
-    ly_bool range_expected = 0, uns;
-    LY_ARRAY_COUNT_TYPE parts_done = 0, u, v;
-
-    assert(range);
-    assert(range_p);
-
-    expr = range_p->arg.str;
-    while (1) {
-        if (isspace(*expr)) {
-            ++expr;
-        } else if (*expr == '\0') {
-            if (range_expected) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                        "Invalid %s restriction - unexpected end of the expression after \"..\" (%s).",
-                        length_restr ? "length" : "range", range_p->arg);
-                goto cleanup;
-            } else if (!parts || (parts_done == LY_ARRAY_COUNT(parts))) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                        "Invalid %s restriction - unexpected end of the expression (%s).",
-                        length_restr ? "length" : "range", range_p->arg);
-                goto cleanup;
-            }
-            parts_done++;
-            break;
-        } else if (!strncmp(expr, "min", 3)) {
-            if (parts) {
-                /* min cannot be used elsewhere than in the first part */
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                        "Invalid %s restriction - unexpected data before min keyword (%.*s).", length_restr ? "length" : "range",
-                        expr - range_p->arg.str, range_p->arg.str);
-                goto cleanup;
-            }
-            expr += 3;
-
-            LY_ARRAY_NEW_GOTO(ctx->ctx, parts, part, ret, cleanup);
-            LY_CHECK_GOTO(range_part_minmax(ctx, part, 0, 0, basetype, 1, length_restr, frdigits, base_range, NULL), cleanup);
-            part->max_64 = part->min_64;
-        } else if (*expr == '|') {
-            if (!parts || range_expected) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                        "Invalid %s restriction - unexpected beginning of the expression (%s).", length_restr ? "length" : "range", expr);
-                goto cleanup;
-            }
-            expr++;
-            parts_done++;
-            /* process next part of the expression */
-        } else if (!strncmp(expr, "..", 2)) {
-            expr += 2;
-            while (isspace(*expr)) {
-                expr++;
-            }
-            if (!parts || (LY_ARRAY_COUNT(parts) == parts_done)) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                        "Invalid %s restriction - unexpected \"..\" without a lower bound.", length_restr ? "length" : "range");
-                goto cleanup;
-            }
-            /* continue expecting the upper boundary */
-            range_expected = 1;
-        } else if (isdigit(*expr) || (*expr == '-') || (*expr == '+')) {
-            /* number */
-            if (range_expected) {
-                part = &parts[LY_ARRAY_COUNT(parts) - 1];
-                LY_CHECK_GOTO(range_part_minmax(ctx, part, 1, part->min_64, basetype, 0, length_restr, frdigits, NULL, &expr), cleanup);
-                range_expected = 0;
-            } else {
-                LY_ARRAY_NEW_GOTO(ctx->ctx, parts, part, ret, cleanup);
-                LY_CHECK_GOTO(range_part_minmax(ctx, part, 0, parts_done ? parts[LY_ARRAY_COUNT(parts) - 2].max_64 : 0,
-                        basetype, parts_done ? 0 : 1, length_restr, frdigits, NULL, &expr), cleanup);
-                part->max_64 = part->min_64;
-            }
-
-            /* continue with possible another expression part */
-        } else if (!strncmp(expr, "max", 3)) {
-            expr += 3;
-            while (isspace(*expr)) {
-                expr++;
-            }
-            if (*expr != '\0') {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid %s restriction - unexpected data after max keyword (%s).",
-                        length_restr ? "length" : "range", expr);
-                goto cleanup;
-            }
-            if (range_expected) {
-                part = &parts[LY_ARRAY_COUNT(parts) - 1];
-                LY_CHECK_GOTO(range_part_minmax(ctx, part, 1, part->min_64, basetype, 0, length_restr, frdigits, base_range, NULL), cleanup);
-                range_expected = 0;
-            } else {
-                LY_ARRAY_NEW_GOTO(ctx->ctx, parts, part, ret, cleanup);
-                LY_CHECK_GOTO(range_part_minmax(ctx, part, 1, parts_done ? parts[LY_ARRAY_COUNT(parts) - 2].max_64 : 0,
-                        basetype, parts_done ? 0 : 1, length_restr, frdigits, base_range, NULL), cleanup);
-                part->min_64 = part->max_64;
-            }
-        } else {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid %s restriction - unexpected data (%s).",
-                    length_restr ? "length" : "range", expr);
-            goto cleanup;
-        }
-    }
-
-    /* check with the previous range/length restriction */
-    if (base_range) {
-        switch (basetype) {
-        case LY_TYPE_BINARY:
-        case LY_TYPE_UINT8:
-        case LY_TYPE_UINT16:
-        case LY_TYPE_UINT32:
-        case LY_TYPE_UINT64:
-        case LY_TYPE_STRING:
-            uns = 1;
-            break;
-        case LY_TYPE_DEC64:
-        case LY_TYPE_INT8:
-        case LY_TYPE_INT16:
-        case LY_TYPE_INT32:
-        case LY_TYPE_INT64:
-            uns = 0;
-            break;
-        default:
-            LOGINT(ctx->ctx);
-            ret = LY_EINT;
-            goto cleanup;
-        }
-        for (u = v = 0; u < parts_done && v < LY_ARRAY_COUNT(base_range->parts); ++u) {
-            if ((uns && (parts[u].min_u64 < base_range->parts[v].min_u64)) || (!uns && (parts[u].min_64 < base_range->parts[v].min_64))) {
-                goto baseerror;
-            }
-            /* current lower bound is not lower than the base */
-            if (base_range->parts[v].min_64 == base_range->parts[v].max_64) {
-                /* base has single value */
-                if (base_range->parts[v].min_64 == parts[u].min_64) {
-                    /* both lower bounds are the same */
-                    if (parts[u].min_64 != parts[u].max_64) {
-                        /* current continues with a range */
-                        goto baseerror;
-                    } else {
-                        /* equal single values, move both forward */
-                        ++v;
-                        continue;
-                    }
-                } else {
-                    /* base is single value lower than current range, so the
-                     * value from base range is removed in the current,
-                     * move only base and repeat checking */
-                    ++v;
-                    --u;
-                    continue;
-                }
-            } else {
-                /* base is the range */
-                if (parts[u].min_64 == parts[u].max_64) {
-                    /* current is a single value */
-                    if ((uns && (parts[u].max_u64 > base_range->parts[v].max_u64)) || (!uns && (parts[u].max_64 > base_range->parts[v].max_64))) {
-                        /* current is behind the base range, so base range is omitted,
-                         * move the base and keep the current for further check */
-                        ++v;
-                        --u;
-                    } /* else it is within the base range, so move the current, but keep the base */
-                    continue;
-                } else {
-                    /* both are ranges - check the higher bound, the lower was already checked */
-                    if ((uns && (parts[u].max_u64 > base_range->parts[v].max_u64)) || (!uns && (parts[u].max_64 > base_range->parts[v].max_64))) {
-                        /* higher bound is higher than the current higher bound */
-                        if ((uns && (parts[u].min_u64 > base_range->parts[v].max_u64)) || (!uns && (parts[u].min_64 > base_range->parts[v].max_64))) {
-                            /* but the current lower bound is also higher, so the base range is omitted,
-                             * continue with the same current, but move the base */
-                            --u;
-                            ++v;
-                            continue;
-                        }
-                        /* current range starts within the base range but end behind it */
-                        goto baseerror;
-                    } else {
-                        /* current range is smaller than the base,
-                         * move current, but stay with the base */
-                        continue;
-                    }
-                }
-            }
-        }
-        if (u != parts_done) {
-baseerror:
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                    "Invalid %s restriction - the derived restriction (%s) is not equally or more limiting.",
-                    length_restr ? "length" : "range", range_p->arg);
-            goto cleanup;
-        }
-    }
-
-    if (!(*range)) {
-        *range = calloc(1, sizeof **range);
-        LY_CHECK_ERR_RET(!(*range), LOGMEM(ctx->ctx), LY_EMEM);
-    }
-
-    /* we rewrite the following values as the types chain is being processed */
-    if (range_p->eapptag) {
-        lydict_remove(ctx->ctx, (*range)->eapptag);
-        LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, range_p->eapptag, 0, &(*range)->eapptag), cleanup);
-    }
-    if (range_p->emsg) {
-        lydict_remove(ctx->ctx, (*range)->emsg);
-        LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, range_p->emsg, 0, &(*range)->emsg), cleanup);
-    }
-    if (range_p->dsc) {
-        lydict_remove(ctx->ctx, (*range)->dsc);
-        LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, range_p->dsc, 0, &(*range)->dsc), cleanup);
-    }
-    if (range_p->ref) {
-        lydict_remove(ctx->ctx, (*range)->ref);
-        LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, range_p->ref, 0, &(*range)->ref), cleanup);
-    }
-    /* extensions are taken only from the last range by the caller */
-
-    (*range)->parts = parts;
-    parts = NULL;
-    ret = LY_SUCCESS;
-cleanup:
-    LY_ARRAY_FREE(parts);
-
-    return ret;
-}
-
-/**
- * @brief Checks pattern syntax.
- *
- * @param[in] ctx Context.
- * @param[in] log_path Path for logging errors.
- * @param[in] pattern Pattern to check.
- * @param[in,out] pcre2_code Compiled PCRE2 pattern. If NULL, the compiled information used to validate pattern are freed.
- * @return LY_ERR value - LY_SUCCESS, LY_EMEM, LY_EVALID.
- */
-LY_ERR
-lys_compile_type_pattern_check(struct ly_ctx *ctx, const char *log_path, const char *pattern, pcre2_code **code)
-{
-    size_t idx, idx2, start, end, size, brack;
-    char *perl_regex, *ptr;
-    int err_code;
-    const char *orig_ptr;
-    PCRE2_SIZE err_offset;
-    pcre2_code *code_local;
-
-#define URANGE_LEN 19
-    char *ublock2urange[][2] = {
-        {"BasicLatin", "[\\x{0000}-\\x{007F}]"},
-        {"Latin-1Supplement", "[\\x{0080}-\\x{00FF}]"},
-        {"LatinExtended-A", "[\\x{0100}-\\x{017F}]"},
-        {"LatinExtended-B", "[\\x{0180}-\\x{024F}]"},
-        {"IPAExtensions", "[\\x{0250}-\\x{02AF}]"},
-        {"SpacingModifierLetters", "[\\x{02B0}-\\x{02FF}]"},
-        {"CombiningDiacriticalMarks", "[\\x{0300}-\\x{036F}]"},
-        {"Greek", "[\\x{0370}-\\x{03FF}]"},
-        {"Cyrillic", "[\\x{0400}-\\x{04FF}]"},
-        {"Armenian", "[\\x{0530}-\\x{058F}]"},
-        {"Hebrew", "[\\x{0590}-\\x{05FF}]"},
-        {"Arabic", "[\\x{0600}-\\x{06FF}]"},
-        {"Syriac", "[\\x{0700}-\\x{074F}]"},
-        {"Thaana", "[\\x{0780}-\\x{07BF}]"},
-        {"Devanagari", "[\\x{0900}-\\x{097F}]"},
-        {"Bengali", "[\\x{0980}-\\x{09FF}]"},
-        {"Gurmukhi", "[\\x{0A00}-\\x{0A7F}]"},
-        {"Gujarati", "[\\x{0A80}-\\x{0AFF}]"},
-        {"Oriya", "[\\x{0B00}-\\x{0B7F}]"},
-        {"Tamil", "[\\x{0B80}-\\x{0BFF}]"},
-        {"Telugu", "[\\x{0C00}-\\x{0C7F}]"},
-        {"Kannada", "[\\x{0C80}-\\x{0CFF}]"},
-        {"Malayalam", "[\\x{0D00}-\\x{0D7F}]"},
-        {"Sinhala", "[\\x{0D80}-\\x{0DFF}]"},
-        {"Thai", "[\\x{0E00}-\\x{0E7F}]"},
-        {"Lao", "[\\x{0E80}-\\x{0EFF}]"},
-        {"Tibetan", "[\\x{0F00}-\\x{0FFF}]"},
-        {"Myanmar", "[\\x{1000}-\\x{109F}]"},
-        {"Georgian", "[\\x{10A0}-\\x{10FF}]"},
-        {"HangulJamo", "[\\x{1100}-\\x{11FF}]"},
-        {"Ethiopic", "[\\x{1200}-\\x{137F}]"},
-        {"Cherokee", "[\\x{13A0}-\\x{13FF}]"},
-        {"UnifiedCanadianAboriginalSyllabics", "[\\x{1400}-\\x{167F}]"},
-        {"Ogham", "[\\x{1680}-\\x{169F}]"},
-        {"Runic", "[\\x{16A0}-\\x{16FF}]"},
-        {"Khmer", "[\\x{1780}-\\x{17FF}]"},
-        {"Mongolian", "[\\x{1800}-\\x{18AF}]"},
-        {"LatinExtendedAdditional", "[\\x{1E00}-\\x{1EFF}]"},
-        {"GreekExtended", "[\\x{1F00}-\\x{1FFF}]"},
-        {"GeneralPunctuation", "[\\x{2000}-\\x{206F}]"},
-        {"SuperscriptsandSubscripts", "[\\x{2070}-\\x{209F}]"},
-        {"CurrencySymbols", "[\\x{20A0}-\\x{20CF}]"},
-        {"CombiningMarksforSymbols", "[\\x{20D0}-\\x{20FF}]"},
-        {"LetterlikeSymbols", "[\\x{2100}-\\x{214F}]"},
-        {"NumberForms", "[\\x{2150}-\\x{218F}]"},
-        {"Arrows", "[\\x{2190}-\\x{21FF}]"},
-        {"MathematicalOperators", "[\\x{2200}-\\x{22FF}]"},
-        {"MiscellaneousTechnical", "[\\x{2300}-\\x{23FF}]"},
-        {"ControlPictures", "[\\x{2400}-\\x{243F}]"},
-        {"OpticalCharacterRecognition", "[\\x{2440}-\\x{245F}]"},
-        {"EnclosedAlphanumerics", "[\\x{2460}-\\x{24FF}]"},
-        {"BoxDrawing", "[\\x{2500}-\\x{257F}]"},
-        {"BlockElements", "[\\x{2580}-\\x{259F}]"},
-        {"GeometricShapes", "[\\x{25A0}-\\x{25FF}]"},
-        {"MiscellaneousSymbols", "[\\x{2600}-\\x{26FF}]"},
-        {"Dingbats", "[\\x{2700}-\\x{27BF}]"},
-        {"BraillePatterns", "[\\x{2800}-\\x{28FF}]"},
-        {"CJKRadicalsSupplement", "[\\x{2E80}-\\x{2EFF}]"},
-        {"KangxiRadicals", "[\\x{2F00}-\\x{2FDF}]"},
-        {"IdeographicDescriptionCharacters", "[\\x{2FF0}-\\x{2FFF}]"},
-        {"CJKSymbolsandPunctuation", "[\\x{3000}-\\x{303F}]"},
-        {"Hiragana", "[\\x{3040}-\\x{309F}]"},
-        {"Katakana", "[\\x{30A0}-\\x{30FF}]"},
-        {"Bopomofo", "[\\x{3100}-\\x{312F}]"},
-        {"HangulCompatibilityJamo", "[\\x{3130}-\\x{318F}]"},
-        {"Kanbun", "[\\x{3190}-\\x{319F}]"},
-        {"BopomofoExtended", "[\\x{31A0}-\\x{31BF}]"},
-        {"EnclosedCJKLettersandMonths", "[\\x{3200}-\\x{32FF}]"},
-        {"CJKCompatibility", "[\\x{3300}-\\x{33FF}]"},
-        {"CJKUnifiedIdeographsExtensionA", "[\\x{3400}-\\x{4DB5}]"},
-        {"CJKUnifiedIdeographs", "[\\x{4E00}-\\x{9FFF}]"},
-        {"YiSyllables", "[\\x{A000}-\\x{A48F}]"},
-        {"YiRadicals", "[\\x{A490}-\\x{A4CF}]"},
-        {"HangulSyllables", "[\\x{AC00}-\\x{D7A3}]"},
-        {"PrivateUse", "[\\x{E000}-\\x{F8FF}]"},
-        {"CJKCompatibilityIdeographs", "[\\x{F900}-\\x{FAFF}]"},
-        {"AlphabeticPresentationForms", "[\\x{FB00}-\\x{FB4F}]"},
-        {"ArabicPresentationForms-A", "[\\x{FB50}-\\x{FDFF}]"},
-        {"CombiningHalfMarks", "[\\x{FE20}-\\x{FE2F}]"},
-        {"CJKCompatibilityForms", "[\\x{FE30}-\\x{FE4F}]"},
-        {"SmallFormVariants", "[\\x{FE50}-\\x{FE6F}]"},
-        {"ArabicPresentationForms-B", "[\\x{FE70}-\\x{FEFE}]"},
-        {"HalfwidthandFullwidthForms", "[\\x{FF00}-\\x{FFEF}]"},
-        {NULL, NULL}
-    };
-
-    /* adjust the expression to a Perl equivalent
-     * http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#regexs */
-
-    /* allocate space for the transformed pattern */
-    size = strlen(pattern) + 1;
-    perl_regex = malloc(size);
-    LY_CHECK_ERR_RET(!perl_regex, LOGMEM(ctx), LY_EMEM);
-    perl_regex[0] = '\0';
-
-    /* we need to replace all "$" and "^" (that are not in "[]") with "\$" and "\^" */
-    brack = 0;
-    idx = 0;
-    orig_ptr = pattern;
-    while (orig_ptr[0]) {
-        switch (orig_ptr[0]) {
-        case '$':
-        case '^':
-            if (!brack) {
-                /* make space for the extra character */
-                ++size;
-                perl_regex = ly_realloc(perl_regex, size);
-                LY_CHECK_ERR_RET(!perl_regex, LOGMEM(ctx), LY_EMEM);
-
-                /* print escape slash */
-                perl_regex[idx] = '\\';
-                ++idx;
-            }
-            break;
-        case '[':
-            /* must not be escaped */
-            if ((orig_ptr == pattern) || (orig_ptr[-1] != '\\')) {
-                ++brack;
-            }
-            break;
-        case ']':
-            if ((orig_ptr == pattern) || (orig_ptr[-1] != '\\')) {
-                /* pattern was checked and compiled already */
-                assert(brack);
-                --brack;
-            }
-            break;
-        default:
-            break;
-        }
-
-        /* copy char */
-        perl_regex[idx] = orig_ptr[0];
-
-        ++idx;
-        ++orig_ptr;
-    }
-    perl_regex[idx] = '\0';
-
-    /* substitute Unicode Character Blocks with exact Character Ranges */
-    while ((ptr = strstr(perl_regex, "\\p{Is"))) {
-        start = ptr - perl_regex;
-
-        ptr = strchr(ptr, '}');
-        if (!ptr) {
-            LOGVAL(ctx, LY_VLOG_STR, log_path, LY_VCODE_INREGEXP,
-                    pattern, perl_regex + start + 2, "unterminated character property");
-            free(perl_regex);
-            return LY_EVALID;
-        }
-        end = (ptr - perl_regex) + 1;
-
-        /* need more space */
-        if (end - start < URANGE_LEN) {
-            perl_regex = ly_realloc(perl_regex, strlen(perl_regex) + (URANGE_LEN - (end - start)) + 1);
-            LY_CHECK_ERR_RET(!perl_regex, LOGMEM(ctx); free(perl_regex), LY_EMEM);
-        }
-
-        /* find our range */
-        for (idx = 0; ublock2urange[idx][0]; ++idx) {
-            if (!strncmp(perl_regex + start + 5, ublock2urange[idx][0], strlen(ublock2urange[idx][0]))) {
-                break;
-            }
-        }
-        if (!ublock2urange[idx][0]) {
-            LOGVAL(ctx, LY_VLOG_STR, log_path, LY_VCODE_INREGEXP,
-                    pattern, perl_regex + start + 5, "unknown block name");
-            free(perl_regex);
-            return LY_EVALID;
-        }
-
-        /* make the space in the string and replace the block (but we cannot include brackets if it was already enclosed in them) */
-        for (idx2 = 0, idx = 0; idx2 < start; ++idx2) {
-            if ((perl_regex[idx2] == '[') && (!idx2 || (perl_regex[idx2 - 1] != '\\'))) {
-                ++idx;
-            }
-            if ((perl_regex[idx2] == ']') && (!idx2 || (perl_regex[idx2 - 1] != '\\'))) {
-                --idx;
-            }
-        }
-        if (idx) {
-            /* skip brackets */
-            memmove(perl_regex + start + (URANGE_LEN - 2), perl_regex + end, strlen(perl_regex + end) + 1);
-            memcpy(perl_regex + start, ublock2urange[idx][1] + 1, URANGE_LEN - 2);
-        } else {
-            memmove(perl_regex + start + URANGE_LEN, perl_regex + end, strlen(perl_regex + end) + 1);
-            memcpy(perl_regex + start, ublock2urange[idx][1], URANGE_LEN);
-        }
-    }
-
-    /* must return 0, already checked during parsing */
-    code_local = pcre2_compile((PCRE2_SPTR)perl_regex, PCRE2_ZERO_TERMINATED,
-            PCRE2_UTF | PCRE2_ANCHORED | PCRE2_ENDANCHORED | PCRE2_DOLLAR_ENDONLY | PCRE2_NO_AUTO_CAPTURE,
-            &err_code, &err_offset, NULL);
-    if (!code_local) {
-        PCRE2_UCHAR err_msg[256] = {0};
-        pcre2_get_error_message(err_code, err_msg, 256);
-        LOGVAL(ctx, LY_VLOG_STR, log_path, LY_VCODE_INREGEXP, pattern, perl_regex + err_offset, err_msg);
-        free(perl_regex);
-        return LY_EVALID;
-    }
-    free(perl_regex);
-
-    if (code) {
-        *code = code_local;
-    } else {
-        free(code_local);
-    }
-
-    return LY_SUCCESS;
-
-#undef URANGE_LEN
-}
-
-/**
- * @brief Compile parsed pattern restriction in conjunction with the patterns from base type.
- * @param[in] ctx Compile context.
- * @param[in] patterns_p Array of parsed patterns from the current type to compile.
- * @param[in] base_patterns Compiled patterns from the type from which the current type is derived.
- * Patterns from the base type are inherited to have all the patterns that have to match at one place.
- * @param[out] patterns Pointer to the storage for the patterns of the current type.
- * @return LY_ERR LY_SUCCESS, LY_EMEM, LY_EVALID.
- */
-static LY_ERR
-lys_compile_type_patterns(struct lysc_ctx *ctx, struct lysp_restr *patterns_p,
-        struct lysc_pattern **base_patterns, struct lysc_pattern ***patterns)
-{
-    struct lysc_pattern **pattern;
-    LY_ARRAY_COUNT_TYPE u;
-    LY_ERR ret = LY_SUCCESS;
-
-    /* first, copy the patterns from the base type */
-    if (base_patterns) {
-        *patterns = lysc_patterns_dup(ctx->ctx, base_patterns);
-        LY_CHECK_ERR_RET(!(*patterns), LOGMEM(ctx->ctx), LY_EMEM);
-    }
-
-    LY_ARRAY_FOR(patterns_p, u) {
-        LY_ARRAY_NEW_RET(ctx->ctx, (*patterns), pattern, LY_EMEM);
-        *pattern = calloc(1, sizeof **pattern);
-        ++(*pattern)->refcount;
-
-        ret = lys_compile_type_pattern_check(ctx->ctx, ctx->path, &patterns_p[u].arg.str[1], &(*pattern)->code);
-        LY_CHECK_RET(ret);
-
-        if (patterns_p[u].arg.str[0] == 0x15) {
-            (*pattern)->inverted = 1;
-        }
-        DUP_STRING_GOTO(ctx->ctx, &patterns_p[u].arg.str[1], (*pattern)->expr, ret, done);
-        DUP_STRING_GOTO(ctx->ctx, patterns_p[u].eapptag, (*pattern)->eapptag, ret, done);
-        DUP_STRING_GOTO(ctx->ctx, patterns_p[u].emsg, (*pattern)->emsg, ret, done);
-        DUP_STRING_GOTO(ctx->ctx, patterns_p[u].dsc, (*pattern)->dsc, ret, done);
-        DUP_STRING_GOTO(ctx->ctx, patterns_p[u].ref, (*pattern)->ref, ret, done);
-        COMPILE_EXTS_GOTO(ctx, patterns_p[u].exts, (*pattern)->exts, (*pattern), LYEXT_PAR_PATTERN, ret, done);
-    }
-done:
-    return ret;
-}
-
-/**
- * @brief map of the possible restrictions combination for the specific built-in type.
- */
-static uint16_t type_substmt_map[LY_DATA_TYPE_COUNT] = {
-    0 /* LY_TYPE_UNKNOWN */,
-    LYS_SET_LENGTH /* LY_TYPE_BINARY */,
-    LYS_SET_RANGE /* LY_TYPE_UINT8 */,
-    LYS_SET_RANGE /* LY_TYPE_UINT16 */,
-    LYS_SET_RANGE /* LY_TYPE_UINT32 */,
-    LYS_SET_RANGE /* LY_TYPE_UINT64 */,
-    LYS_SET_LENGTH | LYS_SET_PATTERN /* LY_TYPE_STRING */,
-    LYS_SET_BIT /* LY_TYPE_BITS */,
-    0 /* LY_TYPE_BOOL */,
-    LYS_SET_FRDIGITS | LYS_SET_RANGE /* LY_TYPE_DEC64 */,
-    0 /* LY_TYPE_EMPTY */,
-    LYS_SET_ENUM /* LY_TYPE_ENUM */,
-    LYS_SET_BASE /* LY_TYPE_IDENT */,
-    LYS_SET_REQINST /* LY_TYPE_INST */,
-    LYS_SET_REQINST | LYS_SET_PATH /* LY_TYPE_LEAFREF */,
-    LYS_SET_TYPE /* LY_TYPE_UNION */,
-    LYS_SET_RANGE /* LY_TYPE_INT8 */,
-    LYS_SET_RANGE /* LY_TYPE_INT16 */,
-    LYS_SET_RANGE /* LY_TYPE_INT32 */,
-    LYS_SET_RANGE /* LY_TYPE_INT64 */
-};
-
-/**
- * @brief stringification of the YANG built-in data types
- */
-const char *ly_data_type2str[LY_DATA_TYPE_COUNT] = {
-    "unknown", "binary", "8bit unsigned integer", "16bit unsigned integer",
-    "32bit unsigned integer", "64bit unsigned integer", "string", "bits", "boolean", "decimal64", "empty", "enumeration",
-    "identityref", "instance-identifier", "leafref", "union", "8bit integer", "16bit integer", "32bit integer", "64bit integer"
-};
-
-/**
- * @brief Compile parsed type's enum structures (for enumeration and bits types).
- * @param[in] ctx Compile context.
- * @param[in] enums_p Array of the parsed enum structures to compile.
- * @param[in] basetype Base YANG built-in type from which the current type is derived. Only LY_TYPE_ENUM and LY_TYPE_BITS are expected.
- * @param[in] base_enums Array of the compiled enums information from the (latest) base type to check if the current enums are compatible.
- * @param[out] enums Newly created array of the compiled enums information for the current type.
- * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
- */
-static LY_ERR
-lys_compile_type_enums(struct lysc_ctx *ctx, struct lysp_type_enum *enums_p, LY_DATA_TYPE basetype,
-        struct lysc_type_bitenum_item *base_enums, struct lysc_type_bitenum_item **enums)
-{
-    LY_ERR ret = LY_SUCCESS;
-    LY_ARRAY_COUNT_TYPE u, v, match = 0;
-    int32_t value = 0;
-    uint32_t position = 0;
-    struct lysc_type_bitenum_item *e, storage;
-
-    if (base_enums && (ctx->pmod->version < LYS_VERSION_1_1)) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "%s type can be subtyped only in YANG 1.1 modules.",
-                basetype == LY_TYPE_ENUM ? "Enumeration" : "Bits");
-        return LY_EVALID;
-    }
-
-    LY_ARRAY_FOR(enums_p, u) {
-        LY_ARRAY_NEW_RET(ctx->ctx, *enums, e, LY_EMEM);
-        DUP_STRING_GOTO(ctx->ctx, enums_p[u].name, e->name, ret, done);
-        DUP_STRING_GOTO(ctx->ctx, enums_p[u].ref, e->dsc, ret, done);
-        DUP_STRING_GOTO(ctx->ctx, enums_p[u].ref, e->ref, ret, done);
-        e->flags = enums_p[u].flags & LYS_FLAGS_COMPILED_MASK;
-        if (base_enums) {
-            /* check the enum/bit presence in the base type - the set of enums/bits in the derived type must be a subset */
-            LY_ARRAY_FOR(base_enums, v) {
-                if (!strcmp(e->name, base_enums[v].name)) {
-                    break;
-                }
-            }
-            if (v == LY_ARRAY_COUNT(base_enums)) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                        "Invalid %s - derived type adds new item \"%s\".",
-                        basetype == LY_TYPE_ENUM ? "enumeration" : "bits", e->name);
-                return LY_EVALID;
-            }
-            match = v;
-        }
-
-        if (basetype == LY_TYPE_ENUM) {
-            e->flags |= LYS_ISENUM;
-            if (enums_p[u].flags & LYS_SET_VALUE) {
-                e->value = (int32_t)enums_p[u].value;
-                if (!u || (e->value >= value)) {
-                    value = e->value + 1;
-                }
-                /* check collision with other values */
-                for (v = 0; v < LY_ARRAY_COUNT(*enums) - 1; ++v) {
-                    if (e->value == (*enums)[v].value) {
-                        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                                "Invalid enumeration - value %d collide in items \"%s\" and \"%s\".",
-                                e->value, e->name, (*enums)[v].name);
-                        return LY_EVALID;
-                    }
-                }
-            } else if (base_enums) {
-                /* inherit the assigned value */
-                e->value = base_enums[match].value;
-                if (!u || (e->value >= value)) {
-                    value = e->value + 1;
-                }
-            } else {
-                /* assign value automatically */
-                if (u && (value == INT32_MIN)) {
-                    /* counter overflow */
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                            "Invalid enumeration - it is not possible to auto-assign enum value for "
-                            "\"%s\" since the highest value is already 2147483647.", e->name);
-                    return LY_EVALID;
-                }
-                e->value = value++;
-            }
-        } else { /* LY_TYPE_BITS */
-            if (enums_p[u].flags & LYS_SET_VALUE) {
-                e->value = (int32_t)enums_p[u].value;
-                if (!u || ((uint32_t)e->value >= position)) {
-                    position = (uint32_t)e->value + 1;
-                }
-                /* check collision with other values */
-                for (v = 0; v < LY_ARRAY_COUNT(*enums) - 1; ++v) {
-                    if (e->value == (*enums)[v].value) {
-                        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                                "Invalid bits - position %u collide in items \"%s\" and \"%s\".",
-                                (uint32_t)e->value, e->name, (*enums)[v].name);
-                        return LY_EVALID;
-                    }
-                }
-            } else if (base_enums) {
-                /* inherit the assigned value */
-                e->value = base_enums[match].value;
-                if (!u || ((uint32_t)e->value >= position)) {
-                    position = (uint32_t)e->value + 1;
-                }
-            } else {
-                /* assign value automatically */
-                if (u && (position == 0)) {
-                    /* counter overflow */
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                            "Invalid bits - it is not possible to auto-assign bit position for "
-                            "\"%s\" since the highest value is already 4294967295.", e->name);
-                    return LY_EVALID;
-                }
-                e->value = position++;
-            }
-        }
-
-        if (base_enums) {
-            /* the assigned values must not change from the derived type */
-            if (e->value != base_enums[match].value) {
-                if (basetype == LY_TYPE_ENUM) {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                            "Invalid enumeration - value of the item \"%s\" has changed from %d to %d in the derived type.",
-                            e->name, base_enums[match].value, e->value);
-                } else {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                            "Invalid bits - position of the item \"%s\" has changed from %u to %u in the derived type.",
-                            e->name, (uint32_t)base_enums[match].value, (uint32_t)e->value);
-                }
-                return LY_EVALID;
-            }
-        }
-
-        COMPILE_ARRAY_GOTO(ctx, enums_p[u].iffeatures, e->iffeatures, v, lys_compile_iffeature, ret, done);
-        COMPILE_EXTS_GOTO(ctx, enums_p[u].exts, e->exts, e, basetype == LY_TYPE_ENUM ? LYEXT_PAR_TYPE_ENUM : LYEXT_PAR_TYPE_BIT, ret, done);
-
-        if (basetype == LY_TYPE_BITS) {
-            /* keep bits ordered by position */
-            for (v = u; v && (*enums)[v - 1].value > e->value; --v) {}
-            if (v != u) {
-                memcpy(&storage, e, sizeof *e);
-                memmove(&(*enums)[v + 1], &(*enums)[v], (u - v) * sizeof **enums);
-                memcpy(&(*enums)[v], &storage, sizeof storage);
-            }
-        }
-    }
-
-done:
-    return ret;
-}
-
-/**
- * @brief Check the features used in if-feature statements applicable to the leafref and its target.
- *
- * The set of features used for target must be a subset of features used for the leafref.
- * This is not a perfect, we should compare the truth tables but it could require too much resources
- * and RFC 7950 does not require it explicitely, so we simplify that.
- *
- * @param[in] refnode The leafref node.
- * @param[in] target Tha target node of the leafref.
- * @return LY_SUCCESS or LY_EVALID;
- */
-static LY_ERR
-lys_compile_leafref_features_validate(const struct lysc_node *refnode, const struct lysc_node *target)
-{
-    LY_ERR ret = LY_EVALID;
-    const struct lysc_node *iter;
-    LY_ARRAY_COUNT_TYPE u, v;
-    struct ly_set features = {0};
-
-    for (iter = refnode; iter; iter = iter->parent) {
-        if (iter->iffeatures) {
-            LY_ARRAY_FOR(iter->iffeatures, u) {
-                LY_ARRAY_FOR(iter->iffeatures[u].features, v) {
-                    LY_CHECK_GOTO(ly_set_add(&features, iter->iffeatures[u].features[v], 0, NULL), cleanup);
-                }
-            }
-        }
-    }
-
-    /* we should have, in features set, a superset of features applicable to the target node.
-     * If the feature is not present, we don;t have a subset of features applicable
-     * to the leafref itself. */
-    for (iter = target; iter; iter = iter->parent) {
-        if (iter->iffeatures) {
-            LY_ARRAY_FOR(iter->iffeatures, u) {
-                LY_ARRAY_FOR(iter->iffeatures[u].features, v) {
-                    if (!ly_set_contains(&features, iter->iffeatures[u].features[v], NULL)) {
-                        /* feature not present */
-                        goto cleanup;
-                    }
-                }
-            }
-        }
-    }
-    ret = LY_SUCCESS;
-
-cleanup:
-    ly_set_erase(&features, NULL);
-    return ret;
-}
-
-static LY_ERR lys_compile_type(struct lysc_ctx *ctx, struct lysp_node *context_pnode, uint16_t context_flags,
-        struct lysp_module *context_mod, const char *context_name, struct lysp_type *type_p,
-        struct lysc_type **type, const char **units, struct lysp_qname **dflt);
-
-/**
- * @brief The core of the lys_compile_type() - compile information about the given type (from typedef or leaf/leaf-list).
- * @param[in] ctx Compile context.
- * @param[in] context_pnode Schema node where the type/typedef is placed to correctly find the base types.
- * @param[in] context_flags Flags of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
- * @param[in] context_mod Module of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
- * @param[in] context_name Name of the context node or referencing typedef for logging.
- * @param[in] type_p Parsed type to compile.
- * @param[in] basetype Base YANG built-in type of the type to compile.
- * @param[in] tpdfname Name of the type's typedef, serves as a flag - if it is leaf/leaf-list's type, it is NULL.
- * @param[in] base The latest base (compiled) type from which the current type is being derived.
- * @param[out] type Newly created type structure with the filled information about the type.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_type_(struct lysc_ctx *ctx, struct lysp_node *context_pnode, uint16_t context_flags,
-        struct lysp_module *context_mod, const char *context_name, struct lysp_type *type_p, LY_DATA_TYPE basetype,
-        const char *tpdfname, struct lysc_type *base, struct lysc_type **type)
-{
-    LY_ERR ret = LY_SUCCESS;
-    struct lysc_type_bin *bin;
-    struct lysc_type_num *num;
-    struct lysc_type_str *str;
-    struct lysc_type_bits *bits;
-    struct lysc_type_enum *enumeration;
-    struct lysc_type_dec *dec;
-    struct lysc_type_identityref *idref;
-    struct lysc_type_leafref *lref;
-    struct lysc_type_union *un, *un_aux;
-
-    switch (basetype) {
-    case LY_TYPE_BINARY:
-        bin = (struct lysc_type_bin *)(*type);
-
-        /* RFC 7950 9.8.1, 9.4.4 - length, number of octets it contains */
-        if (type_p->length) {
-            LY_CHECK_RET(lys_compile_type_range(ctx, type_p->length, basetype, 1, 0,
-                    base ? ((struct lysc_type_bin *)base)->length : NULL, &bin->length));
-            if (!tpdfname) {
-                COMPILE_EXTS_GOTO(ctx, type_p->length->exts, bin->length->exts, bin->length, LYEXT_PAR_LENGTH, ret, cleanup);
-            }
-        }
-        break;
-    case LY_TYPE_BITS:
-        /* RFC 7950 9.7 - bits */
-        bits = (struct lysc_type_bits *)(*type);
-        if (type_p->bits) {
-            LY_CHECK_RET(lys_compile_type_enums(ctx, type_p->bits, basetype,
-                    base ? (struct lysc_type_bitenum_item *)((struct lysc_type_bits *)base)->bits : NULL,
-                    (struct lysc_type_bitenum_item **)&bits->bits));
-        }
-
-        if (!base && !type_p->flags) {
-            /* type derived from bits built-in type must contain at least one bit */
-            if (tpdfname) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "bit", "bits type ", tpdfname);
-            } else {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "bit", "bits type", "");
-            }
-            return LY_EVALID;
-        }
-        break;
-    case LY_TYPE_DEC64:
-        dec = (struct lysc_type_dec *)(*type);
-
-        /* RFC 7950 9.3.4 - fraction-digits */
-        if (!base) {
-            if (!type_p->fraction_digits) {
-                if (tpdfname) {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "fraction-digits", "decimal64 type ", tpdfname);
-                } else {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "fraction-digits", "decimal64 type", "");
-                }
-                return LY_EVALID;
-            }
-            dec->fraction_digits = type_p->fraction_digits;
-        } else {
-            if (type_p->fraction_digits) {
-                /* fraction digits is prohibited in types not directly derived from built-in decimal64 */
-                if (tpdfname) {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                            "Invalid fraction-digits substatement for type \"%s\" not directly derived from decimal64 built-in type.",
-                            tpdfname);
-                } else {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                            "Invalid fraction-digits substatement for type not directly derived from decimal64 built-in type.");
-                }
-                return LY_EVALID;
-            }
-            dec->fraction_digits = ((struct lysc_type_dec *)base)->fraction_digits;
-        }
-
-        /* RFC 7950 9.2.4 - range */
-        if (type_p->range) {
-            LY_CHECK_RET(lys_compile_type_range(ctx, type_p->range, basetype, 0, dec->fraction_digits,
-                    base ? ((struct lysc_type_dec *)base)->range : NULL, &dec->range));
-            if (!tpdfname) {
-                COMPILE_EXTS_GOTO(ctx, type_p->range->exts, dec->range->exts, dec->range, LYEXT_PAR_RANGE, ret, cleanup);
-            }
-        }
-        break;
-    case LY_TYPE_STRING:
-        str = (struct lysc_type_str *)(*type);
-
-        /* RFC 7950 9.4.4 - length */
-        if (type_p->length) {
-            LY_CHECK_RET(lys_compile_type_range(ctx, type_p->length, basetype, 1, 0,
-                    base ? ((struct lysc_type_str *)base)->length : NULL, &str->length));
-            if (!tpdfname) {
-                COMPILE_EXTS_GOTO(ctx, type_p->length->exts, str->length->exts, str->length, LYEXT_PAR_LENGTH, ret, cleanup);
-            }
-        } else if (base && ((struct lysc_type_str *)base)->length) {
-            str->length = lysc_range_dup(ctx->ctx, ((struct lysc_type_str *)base)->length);
-        }
-
-        /* RFC 7950 9.4.5 - pattern */
-        if (type_p->patterns) {
-            LY_CHECK_RET(lys_compile_type_patterns(ctx, type_p->patterns,
-                    base ? ((struct lysc_type_str *)base)->patterns : NULL, &str->patterns));
-        } else if (base && ((struct lysc_type_str *)base)->patterns) {
-            str->patterns = lysc_patterns_dup(ctx->ctx, ((struct lysc_type_str *)base)->patterns);
-        }
-        break;
-    case LY_TYPE_ENUM:
-        enumeration = (struct lysc_type_enum *)(*type);
-
-        /* RFC 7950 9.6 - enum */
-        if (type_p->enums) {
-            LY_CHECK_RET(lys_compile_type_enums(ctx, type_p->enums, basetype,
-                    base ? ((struct lysc_type_enum *)base)->enums : NULL, &enumeration->enums));
-        }
-
-        if (!base && !type_p->flags) {
-            /* type derived from enumerations built-in type must contain at least one enum */
-            if (tpdfname) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "enum", "enumeration type ", tpdfname);
-            } else {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "enum", "enumeration type", "");
-            }
-            return LY_EVALID;
-        }
-        break;
-    case LY_TYPE_INT8:
-    case LY_TYPE_UINT8:
-    case LY_TYPE_INT16:
-    case LY_TYPE_UINT16:
-    case LY_TYPE_INT32:
-    case LY_TYPE_UINT32:
-    case LY_TYPE_INT64:
-    case LY_TYPE_UINT64:
-        num = (struct lysc_type_num *)(*type);
-
-        /* RFC 6020 9.2.4 - range */
-        if (type_p->range) {
-            LY_CHECK_RET(lys_compile_type_range(ctx, type_p->range, basetype, 0, 0,
-                    base ? ((struct lysc_type_num *)base)->range : NULL, &num->range));
-            if (!tpdfname) {
-                COMPILE_EXTS_GOTO(ctx, type_p->range->exts, num->range->exts, num->range, LYEXT_PAR_RANGE, ret, cleanup);
-            }
-        }
-        break;
-    case LY_TYPE_IDENT:
-        idref = (struct lysc_type_identityref *)(*type);
-
-        /* RFC 7950 9.10.2 - base */
-        if (type_p->bases) {
-            if (base) {
-                /* only the directly derived identityrefs can contain base specification */
-                if (tpdfname) {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                            "Invalid base substatement for the type \"%s\" not directly derived from identityref built-in type.",
-                            tpdfname);
-                } else {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                            "Invalid base substatement for the type not directly derived from identityref built-in type.");
-                }
-                return LY_EVALID;
-            }
-            LY_CHECK_RET(lys_compile_identity_bases(ctx, type_p->pmod, type_p->bases, NULL, &idref->bases));
-        }
-
-        if (!base && !type_p->flags) {
-            /* type derived from identityref built-in type must contain at least one base */
-            if (tpdfname) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "base", "identityref type ", tpdfname);
-            } else {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "base", "identityref type", "");
-            }
-            return LY_EVALID;
-        }
-        break;
-    case LY_TYPE_LEAFREF:
-        lref = (struct lysc_type_leafref *)*type;
-
-        /* RFC 7950 9.9.3 - require-instance */
-        if (type_p->flags & LYS_SET_REQINST) {
-            if (context_mod->version < LYS_VERSION_1_1) {
-                if (tpdfname) {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                            "Leafref type \"%s\" can be restricted by require-instance statement only in YANG 1.1 modules.", tpdfname);
-                } else {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                            "Leafref type can be restricted by require-instance statement only in YANG 1.1 modules.");
-                }
-                return LY_EVALID;
-            }
-            lref->require_instance = type_p->require_instance;
-        } else if (base) {
-            /* inherit */
-            lref->require_instance = ((struct lysc_type_leafref *)base)->require_instance;
-        } else {
-            /* default is true */
-            lref->require_instance = 1;
-        }
-        if (type_p->path) {
-            LY_CHECK_RET(lyxp_expr_dup(ctx->ctx, type_p->path, &lref->path));
-            LY_CHECK_RET(lysc_prefixes_compile(type_p->path->expr, strlen(type_p->path->expr), type_p->pmod,
-                    &lref->prefixes));
-        } else if (base) {
-            LY_CHECK_RET(lyxp_expr_dup(ctx->ctx, ((struct lysc_type_leafref *)base)->path, &lref->path));
-            LY_CHECK_RET(lysc_prefixes_dup(((struct lysc_type_leafref *)base)->prefixes, &lref->prefixes));
-        } else if (tpdfname) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "path", "leafref type ", tpdfname);
-            return LY_EVALID;
-        } else {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "path", "leafref type", "");
-            return LY_EVALID;
-        }
-        break;
-    case LY_TYPE_INST:
-        /* RFC 7950 9.9.3 - require-instance */
-        if (type_p->flags & LYS_SET_REQINST) {
-            ((struct lysc_type_instanceid *)(*type))->require_instance = type_p->require_instance;
-        } else {
-            /* default is true */
-            ((struct lysc_type_instanceid *)(*type))->require_instance = 1;
-        }
-        break;
-    case LY_TYPE_UNION:
-        un = (struct lysc_type_union *)(*type);
-
-        /* RFC 7950 7.4 - type */
-        if (type_p->types) {
-            if (base) {
-                /* only the directly derived union can contain types specification */
-                if (tpdfname) {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                            "Invalid type substatement for the type \"%s\" not directly derived from union built-in type.",
-                            tpdfname);
-                } else {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
-                            "Invalid type substatement for the type not directly derived from union built-in type.");
-                }
-                return LY_EVALID;
-            }
-            /* compile the type */
-            LY_ARRAY_CREATE_RET(ctx->ctx, un->types, LY_ARRAY_COUNT(type_p->types), LY_EVALID);
-            for (LY_ARRAY_COUNT_TYPE u = 0, additional = 0; u < LY_ARRAY_COUNT(type_p->types); ++u) {
-                LY_CHECK_RET(lys_compile_type(ctx, context_pnode, context_flags, context_mod, context_name,
-                        &type_p->types[u], &un->types[u + additional], NULL, NULL));
-                if (un->types[u + additional]->basetype == LY_TYPE_UNION) {
-                    /* add space for additional types from the union subtype */
-                    un_aux = (struct lysc_type_union *)un->types[u + additional];
-                    LY_ARRAY_RESIZE_ERR_RET(ctx->ctx, un->types, (*((uint64_t *)(type_p->types) - 1)) + additional + LY_ARRAY_COUNT(un_aux->types) - 1,
-                            lysc_type_free(ctx->ctx, (struct lysc_type *)un_aux), LY_EMEM);
-
-                    /* copy subtypes of the subtype union */
-                    for (LY_ARRAY_COUNT_TYPE v = 0; v < LY_ARRAY_COUNT(un_aux->types); ++v) {
-                        if (un_aux->types[v]->basetype == LY_TYPE_LEAFREF) {
-                            /* duplicate the whole structure because of the instance-specific path resolving for realtype */
-                            un->types[u + additional] = calloc(1, sizeof(struct lysc_type_leafref));
-                            LY_CHECK_ERR_RET(!un->types[u + additional], LOGMEM(ctx->ctx); lysc_type_free(ctx->ctx, (struct lysc_type *)un_aux), LY_EMEM);
-                            lref = (struct lysc_type_leafref *)un->types[u + additional];
-
-                            lref->basetype = LY_TYPE_LEAFREF;
-                            LY_CHECK_RET(lyxp_expr_dup(ctx->ctx, ((struct lysc_type_leafref *)un_aux->types[v])->path, &lref->path));
-                            lref->refcount = 1;
-                            lref->require_instance = ((struct lysc_type_leafref *)un_aux->types[v])->require_instance;
-                            LY_CHECK_RET(lysc_prefixes_dup(((struct lysc_type_leafref *)un_aux->types[v])->prefixes,
-                                    &lref->prefixes));
-                            /* TODO extensions */
-
-                        } else {
-                            un->types[u + additional] = un_aux->types[v];
-                            ++un_aux->types[v]->refcount;
-                        }
-                        ++additional;
-                        LY_ARRAY_INCREMENT(un->types);
-                    }
-                    /* compensate u increment in main loop */
-                    --additional;
-
-                    /* free the replaced union subtype */
-                    lysc_type_free(ctx->ctx, (struct lysc_type *)un_aux);
-                } else {
-                    LY_ARRAY_INCREMENT(un->types);
-                }
-            }
-        }
-
-        if (!base && !type_p->flags) {
-            /* type derived from union built-in type must contain at least one type */
-            if (tpdfname) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "type", "union type ", tpdfname);
-            } else {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "type", "union type", "");
-            }
-            return LY_EVALID;
-        }
-        break;
-    case LY_TYPE_BOOL:
-    case LY_TYPE_EMPTY:
-    case LY_TYPE_UNKNOWN: /* just to complete switch */
-        break;
-    }
-
-    if (tpdfname) {
-        switch (basetype) {
-        case LY_TYPE_BINARY:
-            type_p->compiled = *type;
-            *type = calloc(1, sizeof(struct lysc_type_bin));
-            break;
-        case LY_TYPE_BITS:
-            type_p->compiled = *type;
-            *type = calloc(1, sizeof(struct lysc_type_bits));
-            break;
-        case LY_TYPE_DEC64:
-            type_p->compiled = *type;
-            *type = calloc(1, sizeof(struct lysc_type_dec));
-            break;
-        case LY_TYPE_STRING:
-            type_p->compiled = *type;
-            *type = calloc(1, sizeof(struct lysc_type_str));
-            break;
-        case LY_TYPE_ENUM:
-            type_p->compiled = *type;
-            *type = calloc(1, sizeof(struct lysc_type_enum));
-            break;
-        case LY_TYPE_INT8:
-        case LY_TYPE_UINT8:
-        case LY_TYPE_INT16:
-        case LY_TYPE_UINT16:
-        case LY_TYPE_INT32:
-        case LY_TYPE_UINT32:
-        case LY_TYPE_INT64:
-        case LY_TYPE_UINT64:
-            type_p->compiled = *type;
-            *type = calloc(1, sizeof(struct lysc_type_num));
-            break;
-        case LY_TYPE_IDENT:
-            type_p->compiled = *type;
-            *type = calloc(1, sizeof(struct lysc_type_identityref));
-            break;
-        case LY_TYPE_LEAFREF:
-            type_p->compiled = *type;
-            *type = calloc(1, sizeof(struct lysc_type_leafref));
-            break;
-        case LY_TYPE_INST:
-            type_p->compiled = *type;
-            *type = calloc(1, sizeof(struct lysc_type_instanceid));
-            break;
-        case LY_TYPE_UNION:
-            type_p->compiled = *type;
-            *type = calloc(1, sizeof(struct lysc_type_union));
-            break;
-        case LY_TYPE_BOOL:
-        case LY_TYPE_EMPTY:
-        case LY_TYPE_UNKNOWN: /* just to complete switch */
-            break;
-        }
-    }
-    LY_CHECK_ERR_RET(!(*type), LOGMEM(ctx->ctx), LY_EMEM);
-
-cleanup:
-    return ret;
-}
-
-/**
- * @brief Compile information about the leaf/leaf-list's type.
- * @param[in] ctx Compile context.
- * @param[in] context_pnode Schema node where the type/typedef is placed to correctly find the base types.
- * @param[in] context_flags Flags of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
- * @param[in] context_mod Module of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
- * @param[in] context_name Name of the context node or referencing typedef for logging.
- * @param[in] type_p Parsed type to compile.
- * @param[out] type Newly created (or reused with increased refcount) type structure with the filled information about the type.
- * @param[out] units Storage for inheriting units value from the typedefs the current type derives from.
- * @param[out] dflt Default value for the type.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_type(struct lysc_ctx *ctx, struct lysp_node *context_pnode, uint16_t context_flags,
-        struct lysp_module *context_mod, const char *context_name, struct lysp_type *type_p,
-        struct lysc_type **type, const char **units, struct lysp_qname **dflt)
-{
-    LY_ERR ret = LY_SUCCESS;
-    ly_bool dummyloops = 0;
-    struct type_context {
-        const struct lysp_tpdf *tpdf;
-        struct lysp_node *node;
-        struct lysp_module *mod;
-    } *tctx, *tctx_prev = NULL, *tctx_iter;
-    LY_DATA_TYPE basetype = LY_TYPE_UNKNOWN;
-    struct lysc_type *base = NULL, *prev_type;
-    struct ly_set tpdf_chain = {0};
-
-    (*type) = NULL;
-    if (dflt) {
-        *dflt = NULL;
-    }
-
-    tctx = calloc(1, sizeof *tctx);
-    LY_CHECK_ERR_RET(!tctx, LOGMEM(ctx->ctx), LY_EMEM);
-    for (ret = lysp_type_find(type_p->name, context_pnode, ctx->pmod, &basetype, &tctx->tpdf, &tctx->node, &tctx->mod);
-            ret == LY_SUCCESS;
-            ret = lysp_type_find(tctx_prev->tpdf->type.name, tctx_prev->node, tctx_prev->mod,
-                    &basetype, &tctx->tpdf, &tctx->node, &tctx->mod)) {
-        if (basetype) {
-            break;
-        }
-
-        /* check status */
-        ret = lysc_check_status(ctx, context_flags, context_mod, context_name,
-                tctx->tpdf->flags, tctx->mod, tctx->node ? tctx->node->name : tctx->tpdf->name);
-        LY_CHECK_ERR_GOTO(ret, free(tctx), cleanup);
-
-        if (units && !*units) {
-            /* inherit units */
-            DUP_STRING(ctx->ctx, tctx->tpdf->units, *units, ret);
-            LY_CHECK_ERR_GOTO(ret, free(tctx), cleanup);
-        }
-        if (dflt && !*dflt && tctx->tpdf->dflt.str) {
-            /* inherit default */
-            *dflt = (struct lysp_qname *)&tctx->tpdf->dflt;
-        }
-        if (dummyloops && (!units || *units) && dflt && *dflt) {
-            basetype = ((struct type_context *)tpdf_chain.objs[tpdf_chain.count - 1])->tpdf->type.compiled->basetype;
-            break;
-        }
-
-        if (tctx->tpdf->type.compiled) {
-            /* it is not necessary to continue, the rest of the chain was already compiled,
-             * but we still may need to inherit default and units values, so start dummy loops */
-            basetype = tctx->tpdf->type.compiled->basetype;
-            ret = ly_set_add(&tpdf_chain, tctx, 1, NULL);
-            LY_CHECK_ERR_GOTO(ret, free(tctx), cleanup);
-
-            if ((units && !*units) || (dflt && !*dflt)) {
-                dummyloops = 1;
-                goto preparenext;
-            } else {
-                tctx = NULL;
-                break;
-            }
-        }
-
-        /* circular typedef reference detection */
-        for (uint32_t u = 0; u < tpdf_chain.count; u++) {
-            /* local part */
-            tctx_iter = (struct type_context *)tpdf_chain.objs[u];
-            if ((tctx_iter->mod == tctx->mod) && (tctx_iter->node == tctx->node) && (tctx_iter->tpdf == tctx->tpdf)) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                        "Invalid \"%s\" type reference - circular chain of types detected.", tctx->tpdf->name);
-                free(tctx);
-                ret = LY_EVALID;
-                goto cleanup;
-            }
-        }
-        for (uint32_t u = 0; u < ctx->tpdf_chain.count; u++) {
-            /* global part for unions corner case */
-            tctx_iter = (struct type_context *)ctx->tpdf_chain.objs[u];
-            if ((tctx_iter->mod == tctx->mod) && (tctx_iter->node == tctx->node) && (tctx_iter->tpdf == tctx->tpdf)) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                        "Invalid \"%s\" type reference - circular chain of types detected.", tctx->tpdf->name);
-                free(tctx);
-                ret = LY_EVALID;
-                goto cleanup;
-            }
-        }
-
-        /* store information for the following processing */
-        ret = ly_set_add(&tpdf_chain, tctx, 1, NULL);
-        LY_CHECK_ERR_GOTO(ret, free(tctx), cleanup);
-
-preparenext:
-        /* prepare next loop */
-        tctx_prev = tctx;
-        tctx = calloc(1, sizeof *tctx);
-        LY_CHECK_ERR_RET(!tctx, LOGMEM(ctx->ctx), LY_EMEM);
-    }
-    free(tctx);
-
-    /* allocate type according to the basetype */
-    switch (basetype) {
-    case LY_TYPE_BINARY:
-        *type = calloc(1, sizeof(struct lysc_type_bin));
-        break;
-    case LY_TYPE_BITS:
-        *type = calloc(1, sizeof(struct lysc_type_bits));
-        break;
-    case LY_TYPE_BOOL:
-    case LY_TYPE_EMPTY:
-        *type = calloc(1, sizeof(struct lysc_type));
-        break;
-    case LY_TYPE_DEC64:
-        *type = calloc(1, sizeof(struct lysc_type_dec));
-        break;
-    case LY_TYPE_ENUM:
-        *type = calloc(1, sizeof(struct lysc_type_enum));
-        break;
-    case LY_TYPE_IDENT:
-        *type = calloc(1, sizeof(struct lysc_type_identityref));
-        break;
-    case LY_TYPE_INST:
-        *type = calloc(1, sizeof(struct lysc_type_instanceid));
-        break;
-    case LY_TYPE_LEAFREF:
-        *type = calloc(1, sizeof(struct lysc_type_leafref));
-        break;
-    case LY_TYPE_STRING:
-        *type = calloc(1, sizeof(struct lysc_type_str));
-        break;
-    case LY_TYPE_UNION:
-        *type = calloc(1, sizeof(struct lysc_type_union));
-        break;
-    case LY_TYPE_INT8:
-    case LY_TYPE_UINT8:
-    case LY_TYPE_INT16:
-    case LY_TYPE_UINT16:
-    case LY_TYPE_INT32:
-    case LY_TYPE_UINT32:
-    case LY_TYPE_INT64:
-    case LY_TYPE_UINT64:
-        *type = calloc(1, sizeof(struct lysc_type_num));
-        break;
-    case LY_TYPE_UNKNOWN:
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                "Referenced type \"%s\" not found.", tctx_prev ? tctx_prev->tpdf->type.name : type_p->name);
-        ret = LY_EVALID;
-        goto cleanup;
-    }
-    LY_CHECK_ERR_GOTO(!(*type), LOGMEM(ctx->ctx), cleanup);
-    if (~type_substmt_map[basetype] & type_p->flags) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid type restrictions for %s type.",
-                ly_data_type2str[basetype]);
-        free(*type);
-        (*type) = NULL;
-        ret = LY_EVALID;
-        goto cleanup;
-    }
-
-    /* get restrictions from the referred typedefs */
-    for (uint32_t u = tpdf_chain.count - 1; u + 1 > 0; --u) {
-        tctx = (struct type_context *)tpdf_chain.objs[u];
-
-        /* remember the typedef context for circular check */
-        ret = ly_set_add(&ctx->tpdf_chain, tctx, 1, NULL);
-        LY_CHECK_GOTO(ret, cleanup);
-
-        if (tctx->tpdf->type.compiled) {
-            base = tctx->tpdf->type.compiled;
-            continue;
-        } else if ((basetype != LY_TYPE_LEAFREF) && (u != tpdf_chain.count - 1) && !(tctx->tpdf->type.flags)) {
-            /* no change, just use the type information from the base */
-            base = ((struct lysp_tpdf *)tctx->tpdf)->type.compiled = ((struct type_context *)tpdf_chain.objs[u + 1])->tpdf->type.compiled;
-            ++base->refcount;
-            continue;
-        }
-
-        ++(*type)->refcount;
-        if (~type_substmt_map[basetype] & tctx->tpdf->type.flags) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid type \"%s\" restriction(s) for %s type.",
-                    tctx->tpdf->name, ly_data_type2str[basetype]);
-            ret = LY_EVALID;
-            goto cleanup;
-        } else if ((basetype == LY_TYPE_EMPTY) && tctx->tpdf->dflt.str) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                    "Invalid type \"%s\" - \"empty\" type must not have a default value (%s).",
-                    tctx->tpdf->name, tctx->tpdf->dflt.str);
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-
-        (*type)->basetype = basetype;
-        /* TODO user type plugins */
-        (*type)->plugin = &ly_builtin_type_plugins[basetype];
-        prev_type = *type;
-        ret = lys_compile_type_(ctx, tctx->node, tctx->tpdf->flags, tctx->mod, tctx->tpdf->name,
-                &((struct lysp_tpdf *)tctx->tpdf)->type, basetype, tctx->tpdf->name, base, type);
-        LY_CHECK_GOTO(ret, cleanup);
-        base = prev_type;
-    }
-    /* remove the processed typedef contexts from the stack for circular check */
-    ctx->tpdf_chain.count = ctx->tpdf_chain.count - tpdf_chain.count;
-
-    /* process the type definition in leaf */
-    if (type_p->flags || !base || (basetype == LY_TYPE_LEAFREF)) {
-        /* get restrictions from the node itself */
-        (*type)->basetype = basetype;
-        /* TODO user type plugins */
-        (*type)->plugin = &ly_builtin_type_plugins[basetype];
-        ++(*type)->refcount;
-        ret = lys_compile_type_(ctx, context_pnode, context_flags, context_mod, context_name, type_p, basetype, NULL,
-                base, type);
-        LY_CHECK_GOTO(ret, cleanup);
-    } else if ((basetype != LY_TYPE_BOOL) && (basetype != LY_TYPE_EMPTY)) {
-        /* no specific restriction in leaf's type definition, copy from the base */
-        free(*type);
-        (*type) = base;
-        ++(*type)->refcount;
-    }
-
-    COMPILE_EXTS_GOTO(ctx, type_p->exts, (*type)->exts, (*type), LYEXT_PAR_TYPE, ret, cleanup);
-
-cleanup:
-    ly_set_erase(&tpdf_chain, free);
-    return ret;
-}
-
-/**
- * @brief Compile status information of the given node.
- *
- * To simplify getting status of the node, the flags are set following inheritance rules, so all the nodes
- * has the status correctly set during the compilation.
- *
- * @param[in] ctx Compile context
- * @param[in,out] node_flags Flags of the compiled node which status is supposed to be resolved.
- * If the status was set explicitly on the node, it is already set in the flags value and we just check
- * the compatibility with the parent's status value.
- * @param[in] parent_flags Flags of the parent node to check/inherit the status value.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_status(struct lysc_ctx *ctx, uint16_t *node_flags, uint16_t parent_flags)
-{
-    /* status - it is not inherited by specification, but it does not make sense to have
-     * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
-    if (!((*node_flags) & LYS_STATUS_MASK)) {
-        if (parent_flags & (LYS_STATUS_DEPRC | LYS_STATUS_OBSLT)) {
-            if ((parent_flags & 0x3) != 0x3) {
-                /* do not print the warning when inheriting status from uses - the uses_status value has a special
-                 * combination of bits (0x3) which marks the uses_status value */
-                LOGWRN(ctx->ctx, "Missing explicit \"%s\" status that was already specified in parent, inheriting.",
-                        (parent_flags & LYS_STATUS_DEPRC) ? "deprecated" : "obsolete");
-            }
-            (*node_flags) |= parent_flags & LYS_STATUS_MASK;
-        } else {
-            (*node_flags) |= LYS_STATUS_CURR;
-        }
-    } else if (parent_flags & LYS_STATUS_MASK) {
-        /* check status compatibility with the parent */
-        if ((parent_flags & LYS_STATUS_MASK) > ((*node_flags) & LYS_STATUS_MASK)) {
-            if ((*node_flags) & LYS_STATUS_CURR) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                        "A \"current\" status is in conflict with the parent's \"%s\" status.",
-                        (parent_flags & LYS_STATUS_DEPRC) ? "deprecated" : "obsolete");
-            } else { /* LYS_STATUS_DEPRC */
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                        "A \"deprecated\" status is in conflict with the parent's \"obsolete\" status.");
-            }
-            return LY_EVALID;
-        }
-    }
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Check uniqness of the node/action/notification name.
- *
- * Data nodes, actions/RPCs and Notifications are stored separately (in distinguish lists) in the schema
- * structures, but they share the namespace so we need to check their name collisions.
- *
- * @param[in] ctx Compile context.
- * @param[in] parent Parent of the nodes to check, can be NULL.
- * @param[in] name Name of the item to find in the given lists.
- * @param[in] exclude Node that was just added that should be excluded from the name checking.
- * @return LY_SUCCESS in case of unique name, LY_EEXIST otherwise.
- */
-static LY_ERR
-lys_compile_node_uniqness(struct lysc_ctx *ctx, const struct lysc_node *parent, const char *name,
-        const struct lysc_node *exclude)
-{
-    const struct lysc_node *iter, *iter2;
-    const struct lysc_action *actions;
-    const struct lysc_notif *notifs;
-    uint32_t getnext_flags;
-    LY_ARRAY_COUNT_TYPE u;
-
-#define CHECK_NODE(iter, exclude, name) (iter != (void *)exclude && (iter)->module == exclude->module && !strcmp(name, (iter)->name))
-
-    if (exclude->nodetype == LYS_CASE) {
-        /* check restricted only to all the cases */
-        assert(parent->nodetype == LYS_CHOICE);
-        LY_LIST_FOR(lysc_node_children(parent, 0), iter) {
-            if (CHECK_NODE(iter, exclude, name)) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPIDENT, name, "case");
-                return LY_EEXIST;
-            }
-        }
-
-        return LY_SUCCESS;
-    }
-
-    /* no reason for our parent to be choice anymore */
-    assert(!parent || (parent->nodetype != LYS_CHOICE));
-
-    if (parent && (parent->nodetype == LYS_CASE)) {
-        /* move to the first data definition parent */
-        parent = lysc_data_parent(parent);
-    }
-
-    getnext_flags = LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCHOICE;
-    if (parent && (parent->nodetype & (LYS_RPC | LYS_ACTION)) && (exclude->flags & LYS_CONFIG_R)) {
-        getnext_flags |= LYS_GETNEXT_OUTPUT;
-    }
-
-    iter = NULL;
-    while ((iter = lys_getnext(iter, parent, ctx->cur_mod->compiled, getnext_flags))) {
-        if (CHECK_NODE(iter, exclude, name)) {
-            goto error;
-        }
-
-        /* we must compare with both the choice and all its nested data-definiition nodes (but not recursively) */
-        if (iter->nodetype == LYS_CHOICE) {
-            iter2 = NULL;
-            while ((iter2 = lys_getnext(iter2, iter, NULL, LYS_GETNEXT_NOSTATECHECK))) {
-                if (CHECK_NODE(iter2, exclude, name)) {
-                    goto error;
-                }
-            }
-        }
-    }
-
-    actions = parent ? lysc_node_actions(parent) : ctx->cur_mod->compiled->rpcs;
-    LY_ARRAY_FOR(actions, u) {
-        if (CHECK_NODE(&actions[u], exclude, name)) {
-            goto error;
-        }
-    }
-
-    notifs = parent ? lysc_node_notifs(parent) : ctx->cur_mod->compiled->notifs;
-    LY_ARRAY_FOR(notifs, u) {
-        if (CHECK_NODE(&notifs[u], exclude, name)) {
-            goto error;
-        }
-    }
-    return LY_SUCCESS;
-
-error:
-    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPIDENT, name, "data definition/RPC/action/notification");
-    return LY_EEXIST;
-
-#undef CHECK_NODE
-}
-
-static LY_ERR lys_compile_node(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *parent,
-        uint16_t uses_status, struct ly_set *child_set);
-
-static LY_ERR lys_compile_node_deviations_refines(struct lysc_ctx *ctx, const struct lysp_node *pnode,
-        const struct lysc_node *parent, struct lysp_node **dev_pnode, ly_bool *not_supported);
-
-static LY_ERR lys_compile_node_augments(struct lysc_ctx *ctx, struct lysc_node *node);
-
-static void lysp_dev_node_free(const struct ly_ctx *ctx, struct lysp_node *dev_pnode);
-
-/**
- * @brief Compile parsed RPC/action schema node information.
- * @param[in] ctx Compile context
- * @param[in] action_p Parsed RPC/action schema node.
- * @param[in] parent Parent node of the action, NULL in case of RPC (top-level action)
- * @param[in,out] action Prepared (empty) compiled action structure to fill.
- * @param[in] uses_status If the RPC/action is being placed instead of uses, here we have the uses's status value (as node's flags).
- * Zero means no uses, non-zero value with no status bit set mean the default status.
- * @return LY_SUCCESS on success,
- * @return LY_EVALID on validation error,
- * @return LY_EDENIED on not-supported deviation.
- */
-static LY_ERR
-lys_compile_action(struct lysc_ctx *ctx, struct lysp_action *action_p,
-        struct lysc_node *parent, struct lysc_action *action, uint16_t uses_status)
-{
-    LY_ERR ret = LY_SUCCESS;
-    struct lysp_node *child_p, *dev_pnode = NULL, *dev_input_p = NULL, *dev_output_p = NULL;
-    struct lysp_action *orig_action_p = action_p;
-    struct lysp_action_inout *inout_p;
-    LY_ARRAY_COUNT_TYPE u;
-    ly_bool not_supported;
-    uint32_t opt_prev = ctx->options;
-
-    lysc_update_path(ctx, parent, action_p->name);
-
-    /* apply deviation on the action/RPC */
-    LY_CHECK_RET(lys_compile_node_deviations_refines(ctx, (struct lysp_node *)action_p, parent, &dev_pnode, &not_supported));
-    if (not_supported) {
-        lysc_update_path(ctx, NULL, NULL);
-        return LY_EDENIED;
-    } else if (dev_pnode) {
-        action_p = (struct lysp_action *)dev_pnode;
-    }
-
-    /* member needed for uniqueness check lys_getnext() */
-    action->nodetype = parent ? LYS_ACTION : LYS_RPC;
-    action->module = ctx->cur_mod;
-    action->parent = parent;
-
-    LY_CHECK_RET(lys_compile_node_uniqness(ctx, parent, action_p->name, (struct lysc_node *)action));
-
-    if (ctx->options & (LYS_COMPILE_RPC_MASK | LYS_COMPILE_NOTIFICATION)) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                "Action \"%s\" is placed inside %s.", action_p->name,
-                ctx->options & LYS_COMPILE_RPC_MASK ? "another RPC/action" : "notification");
-        return LY_EVALID;
-    }
-
-    action->sp = orig_action_p;
-    action->flags = action_p->flags & LYS_FLAGS_COMPILED_MASK;
-
-    /* status - it is not inherited by specification, but it does not make sense to have
-     * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
-    LY_CHECK_RET(lys_compile_status(ctx, &action->flags, uses_status ? uses_status : (parent ? parent->flags : 0)));
-
-    DUP_STRING_GOTO(ctx->ctx, action_p->name, action->name, ret, cleanup);
-    DUP_STRING_GOTO(ctx->ctx, action_p->dsc, action->dsc, ret, cleanup);
-    DUP_STRING_GOTO(ctx->ctx, action_p->ref, action->ref, ret, cleanup);
-    COMPILE_ARRAY_GOTO(ctx, action_p->iffeatures, action->iffeatures, u, lys_compile_iffeature, ret, cleanup);
-    COMPILE_EXTS_GOTO(ctx, action_p->exts, action->exts, action, LYEXT_PAR_NODE, ret, cleanup);
-
-    /* connect any action augments */
-    LY_CHECK_RET(lys_compile_node_augments(ctx, (struct lysc_node *)action));
-
-    /* input */
-    lysc_update_path(ctx, (struct lysc_node *)action, "input");
-
-    /* apply deviations on input */
-    LY_CHECK_RET(lys_compile_node_deviations_refines(ctx, (struct lysp_node *)&action_p->input, (struct lysc_node *)action,
-            &dev_input_p, &not_supported));
-    if (not_supported) {
-        inout_p = NULL;
-    } else if (dev_input_p) {
-        inout_p = (struct lysp_action_inout *)dev_input_p;
-    } else {
-        inout_p = &action_p->input;
-    }
-
-    if (inout_p) {
-        action->input.nodetype = LYS_INPUT;
-        COMPILE_ARRAY_GOTO(ctx, inout_p->musts, action->input.musts, u, lys_compile_must, ret, cleanup);
-        COMPILE_EXTS_GOTO(ctx, inout_p->exts, action->input_exts, &action->input, LYEXT_PAR_INPUT, ret, cleanup);
-        ctx->options |= LYS_COMPILE_RPC_INPUT;
-
-        /* connect any input augments */
-        LY_CHECK_RET(lys_compile_node_augments(ctx, (struct lysc_node *)&action->input));
-
-        LY_LIST_FOR(inout_p->data, child_p) {
-            LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node *)action, uses_status, NULL));
-        }
-        ctx->options = opt_prev;
-    }
-
-    lysc_update_path(ctx, NULL, NULL);
-
-    /* output */
-    lysc_update_path(ctx, (struct lysc_node *)action, "output");
-
-    /* apply deviations on output */
-    LY_CHECK_RET(lys_compile_node_deviations_refines(ctx, (struct lysp_node *)&action_p->output, (struct lysc_node *)action,
-            &dev_output_p, &not_supported));
-    if (not_supported) {
-        inout_p = NULL;
-    } else if (dev_output_p) {
-        inout_p = (struct lysp_action_inout *)dev_output_p;
-    } else {
-        inout_p = &action_p->output;
-    }
-
-    if (inout_p) {
-        action->output.nodetype = LYS_OUTPUT;
-        COMPILE_ARRAY_GOTO(ctx, inout_p->musts, action->output.musts, u, lys_compile_must, ret, cleanup);
-        COMPILE_EXTS_GOTO(ctx, inout_p->exts, action->output_exts, &action->output, LYEXT_PAR_OUTPUT, ret, cleanup);
-        ctx->options |= LYS_COMPILE_RPC_OUTPUT;
-
-        /* connect any output augments */
-        LY_CHECK_RET(lys_compile_node_augments(ctx, (struct lysc_node *)&action->output));
-
-        LY_LIST_FOR(inout_p->data, child_p) {
-            LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node *)action, uses_status, NULL));
-        }
-        ctx->options = opt_prev;
-    }
-
-    lysc_update_path(ctx, NULL, NULL);
-
-    if ((action->input.musts || action->output.musts) && !(ctx->options & LYS_COMPILE_GROUPING)) {
-        /* do not check "must" semantics in a grouping */
-        ret = ly_set_add(&ctx->xpath, action, 0, NULL);
-        LY_CHECK_GOTO(ret, cleanup);
-    }
-
-    lysc_update_path(ctx, NULL, NULL);
-
-cleanup:
-    lysp_dev_node_free(ctx->ctx, dev_pnode);
-    lysp_dev_node_free(ctx->ctx, dev_input_p);
-    lysp_dev_node_free(ctx->ctx, dev_output_p);
-    ctx->options = opt_prev;
-    return ret;
-}
-
-/**
- * @brief Compile parsed Notification schema node information.
- * @param[in] ctx Compile context
- * @param[in] notif_p Parsed Notification schema node.
- * @param[in] parent Parent node of the Notification, NULL in case of top-level Notification
- * @param[in,out] notif Prepared (empty) compiled notification structure to fill.
- * @param[in] uses_status If the Notification is being placed instead of uses, here we have the uses's status value (as node's flags).
- * Zero means no uses, non-zero value with no status bit set mean the default status.
- * @return LY_SUCCESS on success,
- * @return LY_EVALID on validation error,
- * @return LY_EDENIED on not-supported deviation.
- */
-static LY_ERR
-lys_compile_notif(struct lysc_ctx *ctx, struct lysp_notif *notif_p,
-        struct lysc_node *parent, struct lysc_notif *notif, uint16_t uses_status)
-{
-    LY_ERR ret = LY_SUCCESS;
-    struct lysp_node *child_p, *dev_pnode = NULL;
-    struct lysp_notif *orig_notif_p = notif_p;
-    LY_ARRAY_COUNT_TYPE u;
-    ly_bool not_supported;
-    uint32_t opt_prev = ctx->options;
-
-    lysc_update_path(ctx, parent, notif_p->name);
-
-    LY_CHECK_RET(lys_compile_node_deviations_refines(ctx, (struct lysp_node *)notif_p, parent, &dev_pnode, &not_supported));
-    if (not_supported) {
-        lysc_update_path(ctx, NULL, NULL);
-        return LY_EDENIED;
-    } else if (dev_pnode) {
-        notif_p = (struct lysp_notif *)dev_pnode;
-    }
-
-    /* member needed for uniqueness check lys_getnext() */
-    notif->nodetype = LYS_NOTIF;
-    notif->module = ctx->cur_mod;
-    notif->parent = parent;
-
-    LY_CHECK_RET(lys_compile_node_uniqness(ctx, parent, notif_p->name, (struct lysc_node *)notif));
-
-    if (ctx->options & (LYS_COMPILE_RPC_MASK | LYS_COMPILE_NOTIFICATION)) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                "Notification \"%s\" is placed inside %s.", notif_p->name,
-                ctx->options & LYS_COMPILE_RPC_MASK ? "RPC/action" : "another notification");
-        return LY_EVALID;
-    }
-
-    notif->sp = orig_notif_p;
-    notif->flags = notif_p->flags & LYS_FLAGS_COMPILED_MASK;
-
-    /* status - it is not inherited by specification, but it does not make sense to have
-     * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
-    ret = lys_compile_status(ctx, &notif->flags, uses_status ? uses_status : (parent ? parent->flags : 0));
-    LY_CHECK_GOTO(ret, cleanup);
-
-    DUP_STRING_GOTO(ctx->ctx, notif_p->name, notif->name, ret, cleanup);
-    DUP_STRING_GOTO(ctx->ctx, notif_p->dsc, notif->dsc, ret, cleanup);
-    DUP_STRING_GOTO(ctx->ctx, notif_p->ref, notif->ref, ret, cleanup);
-    COMPILE_ARRAY_GOTO(ctx, notif_p->iffeatures, notif->iffeatures, u, lys_compile_iffeature, ret, cleanup);
-    COMPILE_ARRAY_GOTO(ctx, notif_p->musts, notif->musts, u, lys_compile_must, ret, cleanup);
-    if (notif_p->musts && !(ctx->options & LYS_COMPILE_GROUPING)) {
-        /* do not check "must" semantics in a grouping */
-        ret = ly_set_add(&ctx->xpath, notif, 0, NULL);
-        LY_CHECK_GOTO(ret, cleanup);
-    }
-    COMPILE_EXTS_GOTO(ctx, notif_p->exts, notif->exts, notif, LYEXT_PAR_NODE, ret, cleanup);
-
-    ctx->options |= LYS_COMPILE_NOTIFICATION;
-
-    /* connect any notification augments */
-    LY_CHECK_RET(lys_compile_node_augments(ctx, (struct lysc_node *)notif));
-
-    LY_LIST_FOR(notif_p->data, child_p) {
-        ret = lys_compile_node(ctx, child_p, (struct lysc_node *)notif, uses_status, NULL);
-        LY_CHECK_GOTO(ret, cleanup);
-    }
-
-    lysc_update_path(ctx, NULL, NULL);
-
-cleanup:
-    lysp_dev_node_free(ctx->ctx, dev_pnode);
-    ctx->options = opt_prev;
-    return ret;
-}
-
-/**
- * @brief Compile parsed container node information.
- * @param[in] ctx Compile context
- * @param[in] pnode Parsed container node.
- * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
- * is enriched with the container-specific information.
- * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
- */
-static LY_ERR
-lys_compile_node_container(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *node)
-{
-    struct lysp_node_container *cont_p = (struct lysp_node_container *)pnode;
-    struct lysc_node_container *cont = (struct lysc_node_container *)node;
-    struct lysp_node *child_p;
-    LY_ARRAY_COUNT_TYPE u;
-    LY_ERR ret = LY_SUCCESS;
-
-    if (cont_p->presence) {
-        /* explicit presence */
-        cont->flags |= LYS_PRESENCE;
-    } else if (cont_p->musts) {
-        /* container with a must condition */
-        LOGWRN(ctx->ctx, "Container \"%s\" changed to presence because it has a meaning from its \"must\" condition.", cont_p->name);
-        cont->flags |= LYS_PRESENCE;
-    } else if (cont_p->when) {
-        /* container with a when condition */
-        LOGWRN(ctx->ctx, "Container \"%s\" changed to presence because it has a meaning from its \"when\" condition.", cont_p->name);
-        cont->flags |= LYS_PRESENCE;
-    } else if (cont_p->parent) {
-        if (cont_p->parent->nodetype == LYS_CHOICE) {
-            /* container is an implicit case, so its existence decides the existence of the whole case */
-            LOGWRN(ctx->ctx, "Container \"%s\" changed to presence because it has a meaning as a case of choice \"%s\".",
-                    cont_p->name, cont_p->parent->name);
-            cont->flags |= LYS_PRESENCE;
-        } else if ((cont_p->parent->nodetype == LYS_CASE) &&
-                (((struct lysp_node_case *)cont_p->parent)->child == pnode) && !cont_p->next) {
-            /* container is the only node in a case, so its existence decides the existence of the whole case */
-            LOGWRN(ctx->ctx, "Container \"%s\" changed to presence because it has a meaning as a case of choice \"%s\".",
-                    cont_p->name, cont_p->parent->name);
-            cont->flags |= LYS_PRESENCE;
-        }
-    }
-
-    /* more cases when the container has meaning but is kept NP for convenience:
-     *   - when condition
-     *   - direct child action/notification
-     */
-
-    LY_LIST_FOR(cont_p->child, child_p) {
-        ret = lys_compile_node(ctx, child_p, node, 0, NULL);
-        LY_CHECK_GOTO(ret, done);
-    }
-
-    COMPILE_ARRAY_GOTO(ctx, cont_p->musts, cont->musts, u, lys_compile_must, ret, done);
-    if (cont_p->musts && !(ctx->options & LYS_COMPILE_GROUPING)) {
-        /* do not check "must" semantics in a grouping */
-        ret = ly_set_add(&ctx->xpath, cont, 0, NULL);
-        LY_CHECK_GOTO(ret, done);
-    }
-    COMPILE_OP_ARRAY_GOTO(ctx, cont_p->actions, cont->actions, node, u, lys_compile_action, 0, ret, done);
-    COMPILE_OP_ARRAY_GOTO(ctx, cont_p->notifs, cont->notifs, node, u, lys_compile_notif, 0, ret, done);
-
-done:
-    return ret;
-}
-
-/*
- * @brief Compile type in leaf/leaf-list node and do all the necessary checks.
- * @param[in] ctx Compile context.
- * @param[in] context_node Schema node where the type/typedef is placed to correctly find the base types.
- * @param[in] type_p Parsed type to compile.
- * @param[in,out] leaf Compiled leaf structure (possibly cast leaf-list) to provide node information and to store the compiled type information.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_node_type(struct lysc_ctx *ctx, struct lysp_node *context_node, struct lysp_type *type_p,
-        struct lysc_node_leaf *leaf)
-{
-    struct lysp_qname *dflt;
-
-    LY_CHECK_RET(lys_compile_type(ctx, context_node, leaf->flags, ctx->pmod, leaf->name, type_p, &leaf->type,
-            leaf->units ? NULL : &leaf->units, &dflt));
-
-    /* store default value, if any */
-    if (dflt && !(leaf->flags & LYS_SET_DFLT)) {
-        LY_CHECK_RET(lysc_unres_leaf_dflt_add(ctx, leaf, dflt));
-    }
-
-    if (leaf->type->basetype == LY_TYPE_LEAFREF) {
-        /* store to validate the path in the current context at the end of schema compiling when all the nodes are present */
-        LY_CHECK_RET(ly_set_add(&ctx->leafrefs, leaf, 0, NULL));
-    } else if (leaf->type->basetype == LY_TYPE_UNION) {
-        LY_ARRAY_COUNT_TYPE u;
-        LY_ARRAY_FOR(((struct lysc_type_union *)leaf->type)->types, u) {
-            if (((struct lysc_type_union *)leaf->type)->types[u]->basetype == LY_TYPE_LEAFREF) {
-                /* store to validate the path in the current context at the end of schema compiling when all the nodes are present */
-                LY_CHECK_RET(ly_set_add(&ctx->leafrefs, leaf, 0, NULL));
-            }
-        }
-    } else if (leaf->type->basetype == LY_TYPE_EMPTY) {
-        if ((leaf->nodetype == LYS_LEAFLIST) && (ctx->pmod->version < LYS_VERSION_1_1)) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                    "Leaf-list of type \"empty\" is allowed only in YANG 1.1 modules.");
-            return LY_EVALID;
-        }
-    }
-
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Compile parsed leaf node information.
- * @param[in] ctx Compile context
- * @param[in] pnode Parsed leaf node.
- * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
- * is enriched with the leaf-specific information.
- * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
- */
-static LY_ERR
-lys_compile_node_leaf(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *node)
-{
-    struct lysp_node_leaf *leaf_p = (struct lysp_node_leaf *)pnode;
-    struct lysc_node_leaf *leaf = (struct lysc_node_leaf *)node;
-    LY_ARRAY_COUNT_TYPE u;
-    LY_ERR ret = LY_SUCCESS;
-
-    COMPILE_ARRAY_GOTO(ctx, leaf_p->musts, leaf->musts, u, lys_compile_must, ret, done);
-    if (leaf_p->musts && !(ctx->options & LYS_COMPILE_GROUPING)) {
-        /* do not check "must" semantics in a grouping */
-        ret = ly_set_add(&ctx->xpath, leaf, 0, NULL);
-        LY_CHECK_GOTO(ret, done);
-    }
-    if (leaf_p->units) {
-        LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, leaf_p->units, 0, &leaf->units), done);
-        leaf->flags |= LYS_SET_UNITS;
-    }
-
-    /* compile type */
-    ret = lys_compile_node_type(ctx, pnode, &leaf_p->type, leaf);
-    LY_CHECK_GOTO(ret, done);
-
-    /* store/update default value */
-    if (leaf_p->dflt.str) {
-        LY_CHECK_RET(lysc_unres_leaf_dflt_add(ctx, leaf, &leaf_p->dflt));
-        leaf->flags |= LYS_SET_DFLT;
-    }
-
-    /* checks */
-    if ((leaf->flags & LYS_SET_DFLT) && (leaf->flags & LYS_MAND_TRUE)) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                "Invalid mandatory leaf with a default value.");
-        return LY_EVALID;
-    }
-
-done:
-    return ret;
-}
-
-/**
- * @brief Compile parsed leaf-list node information.
- * @param[in] ctx Compile context
- * @param[in] pnode Parsed leaf-list node.
- * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
- * is enriched with the leaf-list-specific information.
- * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
- */
-static LY_ERR
-lys_compile_node_leaflist(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *node)
-{
-    struct lysp_node_leaflist *llist_p = (struct lysp_node_leaflist *)pnode;
-    struct lysc_node_leaflist *llist = (struct lysc_node_leaflist *)node;
-    LY_ARRAY_COUNT_TYPE u;
-    LY_ERR ret = LY_SUCCESS;
-
-    COMPILE_ARRAY_GOTO(ctx, llist_p->musts, llist->musts, u, lys_compile_must, ret, done);
-    if (llist_p->musts && !(ctx->options & LYS_COMPILE_GROUPING)) {
-        /* do not check "must" semantics in a grouping */
-        ret = ly_set_add(&ctx->xpath, llist, 0, NULL);
-        LY_CHECK_GOTO(ret, done);
-    }
-    if (llist_p->units) {
-        LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, llist_p->units, 0, &llist->units), done);
-        llist->flags |= LYS_SET_UNITS;
-    }
-
-    /* compile type */
-    ret = lys_compile_node_type(ctx, pnode, &llist_p->type, (struct lysc_node_leaf *)llist);
-    LY_CHECK_GOTO(ret, done);
-
-    /* store/update default values */
-    if (llist_p->dflts) {
-        if (ctx->pmod->version < LYS_VERSION_1_1) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                    "Leaf-list default values are allowed only in YANG 1.1 modules.");
-            return LY_EVALID;
-        }
-
-        LY_CHECK_GOTO(lysc_unres_llist_dflts_add(ctx, llist, llist_p->dflts), done);
-        llist->flags |= LYS_SET_DFLT;
-    }
-
-    llist->min = llist_p->min;
-    if (llist->min) {
-        llist->flags |= LYS_MAND_TRUE;
-    }
-    llist->max = llist_p->max ? llist_p->max : (uint32_t)-1;
-
-    /* checks */
-    if ((llist->flags & LYS_SET_DFLT) && (llist->flags & LYS_MAND_TRUE)) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                "Invalid mandatory leaf-list with default value(s).");
-        return LY_EVALID;
-    }
-
-    if (llist->min > llist->max) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Leaf-list min-elements %u is bigger than max-elements %u.",
-                llist->min, llist->max);
-        return LY_EVALID;
-    }
-
-done:
-    return ret;
-}
-
-/**
- * @brief Find the node according to the given descendant/absolute schema nodeid.
- * Used in unique, refine and augment statements.
- *
- * @param[in] ctx Compile context
- * @param[in] nodeid Descendant-schema-nodeid (according to the YANG grammar)
- * @param[in] nodeid_len Length of the given nodeid, if it is not NULL-terminated string.
- * @param[in] ctx_node Context node for a relative nodeid.
- * @param[in] cur_mod Current module for the nodeid (where it was "instantiated").
- * @param[in] format Format of any prefixes.
- * @param[in] prefix_data Format-specific prefix data (see ::ly_resolve_prefix).
- * @param[in] nodetype Optional (can be 0) restriction for target's nodetype. If target exists, but does not match
- * the given nodetype, LY_EDENIED is returned (and target is provided), but no error message is printed.
- * The value can be even an ORed value to allow multiple nodetypes.
- * @param[out] target Found target node if any.
- * @param[out] result_flag Output parameter to announce if the schema nodeid goes through the action's input/output or a Notification.
- * The LYSC_OPT_RPC_INPUT, LYSC_OPT_RPC_OUTPUT and LYSC_OPT_NOTIFICATION are used as flags.
- * @return LY_ERR values - LY_ENOTFOUND, LY_EVALID, LY_EDENIED or LY_SUCCESS.
- */
-static LY_ERR
-lysc_resolve_schema_nodeid(struct lysc_ctx *ctx, const char *nodeid, size_t nodeid_len, const struct lysc_node *ctx_node,
-        const struct lys_module *cur_mod, LY_PREFIX_FORMAT format, void *prefix_data, uint16_t nodetype,
-        const struct lysc_node **target, uint16_t *result_flag)
-{
-    LY_ERR ret = LY_EVALID;
-    const char *name, *prefix, *id;
-    size_t name_len, prefix_len;
-    const struct lys_module *mod;
-    const char *nodeid_type;
-    uint32_t getnext_extra_flag = 0;
-    uint16_t current_nodetype = 0;
-
-    assert(nodeid);
-    assert(target);
-    assert(result_flag);
-    *target = NULL;
-    *result_flag = 0;
-
-    id = nodeid;
-
-    if (ctx_node) {
-        /* descendant-schema-nodeid */
-        nodeid_type = "descendant";
-
-        if (*id == '/') {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid descendant-schema-nodeid value \"%.*s\" - absolute-schema-nodeid used.",
-                    nodeid_len ? nodeid_len : strlen(nodeid), nodeid);
-            return LY_EVALID;
-        }
-    } else {
-        /* absolute-schema-nodeid */
-        nodeid_type = "absolute";
-
-        if (*id != '/') {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid absolute-schema-nodeid value \"%.*s\" - missing starting \"/\".",
-                    nodeid_len ? nodeid_len : strlen(nodeid), nodeid);
-            return LY_EVALID;
-        }
-        ++id;
-    }
-
-    while (*id && (ret = ly_parse_nodeid(&id, &prefix, &prefix_len, &name, &name_len)) == LY_SUCCESS) {
-        if (prefix) {
-            mod = ly_resolve_prefix(ctx->ctx, prefix, prefix_len, format, prefix_data);
-            if (!mod) {
-                /* module must always be found */
-                assert(prefix);
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                        "Invalid %s-schema-nodeid value \"%.*s\" - prefix \"%.*s\" not defined in module \"%s\".",
-                        nodeid_type, id - nodeid, nodeid, prefix_len, prefix, LYSP_MODULE_NAME(ctx->pmod));
-                return LY_ENOTFOUND;
-            }
-        } else {
-            switch (format) {
-            case LY_PREF_SCHEMA:
-            case LY_PREF_SCHEMA_RESOLVED:
-                /* use the current module */
-                mod = cur_mod;
-                break;
-            case LY_PREF_JSON:
-                if (!ctx_node) {
-                    LOGINT_RET(ctx->ctx);
-                }
-                /* inherit the module of the previous context node */
-                mod = ctx_node->module;
-                break;
-            case LY_PREF_XML:
-                /* not really defined */
-                LOGINT_RET(ctx->ctx);
-            }
-        }
-
-        if (ctx_node && (ctx_node->nodetype & (LYS_RPC | LYS_ACTION))) {
-            /* move through input/output manually */
-            if (mod != ctx_node->module) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                        "Invalid %s-schema-nodeid value \"%.*s\" - target node not found.", nodeid_type, id - nodeid, nodeid);
-                return LY_ENOTFOUND;
-            }
-            if (!ly_strncmp("input", name, name_len)) {
-                ctx_node = (struct lysc_node *)&((struct lysc_action *)ctx_node)->input;
-            } else if (!ly_strncmp("output", name, name_len)) {
-                ctx_node = (struct lysc_node *)&((struct lysc_action *)ctx_node)->output;
-                getnext_extra_flag = LYS_GETNEXT_OUTPUT;
-            } else {
-                /* only input or output is valid */
-                ctx_node = NULL;
-            }
-        } else {
-            ctx_node = lys_find_child(ctx_node, mod, name, name_len, 0,
-                    getnext_extra_flag | LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCHOICE | LYS_GETNEXT_WITHCASE);
-            getnext_extra_flag = 0;
-        }
-        if (!ctx_node) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid %s-schema-nodeid value \"%.*s\" - target node not found.", nodeid_type, id - nodeid, nodeid);
-            return LY_ENOTFOUND;
-        }
-        current_nodetype = ctx_node->nodetype;
-
-        if (current_nodetype == LYS_NOTIF) {
-            (*result_flag) |= LYS_COMPILE_NOTIFICATION;
-        } else if (current_nodetype == LYS_INPUT) {
-            (*result_flag) |= LYS_COMPILE_RPC_INPUT;
-        } else if (current_nodetype == LYS_OUTPUT) {
-            (*result_flag) |= LYS_COMPILE_RPC_OUTPUT;
-        }
-
-        if (!*id || (nodeid_len && ((size_t)(id - nodeid) >= nodeid_len))) {
-            break;
-        }
-        if (*id != '/') {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid %s-schema-nodeid value \"%.*s\" - missing \"/\" as node-identifier separator.",
-                    nodeid_type, id - nodeid + 1, nodeid);
-            return LY_EVALID;
-        }
-        ++id;
-    }
-
-    if (ret == LY_SUCCESS) {
-        *target = ctx_node;
-        if (nodetype && !(current_nodetype & nodetype)) {
-            return LY_EDENIED;
-        }
-    } else {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                "Invalid %s-schema-nodeid value \"%.*s\" - unexpected end of expression.",
-                nodeid_type, nodeid_len ? nodeid_len : strlen(nodeid), nodeid);
-    }
-
-    return ret;
-}
-
-/**
- * @brief Compile information about list's uniques.
- * @param[in] ctx Compile context.
- * @param[in] uniques Sized array list of unique statements.
- * @param[in] list Compiled list where the uniques are supposed to be resolved and stored.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_node_list_unique(struct lysc_ctx *ctx, struct lysp_qname *uniques, struct lysc_node_list *list)
-{
-    LY_ERR ret = LY_SUCCESS;
-    struct lysc_node_leaf **key, ***unique;
-    struct lysc_node *parent;
-    const char *keystr, *delim;
-    size_t len;
-    LY_ARRAY_COUNT_TYPE v;
-    int8_t config; /* -1 - not yet seen; 0 - LYS_CONFIG_R; 1 - LYS_CONFIG_W */
-    uint16_t flags;
-
-    LY_ARRAY_FOR(uniques, v) {
-        config = -1;
-        LY_ARRAY_NEW_RET(ctx->ctx, list->uniques, unique, LY_EMEM);
-        keystr = uniques[v].str;
-        while (keystr) {
-            delim = strpbrk(keystr, " \t\n");
-            if (delim) {
-                len = delim - keystr;
-                while (isspace(*delim)) {
-                    ++delim;
-                }
-            } else {
-                len = strlen(keystr);
-            }
-
-            /* unique node must be present */
-            LY_ARRAY_NEW_RET(ctx->ctx, *unique, key, LY_EMEM);
-            ret = lysc_resolve_schema_nodeid(ctx, keystr, len, (struct lysc_node *)list, uniques[v].mod->mod,
-                    LY_PREF_SCHEMA, (void *)uniques[v].mod, LYS_LEAF, (const struct lysc_node **)key, &flags);
-            if (ret != LY_SUCCESS) {
-                if (ret == LY_EDENIED) {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                            "Unique's descendant-schema-nodeid \"%.*s\" refers to %s node instead of a leaf.",
-                            len, keystr, lys_nodetype2str((*key)->nodetype));
-                }
-                return LY_EVALID;
-            } else if (flags) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                        "Unique's descendant-schema-nodeid \"%.*s\" refers into %s node.",
-                        len, keystr, flags & LYS_COMPILE_NOTIFICATION ? "notification" : "RPC/action");
-                return LY_EVALID;
-            }
-
-            /* all referenced leafs must be of the same config type */
-            if ((config != -1) && ((((*key)->flags & LYS_CONFIG_W) && (config == 0)) ||
-                    (((*key)->flags & LYS_CONFIG_R) && (config == 1)))) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                        "Unique statement \"%s\" refers to leaves with different config type.", uniques[v].str);
-                return LY_EVALID;
-            } else if ((*key)->flags & LYS_CONFIG_W) {
-                config = 1;
-            } else { /* LYS_CONFIG_R */
-                config = 0;
-            }
-
-            /* we forbid referencing nested lists because it is unspecified what instance of such a list to use */
-            for (parent = (*key)->parent; parent != (struct lysc_node *)list; parent = parent->parent) {
-                if (parent->nodetype == LYS_LIST) {
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                            "Unique statement \"%s\" refers to a leaf in nested list \"%s\".", uniques[v].str, parent->name);
-                    return LY_EVALID;
-                }
-            }
-
-            /* check status */
-            LY_CHECK_RET(lysc_check_status(ctx, list->flags, list->module, list->name,
-                    (*key)->flags, (*key)->module, (*key)->name));
-
-            /* mark leaf as unique */
-            (*key)->flags |= LYS_UNIQUE;
-
-            /* next unique value in line */
-            keystr = delim;
-        }
-        /* next unique definition */
-    }
-
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Compile parsed list node information.
- * @param[in] ctx Compile context
- * @param[in] pnode Parsed list node.
- * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
- * is enriched with the list-specific information.
- * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
- */
-static LY_ERR
-lys_compile_node_list(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *node)
-{
-    struct lysp_node_list *list_p = (struct lysp_node_list *)pnode;
-    struct lysc_node_list *list = (struct lysc_node_list *)node;
-    struct lysp_node *child_p;
-    struct lysc_node_leaf *key, *prev_key = NULL;
-    size_t len;
-    LY_ARRAY_COUNT_TYPE u;
-    const char *keystr, *delim;
-    LY_ERR ret = LY_SUCCESS;
-
-    list->min = list_p->min;
-    if (list->min) {
-        list->flags |= LYS_MAND_TRUE;
-    }
-    list->max = list_p->max ? list_p->max : (uint32_t)-1;
-
-    LY_LIST_FOR(list_p->child, child_p) {
-        LY_CHECK_RET(lys_compile_node(ctx, child_p, node, 0, NULL));
-    }
-
-    COMPILE_ARRAY_GOTO(ctx, list_p->musts, list->musts, u, lys_compile_must, ret, done);
-    if (list_p->musts && !(ctx->options & LYS_COMPILE_GROUPING)) {
-        /* do not check "must" semantics in a grouping */
-        LY_CHECK_RET(ly_set_add(&ctx->xpath, list, 0, NULL));
-    }
-
-    /* keys */
-    if ((list->flags & LYS_CONFIG_W) && (!list_p->key || !list_p->key[0])) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Missing key in list representing configuration data.");
-        return LY_EVALID;
-    }
-
-    /* find all the keys (must be direct children) */
-    keystr = list_p->key;
-    if (!keystr) {
-        /* keyless list */
-        list->flags |= LYS_KEYLESS;
-    }
-    while (keystr) {
-        delim = strpbrk(keystr, " \t\n");
-        if (delim) {
-            len = delim - keystr;
-            while (isspace(*delim)) {
-                ++delim;
-            }
-        } else {
-            len = strlen(keystr);
-        }
-
-        /* key node must be present */
-        key = (struct lysc_node_leaf *)lys_find_child(node, node->module, keystr, len, LYS_LEAF, LYS_GETNEXT_NOCHOICE | LYS_GETNEXT_NOSTATECHECK);
-        if (!(key)) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "The list's key \"%.*s\" not found.", len, keystr);
-            return LY_EVALID;
-        }
-        /* keys must be unique */
-        if (key->flags & LYS_KEY) {
-            /* the node was already marked as a key */
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                    "Duplicated key identifier \"%.*s\".", len, keystr);
-            return LY_EVALID;
-        }
-
-        lysc_update_path(ctx, (struct lysc_node *)list, key->name);
-        /* key must have the same config flag as the list itself */
-        if ((list->flags & LYS_CONFIG_MASK) != (key->flags & LYS_CONFIG_MASK)) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Key of the configuration list must not be status leaf.");
-            return LY_EVALID;
-        }
-        if (ctx->pmod->version < LYS_VERSION_1_1) {
-            /* YANG 1.0 denies key to be of empty type */
-            if (key->type->basetype == LY_TYPE_EMPTY) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                        "List's key cannot be of \"empty\" type until it is in YANG 1.1 module.");
-                return LY_EVALID;
-            }
-        } else {
-            /* when and if-feature are illegal on list keys */
-            if (key->when) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                        "List's key must not have any \"when\" statement.");
-                return LY_EVALID;
-            }
-            if (key->iffeatures) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                        "List's key must not have any \"if-feature\" statement.");
-                return LY_EVALID;
-            }
-        }
-
-        /* check status */
-        LY_CHECK_RET(lysc_check_status(ctx, list->flags, list->module, list->name,
-                key->flags, key->module, key->name));
-
-        /* ignore default values of the key */
-        if (key->dflt) {
-            key->dflt->realtype->plugin->free(ctx->ctx, key->dflt);
-            lysc_type_free(ctx->ctx, (struct lysc_type *)key->dflt->realtype);
-            free(key->dflt);
-            key->dflt = NULL;
-        }
-        /* mark leaf as key */
-        key->flags |= LYS_KEY;
-
-        /* move it to the correct position */
-        if ((prev_key && ((struct lysc_node *)prev_key != key->prev)) || (!prev_key && key->prev->next)) {
-            /* fix links in closest previous siblings of the key */
-            if (key->next) {
-                key->next->prev = key->prev;
-            } else {
-                /* last child */
-                list->child->prev = key->prev;
-            }
-            if (key->prev->next) {
-                key->prev->next = key->next;
-            }
-            /* fix links in the key */
-            if (prev_key) {
-                key->prev = (struct lysc_node *)prev_key;
-                key->next = prev_key->next;
-            } else {
-                key->prev = list->child->prev;
-                key->next = list->child;
-            }
-            /* fix links in closes future siblings of the key */
-            if (prev_key) {
-                if (prev_key->next) {
-                    prev_key->next->prev = (struct lysc_node *)key;
-                } else {
-                    list->child->prev = (struct lysc_node *)key;
-                }
-                prev_key->next = (struct lysc_node *)key;
-            } else {
-                list->child->prev = (struct lysc_node *)key;
-            }
-            /* fix links in parent */
-            if (!key->prev->next) {
-                list->child = (struct lysc_node *)key;
-            }
-        }
-
-        /* next key value */
-        prev_key = key;
-        keystr = delim;
-        lysc_update_path(ctx, NULL, NULL);
-    }
-
-    /* uniques */
-    if (list_p->uniques) {
-        LY_CHECK_RET(lys_compile_node_list_unique(ctx, list_p->uniques, list));
-    }
-
-    COMPILE_OP_ARRAY_GOTO(ctx, list_p->actions, list->actions, node, u, lys_compile_action, 0, ret, done);
-    COMPILE_OP_ARRAY_GOTO(ctx, list_p->notifs, list->notifs, node, u, lys_compile_notif, 0, ret, done);
-
-    /* checks */
-    if (list->min > list->max) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "List min-elements %u is bigger than max-elements %u.",
-                list->min, list->max);
-        return LY_EVALID;
-    }
-
-done:
-    return ret;
-}
-
-/**
- * @brief Do some checks and set the default choice's case.
- *
- * Selects (and stores into ::lysc_node_choice#dflt) the default case and set LYS_SET_DFLT flag on it.
- *
- * @param[in] ctx Compile context.
- * @param[in] dflt Name of the default branch. Can even contain a prefix.
- * @param[in,out] ch The compiled choice node, its dflt member is filled to point to the default case node of the choice.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_node_choice_dflt(struct lysc_ctx *ctx, struct lysp_qname *dflt, struct lysc_node_choice *ch)
-{
-    struct lysc_node *iter, *node = (struct lysc_node *)ch;
-    const struct lys_module *mod;
-    const char *prefix = NULL, *name;
-    size_t prefix_len = 0;
-
-    /* could use lys_parse_nodeid(), but it checks syntax which is already done in this case by the parsers */
-    name = strchr(dflt->str, ':');
-    if (name) {
-        prefix = dflt->str;
-        prefix_len = name - prefix;
-        ++name;
-    } else {
-        name = dflt->str;
-    }
-    if (prefix) {
-        mod = ly_resolve_prefix(ctx->ctx, prefix, prefix_len, LY_PREF_SCHEMA, (void *)dflt->mod);
-        if (!mod) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Default case prefix \"%.*s\" not found "
-                    "in imports of \"%s\".", prefix_len, prefix, LYSP_MODULE_NAME(dflt->mod));
-            return LY_EVALID;
-        }
-    } else {
-        mod = node->module;
-    }
-
-    ch->dflt = (struct lysc_node_case *)lys_find_child(node, mod, name, 0, LYS_CASE, LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCASE);
-    if (!ch->dflt) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                "Default case \"%s\" not found.", dflt->str);
-        return LY_EVALID;
-    }
-
-    /* no mandatory nodes directly under the default case */
-    LY_LIST_FOR(ch->dflt->child, iter) {
-        if (iter->parent != (struct lysc_node *)ch->dflt) {
-            break;
-        }
-        if (iter->flags & LYS_MAND_TRUE) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                    "Mandatory node \"%s\" under the default case \"%s\".", iter->name, dflt->str);
-            return LY_EVALID;
-        }
-    }
-
-    if (ch->flags & LYS_MAND_TRUE) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Invalid mandatory choice with a default case.");
-        return LY_EVALID;
-    }
-
-    ch->dflt->flags |= LYS_SET_DFLT;
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Compile choice children.
- *
- * @param[in] ctx Compile context
- * @param[in] child_p Parsed choice children nodes.
- * @param[in] node Compiled choice node to compile and add children to.
- * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
- */
-static LY_ERR
-lys_compile_node_choice_child(struct lysc_ctx *ctx, struct lysp_node *child_p, struct lysc_node *node,
-        struct ly_set *child_set)
-{
-    LY_ERR ret = LY_SUCCESS;
-    struct lysp_node *child_p_next = child_p->next;
-    struct lysp_node_case *cs_p;
-
-    if (child_p->nodetype == LYS_CASE) {
-        /* standard case under choice */
-        ret = lys_compile_node(ctx, child_p, node, 0, child_set);
-    } else {
-        /* we need the implicit case first, so create a fake parsed case */
-        cs_p = calloc(1, sizeof *cs_p);
-        cs_p->nodetype = LYS_CASE;
-        DUP_STRING_GOTO(ctx->ctx, child_p->name, cs_p->name, ret, free_fake_node);
-        cs_p->child = child_p;
-
-        /* make the child the only case child */
-        child_p->next = NULL;
-
-        /* compile it normally */
-        ret = lys_compile_node(ctx, (struct lysp_node *)cs_p, node, 0, child_set);
-
-free_fake_node:
-        /* free the fake parsed node and correct pointers back */
-        cs_p->child = NULL;
-        lysp_node_free(ctx->ctx, (struct lysp_node *)cs_p);
-        child_p->next = child_p_next;
-    }
-
-    return ret;
-}
-
-/**
- * @brief Compile parsed choice node information.
- *
- * @param[in] ctx Compile context
- * @param[in] pnode Parsed choice node.
- * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
- * is enriched with the choice-specific information.
- * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
- */
-static LY_ERR
-lys_compile_node_choice(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *node)
-{
-    struct lysp_node_choice *ch_p = (struct lysp_node_choice *)pnode;
-    struct lysc_node_choice *ch = (struct lysc_node_choice *)node;
-    struct lysp_node *child_p;
-    LY_ERR ret = LY_SUCCESS;
-
-    assert(node->nodetype == LYS_CHOICE);
-
-    LY_LIST_FOR(ch_p->child, child_p) {
-        LY_CHECK_RET(lys_compile_node_choice_child(ctx, child_p, node, NULL));
-    }
-
-    /* default branch */
-    if (ch_p->dflt.str) {
-        LY_CHECK_RET(lys_compile_node_choice_dflt(ctx, &ch_p->dflt, ch));
-    }
-
-    return ret;
-}
-
-/**
- * @brief Compile parsed anydata or anyxml node information.
- * @param[in] ctx Compile context
- * @param[in] pnode Parsed anydata or anyxml node.
- * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
- * is enriched with the any-specific information.
- * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
- */
-static LY_ERR
-lys_compile_node_any(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *node)
-{
-    struct lysp_node_anydata *any_p = (struct lysp_node_anydata *)pnode;
-    struct lysc_node_anydata *any = (struct lysc_node_anydata *)node;
-    LY_ARRAY_COUNT_TYPE u;
-    LY_ERR ret = LY_SUCCESS;
-
-    COMPILE_ARRAY_GOTO(ctx, any_p->musts, any->musts, u, lys_compile_must, ret, done);
-    if (any_p->musts && !(ctx->options & LYS_COMPILE_GROUPING)) {
-        /* do not check "must" semantics in a grouping */
-        ret = ly_set_add(&ctx->xpath, any, 0, NULL);
-        LY_CHECK_GOTO(ret, done);
-    }
-
-    if (any->flags & LYS_CONFIG_W) {
-        LOGWRN(ctx->ctx, "Use of %s to define configuration data is not recommended. %s",
-                ly_stmt2str(any->nodetype == LYS_ANYDATA ? LY_STMT_ANYDATA : LY_STMT_ANYXML), ctx->path);
-    }
-done:
-    return ret;
-}
-
-/**
- * @brief Connect the node into the siblings list and check its name uniqueness. Also,
- * keep specific order of augments targetting the same node.
- *
- * @param[in] ctx Compile context
- * @param[in] parent Parent node holding the children list, in case of node from a choice's case,
- * the choice itself is expected instead of a specific case node.
- * @param[in] node Schema node to connect into the list.
- * @return LY_ERR value - LY_SUCCESS or LY_EEXIST.
- * In case of LY_EEXIST, the node is actually kept in the tree, so do not free it directly.
- */
-static LY_ERR
-lys_compile_node_connect(struct lysc_ctx *ctx, struct lysc_node *parent, struct lysc_node *node)
-{
-    struct lysc_node **children, *anchor = NULL;
-    int insert_after = 0;
-
-    node->parent = parent;
-
-    if (parent) {
-        if (parent->nodetype == LYS_CHOICE) {
-            assert(node->nodetype == LYS_CASE);
-            children = (struct lysc_node **)&((struct lysc_node_choice *)parent)->cases;
-        } else {
-            children = lysc_node_children_p(parent, ctx->options);
-        }
-        assert(children);
-
-        if (!(*children)) {
-            /* first child */
-            *children = node;
-        } else if (node->flags & LYS_KEY) {
-            /* special handling of adding keys */
-            assert(node->module == parent->module);
-            anchor = *children;
-            if (anchor->flags & LYS_KEY) {
-                while ((anchor->flags & LYS_KEY) && anchor->next) {
-                    anchor = anchor->next;
-                }
-                /* insert after the last key */
-                insert_after = 1;
-            } /* else insert before anchor (at the beginning) */
-        } else if ((*children)->prev->module == node->module) {
-            /* last child is from the same module, keep the order and insert at the end */
-            anchor = (*children)->prev;
-            insert_after = 1;
-        } else if (parent->module == node->module) {
-            /* adding module child after some augments were connected */
-            for (anchor = *children; anchor->module == node->module; anchor = anchor->next) {}
-        } else {
-            /* some augments are already connected and we are connecting new ones,
-             * keep module name order and insert the node into the children list */
-            anchor = *children;
-            do {
-                anchor = anchor->prev;
-
-                /* check that we have not found the last augment node from our module or
-                 * the first augment node from a "smaller" module or
-                 * the first node from a local module */
-                if ((anchor->module == node->module) || (strcmp(anchor->module->name, node->module->name) < 0) ||
-                        (anchor->module == parent->module)) {
-                    /* insert after */
-                    insert_after = 1;
-                    break;
-                }
-
-                /* we have traversed all the nodes, insert before anchor (as the first node) */
-            } while (anchor->prev->next);
-        }
-
-        /* insert */
-        if (anchor) {
-            if (insert_after) {
-                node->next = anchor->next;
-                node->prev = anchor;
-                anchor->next = node;
-                if (node->next) {
-                    /* middle node */
-                    node->next->prev = node;
-                } else {
-                    /* last node */
-                    (*children)->prev = node;
-                }
-            } else {
-                node->next = anchor;
-                node->prev = anchor->prev;
-                anchor->prev = node;
-                if (anchor == *children) {
-                    /* first node */
-                    *children = node;
-                } else {
-                    /* middle node */
-                    node->prev->next = node;
-                }
-            }
-        }
-
-        /* check the name uniqueness (even for an only child, it may be in case) */
-        if (lys_compile_node_uniqness(ctx, parent, node->name, node)) {
-            return LY_EEXIST;
-        }
-    } else {
-        /* top-level element */
-        if (!ctx->cur_mod->compiled->data) {
-            ctx->cur_mod->compiled->data = node;
-        } else {
-            /* insert at the end of the module's top-level nodes list */
-            ctx->cur_mod->compiled->data->prev->next = node;
-            node->prev = ctx->cur_mod->compiled->data->prev;
-            ctx->cur_mod->compiled->data->prev = node;
-        }
-
-        /* check the name uniqueness on top-level */
-        if (lys_compile_node_uniqness(ctx, NULL, node->name, node)) {
-            return LY_EEXIST;
-        }
-    }
-
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Prepare the case structure in choice node for the new data node.
- *
- * It is able to handle implicit as well as explicit cases and the situation when the case has multiple data nodes and the case was already
- * created in the choice when the first child was processed.
- *
- * @param[in] ctx Compile context.
- * @param[in] pnode Node image from the parsed tree. If the case is explicit, it is the LYS_CASE node, but in case of implicit case,
- *                   it is the LYS_CHOICE, LYS_AUGMENT or LYS_GROUPING node.
- * @param[in] ch The compiled choice structure where the new case structures are created (if needed).
- * @param[in] child The new data node being part of a case (no matter if explicit or implicit).
- * @return The case structure where the child node belongs to, NULL in case of error. Note that the child is not connected into the siblings list,
- * it is linked from the case structure only in case it is its first child.
- */
-static LY_ERR
-lys_compile_node_case(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *node)
-{
-    struct lysp_node *child_p;
-    struct lysp_node_case *cs_p = (struct lysp_node_case *)pnode;
-
-    if (pnode->nodetype & (LYS_CHOICE | LYS_AUGMENT | LYS_GROUPING)) {
-        /* we have to add an implicit case node into the parent choice */
-    } else if (pnode->nodetype == LYS_CASE) {
-        /* explicit parent case */
-        LY_LIST_FOR(cs_p->child, child_p) {
-            LY_CHECK_RET(lys_compile_node(ctx, child_p, node, 0, NULL));
-        }
-    } else {
-        LOGINT_RET(ctx->ctx);
-    }
-
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Set LYS_MAND_TRUE flag for the non-presence container parents.
- *
- * A non-presence container is mandatory in case it has at least one mandatory children. This function propagate
- * the flag to such parents from a mandatory children.
- *
- * @param[in] parent A schema node to be examined if the mandatory child make it also mandatory.
- * @param[in] add Flag to distinguish adding the mandatory flag (new mandatory children appeared) or removing the flag
- * (mandatory children was removed).
- */
-static void
-lys_compile_mandatory_parents(struct lysc_node *parent, ly_bool add)
-{
-    struct lysc_node *iter;
-
-    if (add) { /* set flag */
-        for ( ; parent && parent->nodetype == LYS_CONTAINER && !(parent->flags & LYS_MAND_TRUE) && !(parent->flags & LYS_PRESENCE);
-                parent = parent->parent) {
-            parent->flags |= LYS_MAND_TRUE;
-        }
-    } else { /* unset flag */
-        for ( ; parent && parent->nodetype == LYS_CONTAINER && (parent->flags & LYS_MAND_TRUE); parent = parent->parent) {
-            for (iter = (struct lysc_node *)lysc_node_children(parent, 0); iter; iter = iter->next) {
-                if (iter->flags & LYS_MAND_TRUE) {
-                    /* there is another mandatory node */
-                    return;
-                }
-            }
-            /* unset mandatory flag - there is no mandatory children in the non-presence container */
-            parent->flags &= ~LYS_MAND_TRUE;
-        }
-    }
-}
-
-/**
- * @brief Compile the parsed augment connecting it into its target.
- *
- * It is expected that all the data referenced in path are present - augments are ordered so that augment B
- * targeting data from augment A is being compiled after augment A. Also the modules referenced in the path
- * are already implemented and compiled.
- *
- * @param[in] ctx Compile context.
- * @param[in] aug_p Parsed augment to compile.
- * @param[in] target Target node of the augment.
- * @return LY_SUCCESS on success.
- * @return LY_EVALID on failure.
- */
-static LY_ERR
-lys_compile_augment(struct lysc_ctx *ctx, struct lysp_augment *aug_p, struct lysc_node *target)
-{
-    LY_ERR ret = LY_SUCCESS;
-    struct lysp_node *pnode;
-    struct lysc_node *node;
-    struct lysc_when *when_shared = NULL;
-    struct lysc_action **actions;
-    struct lysc_notif **notifs;
-    ly_bool allow_mandatory = 0;
-    LY_ARRAY_COUNT_TYPE u;
-    struct ly_set child_set = {0};
-    uint32_t i;
-
-    if (!(target->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_CHOICE | LYS_CASE | LYS_INPUT | LYS_OUTPUT | LYS_NOTIF))) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                "Augment's %s-schema-nodeid \"%s\" refers to a %s node which is not an allowed augment's target.",
-                aug_p->nodeid[0] == '/' ? "absolute" : "descendant", aug_p->nodeid, lys_nodetype2str(target->nodetype));
-        ret = LY_EVALID;
-        goto cleanup;
-    }
-
-    /* check for mandatory nodes
-     * - new cases augmenting some choice can have mandatory nodes
-     * - mandatory nodes are allowed only in case the augmentation is made conditional with a when statement
-     */
-    if (aug_p->when || (target->nodetype == LYS_CHOICE) || (ctx->cur_mod == target->module)) {
-        allow_mandatory = 1;
-    }
-
-    LY_LIST_FOR(aug_p->child, pnode) {
-        /* check if the subnode can be connected to the found target (e.g. case cannot be inserted into container) */
-        if (((pnode->nodetype == LYS_CASE) && (target->nodetype != LYS_CHOICE)) ||
-                ((pnode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) && !(target->nodetype & (LYS_CONTAINER | LYS_LIST))) ||
-                ((pnode->nodetype == LYS_USES) && (target->nodetype == LYS_CHOICE))) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid augment of %s node which is not allowed to contain %s node \"%s\".",
-                    lys_nodetype2str(target->nodetype), lys_nodetype2str(pnode->nodetype), pnode->name);
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-
-        /* compile the children */
-        if (target->nodetype == LYS_CHOICE) {
-            LY_CHECK_GOTO(ret = lys_compile_node_choice_child(ctx, pnode, target, &child_set), cleanup);
-        } else {
-            LY_CHECK_GOTO(ret = lys_compile_node(ctx, pnode, target, 0, &child_set), cleanup);
-        }
-
-        /* since the augment node is not present in the compiled tree, we need to pass some of its
-         * statements to all its children */
-        for (i = 0; i < child_set.count; ++i) {
-            node = child_set.snodes[i];
-            if (!allow_mandatory && (node->flags & LYS_CONFIG_W) && (node->flags & LYS_MAND_TRUE)) {
-                node->flags &= ~LYS_MAND_TRUE;
-                lys_compile_mandatory_parents(target, 0);
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                        "Invalid augment adding mandatory node \"%s\" without making it conditional via when statement.", node->name);
-                ret = LY_EVALID;
-                goto cleanup;
-            }
-
-            if (aug_p->when) {
-                /* pass augment's when to all the children */
-                ret = lys_compile_when(ctx, aug_p->when, aug_p->flags, lysc_xpath_context(target), node, &when_shared);
-                LY_CHECK_GOTO(ret, cleanup);
-            }
-        }
-        ly_set_erase(&child_set, NULL);
-    }
-
-    switch (target->nodetype) {
-    case LYS_CONTAINER:
-        actions = &((struct lysc_node_container *)target)->actions;
-        notifs = &((struct lysc_node_container *)target)->notifs;
-        break;
-    case LYS_LIST:
-        actions = &((struct lysc_node_list *)target)->actions;
-        notifs = &((struct lysc_node_list *)target)->notifs;
-        break;
-    default:
-        actions = NULL;
-        notifs = NULL;
-        break;
-    }
-
-    if (aug_p->actions) {
-        if (!actions) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid augment of %s node which is not allowed to contain RPC/action node \"%s\".",
-                    lys_nodetype2str(target->nodetype), aug_p->actions[0].name);
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-
-        /* compile actions into the target */
-        COMPILE_OP_ARRAY_GOTO(ctx, aug_p->actions, *actions, target, u, lys_compile_action, 0, ret, cleanup);
-
-        if (aug_p->when) {
-            /* inherit when */
-            LY_ARRAY_FOR(*actions, u) {
-                ret = lys_compile_when(ctx, aug_p->when, aug_p->flags, lysc_xpath_context(target),
-                        (struct lysc_node *)&(*actions)[u], &when_shared);
-                LY_CHECK_GOTO(ret, cleanup);
-            }
-        }
-    }
-    if (aug_p->notifs) {
-        if (!notifs) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid augment of %s node which is not allowed to contain notification node \"%s\".",
-                    lys_nodetype2str(target->nodetype), aug_p->notifs[0].name);
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-
-        /* compile notifications into the target */
-        COMPILE_OP_ARRAY_GOTO(ctx, aug_p->notifs, *notifs, target, u, lys_compile_notif, 0, ret, cleanup);
-
-        if (aug_p->when) {
-            /* inherit when */
-            LY_ARRAY_FOR(*notifs, u) {
-                ret = lys_compile_when(ctx, aug_p->when, aug_p->flags, lysc_xpath_context(target),
-                        (struct lysc_node *)&(*notifs)[u], &when_shared);
-                LY_CHECK_GOTO(ret, cleanup);
-            }
-        }
-    }
-
-cleanup:
-    ly_set_erase(&child_set, NULL);
-    return ret;
-}
-
-/**
- * @brief Find grouping for a uses.
- *
- * @param[in] ctx Compile context.
- * @param[in] uses_p Parsed uses node.
- * @param[out] gpr_p Found grouping on success.
- * @param[out] grp_pmod Module of @p grp_p on success.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_uses_find_grouping(struct lysc_ctx *ctx, struct lysp_node_uses *uses_p, struct lysp_grp **grp_p,
-        struct lysp_module **grp_pmod)
-{
-    struct lysp_node *pnode;
-    struct lysp_grp *grp;
-    LY_ARRAY_COUNT_TYPE u, v;
-    const char *id, *name, *prefix, *local_pref;
-    size_t prefix_len, name_len;
-    struct lysp_module *pmod, *found = NULL;
-    struct lys_module *mod;
-
-    *grp_p = NULL;
-    *grp_pmod = NULL;
-
-    /* search for the grouping definition */
-    id = uses_p->name;
-    LY_CHECK_RET(ly_parse_nodeid(&id, &prefix, &prefix_len, &name, &name_len), LY_EVALID);
-    local_pref = ctx->pmod->is_submod ? ((struct lysp_submodule *)ctx->pmod)->prefix : ctx->pmod->mod->prefix;
-    if (!prefix || !ly_strncmp(local_pref, prefix, prefix_len)) {
-        /* current module, search local groupings first */
-        pmod = ctx->pmod;
-        for (pnode = uses_p->parent; !found && pnode; pnode = pnode->parent) {
-            grp = (struct lysp_grp *)lysp_node_groupings(pnode);
-            LY_ARRAY_FOR(grp, u) {
-                if (!strcmp(grp[u].name, name)) {
-                    grp = &grp[u];
-                    found = ctx->pmod;
-                    break;
-                }
-            }
-        }
-    } else {
-        /* foreign module, find it first */
-        mod = lysp_module_find_prefix(ctx->pmod, prefix, prefix_len);
-        if (!mod) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid prefix used for grouping reference.", uses_p->name);
-            return LY_EVALID;
-        }
-        pmod = mod->parsed;
-    }
-
-    if (!found) {
-        /* search in top-level groupings of the main module ... */
-        grp = pmod->groupings;
-        LY_ARRAY_FOR(grp, u) {
-            if (!strcmp(grp[u].name, name)) {
-                grp = &grp[u];
-                found = pmod;
-                break;
-            }
-        }
-        if (!found) {
-            /* ... and all the submodules */
-            LY_ARRAY_FOR(pmod->includes, u) {
-                grp = pmod->includes[u].submodule->groupings;
-                LY_ARRAY_FOR(grp, v) {
-                    if (!strcmp(grp[v].name, name)) {
-                        grp = &grp[v];
-                        found = (struct lysp_module *)pmod->includes[u].submodule;
-                        break;
-                    }
-                }
-                if (found) {
-                    break;
-                }
-            }
-        }
-    }
-    if (!found) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                "Grouping \"%s\" referenced by a uses statement not found.", uses_p->name);
-        return LY_EVALID;
-    }
-
-    if (!(ctx->options & LYS_COMPILE_GROUPING)) {
-        /* remember that the grouping is instantiated to avoid its standalone validation */
-        grp->flags |= LYS_USED_GRP;
-    }
-
-    *grp_p = grp;
-    *grp_pmod = found;
-    return LY_SUCCESS;
-}
-
-static const struct lys_module *lys_schema_node_get_module(const struct ly_ctx *ctx, const char *nametest,
-        size_t nametest_len, const struct lysp_module *mod, const char **name, size_t *name_len);
-
-static LY_ERR
-lys_nodeid_check(struct lysc_ctx *ctx, const char *nodeid, ly_bool abs, struct lys_module **target_mod,
-        struct lyxp_expr **expr)
-{
-    LY_ERR ret = LY_SUCCESS;
-    struct lyxp_expr *e = NULL;
-    struct lys_module *tmod = NULL, *mod;
-    const char *nodeid_type = abs ? "absolute-schema-nodeid" : "descendant-schema-nodeid";
-    uint32_t i;
-
-    /* parse */
-    ret = lyxp_expr_parse(ctx->ctx, nodeid, strlen(nodeid), 0, &e);
-    if (ret) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid %s value \"%s\" - invalid syntax.",
-                nodeid_type, nodeid);
-        ret = LY_EVALID;
-        goto cleanup;
-    }
-
-    if (abs) {
-        /* absolute schema nodeid */
-        i = 0;
-    } else {
-        /* descendant schema nodeid */
-        if (e->tokens[0] != LYXP_TOKEN_NAMETEST) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Invalid %s value \"%s\" - name test expected instead of \"%.*s\".",
-                    nodeid_type, nodeid, e->tok_len[0], e->expr + e->tok_pos[0]);
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-        i = 1;
-    }
-
-    /* check all the tokens */
-    for ( ; i < e->used; i += 2) {
-        if (e->tokens[i] != LYXP_TOKEN_OPER_PATH) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Invalid %s value \"%s\" - \"/\" expected instead of \"%.*s\".",
-                    nodeid_type, nodeid, e->tok_len[i], e->expr + e->tok_pos[i]);
-            ret = LY_EVALID;
-            goto cleanup;
-        } else if (e->used == i + 1) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid %s value \"%s\" - unexpected end of expression.", nodeid_type, e->expr);
-            ret = LY_EVALID;
-            goto cleanup;
-        } else if (e->tokens[i + 1] != LYXP_TOKEN_NAMETEST) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Invalid %s value \"%s\" - name test expected instead of \"%.*s\".",
-                    nodeid_type, nodeid, e->tok_len[i + 1], e->expr + e->tok_pos[i + 1]);
-            ret = LY_EVALID;
-            goto cleanup;
-        } else if (abs) {
-            mod = (struct lys_module *)lys_schema_node_get_module(ctx->ctx, e->expr + e->tok_pos[i + 1],
-                    e->tok_len[i + 1], ctx->pmod, NULL, NULL);
-            LY_CHECK_ERR_GOTO(!mod, ret = LY_EVALID, cleanup);
-
-            /* only keep the first module */
-            if (!tmod) {
-                tmod = mod;
-            }
-
-            /* all the modules must be implemented */
-            if (!mod->implemented) {
-                ret = lys_set_implemented(mod);
-                LY_CHECK_GOTO(ret, cleanup);
-            }
-        }
-    }
-
-cleanup:
-    if (ret || !expr) {
-        lyxp_expr_free(ctx->ctx, e);
-        e = NULL;
-    }
-    if (expr) {
-        *expr = ret ? NULL : e;
-    }
-    if (target_mod) {
-        *target_mod = ret ? NULL : tmod;
-    }
-    return ret;
-}
-
-/**
- * @brief Check whether 2 schema nodeids match.
- *
- * @param[in] ctx libyang context.
- * @param[in] exp1 First schema nodeid.
- * @param[in] exp1p_mod Module of @p exp1 nodes without any prefix.
- * @param[in] exp2 Second schema nodeid.
- * @param[in] exp2_pmod Module of @p exp2 nodes without any prefix.
- * @return Whether the schema nodeids match or not.
- */
-static ly_bool
-lys_abs_schema_nodeid_match(const struct ly_ctx *ctx, const struct lyxp_expr *exp1, const struct lysp_module *exp1_pmod,
-        const struct lyxp_expr *exp2, const struct lysp_module *exp2_pmod)
-{
-    uint32_t i;
-    const struct lys_module *mod1, *mod2;
-    const char *name1, *name2;
-    size_t name1_len, name2_len;
-
-    if (exp1->used != exp2->used) {
-        return 0;
-    }
-
-    for (i = 0; i < exp1->used; ++i) {
-        assert(exp1->tokens[i] == exp2->tokens[i]);
-
-        if (exp1->tokens[i] == LYXP_TOKEN_NAMETEST) {
-            /* check modules of all the nodes in the node ID */
-            mod1 = lys_schema_node_get_module(ctx, exp1->expr + exp1->tok_pos[i], exp1->tok_len[i], exp1_pmod,
-                    &name1, &name1_len);
-            assert(mod1);
-            mod2 = lys_schema_node_get_module(ctx, exp2->expr + exp2->tok_pos[i], exp2->tok_len[i], exp2_pmod,
-                    &name2, &name2_len);
-            assert(mod2);
-
-            /* compare modules */
-            if (mod1 != mod2) {
-                return 0;
-            }
-
-            /* compare names */
-            if ((name1_len != name2_len) || strncmp(name1, name2, name1_len)) {
-                return 0;
-            }
-        }
-    }
-
-    return 1;
-}
-
-/**
- * @brief Prepare any uses augments and refines in the context to be applied during uses descendant node compilation.
- *
- * @param[in] ctx Compile context.
- * @param[in] uses_p Parsed uses structure with augments and refines.
- * @param[in] ctx_node Context node of @p uses_p meaning its first data definiition parent.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_precompile_uses_augments_refines(struct lysc_ctx *ctx, struct lysp_node_uses *uses_p, const struct lysc_node *ctx_node)
-{
-    LY_ERR ret = LY_SUCCESS;
-    LY_ARRAY_COUNT_TYPE u;
-    struct lyxp_expr *exp = NULL;
-    struct lysc_augment *aug;
-    struct lysc_refine *rfn;
-    struct lysp_refine **new_rfn;
-    uint32_t i;
-
-    LY_ARRAY_FOR(uses_p->augments, u) {
-        lysc_update_path(ctx, NULL, "{augment}");
-        lysc_update_path(ctx, NULL, uses_p->augments[u].nodeid);
-
-        /* parse the nodeid */
-        LY_CHECK_GOTO(ret = lys_nodeid_check(ctx, uses_p->augments[u].nodeid, 0, NULL, &exp), cleanup);
-
-        /* allocate new compiled augment and store it in the set */
-        aug = calloc(1, sizeof *aug);
-        LY_CHECK_ERR_GOTO(!aug, LOGMEM(ctx->ctx); ret = LY_EMEM, cleanup);
-        LY_CHECK_GOTO(ret = ly_set_add(&ctx->uses_augs, aug, 1, NULL), cleanup);
-
-        aug->nodeid = exp;
-        exp = NULL;
-        aug->nodeid_pmod = ctx->pmod;
-        aug->nodeid_ctx_node = ctx_node;
-        aug->aug_p = &uses_p->augments[u];
-
-        lysc_update_path(ctx, NULL, NULL);
-        lysc_update_path(ctx, NULL, NULL);
-    }
-
-    LY_ARRAY_FOR(uses_p->refines, u) {
-        lysc_update_path(ctx, NULL, "{refine}");
-        lysc_update_path(ctx, NULL, uses_p->refines[u].nodeid);
-
-        /* parse the nodeid */
-        LY_CHECK_GOTO(ret = lys_nodeid_check(ctx, uses_p->refines[u].nodeid, 0, NULL, &exp), cleanup);
-
-        /* try to find the node in already compiled refines */
-        rfn = NULL;
-        for (i = 0; i < ctx->uses_rfns.count; ++i) {
-            if (lys_abs_schema_nodeid_match(ctx->ctx, exp, ctx->pmod, ((struct lysc_refine *)ctx->uses_rfns.objs[i])->nodeid,
-                    ctx->pmod)) {
-                rfn = ctx->uses_rfns.objs[i];
-                break;
-            }
-        }
-
-        if (!rfn) {
-            /* allocate new compiled refine */
-            rfn = calloc(1, sizeof *rfn);
-            LY_CHECK_ERR_GOTO(!rfn, LOGMEM(ctx->ctx); ret = LY_EMEM, cleanup);
-            LY_CHECK_GOTO(ret = ly_set_add(&ctx->uses_rfns, rfn, 1, NULL), cleanup);
-
-            rfn->nodeid = exp;
-            exp = NULL;
-            rfn->nodeid_pmod = ctx->pmod;
-            rfn->nodeid_ctx_node = ctx_node;
-        } else {
-            /* just free exp */
-            lyxp_expr_free(ctx->ctx, exp);
-            exp = NULL;
-        }
-
-        /* add new parsed refine structure */
-        LY_ARRAY_NEW_GOTO(ctx->ctx, rfn->rfns, new_rfn, ret, cleanup);
-        *new_rfn = &uses_p->refines[u];
-
-        lysc_update_path(ctx, NULL, NULL);
-        lysc_update_path(ctx, NULL, NULL);
-    }
-
-cleanup:
-    lyxp_expr_free(ctx->ctx, exp);
-    return ret;
-}
-
-/**
- * @brief Compile parsed uses statement - resolve target grouping and connect its content into parent.
- * If present, also apply uses's modificators.
- *
- * @param[in] ctx Compile context
- * @param[in] uses_p Parsed uses schema node.
- * @param[in] parent Compiled parent node where the content of the referenced grouping is supposed to be connected. It is
- * NULL for top-level nodes, in such a case the module where the node will be connected is taken from
- * the compile context.
- * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
- */
-static LY_ERR
-lys_compile_uses(struct lysc_ctx *ctx, struct lysp_node_uses *uses_p, struct lysc_node *parent, struct ly_set *child_set)
-{
-    struct lysp_node *pnode;
-    struct lysc_node *child;
-    struct lysp_grp *grp = NULL;
-    uint32_t i, grp_stack_count;
-    struct lysp_module *grp_mod, *mod_old = ctx->pmod;
-    LY_ERR ret = LY_SUCCESS;
-    struct lysc_when *when_shared = NULL;
-    LY_ARRAY_COUNT_TYPE u;
-    struct lysc_notif **notifs = NULL;
-    struct lysc_action **actions = NULL;
-    struct ly_set uses_child_set = {0};
-
-    /* find the referenced grouping */
-    LY_CHECK_RET(lys_compile_uses_find_grouping(ctx, uses_p, &grp, &grp_mod));
-
-    /* grouping must not reference themselves - stack in ctx maintains list of groupings currently being applied */
-    grp_stack_count = ctx->groupings.count;
-    LY_CHECK_RET(ly_set_add(&ctx->groupings, (void *)grp, 0, NULL));
-    if (grp_stack_count == ctx->groupings.count) {
-        /* the target grouping is already in the stack, so we are already inside it -> circular dependency */
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                "Grouping \"%s\" references itself through a uses statement.", grp->name);
-        return LY_EVALID;
-    }
-
-    /* check status */
-    ret = lysc_check_status(ctx, uses_p->flags, ctx->pmod, uses_p->name, grp->flags, grp_mod, grp->name);
-    LY_CHECK_GOTO(ret, cleanup);
-
-    /* compile any augments and refines so they can be applied during the grouping nodes compilation */
-    ret = lys_precompile_uses_augments_refines(ctx, uses_p, parent);
-    LY_CHECK_GOTO(ret, cleanup);
-
-    /* switch context's parsed module being processed */
-    ctx->pmod = grp_mod;
-
-    /* compile data nodes */
-    LY_LIST_FOR(grp->data, pnode) {
-        /* 0x3 in uses_status is a special bits combination to be able to detect status flags from uses */
-        ret = lys_compile_node(ctx, pnode, parent, (uses_p->flags & LYS_STATUS_MASK) | 0x3, &uses_child_set);
-        LY_CHECK_GOTO(ret, cleanup);
-    }
-
-    if (child_set) {
-        /* add these children to our compiled child_set as well since uses is a schema-only node */
-        LY_CHECK_GOTO(ret = ly_set_merge(child_set, &uses_child_set, 1, NULL), cleanup);
-    }
-
-    if (uses_p->when) {
-        /* pass uses's when to all the data children */
-        for (i = 0; i < uses_child_set.count; ++i) {
-            child = uses_child_set.snodes[i];
-
-            ret = lys_compile_when(ctx, uses_p->when, uses_p->flags, lysc_xpath_context(parent), child, &when_shared);
-            LY_CHECK_GOTO(ret, cleanup);
-        }
-    }
-
-    /* compile actions */
-    if (grp->actions) {
-        actions = parent ? lysc_node_actions_p(parent) : &ctx->cur_mod->compiled->rpcs;
-        if (!actions) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Invalid child %s \"%s\" of uses parent %s \"%s\" node.",
-                    grp->actions[0].name, lys_nodetype2str(grp->actions[0].nodetype), parent->name,
-                    lys_nodetype2str(parent->nodetype));
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-        COMPILE_OP_ARRAY_GOTO(ctx, grp->actions, *actions, parent, u, lys_compile_action, 0, ret, cleanup);
-
-        if (uses_p->when) {
-            /* inherit when */
-            LY_ARRAY_FOR(*actions, u) {
-                ret = lys_compile_when(ctx, uses_p->when, uses_p->flags, lysc_xpath_context(parent),
-                        (struct lysc_node *)&(*actions)[u], &when_shared);
-                LY_CHECK_GOTO(ret, cleanup);
-            }
-        }
-    }
-
-    /* compile notifications */
-    if (grp->notifs) {
-        notifs = parent ? lysc_node_notifs_p(parent) : &ctx->cur_mod->compiled->notifs;
-        if (!notifs) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Invalid child %s \"%s\" of uses parent %s \"%s\" node.",
-                    grp->notifs[0].name, lys_nodetype2str(grp->notifs[0].nodetype), parent->name,
-                    lys_nodetype2str(parent->nodetype));
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-        COMPILE_OP_ARRAY_GOTO(ctx, grp->notifs, *notifs, parent, u, lys_compile_notif, 0, ret, cleanup);
-
-        if (uses_p->when) {
-            /* inherit when */
-            LY_ARRAY_FOR(*notifs, u) {
-                ret = lys_compile_when(ctx, uses_p->when, uses_p->flags, lysc_xpath_context(parent),
-                        (struct lysc_node *)&(*notifs)[u], &when_shared);
-                LY_CHECK_GOTO(ret, cleanup);
-            }
-        }
-    }
-
-    /* check that all augments were applied */
-    for (i = 0; i < ctx->uses_augs.count; ++i) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                "Augment target node \"%s\" in grouping \"%s\" was not found.",
-                ((struct lysc_augment *)ctx->uses_augs.objs[i])->nodeid->expr, grp->name);
-        ret = LY_ENOTFOUND;
-    }
-    LY_CHECK_GOTO(ret, cleanup);
-
-    /* check that all refines were applied */
-    for (i = 0; i < ctx->uses_rfns.count; ++i) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                "Refine(s) target node \"%s\" in grouping \"%s\" was not found.",
-                ((struct lysc_refine *)ctx->uses_rfns.objs[i])->nodeid->expr, grp->name);
-        ret = LY_ENOTFOUND;
-    }
-    LY_CHECK_GOTO(ret, cleanup);
-
-cleanup:
-    /* reload previous context's parsed module being processed */
-    ctx->pmod = mod_old;
-
-    /* remove the grouping from the stack for circular groupings dependency check */
-    ly_set_rm_index(&ctx->groupings, ctx->groupings.count - 1, NULL);
-    assert(ctx->groupings.count == grp_stack_count);
-
-    ly_set_erase(&uses_child_set, NULL);
-    return ret;
-}
-
-static int
-lys_compile_grouping_pathlog(struct lysc_ctx *ctx, struct lysp_node *node, char **path)
-{
-    struct lysp_node *iter;
-    int len = 0;
-
-    *path = NULL;
-    for (iter = node; iter && len >= 0; iter = iter->parent) {
-        char *s = *path;
-        char *id;
-
-        switch (iter->nodetype) {
-        case LYS_USES:
-            LY_CHECK_RET(asprintf(&id, "{uses='%s'}", iter->name) == -1, -1);
-            break;
-        case LYS_GROUPING:
-            LY_CHECK_RET(asprintf(&id, "{grouping='%s'}", iter->name) == -1, -1);
-            break;
-        case LYS_AUGMENT:
-            LY_CHECK_RET(asprintf(&id, "{augment='%s'}", iter->name) == -1, -1);
-            break;
-        default:
-            id = strdup(iter->name);
-            break;
-        }
-
-        if (!iter->parent) {
-            /* print prefix */
-            len = asprintf(path, "/%s:%s%s", ctx->cur_mod->name, id, s ? s : "");
-        } else {
-            /* prefix is the same as in parent */
-            len = asprintf(path, "/%s%s", id, s ? s : "");
-        }
-        free(s);
-        free(id);
-    }
-
-    if (len < 0) {
-        free(*path);
-        *path = NULL;
-    } else if (len == 0) {
-        *path = strdup("/");
-        len = 1;
-    }
-    return len;
-}
-
-/**
- * @brief Validate groupings that were defined but not directly used in the schema itself.
- *
- * The grouping does not need to be compiled (and it is compiled here, but the result is forgotten immediately),
- * but to have the complete result of the schema validity, even such groupings are supposed to be checked.
- */
-static LY_ERR
-lys_compile_grouping(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysp_grp *grp)
-{
-    LY_ERR ret;
-    char *path;
-    int len;
-
-    struct lysp_node_uses fake_uses = {
-        .parent = pnode,
-        .nodetype = LYS_USES,
-        .flags = 0, .next = NULL,
-        .name = grp->name,
-        .dsc = NULL, .ref = NULL, .when = NULL, .iffeatures = NULL, .exts = NULL,
-        .refines = NULL, .augments = NULL
-    };
-    struct lysc_node_container fake_container = {
-        .nodetype = LYS_CONTAINER,
-        .flags = pnode ? (pnode->flags & LYS_FLAGS_COMPILED_MASK) : 0,
-        .module = ctx->cur_mod,
-        .sp = NULL, .parent = NULL, .next = NULL,
-        .prev = (struct lysc_node *)&fake_container,
-        .name = "fake",
-        .dsc = NULL, .ref = NULL, .exts = NULL, .iffeatures = NULL, .when = NULL,
-        .child = NULL, .musts = NULL, .actions = NULL, .notifs = NULL
-    };
-
-    if (grp->parent) {
-        LOGWRN(ctx->ctx, "Locally scoped grouping \"%s\" not used.", grp->name);
-    }
-
-    len = lys_compile_grouping_pathlog(ctx, grp->parent, &path);
-    if (len < 0) {
-        LOGMEM(ctx->ctx);
-        return LY_EMEM;
-    }
-    strncpy(ctx->path, path, LYSC_CTX_BUFSIZE - 1);
-    ctx->path_len = (uint32_t)len;
-    free(path);
-
-    lysc_update_path(ctx, NULL, "{grouping}");
-    lysc_update_path(ctx, NULL, grp->name);
-    ret = lys_compile_uses(ctx, &fake_uses, (struct lysc_node *)&fake_container, NULL);
-    lysc_update_path(ctx, NULL, NULL);
-    lysc_update_path(ctx, NULL, NULL);
-
-    ctx->path_len = 1;
-    ctx->path[1] = '\0';
-
-    /* cleanup */
-    lysc_node_container_free(ctx->ctx, &fake_container);
-
-    return ret;
-}
-
-/**
- * @brief Set config flags for a node.
- *
- * @param[in] ctx Compile context.
- * @param[in] node Compiled node config to set.
- * @param[in] parent Parent of @p node.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_config(struct lysc_ctx *ctx, struct lysc_node *node, struct lysc_node *parent)
-{
-    if (node->nodetype == LYS_CASE) {
-        /* case never has any config */
-        assert(!(node->flags & LYS_CONFIG_MASK));
-        return LY_SUCCESS;
-    }
-
-    /* adjust parent to always get the ancestor with config */
-    if (parent && (parent->nodetype == LYS_CASE)) {
-        parent = parent->parent;
-        assert(parent);
-    }
-
-    if (ctx->options & (LYS_COMPILE_RPC_INPUT | LYS_COMPILE_RPC_OUTPUT)) {
-        /* ignore config statements inside RPC/action data */
-        node->flags &= ~LYS_CONFIG_MASK;
-        node->flags |= (ctx->options & LYS_COMPILE_RPC_INPUT) ? LYS_CONFIG_W : LYS_CONFIG_R;
-    } else if (ctx->options & LYS_COMPILE_NOTIFICATION) {
-        /* ignore config statements inside Notification data */
-        node->flags &= ~LYS_CONFIG_MASK;
-        node->flags |= LYS_CONFIG_R;
-    } else if (!(node->flags & LYS_CONFIG_MASK)) {
-        /* config not explicitely set, inherit it from parent */
-        if (parent) {
-            node->flags |= parent->flags & LYS_CONFIG_MASK;
-        } else {
-            /* default is config true */
-            node->flags |= LYS_CONFIG_W;
-        }
-    } else {
-        /* config set explicitely */
-        node->flags |= LYS_SET_CONFIG;
-    }
-
-    if (parent && (parent->flags & LYS_CONFIG_R) && (node->flags & LYS_CONFIG_W)) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                "Configuration node cannot be child of any state data node.");
-        return LY_EVALID;
-    }
-
-    return LY_SUCCESS;
-}
-
-static LY_ERR
-lysp_ext_dup(const struct ly_ctx *ctx, struct lysp_ext_instance *ext, const struct lysp_ext_instance *orig_ext)
-{
-    LY_ERR ret = LY_SUCCESS;
-
-    *ext = *orig_ext;
-    DUP_STRING(ctx, orig_ext->name, ext->name, ret);
-    DUP_STRING(ctx, orig_ext->argument, ext->argument, ret);
-
-    return ret;
-}
-
-static LY_ERR
-lysp_restr_dup(const struct ly_ctx *ctx, struct lysp_restr *restr, const struct lysp_restr *orig_restr)
-{
-    LY_ERR ret = LY_SUCCESS;
-
-    if (orig_restr) {
-        DUP_STRING(ctx, orig_restr->arg.str, restr->arg.str, ret);
-        restr->arg.mod = orig_restr->arg.mod;
-        DUP_STRING(ctx, orig_restr->emsg, restr->emsg, ret);
-        DUP_STRING(ctx, orig_restr->eapptag, restr->eapptag, ret);
-        DUP_STRING(ctx, orig_restr->dsc, restr->dsc, ret);
-        DUP_STRING(ctx, orig_restr->ref, restr->ref, ret);
-        DUP_ARRAY(ctx, orig_restr->exts, restr->exts, lysp_ext_dup);
-    }
-
-    return ret;
-}
-
-static LY_ERR
-lysp_string_dup(const struct ly_ctx *ctx, const char **str, const char **orig_str)
-{
-    LY_ERR ret = LY_SUCCESS;
-
-    DUP_STRING(ctx, *orig_str, *str, ret);
-
-    return ret;
-}
-
-static LY_ERR
-lysp_qname_dup(const struct ly_ctx *ctx, struct lysp_qname *qname, const struct lysp_qname *orig_qname)
-{
-    LY_ERR ret = LY_SUCCESS;
-
-    if (!orig_qname->str) {
-        return LY_SUCCESS;
-    }
-
-    DUP_STRING(ctx, orig_qname->str, qname->str, ret);
-    assert(orig_qname->mod);
-    qname->mod = orig_qname->mod;
-
-    return ret;
-}
-
-static LY_ERR
-lysp_type_enum_dup(const struct ly_ctx *ctx, struct lysp_type_enum *enm, const struct lysp_type_enum *orig_enm)
-{
-    LY_ERR ret = LY_SUCCESS;
-
-    DUP_STRING(ctx, orig_enm->name, enm->name, ret);
-    DUP_STRING(ctx, orig_enm->dsc, enm->dsc, ret);
-    DUP_STRING(ctx, orig_enm->ref, enm->ref, ret);
-    enm->value = orig_enm->value;
-    DUP_ARRAY(ctx, orig_enm->iffeatures, enm->iffeatures, lysp_qname_dup);
-    DUP_ARRAY(ctx, orig_enm->exts, enm->exts, lysp_ext_dup);
-    enm->flags = orig_enm->flags;
-
-    return ret;
-}
-
-static LY_ERR
-lysp_type_dup(const struct ly_ctx *ctx, struct lysp_type *type, const struct lysp_type *orig_type)
-{
-    LY_ERR ret = LY_SUCCESS;
-
-    DUP_STRING_GOTO(ctx, orig_type->name, type->name, ret, done);
-
-    if (orig_type->range) {
-        type->range = calloc(1, sizeof *type->range);
-        LY_CHECK_ERR_RET(!type->range, LOGMEM(ctx), LY_EMEM);
-        LY_CHECK_RET(lysp_restr_dup(ctx, type->range, orig_type->range));
-    }
-
-    if (orig_type->length) {
-        type->length = calloc(1, sizeof *type->length);
-        LY_CHECK_ERR_RET(!type->length, LOGMEM(ctx), LY_EMEM);
-        LY_CHECK_RET(lysp_restr_dup(ctx, type->length, orig_type->length));
-    }
-
-    DUP_ARRAY(ctx, orig_type->patterns, type->patterns, lysp_restr_dup);
-    DUP_ARRAY(ctx, orig_type->enums, type->enums, lysp_type_enum_dup);
-    DUP_ARRAY(ctx, orig_type->bits, type->bits, lysp_type_enum_dup);
-    LY_CHECK_GOTO(ret = lyxp_expr_dup(ctx, orig_type->path, &type->path), done);
-    DUP_ARRAY(ctx, orig_type->bases, type->bases, lysp_string_dup);
-    DUP_ARRAY(ctx, orig_type->types, type->types, lysp_type_dup);
-    DUP_ARRAY(ctx, orig_type->exts, type->exts, lysp_ext_dup);
-
-    type->pmod = orig_type->pmod;
-    type->compiled = orig_type->compiled;
-
-    type->fraction_digits = orig_type->fraction_digits;
-    type->require_instance = orig_type->require_instance;
-    type->flags = orig_type->flags;
-
-done:
-    return ret;
-}
-
-static LY_ERR
-lysp_when_dup(const struct ly_ctx *ctx, struct lysp_when *when, const struct lysp_when *orig_when)
-{
-    LY_ERR ret = LY_SUCCESS;
-
-    DUP_STRING(ctx, orig_when->cond, when->cond, ret);
-    DUP_STRING(ctx, orig_when->dsc, when->dsc, ret);
-    DUP_STRING(ctx, orig_when->ref, when->ref, ret);
-    DUP_ARRAY(ctx, orig_when->exts, when->exts, lysp_ext_dup);
-
-    return ret;
-}
-
-static LY_ERR
-lysp_node_common_dup(const struct ly_ctx *ctx, struct lysp_node *node, const struct lysp_node *orig)
-{
-    LY_ERR ret = LY_SUCCESS;
-
-    node->parent = NULL;
-    node->nodetype = orig->nodetype;
-    node->flags = orig->flags;
-    node->next = NULL;
-    DUP_STRING(ctx, orig->name, node->name, ret);
-    DUP_STRING(ctx, orig->dsc, node->dsc, ret);
-    DUP_STRING(ctx, orig->ref, node->ref, ret);
-
-    if (orig->when) {
-        node->when = calloc(1, sizeof *node->when);
-        LY_CHECK_ERR_RET(!node->when, LOGMEM(ctx), LY_EMEM);
-        LY_CHECK_RET(lysp_when_dup(ctx, node->when, orig->when));
-    }
-
-    DUP_ARRAY(ctx, orig->iffeatures, node->iffeatures, lysp_qname_dup);
-    DUP_ARRAY(ctx, orig->exts, node->exts, lysp_ext_dup);
-
-    return ret;
-}
-
-static LY_ERR
-lysp_node_dup(const struct ly_ctx *ctx, struct lysp_node *node, const struct lysp_node *orig)
-{
-    LY_ERR ret = LY_SUCCESS;
-    struct lysp_node_container *cont;
-    const struct lysp_node_container *orig_cont;
-    struct lysp_node_leaf *leaf;
-    const struct lysp_node_leaf *orig_leaf;
-    struct lysp_node_leaflist *llist;
-    const struct lysp_node_leaflist *orig_llist;
-    struct lysp_node_list *list;
-    const struct lysp_node_list *orig_list;
-    struct lysp_node_choice *choice;
-    const struct lysp_node_choice *orig_choice;
-    struct lysp_node_case *cas;
-    const struct lysp_node_case *orig_cas;
-    struct lysp_node_anydata *any;
-    const struct lysp_node_anydata *orig_any;
-
-    assert(orig->nodetype & (LYS_CONTAINER | LYS_LEAF | LYS_LEAFLIST | LYS_LIST | LYS_CHOICE | LYS_CASE | LYS_ANYDATA));
-
-    /* common part */
-    LY_CHECK_RET(lysp_node_common_dup(ctx, node, orig));
-
-    /* specific part */
-    switch (node->nodetype) {
-    case LYS_CONTAINER:
-        cont = (struct lysp_node_container *)node;
-        orig_cont = (const struct lysp_node_container *)orig;
-
-        DUP_ARRAY(ctx, orig_cont->musts, cont->musts, lysp_restr_dup);
-        DUP_STRING(ctx, orig_cont->presence, cont->presence, ret);
-        /* we do not need the rest */
-        break;
-    case LYS_LEAF:
-        leaf = (struct lysp_node_leaf *)node;
-        orig_leaf = (const struct lysp_node_leaf *)orig;
-
-        DUP_ARRAY(ctx, orig_leaf->musts, leaf->musts, lysp_restr_dup);
-        LY_CHECK_RET(lysp_type_dup(ctx, &leaf->type, &orig_leaf->type));
-        DUP_STRING(ctx, orig_leaf->units, leaf->units, ret);
-        LY_CHECK_RET(lysp_qname_dup(ctx, &leaf->dflt, &orig_leaf->dflt));
-        break;
-    case LYS_LEAFLIST:
-        llist = (struct lysp_node_leaflist *)node;
-        orig_llist = (const struct lysp_node_leaflist *)orig;
-
-        DUP_ARRAY(ctx, orig_llist->musts, llist->musts, lysp_restr_dup);
-        LY_CHECK_RET(lysp_type_dup(ctx, &llist->type, &orig_llist->type));
-        DUP_STRING(ctx, orig_llist->units, llist->units, ret);
-        DUP_ARRAY(ctx, orig_llist->dflts, llist->dflts, lysp_qname_dup);
-        llist->min = orig_llist->min;
-        llist->max = orig_llist->max;
-        break;
-    case LYS_LIST:
-        list = (struct lysp_node_list *)node;
-        orig_list = (const struct lysp_node_list *)orig;
-
-        DUP_ARRAY(ctx, orig_list->musts, list->musts, lysp_restr_dup);
-        DUP_STRING(ctx, orig_list->key, list->key, ret);
-        /* we do not need these arrays */
-        DUP_ARRAY(ctx, orig_list->uniques, list->uniques, lysp_qname_dup);
-        list->min = orig_list->min;
-        list->max = orig_list->max;
-        break;
-    case LYS_CHOICE:
-        choice = (struct lysp_node_choice *)node;
-        orig_choice = (const struct lysp_node_choice *)orig;
-
-        /* we do not need children */
-        LY_CHECK_RET(lysp_qname_dup(ctx, &choice->dflt, &orig_choice->dflt));
-        break;
-    case LYS_CASE:
-        cas = (struct lysp_node_case *)node;
-        orig_cas = (const struct lysp_node_case *)orig;
-
-        /* we do not need children */
-        (void)cas;
-        (void)orig_cas;
-        break;
-    case LYS_ANYDATA:
-    case LYS_ANYXML:
-        any = (struct lysp_node_anydata *)node;
-        orig_any = (const struct lysp_node_anydata *)orig;
-
-        DUP_ARRAY(ctx, orig_any->musts, any->musts, lysp_restr_dup);
-        break;
-    default:
-        LOGINT_RET(ctx);
-    }
-
-    return ret;
-}
-
-static LY_ERR
-lysp_action_inout_dup(const struct ly_ctx *ctx, struct lysp_action_inout *inout, const struct lysp_action_inout *orig)
-{
-    inout->parent = NULL;
-    inout->nodetype = orig->nodetype;
-    DUP_ARRAY(ctx, orig->musts, inout->musts, lysp_restr_dup);
-    /* we dot need these arrays */
-    DUP_ARRAY(ctx, orig->exts, inout->exts, lysp_ext_dup);
-
-    return LY_SUCCESS;
-}
-
-static LY_ERR
-lysp_action_dup(const struct ly_ctx *ctx, struct lysp_action *act, const struct lysp_action *orig)
-{
-    LY_ERR ret = LY_SUCCESS;
-
-    act->parent = NULL;
-    act->nodetype = orig->nodetype;
-    act->flags = orig->flags;
-    DUP_STRING(ctx, orig->name, act->name, ret);
-    DUP_STRING(ctx, orig->dsc, act->dsc, ret);
-    DUP_STRING(ctx, orig->ref, act->ref, ret);
-    DUP_ARRAY(ctx, orig->iffeatures, act->iffeatures, lysp_qname_dup);
-
-    act->input.nodetype = orig->input.nodetype;
-    act->output.nodetype = orig->output.nodetype;
-    /* we do not need choldren of in/out */
-    DUP_ARRAY(ctx, orig->exts, act->exts, lysp_ext_dup);
-
-    return ret;
-}
-
-static LY_ERR
-lysp_notif_dup(const struct ly_ctx *ctx, struct lysp_notif *notif, const struct lysp_notif *orig)
-{
-    LY_ERR ret = LY_SUCCESS;
-
-    notif->parent = NULL;
-    notif->nodetype = orig->nodetype;
-    notif->flags = orig->flags;
-    DUP_STRING(ctx, orig->name, notif->name, ret);
-    DUP_STRING(ctx, orig->dsc, notif->dsc, ret);
-    DUP_STRING(ctx, orig->ref, notif->ref, ret);
-    DUP_ARRAY(ctx, orig->iffeatures, notif->iffeatures, lysp_qname_dup);
-    DUP_ARRAY(ctx, orig->musts, notif->musts, lysp_restr_dup);
-    /* we do not need these arrays */
-    DUP_ARRAY(ctx, orig->exts, notif->exts, lysp_ext_dup);
-
-    return ret;
-}
-
-/**
- * @brief Duplicate a single parsed node. Only attributes that are used in compilation are copied.
- *
- * @param[in] ctx libyang context.
- * @param[in] pnode Node to duplicate.
- * @param[in] with_links Whether to also copy any links (child, parent pointers).
- * @param[out] dup_p Duplicated parsed node.
- * @return LY_ERR value.
- */
-static LY_ERR
-lysp_dup_single(const struct ly_ctx *ctx, const struct lysp_node *pnode, ly_bool with_links, struct lysp_node **dup_p)
-{
-    LY_ERR ret = LY_SUCCESS;
-    void *mem = NULL;
-
-    if (!pnode) {
-        *dup_p = NULL;
-        return LY_SUCCESS;
-    }
-
-    switch (pnode->nodetype) {
-    case LYS_CONTAINER:
-        mem = calloc(1, sizeof(struct lysp_node_container));
-        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
-        LY_CHECK_GOTO(ret = lysp_node_dup(ctx, mem, pnode), cleanup);
-        break;
-    case LYS_LEAF:
-        mem = calloc(1, sizeof(struct lysp_node_leaf));
-        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
-        LY_CHECK_GOTO(ret = lysp_node_dup(ctx, mem, pnode), cleanup);
-        break;
-    case LYS_LEAFLIST:
-        mem = calloc(1, sizeof(struct lysp_node_leaflist));
-        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
-        LY_CHECK_GOTO(ret = lysp_node_dup(ctx, mem, pnode), cleanup);
-        break;
-    case LYS_LIST:
-        mem = calloc(1, sizeof(struct lysp_node_list));
-        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
-        LY_CHECK_GOTO(ret = lysp_node_dup(ctx, mem, pnode), cleanup);
-        break;
-    case LYS_CHOICE:
-        mem = calloc(1, sizeof(struct lysp_node_choice));
-        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
-        LY_CHECK_GOTO(ret = lysp_node_dup(ctx, mem, pnode), cleanup);
-        break;
-    case LYS_CASE:
-        mem = calloc(1, sizeof(struct lysp_node_case));
-        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
-        LY_CHECK_GOTO(ret = lysp_node_dup(ctx, mem, pnode), cleanup);
-        break;
-    case LYS_ANYDATA:
-    case LYS_ANYXML:
-        mem = calloc(1, sizeof(struct lysp_node_anydata));
-        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
-        LY_CHECK_GOTO(ret = lysp_node_dup(ctx, mem, pnode), cleanup);
-        break;
-    case LYS_INPUT:
-    case LYS_OUTPUT:
-        mem = calloc(1, sizeof(struct lysp_action_inout));
-        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
-        LY_CHECK_GOTO(ret = lysp_action_inout_dup(ctx, mem, (struct lysp_action_inout *)pnode), cleanup);
-        break;
-    case LYS_ACTION:
-    case LYS_RPC:
-        mem = calloc(1, sizeof(struct lysp_action));
-        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
-        LY_CHECK_GOTO(ret = lysp_action_dup(ctx, mem, (struct lysp_action *)pnode), cleanup);
-        break;
-    case LYS_NOTIF:
-        mem = calloc(1, sizeof(struct lysp_notif));
-        LY_CHECK_ERR_GOTO(!mem, LOGMEM(ctx); ret = LY_EMEM, cleanup);
-        LY_CHECK_GOTO(ret = lysp_notif_dup(ctx, mem, (struct lysp_notif *)pnode), cleanup);
-        break;
-    default:
-        LOGINT_RET(ctx);
-    }
-
-    if (with_links) {
-        /* copy also parent and child pointers */
-        ((struct lysp_node *)mem)->parent = pnode->parent;
-        switch (pnode->nodetype) {
-        case LYS_CONTAINER:
-            ((struct lysp_node_container *)mem)->child = ((struct lysp_node_container *)pnode)->child;
-            break;
-        case LYS_LIST:
-            ((struct lysp_node_list *)mem)->child = ((struct lysp_node_list *)pnode)->child;
-            break;
-        case LYS_CHOICE:
-            ((struct lysp_node_choice *)mem)->child = ((struct lysp_node_choice *)pnode)->child;
-            break;
-        case LYS_CASE:
-            ((struct lysp_node_case *)mem)->child = ((struct lysp_node_case *)pnode)->child;
-            break;
-        default:
-            break;
-        }
-    }
-
-cleanup:
-    if (ret) {
-        free(mem);
-    } else {
-        *dup_p = mem;
-    }
-    return ret;
-}
-
-#define AMEND_WRONG_NODETYPE(AMEND_STR, OP_STR, PROPERTY) \
-    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Invalid %s of %s node - it is not possible to %s \"%s\" property.", \
-            AMEND_STR, lys_nodetype2str(target->nodetype), OP_STR, PROPERTY);\
-    ret = LY_EVALID; \
-    goto cleanup;
-
-#define AMEND_CHECK_CARDINALITY(ARRAY, MAX, AMEND_STR, PROPERTY) \
-    if (LY_ARRAY_COUNT(ARRAY) > MAX) { \
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Invalid %s of %s with too many (%"LY_PRI_ARRAY_COUNT_TYPE") %s properties.", \
-               AMEND_STR, lys_nodetype2str(target->nodetype), LY_ARRAY_COUNT(ARRAY), PROPERTY); \
-        ret = LY_EVALID; \
-        goto cleanup; \
-    }
-
-/**
- * @brief Apply refine.
- *
- * @param[in] ctx Compile context.
- * @param[in] rfn Refine to apply.
- * @param[in,out] target Refine target.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_apply_refine(struct lysc_ctx *ctx, struct lysp_refine *rfn, struct lysp_node *target)
-{
-    LY_ERR ret = LY_SUCCESS;
-    LY_ARRAY_COUNT_TYPE u;
-    struct lysp_qname *qname;
-    struct lysp_restr **musts, *must;
-    uint32_t *num;
-
-    /* default value */
-    if (rfn->dflts) {
-        switch (target->nodetype) {
-        case LYS_LEAF:
-            AMEND_CHECK_CARDINALITY(rfn->dflts, 1, "refine", "default");
-
-            FREE_STRING(ctx->ctx, ((struct lysp_node_leaf *)target)->dflt.str);
-            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, &((struct lysp_node_leaf *)target)->dflt, &rfn->dflts[0]), cleanup);
-            break;
-        case LYS_LEAFLIST:
-            if (rfn->dflts[0].mod->version < LYS_VERSION_1_1) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                        "Invalid refine of default in leaf-list - the default statement is allowed only in YANG 1.1 modules.");
-                ret = LY_EVALID;
-                goto cleanup;
-            }
-
-            FREE_ARRAY(ctx->ctx, ((struct lysp_node_leaflist *)target)->dflts, lysp_qname_free);
-            ((struct lysp_node_leaflist *)target)->dflts = NULL;
-            LY_ARRAY_FOR(rfn->dflts, u) {
-                LY_ARRAY_NEW_GOTO(ctx->ctx, ((struct lysp_node_leaflist *)target)->dflts, qname, ret, cleanup);
-                LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, qname, &rfn->dflts[u]), cleanup);
-            }
-            break;
-        case LYS_CHOICE:
-            AMEND_CHECK_CARDINALITY(rfn->dflts, 1, "refine", "default");
-
-            FREE_STRING(ctx->ctx, ((struct lysp_node_choice *)target)->dflt.str);
-            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, &((struct lysp_node_choice *)target)->dflt, &rfn->dflts[0]), cleanup);
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("refine", "replace", "default");
-        }
-    }
-
-    /* description */
-    if (rfn->dsc) {
-        FREE_STRING(ctx->ctx, target->dsc);
-        DUP_STRING_GOTO(ctx->ctx, rfn->dsc, target->dsc, ret, cleanup);
-    }
-
-    /* reference */
-    if (rfn->ref) {
-        FREE_STRING(ctx->ctx, target->ref);
-        DUP_STRING_GOTO(ctx->ctx, rfn->ref, target->ref, ret, cleanup);
-    }
-
-    /* config */
-    if (rfn->flags & LYS_CONFIG_MASK) {
-        if (ctx->options & (LYS_COMPILE_NOTIFICATION | LYS_COMPILE_RPC_INPUT | LYS_COMPILE_RPC_OUTPUT)) {
-            LOGWRN(ctx->ctx, "Refining config inside %s has no effect (%s).",
-                    ctx->options & LYS_COMPILE_NOTIFICATION ? "notification" : "RPC/action", ctx->path);
-        } else {
-            target->flags &= ~LYS_CONFIG_MASK;
-            target->flags |= rfn->flags & LYS_CONFIG_MASK;
-        }
-    }
-
-    /* mandatory */
-    if (rfn->flags & LYS_MAND_MASK) {
-        switch (target->nodetype) {
-        case LYS_LEAF:
-        case LYS_CHOICE:
-        case LYS_ANYDATA:
-        case LYS_ANYXML:
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("refine", "replace", "mandatory");
-        }
-
-        target->flags &= ~LYS_MAND_MASK;
-        target->flags |= rfn->flags & LYS_MAND_MASK;
-    }
-
-    /* presence */
-    if (rfn->presence) {
-        switch (target->nodetype) {
-        case LYS_CONTAINER:
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("refine", "replace", "presence");
-        }
-
-        FREE_STRING(ctx->ctx, ((struct lysp_node_container *)target)->presence);
-        DUP_STRING_GOTO(ctx->ctx, rfn->presence, ((struct lysp_node_container *)target)->presence, ret, cleanup);
-    }
-
-    /* must */
-    if (rfn->musts) {
-        switch (target->nodetype) {
-        case LYS_CONTAINER:
-        case LYS_LIST:
-        case LYS_LEAF:
-        case LYS_LEAFLIST:
-        case LYS_ANYDATA:
-        case LYS_ANYXML:
-            musts = &((struct lysp_node_container *)target)->musts;
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("refine", "add", "must");
-        }
-
-        LY_ARRAY_FOR(rfn->musts, u) {
-            LY_ARRAY_NEW_GOTO(ctx->ctx, *musts, must, ret, cleanup);
-            LY_CHECK_GOTO(ret = lysp_restr_dup(ctx->ctx, must, &rfn->musts[u]), cleanup);
-        }
-    }
-
-    /* min-elements */
-    if (rfn->flags & LYS_SET_MIN) {
-        switch (target->nodetype) {
-        case LYS_LEAFLIST:
-            num = &((struct lysp_node_leaflist *)target)->min;
-            break;
-        case LYS_LIST:
-            num = &((struct lysp_node_list *)target)->min;
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("refine", "replace", "min-elements");
-        }
-
-        *num = rfn->min;
-    }
-
-    /* max-elements */
-    if (rfn->flags & LYS_SET_MAX) {
-        switch (target->nodetype) {
-        case LYS_LEAFLIST:
-            num = &((struct lysp_node_leaflist *)target)->max;
-            break;
-        case LYS_LIST:
-            num = &((struct lysp_node_list *)target)->max;
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("refine", "replace", "max-elements");
-        }
-
-        *num = rfn->max;
-    }
-
-    /* if-feature */
-    if (rfn->iffeatures) {
-        switch (target->nodetype) {
-        case LYS_LEAF:
-        case LYS_LEAFLIST:
-        case LYS_LIST:
-        case LYS_CONTAINER:
-        case LYS_CHOICE:
-        case LYS_CASE:
-        case LYS_ANYDATA:
-        case LYS_ANYXML:
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("refine", "add", "if-feature");
-        }
-
-        LY_ARRAY_FOR(rfn->iffeatures, u) {
-            LY_ARRAY_NEW_GOTO(ctx->ctx, target->iffeatures, qname, ret, cleanup);
-            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, qname, &rfn->iffeatures[u]), cleanup);
-        }
-    }
-
-    /* extension */
-    /* TODO refine extensions */
-
-cleanup:
-    return ret;
-}
-
-/**
- * @brief Apply deviate add.
- *
- * @param[in] ctx Compile context.
- * @param[in] d Deviate add to apply.
- * @param[in,out] target Deviation target.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_apply_deviate_add(struct lysc_ctx *ctx, struct lysp_deviate_add *d, struct lysp_node *target)
-{
-    LY_ERR ret = LY_SUCCESS;
-    LY_ARRAY_COUNT_TYPE u;
-    struct lysp_qname *qname;
-    uint32_t *num;
-    struct lysp_restr **musts, *must;
-
-#define DEV_CHECK_NONPRESENCE(TYPE, MEMBER, PROPERTY, VALUEMEMBER) \
-    if (((TYPE)target)->MEMBER) { \
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
-                "Invalid deviation adding \"%s\" property which already exists (with value \"%s\").", \
-                PROPERTY, ((TYPE)target)->VALUEMEMBER); \
-        ret = LY_EVALID; \
-        goto cleanup; \
-    }
-
-    /* [units-stmt] */
-    if (d->units) {
-        switch (target->nodetype) {
-        case LYS_LEAF:
-        case LYS_LEAFLIST:
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "add", "units");
-        }
-
-        DEV_CHECK_NONPRESENCE(struct lysp_node_leaf *, units, "units", units);
-        DUP_STRING_GOTO(ctx->ctx, d->units, ((struct lysp_node_leaf *)target)->units, ret, cleanup);
-    }
-
-    /* *must-stmt */
-    if (d->musts) {
-        switch (target->nodetype) {
-        case LYS_CONTAINER:
-        case LYS_LIST:
-        case LYS_LEAF:
-        case LYS_LEAFLIST:
-        case LYS_ANYDATA:
-        case LYS_ANYXML:
-            musts = &((struct lysp_node_container *)target)->musts;
-            break;
-        case LYS_NOTIF:
-            musts = &((struct lysp_notif *)target)->musts;
-            break;
-        case LYS_INPUT:
-        case LYS_OUTPUT:
-            musts = &((struct lysp_action_inout *)target)->musts;
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "add", "must");
-        }
-
-        LY_ARRAY_FOR(d->musts, u) {
-            LY_ARRAY_NEW_GOTO(ctx->ctx, *musts, must, ret, cleanup);
-            LY_CHECK_GOTO(ret = lysp_restr_dup(ctx->ctx, must, &d->musts[u]), cleanup);
-        }
-    }
-
-    /* *unique-stmt */
-    if (d->uniques) {
-        switch (target->nodetype) {
-        case LYS_LIST:
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "add", "unique");
-        }
-
-        LY_ARRAY_FOR(d->uniques, u) {
-            LY_ARRAY_NEW_GOTO(ctx->ctx, ((struct lysp_node_list *)target)->uniques, qname, ret, cleanup);
-            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, qname, &d->uniques[u]), cleanup);
-        }
-    }
-
-    /* *default-stmt */
-    if (d->dflts) {
-        switch (target->nodetype) {
-        case LYS_LEAF:
-            AMEND_CHECK_CARDINALITY(d->dflts, 1, "deviation", "default");
-            DEV_CHECK_NONPRESENCE(struct lysp_node_leaf *, dflt.str, "default", dflt.str);
-
-            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, &((struct lysp_node_leaf *)target)->dflt, &d->dflts[0]), cleanup);
-            break;
-        case LYS_LEAFLIST:
-            LY_ARRAY_FOR(d->dflts, u) {
-                LY_ARRAY_NEW_GOTO(ctx->ctx, ((struct lysp_node_leaflist *)target)->dflts, qname, ret, cleanup);
-                LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, qname, &d->dflts[u]), cleanup);
-            }
-            break;
-        case LYS_CHOICE:
-            AMEND_CHECK_CARDINALITY(d->dflts, 1, "deviation", "default");
-            DEV_CHECK_NONPRESENCE(struct lysp_node_choice *, dflt.str, "default", dflt.str);
-
-            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, &((struct lysp_node_choice *)target)->dflt, &d->dflts[0]), cleanup);
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "add", "default");
-        }
-    }
-
-    /* [config-stmt] */
-    if (d->flags & LYS_CONFIG_MASK) {
-        switch (target->nodetype) {
-        case LYS_CONTAINER:
-        case LYS_LEAF:
-        case LYS_LEAFLIST:
-        case LYS_LIST:
-        case LYS_CHOICE:
-        case LYS_ANYDATA:
-        case LYS_ANYXML:
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "add", "config");
-        }
-
-        if (target->flags & LYS_CONFIG_MASK) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid deviation adding \"config\" property which already exists (with value \"config %s\").",
-                    target->flags & LYS_CONFIG_W ? "true" : "false");
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-
-        target->flags |= d->flags & LYS_CONFIG_MASK;
-    }
-
-    /* [mandatory-stmt] */
-    if (d->flags & LYS_MAND_MASK) {
-        switch (target->nodetype) {
-        case LYS_LEAF:
-        case LYS_CHOICE:
-        case LYS_ANYDATA:
-        case LYS_ANYXML:
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "add", "mandatory");
-        }
-
-        if (target->flags & LYS_MAND_MASK) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid deviation adding \"mandatory\" property which already exists (with value \"mandatory %s\").",
-                    target->flags & LYS_MAND_TRUE ? "true" : "false");
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-
-        target->flags |= d->flags & LYS_MAND_MASK;
-    }
-
-    /* [min-elements-stmt] */
-    if (d->flags & LYS_SET_MIN) {
-        switch (target->nodetype) {
-        case LYS_LEAFLIST:
-            num = &((struct lysp_node_leaflist *)target)->min;
-            break;
-        case LYS_LIST:
-            num = &((struct lysp_node_list *)target)->min;
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "add", "min-elements");
-        }
-
-        if (target->flags & LYS_SET_MIN) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid deviation adding \"min-elements\" property which already exists (with value \"%u\").", *num);
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-
-        *num = d->min;
-    }
-
-    /* [max-elements-stmt] */
-    if (d->flags & LYS_SET_MAX) {
-        switch (target->nodetype) {
-        case LYS_LEAFLIST:
-            num = &((struct lysp_node_leaflist *)target)->max;
-            break;
-        case LYS_LIST:
-            num = &((struct lysp_node_list *)target)->max;
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "add", "max-elements");
-        }
-
-        if (target->flags & LYS_SET_MAX) {
-            if (*num) {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                        "Invalid deviation adding \"max-elements\" property which already exists (with value \"%u\").",
-                        *num);
-            } else {
-                LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                        "Invalid deviation adding \"max-elements\" property which already exists (with value \"unbounded\").");
-            }
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-
-        *num = d->max;
-    }
-
-cleanup:
-    return ret;
-}
-
-/**
- * @brief Apply deviate delete.
- *
- * @param[in] ctx Compile context.
- * @param[in] d Deviate delete to apply.
- * @param[in,out] target Deviation target.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_apply_deviate_delete(struct lysc_ctx *ctx, struct lysp_deviate_del *d, struct lysp_node *target)
-{
-    LY_ERR ret = LY_SUCCESS;
-    struct lysp_restr **musts;
-    LY_ARRAY_COUNT_TYPE u, v;
-    struct lysp_qname **uniques, **dflts;
-
-#define DEV_DEL_ARRAY(DEV_ARRAY, ORIG_ARRAY, DEV_MEMBER, ORIG_MEMBER, FREE_FUNC, PROPERTY) \
-    LY_ARRAY_FOR(d->DEV_ARRAY, u) { \
-        int found = 0; \
-        LY_ARRAY_FOR(ORIG_ARRAY, v) { \
-            if (!strcmp(d->DEV_ARRAY[u]DEV_MEMBER, (ORIG_ARRAY)[v]ORIG_MEMBER)) { \
-                found = 1; \
-                break; \
-            } \
-        } \
-        if (!found) { \
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
-                    "Invalid deviation deleting \"%s\" property \"%s\" which does not match any of the target's property values.", \
-                    PROPERTY, d->DEV_ARRAY[u]DEV_MEMBER); \
-            ret = LY_EVALID; \
-            goto cleanup; \
-        } \
-        LY_ARRAY_DECREMENT(ORIG_ARRAY); \
-        FREE_FUNC(ctx->ctx, &(ORIG_ARRAY)[v]); \
-        memmove(&(ORIG_ARRAY)[v], &(ORIG_ARRAY)[v + 1], (LY_ARRAY_COUNT(ORIG_ARRAY) - v) * sizeof *(ORIG_ARRAY)); \
-    } \
-    if (!LY_ARRAY_COUNT(ORIG_ARRAY)) { \
-        LY_ARRAY_FREE(ORIG_ARRAY); \
-        ORIG_ARRAY = NULL; \
-    }
-
-#define DEV_CHECK_PRESENCE_VALUE(TYPE, MEMBER, DEVTYPE, PROPERTY, VALUE) \
-    if (!((TYPE)target)->MEMBER) { \
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NOT_PRESENT, DEVTYPE, PROPERTY, VALUE); \
-        ret = LY_EVALID; \
-        goto cleanup; \
-    } else if (strcmp(((TYPE)target)->MEMBER, VALUE)) { \
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
-                "Invalid deviation deleting \"%s\" property \"%s\" which does not match the target's property value \"%s\".", \
-                PROPERTY, VALUE, ((TYPE)target)->MEMBER); \
-        ret = LY_EVALID; \
-        goto cleanup; \
-    }
-
-    /* [units-stmt] */
-    if (d->units) {
-        switch (target->nodetype) {
-        case LYS_LEAF:
-        case LYS_LEAFLIST:
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "delete", "units");
-        }
-
-        DEV_CHECK_PRESENCE_VALUE(struct lysp_node_leaf *, units, "deleting", "units", d->units);
-        FREE_STRING(ctx->ctx, ((struct lysp_node_leaf *)target)->units);
-        ((struct lysp_node_leaf *)target)->units = NULL;
-    }
-
-    /* *must-stmt */
-    if (d->musts) {
-        switch (target->nodetype) {
-        case LYS_CONTAINER:
-        case LYS_LIST:
-        case LYS_LEAF:
-        case LYS_LEAFLIST:
-        case LYS_ANYDATA:
-        case LYS_ANYXML:
-            musts = &((struct lysp_node_container *)target)->musts;
-            break;
-        case LYS_NOTIF:
-            musts = &((struct lysp_notif *)target)->musts;
-            break;
-        case LYS_INPUT:
-        case LYS_OUTPUT:
-            musts = &((struct lysp_action_inout *)target)->musts;
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "delete", "must");
-        }
-
-        DEV_DEL_ARRAY(musts, *musts, .arg.str, .arg.str, lysp_restr_free, "must");
-    }
-
-    /* *unique-stmt */
-    if (d->uniques) {
-        switch (target->nodetype) {
-        case LYS_LIST:
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "delete", "unique");
-        }
-
-        uniques = &((struct lysp_node_list *)target)->uniques;
-        DEV_DEL_ARRAY(uniques, *uniques, .str, .str, lysp_qname_free, "unique");
-    }
-
-    /* *default-stmt */
-    if (d->dflts) {
-        switch (target->nodetype) {
-        case LYS_LEAF:
-            AMEND_CHECK_CARDINALITY(d->dflts, 1, "deviation", "default");
-            DEV_CHECK_PRESENCE_VALUE(struct lysp_node_leaf *, dflt.str, "deleting", "default", d->dflts[0].str);
-
-            FREE_STRING(ctx->ctx, ((struct lysp_node_leaf *)target)->dflt.str);
-            ((struct lysp_node_leaf *)target)->dflt.str = NULL;
-            break;
-        case LYS_LEAFLIST:
-            dflts = &((struct lysp_node_leaflist *)target)->dflts;
-            DEV_DEL_ARRAY(dflts, *dflts, .str, .str, lysp_qname_free, "default");
-            break;
-        case LYS_CHOICE:
-            AMEND_CHECK_CARDINALITY(d->dflts, 1, "deviation", "default");
-            DEV_CHECK_PRESENCE_VALUE(struct lysp_node_choice *, dflt.str, "deleting", "default", d->dflts[0].str);
-
-            FREE_STRING(ctx->ctx, ((struct lysp_node_choice *)target)->dflt.str);
-            ((struct lysp_node_choice *)target)->dflt.str = NULL;
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "delete", "default");
-        }
-    }
-
-cleanup:
-    return ret;
-}
-
-/**
- * @brief Apply deviate replace.
- *
- * @param[in] ctx Compile context.
- * @param[in] d Deviate replace to apply.
- * @param[in,out] target Deviation target.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_apply_deviate_replace(struct lysc_ctx *ctx, struct lysp_deviate_rpl *d, struct lysp_node *target)
-{
-    LY_ERR ret = LY_SUCCESS;
-    uint32_t *num;
-
-#define DEV_CHECK_PRESENCE(TYPE, MEMBER, DEVTYPE, PROPERTY, VALUE) \
-    if (!((TYPE)target)->MEMBER) { \
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NOT_PRESENT, DEVTYPE, PROPERTY, VALUE); \
-        ret = LY_EVALID; \
-        goto cleanup; \
-    }
-
-    /* [type-stmt] */
-    if (d->type) {
-        switch (target->nodetype) {
-        case LYS_LEAF:
-        case LYS_LEAFLIST:
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "replace", "type");
-        }
-
-        lysp_type_free(ctx->ctx, &((struct lysp_node_leaf *)target)->type);
-        lysp_type_dup(ctx->ctx, &((struct lysp_node_leaf *)target)->type, d->type);
-    }
-
-    /* [units-stmt] */
-    if (d->units) {
-        switch (target->nodetype) {
-        case LYS_LEAF:
-        case LYS_LEAFLIST:
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "replace", "units");
-        }
-
-        DEV_CHECK_PRESENCE(struct lysp_node_leaf *, units, "replacing", "units", d->units);
-        FREE_STRING(ctx->ctx, ((struct lysp_node_leaf *)target)->units);
-        DUP_STRING_GOTO(ctx->ctx, d->units, ((struct lysp_node_leaf *)target)->units, ret, cleanup);
-    }
-
-    /* [default-stmt] */
-    if (d->dflt.str) {
-        switch (target->nodetype) {
-        case LYS_LEAF:
-            DEV_CHECK_PRESENCE(struct lysp_node_leaf *, dflt.str, "replacing", "default", d->dflt.str);
-
-            FREE_STRING(ctx->ctx, ((struct lysp_node_leaf *)target)->dflt.str);
-            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, &((struct lysp_node_leaf *)target)->dflt, &d->dflt), cleanup);
-            break;
-        case LYS_CHOICE:
-            DEV_CHECK_PRESENCE(struct lysp_node_choice *, dflt.str, "replacing", "default", d->dflt);
-
-            FREE_STRING(ctx->ctx, ((struct lysp_node_choice *)target)->dflt.str);
-            LY_CHECK_GOTO(ret = lysp_qname_dup(ctx->ctx, &((struct lysp_node_choice *)target)->dflt, &d->dflt), cleanup);
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "replace", "default");
-        }
-    }
-
-    /* [config-stmt] */
-    if (d->flags & LYS_CONFIG_MASK) {
-        switch (target->nodetype) {
-        case LYS_CONTAINER:
-        case LYS_LEAF:
-        case LYS_LEAFLIST:
-        case LYS_LIST:
-        case LYS_CHOICE:
-        case LYS_ANYDATA:
-        case LYS_ANYXML:
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "replace", "config");
-        }
-
-        if (!(target->flags & LYS_CONFIG_MASK)) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NOT_PRESENT,
-                    "replacing", "config", d->flags & LYS_CONFIG_W ? "config true" : "config false");
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-
-        target->flags &= ~LYS_CONFIG_MASK;
-        target->flags |= d->flags & LYS_CONFIG_MASK;
-    }
-
-    /* [mandatory-stmt] */
-    if (d->flags & LYS_MAND_MASK) {
-        switch (target->nodetype) {
-        case LYS_LEAF:
-        case LYS_CHOICE:
-        case LYS_ANYDATA:
-        case LYS_ANYXML:
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "replace", "mandatory");
-        }
-
-        if (!(target->flags & LYS_MAND_MASK)) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NOT_PRESENT,
-                    "replacing", "mandatory", d->flags & LYS_MAND_TRUE ? "mandatory true" : "mandatory false");
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-
-        target->flags &= ~LYS_MAND_MASK;
-        target->flags |= d->flags & LYS_MAND_MASK;
-    }
-
-    /* [min-elements-stmt] */
-    if (d->flags & LYS_SET_MIN) {
-        switch (target->nodetype) {
-        case LYS_LEAFLIST:
-            num = &((struct lysp_node_leaflist *)target)->min;
-            break;
-        case LYS_LIST:
-            num = &((struct lysp_node_list *)target)->min;
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "replace", "min-elements");
-        }
-
-        if (!(target->flags & LYS_SET_MIN)) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid deviation replacing \"min-elements\" property which is not present.");
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-
-        *num = d->min;
-    }
-
-    /* [max-elements-stmt] */
-    if (d->flags & LYS_SET_MAX) {
-        switch (target->nodetype) {
-        case LYS_LEAFLIST:
-            num = &((struct lysp_node_leaflist *)target)->max;
-            break;
-        case LYS_LIST:
-            num = &((struct lysp_node_list *)target)->max;
-            break;
-        default:
-            AMEND_WRONG_NODETYPE("deviation", "replace", "max-elements");
-        }
-
-        if (!(target->flags & LYS_SET_MAX)) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "Invalid deviation replacing \"max-elements\" property which is not present.");
-            ret = LY_EVALID;
-            goto cleanup;
-        }
-
-        *num = d->max;
-    }
-
-cleanup:
-    return ret;
-}
-
-/**
- * @brief Get module of a single nodeid node name test.
- *
- * @param[in] ctx libyang context.
- * @param[in] nametest Nametest with an optional prefix.
- * @param[in] nametest_len Length of @p nametest.
- * @param[in] mod Both current and prefix module for resolving prefixes and to return in case of no prefix.
- * @param[out] name Optional pointer to the name test without the prefix.
- * @param[out] name_len Length of @p name.
- * @return Resolved module.
- */
-static const struct lys_module *
-lys_schema_node_get_module(const struct ly_ctx *ctx, const char *nametest, size_t nametest_len,
-        const struct lysp_module *mod, const char **name, size_t *name_len)
-{
-    const struct lys_module *target_mod;
-    const char *ptr;
-
-    ptr = ly_strnchr(nametest, ':', nametest_len);
-    if (ptr) {
-        target_mod = ly_resolve_prefix(ctx, nametest, ptr - nametest, LY_PREF_SCHEMA, (void *)mod);
-        if (!target_mod) {
-            LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE,
-                    "Invalid absolute-schema-nodeid nametest \"%.*s\" - prefix \"%.*s\" not defined in module \"%s\".",
-                    nametest_len, nametest, ptr - nametest, nametest, LYSP_MODULE_NAME(mod));
-            return NULL;
-        }
-
-        if (name) {
-            *name = ptr + 1;
-            *name_len = nametest_len - ((ptr - nametest) + 1);
-        }
-    } else {
-        target_mod = mod->mod;
-        if (name) {
-            *name = nametest;
-            *name_len = nametest_len;
-        }
-    }
-
-    return target_mod;
-}
-
-/**
- * @brief Check whether a parsed node matches a single schema nodeid name test.
- *
- * @param[in] pnode Parsed node to consider.
- * @param[in] pnode_mod Compiled @p pnode to-be module.
- * @param[in] mod Expected module.
- * @param[in] name Expected name.
- * @param[in] name_len Length of @p name.
- * @return Whether it is a match or not.
- */
-static ly_bool
-lysp_schema_nodeid_match_pnode(const struct lysp_node *pnode, const struct lys_module *pnode_mod,
-        const struct lys_module *mod, const char *name, size_t name_len)
-{
-    const char *pname;
-
-    /* compare with the module of the node */
-    if (pnode_mod != mod) {
-        return 0;
-    }
-
-    /* compare names */
-    if (pnode->nodetype & (LYS_ACTION | LYS_RPC)) {
-        pname = ((struct lysp_action *)pnode)->name;
-    } else if (pnode->nodetype & (LYS_INPUT | LYS_OUTPUT)) {
-        pname = (pnode->nodetype & LYS_INPUT) ? "input" : "output";
-    } else {
-        pname = pnode->name;
-    }
-    if (ly_strncmp(pname, name, name_len)) {
-        return 0;
-    }
-
-    return 1;
-}
-
-/**
- * @brief Check whether a compiled node matches a single schema nodeid name test.
- *
- * @param[in,out] node Compiled node to consider. On a match it is moved to its parent.
- * @param[in] mod Expected module.
- * @param[in] name Expected name.
- * @param[in] name_len Length of @p name.
- * @return Whether it is a match or not.
- */
-static ly_bool
-lysp_schema_nodeid_match_node(const struct lysc_node **node, const struct lys_module *mod, const char *name,
-        size_t name_len)
-{
-    const struct lys_module *node_mod;
-    const char *node_name;
-
-    /* compare with the module of the node */
-    if ((*node)->nodetype == LYS_INPUT) {
-        node_mod = ((struct lysc_node *)(((char *)*node) - offsetof(struct lysc_action, input)))->module;
-    } else if ((*node)->nodetype == LYS_OUTPUT) {
-        node_mod = ((struct lysc_node *)(((char *)*node) - offsetof(struct lysc_action, output)))->module;
-    } else {
-        node_mod = (*node)->module;
-    }
-    if (node_mod != mod) {
-        return 0;
-    }
-
-    /* compare names */
-    if ((*node)->nodetype == LYS_INPUT) {
-        node_name = "input";
-    } else if ((*node)->nodetype == LYS_OUTPUT) {
-        node_name = "output";
-    } else {
-        node_name = (*node)->name;
-    }
-    if (ly_strncmp(node_name, name, name_len)) {
-        return 0;
-    }
-
-    if ((*node)->nodetype & (LYS_INPUT | LYS_OUTPUT)) {
-        /* move up from input/output */
-        if ((*node)->nodetype == LYS_INPUT) {
-            (*node) = (struct lysc_node *)(((char *)*node) - offsetof(struct lysc_action, input));
-        } else {
-            (*node) = (struct lysc_node *)(((char *)*node) - offsetof(struct lysc_action, output));
-        }
-    } else if ((*node)->parent && ((*node)->parent->nodetype & (LYS_RPC | LYS_ACTION))) {
-        /* move to the input/output */
-        if ((*node)->flags & LYS_CONFIG_W) {
-            *node = (struct lysc_node *)&((struct lysc_action *)(*node)->parent)->input;
-        } else {
-            *node = (struct lysc_node *)&((struct lysc_action *)(*node)->parent)->output;
-        }
-    } else {
-        /* move to next parent */
-        *node = (*node)->parent;
-    }
-
-    return 1;
-}
-
-/**
- * @brief Check whether a node matches specific schema nodeid.
- *
- * @param[in] exp Parsed nodeid to match.
- * @param[in] exp_pmod Module to use for nodes in @p exp without a prefix.
- * @param[in] ctx_node Initial context node that should match, only for descendant paths.
- * @param[in] parent First compiled parent to consider. If @p pnode is NULL, it is condered the node to be matched.
- * @param[in] pnode Parsed node to be matched. May be NULL if the target node was already compiled.
- * @param[in] pnode_mod Compiled @p pnode to-be module.
- * @return Whether it is a match or not.
- */
-static ly_bool
-lysp_schema_nodeid_match(const struct lyxp_expr *exp, const struct lysp_module *exp_pmod, const struct lysc_node *ctx_node,
-        const struct lysc_node *parent, const struct lysp_node *pnode, const struct lys_module *pnode_mod)
-{
-    uint32_t i;
-    const struct lys_module *mod;
-    const char *name;
-    size_t name_len;
-
-    /* compare last node in the node ID */
-    i = exp->used - 1;
-
-    /* get exp node ID module */
-    mod = lys_schema_node_get_module(exp_pmod->mod->ctx, exp->expr + exp->tok_pos[i], exp->tok_len[i], exp_pmod, &name, &name_len);
-    assert(mod);
-
-    if (pnode) {
-        /* compare on the last parsed-only node */
-        if (!lysp_schema_nodeid_match_pnode(pnode, pnode_mod, mod, name, name_len)) {
-            return 0;
-        }
-    } else {
-        /* using parent directly */
-        if (!lysp_schema_nodeid_match_node(&parent, mod, name, name_len)) {
-            return 0;
-        }
-    }
-
-    /* now compare all the compiled parents */
-    while (i > 1) {
-        i -= 2;
-        assert(exp->tokens[i] == LYXP_TOKEN_NAMETEST);
-
-        if (!parent) {
-            /* no more parents but path continues */
-            return 0;
-        }
-
-        /* get exp node ID module */
-        mod = lys_schema_node_get_module(exp_pmod->mod->ctx, exp->expr + exp->tok_pos[i], exp->tok_len[i], exp_pmod, &name,
-                &name_len);
-        assert(mod);
-
-        /* compare with the parent */
-        if (!lysp_schema_nodeid_match_node(&parent, mod, name, name_len)) {
-            return 0;
-        }
-    }
-
-    if (ctx_node && (ctx_node != parent)) {
-        /* descendant path has not finished in the context node */
-        return 0;
-    } else if (!ctx_node && parent) {
-        /* some parent was not matched */
-        return 0;
-    }
-
-    return 1;
-}
-
-static void
-lysc_augment_free(const struct ly_ctx *ctx, struct lysc_augment *aug)
-{
-    if (aug) {
-        lyxp_expr_free(ctx, aug->nodeid);
-
-        free(aug);
-    }
-}
-
-static void
-lysc_deviation_free(const struct ly_ctx *ctx, struct lysc_deviation *dev)
-{
-    if (dev) {
-        lyxp_expr_free(ctx, dev->nodeid);
-        LY_ARRAY_FREE(dev->devs);
-        LY_ARRAY_FREE(dev->dev_pmods);
-
-        free(dev);
-    }
-}
-
-static void
-lysc_refine_free(const struct ly_ctx *ctx, struct lysc_refine *rfn)
-{
-    if (rfn) {
-        lyxp_expr_free(ctx, rfn->nodeid);
-        LY_ARRAY_FREE(rfn->rfns);
-
-        free(rfn);
-    }
-}
-
-static void
-lysp_dev_node_free(const struct ly_ctx *ctx, struct lysp_node *dev_pnode)
-{
-    if (!dev_pnode) {
-        return;
-    }
-
-    switch (dev_pnode->nodetype) {
-    case LYS_CONTAINER:
-        ((struct lysp_node_container *)dev_pnode)->child = NULL;
-        break;
-    case LYS_LIST:
-        ((struct lysp_node_list *)dev_pnode)->child = NULL;
-        break;
-    case LYS_CHOICE:
-        ((struct lysp_node_choice *)dev_pnode)->child = NULL;
-        break;
-    case LYS_CASE:
-        ((struct lysp_node_case *)dev_pnode)->child = NULL;
-        break;
-    case LYS_LEAF:
-    case LYS_LEAFLIST:
-    case LYS_ANYXML:
-    case LYS_ANYDATA:
-        /* no children */
-        break;
-    case LYS_NOTIF:
-        ((struct lysp_notif *)dev_pnode)->data = NULL;
-        lysp_notif_free((struct ly_ctx *)ctx, (struct lysp_notif *)dev_pnode);
-        free(dev_pnode);
-        return;
-    case LYS_RPC:
-    case LYS_ACTION:
-        ((struct lysp_action *)dev_pnode)->input.data = NULL;
-        ((struct lysp_action *)dev_pnode)->output.data = NULL;
-        lysp_action_free((struct ly_ctx *)ctx, (struct lysp_action *)dev_pnode);
-        free(dev_pnode);
-        return;
-    case LYS_INPUT:
-    case LYS_OUTPUT:
-        ((struct lysp_action_inout *)dev_pnode)->data = NULL;
-        lysp_action_inout_free((struct ly_ctx *)ctx, (struct lysp_action_inout *)dev_pnode);
-        free(dev_pnode);
-        return;
-    default:
-        LOGINT(ctx);
-        return;
-    }
-
-    lysp_node_free((struct ly_ctx *)ctx, dev_pnode);
-}
-
-/**
- * @brief Compile and apply any precompiled deviations and refines targetting a node.
- *
- * @param[in] ctx Compile context.
- * @param[in] pnode Parsed node to consider.
- * @param[in] parent First compiled parent of @p pnode.
- * @param[out] dev_pnode Copy of parsed node @p pnode with deviations and refines, if any. NULL if there are none.
- * @param[out] no_supported Whether a not-supported deviation is defined for the node.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_node_deviations_refines(struct lysc_ctx *ctx, const struct lysp_node *pnode, const struct lysc_node *parent,
-        struct lysp_node **dev_pnode, ly_bool *not_supported)
-{
-    LY_ERR ret = LY_SUCCESS;
-    uint32_t i;
-    LY_ARRAY_COUNT_TYPE u;
-    struct lys_module *orig_mod = ctx->cur_mod;
-    struct lysp_module *orig_pmod = ctx->pmod;
-    char orig_path[LYSC_CTX_BUFSIZE];
-    struct lysc_refine *rfn;
-    struct lysc_deviation *dev;
-    struct lysp_deviation *dev_p;
-    struct lysp_deviate *d;
-
-    *dev_pnode = NULL;
-    *not_supported = 0;
-
-    for (i = 0; i < ctx->uses_rfns.count; ++i) {
-        rfn = ctx->uses_rfns.objs[i];
-
-        if (!lysp_schema_nodeid_match(rfn->nodeid, rfn->nodeid_pmod, rfn->nodeid_ctx_node, parent, pnode, ctx->cur_mod)) {
-            /* not our target node */
-            continue;
-        }
-
-        if (!*dev_pnode) {
-            /* first refine on this node, create a copy first */
-            LY_CHECK_GOTO(ret = lysp_dup_single(ctx->ctx, pnode, 1, dev_pnode), cleanup);
-        }
-
-        /* apply all the refines by changing (the copy of) the parsed node */
-        LY_ARRAY_FOR(rfn->rfns, u) {
-            /* apply refine, keep the current path and add to it */
-            lysc_update_path(ctx, NULL, "{refine}");
-            lysc_update_path(ctx, NULL, rfn->rfns[u]->nodeid);
-            ret = lys_apply_refine(ctx, rfn->rfns[u], *dev_pnode);
-            lysc_update_path(ctx, NULL, NULL);
-            lysc_update_path(ctx, NULL, NULL);
-            LY_CHECK_GOTO(ret, cleanup);
-        }
-
-        /* refine was applied, remove it */
-        lysc_refine_free(ctx->ctx, rfn);
-        ly_set_rm_index(&ctx->uses_rfns, i, NULL);
-
-        /* all the refines for one target node are in one structure, we are done */
-        break;
-    }
-
-    for (i = 0; i < ctx->devs.count; ++i) {
-        dev = ctx->devs.objs[i];
-
-        if (!lysp_schema_nodeid_match(dev->nodeid, dev->dev_pmods[0], NULL, parent, pnode, ctx->cur_mod)) {
-            /* not our target node */
-            continue;
-        }
-
-        if (dev->not_supported) {
-            /* it is not supported, no more deviations */
-            *not_supported = 1;
-            goto dev_applied;
-        }
-
-        if (!*dev_pnode) {
-            /* first deviation on this node, create a copy first */
-            LY_CHECK_GOTO(ret = lysp_dup_single(ctx->ctx, pnode, 1, dev_pnode), cleanup);
-        }
-
-        /* apply all the deviates by changing (the copy of) the parsed node */
-        LY_ARRAY_FOR(dev->devs, u) {
-            dev_p = dev->devs[u];
-            LY_LIST_FOR(dev_p->deviates, d) {
-                /* generate correct path */
-                strcpy(orig_path, ctx->path);
-                ctx->path_len = 1;
-                ctx->cur_mod = dev->dev_pmods[u]->mod;
-                ctx->pmod = (struct lysp_module *)dev->dev_pmods[u];
-                lysc_update_path(ctx, NULL, "{deviation}");
-                lysc_update_path(ctx, NULL, dev_p->nodeid);
-
-                switch (d->mod) {
-                case LYS_DEV_ADD:
-                    ret = lys_apply_deviate_add(ctx, (struct lysp_deviate_add *)d, *dev_pnode);
-                    break;
-                case LYS_DEV_DELETE:
-                    ret = lys_apply_deviate_delete(ctx, (struct lysp_deviate_del *)d, *dev_pnode);
-                    break;
-                case LYS_DEV_REPLACE:
-                    ret = lys_apply_deviate_replace(ctx, (struct lysp_deviate_rpl *)d, *dev_pnode);
-                    break;
-                default:
-                    LOGINT(ctx->ctx);
-                    ret = LY_EINT;
-                }
-
-                /* restore previous path */
-                strcpy(ctx->path, orig_path);
-                ctx->path_len = strlen(ctx->path);
-                ctx->cur_mod = orig_mod;
-                ctx->pmod = orig_pmod;
-
-                LY_CHECK_GOTO(ret, cleanup);
-            }
-        }
-
-dev_applied:
-        /* deviation was applied, remove it */
-        lysc_deviation_free(ctx->ctx, dev);
-        ly_set_rm_index(&ctx->devs, i, NULL);
-
-        /* all the deviations for one target node are in one structure, we are done */
-        break;
-    }
-
-cleanup:
-    if (ret) {
-        lysp_dev_node_free(ctx->ctx, *dev_pnode);
-        *dev_pnode = NULL;
-        *not_supported = 0;
-    }
-    return ret;
-}
-
-/**
- * @brief Compile and apply any precompiled top-level or uses augments targetting a node.
- *
- * @param[in] ctx Compile context.
- * @param[in] node Compiled node to consider.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_node_augments(struct lysc_ctx *ctx, struct lysc_node *node)
-{
-    LY_ERR ret = LY_SUCCESS;
-    struct lys_module *orig_mod = ctx->cur_mod;
-    struct lysp_module *orig_pmod = ctx->pmod;
-    uint32_t i;
-    char orig_path[LYSC_CTX_BUFSIZE];
-    struct lysc_augment *aug;
-
-    /* uses augments */
-    for (i = 0; i < ctx->uses_augs.count; ) {
-        aug = ctx->uses_augs.objs[i];
-
-        if (!lysp_schema_nodeid_match(aug->nodeid, aug->nodeid_pmod, aug->nodeid_ctx_node, node, NULL, NULL)) {
-            /* not our target node */
-            ++i;
-            continue;
-        }
-
-        /* apply augment, keep the current path and add to it */
-        lysc_update_path(ctx, NULL, "{augment}");
-        lysc_update_path(ctx, NULL, aug->aug_p->nodeid);
-        ret = lys_compile_augment(ctx, aug->aug_p, node);
-        lysc_update_path(ctx, NULL, NULL);
-        lysc_update_path(ctx, NULL, NULL);
-        LY_CHECK_GOTO(ret, cleanup);
-
-        /* augment was applied, remove it (index may have changed because other augments could have been applied) */
-        ly_set_rm(&ctx->uses_augs, aug, NULL);
-        lysc_augment_free(ctx->ctx, aug);
-    }
-
-    /* top-level augments */
-    for (i = 0; i < ctx->augs.count; ) {
-        aug = ctx->augs.objs[i];
-
-        if (!lysp_schema_nodeid_match(aug->nodeid, aug->nodeid_pmod, NULL, node, NULL, NULL)) {
-            /* not our target node */
-            ++i;
-            continue;
-        }
-
-        /* apply augment, use the path and modules from the augment */
-        strcpy(orig_path, ctx->path);
-        ctx->path_len = 1;
-        lysc_update_path(ctx, NULL, "{augment}");
-        lysc_update_path(ctx, NULL, aug->aug_p->nodeid);
-        ctx->cur_mod = aug->nodeid_pmod->mod;
-        ctx->pmod = (struct lysp_module *)aug->nodeid_pmod;
-        ret = lys_compile_augment(ctx, aug->aug_p, node);
-        strcpy(ctx->path, orig_path);
-        ctx->path_len = strlen(ctx->path);
-        LY_CHECK_GOTO(ret, cleanup);
-
-        /* augment was applied, remove it */
-        ly_set_rm(&ctx->augs, aug, NULL);
-        lysc_augment_free(ctx->ctx, aug);
-    }
-
-cleanup:
-    ctx->cur_mod = orig_mod;
-    ctx->pmod = orig_pmod;
-    return ret;
-}
-
-/**
- * @brief Prepare a top-level augment to be applied during data nodes compilation.
- *
- * @param[in] ctx Compile context.
- * @param[in] aug_p Parsed augment to be applied.
- * @param[in] pmod Both current and prefix module for @p aug_p.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_precompile_own_augment(struct lysc_ctx *ctx, struct lysp_augment *aug_p, const struct lysp_module *pmod)
-{
-    LY_ERR ret = LY_SUCCESS;
-    struct lyxp_expr *exp = NULL;
-    struct lysc_augment *aug;
-    const struct lys_module *mod;
-
-    /* parse its target, it was already parsed and fully checked (except for the existence of the nodes) */
-    ret = lyxp_expr_parse(ctx->ctx, aug_p->nodeid, strlen(aug_p->nodeid), 0, &exp);
-    LY_CHECK_GOTO(ret, cleanup);
-
-    mod = lys_schema_node_get_module(ctx->ctx, exp->expr + exp->tok_pos[1], exp->tok_len[1], pmod, NULL, NULL);
-    LY_CHECK_ERR_GOTO(!mod, LOGINT(ctx->ctx); ret = LY_EINT, cleanup);
-    if (mod != ctx->cur_mod) {
-        /* augment for another module, ignore */
-        goto cleanup;
-    }
-
-    /* allocate new compiled augment and store it in the set */
-    aug = calloc(1, sizeof *aug);
-    LY_CHECK_ERR_GOTO(!aug, LOGMEM(ctx->ctx); ret = LY_EMEM, cleanup);
-    LY_CHECK_GOTO(ret = ly_set_add(&ctx->augs, aug, 1, NULL), cleanup);
-
-    aug->nodeid = exp;
-    exp = NULL;
-    aug->nodeid_pmod = pmod;
-    aug->aug_p = aug_p;
-
-cleanup:
-    lyxp_expr_free(ctx->ctx, exp);
-    return ret;
-}
-
-/**
- * @brief Prepare all top-level augments for the current module to be applied during data nodes compilation.
- *
- * @param[in] ctx Compile context.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_precompile_own_augments(struct lysc_ctx *ctx)
-{
-    LY_ARRAY_COUNT_TYPE u, v, w;
-    const struct lys_module *aug_mod;
-
-    LY_ARRAY_FOR(ctx->cur_mod->augmented_by, u) {
-        aug_mod = ctx->cur_mod->augmented_by[u];
-
-        /* collect all module augments */
-        LY_ARRAY_FOR(aug_mod->parsed->augments, v) {
-            LY_CHECK_RET(lys_precompile_own_augment(ctx, &aug_mod->parsed->augments[v], aug_mod->parsed));
-        }
-
-        /* collect all submodules augments */
-        LY_ARRAY_FOR(aug_mod->parsed->includes, v) {
-            LY_ARRAY_FOR(aug_mod->parsed->includes[v].submodule->augments, w) {
-                LY_CHECK_RET(lys_precompile_own_augment(ctx, &aug_mod->parsed->includes[v].submodule->augments[w],
-                        (struct lysp_module *)aug_mod->parsed->includes[v].submodule));
-            }
-        }
-    }
-
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Prepare a deviation to be applied during data nodes compilation.
- *
- * @param[in] ctx Compile context.
- * @param[in] dev_p Parsed deviation to be applied.
- * @param[in] pmod Both current and prefix module for @p dev_p.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_precompile_own_deviation(struct lysc_ctx *ctx, struct lysp_deviation *dev_p, const struct lysp_module *pmod)
-{
-    LY_ERR ret = LY_SUCCESS;
-    struct lysc_deviation *dev = NULL;
-    struct lyxp_expr *exp = NULL;
-    struct lysp_deviation **new_dev;
-    const struct lys_module *mod;
-    const struct lysp_module **new_dev_pmod;
-    uint32_t i;
-
-    /* parse its target, it was already parsed and fully checked (except for the existence of the nodes) */
-    ret = lyxp_expr_parse(ctx->ctx, dev_p->nodeid, strlen(dev_p->nodeid), 0, &exp);
-    LY_CHECK_GOTO(ret, cleanup);
-
-    mod = lys_schema_node_get_module(ctx->ctx, exp->expr + exp->tok_pos[1], exp->tok_len[1], pmod, NULL, NULL);
-    LY_CHECK_ERR_GOTO(!mod, LOGINT(ctx->ctx); ret = LY_EINT, cleanup);
-    if (mod != ctx->cur_mod) {
-        /* deviation for another module, ignore */
-        goto cleanup;
-    }
-
-    /* try to find the node in already compiled deviations */
-    for (i = 0; i < ctx->devs.count; ++i) {
-        if (lys_abs_schema_nodeid_match(ctx->ctx, exp, pmod, ((struct lysc_deviation *)ctx->devs.objs[i])->nodeid,
-                ((struct lysc_deviation *)ctx->devs.objs[i])->dev_pmods[0])) {
-            dev = ctx->devs.objs[i];
-            break;
-        }
-    }
-
-    if (!dev) {
-        /* allocate new compiled deviation */
-        dev = calloc(1, sizeof *dev);
-        LY_CHECK_ERR_GOTO(!dev, LOGMEM(ctx->ctx); ret = LY_EMEM, cleanup);
-        LY_CHECK_GOTO(ret = ly_set_add(&ctx->devs, dev, 1, NULL), cleanup);
-
-        dev->nodeid = exp;
-        exp = NULL;
-    }
-
-    /* add new parsed deviation structure */
-    LY_ARRAY_NEW_GOTO(ctx->ctx, dev->devs, new_dev, ret, cleanup);
-    *new_dev = dev_p;
-    LY_ARRAY_NEW_GOTO(ctx->ctx, dev->dev_pmods, new_dev_pmod, ret, cleanup);
-    *new_dev_pmod = pmod;
-
-cleanup:
-    lyxp_expr_free(ctx->ctx, exp);
-    return ret;
-}
-
-/**
- * @brief Prepare all deviations for the current module to be applied during data nodes compilation.
- *
- * @param[in] ctx Compile context.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_precompile_own_deviations(struct lysc_ctx *ctx)
-{
-    LY_ARRAY_COUNT_TYPE u, v, w;
-    const struct lys_module *dev_mod;
-    struct lysc_deviation *dev;
-    struct lysp_deviate *d;
-    int not_supported;
-    uint32_t i;
-
-    LY_ARRAY_FOR(ctx->cur_mod->deviated_by, u) {
-        dev_mod = ctx->cur_mod->deviated_by[u];
-
-        /* compile all module deviations */
-        LY_ARRAY_FOR(dev_mod->parsed->deviations, v) {
-            LY_CHECK_RET(lys_precompile_own_deviation(ctx, &dev_mod->parsed->deviations[v], dev_mod->parsed));
-        }
-
-        /* compile all submodules deviations */
-        LY_ARRAY_FOR(dev_mod->parsed->includes, v) {
-            LY_ARRAY_FOR(dev_mod->parsed->includes[v].submodule->deviations, w) {
-                LY_CHECK_RET(lys_precompile_own_deviation(ctx, &dev_mod->parsed->includes[v].submodule->deviations[w],
-                        (struct lysp_module *)dev_mod->parsed->includes[v].submodule));
-            }
-        }
-    }
-
-    /* set not-supported flags for all the deviations */
-    for (i = 0; i < ctx->devs.count; ++i) {
-        dev = ctx->devs.objs[i];
-        not_supported = 0;
-
-        LY_ARRAY_FOR(dev->devs, u) {
-            LY_LIST_FOR(dev->devs[u]->deviates, d) {
-                if (d->mod == LYS_DEV_NOT_SUPPORTED) {
-                    not_supported = 1;
-                    break;
-                }
-            }
-            if (not_supported) {
-                break;
-            }
-        }
-        if (not_supported && (LY_ARRAY_COUNT(dev->devs) > 1)) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                    "Multiple deviations of \"%s\" with one of them being \"not-supported\".", dev->nodeid->expr);
-            return LY_EVALID;
-        }
-
-        dev->not_supported = not_supported;
-    }
-
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Compile parsed schema node information.
- * @param[in] ctx Compile context
- * @param[in] pnode Parsed schema node.
- * @param[in] parent Compiled parent node where the current node is supposed to be connected. It is
- * NULL for top-level nodes, in such a case the module where the node will be connected is taken from
- * the compile context.
- * @param[in] uses_status If the node is being placed instead of uses, here we have the uses's status value (as node's flags).
- * Zero means no uses, non-zero value with no status bit set mean the default status.
- * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
- */
-static LY_ERR
-lys_compile_node(struct lysc_ctx *ctx, struct lysp_node *pnode, struct lysc_node *parent, uint16_t uses_status,
-        struct ly_set *child_set)
-{
-    LY_ERR ret = LY_SUCCESS;
-    struct lysc_node *node = NULL;
-    struct lysp_node *dev_pnode = NULL, *orig_pnode = pnode;
-    LY_ARRAY_COUNT_TYPE u;
-    ly_bool not_supported;
-
-    LY_ERR (*node_compile_spec)(struct lysc_ctx *, struct lysp_node *, struct lysc_node *);
-
-    if (pnode->nodetype != LYS_USES) {
-        lysc_update_path(ctx, parent, pnode->name);
-    } else {
-        lysc_update_path(ctx, NULL, "{uses}");
-        lysc_update_path(ctx, NULL, pnode->name);
-    }
-
-    switch (pnode->nodetype) {
-    case LYS_CONTAINER:
-        node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_container));
-        node_compile_spec = lys_compile_node_container;
-        break;
-    case LYS_LEAF:
-        node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_leaf));
-        node_compile_spec = lys_compile_node_leaf;
-        break;
-    case LYS_LIST:
-        node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_list));
-        node_compile_spec = lys_compile_node_list;
-        break;
-    case LYS_LEAFLIST:
-        node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_leaflist));
-        node_compile_spec = lys_compile_node_leaflist;
-        break;
-    case LYS_CHOICE:
-        node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_choice));
-        node_compile_spec = lys_compile_node_choice;
-        break;
-    case LYS_CASE:
-        node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_case));
-        node_compile_spec = lys_compile_node_case;
-        break;
-    case LYS_ANYXML:
-    case LYS_ANYDATA:
-        node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_anydata));
-        node_compile_spec = lys_compile_node_any;
-        break;
-    case LYS_USES:
-        ret = lys_compile_uses(ctx, (struct lysp_node_uses *)pnode, parent, child_set);
-        lysc_update_path(ctx, NULL, NULL);
-        lysc_update_path(ctx, NULL, NULL);
-        return ret;
-    default:
-        LOGINT(ctx->ctx);
-        return LY_EINT;
-    }
-    LY_CHECK_ERR_RET(!node, LOGMEM(ctx->ctx), LY_EMEM);
-
-    /* compile any deviations for this node */
-    LY_CHECK_ERR_RET(ret = lys_compile_node_deviations_refines(ctx, pnode, parent, &dev_pnode, &not_supported),
-            free(node), ret);
-    if (not_supported) {
-        free(node);
-        lysc_update_path(ctx, NULL, NULL);
-        return LY_SUCCESS;
-    } else if (dev_pnode) {
-        pnode = dev_pnode;
-    }
-
-    node->nodetype = pnode->nodetype;
-    node->module = ctx->cur_mod;
-    node->prev = node;
-    node->flags = pnode->flags & LYS_FLAGS_COMPILED_MASK;
-
-    /* config */
-    ret = lys_compile_config(ctx, node, parent);
-    LY_CHECK_GOTO(ret, error);
-
-    /* list ordering */
-    if (node->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
-        if ((node->flags & LYS_CONFIG_R) && (node->flags & LYS_ORDBY_MASK)) {
-            LOGWRN(ctx->ctx, "The ordered-by statement is ignored in lists representing %s (%s).",
-                    (ctx->options & LYS_COMPILE_RPC_OUTPUT) ? "RPC/action output parameters" :
-                    (ctx->options & LYS_COMPILE_NOTIFICATION) ? "notification content" : "state data", ctx->path);
-            node->flags &= ~LYS_ORDBY_MASK;
-            node->flags |= LYS_ORDBY_SYSTEM;
-        } else if (!(node->flags & LYS_ORDBY_MASK)) {
-            /* default ordering is system */
-            node->flags |= LYS_ORDBY_SYSTEM;
-        }
-    }
-
-    /* status - it is not inherited by specification, but it does not make sense to have
-     * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
-    LY_CHECK_GOTO(ret = lys_compile_status(ctx, &node->flags, uses_status ? uses_status : (parent ? parent->flags : 0)), error);
-
-    node->sp = orig_pnode;
-    DUP_STRING_GOTO(ctx->ctx, pnode->name, node->name, ret, error);
-    DUP_STRING_GOTO(ctx->ctx, pnode->dsc, node->dsc, ret, error);
-    DUP_STRING_GOTO(ctx->ctx, pnode->ref, node->ref, ret, error);
-    COMPILE_ARRAY_GOTO(ctx, pnode->iffeatures, node->iffeatures, u, lys_compile_iffeature, ret, error);
-
-    /* insert into parent's children/compiled module (we can no longer free the node separately on error) */
-    LY_CHECK_GOTO(ret = lys_compile_node_connect(ctx, parent, node), cleanup);
-
-    if (pnode->when) {
-        /* compile when */
-        ret = lys_compile_when(ctx, pnode->when, pnode->flags, lysc_xpath_context(node), node, NULL);
-        LY_CHECK_GOTO(ret, cleanup);
-    }
-
-    /* connect any augments */
-    LY_CHECK_GOTO(ret = lys_compile_node_augments(ctx, node), cleanup);
-
-    /* nodetype-specific part */
-    LY_CHECK_GOTO(ret = node_compile_spec(ctx, pnode, node), cleanup);
-
-    /* final compilation tasks that require the node to be connected */
-    COMPILE_EXTS_GOTO(ctx, pnode->exts, node->exts, node, LYEXT_PAR_NODE, ret, cleanup);
-    if (node->flags & LYS_MAND_TRUE) {
-        /* inherit LYS_MAND_TRUE in parent containers */
-        lys_compile_mandatory_parents(parent, 1);
-    }
-
-    if (child_set) {
-        /* add the new node into set */
-        LY_CHECK_GOTO(ret = ly_set_add(child_set, node, 1, NULL), cleanup);
-    }
-
-    lysc_update_path(ctx, NULL, NULL);
-    lysp_dev_node_free(ctx->ctx, dev_pnode);
-    return LY_SUCCESS;
-
-error:
-    lysc_node_free(ctx->ctx, node);
-cleanup:
-    if (dev_pnode) {
-        LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_OTHER, "Compilation of a deviated and/or refined node failed.");
-        lysp_dev_node_free(ctx->ctx, dev_pnode);
-    }
-    return ret;
-}
-
-/**
- * @brief Add a module reference into an array, checks for duplicities.
- *
- * @param[in] ctx Compile context.
- * @param[in] mod Module reference to add.
- * @param[in,out] mod_array Module sized array to add to.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_array_add_mod_ref(struct lysc_ctx *ctx, struct lys_module *mod, struct lys_module ***mod_array)
-{
-    LY_ARRAY_COUNT_TYPE u;
-    struct lys_module **new_mod;
-
-    LY_ARRAY_FOR(*mod_array, u) {
-        if ((*mod_array)[u] == mod) {
-            /* already there */
-            return LY_EEXIST;
-        }
-    }
-
-    /* add the new module ref */
-    LY_ARRAY_NEW_RET(ctx->ctx, *mod_array, new_mod, LY_EMEM);
-    *new_mod = mod;
-
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Compile top-level augments and deviations defined in the current module.
- * Generally, just add the module refence to the target modules. But in case
- * of foreign augments, they are directly applied.
- *
- * @param[in] ctx Compile context.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_precompile_augments_deviations(struct lysc_ctx *ctx)
-{
-    LY_ERR ret = LY_SUCCESS;
-    LY_ARRAY_COUNT_TYPE u, v;
-    const struct lysp_module *mod_p;
-    const struct lysc_node *target;
-    struct lys_module *mod;
-    struct lysp_submodule *submod;
-    ly_bool has_dev = 0;
-    uint16_t flags;
-    uint32_t idx, opt_prev = ctx->options;
-
-    for (idx = 0; idx < ctx->ctx->implementing.count; ++idx) {
-        if (ctx->cur_mod == ctx->ctx->implementing.objs[idx]) {
-            break;
-        }
-    }
-    if (idx == ctx->ctx->implementing.count) {
-        /* it was already implemented and all the augments and deviations fully applied */
-        return LY_SUCCESS;
-    }
-
-    mod_p = ctx->cur_mod->parsed;
-
-    LY_ARRAY_FOR(mod_p->augments, u) {
-        lysc_update_path(ctx, NULL, "{augment}");
-        lysc_update_path(ctx, NULL, mod_p->augments[u].nodeid);
-
-        /* get target module */
-        ret = lys_nodeid_check(ctx, mod_p->augments[u].nodeid, 1, &mod, NULL);
-        LY_CHECK_RET(ret);
-
-        /* add this module into the target module augmented_by, if not there already from previous augments */
-        lys_array_add_mod_ref(ctx, ctx->cur_mod, &mod->augmented_by);
-
-        /* if we are compiling this module, we cannot add augments to it yet */
-        if (mod != ctx->cur_mod) {
-            /* apply the augment, find the target node first */
-            flags = 0;
-            ret = lysc_resolve_schema_nodeid(ctx, mod_p->augments[u].nodeid, 0, NULL, ctx->cur_mod, LY_PREF_SCHEMA,
-                    (void *)mod_p, 0, &target, &flags);
-            LY_CHECK_RET(ret);
-
-            /* apply the augment */
-            ctx->options |= flags;
-            ret = lys_compile_augment(ctx, &mod_p->augments[u], (struct lysc_node *)target);
-            ctx->options = opt_prev;
-            LY_CHECK_RET(ret);
-        }
-
-        lysc_update_path(ctx, NULL, NULL);
-        lysc_update_path(ctx, NULL, NULL);
-    }
-
-    LY_ARRAY_FOR(mod_p->deviations, u) {
-        /* get target module */
-        lysc_update_path(ctx, NULL, "{deviation}");
-        lysc_update_path(ctx, NULL, mod_p->deviations[u].nodeid);
-        ret = lys_nodeid_check(ctx, mod_p->deviations[u].nodeid, 1, &mod, NULL);
-        lysc_update_path(ctx, NULL, NULL);
-        lysc_update_path(ctx, NULL, NULL);
-        LY_CHECK_RET(ret);
-
-        /* add this module into the target module deviated_by, if not there already from previous deviations */
-        lys_array_add_mod_ref(ctx, ctx->cur_mod, &mod->deviated_by);
-
-        /* new deviation added to the target module */
-        has_dev = 1;
-    }
-
-    /* the same for augments and deviations in submodules */
-    LY_ARRAY_FOR(mod_p->includes, v) {
-        submod = mod_p->includes[v].submodule;
-        LY_ARRAY_FOR(submod->augments, u) {
-            lysc_update_path(ctx, NULL, "{augment}");
-            lysc_update_path(ctx, NULL, submod->augments[u].nodeid);
-
-            ret = lys_nodeid_check(ctx, submod->augments[u].nodeid, 1, &mod, NULL);
-            LY_CHECK_RET(ret);
-
-            lys_array_add_mod_ref(ctx, ctx->cur_mod, &mod->augmented_by);
-            if (mod != ctx->cur_mod) {
-                flags = 0;
-                ret = lysc_resolve_schema_nodeid(ctx, mod_p->augments[u].nodeid, 0, NULL, ctx->cur_mod, LY_PREF_SCHEMA,
-                        submod, 0, &target, &flags);
-                LY_CHECK_RET(ret);
-
-                ctx->options |= flags;
-                ret = lys_compile_augment(ctx, &submod->augments[u], (struct lysc_node *)target);
-                ctx->options = opt_prev;
-                LY_CHECK_RET(ret);
-            }
-
-            lysc_update_path(ctx, NULL, NULL);
-            lysc_update_path(ctx, NULL, NULL);
-        }
-
-        LY_ARRAY_FOR(submod->deviations, u) {
-            lysc_update_path(ctx, NULL, "{deviation}");
-            lysc_update_path(ctx, NULL, submod->deviations[u].nodeid);
-            ret = lys_nodeid_check(ctx, submod->deviations[u].nodeid, 1, &mod, NULL);
-            lysc_update_path(ctx, NULL, NULL);
-            lysc_update_path(ctx, NULL, NULL);
-            LY_CHECK_RET(ret);
-
-            lys_array_add_mod_ref(ctx, ctx->cur_mod, &mod->deviated_by);
-            has_dev = 1;
-        }
-    }
-
-    if (!has_dev) {
-        /* no need to recompile any modules */
-        return LY_SUCCESS;
-    }
-
-    /* free all the modules in descending order */
-    idx = ctx->ctx->list.count;
-    do {
-        --idx;
-        mod = ctx->ctx->list.objs[idx];
-        /* skip this module */
-        if (mod == mod_p->mod) {
-            continue;
-        }
-
-        if (mod->implemented && mod->compiled) {
-            /* keep information about features state in the module */
-            lys_feature_precompile_revert(ctx, mod);
-
-            /* free the module */
-            lysc_module_free(mod->compiled, NULL);
-            mod->compiled = NULL;
-        }
-    } while (idx);
-
-    /* recompile all the modules in ascending order */
-    for (idx = 0; idx < ctx->ctx->list.count; ++idx) {
-        mod = ctx->ctx->list.objs[idx];
-
-        /* skip this module */
-        if (mod == mod_p->mod) {
-            continue;
-        }
-
-        if (mod->implemented) {
-            /* compile */
-            LY_CHECK_GOTO(ret = lys_compile(mod, 0), cleanup);
-        }
-    }
-
-cleanup:
-    return ret;
-}
-
-static void *
-lys_compile_extension_instance_storage(enum ly_stmt stmt, struct lysc_ext_substmt *substmts)
-{
-    for (LY_ARRAY_COUNT_TYPE u = 0; substmts[u].stmt; ++u) {
-        if (substmts[u].stmt == stmt) {
-            return substmts[u].storage;
-        }
-    }
-    return NULL;
-}
-
-LY_ERR
-lys_compile_extension_instance(struct lysc_ctx *ctx, const struct lysp_ext_instance *ext, struct lysc_ext_substmt *substmts)
-{
-    LY_ERR ret = LY_EVALID, r;
-    LY_ARRAY_COUNT_TYPE u;
-    struct lysp_stmt *stmt;
-    struct lysp_qname qname;
-    void *parsed = NULL, **compiled = NULL;
-
-    /* check for invalid substatements */
-    for (stmt = ext->child; stmt; stmt = stmt->next) {
-        if (stmt->flags & (LYS_YIN_ATTR | LYS_YIN_ARGUMENT)) {
-            continue;
-        }
-        for (u = 0; substmts[u].stmt; ++u) {
-            if (substmts[u].stmt == stmt->kw) {
-                break;
-            }
-        }
-        if (!substmts[u].stmt) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid keyword \"%s\" as a child of \"%s%s%s\" extension instance.",
-                    stmt->stmt, ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
-            goto cleanup;
-        }
-    }
-
-    /* TODO store inherited data, e.g. status first, but mark them somehow to allow to overwrite them and not detect duplicity */
-
-    /* keep order of the processing the same as the order in the defined substmts,
-     * the order is important for some of the statements depending on others (e.g. type needs status and units) */
-    for (u = 0; substmts[u].stmt; ++u) {
-        ly_bool stmt_present = 0;
-
-        for (stmt = ext->child; stmt; stmt = stmt->next) {
-            if (substmts[u].stmt != stmt->kw) {
-                continue;
-            }
-
-            stmt_present = 1;
-            if (substmts[u].storage) {
-                switch (stmt->kw) {
-                case LY_STMT_STATUS:
-                    assert(substmts[u].cardinality < LY_STMT_CARD_SOME);
-                    LY_CHECK_ERR_GOTO(r = lysp_stmt_parse(ctx, stmt, stmt->kw, &substmts[u].storage, /* TODO */ NULL), ret = r, cleanup);
-                    break;
-                case LY_STMT_UNITS: {
-                    const char **units;
-
-                    if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
-                        /* single item */
-                        if (*((const char **)substmts[u].storage)) {
-                            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPSTMT, stmt->stmt);
-                            goto cleanup;
-                        }
-                        units = (const char **)substmts[u].storage;
-                    } else {
-                        /* sized array */
-                        const char ***units_array = (const char ***)substmts[u].storage;
-                        LY_ARRAY_NEW_GOTO(ctx->ctx, *units_array, units, ret, cleanup);
-                    }
-                    r = lydict_insert(ctx->ctx, stmt->arg, 0, units);
-                    LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
-                    break;
-                }
-                case LY_STMT_TYPE: {
-                    uint16_t *flags = lys_compile_extension_instance_storage(LY_STMT_STATUS, substmts);
-                    const char **units = lys_compile_extension_instance_storage(LY_STMT_UNITS, substmts);
-
-                    if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
-                        /* single item */
-                        if (*(struct lysc_type **)substmts[u].storage) {
-                            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPSTMT, stmt->stmt);
-                            goto cleanup;
-                        }
-                        compiled = substmts[u].storage;
-                    } else {
-                        /* sized array */
-                        struct lysc_type ***types = (struct lysc_type ***)substmts[u].storage, **type = NULL;
-                        LY_ARRAY_NEW_GOTO(ctx->ctx, *types, type, ret, cleanup);
-                        compiled = (void *)type;
-                    }
-
-                    r = lysp_stmt_parse(ctx, stmt, stmt->kw, &parsed, NULL);
-                    LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
-                    r = lys_compile_type(ctx, ext->parent_type == LYEXT_PAR_NODE ? ((struct lysc_node *)ext->parent)->sp : NULL,
-                            flags ? *flags : 0, ctx->pmod, ext->name, parsed, (struct lysc_type **)compiled,
-                            units && !*units ? units : NULL, NULL);
-                    lysp_type_free(ctx->ctx, parsed);
-                    free(parsed);
-                    LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
-                    break;
-                }
-                case LY_STMT_IF_FEATURE: {
-                    struct lysc_iffeature *iff = NULL;
-
-                    if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
-                        /* single item */
-                        if (((struct lysc_iffeature *)substmts[u].storage)->features) {
-                            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPSTMT, stmt->stmt);
-                            goto cleanup;
-                        }
-                        iff = (struct lysc_iffeature *)substmts[u].storage;
-                    } else {
-                        /* sized array */
-                        struct lysc_iffeature **iffs = (struct lysc_iffeature **)substmts[u].storage;
-                        LY_ARRAY_NEW_GOTO(ctx->ctx, *iffs, iff, ret, cleanup);
-                    }
-                    qname.str = stmt->arg;
-                    qname.mod = ctx->pmod;
-                    LY_CHECK_ERR_GOTO(r = lys_compile_iffeature(ctx, &qname, iff), ret = r, cleanup);
-                    break;
-                }
-                /* TODO support other substatements (parse stmt to lysp and then compile lysp to lysc),
-                 * also note that in many statements their extensions are not taken into account  */
-                default:
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Statement \"%s\" is not supported as an extension (found in \"%s%s%s\") substatement.",
-                            stmt->stmt, ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
-                    goto cleanup;
-                }
-            }
-        }
-
-        if (((substmts[u].cardinality == LY_STMT_CARD_MAND) || (substmts[u].cardinality == LY_STMT_CARD_SOME)) && !stmt_present) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Missing mandatory keyword \"%s\" as a child of \"%s%s%s\".",
-                    ly_stmt2str(substmts[u].stmt), ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
-            goto cleanup;
-        }
-    }
-
-    ret = LY_SUCCESS;
-
-cleanup:
-    return ret;
-}
-
-/**
- * @brief Check when for cyclic dependencies.
- *
- * @param[in] set Set with all the referenced nodes.
- * @param[in] node Node whose "when" referenced nodes are in @p set.
- * @return LY_ERR value
- */
-static LY_ERR
-lys_compile_unres_when_cyclic(struct lyxp_set *set, const struct lysc_node *node)
-{
-    struct lyxp_set tmp_set;
-    struct lyxp_set_scnode *xp_scnode;
-    uint32_t i, j;
-    LY_ARRAY_COUNT_TYPE u;
-    struct lysc_when *when;
-    LY_ERR ret = LY_SUCCESS;
-
-    memset(&tmp_set, 0, sizeof tmp_set);
-
-    /* prepare in_ctx of the set */
-    for (i = 0; i < set->used; ++i) {
-        xp_scnode = &set->val.scnodes[i];
-
-        if (xp_scnode->in_ctx != -1) {
-            /* check node when, skip the context node (it was just checked) */
-            xp_scnode->in_ctx = 1;
-        }
-    }
-
-    for (i = 0; i < set->used; ++i) {
-        xp_scnode = &set->val.scnodes[i];
-        if (xp_scnode->in_ctx != 1) {
-            /* already checked */
-            continue;
-        }
-
-        if ((xp_scnode->type != LYXP_NODE_ELEM) || (xp_scnode->scnode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) ||
-                !xp_scnode->scnode->when) {
-            /* no when to check */
-            xp_scnode->in_ctx = 0;
-            continue;
-        }
-
-        node = xp_scnode->scnode;
-        do {
-            LY_ARRAY_FOR(node->when, u) {
-                when = node->when[u];
-                ret = lyxp_atomize(when->cond, node->module, LY_PREF_SCHEMA_RESOLVED, when->prefixes, when->context,
-                        &tmp_set, LYXP_SCNODE_SCHEMA);
-                if (ret != LY_SUCCESS) {
-                    LOGVAL(set->ctx, LY_VLOG_LYSC, node, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when->cond->expr);
-                    goto cleanup;
-                }
-
-                for (j = 0; j < tmp_set.used; ++j) {
-                    /* skip roots'n'stuff */
-                    if (tmp_set.val.scnodes[j].type == LYXP_NODE_ELEM) {
-                        /* try to find this node in our set */
-                        uint32_t idx;
-                        if (lyxp_set_scnode_contains(set, tmp_set.val.scnodes[j].scnode, LYXP_NODE_ELEM, -1, &idx) && (set->val.scnodes[idx].in_ctx == -1)) {
-                            LOGVAL(set->ctx, LY_VLOG_LYSC, node, LY_VCODE_CIRC_WHEN, node->name, set->val.scnodes[idx].scnode->name);
-                            ret = LY_EVALID;
-                            goto cleanup;
-                        }
-
-                        /* needs to be checked, if in both sets, will be ignored */
-                        tmp_set.val.scnodes[j].in_ctx = 1;
-                    } else {
-                        /* no when, nothing to check */
-                        tmp_set.val.scnodes[j].in_ctx = 0;
-                    }
-                }
-
-                /* merge this set into the global when set */
-                lyxp_set_scnode_merge(set, &tmp_set);
-            }
-
-            /* check when of non-data parents as well */
-            node = node->parent;
-        } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE)));
-
-        /* this node when was checked (xp_scnode could have been reallocd) */
-        set->val.scnodes[i].in_ctx = -1;
-    }
-
-cleanup:
-    lyxp_set_free_content(&tmp_set);
-    return ret;
-}
-
-/**
- * @brief Check when/must expressions of a node on a complete compiled schema tree.
- *
- * @param[in] ctx Compile context.
- * @param[in] node Node to check.
- * @return LY_ERR value
- */
-static LY_ERR
-lys_compile_unres_xpath(struct lysc_ctx *ctx, const struct lysc_node *node)
-{
-    struct lyxp_set tmp_set;
-    uint32_t i, opts;
-    LY_ARRAY_COUNT_TYPE u;
-    ly_bool input_done = 0;
-    struct lysc_when **when = NULL;
-    struct lysc_must *musts = NULL;
-    LY_ERR ret = LY_SUCCESS;
-    const struct lysc_node *op;
-
-    memset(&tmp_set, 0, sizeof tmp_set);
-    opts = LYXP_SCNODE_SCHEMA;
-    if (node->flags & LYS_CONFIG_R) {
-        for (op = node->parent; op && !(op->nodetype & (LYS_RPC | LYS_ACTION)); op = op->parent) {}
-        if (op) {
-            /* we are actually in output */
-            opts = LYXP_SCNODE_OUTPUT;
-        }
-    }
-
-    switch (node->nodetype) {
-    case LYS_CONTAINER:
-        when = ((struct lysc_node_container *)node)->when;
-        musts = ((struct lysc_node_container *)node)->musts;
-        break;
-    case LYS_CHOICE:
-        when = ((struct lysc_node_choice *)node)->when;
-        break;
-    case LYS_LEAF:
-        when = ((struct lysc_node_leaf *)node)->when;
-        musts = ((struct lysc_node_leaf *)node)->musts;
-        break;
-    case LYS_LEAFLIST:
-        when = ((struct lysc_node_leaflist *)node)->when;
-        musts = ((struct lysc_node_leaflist *)node)->musts;
-        break;
-    case LYS_LIST:
-        when = ((struct lysc_node_list *)node)->when;
-        musts = ((struct lysc_node_list *)node)->musts;
-        break;
-    case LYS_ANYXML:
-    case LYS_ANYDATA:
-        when = ((struct lysc_node_anydata *)node)->when;
-        musts = ((struct lysc_node_anydata *)node)->musts;
-        break;
-    case LYS_CASE:
-        when = ((struct lysc_node_case *)node)->when;
-        break;
-    case LYS_NOTIF:
-        when = ((struct lysc_notif *)node)->when;
-        musts = ((struct lysc_notif *)node)->musts;
-        break;
-    case LYS_RPC:
-    case LYS_ACTION:
-        /* first process when and input musts */
-        when = ((struct lysc_action *)node)->when;
-        musts = ((struct lysc_action *)node)->input.musts;
-        break;
-    default:
-        /* nothing to check */
-        break;
-    }
-
-    /* check "when" */
-    LY_ARRAY_FOR(when, u) {
-        ret = lyxp_atomize(when[u]->cond, node->module, LY_PREF_SCHEMA_RESOLVED, when[u]->prefixes, when[u]->context,
-                &tmp_set, opts);
-        if (ret != LY_SUCCESS) {
-            LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when[u]->cond->expr);
-            goto cleanup;
-        }
-
-        ctx->path[0] = '\0';
-        lysc_path((struct lysc_node *)node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
-        for (i = 0; i < tmp_set.used; ++i) {
-            /* skip roots'n'stuff */
-            if ((tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (tmp_set.val.scnodes[i].in_ctx != -1)) {
-                struct lysc_node *schema = tmp_set.val.scnodes[i].scnode;
-
-                /* XPath expression cannot reference "lower" status than the node that has the definition */
-                ret = lysc_check_status(ctx, when[u]->flags, node->module, node->name, schema->flags, schema->module,
-                        schema->name);
-                LY_CHECK_GOTO(ret, cleanup);
-
-                /* check dummy node accessing */
-                if (schema == node) {
-                    LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LY_VCODE_DUMMY_WHEN, node->name);
-                    ret = LY_EVALID;
-                    goto cleanup;
-                }
-            }
-        }
-
-        /* check cyclic dependencies */
-        ret = lys_compile_unres_when_cyclic(&tmp_set, node);
-        LY_CHECK_GOTO(ret, cleanup);
-
-        lyxp_set_free_content(&tmp_set);
-    }
-
-check_musts:
-    /* check "must" */
-    LY_ARRAY_FOR(musts, u) {
-        ret = lyxp_atomize(musts[u].cond, node->module, LY_PREF_SCHEMA_RESOLVED, musts[u].prefixes, node, &tmp_set, opts);
-        if (ret != LY_SUCCESS) {
-            LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_SEMANTICS, "Invalid must restriction \"%s\".", musts[u].cond->expr);
-            goto cleanup;
-        }
-
-        ctx->path[0] = '\0';
-        lysc_path((struct lysc_node *)node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
-        for (i = 0; i < tmp_set.used; ++i) {
-            /* skip roots'n'stuff */
-            if (tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
-                /* XPath expression cannot reference "lower" status than the node that has the definition */
-                ret = lysc_check_status(ctx, node->flags, node->module, node->name, tmp_set.val.scnodes[i].scnode->flags,
-                        tmp_set.val.scnodes[i].scnode->module, tmp_set.val.scnodes[i].scnode->name);
-                LY_CHECK_GOTO(ret, cleanup);
-            }
-        }
-
-        lyxp_set_free_content(&tmp_set);
-    }
-
-    if ((node->nodetype & (LYS_RPC | LYS_ACTION)) && !input_done) {
-        /* now check output musts */
-        input_done = 1;
-        when = NULL;
-        musts = ((struct lysc_action *)node)->output.musts;
-        opts = LYXP_SCNODE_OUTPUT;
-        goto check_musts;
-    }
-
-cleanup:
-    lyxp_set_free_content(&tmp_set);
-    return ret;
-}
-
-/**
- * @brief Check leafref for its target existence on a complete compiled schema tree.
- *
- * @param[in] ctx Compile context.
- * @param[in] node Context node for the leafref.
- * @param[in] lref Leafref to check/resolve.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, struct lysc_type_leafref *lref)
-{
-    const struct lysc_node *target = NULL, *siter;
-    struct ly_path *p;
-    struct lysc_type *type;
-
-    assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
-
-    /* try to find the target */
-    LY_CHECK_RET(ly_path_compile(ctx->ctx, node->module, node, lref->path, LY_PATH_LREF_TRUE, lysc_is_output(node) ?
-            LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY, LY_PREF_SCHEMA_RESOLVED, lref->prefixes, &p));
-
-    /* get the target node */
-    target = p[LY_ARRAY_COUNT(p) - 1].node;
-    ly_path_free(node->module->ctx, p);
-
-    if (!(target->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
-        LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_REFERENCE,
-                "Invalid leafref path \"%s\" - target node is %s instead of leaf or leaf-list.",
-                lref->path->expr, lys_nodetype2str(target->nodetype));
-        return LY_EVALID;
-    }
-
-    /* check status */
-    ctx->path[0] = '\0';
-    lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
-    ctx->path_len = strlen(ctx->path);
-    if (lysc_check_status(ctx, node->flags, node->module, node->name, target->flags, target->module, target->name)) {
-        return LY_EVALID;
-    }
-    ctx->path_len = 1;
-    ctx->path[1] = '\0';
-
-    /* check config */
-    if (lref->require_instance) {
-        for (siter = node->parent; siter && !(siter->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); siter = siter->parent) {}
-        if (!siter && (node->flags & LYS_CONFIG_W) && (target->flags & LYS_CONFIG_R)) {
-            LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target is supposed"
-                    " to represent configuration data (as the leafref does), but it does not.", lref->path->expr);
-            return LY_EVALID;
-        }
-    }
-
-    /* store the target's type and check for circular chain of leafrefs */
-    lref->realtype = ((struct lysc_node_leaf *)target)->type;
-    for (type = lref->realtype; type && type->basetype == LY_TYPE_LEAFREF; type = ((struct lysc_type_leafref *)type)->realtype) {
-        if (type == (struct lysc_type *)lref) {
-            /* circular chain detected */
-            LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_REFERENCE,
-                    "Invalid leafref path \"%s\" - circular chain of leafrefs detected.", lref->path->expr);
-            return LY_EVALID;
-        }
-    }
-
-    /* check if leafref and its target are under common if-features */
-    if (lys_compile_leafref_features_validate(node, target)) {
-        LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_REFERENCE,
-                "Invalid leafref path \"%s\" - set of features applicable to the leafref target is not a subset of"
-                " features applicable to the leafref itself.", lref->path->expr);
-        return LY_EVALID;
-    }
-
-    return LY_SUCCESS;
-}
-
-static LY_ERR
-lys_compile_ietf_netconf_wd_annotation(struct lysc_ctx *ctx, struct lys_module *mod)
-{
-    struct lysc_ext_instance *ext;
-    struct lysp_ext_instance *ext_p = NULL;
-    struct lysp_stmt *stmt;
-    const struct lys_module *ext_mod;
-    LY_ERR ret = LY_SUCCESS;
-
-    /* create the parsed extension instance manually */
-    ext_p = calloc(1, sizeof *ext_p);
-    LY_CHECK_ERR_GOTO(!ext_p, LOGMEM(ctx->ctx); ret = LY_EMEM, cleanup);
-    LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, "md:annotation", 0, &ext_p->name), cleanup);
-    LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, "default", 0, &ext_p->argument), cleanup);
-    ext_p->insubstmt = LYEXT_SUBSTMT_SELF;
-    ext_p->insubstmt_index = 0;
-
-    ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
-    LY_CHECK_ERR_GOTO(!stmt, LOGMEM(ctx->ctx); ret = LY_EMEM, cleanup);
-    LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, "type", 0, &stmt->stmt), cleanup);
-    LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, "boolean", 0, &stmt->arg), cleanup);
-    stmt->kw = LY_STMT_TYPE;
-
-    /* allocate new extension instance */
-    LY_ARRAY_NEW_GOTO(mod->ctx, mod->compiled->exts, ext, ret, cleanup);
-
-    /* manually get extension definition module */
-    ext_mod = ly_ctx_get_module_latest(ctx->ctx, "ietf-yang-metadata");
-
-    /* compile the extension instance */
-    LY_CHECK_GOTO(ret = lys_compile_ext(ctx, ext_p, ext, mod->compiled, LYEXT_PAR_MODULE, ext_mod), cleanup);
-
-cleanup:
-    lysp_ext_instance_free(ctx->ctx, ext_p);
-    free(ext_p);
-    return ret;
-}
-
-/**
- * @brief Compile default value(s) for leaf or leaf-list expecting a complete compiled schema tree.
- *
- * @param[in] ctx Compile context.
- * @param[in] node Leaf or leaf-list to compile the default value(s) for.
- * @param[in] type Type of the default value.
- * @param[in] dflt Default value.
- * @param[in] dflt_pmod Parsed module of the @p dflt to resolve possible prefixes.
- * @param[in,out] storage Storage for the compiled default value.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_unres_dflt(struct lysc_ctx *ctx, struct lysc_node *node, struct lysc_type *type, const char *dflt,
-        const struct lysp_module *dflt_pmod, struct lyd_value *storage)
-{
-    LY_ERR ret;
-    struct ly_err_item *err = NULL;
-
-    ret = type->plugin->store(ctx->ctx, type, dflt, strlen(dflt), 0, LY_PREF_SCHEMA, (void *)dflt_pmod,
-            LYD_HINT_SCHEMA, node, storage, &err);
-    if (ret == LY_EINCOMPLETE) {
-        /* we have no data so we will not be resolving it */
-        ret = LY_SUCCESS;
-    }
-
-    if (ret) {
-        ctx->path[0] = '\0';
-        lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
-        if (err) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                    "Invalid default - value does not fit the type (%s).", err->msg);
-            ly_err_free(err);
-        } else {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                    "Invalid default - value does not fit the type.");
-        }
-        return ret;
-    }
-
-    ++((struct lysc_type *)storage->realtype)->refcount;
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Compile default value of a leaf expecting a complete compiled schema tree.
- *
- * @param[in] ctx Compile context.
- * @param[in] leaf Leaf that the default value is for.
- * @param[in] dflt Default value to compile.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_unres_leaf_dlft(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf, struct lysp_qname *dflt)
-{
-    LY_ERR ret;
-
-    assert(!leaf->dflt);
-
-    if (leaf->flags & (LYS_MAND_TRUE | LYS_KEY)) {
-        /* ignore default values for keys and mandatory leaves */
-        return LY_SUCCESS;
-    }
-
-    /* allocate the default value */
-    leaf->dflt = calloc(1, sizeof *leaf->dflt);
-    LY_CHECK_ERR_RET(!leaf->dflt, LOGMEM(ctx->ctx), LY_EMEM);
-
-    /* store the default value */
-    ret = lys_compile_unres_dflt(ctx, (struct lysc_node *)leaf, leaf->type, dflt->str, dflt->mod, leaf->dflt);
-    if (ret) {
-        free(leaf->dflt);
-        leaf->dflt = NULL;
-    }
-
-    return ret;
-}
-
-/**
- * @brief Compile default values of a leaf-list expecting a complete compiled schema tree.
- *
- * @param[in] ctx Compile context.
- * @param[in] llist Leaf-list that the default value(s) are for.
- * @param[in] dflt Default value to compile, in case of a single value.
- * @param[in] dflts Sized array of default values, in case of more values.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_unres_llist_dflts(struct lysc_ctx *ctx, struct lysc_node_leaflist *llist, struct lysp_qname *dflt,
-        struct lysp_qname *dflts)
-{
-    LY_ERR ret;
-    LY_ARRAY_COUNT_TYPE orig_count, u, v;
-
-    assert(dflt || dflts);
-
-    if (llist->dflts) {
-        /* there were already some defaults and we are adding new by deviations */
-        assert(dflts);
-        orig_count = LY_ARRAY_COUNT(llist->dflts);
-    } else {
-        orig_count = 0;
-    }
-
-    /* allocate new items */
-    if (dflts) {
-        LY_ARRAY_CREATE_RET(ctx->ctx, llist->dflts, orig_count + LY_ARRAY_COUNT(dflts), LY_EMEM);
-    } else {
-        LY_ARRAY_CREATE_RET(ctx->ctx, llist->dflts, orig_count + 1, LY_EMEM);
-    }
-
-    /* fill each new default value */
-    if (dflts) {
-        LY_ARRAY_FOR(dflts, u) {
-            llist->dflts[orig_count + u] = calloc(1, sizeof **llist->dflts);
-            ret = lys_compile_unres_dflt(ctx, (struct lysc_node *)llist, llist->type, dflts[u].str, dflts[u].mod,
-                    llist->dflts[orig_count + u]);
-            LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count + u]), ret);
-            LY_ARRAY_INCREMENT(llist->dflts);
-        }
-    } else {
-        llist->dflts[orig_count] = calloc(1, sizeof **llist->dflts);
-        ret = lys_compile_unres_dflt(ctx, (struct lysc_node *)llist, llist->type, dflt->str, dflt->mod,
-                llist->dflts[orig_count]);
-        LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count]), ret);
-        LY_ARRAY_INCREMENT(llist->dflts);
-    }
-
-    /* check default value uniqueness */
-    if (llist->flags & LYS_CONFIG_W) {
-        /* configuration data values must be unique - so check the default values */
-        for (u = orig_count; u < LY_ARRAY_COUNT(llist->dflts); ++u) {
-            for (v = 0; v < u; ++v) {
-                if (!llist->dflts[u]->realtype->plugin->compare(llist->dflts[u], llist->dflts[v])) {
-                    lysc_update_path(ctx, llist->parent, llist->name);
-                    LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
-                            "Configuration leaf-list has multiple defaults of the same value \"%s\".",
-                            llist->dflts[u]->canonical);
-                    lysc_update_path(ctx, NULL, NULL);
-                    return LY_EVALID;
-                }
-            }
-        }
-    }
-
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Finish compilation of all the unres sets of a compile context.
- *
- * @param[in] ctx Compile context with unres sets.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_unres(struct lysc_ctx *ctx)
-{
-    struct lysc_node *node;
-    struct lysc_type *type, *typeiter;
-    struct lysc_type_leafref *lref;
-    struct lysc_augment *aug;
-    struct lysc_deviation *dev;
-    LY_ARRAY_COUNT_TYPE v;
-    uint32_t i;
-
-    /* for leafref, we need 2 rounds - first detects circular chain by storing the first referred type (which
-     * can be also leafref, in case it is already resolved, go through the chain and check that it does not
-     * point to the starting leafref type). The second round stores the first non-leafref type for later data validation. */
-    for (i = 0; i < ctx->leafrefs.count; ++i) {
-        node = ctx->leafrefs.objs[i];
-        assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
-        type = ((struct lysc_node_leaf *)node)->type;
-        if (type->basetype == LY_TYPE_LEAFREF) {
-            LY_CHECK_RET(lys_compile_unres_leafref(ctx, node, (struct lysc_type_leafref *)type));
-        } else if (type->basetype == LY_TYPE_UNION) {
-            LY_ARRAY_FOR(((struct lysc_type_union *)type)->types, v) {
-                if (((struct lysc_type_union *)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
-                    lref = (struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v];
-                    LY_CHECK_RET(lys_compile_unres_leafref(ctx, node, lref));
-                }
-            }
-        }
-    }
-    for (i = 0; i < ctx->leafrefs.count; ++i) {
-        /* store pointer to the real type */
-        type = ((struct lysc_node_leaf *)ctx->leafrefs.objs[i])->type;
-        if (type->basetype == LY_TYPE_LEAFREF) {
-            for (typeiter = ((struct lysc_type_leafref *)type)->realtype;
-                    typeiter->basetype == LY_TYPE_LEAFREF;
-                    typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
-            ((struct lysc_type_leafref *)type)->realtype = typeiter;
-        } else if (type->basetype == LY_TYPE_UNION) {
-            LY_ARRAY_FOR(((struct lysc_type_union *)type)->types, v) {
-                if (((struct lysc_type_union *)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
-                    for (typeiter = ((struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v])->realtype;
-                            typeiter->basetype == LY_TYPE_LEAFREF;
-                            typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
-                    ((struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v])->realtype = typeiter;
-                }
-            }
-        }
-    }
-
-    /* check xpath */
-    for (i = 0; i < ctx->xpath.count; ++i) {
-        LY_CHECK_RET(lys_compile_unres_xpath(ctx, ctx->xpath.objs[i]));
-    }
-
-    /* finish incomplete default values compilation */
-    for (i = 0; i < ctx->dflts.count; ++i) {
-        struct lysc_unres_dflt *r = ctx->dflts.objs[i];
-        if (r->leaf->nodetype == LYS_LEAF) {
-            LY_CHECK_RET(lys_compile_unres_leaf_dlft(ctx, r->leaf, r->dflt));
-        } else {
-            LY_CHECK_RET(lys_compile_unres_llist_dflts(ctx, r->llist, r->dflt, r->dflts));
-        }
-    }
-
-    /* check that all augments were applied */
-    for (i = 0; i < ctx->augs.count; ++i) {
-        aug = ctx->augs.objs[i];
-        LOGVAL(ctx->ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE,
-                "Augment target node \"%s\" from module \"%s\" was not found.", aug->nodeid->expr,
-                LYSP_MODULE_NAME(aug->nodeid_pmod));
-    }
-    if (ctx->augs.count) {
-        return LY_ENOTFOUND;
-    }
-
-    /* check that all deviations were applied */
-    for (i = 0; i < ctx->devs.count; ++i) {
-        dev = ctx->devs.objs[i];
-        LOGVAL(ctx->ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE,
-                "Deviation(s) target node \"%s\" from module \"%s\" was not found.", dev->nodeid->expr,
-                LYSP_MODULE_NAME(dev->dev_pmods[0]));
-    }
-    if (ctx->devs.count) {
-        return LY_ENOTFOUND;
-    }
-
-    return LY_SUCCESS;
-}
-
-void
-lys_precompile_augments_deviations_revert(struct ly_ctx *ctx, const struct lys_module *mod)
-{
-    uint32_t i;
-    LY_ARRAY_COUNT_TYPE u, count;
-    struct lys_module *m;
-
-    for (i = 0; i < ctx->list.count; ++i) {
-        m = ctx->list.objs[i];
-
-        if (m->augmented_by) {
-            count = LY_ARRAY_COUNT(m->augmented_by);
-            for (u = 0; u < count; ++u) {
-                if (m->augmented_by[u] == mod) {
-                    /* keep the order */
-                    if (u < count - 1) {
-                        memmove(m->augmented_by + u, m->augmented_by + u + 1, (count - u) * sizeof *m->augmented_by);
-                    }
-                    LY_ARRAY_DECREMENT(m->augmented_by);
-                    break;
-                }
-            }
-            if (!LY_ARRAY_COUNT(m->augmented_by)) {
-                LY_ARRAY_FREE(m->augmented_by);
-                m->augmented_by = NULL;
-            }
-        }
-
-        if (m->deviated_by) {
-            count = LY_ARRAY_COUNT(m->deviated_by);
-            for (u = 0; u < count; ++u) {
-                if (m->deviated_by[u] == mod) {
-                    /* keep the order */
-                    if (u < count - 1) {
-                        memmove(m->deviated_by + u, m->deviated_by + u + 1, (count - u) * sizeof *m->deviated_by);
-                    }
-                    LY_ARRAY_DECREMENT(m->deviated_by);
-                    break;
-                }
-            }
-            if (!LY_ARRAY_COUNT(m->deviated_by)) {
-                LY_ARRAY_FREE(m->deviated_by);
-                m->deviated_by = NULL;
-            }
-        }
-    }
-}
-
-/**
- * @brief Compile features in the current module and all its submodules.
- *
- * @param[in] ctx Compile context.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_features(struct lysc_ctx *ctx)
-{
-    struct lysp_submodule *submod;
-    LY_ARRAY_COUNT_TYPE u, v;
-
-    if (!ctx->cur_mod->features) {
-        /* features are compiled directly into the module structure,
-         * but it must be done in two steps to allow forward references (via if-feature) between the features themselves */
-        LY_CHECK_RET(lys_feature_precompile(ctx, NULL, NULL, ctx->cur_mod->parsed->features, &ctx->cur_mod->features));
-        LY_ARRAY_FOR(ctx->cur_mod->parsed->includes, v) {
-            submod = ctx->cur_mod->parsed->includes[v].submodule;
-            LY_CHECK_RET(lys_feature_precompile(ctx, NULL, NULL, submod->features, &ctx->cur_mod->features));
-        }
-    }
-
-    /* finish feature compilation, not only for the main module, but also for the submodules.
-     * Due to possible forward references, it must be done when all the features (including submodules)
-     * are present. */
-    LY_ARRAY_FOR(ctx->cur_mod->parsed->features, u) {
-        LY_CHECK_RET(lys_feature_precompile_finish(ctx, &ctx->cur_mod->parsed->features[u], ctx->cur_mod->features));
-    }
-
-    lysc_update_path(ctx, NULL, "{submodule}");
-    LY_ARRAY_FOR(ctx->cur_mod->parsed->includes, v) {
-        submod = ctx->cur_mod->parsed->includes[v].submodule;
-
-        lysc_update_path(ctx, NULL, submod->name);
-        LY_ARRAY_FOR(submod->features, u) {
-            LY_CHECK_RET(lys_feature_precompile_finish(ctx, &submod->features[u], ctx->cur_mod->features));
-        }
-        lysc_update_path(ctx, NULL, NULL);
-    }
-    lysc_update_path(ctx, NULL, NULL);
-
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Compile identites in the current module and all its submodules.
- *
- * @param[in] ctx Compile context.
- * @return LY_ERR value.
- */
-static LY_ERR
-lys_compile_identities(struct lysc_ctx *ctx)
-{
-    struct lysp_submodule *submod;
-    LY_ARRAY_COUNT_TYPE u;
-
-    if (!ctx->cur_mod->identities) {
-        LY_CHECK_RET(lys_identity_precompile(ctx, NULL, NULL, ctx->cur_mod->parsed->identities, &ctx->cur_mod->identities));
-        LY_ARRAY_FOR(ctx->cur_mod->parsed->includes, u) {
-            submod = ctx->cur_mod->parsed->includes[u].submodule;
-            LY_CHECK_RET(lys_identity_precompile(ctx, NULL, NULL, submod->identities, &ctx->cur_mod->identities));
-        }
-    }
-
-    if (ctx->cur_mod->parsed->identities) {
-        LY_CHECK_RET(lys_compile_identities_derived(ctx, ctx->cur_mod->parsed->identities, ctx->cur_mod->identities));
-    }
-    lysc_update_path(ctx, NULL, "{submodule}");
-    LY_ARRAY_FOR(ctx->cur_mod->parsed->includes, u) {
-
-        submod = ctx->cur_mod->parsed->includes[u].submodule;
-        if (submod->identities) {
-            lysc_update_path(ctx, NULL, submod->name);
-            LY_CHECK_RET(lys_compile_identities_derived(ctx, submod->identities, ctx->cur_mod->identities));
-            lysc_update_path(ctx, NULL, NULL);
-        }
-    }
-    lysc_update_path(ctx, NULL, NULL);
-
-    return LY_SUCCESS;
-}
-
-LY_ERR
-lys_compile(struct lys_module *mod, uint32_t options)
-{
-    struct lysc_ctx ctx = {0};
-    struct lysc_module *mod_c;
-    struct lysp_module *sp;
-    struct lysp_submodule *submod;
-    struct lysp_node *pnode;
-    struct lysp_grp *grps;
-    LY_ARRAY_COUNT_TYPE u, v;
-    uint32_t i;
-    LY_ERR ret = LY_SUCCESS;
-
-    LY_CHECK_ARG_RET(NULL, mod, mod->parsed, !mod->compiled, mod->ctx, LY_EINVAL);
-
-    if (!mod->implemented) {
-        /* just imported modules are not compiled */
-        return LY_SUCCESS;
-    }
-
-    /* context will be changed */
-    ++mod->ctx->module_set_id;
-
-    sp = mod->parsed;
-
-    ctx.ctx = mod->ctx;
-    ctx.cur_mod = mod;
-    ctx.pmod = sp;
-    ctx.options = options;
-    ctx.path_len = 1;
-    ctx.path[0] = '/';
-
-    mod->compiled = mod_c = calloc(1, sizeof *mod_c);
-    LY_CHECK_ERR_RET(!mod_c, LOGMEM(mod->ctx), LY_EMEM);
-    mod_c->mod = mod;
-
-    /* process imports */
-    LY_ARRAY_FOR(sp->imports, u) {
-        LY_CHECK_GOTO(ret = lys_compile_import(&ctx, &sp->imports[u]), error);
-    }
-
-    /* features */
-    LY_CHECK_GOTO(ret = lys_compile_features(&ctx), error);
-
-    /* identities, work similarly to features with the precompilation */
-    LY_CHECK_GOTO(ret = lys_compile_identities(&ctx), error);
-
-    /* augments and deviations */
-    LY_CHECK_GOTO(ret = lys_precompile_augments_deviations(&ctx), error);
-
-    /* compile augments and deviations of our module from other modules so they can be applied during compilation */
-    LY_CHECK_GOTO(ret = lys_precompile_own_augments(&ctx), error);
-    LY_CHECK_GOTO(ret = lys_precompile_own_deviations(&ctx), error);
-
-    /* data nodes */
-    LY_LIST_FOR(sp->data, pnode) {
-        LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), error);
-    }
-
-    /* top-level RPCs and notifications */
-    COMPILE_OP_ARRAY_GOTO(&ctx, sp->rpcs, mod_c->rpcs, NULL, u, lys_compile_action, 0, ret, error);
-    COMPILE_OP_ARRAY_GOTO(&ctx, sp->notifs, mod_c->notifs, NULL, u, lys_compile_notif, 0, ret, error);
-
-    /* extension instances */
-    COMPILE_EXTS_GOTO(&ctx, sp->exts, mod_c->exts, mod_c, LYEXT_PAR_MODULE, ret, error);
-
-    /* the same for submodules */
-    LY_ARRAY_FOR(sp->includes, u) {
-        submod = sp->includes[u].submodule;
-        ctx.pmod = (struct lysp_module *)submod;
-
-        LY_LIST_FOR(submod->data, pnode) {
-            ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
-            LY_CHECK_GOTO(ret, error);
-        }
-
-        COMPILE_OP_ARRAY_GOTO(&ctx, submod->rpcs, mod_c->rpcs, NULL, v, lys_compile_action, 0, ret, error);
-        COMPILE_OP_ARRAY_GOTO(&ctx, submod->notifs, mod_c->notifs, NULL, v, lys_compile_notif, 0, ret, error);
-
-        COMPILE_EXTS_GOTO(&ctx, submod->exts, mod_c->exts, mod_c, LYEXT_PAR_MODULE, ret, error);
-    }
-
-    /* finish compilation for all unresolved items in the context */
-    LY_CHECK_GOTO(ret = lys_compile_unres(&ctx), error);
-
-    /* validate non-instantiated groupings from the parsed schema,
-     * without it we would accept even the schemas with invalid grouping specification */
-    ctx.pmod = sp;
-    ctx.options |= LYS_COMPILE_GROUPING;
-    LY_ARRAY_FOR(sp->groupings, u) {
-        if (!(sp->groupings[u].flags & LYS_USED_GRP)) {
-            LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, &sp->groupings[u]), error);
-        }
-    }
-    LY_LIST_FOR(sp->data, pnode) {
-        grps = (struct lysp_grp *)lysp_node_groupings(pnode);
-        LY_ARRAY_FOR(grps, u) {
-            if (!(grps[u].flags & LYS_USED_GRP)) {
-                LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, &grps[u]), error);
-            }
-        }
-    }
-    LY_ARRAY_FOR(sp->includes, u) {
-        submod = sp->includes[u].submodule;
-        ctx.pmod = (struct lysp_module *)submod;
-
-        LY_ARRAY_FOR(submod->groupings, u) {
-            if (!(submod->groupings[u].flags & LYS_USED_GRP)) {
-                LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, &submod->groupings[u]), error);
-            }
-        }
-        LY_LIST_FOR(submod->data, pnode) {
-            grps = (struct lysp_grp *)lysp_node_groupings(pnode);
-            LY_ARRAY_FOR(grps, u) {
-                if (!(grps[u].flags & LYS_USED_GRP)) {
-                    LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, &grps[u]), error);
-                }
-            }
-        }
-    }
-    ctx.pmod = sp;
-
-#if 0
-    /* hack for NETCONF's edit-config's operation attribute. It is not defined in the schema, but since libyang
-     * implements YANG metadata (annotations), we need its definition. Because the ietf-netconf schema is not the
-     * internal part of libyang, we cannot add the annotation into the schema source, but we do it here to have
-     * the anotation definitions available in the internal schema structure. */
-    if (ly_strequal(mod->name, "ietf-netconf", 0)) {
-        if (lyp_add_ietf_netconf_annotations(mod)) {
-            lys_free(mod, NULL, 1, 1);
-            return NULL;
-        }
-    }
-#endif
-
-    /* add ietf-netconf-with-defaults "default" metadata to the compiled module */
-    if (!strcmp(mod->name, "ietf-netconf-with-defaults")) {
-        LY_CHECK_GOTO(ret = lys_compile_ietf_netconf_wd_annotation(&ctx, mod), error);
-    }
-
-    /* there can be no leftover deviations */
-    LY_CHECK_ERR_GOTO(ctx.devs.count, LOGINT(ctx.ctx); ret = LY_EINT, error);
-
-    for (i = 0; i < ctx.dflts.count; ++i) {
-        lysc_unres_dflt_free(ctx.ctx, ctx.dflts.objs[i]);
-    }
-    ly_set_erase(&ctx.dflts, NULL);
-    ly_set_erase(&ctx.xpath, NULL);
-    ly_set_erase(&ctx.leafrefs, NULL);
-    ly_set_erase(&ctx.groupings, NULL);
-    ly_set_erase(&ctx.tpdf_chain, NULL);
-    ly_set_erase(&ctx.augs, NULL);
-    ly_set_erase(&ctx.devs, NULL);
-    ly_set_erase(&ctx.uses_augs, NULL);
-    ly_set_erase(&ctx.uses_rfns, NULL);
-
-    return LY_SUCCESS;
-
-error:
-    lys_precompile_augments_deviations_revert(ctx.ctx, mod);
-    lys_feature_precompile_revert(&ctx, mod);
-    for (i = 0; i < ctx.dflts.count; ++i) {
-        lysc_unres_dflt_free(ctx.ctx, ctx.dflts.objs[i]);
-    }
-    ly_set_erase(&ctx.dflts, NULL);
-    ly_set_erase(&ctx.xpath, NULL);
-    ly_set_erase(&ctx.leafrefs, NULL);
-    ly_set_erase(&ctx.groupings, NULL);
-    ly_set_erase(&ctx.tpdf_chain, NULL);
-    for (i = 0; i < ctx.augs.count; ++i) {
-        lysc_augment_free(ctx.ctx, ctx.augs.objs[i]);
-    }
-    ly_set_erase(&ctx.augs, NULL);
-    for (i = 0; i < ctx.devs.count; ++i) {
-        lysc_deviation_free(ctx.ctx, ctx.devs.objs[i]);
-    }
-    ly_set_erase(&ctx.devs, NULL);
-    for (i = 0; i < ctx.uses_augs.count; ++i) {
-        lysc_augment_free(ctx.ctx, ctx.uses_augs.objs[i]);
-    }
-    ly_set_erase(&ctx.uses_augs, NULL);
-    for (i = 0; i < ctx.uses_rfns.count; ++i) {
-        lysc_refine_free(ctx.ctx, ctx.uses_rfns.objs[i]);
-    }
-    ly_set_erase(&ctx.uses_rfns, NULL);
-    lysc_module_free(mod_c, NULL);
-    mod->compiled = NULL;
-
-    return ret;
-}
diff --git a/src/tree_schema_helpers.c b/src/tree_schema_helpers.c
index c3a166c..f6b2eba 100644
--- a/src/tree_schema_helpers.c
+++ b/src/tree_schema_helpers.c
@@ -53,29 +53,6 @@
 }
 
 LY_ERR
-lysc_check_status(struct lysc_ctx *ctx,
-        uint16_t flags1, void *mod1, const char *name1,
-        uint16_t flags2, void *mod2, const char *name2)
-{
-    uint16_t flg1, flg2;
-
-    flg1 = (flags1 & LYS_STATUS_MASK) ? (flags1 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
-    flg2 = (flags2 & LYS_STATUS_MASK) ? (flags2 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
-
-    if ((flg1 < flg2) && (mod1 == mod2)) {
-        if (ctx) {
-            LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
-                    "A %s definition \"%s\" is not allowed to reference %s definition \"%s\".",
-                    flg1 == LYS_STATUS_CURR ? "current" : "deprecated", name1,
-                    flg2 == LYS_STATUS_OBSLT ? "obsolete" : "deprecated", name2);
-        }
-        return LY_EVALID;
-    }
-
-    return LY_SUCCESS;
-}
-
-LY_ERR
 lysp_check_date(struct lys_parser_ctx *ctx, const char *date, uint8_t date_len, const char *stmt)
 {
     struct tm tm, tm_;
diff --git a/src/tree_schema_internal.h b/src/tree_schema_internal.h
index a2e8d41..4bcd71a 100644
--- a/src/tree_schema_internal.h
+++ b/src/tree_schema_internal.h
@@ -22,6 +22,8 @@
 #include "tree_schema.h"
 #include "xml.h"
 
+struct lysc_ctx;
+
 #define YIN_NS_URI "urn:ietf:params:xml:ns:yang:yin:1"
 
 /**
@@ -156,77 +158,6 @@
 void yin_parser_ctx_free(struct lys_yin_parser_ctx *ctx);
 
 /**
- * @brief Structure for remembering default values of leaves and leaf-lists. They are resolved at schema compilation
- * end when the whole schema tree is available.
- */
-struct lysc_unres_dflt {
-    union {
-        struct lysc_node_leaf *leaf;
-        struct lysc_node_leaflist *llist;
-    };
-    struct lysp_qname *dflt;
-    struct lysp_qname *dflts;           /**< this is a sized array */
-};
-
-/**
- * @brief Compiled parsed augment structure. Just a temporary storage for applying the augment to data.
- */
-struct lysc_augment {
-    struct lyxp_expr *nodeid;                    /**< augment target */
-    const struct lysp_module *nodeid_pmod;       /**< module where the nodeid is defined, used to resolve prefixes */
-    const struct lysc_node *nodeid_ctx_node;     /**< nodeid context node for relative targets */
-
-    struct lysp_augment *aug_p;                  /**< pointer to the parsed augment to apply */
-};
-
-/**
- * @brief Compiled parsed deviation structure. Just a temporary storage for applying the deviation to data.
- */
-struct lysc_deviation {
-    struct lyxp_expr *nodeid;                    /**< deviation target, taken from the first deviation in
-                                                      ::lysc_deviation.dev_pmods array, this module is used for resolving
-                                                      prefixes used in the nodeid. */
-
-    struct lysp_deviation **devs;                /**< sized array of all the parsed deviations for one target node */
-    const struct lysp_module **dev_pmods;        /**< sized array of parsed modules of @p devs (where the specific deviations
-                                                      are defined). */
-    ly_bool not_supported;                       /**< whether this is a not-supported deviation */
-};
-
-/**
- * @brief Compiled parsed refine structure. Just a temporary storage for applying the refine to data.
- */
-struct lysc_refine {
-    struct lyxp_expr *nodeid;                    /**< refine target */
-    const struct lysp_module *nodeid_pmod;       /**< module where the nodeid is defined, used to resolve prefixes */
-    const struct lysc_node *nodeid_ctx_node;     /**< nodeid context node */
-
-    struct lysp_refine **rfns;                   /**< sized array of parsed refines to apply */
-};
-
-/**
- * @brief internal context for compilation
- */
-struct lysc_ctx {
-    struct ly_ctx *ctx;
-    struct lys_module *cur_mod; /**< module currently being compiled, used as the current module for unprefixed nodes */
-    struct lysp_module *pmod;   /**< parsed module being processed, used for searching imports to resolve prefixed nodes */
-    struct ly_set groupings;    /**< stack for groupings circular check */
-    struct ly_set xpath;        /**< when/must to check */
-    struct ly_set leafrefs;     /**< to validate leafref's targets */
-    struct ly_set dflts;        /**< set of incomplete default values */
-    struct ly_set tpdf_chain;
-    struct ly_set augs;         /**< set of compiled non-applied top-level augments */
-    struct ly_set devs;         /**< set of compiled non-applied deviations */
-    struct ly_set uses_augs;    /**< set of compiled non-applied uses augments */
-    struct ly_set uses_rfns;    /**< set of compiled non-applied uses refines */
-    uint32_t path_len;
-    uint32_t options;           /**< various @ref scflags. */
-#define LYSC_CTX_BUFSIZE 4078
-    char path[LYSC_CTX_BUFSIZE];
-};
-
-/**
  * @brief Check that \p c is valid UTF8 code point for YANG string.
  *
  * @param[in] ctx parser context for logging.
@@ -400,25 +331,6 @@
 void lysp_notif_free(struct ly_ctx *ctx, struct lysp_notif *notif);
 
 /**
- * @brief Revert precompilation of module augments and deviations. Meaning remove its reference from
- * all the target modules.
- *
- * @param[in] ctx libyang context.
- * @param[in] mod Mod whose precompilation to revert.
- */
-void lys_precompile_augments_deviations_revert(struct ly_ctx *ctx, const struct lys_module *mod);
-
-/**
- * @brief Compile printable schema into a validated schema linking all the references.
- *
- * @param[in] mod Pointer to the schema structure holding pointers to both schema structure types. The ::lys_module#parsed
- * member is used as input and ::lys_module#compiled is used to hold the result of the compilation.
- * @param[in] options Various options to modify compiler behavior, see [compile flags](@ref scflags).
- * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
- */
-LY_ERR lys_compile(struct lys_module *mod, uint32_t options);
-
-/**
  * @brief Get address of a node's actions list if any.
  *
  * Decides the node's type and in case it has an actions list, returns its address.
@@ -494,26 +406,6 @@
 struct lys_module *lysp_find_module(struct ly_ctx *ctx, const struct lysp_module *mod);
 
 /**
- * @brief Check statement's status for invalid combination.
- *
- * The modX parameters are used just to determine if both flags are in the same module,
- * so any of the schema module structure can be used, but both modules must be provided
- * in the same type.
- *
- * @param[in] ctx Compile context for logging.
- * @param[in] flags1 Flags of the referencing node.
- * @param[in] mod1 Module of the referencing node,
- * @param[in] name1 Schema node name of the referencing node.
- * @param[in] flags2 Flags of the referenced node.
- * @param[in] mod2 Module of the referenced node,
- * @param[in] name2 Schema node name of the referenced node.
- * @return LY_ERR value
- */
-LY_ERR lysc_check_status(struct lysc_ctx *ctx,
-        uint16_t flags1, void *mod1, const char *name1,
-        uint16_t flags2, void *mod2, const char *name2);
-
-/**
  * @brief Find the module referenced by prefix in the provided mod.
  *
  * @param[in] prefix_mod Schema module where the prefix was used.
@@ -600,47 +492,6 @@
         struct lys_parser_ctx *main_ctx, const char *main_name, ly_bool required, void **result);
 
 /**
- * @brief Compile information from the identity statement
- *
- * The backlinks to the identities derived from this one are supposed to be filled later via lys_compile_identity_bases().
- *
- * @param[in] ctx_sc Compile context - alternative to the combination of @p ctx and @p parsed_mod.
- * @param[in] ctx libyang context.
- * @param[in] parsed_mod Module with the identities.
- * @param[in] identities_p Array of the parsed identity definitions to precompile.
- * @param[in,out] identities Pointer to the storage of the (pre)compiled identities array where the new identities are
- * supposed to be added. The storage is supposed to be initiated to NULL when the first parsed identities are going
- * to be processed.
- * @return LY_ERR value.
- */
-LY_ERR lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
-        struct lysp_ident *identities_p, struct lysc_ident **identities);
-
-/**
- * @brief Create pre-compiled features array.
- *
- * Features are compiled in two steps to allow forward references between them via their if-feature statements.
- * In case of not implemented schemas, the precompiled list of features is stored in lys_module structure and
- * the compilation is not finished (if-feature and extensions are missing) and all the features are permanently
- * disabled without a chance to change it. The list is used as target for any if-feature statement in any
- * implemented module to get valid data to evaluate its result. The compilation is finished via
- * lys_feature_precompile_finish() in implemented modules. In case a not implemented module becomes implemented,
- * the precompiled list is reused to finish the compilation to preserve pointers already used in various compiled
- * if-feature structures.
- *
- * @param[in] ctx_sc Compile context - alternative to the combination of @p ctx and @p parsed_mod.
- * @param[in] ctx libyang context.
- * @param[in] parsed_mod Module with the features.
- * @param[in] features_p Array of the parsed features definitions to precompile.
- * @param[in,out] features Pointer to the storage of the (pre)compiled features array where the new features are
- * supposed to be added. The storage is supposed to be initiated to NULL when the first parsed features are going
- * to be processed.
- * @return LY_ERR value.
- */
-LY_ERR lys_feature_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
-        struct lysp_feature *features_p, struct lysc_feature **features);
-
-/**
  * @brief Get the @ref ifftokens from the given position in the 2bits array
  * (libyang format of the if-feature expression).
  * @param[in] list The 2bits array with the compiled if-feature expression.
@@ -649,17 +500,6 @@
 uint8_t lysc_iff_getop(uint8_t *list, size_t pos);
 
 /**
- * @brief Checks pattern syntax.
- *
- * @param[in] ctx Context.
- * @param[in] log_path Path for logging errors.
- * @param[in] pattern Pattern to check.
- * @param[in,out] pcre2_code Compiled PCRE2 pattern. If NULL, the compiled information used to validate pattern are freed.
- * @return LY_ERR value - LY_SUCCESS, LY_EMEM, LY_EVALID.
- */
-LY_ERR lys_compile_type_pattern_check(struct ly_ctx *ctx, const char *log_path, const char *pattern, pcre2_code **code);
-
-/**
  * @brief Macro to free [sized array](@ref sizedarrays) of items using the provided free function. The ARRAY itself is also freed,
  * but the memory is not sanitized.
  */
diff --git a/src/xpath.c b/src/xpath.c
index 1a121b3..7d5ddd9 100644
--- a/src/xpath.c
+++ b/src/xpath.c
@@ -38,6 +38,7 @@
 #include "plugins_types.h"
 #include "printer.h"
 #include "printer_data.h"
+#include "schema_compile_node.h"
 #include "tree.h"
 #include "tree_data_internal.h"
 #include "tree_schema_internal.h"
diff --git a/tests/utests/schema/test_tree_schema_compile.c b/tests/utests/schema/test_tree_schema_compile.c
index e668ced..95dd8a0 100644
--- a/tests/utests/schema/test_tree_schema_compile.c
+++ b/tests/utests/schema/test_tree_schema_compile.c
@@ -24,7 +24,7 @@
 #include "parser_internal.h"
 #include "path.h"
 #include "plugins_types.h"
-#include "tree_schema_internal.h"
+#include "schema_compile.h"
 #include "xpath.h"
 
 void lysc_feature_free(struct ly_ctx *ctx, struct lysc_feature *feat);
diff --git a/tests/utests/test_context.c b/tests/utests/test_context.c
index 495a652..a139bf5 100644
--- a/tests/utests/test_context.c
+++ b/tests/utests/test_context.c
@@ -25,6 +25,7 @@
 #include "parser.h"
 #include "tests/config.h"
 #include "tree_schema_internal.h"
+#include "schema_compile.h"
 
 #define BUFSIZE 1024
 char logbuf[BUFSIZE] = {0};