Adding upstream version 2.1.30.upstream/2.1.30upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 9883 insertions, 0 deletions

diff --git a/src/xpath.c b/src/xpath.c
new file mode 100644
index 0000000..ab7921e
--- /dev/null
+++ b/src/xpath.c
@@ -0,0 +1,9883 @@
+/**
+ * @file xpath.c
+ * @author Michal Vasko <mvasko@cesnet.cz>
+ * @brief YANG XPath evaluation functions
+ *
+ * Copyright (c) 2015 - 2022 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 /* asprintf, strdup */
+
+#include "xpath.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <math.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 "hash_table.h"
+#include "out.h"
+#include "parser_data.h"
+#include "path.h"
+#include "plugins_exts/metadata.h"
+#include "plugins_types.h"
+#include "printer_data.h"
+#include "schema_compile_node.h"
+#include "tree.h"
+#include "tree_data.h"
+#include "tree_data_internal.h"
+#include "tree_edit.h"
+#include "tree_schema_internal.h"
+#include "xml.h"
+
+static LY_ERR set_scnode_insert_node(struct lyxp_set *set, const struct lysc_node *node, enum lyxp_node_type node_type,
+        enum lyxp_axis axis, uint32_t *index_p);
+static LY_ERR reparse_or_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth);
+static LY_ERR eval_expr_select(const struct lyxp_expr *exp, uint32_t *tok_idx, enum lyxp_expr_type etype,
+        struct lyxp_set *set, uint32_t options);
+static LY_ERR moveto_resolve_model(const char **qname, uint32_t *qname_len, const struct lyxp_set *set,
+        const struct lysc_node *ctx_scnode, const struct lys_module **moveto_mod);
+static LY_ERR moveto_axis_node_next(const struct lyd_node **iter, enum lyxp_node_type *iter_type,
+        const struct lyd_node *node, enum lyxp_node_type node_type, enum lyxp_axis axis, struct lyxp_set *set);
+static LY_ERR moveto_node(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname,
+        enum lyxp_axis axis, uint32_t options);
+static LY_ERR moveto_scnode(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname,
+        enum lyxp_axis axis, uint32_t options);
+static LY_ERR moveto_op_comp(struct lyxp_set *set1, struct lyxp_set *set2, const char *op, ly_bool *result);
+
+/* Functions are divided into the following basic classes:
+ *
+ * (re)parse functions:
+ * Parse functions parse the expression into
+ * tokens (syntactic analysis).
+ * Reparse functions perform semantic analysis
+ * (do not save the result, just a check) of
+ * the expression and fill repeat indices.
+ *
+ * warn functions:
+ * Warn functions check specific reasonable conditions for schema XPath
+ * and print a warning if they are not satisfied.
+ *
+ * moveto functions:
+ * They and only they actually change the context (set).
+ *
+ * eval functions:
+ * They execute a parsed XPath expression on some data subtree.
+ */
+
+/**
+ * @brief Print the type of an XPath \p set.
+ *
+ * @param[in] set Set to use.
+ * @return Set type string.
+ */
+static const char *
+print_set_type(struct lyxp_set *set)
+{
+    switch (set->type) {
+    case LYXP_SET_NODE_SET:
+        return "node set";
+    case LYXP_SET_SCNODE_SET:
+        return "schema node set";
+    case LYXP_SET_BOOLEAN:
+        return "boolean";
+    case LYXP_SET_NUMBER:
+        return "number";
+    case LYXP_SET_STRING:
+        return "string";
+    }
+
+    return NULL;
+}
+
+const char *
+lyxp_token2str(enum lyxp_token tok)
+{
+    switch (tok) {
+    case LYXP_TOKEN_PAR1:
+        return "(";
+    case LYXP_TOKEN_PAR2:
+        return ")";
+    case LYXP_TOKEN_BRACK1:
+        return "[";
+    case LYXP_TOKEN_BRACK2:
+        return "]";
+    case LYXP_TOKEN_DOT:
+        return ".";
+    case LYXP_TOKEN_DDOT:
+        return "..";
+    case LYXP_TOKEN_AT:
+        return "@";
+    case LYXP_TOKEN_COMMA:
+        return ",";
+    case LYXP_TOKEN_NAMETEST:
+        return "NameTest";
+    case LYXP_TOKEN_NODETYPE:
+        return "NodeType";
+    case LYXP_TOKEN_VARREF:
+        return "VariableReference";
+    case LYXP_TOKEN_FUNCNAME:
+        return "FunctionName";
+    case LYXP_TOKEN_OPER_LOG:
+        return "Operator(Logic)";
+    case LYXP_TOKEN_OPER_EQUAL:
+        return "Operator(Equal)";
+    case LYXP_TOKEN_OPER_NEQUAL:
+        return "Operator(Non-equal)";
+    case LYXP_TOKEN_OPER_COMP:
+        return "Operator(Comparison)";
+    case LYXP_TOKEN_OPER_MATH:
+        return "Operator(Math)";
+    case LYXP_TOKEN_OPER_UNI:
+        return "Operator(Union)";
+    case LYXP_TOKEN_OPER_PATH:
+        return "Operator(Path)";
+    case LYXP_TOKEN_OPER_RPATH:
+        return "Operator(Recursive Path)";
+    case LYXP_TOKEN_LITERAL:
+        return "Literal";
+    case LYXP_TOKEN_NUMBER:
+        return "Number";
+    default:
+        LOGINT(NULL);
+        return "";
+    }
+}
+
+/**
+ * @brief Transform string into an axis.
+ *
+ * @param[in] str String to transform.
+ * @param[in] str_len Length of @p str.
+ * @return Transformed axis.
+ */
+static enum lyxp_axis
+str2axis(const char *str, uint32_t str_len)
+{
+    switch (str_len) {
+    case 4:
+        assert(!strncmp("self", str, str_len));
+        return LYXP_AXIS_SELF;
+    case 5:
+        assert(!strncmp("child", str, str_len));
+        return LYXP_AXIS_CHILD;
+    case 6:
+        assert(!strncmp("parent", str, str_len));
+        return LYXP_AXIS_PARENT;
+    case 8:
+        assert(!strncmp("ancestor", str, str_len));
+        return LYXP_AXIS_ANCESTOR;
+    case 9:
+        if (str[0] == 'a') {
+            assert(!strncmp("attribute", str, str_len));
+            return LYXP_AXIS_ATTRIBUTE;
+        } else if (str[0] == 'f') {
+            assert(!strncmp("following", str, str_len));
+            return LYXP_AXIS_FOLLOWING;
+        } else {
+            assert(!strncmp("preceding", str, str_len));
+            return LYXP_AXIS_PRECEDING;
+        }
+        break;
+    case 10:
+        assert(!strncmp("descendant", str, str_len));
+        return LYXP_AXIS_DESCENDANT;
+    case 16:
+        assert(!strncmp("ancestor-or-self", str, str_len));
+        return LYXP_AXIS_ANCESTOR_OR_SELF;
+    case 17:
+        if (str[0] == 'f') {
+            assert(!strncmp("following-sibling", str, str_len));
+            return LYXP_AXIS_FOLLOWING_SIBLING;
+        } else {
+            assert(!strncmp("preceding-sibling", str, str_len));
+            return LYXP_AXIS_PRECEDING_SIBLING;
+        }
+        break;
+    case 18:
+        assert(!strncmp("descendant-or-self", str, str_len));
+        return LYXP_AXIS_DESCENDANT_OR_SELF;
+    }
+
+    LOGINT(NULL);
+    return 0;
+}
+
+/**
+ * @brief Print the whole expression \p exp to debug output.
+ *
+ * @param[in] exp Expression to use.
+ */
+static void
+print_expr_struct_debug(const struct lyxp_expr *exp)
+{
+#define MSG_BUFFER_SIZE 128
+    char tmp[MSG_BUFFER_SIZE];
+    uint32_t i, j;
+
+    if (!exp || (ly_ll < LY_LLDBG)) {
+        return;
+    }
+
+    LOGDBG(LY_LDGXPATH, "expression \"%s\":", exp->expr);
+    for (i = 0; i < exp->used; ++i) {
+        sprintf(tmp, "\ttoken %s, in expression \"%.*s\"", lyxp_token2str(exp->tokens[i]), exp->tok_len[i],
+                &exp->expr[exp->tok_pos[i]]);
+        if (exp->repeat && exp->repeat[i]) {
+            sprintf(tmp + strlen(tmp), " (repeat %d", exp->repeat[i][0]);
+            for (j = 1; exp->repeat[i][j]; ++j) {
+                sprintf(tmp + strlen(tmp), ", %d", exp->repeat[i][j]);
+            }
+            strcat(tmp, ")");
+        }
+        LOGDBG(LY_LDGXPATH, tmp);
+    }
+#undef MSG_BUFFER_SIZE
+}
+
+#ifndef NDEBUG
+
+/**
+ * @brief Print XPath set content to debug output.
+ *
+ * @param[in] set Set to print.
+ */
+static void
+print_set_debug(struct lyxp_set *set)
+{
+    uint32_t i;
+    char *str;
+    struct lyxp_set_node *item;
+    struct lyxp_set_scnode *sitem;
+
+    if (ly_ll < LY_LLDBG) {
+        return;
+    }
+
+    switch (set->type) {
+    case LYXP_SET_NODE_SET:
+        LOGDBG(LY_LDGXPATH, "set NODE SET:");
+        for (i = 0; i < set->used; ++i) {
+            item = &set->val.nodes[i];
+
+            switch (item->type) {
+            case LYXP_NODE_NONE:
+                LOGDBG(LY_LDGXPATH, "\t%d (pos %u): NONE", i + 1, item->pos);
+                break;
+            case LYXP_NODE_ROOT:
+                LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ROOT", i + 1, item->pos);
+                break;
+            case LYXP_NODE_ROOT_CONFIG:
+                LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ROOT CONFIG", i + 1, item->pos);
+                break;
+            case LYXP_NODE_ELEM:
+                if ((item->node->schema->nodetype == LYS_LIST) && (lyd_child(item->node)->schema->nodetype == LYS_LEAF)) {
+                    LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s (1st child val: %s)", i + 1, item->pos,
+                            item->node->schema->name, lyd_get_value(lyd_child(item->node)));
+                } else if (item->node->schema->nodetype == LYS_LEAFLIST) {
+                    LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s (val: %s)", i + 1, item->pos,
+                            item->node->schema->name, lyd_get_value(item->node));
+                } else {
+                    LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s", i + 1, item->pos, item->node->schema->name);
+                }
+                break;
+            case LYXP_NODE_TEXT:
+                if (item->node->schema->nodetype & LYS_ANYDATA) {
+                    LOGDBG(LY_LDGXPATH, "\t%d (pos %u): TEXT <%s>", i + 1, item->pos,
+                            item->node->schema->nodetype == LYS_ANYXML ? "anyxml" : "anydata");
+                } else {
+                    LOGDBG(LY_LDGXPATH, "\t%d (pos %u): TEXT %s", i + 1, item->pos, lyd_get_value(item->node));
+                }
+                break;
+            case LYXP_NODE_META:
+                LOGDBG(LY_LDGXPATH, "\t%d (pos %u): META %s = %s", i + 1, item->pos, set->val.meta[i].meta->name,
+                        set->val.meta[i].meta->value);
+                break;
+            }
+        }
+        break;
+
+    case LYXP_SET_SCNODE_SET:
+        LOGDBG(LY_LDGXPATH, "set SCNODE SET:");
+        for (i = 0; i < set->used; ++i) {
+            sitem = &set->val.scnodes[i];
+
+            switch (sitem->type) {
+            case LYXP_NODE_ROOT:
+                LOGDBG(LY_LDGXPATH, "\t%d (%u): ROOT", i + 1, sitem->in_ctx);
+                break;
+            case LYXP_NODE_ROOT_CONFIG:
+                LOGDBG(LY_LDGXPATH, "\t%d (%u): ROOT CONFIG", i + 1, sitem->in_ctx);
+                break;
+            case LYXP_NODE_ELEM:
+                LOGDBG(LY_LDGXPATH, "\t%d (%u): ELEM %s", i + 1, sitem->in_ctx, sitem->scnode->name);
+                break;
+            default:
+                LOGINT(NULL);
+                break;
+            }
+        }
+        break;
+
+    case LYXP_SET_BOOLEAN:
+        LOGDBG(LY_LDGXPATH, "set BOOLEAN");
+        LOGDBG(LY_LDGXPATH, "\t%s", (set->val.bln ? "true" : "false"));
+        break;
+
+    case LYXP_SET_STRING:
+        LOGDBG(LY_LDGXPATH, "set STRING");
+        LOGDBG(LY_LDGXPATH, "\t%s", set->val.str);
+        break;
+
+    case LYXP_SET_NUMBER:
+        LOGDBG(LY_LDGXPATH, "set NUMBER");
+
+        if (isnan(set->val.num)) {
+            str = strdup("NaN");
+        } else if ((set->val.num == 0) || (set->val.num == -0.0f)) {
+            str = strdup("0");
+        } else if (isinf(set->val.num) && !signbit(set->val.num)) {
+            str = strdup("Infinity");
+        } else if (isinf(set->val.num) && signbit(set->val.num)) {
+            str = strdup("-Infinity");
+        } else if ((long long)set->val.num == set->val.num) {
+            if (asprintf(&str, "%lld", (long long)set->val.num) == -1) {
+                str = NULL;
+            }
+        } else {
+            if (asprintf(&str, "%03.1Lf", set->val.num) == -1) {
+                str = NULL;
+            }
+        }
+        LY_CHECK_ERR_RET(!str, LOGMEM(NULL), );
+
+        LOGDBG(LY_LDGXPATH, "\t%s", str);
+        free(str);
+    }
+}
+
+#endif
+
+/**
+ * @brief Realloc the string \p str.
+ *
+ * @param[in] ctx libyang context for logging.
+ * @param[in] needed How much free space is required.
+ * @param[in,out] str Pointer to the string to use.
+ * @param[in,out] used Used bytes in \p str.
+ * @param[in,out] size Allocated bytes in \p str.
+ * @return LY_ERR
+ */
+static LY_ERR
+cast_string_realloc(const struct ly_ctx *ctx, uint64_t needed, char **str, uint32_t *used, uint32_t *size)
+{
+    if (*size - (unsigned)*used < needed) {
+        do {
+            if ((UINT32_MAX - *size) < LYXP_STRING_CAST_SIZE_STEP) {
+                LOGERR(ctx, LY_EINVAL, "XPath string length limit (%" PRIu32 ") reached.", UINT32_MAX);
+                return LY_EINVAL;
+            }
+            *size += LYXP_STRING_CAST_SIZE_STEP;
+        } while (*size - (unsigned)*used < needed);
+        *str = ly_realloc(*str, *size * sizeof(char));
+        LY_CHECK_ERR_RET(!(*str), LOGMEM(ctx), LY_EMEM);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Cast nodes recursively to one string @p str.
+ *
+ * @param[in] node Node to cast, NULL if root.
+ * @param[in] set XPath set.
+ * @param[in] indent Current indent.
+ * @param[in,out] str Resulting string.
+ * @param[in,out] used Used bytes in @p str.
+ * @param[in,out] size Allocated bytes in @p str.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+cast_string_recursive(const struct lyd_node *node, struct lyxp_set *set, uint32_t indent, char **str, uint32_t *used,
+        uint32_t *size)
+{
+    char *buf, *line, *ptr = NULL;
+    const char *value_str;
+    const struct lyd_node *child;
+    enum lyxp_node_type child_type;
+    struct lyd_node *tree;
+    struct lyd_node_any *any;
+    LY_ERR rc;
+
+    if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && node && (node->schema->flags & LYS_CONFIG_R)) {
+        return LY_SUCCESS;
+    }
+
+    if (!node) {
+        /* fake container */
+        LY_CHECK_RET(cast_string_realloc(set->ctx, 1, str, used, size));
+        strcpy(*str + (*used - 1), "\n");
+        ++(*used);
+
+        ++indent;
+
+        /* print all the top-level nodes */
+        child = NULL;
+        child_type = 0;
+        while (!moveto_axis_node_next(&child, &child_type, NULL, set->root_type, LYXP_AXIS_CHILD, set)) {
+            LY_CHECK_RET(cast_string_recursive(child, set, indent, str, used, size));
+        }
+
+        /* end fake container */
+        LY_CHECK_RET(cast_string_realloc(set->ctx, 1, str, used, size));
+        strcpy(*str + (*used - 1), "\n");
+        ++(*used);
+
+        --indent;
+    } else {
+        switch (node->schema->nodetype) {
+        case LYS_CONTAINER:
+        case LYS_LIST:
+        case LYS_RPC:
+        case LYS_NOTIF:
+            LY_CHECK_RET(cast_string_realloc(set->ctx, 1, str, used, size));
+            strcpy(*str + (*used - 1), "\n");
+            ++(*used);
+
+            for (child = lyd_child(node); child; child = child->next) {
+                LY_CHECK_RET(cast_string_recursive(child, set, indent + 1, str, used, size));
+            }
+
+            break;
+
+        case LYS_LEAF:
+        case LYS_LEAFLIST:
+            value_str = lyd_get_value(node);
+
+            /* print indent */
+            LY_CHECK_RET(cast_string_realloc(set->ctx, indent * 2 + strlen(value_str) + 1, str, used, size));
+            memset(*str + (*used - 1), ' ', indent * 2);
+            *used += indent * 2;
+
+            /* print value */
+            if (*used == 1) {
+                sprintf(*str + (*used - 1), "%s", value_str);
+                *used += strlen(value_str);
+            } else {
+                sprintf(*str + (*used - 1), "%s\n", value_str);
+                *used += strlen(value_str) + 1;
+            }
+
+            break;
+
+        case LYS_ANYXML:
+        case LYS_ANYDATA:
+            any = (struct lyd_node_any *)node;
+            if (!(void *)any->value.tree) {
+                /* no content */
+                buf = strdup("");
+                LY_CHECK_ERR_RET(!buf, LOGMEM(set->ctx), LY_EMEM);
+            } else {
+                struct ly_out *out;
+
+                if (any->value_type == LYD_ANYDATA_LYB) {
+                    /* try to parse it into a data tree */
+                    if (lyd_parse_data_mem((struct ly_ctx *)set->ctx, any->value.mem, LYD_LYB,
+                            LYD_PARSE_ONLY | LYD_PARSE_STRICT, 0, &tree) == LY_SUCCESS) {
+                        /* successfully parsed */
+                        free(any->value.mem);
+                        any->value.tree = tree;
+                        any->value_type = LYD_ANYDATA_DATATREE;
+                    }
+                    /* error is covered by the following switch where LYD_ANYDATA_LYB causes failure */
+                }
+
+                switch (any->value_type) {
+                case LYD_ANYDATA_STRING:
+                case LYD_ANYDATA_XML:
+                case LYD_ANYDATA_JSON:
+                    buf = strdup(any->value.json);
+                    LY_CHECK_ERR_RET(!buf, LOGMEM(set->ctx), LY_EMEM);
+                    break;
+                case LYD_ANYDATA_DATATREE:
+                    LY_CHECK_RET(ly_out_new_memory(&buf, 0, &out));
+                    rc = lyd_print_all(out, any->value.tree, LYD_XML, 0);
+                    ly_out_free(out, NULL, 0);
+                    LY_CHECK_RET(rc < 0, -rc);
+                    break;
+                case LYD_ANYDATA_LYB:
+                    LOGERR(set->ctx, LY_EINVAL, "Cannot convert LYB anydata into string.");
+                    return LY_EINVAL;
+                }
+            }
+
+            line = strtok_r(buf, "\n", &ptr);
+            do {
+                rc = cast_string_realloc(set->ctx, indent * 2 + strlen(line) + 1, str, used, size);
+                if (rc != LY_SUCCESS) {
+                    free(buf);
+                    return rc;
+                }
+                memset(*str + (*used - 1), ' ', indent * 2);
+                *used += indent * 2;
+
+                strcpy(*str + (*used - 1), line);
+                *used += strlen(line);
+
+                strcpy(*str + (*used - 1), "\n");
+                *used += 1;
+            } while ((line = strtok_r(NULL, "\n", &ptr)));
+
+            free(buf);
+            break;
+
+        default:
+            LOGINT_RET(set->ctx);
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Cast an element into a string.
+ *
+ * @param[in] node Node to cast, NULL if root.
+ * @param[in] set XPath set.
+ * @param[out] str Element cast to dynamically-allocated string.
+ * @return LY_ERR
+ */
+static LY_ERR
+cast_string_elem(const struct lyd_node *node, struct lyxp_set *set, char **str)
+{
+    uint32_t used, size;
+    LY_ERR rc;
+
+    *str = malloc(LYXP_STRING_CAST_SIZE_START * sizeof(char));
+    LY_CHECK_ERR_RET(!*str, LOGMEM(set->ctx), LY_EMEM);
+    (*str)[0] = '\0';
+    used = 1;
+    size = LYXP_STRING_CAST_SIZE_START;
+
+    rc = cast_string_recursive(node, set, 0, str, &used, &size);
+    if (rc != LY_SUCCESS) {
+        free(*str);
+        return rc;
+    }
+
+    if (size > used) {
+        *str = ly_realloc(*str, used * sizeof(char));
+        LY_CHECK_ERR_RET(!*str, LOGMEM(set->ctx), LY_EMEM);
+    }
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Cast a LYXP_SET_NODE_SET set into a string.
+ *        Context position aware.
+ *
+ * @param[in] set Set to cast.
+ * @param[out] str Cast dynamically-allocated string.
+ * @return LY_ERR
+ */
+static LY_ERR
+cast_node_set_to_string(struct lyxp_set *set, char **str)
+{
+    if (!set->used) {
+        *str = strdup("");
+        if (!*str) {
+            LOGMEM_RET(set->ctx);
+        }
+        return LY_SUCCESS;
+    }
+
+    switch (set->val.nodes[0].type) {
+    case LYXP_NODE_NONE:
+        /* invalid */
+        LOGINT_RET(set->ctx);
+    case LYXP_NODE_ROOT:
+    case LYXP_NODE_ROOT_CONFIG:
+    case LYXP_NODE_ELEM:
+    case LYXP_NODE_TEXT:
+        return cast_string_elem(set->val.nodes[0].node, set, str);
+    case LYXP_NODE_META:
+        *str = strdup(lyd_get_meta_value(set->val.meta[0].meta));
+        if (!*str) {
+            LOGMEM_RET(set->ctx);
+        }
+        return LY_SUCCESS;
+    }
+
+    LOGINT_RET(set->ctx);
+}
+
+/**
+ * @brief Cast a string into an XPath number.
+ *
+ * @param[in] str String to use.
+ * @return Cast number.
+ */
+static long double
+cast_string_to_number(const char *str)
+{
+    long double num;
+    char *ptr;
+
+    errno = 0;
+    num = strtold(str, &ptr);
+    if (errno || *ptr) {
+        num = NAN;
+    }
+    return num;
+}
+
+/**
+ * @brief Callback for checking value equality.
+ *
+ * Implementation of ::lyht_value_equal_cb.
+ *
+ * @param[in] val1_p First value.
+ * @param[in] val2_p Second value.
+ * @param[in] mod Whether hash table is being modified.
+ * @param[in] cb_data Callback data.
+ * @return Boolean value whether values are equal or not.
+ */
+static ly_bool
+set_values_equal_cb(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *UNUSED(cb_data))
+{
+    struct lyxp_set_hash_node *val1, *val2;
+
+    val1 = (struct lyxp_set_hash_node *)val1_p;
+    val2 = (struct lyxp_set_hash_node *)val2_p;
+
+    if ((val1->node == val2->node) && (val1->type == val2->type)) {
+        return 1;
+    }
+
+    return 0;
+}
+
+/**
+ * @brief Insert node and its hash into set.
+ *
+ * @param[in] set et to insert to.
+ * @param[in] node Node with hash.
+ * @param[in] type Node type.
+ */
+static void
+set_insert_node_hash(struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type)
+{
+    LY_ERR r;
+    uint32_t i, hash;
+    struct lyxp_set_hash_node hnode;
+
+    if (!set->ht && (set->used >= LYD_HT_MIN_ITEMS)) {
+        /* create hash table and add all the nodes */
+        set->ht = lyht_new(1, sizeof(struct lyxp_set_hash_node), set_values_equal_cb, NULL, 1);
+        for (i = 0; i < set->used; ++i) {
+            hnode.node = set->val.nodes[i].node;
+            hnode.type = set->val.nodes[i].type;
+
+            hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
+            hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
+            hash = dict_hash_multi(hash, NULL, 0);
+
+            r = lyht_insert(set->ht, &hnode, hash, NULL);
+            assert(!r);
+            (void)r;
+
+            if (hnode.node == node) {
+                /* it was just added, do not add it twice */
+                node = NULL;
+            }
+        }
+    }
+
+    if (set->ht && node) {
+        /* add the new node into hash table */
+        hnode.node = node;
+        hnode.type = type;
+
+        hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
+        hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
+        hash = dict_hash_multi(hash, NULL, 0);
+
+        r = lyht_insert(set->ht, &hnode, hash, NULL);
+        assert(!r);
+        (void)r;
+    }
+}
+
+/**
+ * @brief Remove node and its hash from set.
+ *
+ * @param[in] set Set to remove from.
+ * @param[in] node Node to remove.
+ * @param[in] type Node type.
+ */
+static void
+set_remove_node_hash(struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type)
+{
+    LY_ERR r;
+    struct lyxp_set_hash_node hnode;
+    uint32_t hash;
+
+    if (set->ht) {
+        hnode.node = node;
+        hnode.type = type;
+
+        hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
+        hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
+        hash = dict_hash_multi(hash, NULL, 0);
+
+        r = lyht_remove(set->ht, &hnode, hash);
+        assert(!r);
+        (void)r;
+
+        if (!set->ht->used) {
+            lyht_free(set->ht);
+            set->ht = NULL;
+        }
+    }
+}
+
+/**
+ * @brief Check whether node is in set based on its hash.
+ *
+ * @param[in] set Set to search in.
+ * @param[in] node Node to search for.
+ * @param[in] type Node type.
+ * @param[in] skip_idx Index in @p set to skip.
+ * @return LY_ERR
+ */
+static LY_ERR
+set_dup_node_hash_check(const struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type, int skip_idx)
+{
+    struct lyxp_set_hash_node hnode, *match_p;
+    uint32_t hash;
+
+    hnode.node = node;
+    hnode.type = type;
+
+    hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
+    hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
+    hash = dict_hash_multi(hash, NULL, 0);
+
+    if (!lyht_find(set->ht, &hnode, hash, (void **)&match_p)) {
+        if ((skip_idx > -1) && (set->val.nodes[skip_idx].node == match_p->node) && (set->val.nodes[skip_idx].type == match_p->type)) {
+            /* we found it on the index that should be skipped, find another */
+            hnode = *match_p;
+            if (lyht_find_next(set->ht, &hnode, hash, (void **)&match_p)) {
+                /* none other found */
+                return LY_SUCCESS;
+            }
+        }
+
+        return LY_EEXIST;
+    }
+
+    /* not found */
+    return LY_SUCCESS;
+}
+
+void
+lyxp_set_free_content(struct lyxp_set *set)
+{
+    if (!set) {
+        return;
+    }
+
+    if (set->type == LYXP_SET_NODE_SET) {
+        free(set->val.nodes);
+        lyht_free(set->ht);
+    } else if (set->type == LYXP_SET_SCNODE_SET) {
+        free(set->val.scnodes);
+        lyht_free(set->ht);
+    } else {
+        if (set->type == LYXP_SET_STRING) {
+            free(set->val.str);
+        }
+        set->type = LYXP_SET_NODE_SET;
+    }
+
+    set->val.nodes = NULL;
+    set->used = 0;
+    set->size = 0;
+    set->ht = NULL;
+    set->ctx_pos = 0;
+    set->ctx_size = 0;
+}
+
+/**
+ * @brief Free dynamically-allocated set.
+ *
+ * @param[in] set Set to free.
+ */
+static void
+lyxp_set_free(struct lyxp_set *set)
+{
+    if (!set) {
+        return;
+    }
+
+    lyxp_set_free_content(set);
+    free(set);
+}
+
+/**
+ * @brief Initialize set context.
+ *
+ * @param[in] new Set to initialize.
+ * @param[in] set Arbitrary initialized set.
+ */
+static void
+set_init(struct lyxp_set *new, const struct lyxp_set *set)
+{
+    memset(new, 0, sizeof *new);
+    if (set) {
+        new->non_child_axis = set->non_child_axis;
+        new->ctx = set->ctx;
+        new->cur_node = set->cur_node;
+        new->root_type = set->root_type;
+        new->context_op = set->context_op;
+        new->tree = set->tree;
+        new->cur_mod = set->cur_mod;
+        new->format = set->format;
+        new->prefix_data = set->prefix_data;
+        new->vars = set->vars;
+    }
+}
+
+/**
+ * @brief Create a deep copy of a set.
+ *
+ * @param[in] set Set to copy.
+ * @return Copy of @p set.
+ */
+static struct lyxp_set *
+set_copy(struct lyxp_set *set)
+{
+    struct lyxp_set *ret;
+    uint32_t i;
+
+    if (!set) {
+        return NULL;
+    }
+
+    ret = malloc(sizeof *ret);
+    LY_CHECK_ERR_RET(!ret, LOGMEM(set->ctx), NULL);
+    set_init(ret, set);
+
+    if (set->type == LYXP_SET_SCNODE_SET) {
+        ret->type = set->type;
+
+        for (i = 0; i < set->used; ++i) {
+            if ((set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) ||
+                    (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_START)) {
+                uint32_t idx;
+
+                LY_CHECK_ERR_RET(set_scnode_insert_node(ret, set->val.scnodes[i].scnode, set->val.scnodes[i].type,
+                        set->val.scnodes[i].axis, &idx), lyxp_set_free(ret), NULL);
+                /* coverity seems to think scnodes can be NULL */
+                if (!ret->val.scnodes) {
+                    lyxp_set_free(ret);
+                    return NULL;
+                }
+                ret->val.scnodes[idx].in_ctx = set->val.scnodes[i].in_ctx;
+            }
+        }
+    } else if (set->type == LYXP_SET_NODE_SET) {
+        ret->type = set->type;
+        if (set->used) {
+            ret->val.nodes = malloc(set->used * sizeof *ret->val.nodes);
+            LY_CHECK_ERR_RET(!ret->val.nodes, LOGMEM(set->ctx); free(ret), NULL);
+            memcpy(ret->val.nodes, set->val.nodes, set->used * sizeof *ret->val.nodes);
+        } else {
+            ret->val.nodes = NULL;
+        }
+
+        ret->used = ret->size = set->used;
+        ret->ctx_pos = set->ctx_pos;
+        ret->ctx_size = set->ctx_size;
+        if (set->ht) {
+            ret->ht = lyht_dup(set->ht);
+        }
+    } else {
+        memcpy(ret, set, sizeof *ret);
+        if (set->type == LYXP_SET_STRING) {
+            ret->val.str = strdup(set->val.str);
+            LY_CHECK_ERR_RET(!ret->val.str, LOGMEM(set->ctx); free(ret), NULL);
+        }
+    }
+
+    return ret;
+}
+
+/**
+ * @brief Fill XPath set with a string. Any current data are disposed of.
+ *
+ * @param[in] set Set to fill.
+ * @param[in] string String to fill into \p set.
+ * @param[in] str_len Length of \p string. 0 is a valid value!
+ */
+static void
+set_fill_string(struct lyxp_set *set, const char *string, uint32_t str_len)
+{
+    lyxp_set_free_content(set);
+
+    set->type = LYXP_SET_STRING;
+    if ((str_len == 0) && (string[0] != '\0')) {
+        string = "";
+    }
+    set->val.str = strndup(string, str_len);
+}
+
+/**
+ * @brief Fill XPath set with a number. Any current data are disposed of.
+ *
+ * @param[in] set Set to fill.
+ * @param[in] number Number to fill into \p set.
+ */
+static void
+set_fill_number(struct lyxp_set *set, long double number)
+{
+    lyxp_set_free_content(set);
+
+    set->type = LYXP_SET_NUMBER;
+    set->val.num = number;
+}
+
+/**
+ * @brief Fill XPath set with a boolean. Any current data are disposed of.
+ *
+ * @param[in] set Set to fill.
+ * @param[in] boolean Boolean to fill into \p set.
+ */
+static void
+set_fill_boolean(struct lyxp_set *set, ly_bool boolean)
+{
+    lyxp_set_free_content(set);
+
+    set->type = LYXP_SET_BOOLEAN;
+    set->val.bln = boolean;
+}
+
+/**
+ * @brief Fill XPath set with the value from another set (deep assign).
+ *        Any current data are disposed of.
+ *
+ * @param[in] trg Set to fill.
+ * @param[in] src Source set to copy into \p trg.
+ */
+static void
+set_fill_set(struct lyxp_set *trg, const struct lyxp_set *src)
+{
+    if (!trg || !src) {
+        return;
+    }
+
+    if (trg->type == LYXP_SET_NODE_SET) {
+        free(trg->val.nodes);
+    } else if (trg->type == LYXP_SET_STRING) {
+        free(trg->val.str);
+    }
+    set_init(trg, src);
+
+    if (src->type == LYXP_SET_SCNODE_SET) {
+        trg->type = LYXP_SET_SCNODE_SET;
+        trg->used = src->used;
+        trg->size = src->used;
+
+        if (trg->size) {
+            trg->val.scnodes = ly_realloc(trg->val.scnodes, trg->size * sizeof *trg->val.scnodes);
+            LY_CHECK_ERR_RET(!trg->val.scnodes, LOGMEM(src->ctx); memset(trg, 0, sizeof *trg), );
+            memcpy(trg->val.scnodes, src->val.scnodes, src->used * sizeof *src->val.scnodes);
+        } else {
+            trg->val.scnodes = NULL;
+        }
+    } else if (src->type == LYXP_SET_BOOLEAN) {
+        set_fill_boolean(trg, src->val.bln);
+    } else if (src->type == LYXP_SET_NUMBER) {
+        set_fill_number(trg, src->val.num);
+    } else if (src->type == LYXP_SET_STRING) {
+        set_fill_string(trg, src->val.str, strlen(src->val.str));
+    } else {
+        if (trg->type == LYXP_SET_NODE_SET) {
+            free(trg->val.nodes);
+        } else if (trg->type == LYXP_SET_STRING) {
+            free(trg->val.str);
+        }
+
+        assert(src->type == LYXP_SET_NODE_SET);
+
+        trg->type = LYXP_SET_NODE_SET;
+        trg->used = src->used;
+        trg->size = src->used;
+        trg->ctx_pos = src->ctx_pos;
+        trg->ctx_size = src->ctx_size;
+
+        if (trg->size) {
+            trg->val.nodes = malloc(trg->size * sizeof *trg->val.nodes);
+            LY_CHECK_ERR_RET(!trg->val.nodes, LOGMEM(src->ctx); memset(trg, 0, sizeof *trg), );
+            memcpy(trg->val.nodes, src->val.nodes, src->used * sizeof *src->val.nodes);
+        } else {
+            trg->val.nodes = NULL;
+        }
+        if (src->ht) {
+            trg->ht = lyht_dup(src->ht);
+        } else {
+            trg->ht = NULL;
+        }
+    }
+}
+
+/**
+ * @brief Clear context of all schema nodes.
+ *
+ * @param[in] set Set to clear.
+ * @param[in] new_ctx New context state for all the nodes currently in the context.
+ */
+static void
+set_scnode_clear_ctx(struct lyxp_set *set, int32_t new_ctx)
+{
+    uint32_t i;
+
+    for (i = 0; i < set->used; ++i) {
+        if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
+            set->val.scnodes[i].in_ctx = new_ctx;
+        } else if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_START) {
+            set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
+        }
+    }
+}
+
+/**
+ * @brief Remove a node from a set. Removing last node changes
+ *        set into LYXP_SET_EMPTY. Context position aware.
+ *
+ * @param[in] set Set to use.
+ * @param[in] idx Index from @p set of the node to be removed.
+ */
+static void
+set_remove_node(struct lyxp_set *set, uint32_t idx)
+{
+    assert(set && (set->type == LYXP_SET_NODE_SET));
+    assert(idx < set->used);
+
+    set_remove_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
+
+    --set->used;
+    if (idx < set->used) {
+        memmove(&set->val.nodes[idx], &set->val.nodes[idx + 1], (set->used - idx) * sizeof *set->val.nodes);
+    } else if (!set->used) {
+        lyxp_set_free_content(set);
+    }
+}
+
+/**
+ * @brief Remove a node from a set by setting its type to LYXP_NODE_NONE.
+ *
+ * @param[in] set Set to use.
+ * @param[in] idx Index from @p set of the node to be removed.
+ */
+static void
+set_remove_node_none(struct lyxp_set *set, uint32_t idx)
+{
+    assert(set && (set->type == LYXP_SET_NODE_SET));
+    assert(idx < set->used);
+
+    if (set->val.nodes[idx].type == LYXP_NODE_ELEM) {
+        set_remove_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
+    }
+    set->val.nodes[idx].type = LYXP_NODE_NONE;
+}
+
+/**
+ * @brief Remove all LYXP_NODE_NONE nodes from a set. Removing last node changes
+ *        set into LYXP_SET_EMPTY. Context position aware.
+ *
+ * @param[in] set Set to consolidate.
+ */
+static void
+set_remove_nodes_none(struct lyxp_set *set)
+{
+    uint32_t i, orig_used, end = 0;
+    int64_t start;
+
+    assert(set);
+
+    orig_used = set->used;
+    set->used = 0;
+    for (i = 0; i < orig_used; ) {
+        start = -1;
+        do {
+            if ((set->val.nodes[i].type != LYXP_NODE_NONE) && (start == -1)) {
+                start = i;
+            } else if ((start > -1) && (set->val.nodes[i].type == LYXP_NODE_NONE)) {
+                end = i;
+                ++i;
+                break;
+            }
+
+            ++i;
+            if (i == orig_used) {
+                end = i;
+            }
+        } while (i < orig_used);
+
+        if (start > -1) {
+            /* move the whole chunk of valid nodes together */
+            if (set->used != (unsigned)start) {
+                memmove(&set->val.nodes[set->used], &set->val.nodes[start], (end - start) * sizeof *set->val.nodes);
+            }
+            set->used += end - start;
+        }
+    }
+}
+
+/**
+ * @brief Check for duplicates in a node set.
+ *
+ * @param[in] set Set to check.
+ * @param[in] node Node to look for in @p set.
+ * @param[in] node_type Type of @p node.
+ * @param[in] skip_idx Index from @p set to skip.
+ * @return LY_ERR
+ */
+static LY_ERR
+set_dup_node_check(const struct lyxp_set *set, const struct lyd_node *node, enum lyxp_node_type node_type, int skip_idx)
+{
+    uint32_t i;
+
+    if (set->ht && node) {
+        return set_dup_node_hash_check(set, (struct lyd_node *)node, node_type, skip_idx);
+    }
+
+    for (i = 0; i < set->used; ++i) {
+        if ((skip_idx > -1) && (i == (unsigned)skip_idx)) {
+            continue;
+        }
+
+        if ((set->val.nodes[i].node == node) && (set->val.nodes[i].type == node_type)) {
+            return LY_EEXIST;
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+ly_bool
+lyxp_set_scnode_contains(struct lyxp_set *set, const struct lysc_node *node, enum lyxp_node_type node_type, int skip_idx,
+        uint32_t *index_p)
+{
+    uint32_t i;
+
+    for (i = 0; i < set->used; ++i) {
+        if ((skip_idx > -1) && (i == (unsigned)skip_idx)) {
+            continue;
+        }
+
+        if ((set->val.scnodes[i].scnode == node) && (set->val.scnodes[i].type == node_type)) {
+            if (index_p) {
+                *index_p = i;
+            }
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+void
+lyxp_set_scnode_merge(struct lyxp_set *set1, struct lyxp_set *set2)
+{
+    uint32_t orig_used, i, j;
+
+    assert((set1->type == LYXP_SET_SCNODE_SET) && (set2->type == LYXP_SET_SCNODE_SET));
+
+    if (!set2->used) {
+        return;
+    }
+
+    if (!set1->used) {
+        /* release hidden allocated data (lyxp_set.size) */
+        lyxp_set_free_content(set1);
+        /* direct copying of the entire structure */
+        memcpy(set1, set2, sizeof *set1);
+        return;
+    }
+
+    if (set1->used + set2->used > set1->size) {
+        set1->size = set1->used + set2->used;
+        set1->val.scnodes = ly_realloc(set1->val.scnodes, set1->size * sizeof *set1->val.scnodes);
+        LY_CHECK_ERR_RET(!set1->val.scnodes, LOGMEM(set1->ctx), );
+    }
+
+    orig_used = set1->used;
+
+    for (i = 0; i < set2->used; ++i) {
+        for (j = 0; j < orig_used; ++j) {
+            /* detect duplicities */
+            if (set1->val.scnodes[j].scnode == set2->val.scnodes[i].scnode) {
+                break;
+            }
+        }
+
+        if (j < orig_used) {
+            /* node is there, but update its status if needed */
+            if (set1->val.scnodes[j].in_ctx == LYXP_SET_SCNODE_START_USED) {
+                set1->val.scnodes[j].in_ctx = set2->val.scnodes[i].in_ctx;
+            } else if ((set1->val.scnodes[j].in_ctx == LYXP_SET_SCNODE_ATOM_NODE) &&
+                    (set2->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL)) {
+                set1->val.scnodes[j].in_ctx = set2->val.scnodes[i].in_ctx;
+            }
+        } else {
+            memcpy(&set1->val.scnodes[set1->used], &set2->val.scnodes[i], sizeof *set2->val.scnodes);
+            ++set1->used;
+        }
+    }
+
+    lyxp_set_free_content(set2);
+    set2->type = LYXP_SET_SCNODE_SET;
+}
+
+/**
+ * @brief Insert a node into a set. Context position aware.
+ *
+ * @param[in] set Set to use.
+ * @param[in] node Node to insert to @p set.
+ * @param[in] pos Sort position of @p node. If left 0, it is filled just before sorting.
+ * @param[in] node_type Node type of @p node.
+ * @param[in] idx Index in @p set to insert into.
+ */
+static void
+set_insert_node(struct lyxp_set *set, const struct lyd_node *node, uint32_t pos, enum lyxp_node_type node_type, uint32_t idx)
+{
+    assert(set && (set->type == LYXP_SET_NODE_SET));
+
+    if (!set->size) {
+        /* first item */
+        if (idx) {
+            /* no real harm done, but it is a bug */
+            LOGINT(set->ctx);
+            idx = 0;
+        }
+        set->val.nodes = malloc(LYXP_SET_SIZE_START * sizeof *set->val.nodes);
+        LY_CHECK_ERR_RET(!set->val.nodes, LOGMEM(set->ctx), );
+        set->type = LYXP_SET_NODE_SET;
+        set->used = 0;
+        set->size = LYXP_SET_SIZE_START;
+        set->ctx_pos = 1;
+        set->ctx_size = 1;
+        set->ht = NULL;
+    } else {
+        /* not an empty set */
+        if (set->used == set->size) {
+
+            /* set is full */
+            set->val.nodes = ly_realloc(set->val.nodes, (set->size * LYXP_SET_SIZE_MUL_STEP) * sizeof *set->val.nodes);
+            LY_CHECK_ERR_RET(!set->val.nodes, LOGMEM(set->ctx), );
+            set->size *= LYXP_SET_SIZE_MUL_STEP;
+        }
+
+        if (idx > set->used) {
+            LOGINT(set->ctx);
+            idx = set->used;
+        }
+
+        /* make space for the new node */
+        if (idx < set->used) {
+            memmove(&set->val.nodes[idx + 1], &set->val.nodes[idx], (set->used - idx) * sizeof *set->val.nodes);
+        }
+    }
+
+    /* finally assign the value */
+    set->val.nodes[idx].node = (struct lyd_node *)node;
+    set->val.nodes[idx].type = node_type;
+    set->val.nodes[idx].pos = pos;
+    ++set->used;
+
+    /* add into hash table */
+    set_insert_node_hash(set, (struct lyd_node *)node, node_type);
+}
+
+/**
+ * @brief Insert schema node into set.
+ *
+ * @param[in] set Set to insert into.
+ * @param[in] node Node to insert.
+ * @param[in] node_type Node type of @p node.
+ * @param[in] axis Axis that @p node was reached on.
+ * @param[out] index_p Optional pointer to store index if the inserted @p node.
+ * @return LY_SUCCESS on success.
+ * @return LY_EMEM on memory allocation failure.
+ */
+static LY_ERR
+set_scnode_insert_node(struct lyxp_set *set, const struct lysc_node *node, enum lyxp_node_type node_type,
+        enum lyxp_axis axis, uint32_t *index_p)
+{
+    uint32_t index;
+
+    assert(set->type == LYXP_SET_SCNODE_SET);
+
+    if (!set->size) {
+        /* first item */
+        set->val.scnodes = malloc(LYXP_SET_SIZE_START * sizeof *set->val.scnodes);
+        LY_CHECK_ERR_RET(!set->val.scnodes, LOGMEM(set->ctx), LY_EMEM);
+        set->type = LYXP_SET_SCNODE_SET;
+        set->used = 0;
+        set->size = LYXP_SET_SIZE_START;
+        set->ctx_pos = 1;
+        set->ctx_size = 1;
+        set->ht = NULL;
+    }
+
+    if (lyxp_set_scnode_contains(set, node, node_type, -1, &index)) {
+        /* BUG if axes differs, this new one is thrown away */
+        set->val.scnodes[index].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
+    } else {
+        if (set->used == set->size) {
+            set->val.scnodes = ly_realloc(set->val.scnodes, (set->size * LYXP_SET_SIZE_MUL_STEP) * sizeof *set->val.scnodes);
+            LY_CHECK_ERR_RET(!set->val.scnodes, LOGMEM(set->ctx), LY_EMEM);
+            set->size *= LYXP_SET_SIZE_MUL_STEP;
+        }
+
+        index = set->used;
+        set->val.scnodes[index].scnode = (struct lysc_node *)node;
+        set->val.scnodes[index].type = node_type;
+        set->val.scnodes[index].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
+        set->val.scnodes[index].axis = axis;
+        ++set->used;
+    }
+
+    if (index_p) {
+        *index_p = index;
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Set all nodes with ctx 1 to a new unique context value.
+ *
+ * @param[in] set Set to modify.
+ * @return New context value.
+ */
+static int32_t
+set_scnode_new_in_ctx(struct lyxp_set *set)
+{
+    uint32_t i;
+    int32_t ret_ctx;
+
+    assert(set->type == LYXP_SET_SCNODE_SET);
+
+    ret_ctx = LYXP_SET_SCNODE_ATOM_PRED_CTX;
+retry:
+    for (i = 0; i < set->used; ++i) {
+        if (set->val.scnodes[i].in_ctx >= ret_ctx) {
+            ret_ctx = set->val.scnodes[i].in_ctx + 1;
+            goto retry;
+        }
+    }
+    for (i = 0; i < set->used; ++i) {
+        if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
+            set->val.scnodes[i].in_ctx = ret_ctx;
+        }
+    }
+
+    return ret_ctx;
+}
+
+/**
+ * @brief Get unique @p node position in the data.
+ *
+ * @param[in] node Node to find.
+ * @param[in] node_type Node type of @p node.
+ * @param[in] root Root node.
+ * @param[in] root_type Type of the XPath @p root node.
+ * @param[in] prev Node that we think is before @p node in DFS from @p root. Can optionally
+ * be used to increase efficiency and start the DFS from this node.
+ * @param[in] prev_pos Node @p prev position. Optional, but must be set if @p prev is set.
+ * @return Node position.
+ */
+static uint32_t
+get_node_pos(const struct lyd_node *node, enum lyxp_node_type node_type, const struct lyd_node *root,
+        enum lyxp_node_type root_type, const struct lyd_node **prev, uint32_t *prev_pos)
+{
+    const struct lyd_node *elem = NULL, *top_sibling;
+    uint32_t pos = 1;
+    ly_bool found = 0;
+
+    assert(prev && prev_pos && !root->prev->next);
+
+    if ((node_type == LYXP_NODE_ROOT) || (node_type == LYXP_NODE_ROOT_CONFIG)) {
+        return 0;
+    }
+
+    if (*prev) {
+        /* start from the previous element instead from the root */
+        pos = *prev_pos;
+        for (top_sibling = *prev; top_sibling->parent; top_sibling = lyd_parent(top_sibling)) {}
+        goto dfs_search;
+    }
+
+    LY_LIST_FOR(root, top_sibling) {
+        LYD_TREE_DFS_BEGIN(top_sibling, elem) {
+dfs_search:
+            LYD_TREE_DFS_continue = 0;
+
+            if (*prev && !elem) {
+                /* resume previous DFS */
+                elem = LYD_TREE_DFS_next = (struct lyd_node *)*prev;
+                LYD_TREE_DFS_continue = 0;
+            }
+
+            if (!elem->schema || ((root_type == LYXP_NODE_ROOT_CONFIG) && (elem->schema->flags & LYS_CONFIG_R))) {
+                /* skip */
+                LYD_TREE_DFS_continue = 1;
+            } else {
+                if (elem == node) {
+                    found = 1;
+                    break;
+                }
+                ++pos;
+            }
+
+            LYD_TREE_DFS_END(top_sibling, elem);
+        }
+
+        /* node found */
+        if (found) {
+            break;
+        }
+    }
+
+    if (!found) {
+        if (!(*prev)) {
+            /* we went from root and failed to find it, cannot be */
+            LOGINT(LYD_CTX(node));
+            return 0;
+        } else {
+            /* start the search again from the beginning */
+            *prev = root;
+
+            top_sibling = root;
+            pos = 1;
+            goto dfs_search;
+        }
+    }
+
+    /* remember the last found node for next time */
+    *prev = node;
+    *prev_pos = pos;
+
+    return pos;
+}
+
+/**
+ * @brief Assign (fill) missing node positions.
+ *
+ * @param[in] set Set to fill positions in.
+ * @param[in] root Context root node.
+ * @param[in] root_type Context root type.
+ * @return LY_ERR
+ */
+static LY_ERR
+set_assign_pos(struct lyxp_set *set, const struct lyd_node *root, enum lyxp_node_type root_type)
+{
+    const struct lyd_node *prev = NULL, *tmp_node;
+    uint32_t i, tmp_pos = 0;
+
+    for (i = 0; i < set->used; ++i) {
+        if (!set->val.nodes[i].pos) {
+            tmp_node = NULL;
+            switch (set->val.nodes[i].type) {
+            case LYXP_NODE_META:
+                tmp_node = set->val.meta[i].meta->parent;
+                if (!tmp_node) {
+                    LOGINT_RET(root->schema->module->ctx);
+                }
+            /* fall through */
+            case LYXP_NODE_ELEM:
+            case LYXP_NODE_TEXT:
+                if (!tmp_node) {
+                    tmp_node = set->val.nodes[i].node;
+                }
+                set->val.nodes[i].pos = get_node_pos(tmp_node, set->val.nodes[i].type, root, root_type, &prev, &tmp_pos);
+                break;
+            default:
+                /* all roots have position 0 */
+                break;
+            }
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Get unique @p meta position in the parent metadata.
+ *
+ * @param[in] meta Metadata to use.
+ * @return Metadata position.
+ */
+static uint32_t
+get_meta_pos(struct lyd_meta *meta)
+{
+    uint32_t pos = 0;
+    struct lyd_meta *meta2;
+
+    for (meta2 = meta->parent->meta; meta2 && (meta2 != meta); meta2 = meta2->next) {
+        ++pos;
+    }
+
+    assert(meta2);
+    return pos;
+}
+
+/**
+ * @brief Compare 2 nodes in respect to XPath document order.
+ *
+ * @param[in] item1 1st node.
+ * @param[in] item2 2nd node.
+ * @return If 1st > 2nd returns 1, 1st == 2nd returns 0, and 1st < 2nd returns -1.
+ */
+static int
+set_sort_compare(struct lyxp_set_node *item1, struct lyxp_set_node *item2)
+{
+    uint32_t meta_pos1 = 0, meta_pos2 = 0;
+
+    if (item1->pos < item2->pos) {
+        return -1;
+    }
+
+    if (item1->pos > item2->pos) {
+        return 1;
+    }
+
+    /* node positions are equal, the fun case */
+
+    /* 1st ELEM - == - 2nd TEXT, 1st TEXT - == - 2nd ELEM */
+    /* special case since text nodes are actually saved as their parents */
+    if ((item1->node == item2->node) && (item1->type != item2->type)) {
+        if (item1->type == LYXP_NODE_ELEM) {
+            assert(item2->type == LYXP_NODE_TEXT);
+            return -1;
+        } else {
+            assert((item1->type == LYXP_NODE_TEXT) && (item2->type == LYXP_NODE_ELEM));
+            return 1;
+        }
+    }
+
+    /* we need meta positions now */
+    if (item1->type == LYXP_NODE_META) {
+        meta_pos1 = get_meta_pos((struct lyd_meta *)item1->node);
+    }
+    if (item2->type == LYXP_NODE_META) {
+        meta_pos2 = get_meta_pos((struct lyd_meta *)item2->node);
+    }
+
+    /* 1st ROOT - 2nd ROOT, 1st ELEM - 2nd ELEM, 1st TEXT - 2nd TEXT, 1st META - =pos= - 2nd META */
+    /* check for duplicates */
+    if (item1->node == item2->node) {
+        assert((item1->type == item2->type) && ((item1->type != LYXP_NODE_META) || (meta_pos1 == meta_pos2)));
+        return 0;
+    }
+
+    /* 1st ELEM - 2nd TEXT, 1st ELEM - any pos - 2nd META */
+    /* elem is always first, 2nd node is after it */
+    if (item1->type == LYXP_NODE_ELEM) {
+        assert(item2->type != LYXP_NODE_ELEM);
+        return -1;
+    }
+
+    /* 1st TEXT - 2nd ELEM, 1st TEXT - any pos - 2nd META, 1st META - any pos - 2nd ELEM, 1st META - >pos> - 2nd META */
+    /* 2nd is before 1st */
+    if (((item1->type == LYXP_NODE_TEXT) &&
+            ((item2->type == LYXP_NODE_ELEM) || (item2->type == LYXP_NODE_META))) ||
+            ((item1->type == LYXP_NODE_META) && (item2->type == LYXP_NODE_ELEM)) ||
+            (((item1->type == LYXP_NODE_META) && (item2->type == LYXP_NODE_META)) &&
+            (meta_pos1 > meta_pos2))) {
+        return 1;
+    }
+
+    /* 1st META - any pos - 2nd TEXT, 1st META <pos< - 2nd META */
+    /* 2nd is after 1st */
+    return -1;
+}
+
+/**
+ * @brief Set cast for comparisons.
+ *
+ * @param[in,out] trg Target set to cast source into.
+ * @param[in] src Source set.
+ * @param[in] type Target set type.
+ * @param[in] src_idx Source set node index.
+ * @return LY_SUCCESS on success.
+ * @return LY_ERR value on error.
+ */
+static LY_ERR
+set_comp_cast(struct lyxp_set *trg, const struct lyxp_set *src, enum lyxp_set_type type, uint32_t src_idx)
+{
+    assert(src->type == LYXP_SET_NODE_SET);
+
+    set_init(trg, src);
+
+    /* insert node into target set */
+    set_insert_node(trg, src->val.nodes[src_idx].node, src->val.nodes[src_idx].pos, src->val.nodes[src_idx].type, 0);
+
+    /* cast target set appropriately */
+    return lyxp_set_cast(trg, type);
+}
+
+/**
+ * @brief Set content canonization for comparisons.
+ *
+ * @param[in,out] set Set to canonize.
+ * @param[in] xp_node Source XPath node/meta to use for canonization.
+ * @return LY_SUCCESS on success.
+ * @return LY_ERR value on error.
+ */
+static LY_ERR
+set_comp_canonize(struct lyxp_set *set, const struct lyxp_set_node *xp_node)
+{
+    const struct lysc_type *type = NULL;
+    struct lyd_value val;
+    struct ly_err_item *err = NULL;
+    LY_ERR rc;
+
+    /* is there anything to canonize even? */
+    if (set->type == LYXP_SET_STRING) {
+        /* do we have a type to use for canonization? */
+        if ((xp_node->type == LYXP_NODE_ELEM) && (xp_node->node->schema->nodetype & LYD_NODE_TERM)) {
+            type = ((struct lyd_node_term *)xp_node->node)->value.realtype;
+        } else if (xp_node->type == LYXP_NODE_META) {
+            type = ((struct lyd_meta *)xp_node->node)->value.realtype;
+        }
+    }
+    if (!type) {
+        /* no canonization needed/possible */
+        return LY_SUCCESS;
+    }
+
+    /* check for built-in types without required canonization */
+    if ((type->basetype == LY_TYPE_STRING) && (type->plugin->store == lyplg_type_store_string)) {
+        /* string */
+        return LY_SUCCESS;
+    }
+    if ((type->basetype == LY_TYPE_BOOL) && (type->plugin->store == lyplg_type_store_boolean)) {
+        /* boolean */
+        return LY_SUCCESS;
+    }
+    if ((type->basetype == LY_TYPE_ENUM) && (type->plugin->store == lyplg_type_store_enum)) {
+        /* enumeration */
+        return LY_SUCCESS;
+    }
+
+    /* print canonized string, ignore errors, the value may not satisfy schema constraints */
+    rc = type->plugin->store(set->ctx, type, set->val.str, strlen(set->val.str), 0, set->format, set->prefix_data,
+            LYD_HINT_DATA, xp_node->node->schema, &val, NULL, &err);
+    ly_err_free(err);
+    if (rc) {
+        /* invalid value, function store automaticaly dealloc value when fail */
+        return LY_SUCCESS;
+    }
+
+    /* use the canonized string value */
+    free(set->val.str);
+    set->val.str = strdup(lyd_value_get_canonical(set->ctx, &val));
+    type->plugin->free(set->ctx, &val);
+    LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), LY_EMEM);
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Bubble sort @p set into XPath document order.
+ *        Context position aware.
+ *
+ * @param[in] set Set to sort.
+ * @return How many times the whole set was traversed - 1 (if set was sorted, returns 0).
+ */
+static int
+set_sort(struct lyxp_set *set)
+{
+    uint32_t i, j;
+    int ret = 0, cmp;
+    ly_bool inverted, change;
+    const struct lyd_node *root;
+    struct lyxp_set_node item;
+    struct lyxp_set_hash_node hnode;
+    uint64_t hash;
+
+    if ((set->type != LYXP_SET_NODE_SET) || (set->used < 2)) {
+        return 0;
+    }
+
+    /* find first top-level node to be used as anchor for positions */
+    for (root = set->tree; root->parent; root = lyd_parent(root)) {}
+    for ( ; root->prev->next; root = root->prev) {}
+
+    /* fill positions */
+    if (set_assign_pos(set, root, set->root_type)) {
+        return -1;
+    }
+
+#ifndef NDEBUG
+    LOGDBG(LY_LDGXPATH, "SORT BEGIN");
+    print_set_debug(set);
+#endif
+
+    for (i = 0; i < set->used; ++i) {
+        inverted = 0;
+        change = 0;
+
+        for (j = 1; j < set->used - i; ++j) {
+            /* compare node positions */
+            if (inverted) {
+                cmp = set_sort_compare(&set->val.nodes[j], &set->val.nodes[j - 1]);
+            } else {
+                cmp = set_sort_compare(&set->val.nodes[j - 1], &set->val.nodes[j]);
+            }
+
+            /* swap if needed */
+            if ((inverted && (cmp < 0)) || (!inverted && (cmp > 0))) {
+                change = 1;
+
+                item = set->val.nodes[j - 1];
+                set->val.nodes[j - 1] = set->val.nodes[j];
+                set->val.nodes[j] = item;
+            } else {
+                /* whether node_pos1 should be smaller than node_pos2 or the other way around */
+                inverted = !inverted;
+            }
+        }
+
+        ++ret;
+
+        if (!change) {
+            break;
+        }
+    }
+
+#ifndef NDEBUG
+    LOGDBG(LY_LDGXPATH, "SORT END %d", ret);
+    print_set_debug(set);
+#endif
+
+    /* check node hashes */
+    if (set->used >= LYD_HT_MIN_ITEMS) {
+        assert(set->ht);
+        for (i = 0; i < set->used; ++i) {
+            hnode.node = set->val.nodes[i].node;
+            hnode.type = set->val.nodes[i].type;
+
+            hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
+            hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
+            hash = dict_hash_multi(hash, NULL, 0);
+
+            assert(!lyht_find(set->ht, &hnode, hash, NULL));
+        }
+    }
+
+    return ret - 1;
+}
+
+/**
+ * @brief Merge 2 sorted sets into one.
+ *
+ * @param[in,out] trg Set to merge into. Duplicates are removed.
+ * @param[in] src Set to be merged into @p trg. It is cast to #LYXP_SET_EMPTY on success.
+ * @return LY_ERR
+ */
+static LY_ERR
+set_sorted_merge(struct lyxp_set *trg, struct lyxp_set *src)
+{
+    uint32_t i, j, k, count, dup_count;
+    int cmp;
+    const struct lyd_node *root;
+
+    if ((trg->type != LYXP_SET_NODE_SET) || (src->type != LYXP_SET_NODE_SET)) {
+        return LY_EINVAL;
+    }
+
+    if (!src->used) {
+        return LY_SUCCESS;
+    } else if (!trg->used) {
+        set_fill_set(trg, src);
+        lyxp_set_free_content(src);
+        return LY_SUCCESS;
+    }
+
+    /* find first top-level node to be used as anchor for positions */
+    for (root = trg->tree; root->parent; root = lyd_parent(root)) {}
+    for ( ; root->prev->next; root = root->prev) {}
+
+    /* fill positions */
+    if (set_assign_pos(trg, root, trg->root_type) || set_assign_pos(src, root, src->root_type)) {
+        return LY_EINT;
+    }
+
+#ifndef NDEBUG
+    LOGDBG(LY_LDGXPATH, "MERGE target");
+    print_set_debug(trg);
+    LOGDBG(LY_LDGXPATH, "MERGE source");
+    print_set_debug(src);
+#endif
+
+    /* make memory for the merge (duplicates are not detected yet, so space
+     * will likely be wasted on them, too bad) */
+    if (trg->size - trg->used < src->used) {
+        trg->size = trg->used + src->used;
+
+        trg->val.nodes = ly_realloc(trg->val.nodes, trg->size * sizeof *trg->val.nodes);
+        LY_CHECK_ERR_RET(!trg->val.nodes, LOGMEM(src->ctx), LY_EMEM);
+    }
+
+    i = 0;
+    j = 0;
+    count = 0;
+    dup_count = 0;
+    do {
+        cmp = set_sort_compare(&src->val.nodes[i], &trg->val.nodes[j]);
+        if (!cmp) {
+            if (!count) {
+                /* duplicate, just skip it */
+                ++i;
+                ++j;
+            } else {
+                /* we are copying something already, so let's copy the duplicate too,
+                 * we are hoping that afterwards there are some more nodes to
+                 * copy and this way we can copy them all together */
+                ++count;
+                ++dup_count;
+                ++i;
+                ++j;
+            }
+        } else if (cmp < 0) {
+            /* inserting src node into trg, just remember it for now */
+            ++count;
+            ++i;
+
+            /* insert the hash now */
+            set_insert_node_hash(trg, src->val.nodes[i - 1].node, src->val.nodes[i - 1].type);
+        } else if (count) {
+copy_nodes:
+            /* time to actually copy the nodes, we have found the largest block of nodes */
+            memmove(&trg->val.nodes[j + (count - dup_count)],
+                    &trg->val.nodes[j],
+                    (trg->used - j) * sizeof *trg->val.nodes);
+            memcpy(&trg->val.nodes[j - dup_count], &src->val.nodes[i - count], count * sizeof *src->val.nodes);
+
+            trg->used += count - dup_count;
+            /* do not change i, except the copying above, we are basically doing exactly what is in the else branch below */
+            j += count - dup_count;
+
+            count = 0;
+            dup_count = 0;
+        } else {
+            ++j;
+        }
+    } while ((i < src->used) && (j < trg->used));
+
+    if ((i < src->used) || count) {
+        /* insert all the hashes first */
+        for (k = i; k < src->used; ++k) {
+            set_insert_node_hash(trg, src->val.nodes[k].node, src->val.nodes[k].type);
+        }
+
+        /* loop ended, but we need to copy something at trg end */
+        count += src->used - i;
+        i = src->used;
+        goto copy_nodes;
+    }
+
+    /* we are inserting hashes before the actual node insert, which causes
+     * situations when there were initially not enough items for a hash table,
+     * but even after some were inserted, hash table was not created (during
+     * insertion the number of items is not updated yet) */
+    if (!trg->ht && (trg->used >= LYD_HT_MIN_ITEMS)) {
+        set_insert_node_hash(trg, NULL, 0);
+    }
+
+#ifndef NDEBUG
+    LOGDBG(LY_LDGXPATH, "MERGE result");
+    print_set_debug(trg);
+#endif
+
+    lyxp_set_free_content(src);
+    return LY_SUCCESS;
+}
+
+LY_ERR
+lyxp_check_token(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint32_t tok_idx, enum lyxp_token want_tok)
+{
+    if (exp->used == tok_idx) {
+        if (ctx) {
+            LOGVAL(ctx, LY_VCODE_XP_EOF);
+        }
+        return LY_EINCOMPLETE;
+    }
+
+    if (want_tok && (exp->tokens[tok_idx] != want_tok)) {
+        if (ctx) {
+            LOGVAL(ctx, LY_VCODE_XP_INTOK2, lyxp_token2str(exp->tokens[tok_idx]),
+                    &exp->expr[exp->tok_pos[tok_idx]], lyxp_token2str(want_tok));
+        }
+        return LY_ENOT;
+    }
+
+    return LY_SUCCESS;
+}
+
+LY_ERR
+lyxp_next_token(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint32_t *tok_idx, enum lyxp_token want_tok)
+{
+    LY_CHECK_RET(lyxp_check_token(ctx, exp, *tok_idx, want_tok));
+
+    /* skip the token */
+    ++(*tok_idx);
+
+    return LY_SUCCESS;
+}
+
+/* just like lyxp_check_token() but tests for 2 tokens */
+static LY_ERR
+exp_check_token2(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint32_t tok_idx, enum lyxp_token want_tok1,
+        enum lyxp_token want_tok2)
+{
+    if (exp->used == tok_idx) {
+        if (ctx) {
+            LOGVAL(ctx, LY_VCODE_XP_EOF);
+        }
+        return LY_EINCOMPLETE;
+    }
+
+    if ((exp->tokens[tok_idx] != want_tok1) && (exp->tokens[tok_idx] != want_tok2)) {
+        if (ctx) {
+            LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_token2str(exp->tokens[tok_idx]),
+                    &exp->expr[exp->tok_pos[tok_idx]]);
+        }
+        return LY_ENOT;
+    }
+
+    return LY_SUCCESS;
+}
+
+LY_ERR
+lyxp_next_token2(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint32_t *tok_idx, enum lyxp_token want_tok1,
+        enum lyxp_token want_tok2)
+{
+    LY_CHECK_RET(exp_check_token2(ctx, exp, *tok_idx, want_tok1, want_tok2));
+
+    /* skip the token */
+    ++(*tok_idx);
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Stack operation push on the repeat array.
+ *
+ * @param[in] exp Expression to use.
+ * @param[in] tok_idx Position in the expresion \p exp.
+ * @param[in] repeat_op_idx Index from \p exp of the operator token. This value is pushed.
+ */
+static void
+exp_repeat_push(struct lyxp_expr *exp, uint32_t tok_idx, uint32_t repeat_op_idx)
+{
+    uint32_t i;
+
+    if (exp->repeat[tok_idx]) {
+        for (i = 0; exp->repeat[tok_idx][i]; ++i) {}
+        exp->repeat[tok_idx] = realloc(exp->repeat[tok_idx], (i + 2) * sizeof *exp->repeat[tok_idx]);
+        LY_CHECK_ERR_RET(!exp->repeat[tok_idx], LOGMEM(NULL), );
+        exp->repeat[tok_idx][i] = repeat_op_idx;
+        exp->repeat[tok_idx][i + 1] = 0;
+    } else {
+        exp->repeat[tok_idx] = calloc(2, sizeof *exp->repeat[tok_idx]);
+        LY_CHECK_ERR_RET(!exp->repeat[tok_idx], LOGMEM(NULL), );
+        exp->repeat[tok_idx][0] = repeat_op_idx;
+    }
+}
+
+/**
+ * @brief Reparse Predicate. Logs directly on error.
+ *
+ * [7] Predicate ::= '[' Expr ']'
+ *
+ * @param[in] ctx Context for logging.
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] depth Current number of nested expressions.
+ * @return LY_ERR
+ */
+static LY_ERR
+reparse_predicate(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
+{
+    LY_ERR rc;
+
+    rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_BRACK1);
+    LY_CHECK_RET(rc);
+    ++(*tok_idx);
+
+    rc = reparse_or_expr(ctx, exp, tok_idx, depth);
+    LY_CHECK_RET(rc);
+
+    rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_BRACK2);
+    LY_CHECK_RET(rc);
+    ++(*tok_idx);
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Reparse RelativeLocationPath. Logs directly on error.
+ *
+ * [4] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
+ * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
+ * [6] NodeTest ::= NameTest | NodeType '(' ')'
+ *
+ * @param[in] ctx Context for logging.
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression \p exp.
+ * @param[in] depth Current number of nested expressions.
+ * @return LY_ERR (LY_EINCOMPLETE on forward reference)
+ */
+static LY_ERR
+reparse_relative_location_path(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
+{
+    LY_ERR rc;
+
+    rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
+    LY_CHECK_RET(rc);
+
+    goto step;
+    do {
+        /* '/' or '//' */
+        ++(*tok_idx);
+
+        rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
+        LY_CHECK_RET(rc);
+step:
+        /* Step */
+        switch (exp->tokens[*tok_idx]) {
+        case LYXP_TOKEN_DOT:
+            ++(*tok_idx);
+            break;
+
+        case LYXP_TOKEN_DDOT:
+            ++(*tok_idx);
+            break;
+
+        case LYXP_TOKEN_AXISNAME:
+            ++(*tok_idx);
+
+            rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_DCOLON);
+            LY_CHECK_RET(rc);
+
+        /* fall through */
+        case LYXP_TOKEN_AT:
+            ++(*tok_idx);
+
+            rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
+            LY_CHECK_RET(rc);
+            if ((exp->tokens[*tok_idx] != LYXP_TOKEN_NAMETEST) && (exp->tokens[*tok_idx] != LYXP_TOKEN_NODETYPE)) {
+                LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_token2str(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
+                return LY_EVALID;
+            }
+            if (exp->tokens[*tok_idx] == LYXP_TOKEN_NODETYPE) {
+                goto reparse_nodetype;
+            }
+        /* fall through */
+        case LYXP_TOKEN_NAMETEST:
+            ++(*tok_idx);
+            goto reparse_predicate;
+
+        case LYXP_TOKEN_NODETYPE:
+reparse_nodetype:
+            ++(*tok_idx);
+
+            /* '(' */
+            rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR1);
+            LY_CHECK_RET(rc);
+            ++(*tok_idx);
+
+            /* ')' */
+            rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
+            LY_CHECK_RET(rc);
+            ++(*tok_idx);
+
+reparse_predicate:
+            /* Predicate* */
+            while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
+                rc = reparse_predicate(ctx, exp, tok_idx, depth);
+                LY_CHECK_RET(rc);
+            }
+            break;
+        default:
+            LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_token2str(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
+            return LY_EVALID;
+        }
+    } while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH));
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Reparse AbsoluteLocationPath. Logs directly on error.
+ *
+ * [3] AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
+ *
+ * @param[in] ctx Context for logging.
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression \p exp.
+ * @param[in] depth Current number of nested expressions.
+ * @return LY_ERR
+ */
+static LY_ERR
+reparse_absolute_location_path(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
+{
+    LY_ERR rc;
+
+    LY_CHECK_RET(exp_check_token2(ctx, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH));
+
+    /* '/' RelativeLocationPath? */
+    if (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH) {
+        /* '/' */
+        ++(*tok_idx);
+
+        if (lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NONE)) {
+            return LY_SUCCESS;
+        }
+        switch (exp->tokens[*tok_idx]) {
+        case LYXP_TOKEN_DOT:
+        case LYXP_TOKEN_DDOT:
+        case LYXP_TOKEN_AXISNAME:
+        case LYXP_TOKEN_AT:
+        case LYXP_TOKEN_NAMETEST:
+        case LYXP_TOKEN_NODETYPE:
+            rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
+            LY_CHECK_RET(rc);
+        /* fall through */
+        default:
+            break;
+        }
+
+    } else {
+        /* '//' RelativeLocationPath */
+        ++(*tok_idx);
+
+        rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
+        LY_CHECK_RET(rc);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Reparse FunctionCall. Logs directly on error.
+ *
+ * [9] FunctionCall ::= FunctionName '(' ( Expr ( ',' Expr )* )? ')'
+ *
+ * @param[in] ctx Context for logging.
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] depth Current number of nested expressions.
+ * @return LY_ERR
+ */
+static LY_ERR
+reparse_function_call(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
+{
+    int8_t min_arg_count = -1;
+    uint32_t arg_count, max_arg_count = 0, func_tok_idx;
+    LY_ERR rc;
+
+    rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_FUNCNAME);
+    LY_CHECK_RET(rc);
+    func_tok_idx = *tok_idx;
+    switch (exp->tok_len[*tok_idx]) {
+    case 3:
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "not", 3)) {
+            min_arg_count = 1;
+            max_arg_count = 1;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "sum", 3)) {
+            min_arg_count = 1;
+            max_arg_count = 1;
+        }
+        break;
+    case 4:
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "lang", 4)) {
+            min_arg_count = 1;
+            max_arg_count = 1;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "last", 4)) {
+            min_arg_count = 0;
+            max_arg_count = 0;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "name", 4)) {
+            min_arg_count = 0;
+            max_arg_count = 1;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "true", 4)) {
+            min_arg_count = 0;
+            max_arg_count = 0;
+        }
+        break;
+    case 5:
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "count", 5)) {
+            min_arg_count = 1;
+            max_arg_count = 1;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "false", 5)) {
+            min_arg_count = 0;
+            max_arg_count = 0;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "floor", 5)) {
+            min_arg_count = 1;
+            max_arg_count = 1;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "round", 5)) {
+            min_arg_count = 1;
+            max_arg_count = 1;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "deref", 5)) {
+            min_arg_count = 1;
+            max_arg_count = 1;
+        }
+        break;
+    case 6:
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "concat", 6)) {
+            min_arg_count = 2;
+            max_arg_count = UINT32_MAX;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "number", 6)) {
+            min_arg_count = 0;
+            max_arg_count = 1;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string", 6)) {
+            min_arg_count = 0;
+            max_arg_count = 1;
+        }
+        break;
+    case 7:
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "boolean", 7)) {
+            min_arg_count = 1;
+            max_arg_count = 1;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "ceiling", 7)) {
+            min_arg_count = 1;
+            max_arg_count = 1;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "current", 7)) {
+            min_arg_count = 0;
+            max_arg_count = 0;
+        }
+        break;
+    case 8:
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "contains", 8)) {
+            min_arg_count = 2;
+            max_arg_count = 2;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "position", 8)) {
+            min_arg_count = 0;
+            max_arg_count = 0;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "re-match", 8)) {
+            min_arg_count = 2;
+            max_arg_count = 2;
+        }
+        break;
+    case 9:
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring", 9)) {
+            min_arg_count = 2;
+            max_arg_count = 3;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "translate", 9)) {
+            min_arg_count = 3;
+            max_arg_count = 3;
+        }
+        break;
+    case 10:
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "local-name", 10)) {
+            min_arg_count = 0;
+            max_arg_count = 1;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "enum-value", 10)) {
+            min_arg_count = 1;
+            max_arg_count = 1;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "bit-is-set", 10)) {
+            min_arg_count = 2;
+            max_arg_count = 2;
+        }
+        break;
+    case 11:
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "starts-with", 11)) {
+            min_arg_count = 2;
+            max_arg_count = 2;
+        }
+        break;
+    case 12:
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from", 12)) {
+            min_arg_count = 2;
+            max_arg_count = 2;
+        }
+        break;
+    case 13:
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "namespace-uri", 13)) {
+            min_arg_count = 0;
+            max_arg_count = 1;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string-length", 13)) {
+            min_arg_count = 0;
+            max_arg_count = 1;
+        }
+        break;
+    case 15:
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "normalize-space", 15)) {
+            min_arg_count = 0;
+            max_arg_count = 1;
+        } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-after", 15)) {
+            min_arg_count = 2;
+            max_arg_count = 2;
+        }
+        break;
+    case 16:
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-before", 16)) {
+            min_arg_count = 2;
+            max_arg_count = 2;
+        }
+        break;
+    case 20:
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from-or-self", 20)) {
+            min_arg_count = 2;
+            max_arg_count = 2;
+        }
+        break;
+    }
+    if (min_arg_count == -1) {
+        LOGVAL(ctx, LY_VCODE_XP_INFUNC, exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]]);
+        return LY_EINVAL;
+    }
+    ++(*tok_idx);
+
+    /* '(' */
+    rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR1);
+    LY_CHECK_RET(rc);
+    ++(*tok_idx);
+
+    /* ( Expr ( ',' Expr )* )? */
+    arg_count = 0;
+    rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
+    LY_CHECK_RET(rc);
+    if (exp->tokens[*tok_idx] != LYXP_TOKEN_PAR2) {
+        ++arg_count;
+        rc = reparse_or_expr(ctx, exp, tok_idx, depth);
+        LY_CHECK_RET(rc);
+    }
+    while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_COMMA)) {
+        ++(*tok_idx);
+
+        ++arg_count;
+        rc = reparse_or_expr(ctx, exp, tok_idx, depth);
+        LY_CHECK_RET(rc);
+    }
+
+    /* ')' */
+    rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
+    LY_CHECK_RET(rc);
+    ++(*tok_idx);
+
+    if ((arg_count < (uint32_t)min_arg_count) || (arg_count > max_arg_count)) {
+        LOGVAL(ctx, LY_VCODE_XP_INARGCOUNT, arg_count, exp->tok_len[func_tok_idx], &exp->expr[exp->tok_pos[func_tok_idx]]);
+        return LY_EVALID;
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Reparse PathExpr. Logs directly on error.
+ *
+ * [10] PathExpr ::= LocationPath | PrimaryExpr Predicate*
+ *                 | PrimaryExpr Predicate* '/' RelativeLocationPath
+ *                 | PrimaryExpr Predicate* '//' RelativeLocationPath
+ * [2] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
+ * [8] PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
+ *
+ * @param[in] ctx Context for logging.
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] depth Current number of nested expressions.
+ * @return LY_ERR
+ */
+static LY_ERR
+reparse_path_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
+{
+    LY_ERR rc;
+
+    if (lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE)) {
+        return LY_EVALID;
+    }
+
+    switch (exp->tokens[*tok_idx]) {
+    case LYXP_TOKEN_PAR1:
+        /* '(' Expr ')' Predicate* */
+        ++(*tok_idx);
+
+        rc = reparse_or_expr(ctx, exp, tok_idx, depth);
+        LY_CHECK_RET(rc);
+
+        rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
+        LY_CHECK_RET(rc);
+        ++(*tok_idx);
+        goto predicate;
+    case LYXP_TOKEN_DOT:
+    case LYXP_TOKEN_DDOT:
+    case LYXP_TOKEN_AXISNAME:
+    case LYXP_TOKEN_AT:
+    case LYXP_TOKEN_NAMETEST:
+    case LYXP_TOKEN_NODETYPE:
+        /* RelativeLocationPath */
+        rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
+        LY_CHECK_RET(rc);
+        break;
+    case LYXP_TOKEN_VARREF:
+        /* VariableReference */
+        ++(*tok_idx);
+        goto predicate;
+    case LYXP_TOKEN_FUNCNAME:
+        /* FunctionCall */
+        rc = reparse_function_call(ctx, exp, tok_idx, depth);
+        LY_CHECK_RET(rc);
+        goto predicate;
+    case LYXP_TOKEN_OPER_PATH:
+    case LYXP_TOKEN_OPER_RPATH:
+        /* AbsoluteLocationPath */
+        rc = reparse_absolute_location_path(ctx, exp, tok_idx, depth);
+        LY_CHECK_RET(rc);
+        break;
+    case LYXP_TOKEN_LITERAL:
+        /* Literal */
+        ++(*tok_idx);
+        goto predicate;
+    case LYXP_TOKEN_NUMBER:
+        /* Number */
+        ++(*tok_idx);
+        goto predicate;
+    default:
+        LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_token2str(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
+        return LY_EVALID;
+    }
+
+    return LY_SUCCESS;
+
+predicate:
+    /* Predicate* */
+    while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
+        rc = reparse_predicate(ctx, exp, tok_idx, depth);
+        LY_CHECK_RET(rc);
+    }
+
+    /* ('/' or '//') RelativeLocationPath */
+    if (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH)) {
+
+        /* '/' or '//' */
+        ++(*tok_idx);
+
+        rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
+        LY_CHECK_RET(rc);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Reparse UnaryExpr. Logs directly on error.
+ *
+ * [17] UnaryExpr ::= UnionExpr | '-' UnaryExpr
+ * [18] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
+ *
+ * @param[in] ctx Context for logging.
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] depth Current number of nested expressions.
+ * @return LY_ERR
+ */
+static LY_ERR
+reparse_unary_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
+{
+    uint32_t prev_exp;
+    LY_ERR rc;
+
+    /* ('-')* */
+    prev_exp = *tok_idx;
+    while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
+            (exp->expr[exp->tok_pos[*tok_idx]] == '-')) {
+        exp_repeat_push(exp, prev_exp, LYXP_EXPR_UNARY);
+        ++(*tok_idx);
+    }
+
+    /* PathExpr */
+    prev_exp = *tok_idx;
+    rc = reparse_path_expr(ctx, exp, tok_idx, depth);
+    LY_CHECK_RET(rc);
+
+    /* ('|' PathExpr)* */
+    while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_UNI)) {
+        exp_repeat_push(exp, prev_exp, LYXP_EXPR_UNION);
+        ++(*tok_idx);
+
+        rc = reparse_path_expr(ctx, exp, tok_idx, depth);
+        LY_CHECK_RET(rc);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Reparse AdditiveExpr. Logs directly on error.
+ *
+ * [15] AdditiveExpr ::= MultiplicativeExpr
+ *                     | AdditiveExpr '+' MultiplicativeExpr
+ *                     | AdditiveExpr '-' MultiplicativeExpr
+ * [16] MultiplicativeExpr ::= UnaryExpr
+ *                     | MultiplicativeExpr '*' UnaryExpr
+ *                     | MultiplicativeExpr 'div' UnaryExpr
+ *                     | MultiplicativeExpr 'mod' UnaryExpr
+ *
+ * @param[in] ctx Context for logging.
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] depth Current number of nested expressions.
+ * @return LY_ERR
+ */
+static LY_ERR
+reparse_additive_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
+{
+    uint32_t prev_add_exp, prev_mul_exp;
+    LY_ERR rc;
+
+    prev_add_exp = *tok_idx;
+    goto reparse_multiplicative_expr;
+
+    /* ('+' / '-' MultiplicativeExpr)* */
+    while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
+            ((exp->expr[exp->tok_pos[*tok_idx]] == '+') || (exp->expr[exp->tok_pos[*tok_idx]] == '-'))) {
+        exp_repeat_push(exp, prev_add_exp, LYXP_EXPR_ADDITIVE);
+        ++(*tok_idx);
+
+reparse_multiplicative_expr:
+        /* UnaryExpr */
+        prev_mul_exp = *tok_idx;
+        rc = reparse_unary_expr(ctx, exp, tok_idx, depth);
+        LY_CHECK_RET(rc);
+
+        /* ('*' / 'div' / 'mod' UnaryExpr)* */
+        while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
+                ((exp->expr[exp->tok_pos[*tok_idx]] == '*') || (exp->tok_len[*tok_idx] == 3))) {
+            exp_repeat_push(exp, prev_mul_exp, LYXP_EXPR_MULTIPLICATIVE);
+            ++(*tok_idx);
+
+            rc = reparse_unary_expr(ctx, exp, tok_idx, depth);
+            LY_CHECK_RET(rc);
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Reparse EqualityExpr. Logs directly on error.
+ *
+ * [13] EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr
+ *                     | EqualityExpr '!=' RelationalExpr
+ * [14] RelationalExpr ::= AdditiveExpr
+ *                       | RelationalExpr '<' AdditiveExpr
+ *                       | RelationalExpr '>' AdditiveExpr
+ *                       | RelationalExpr '<=' AdditiveExpr
+ *                       | RelationalExpr '>=' AdditiveExpr
+ *
+ * @param[in] ctx Context for logging.
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] depth Current number of nested expressions.
+ * @return LY_ERR
+ */
+static LY_ERR
+reparse_equality_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
+{
+    uint32_t prev_eq_exp, prev_rel_exp;
+    LY_ERR rc;
+
+    prev_eq_exp = *tok_idx;
+    goto reparse_additive_expr;
+
+    /* ('=' / '!=' RelationalExpr)* */
+    while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_EQUAL, LYXP_TOKEN_OPER_NEQUAL)) {
+        exp_repeat_push(exp, prev_eq_exp, LYXP_EXPR_EQUALITY);
+        ++(*tok_idx);
+
+reparse_additive_expr:
+        /* AdditiveExpr */
+        prev_rel_exp = *tok_idx;
+        rc = reparse_additive_expr(ctx, exp, tok_idx, depth);
+        LY_CHECK_RET(rc);
+
+        /* ('<' / '>' / '<=' / '>=' AdditiveExpr)* */
+        while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_COMP)) {
+            exp_repeat_push(exp, prev_rel_exp, LYXP_EXPR_RELATIONAL);
+            ++(*tok_idx);
+
+            rc = reparse_additive_expr(ctx, exp, tok_idx, depth);
+            LY_CHECK_RET(rc);
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Reparse OrExpr. Logs directly on error.
+ *
+ * [11] OrExpr ::= AndExpr | OrExpr 'or' AndExpr
+ * [12] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
+ *
+ * @param[in] ctx Context for logging.
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] depth Current number of nested expressions.
+ * @return LY_ERR
+ */
+static LY_ERR
+reparse_or_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
+{
+    uint32_t prev_or_exp, prev_and_exp;
+    LY_ERR rc;
+
+    ++depth;
+    LY_CHECK_ERR_RET(depth > LYXP_MAX_BLOCK_DEPTH, LOGVAL(ctx, LY_VCODE_XP_DEPTH), LY_EINVAL);
+
+    prev_or_exp = *tok_idx;
+    goto reparse_equality_expr;
+
+    /* ('or' AndExpr)* */
+    while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_LOG) && (exp->tok_len[*tok_idx] == 2)) {
+        exp_repeat_push(exp, prev_or_exp, LYXP_EXPR_OR);
+        ++(*tok_idx);
+
+reparse_equality_expr:
+        /* EqualityExpr */
+        prev_and_exp = *tok_idx;
+        rc = reparse_equality_expr(ctx, exp, tok_idx, depth);
+        LY_CHECK_RET(rc);
+
+        /* ('and' EqualityExpr)* */
+        while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_LOG) && (exp->tok_len[*tok_idx] == 3)) {
+            exp_repeat_push(exp, prev_and_exp, LYXP_EXPR_AND);
+            ++(*tok_idx);
+
+            rc = reparse_equality_expr(ctx, exp, tok_idx, depth);
+            LY_CHECK_RET(rc);
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Parse NCName.
+ *
+ * @param[in] ncname Name to parse.
+ * @return Length of @p ncname valid bytes.
+ */
+static ssize_t
+parse_ncname(const char *ncname)
+{
+    uint32_t uc;
+    size_t size;
+    ssize_t len = 0;
+
+    LY_CHECK_RET(ly_getutf8(&ncname, &uc, &size), 0);
+    if (!is_xmlqnamestartchar(uc) || (uc == ':')) {
+        return len;
+    }
+
+    do {
+        len += size;
+        if (!*ncname) {
+            break;
+        }
+        LY_CHECK_RET(ly_getutf8(&ncname, &uc, &size), -len);
+    } while (is_xmlqnamechar(uc) && (uc != ':'));
+
+    return len;
+}
+
+/**
+ * @brief Add @p token into the expression @p exp.
+ *
+ * @param[in] ctx Context for logging.
+ * @param[in] exp Expression to use.
+ * @param[in] token Token to add.
+ * @param[in] tok_pos Token position in the XPath expression.
+ * @param[in] tok_len Token length in the XPath expression.
+ * @return LY_ERR
+ */
+static LY_ERR
+exp_add_token(const struct ly_ctx *ctx, struct lyxp_expr *exp, enum lyxp_token token, uint32_t tok_pos, uint32_t tok_len)
+{
+    uint32_t prev;
+
+    if (exp->used == exp->size) {
+        prev = exp->size;
+        exp->size += LYXP_EXPR_SIZE_STEP;
+        if (prev > exp->size) {
+            LOGINT(ctx);
+            return LY_EINT;
+        }
+
+        exp->tokens = ly_realloc(exp->tokens, exp->size * sizeof *exp->tokens);
+        LY_CHECK_ERR_RET(!exp->tokens, LOGMEM(ctx), LY_EMEM);
+        exp->tok_pos = ly_realloc(exp->tok_pos, exp->size * sizeof *exp->tok_pos);
+        LY_CHECK_ERR_RET(!exp->tok_pos, LOGMEM(ctx), LY_EMEM);
+        exp->tok_len = ly_realloc(exp->tok_len, exp->size * sizeof *exp->tok_len);
+        LY_CHECK_ERR_RET(!exp->tok_len, LOGMEM(ctx), LY_EMEM);
+    }
+
+    exp->tokens[exp->used] = token;
+    exp->tok_pos[exp->used] = tok_pos;
+    exp->tok_len[exp->used] = tok_len;
+    ++exp->used;
+    return LY_SUCCESS;
+}
+
+void
+lyxp_expr_free(const struct ly_ctx *ctx, struct lyxp_expr *expr)
+{
+    uint32_t i;
+
+    if (!expr) {
+        return;
+    }
+
+    lydict_remove(ctx, expr->expr);
+    free(expr->tokens);
+    free(expr->tok_pos);
+    free(expr->tok_len);
+    if (expr->repeat) {
+        for (i = 0; i < expr->used; ++i) {
+            free(expr->repeat[i]);
+        }
+    }
+    free(expr->repeat);
+    free(expr);
+}
+
+/**
+ * @brief Parse Axis name.
+ *
+ * @param[in] str String to parse.
+ * @param[in] str_len Length of @p str.
+ * @return LY_SUCCESS if an axis.
+ * @return LY_ENOT otherwise.
+ */
+static LY_ERR
+expr_parse_axis(const char *str, size_t str_len)
+{
+    switch (str_len) {
+    case 4:
+        if (!strncmp("self", str, str_len)) {
+            return LY_SUCCESS;
+        }
+        break;
+    case 5:
+        if (!strncmp("child", str, str_len)) {
+            return LY_SUCCESS;
+        }
+        break;
+    case 6:
+        if (!strncmp("parent", str, str_len)) {
+            return LY_SUCCESS;
+        }
+        break;
+    case 8:
+        if (!strncmp("ancestor", str, str_len)) {
+            return LY_SUCCESS;
+        }
+        break;
+    case 9:
+        if (!strncmp("attribute", str, str_len)) {
+            return LY_SUCCESS;
+        } else if (!strncmp("following", str, str_len)) {
+            return LY_SUCCESS;
+        } else if (!strncmp("namespace", str, str_len)) {
+            LOGERR(NULL, LY_EINVAL, "Axis \"namespace\" not supported.");
+            return LY_ENOT;
+        } else if (!strncmp("preceding", str, str_len)) {
+            return LY_SUCCESS;
+        }
+        break;
+    case 10:
+        if (!strncmp("descendant", str, str_len)) {
+            return LY_SUCCESS;
+        }
+        break;
+    case 16:
+        if (!strncmp("ancestor-or-self", str, str_len)) {
+            return LY_SUCCESS;
+        }
+        break;
+    case 17:
+        if (!strncmp("following-sibling", str, str_len)) {
+            return LY_SUCCESS;
+        } else if (!strncmp("preceding-sibling", str, str_len)) {
+            return LY_SUCCESS;
+        }
+        break;
+    case 18:
+        if (!strncmp("descendant-or-self", str, str_len)) {
+            return LY_SUCCESS;
+        }
+        break;
+    }
+
+    return LY_ENOT;
+}
+
+LY_ERR
+lyxp_expr_parse(const struct ly_ctx *ctx, const char *expr_str, size_t expr_len, ly_bool reparse, struct lyxp_expr **expr_p)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lyxp_expr *expr;
+    size_t parsed = 0, tok_len;
+    enum lyxp_token tok_type;
+    ly_bool prev_func_check = 0, prev_ntype_check = 0, has_axis;
+    uint32_t tok_idx = 0;
+    ssize_t ncname_len;
+
+    assert(expr_p);
+
+    if (!expr_str[0]) {
+        LOGVAL(ctx, LY_VCODE_XP_EOF);
+        return LY_EVALID;
+    }
+
+    if (!expr_len) {
+        expr_len = strlen(expr_str);
+    }
+    if (expr_len > UINT32_MAX) {
+        LOGVAL(ctx, LYVE_XPATH, "XPath expression cannot be longer than %" PRIu32 " characters.", UINT32_MAX);
+        return LY_EVALID;
+    }
+
+    /* init lyxp_expr structure */
+    expr = calloc(1, sizeof *expr);
+    LY_CHECK_ERR_GOTO(!expr, LOGMEM(ctx); ret = LY_EMEM, error);
+    LY_CHECK_GOTO(ret = lydict_insert(ctx, expr_str, expr_len, &expr->expr), error);
+    expr->used = 0;
+    expr->size = LYXP_EXPR_SIZE_START;
+    expr->tokens = malloc(expr->size * sizeof *expr->tokens);
+    LY_CHECK_ERR_GOTO(!expr->tokens, LOGMEM(ctx); ret = LY_EMEM, error);
+
+    expr->tok_pos = malloc(expr->size * sizeof *expr->tok_pos);
+    LY_CHECK_ERR_GOTO(!expr->tok_pos, LOGMEM(ctx); ret = LY_EMEM, error);
+
+    expr->tok_len = malloc(expr->size * sizeof *expr->tok_len);
+    LY_CHECK_ERR_GOTO(!expr->tok_len, LOGMEM(ctx); ret = LY_EMEM, error);
+
+    /* make expr 0-terminated */
+    expr_str = expr->expr;
+
+    while (is_xmlws(expr_str[parsed])) {
+        ++parsed;
+    }
+
+    do {
+        if (expr_str[parsed] == '(') {
+
+            /* '(' */
+            tok_len = 1;
+            tok_type = LYXP_TOKEN_PAR1;
+
+            if (prev_ntype_check && expr->used && (expr->tokens[expr->used - 1] == LYXP_TOKEN_NAMETEST) &&
+                    (((expr->tok_len[expr->used - 1] == 4) &&
+                    (!strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "node", 4) ||
+                    !strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "text", 4))) ||
+                    ((expr->tok_len[expr->used - 1] == 7) &&
+                    !strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "comment", 7)))) {
+                /* it is NodeType after all */
+                expr->tokens[expr->used - 1] = LYXP_TOKEN_NODETYPE;
+
+                prev_ntype_check = 0;
+                prev_func_check = 0;
+            } else if (prev_func_check && expr->used && (expr->tokens[expr->used - 1] == LYXP_TOKEN_NAMETEST)) {
+                /* it is FunctionName after all */
+                expr->tokens[expr->used - 1] = LYXP_TOKEN_FUNCNAME;
+
+                prev_ntype_check = 0;
+                prev_func_check = 0;
+            }
+
+        } else if (expr_str[parsed] == ')') {
+
+            /* ')' */
+            tok_len = 1;
+            tok_type = LYXP_TOKEN_PAR2;
+
+        } else if (expr_str[parsed] == '[') {
+
+            /* '[' */
+            tok_len = 1;
+            tok_type = LYXP_TOKEN_BRACK1;
+
+        } else if (expr_str[parsed] == ']') {
+
+            /* ']' */
+            tok_len = 1;
+            tok_type = LYXP_TOKEN_BRACK2;
+
+        } else if (!strncmp(&expr_str[parsed], "..", 2)) {
+
+            /* '..' */
+            tok_len = 2;
+            tok_type = LYXP_TOKEN_DDOT;
+
+        } else if ((expr_str[parsed] == '.') && (!isdigit(expr_str[parsed + 1]))) {
+
+            /* '.' */
+            tok_len = 1;
+            tok_type = LYXP_TOKEN_DOT;
+
+        } else if (expr_str[parsed] == '@') {
+
+            /* '@' */
+            tok_len = 1;
+            tok_type = LYXP_TOKEN_AT;
+
+        } else if (expr_str[parsed] == ',') {
+
+            /* ',' */
+            tok_len = 1;
+            tok_type = LYXP_TOKEN_COMMA;
+
+        } else if (expr_str[parsed] == '\'') {
+
+            /* Literal with ' */
+            for (tok_len = 1; (expr_str[parsed + tok_len] != '\0') && (expr_str[parsed + tok_len] != '\''); ++tok_len) {}
+            LY_CHECK_ERR_GOTO(expr_str[parsed + tok_len] == '\0',
+                    LOGVAL(ctx, LY_VCODE_XP_EOE, expr_str[parsed], &expr_str[parsed]); ret = LY_EVALID,
+                    error);
+            ++tok_len;
+            tok_type = LYXP_TOKEN_LITERAL;
+
+        } else if (expr_str[parsed] == '\"') {
+
+            /* Literal with " */
+            for (tok_len = 1; (expr_str[parsed + tok_len] != '\0') && (expr_str[parsed + tok_len] != '\"'); ++tok_len) {}
+            LY_CHECK_ERR_GOTO(expr_str[parsed + tok_len] == '\0',
+                    LOGVAL(ctx, LY_VCODE_XP_EOE, expr_str[parsed], &expr_str[parsed]); ret = LY_EVALID,
+                    error);
+            ++tok_len;
+            tok_type = LYXP_TOKEN_LITERAL;
+
+        } else if ((expr_str[parsed] == '.') || (isdigit(expr_str[parsed]))) {
+
+            /* Number */
+            for (tok_len = 0; isdigit(expr_str[parsed + tok_len]); ++tok_len) {}
+            if (expr_str[parsed + tok_len] == '.') {
+                ++tok_len;
+                for ( ; isdigit(expr_str[parsed + tok_len]); ++tok_len) {}
+            }
+            tok_type = LYXP_TOKEN_NUMBER;
+
+        } else if (expr_str[parsed] == '$') {
+
+            /* VariableReference */
+            parsed++;
+            ncname_len = parse_ncname(&expr_str[parsed]);
+            LY_CHECK_ERR_GOTO(ncname_len < 1, LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed - ncname_len],
+                    parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
+            tok_len = ncname_len;
+            LY_CHECK_ERR_GOTO(expr_str[parsed + tok_len] == ':',
+                    LOGVAL(ctx, LYVE_XPATH, "Variable with prefix is not supported."); ret = LY_EVALID,
+                    error);
+            tok_type = LYXP_TOKEN_VARREF;
+
+        } else if (expr_str[parsed] == '/') {
+
+            /* Operator '/', '//' */
+            if (!strncmp(&expr_str[parsed], "//", 2)) {
+                tok_len = 2;
+                tok_type = LYXP_TOKEN_OPER_RPATH;
+            } else {
+                tok_len = 1;
+                tok_type = LYXP_TOKEN_OPER_PATH;
+            }
+
+        } else if (!strncmp(&expr_str[parsed], "!=", 2)) {
+
+            /* Operator '!=' */
+            tok_len = 2;
+            tok_type = LYXP_TOKEN_OPER_NEQUAL;
+
+        } else if (!strncmp(&expr_str[parsed], "<=", 2) || !strncmp(&expr_str[parsed], ">=", 2)) {
+
+            /* Operator '<=', '>=' */
+            tok_len = 2;
+            tok_type = LYXP_TOKEN_OPER_COMP;
+
+        } else if (expr_str[parsed] == '|') {
+
+            /* Operator '|' */
+            tok_len = 1;
+            tok_type = LYXP_TOKEN_OPER_UNI;
+
+        } else if ((expr_str[parsed] == '+') || (expr_str[parsed] == '-')) {
+
+            /* Operator '+', '-' */
+            tok_len = 1;
+            tok_type = LYXP_TOKEN_OPER_MATH;
+
+        } else if (expr_str[parsed] == '=') {
+
+            /* Operator '=' */
+            tok_len = 1;
+            tok_type = LYXP_TOKEN_OPER_EQUAL;
+
+        } else if ((expr_str[parsed] == '<') || (expr_str[parsed] == '>')) {
+
+            /* Operator '<', '>' */
+            tok_len = 1;
+            tok_type = LYXP_TOKEN_OPER_COMP;
+
+        } else if (expr->used && (expr->tokens[expr->used - 1] != LYXP_TOKEN_AT) &&
+                (expr->tokens[expr->used - 1] != LYXP_TOKEN_PAR1) &&
+                (expr->tokens[expr->used - 1] != LYXP_TOKEN_BRACK1) &&
+                (expr->tokens[expr->used - 1] != LYXP_TOKEN_COMMA) &&
+                (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_LOG) &&
+                (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_EQUAL) &&
+                (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_NEQUAL) &&
+                (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_COMP) &&
+                (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_MATH) &&
+                (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_UNI) &&
+                (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_PATH) &&
+                (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_RPATH)) {
+
+            /* Operator '*', 'or', 'and', 'mod', or 'div' */
+            if (expr_str[parsed] == '*') {
+                tok_len = 1;
+                tok_type = LYXP_TOKEN_OPER_MATH;
+
+            } else if (!strncmp(&expr_str[parsed], "or", 2)) {
+                tok_len = 2;
+                tok_type = LYXP_TOKEN_OPER_LOG;
+
+            } else if (!strncmp(&expr_str[parsed], "and", 3)) {
+                tok_len = 3;
+                tok_type = LYXP_TOKEN_OPER_LOG;
+
+            } else if (!strncmp(&expr_str[parsed], "mod", 3) || !strncmp(&expr_str[parsed], "div", 3)) {
+                tok_len = 3;
+                tok_type = LYXP_TOKEN_OPER_MATH;
+
+            } else if (prev_ntype_check || prev_func_check) {
+                LOGVAL(ctx, LYVE_XPATH, "Invalid character 0x%x ('%c'), perhaps \"%.*s\" is supposed to be a function call.",
+                        expr_str[parsed], expr_str[parsed], expr->tok_len[expr->used - 1], &expr->expr[expr->tok_pos[expr->used - 1]]);
+                ret = LY_EVALID;
+                goto error;
+            } else {
+                LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed], parsed + 1, expr_str);
+                ret = LY_EVALID;
+                goto error;
+            }
+        } else {
+
+            /* (AxisName '::')? ((NCName ':')? '*' | QName) or NodeType/FunctionName */
+            if (expr_str[parsed] == '*') {
+                ncname_len = 1;
+            } else {
+                ncname_len = parse_ncname(&expr_str[parsed]);
+                LY_CHECK_ERR_GOTO(ncname_len < 1, LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed - ncname_len],
+                        parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
+            }
+            tok_len = ncname_len;
+
+            has_axis = 0;
+            if (!strncmp(&expr_str[parsed + tok_len], "::", 2)) {
+                /* axis */
+                LY_CHECK_ERR_GOTO(expr_parse_axis(&expr_str[parsed], ncname_len),
+                        LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed], parsed + 1, expr_str); ret = LY_EVALID, error);
+                tok_type = LYXP_TOKEN_AXISNAME;
+
+                LY_CHECK_GOTO(ret = exp_add_token(ctx, expr, tok_type, parsed, tok_len), error);
+                parsed += tok_len;
+
+                /* '::' */
+                tok_len = 2;
+                tok_type = LYXP_TOKEN_DCOLON;
+
+                LY_CHECK_GOTO(ret = exp_add_token(ctx, expr, tok_type, parsed, tok_len), error);
+                parsed += tok_len;
+
+                if (expr_str[parsed] == '*') {
+                    ncname_len = 1;
+                } else {
+                    ncname_len = parse_ncname(&expr_str[parsed]);
+                    LY_CHECK_ERR_GOTO(ncname_len < 1, LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed - ncname_len],
+                            parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
+                }
+                tok_len = ncname_len;
+
+                has_axis = 1;
+            }
+
+            if (expr_str[parsed + tok_len] == ':') {
+                ++tok_len;
+                if (expr_str[parsed + tok_len] == '*') {
+                    ++tok_len;
+                } else {
+                    ncname_len = parse_ncname(&expr_str[parsed + tok_len]);
+                    LY_CHECK_ERR_GOTO(ncname_len < 1, LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed - ncname_len],
+                            parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
+                    tok_len += ncname_len;
+                }
+                /* remove old flags to prevent ambiguities */
+                prev_ntype_check = 0;
+                prev_func_check = 0;
+                tok_type = LYXP_TOKEN_NAMETEST;
+            } else {
+                /* if not '*', there is no prefix so it can still be NodeType/FunctionName, we can't finally decide now */
+                prev_ntype_check = (expr_str[parsed] == '*') ? 0 : 1;
+                prev_func_check = (prev_ntype_check && !has_axis) ? 1 : 0;
+                tok_type = LYXP_TOKEN_NAMETEST;
+            }
+        }
+
+        /* store the token, move on to the next one */
+        LY_CHECK_GOTO(ret = exp_add_token(ctx, expr, tok_type, parsed, tok_len), error);
+        parsed += tok_len;
+        while (is_xmlws(expr_str[parsed])) {
+            ++parsed;
+        }
+
+    } while (expr_str[parsed]);
+
+    if (reparse) {
+        /* prealloc repeat */
+        expr->repeat = calloc(expr->size, sizeof *expr->repeat);
+        LY_CHECK_ERR_GOTO(!expr->repeat, LOGMEM(ctx); ret = LY_EMEM, error);
+
+        /* fill repeat */
+        LY_CHECK_ERR_GOTO(reparse_or_expr(ctx, expr, &tok_idx, 0), ret = LY_EVALID, error);
+        if (expr->used > tok_idx) {
+            LOGVAL(ctx, LYVE_XPATH, "Unparsed characters \"%s\" left at the end of an XPath expression.",
+                    &expr->expr[expr->tok_pos[tok_idx]]);
+            ret = LY_EVALID;
+            goto error;
+        }
+    }
+
+    print_expr_struct_debug(expr);
+    *expr_p = expr;
+    return LY_SUCCESS;
+
+error:
+    lyxp_expr_free(ctx, expr);
+    return ret;
+}
+
+LY_ERR
+lyxp_expr_dup(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint32_t start_idx, uint32_t end_idx,
+        struct lyxp_expr **dup_p)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lyxp_expr *dup = NULL;
+    uint32_t used = 0, i, j, expr_len;
+    const char *expr_start;
+
+    assert((!start_idx && !end_idx) || ((start_idx < exp->used) && (end_idx < exp->used) && (start_idx <= end_idx)));
+
+    if (!exp) {
+        goto cleanup;
+    }
+
+    if (!start_idx && !end_idx) {
+        end_idx = exp->used - 1;
+    }
+
+    expr_start = exp->expr + exp->tok_pos[start_idx];
+    expr_len = (exp->tok_pos[end_idx] + exp->tok_len[end_idx]) - exp->tok_pos[start_idx];
+
+    dup = calloc(1, sizeof *dup);
+    LY_CHECK_ERR_GOTO(!dup, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+
+    if (exp->used) {
+        used = (end_idx - start_idx) + 1;
+
+        dup->tokens = malloc(used * sizeof *dup->tokens);
+        LY_CHECK_ERR_GOTO(!dup->tokens, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+        memcpy(dup->tokens, exp->tokens + start_idx, used * sizeof *dup->tokens);
+
+        dup->tok_pos = malloc(used * sizeof *dup->tok_pos);
+        LY_CHECK_ERR_GOTO(!dup->tok_pos, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+        memcpy(dup->tok_pos, exp->tok_pos + start_idx, used * sizeof *dup->tok_pos);
+
+        if (start_idx) {
+            /* fix the indices in the expression */
+            for (i = 0; i < used; ++i) {
+                dup->tok_pos[i] -= expr_start - exp->expr;
+            }
+        }
+
+        dup->tok_len = malloc(used * sizeof *dup->tok_len);
+        LY_CHECK_ERR_GOTO(!dup->tok_len, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+        memcpy(dup->tok_len, exp->tok_len + start_idx, used * sizeof *dup->tok_len);
+
+        if (exp->repeat) {
+            dup->repeat = malloc(used * sizeof *dup->repeat);
+            LY_CHECK_ERR_GOTO(!dup->repeat, LOGMEM(ctx); ret = LY_EMEM, cleanup);
+            for (i = start_idx; i <= end_idx; ++i) {
+                if (!exp->repeat[i]) {
+                    dup->repeat[i - start_idx] = NULL;
+                } else {
+                    for (j = 0; exp->repeat[i][j]; ++j) {}
+                    /* the ending 0 as well */
+                    ++j;
+
+                    dup->repeat[i - start_idx] = malloc(j * sizeof **dup->repeat);
+                    LY_CHECK_ERR_GOTO(!dup->repeat[i - start_idx], LOGMEM(ctx); ret = LY_EMEM, cleanup);
+                    memcpy(dup->repeat[i - start_idx], exp->repeat[i], j * sizeof **dup->repeat);
+                }
+            }
+        }
+    }
+
+    dup->used = used;
+    dup->size = used;
+
+    /* copy only subexpression */
+    LY_CHECK_GOTO(ret = lydict_insert(ctx, expr_start, expr_len, &dup->expr), cleanup);
+
+cleanup:
+    if (ret) {
+        lyxp_expr_free(ctx, dup);
+    } else {
+        *dup_p = dup;
+    }
+    return ret;
+}
+
+/**
+ * @brief Get the last-added schema node that is currently in the context.
+ *
+ * @param[in] set Set to search in.
+ * @return Last-added schema context node, NULL if no node is in context.
+ */
+static struct lysc_node *
+warn_get_scnode_in_ctx(struct lyxp_set *set)
+{
+    uint32_t i;
+
+    if (!set || (set->type != LYXP_SET_SCNODE_SET)) {
+        return NULL;
+    }
+
+    i = set->used;
+    do {
+        --i;
+        if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
+            /* if there are more, simply return the first found (last added) */
+            return set->val.scnodes[i].scnode;
+        }
+    } while (i);
+
+    return NULL;
+}
+
+/**
+ * @brief Test whether a type is numeric - integer type or decimal64.
+ *
+ * @param[in] type Type to test.
+ * @return Boolean value whether @p type is numeric type or not.
+ */
+static ly_bool
+warn_is_numeric_type(struct lysc_type *type)
+{
+    struct lysc_type_union *uni;
+    ly_bool ret;
+    LY_ARRAY_COUNT_TYPE u;
+
+    switch (type->basetype) {
+    case LY_TYPE_DEC64:
+    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:
+        return 1;
+    case LY_TYPE_UNION:
+        uni = (struct lysc_type_union *)type;
+        LY_ARRAY_FOR(uni->types, u) {
+            ret = warn_is_numeric_type(uni->types[u]);
+            if (ret) {
+                /* found a suitable type */
+                return ret;
+            }
+        }
+        /* did not find any suitable type */
+        return 0;
+    case LY_TYPE_LEAFREF:
+        return warn_is_numeric_type(((struct lysc_type_leafref *)type)->realtype);
+    default:
+        return 0;
+    }
+}
+
+/**
+ * @brief Test whether a type is string-like - no integers, decimal64 or binary.
+ *
+ * @param[in] type Type to test.
+ * @return Boolean value whether @p type's basetype is string type or not.
+ */
+static ly_bool
+warn_is_string_type(struct lysc_type *type)
+{
+    struct lysc_type_union *uni;
+    ly_bool ret;
+    LY_ARRAY_COUNT_TYPE u;
+
+    switch (type->basetype) {
+    case LY_TYPE_BITS:
+    case LY_TYPE_ENUM:
+    case LY_TYPE_IDENT:
+    case LY_TYPE_INST:
+    case LY_TYPE_STRING:
+        return 1;
+    case LY_TYPE_UNION:
+        uni = (struct lysc_type_union *)type;
+        LY_ARRAY_FOR(uni->types, u) {
+            ret = warn_is_string_type(uni->types[u]);
+            if (ret) {
+                /* found a suitable type */
+                return ret;
+            }
+        }
+        /* did not find any suitable type */
+        return 0;
+    case LY_TYPE_LEAFREF:
+        return warn_is_string_type(((struct lysc_type_leafref *)type)->realtype);
+    default:
+        return 0;
+    }
+}
+
+/**
+ * @brief Test whether a type is one specific type.
+ *
+ * @param[in] type Type to test.
+ * @param[in] base Expected type.
+ * @return Boolean value whether the given @p type is of the specific basetype @p base.
+ */
+static ly_bool
+warn_is_specific_type(struct lysc_type *type, LY_DATA_TYPE base)
+{
+    struct lysc_type_union *uni;
+    ly_bool ret;
+    LY_ARRAY_COUNT_TYPE u;
+
+    if (type->basetype == base) {
+        return 1;
+    } else if (type->basetype == LY_TYPE_UNION) {
+        uni = (struct lysc_type_union *)type;
+        LY_ARRAY_FOR(uni->types, u) {
+            ret = warn_is_specific_type(uni->types[u], base);
+            if (ret) {
+                /* found a suitable type */
+                return ret;
+            }
+        }
+        /* did not find any suitable type */
+        return 0;
+    } else if (type->basetype == LY_TYPE_LEAFREF) {
+        return warn_is_specific_type(((struct lysc_type_leafref *)type)->realtype, base);
+    }
+
+    return 0;
+}
+
+/**
+ * @brief Get next type of a (union) type.
+ *
+ * @param[in] type Base type.
+ * @param[in] prev_type Previously returned type.
+ * @return Next type or NULL.
+ */
+static struct lysc_type *
+warn_is_equal_type_next_type(struct lysc_type *type, struct lysc_type *prev_type)
+{
+    struct lysc_type_union *uni;
+    ly_bool found = 0;
+    LY_ARRAY_COUNT_TYPE u;
+
+    if (type->basetype == LY_TYPE_UNION) {
+        uni = (struct lysc_type_union *)type;
+        if (!prev_type) {
+            return uni->types[0];
+        }
+        LY_ARRAY_FOR(uni->types, u) {
+            if (found) {
+                return uni->types[u];
+            }
+            if (prev_type == uni->types[u]) {
+                found = 1;
+            }
+        }
+        return NULL;
+    } else {
+        if (prev_type) {
+            assert(type == prev_type);
+            return NULL;
+        } else {
+            return type;
+        }
+    }
+}
+
+/**
+ * @brief Test whether 2 types have a common type.
+ *
+ * @param[in] type1 First type.
+ * @param[in] type2 Second type.
+ * @return 1 if they do, 0 otherwise.
+ */
+static int
+warn_is_equal_type(struct lysc_type *type1, struct lysc_type *type2)
+{
+    struct lysc_type *t1, *rt1, *t2, *rt2;
+
+    t1 = NULL;
+    while ((t1 = warn_is_equal_type_next_type(type1, t1))) {
+        if (t1->basetype == LY_TYPE_LEAFREF) {
+            rt1 = ((struct lysc_type_leafref *)t1)->realtype;
+        } else {
+            rt1 = t1;
+        }
+
+        t2 = NULL;
+        while ((t2 = warn_is_equal_type_next_type(type2, t2))) {
+            if (t2->basetype == LY_TYPE_LEAFREF) {
+                rt2 = ((struct lysc_type_leafref *)t2)->realtype;
+            } else {
+                rt2 = t2;
+            }
+
+            if (rt2->basetype == rt1->basetype) {
+                /* match found */
+                return 1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+/**
+ * @brief Print warning with information about the XPath subexpression that caused previous warning.
+ *
+ * @param[in] ctx Context for logging.
+ * @param[in] tok_pos Index of the subexpression in the whole expression.
+ * @param[in] subexpr Subexpression start.
+ * @param[in] subexpr_len Length of @p subexpr to print.
+ * @param[in] cur_scnode Expression context node.
+ */
+static void
+warn_subexpr_log(const struct ly_ctx *ctx, uint32_t tok_pos, const char *subexpr, int subexpr_len,
+        const struct lysc_node *cur_scnode)
+{
+    char *path;
+
+    path = lysc_path(cur_scnode, LYSC_PATH_LOG, NULL, 0);
+    LOGWRN(ctx, "Previous warning generated by XPath subexpression[%" PRIu32 "] \"%.*s\" with context node \"%s\".",
+            tok_pos, subexpr_len, subexpr, path);
+    free(path);
+}
+
+/**
+ * @brief Check both operands of comparison operators.
+ *
+ * @param[in] ctx Context for errors.
+ * @param[in] set1 First operand set.
+ * @param[in] set2 Second operand set.
+ * @param[in] numbers_only Whether accept only numbers or other types are fine too (for '=' and '!=').
+ * @param[in] expr Start of the expression to print with the warning.
+ * @param[in] tok_pos Token position.
+ */
+static void
+warn_operands(struct ly_ctx *ctx, struct lyxp_set *set1, struct lyxp_set *set2, ly_bool numbers_only, const char *expr,
+        uint32_t tok_pos)
+{
+    struct lysc_node_leaf *node1, *node2;
+    ly_bool leaves = 1, warning = 0;
+
+    node1 = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set1);
+    node2 = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set2);
+
+    if (!node1 && !node2) {
+        /* no node-sets involved, nothing to do */
+        return;
+    }
+
+    if (node1) {
+        if (!(node1->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+            LOGWRN(ctx, "Node type %s \"%s\" used as operand.", lys_nodetype2str(node1->nodetype), node1->name);
+            warning = 1;
+            leaves = 0;
+        } else if (numbers_only && !warn_is_numeric_type(node1->type)) {
+            LOGWRN(ctx, "Node \"%s\" is not of a numeric type, but used where it was expected.", node1->name);
+            warning = 1;
+        }
+    }
+
+    if (node2) {
+        if (!(node2->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+            LOGWRN(ctx, "Node type %s \"%s\" used as operand.", lys_nodetype2str(node2->nodetype), node2->name);
+            warning = 1;
+            leaves = 0;
+        } else if (numbers_only && !warn_is_numeric_type(node2->type)) {
+            LOGWRN(ctx, "Node \"%s\" is not of a numeric type, but used where it was expected.", node2->name);
+            warning = 1;
+        }
+    }
+
+    if (node1 && node2 && leaves && !numbers_only) {
+        if ((warn_is_numeric_type(node1->type) && !warn_is_numeric_type(node2->type)) ||
+                (!warn_is_numeric_type(node1->type) && warn_is_numeric_type(node2->type)) ||
+                (!warn_is_numeric_type(node1->type) && !warn_is_numeric_type(node2->type) &&
+                !warn_is_equal_type(node1->type, node2->type))) {
+            LOGWRN(ctx, "Incompatible types of operands \"%s\" and \"%s\" for comparison.", node1->name, node2->name);
+            warning = 1;
+        }
+    }
+
+    if (warning) {
+        warn_subexpr_log(ctx, tok_pos, expr + tok_pos, 20, set1->cur_scnode);
+    }
+}
+
+/**
+ * @brief Check that a value is valid for a leaf. If not applicable, does nothing.
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] set Set with the leaf/leaf-list.
+ * @param[in] val_exp Index of the value (literal/number) in @p exp.
+ * @param[in] equal_exp Index of the start of the equality expression in @p exp.
+ * @param[in] last_equal_exp Index of the end of the equality expression in @p exp.
+ */
+static void
+warn_equality_value(const struct lyxp_expr *exp, struct lyxp_set *set, uint32_t val_exp, uint32_t equal_exp,
+        uint32_t last_equal_exp)
+{
+    struct lysc_node *scnode;
+    struct lysc_type *type;
+    char *value;
+    struct lyd_value storage;
+    LY_ERR rc;
+    struct ly_err_item *err = NULL;
+
+    if ((scnode = warn_get_scnode_in_ctx(set)) && (scnode->nodetype & (LYS_LEAF | LYS_LEAFLIST)) &&
+            ((exp->tokens[val_exp] == LYXP_TOKEN_LITERAL) || (exp->tokens[val_exp] == LYXP_TOKEN_NUMBER))) {
+        /* check that the node can have the specified value */
+        if (exp->tokens[val_exp] == LYXP_TOKEN_LITERAL) {
+            value = strndup(exp->expr + exp->tok_pos[val_exp] + 1, exp->tok_len[val_exp] - 2);
+        } else {
+            value = strndup(exp->expr + exp->tok_pos[val_exp], exp->tok_len[val_exp]);
+        }
+        if (!value) {
+            LOGMEM(set->ctx);
+            return;
+        }
+
+        if ((((struct lysc_node_leaf *)scnode)->type->basetype == LY_TYPE_IDENT) && !strchr(value, ':')) {
+            LOGWRN(set->ctx, "Identityref \"%s\" comparison with identity \"%s\" without prefix, consider adding"
+                    " a prefix or best using \"derived-from(-or-self)()\" functions.", scnode->name, value);
+            warn_subexpr_log(set->ctx, exp->tok_pos[equal_exp], exp->expr + exp->tok_pos[equal_exp],
+                    (exp->tok_pos[last_equal_exp] - exp->tok_pos[equal_exp]) + exp->tok_len[last_equal_exp],
+                    set->cur_scnode);
+        }
+
+        type = ((struct lysc_node_leaf *)scnode)->type;
+        if (type->basetype != LY_TYPE_IDENT) {
+            rc = type->plugin->store(set->ctx, type, value, strlen(value), 0, set->format, set->prefix_data,
+                    LYD_HINT_DATA, scnode, &storage, NULL, &err);
+            if (rc == LY_EINCOMPLETE) {
+                rc = LY_SUCCESS;
+            }
+
+            if (err) {
+                LOGWRN(set->ctx, "Invalid value \"%s\" which does not fit the type (%s).", value, err->msg);
+                ly_err_free(err);
+            } else if (rc != LY_SUCCESS) {
+                LOGWRN(set->ctx, "Invalid value \"%s\" which does not fit the type.", value);
+            }
+            if (rc != LY_SUCCESS) {
+                warn_subexpr_log(set->ctx, exp->tok_pos[equal_exp], exp->expr + exp->tok_pos[equal_exp],
+                        (exp->tok_pos[last_equal_exp] - exp->tok_pos[equal_exp]) + exp->tok_len[last_equal_exp],
+                        set->cur_scnode);
+            } else {
+                type->plugin->free(set->ctx, &storage);
+            }
+        }
+        free(value);
+    }
+}
+
+/*
+ * XPath functions
+ */
+
+/**
+ * @brief Execute the YANG 1.1 bit-is-set(node-set, string) function. Returns LYXP_SET_BOOLEAN
+ *        depending on whether the first node bit value from the second argument is set.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_bit_is_set(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    struct lyd_node_term *leaf;
+    struct lysc_node_leaf *sleaf;
+    struct lyd_value_bits *bits;
+    LY_ERR rc = LY_SUCCESS;
+    LY_ARRAY_COUNT_TYPE u;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if (args[0]->type != LYXP_SET_SCNODE_SET) {
+            LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
+        } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
+                        sleaf->name);
+            } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_BITS)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"bits\".", __func__, sleaf->name);
+            }
+        }
+
+        if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
+                        sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    if (args[0]->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "bit-is-set(node-set, string)");
+        return LY_EVALID;
+    }
+    rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+
+    set_fill_boolean(set, 0);
+    if (args[0]->used) {
+        leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
+        if ((leaf->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST)) && (leaf->value.realtype->basetype == LY_TYPE_BITS)) {
+            LYD_VALUE_GET(&leaf->value, bits);
+            LY_ARRAY_FOR(bits->items, u) {
+                if (!strcmp(bits->items[u]->name, args[1]->val.str)) {
+                    set_fill_boolean(set, 1);
+                    break;
+                }
+            }
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath boolean(object) function. Returns LYXP_SET_BOOLEAN
+ *        with the argument converted to boolean.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_boolean(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR rc;
+
+    if (options & LYXP_SCNODE_ALL) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
+        return LY_SUCCESS;
+    }
+
+    rc = lyxp_set_cast(args[0], LYXP_SET_BOOLEAN);
+    LY_CHECK_RET(rc);
+    set_fill_set(set, args[0]);
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath ceiling(number) function. Returns LYXP_SET_NUMBER
+ *        with the first argument rounded up to the nearest integer.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_ceiling(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    struct lysc_node_leaf *sleaf;
+    LY_ERR rc = LY_SUCCESS;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if (args[0]->type != LYXP_SET_SCNODE_SET) {
+            LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
+        } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
+                        sleaf->name);
+            } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_DEC64)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"decimal64\".", __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
+    LY_CHECK_RET(rc);
+    if ((long long)args[0]->val.num != args[0]->val.num) {
+        set_fill_number(set, ((long long)args[0]->val.num) + 1);
+    } else {
+        set_fill_number(set, args[0]->val.num);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath concat(string, string, string*) function.
+ *        Returns LYXP_SET_STRING with the concatenation of all the arguments.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_concat(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
+{
+    uint32_t i;
+    char *str = NULL;
+    size_t used = 1;
+    LY_ERR rc = LY_SUCCESS;
+    struct lysc_node_leaf *sleaf;
+
+    if (options & LYXP_SCNODE_ALL) {
+        for (i = 0; i < arg_count; ++i) {
+            if ((args[i]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[i]))) {
+                if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                    LOGWRN(set->ctx, "Argument #%u of %s is a %s node \"%s\".",
+                            i + 1, __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+                } else if (!warn_is_string_type(sleaf->type)) {
+                    LOGWRN(set->ctx, "Argument #%u of %s is node \"%s\", not of string-type.", i + 1, __func__, sleaf->name);
+                }
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    for (i = 0; i < arg_count; ++i) {
+        rc = lyxp_set_cast(args[i], LYXP_SET_STRING);
+        if (rc != LY_SUCCESS) {
+            free(str);
+            return rc;
+        }
+
+        str = ly_realloc(str, (used + strlen(args[i]->val.str)) * sizeof(char));
+        LY_CHECK_ERR_RET(!str, LOGMEM(set->ctx), LY_EMEM);
+        strcpy(str + used - 1, args[i]->val.str);
+        used += strlen(args[i]->val.str);
+    }
+
+    /* free, kind of */
+    lyxp_set_free_content(set);
+    set->type = LYXP_SET_STRING;
+    set->val.str = str;
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath contains(string, string) function.
+ *        Returns LYXP_SET_BOOLEAN whether the second argument can
+ *        be found in the first or not.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_contains(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    struct lysc_node_leaf *sleaf;
+    LY_ERR rc = LY_SUCCESS;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
+                        sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+
+        if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
+                        sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+    rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+
+    if (strstr(args[0]->val.str, args[1]->val.str)) {
+        set_fill_boolean(set, 1);
+    } else {
+        set_fill_boolean(set, 0);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath count(node-set) function. Returns LYXP_SET_NUMBER
+ *        with the size of the node-set from the argument.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_count(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR rc = LY_SUCCESS;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if (args[0]->type != LYXP_SET_SCNODE_SET) {
+            LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
+        return rc;
+    }
+
+    if (args[0]->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "count(node-set)");
+        return LY_EVALID;
+    }
+
+    set_fill_number(set, args[0]->used);
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath current() function. Returns LYXP_SET_NODE_SET
+ *        with the context with the intial node.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_current(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
+{
+    if (arg_count || args) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INARGCOUNT, arg_count, LY_PRI_LENSTR("current()"));
+        return LY_EVALID;
+    }
+
+    if (options & LYXP_SCNODE_ALL) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
+
+        if (set->cur_scnode) {
+            LY_CHECK_RET(set_scnode_insert_node(set, set->cur_scnode, LYXP_NODE_ELEM, LYXP_AXIS_SELF, NULL));
+        } else {
+            /* root node */
+            LY_CHECK_RET(set_scnode_insert_node(set, NULL, set->root_type, LYXP_AXIS_SELF, NULL));
+        }
+    } else {
+        lyxp_set_free_content(set);
+
+        if (set->cur_node) {
+            /* position is filled later */
+            set_insert_node(set, set->cur_node, 0, LYXP_NODE_ELEM, 0);
+        } else {
+            /* root node */
+            set_insert_node(set, NULL, 0, set->root_type, 0);
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the YANG 1.1 deref(node-set) function. Returns LYXP_SET_NODE_SET with either
+ *        leafref or instance-identifier target node(s).
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_deref(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    struct lyd_node_term *leaf;
+    struct lysc_node_leaf *sleaf = NULL;
+    struct lysc_type_leafref *lref;
+    const struct lysc_node *target;
+    struct ly_path *p;
+    struct lyd_node *node;
+    char *errmsg = NULL;
+    uint8_t oper;
+    LY_ERR r;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if (args[0]->type != LYXP_SET_SCNODE_SET) {
+            LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
+        } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & LYD_NODE_TERM)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
+                        sleaf->name);
+            } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_LEAFREF) &&
+                    !warn_is_specific_type(sleaf->type, LY_TYPE_INST)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"leafref\" nor \"instance-identifier\".",
+                        __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        if (sleaf && (sleaf->nodetype & LYD_NODE_TERM) && (sleaf->type->basetype == LY_TYPE_LEAFREF)) {
+            lref = (struct lysc_type_leafref *)sleaf->type;
+            oper = (sleaf->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
+
+            /* it was already evaluated on schema, it must succeed */
+            r = ly_path_compile_leafref(set->ctx, &sleaf->node, NULL, lref->path, oper, LY_PATH_TARGET_MANY,
+                    LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &p);
+            if (!r) {
+                /* get the target node */
+                target = p[LY_ARRAY_COUNT(p) - 1].node;
+                ly_path_free(set->ctx, p);
+
+                LY_CHECK_RET(set_scnode_insert_node(set, target, LYXP_NODE_ELEM, LYXP_AXIS_SELF, NULL));
+            } /* else the target was found before but is disabled so it was removed */
+        }
+
+        return LY_SUCCESS;
+    }
+
+    if (args[0]->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "deref(node-set)");
+        return LY_EVALID;
+    }
+
+    lyxp_set_free_content(set);
+    if (args[0]->used) {
+        leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
+        sleaf = (struct lysc_node_leaf *)leaf->schema;
+        if (sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
+            if (sleaf->type->basetype == LY_TYPE_LEAFREF) {
+                /* find leafref target */
+                if (lyplg_type_resolve_leafref((struct lysc_type_leafref *)sleaf->type, &leaf->node, &leaf->value, set->tree,
+                        &node, &errmsg)) {
+                    LOGERR(set->ctx, LY_EVALID, "%s", errmsg);
+                    free(errmsg);
+                    return LY_EVALID;
+                }
+            } else {
+                assert(sleaf->type->basetype == LY_TYPE_INST);
+                if (ly_path_eval(leaf->value.target, set->tree, &node)) {
+                    LOGERR(set->ctx, LY_EVALID, "Invalid instance-identifier \"%s\" value - required instance not found.",
+                            lyd_get_value(&leaf->node));
+                    return LY_EVALID;
+                }
+            }
+
+            /* insert it */
+            set_insert_node(set, node, 0, LYXP_NODE_ELEM, 0);
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+static LY_ERR
+xpath_derived_(struct lyxp_set **args, struct lyxp_set *set, uint32_t options, ly_bool self_match, const char *func)
+{
+    uint32_t i, id_len;
+    LY_ARRAY_COUNT_TYPE u;
+    struct lyd_node_term *leaf;
+    struct lysc_node_leaf *sleaf;
+    struct lyd_meta *meta;
+    struct lyd_value *val;
+    const struct lys_module *mod;
+    const char *id_name;
+    struct lysc_ident *id;
+    LY_ERR rc = LY_SUCCESS;
+    ly_bool found;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if (args[0]->type != LYXP_SET_SCNODE_SET) {
+            LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", func);
+        } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", func, lys_nodetype2str(sleaf->nodetype),
+                        sleaf->name);
+            } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_IDENT)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"identityref\".", func, sleaf->name);
+            }
+        }
+
+        if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", func, lys_nodetype2str(sleaf->nodetype),
+                        sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", func, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    if (args[0]->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "derived-from(-or-self)(node-set, string)");
+        return LY_EVALID;
+    }
+    rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+
+    /* parse the identity */
+    id_name = args[1]->val.str;
+    id_len = strlen(id_name);
+    rc = moveto_resolve_model(&id_name, &id_len, set, set->cur_node ? set->cur_node->schema : NULL, &mod);
+    LY_CHECK_RET(rc);
+    if (!mod) {
+        LOGVAL(set->ctx, LYVE_XPATH, "Identity \"%.*s\" without a prefix.", (int)id_len, id_name);
+        return LY_EVALID;
+    }
+
+    /* find the identity */
+    found = 0;
+    LY_ARRAY_FOR(mod->identities, u) {
+        if (!ly_strncmp(mod->identities[u].name, id_name, id_len)) {
+            /* we have match */
+            found = 1;
+            break;
+        }
+    }
+    if (!found) {
+        LOGVAL(set->ctx, LYVE_XPATH, "Identity \"%.*s\" not found in module \"%s\".", (int)id_len, id_name, mod->name);
+        return LY_EVALID;
+    }
+    id = &mod->identities[u];
+
+    set_fill_boolean(set, 0);
+    found = 0;
+    for (i = 0; i < args[0]->used; ++i) {
+        if ((args[0]->val.nodes[i].type != LYXP_NODE_ELEM) && (args[0]->val.nodes[i].type != LYXP_NODE_META)) {
+            continue;
+        }
+
+        if (args[0]->val.nodes[i].type == LYXP_NODE_ELEM) {
+            leaf = (struct lyd_node_term *)args[0]->val.nodes[i].node;
+            sleaf = (struct lysc_node_leaf *)leaf->schema;
+            val = &leaf->value;
+            if (!(sleaf->nodetype & LYD_NODE_TERM) || (leaf->value.realtype->basetype != LY_TYPE_IDENT)) {
+                /* uninteresting */
+                continue;
+            }
+        } else {
+            meta = args[0]->val.meta[i].meta;
+            val = &meta->value;
+            if (val->realtype->basetype != LY_TYPE_IDENT) {
+                /* uninteresting */
+                continue;
+            }
+        }
+
+        /* check the identity itself */
+        if (self_match && (id == val->ident)) {
+            set_fill_boolean(set, 1);
+            found = 1;
+        }
+        if (!found && !lyplg_type_identity_isderived(id, val->ident)) {
+            set_fill_boolean(set, 1);
+            found = 1;
+        }
+
+        if (found) {
+            break;
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the YANG 1.1 derived-from(node-set, string) function. Returns LYXP_SET_BOOLEAN depending
+ *        on whether the first argument nodes contain a node of an identity derived from the second
+ *        argument identity.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_derived_from(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    return xpath_derived_(args, set, options, 0, __func__);
+}
+
+/**
+ * @brief Execute the YANG 1.1 derived-from-or-self(node-set, string) function. Returns LYXP_SET_BOOLEAN depending
+ *        on whether the first argument nodes contain a node of an identity that either is or is derived from
+ *        the second argument identity.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_derived_from_or_self(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    return xpath_derived_(args, set, options, 1, __func__);
+}
+
+/**
+ * @brief Execute the YANG 1.1 enum-value(node-set) function. Returns LYXP_SET_NUMBER
+ *        with the integer value of the first node's enum value, otherwise NaN.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_enum_value(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    struct lyd_node_term *leaf;
+    struct lysc_node_leaf *sleaf;
+    LY_ERR rc = LY_SUCCESS;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if (args[0]->type != LYXP_SET_SCNODE_SET) {
+            LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
+        } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
+                        sleaf->name);
+            } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_ENUM)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"enumeration\".", __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    if (args[0]->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "enum-value(node-set)");
+        return LY_EVALID;
+    }
+
+    set_fill_number(set, NAN);
+    if (args[0]->used) {
+        leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
+        sleaf = (struct lysc_node_leaf *)leaf->schema;
+        if ((sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST)) && (sleaf->type->basetype == LY_TYPE_ENUM)) {
+            set_fill_number(set, leaf->value.enum_item->value);
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath false() function. Returns LYXP_SET_BOOLEAN
+ *        with false value.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_false(struct lyxp_set **UNUSED(args), uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    if (options & LYXP_SCNODE_ALL) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
+        return LY_SUCCESS;
+    }
+
+    set_fill_boolean(set, 0);
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath floor(number) function. Returns LYXP_SET_NUMBER
+ *        with the first argument floored (truncated).
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_floor(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t UNUSED(options))
+{
+    LY_ERR rc;
+
+    rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
+    LY_CHECK_RET(rc);
+    if (isfinite(args[0]->val.num)) {
+        set_fill_number(set, (long long)args[0]->val.num);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath lang(string) function. Returns LYXP_SET_BOOLEAN
+ *        whether the language of the text matches the one from the argument.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_lang(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    const struct lyd_node *node;
+    struct lysc_node_leaf *sleaf;
+    struct lyd_meta *meta = NULL;
+    const char *val;
+    LY_ERR rc = LY_SUCCESS;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
+                        sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+
+    if (set->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "lang(string)");
+        return LY_EVALID;
+    } else if (!set->used) {
+        set_fill_boolean(set, 0);
+        return LY_SUCCESS;
+    }
+
+    switch (set->val.nodes[0].type) {
+    case LYXP_NODE_ELEM:
+    case LYXP_NODE_TEXT:
+        node = set->val.nodes[0].node;
+        break;
+    case LYXP_NODE_META:
+        node = set->val.meta[0].meta->parent;
+        break;
+    default:
+        /* nothing to do with roots */
+        set_fill_boolean(set, 0);
+        return LY_SUCCESS;
+    }
+
+    /* find lang metadata */
+    for ( ; node; node = lyd_parent(node)) {
+        for (meta = node->meta; meta; meta = meta->next) {
+            /* annotations */
+            if (meta->name && !strcmp(meta->name, "lang") && !strcmp(meta->annotation->module->name, "xml")) {
+                break;
+            }
+        }
+
+        if (meta) {
+            break;
+        }
+    }
+
+    /* compare languages */
+    if (!meta) {
+        set_fill_boolean(set, 0);
+    } else {
+        uint64_t i;
+
+        val = lyd_get_meta_value(meta);
+        for (i = 0; args[0]->val.str[i]; ++i) {
+            if (tolower(args[0]->val.str[i]) != tolower(val[i])) {
+                set_fill_boolean(set, 0);
+                break;
+            }
+        }
+        if (!args[0]->val.str[i]) {
+            if (!val[i] || (val[i] == '-')) {
+                set_fill_boolean(set, 1);
+            } else {
+                set_fill_boolean(set, 0);
+            }
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath last() function. Returns LYXP_SET_NUMBER
+ *        with the context size.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_last(struct lyxp_set **UNUSED(args), uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    if (options & LYXP_SCNODE_ALL) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
+        return LY_SUCCESS;
+    }
+
+    if (set->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "last()");
+        return LY_EVALID;
+    } else if (!set->used) {
+        set_fill_number(set, 0);
+        return LY_SUCCESS;
+    }
+
+    set_fill_number(set, set->ctx_size);
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath local-name(node-set?) function. Returns LYXP_SET_STRING
+ *        with the node name without namespace from the argument or the context.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_local_name(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
+{
+    struct lyxp_set_node *item;
+
+    /* suppress unused variable warning */
+    (void)options;
+
+    if (options & LYXP_SCNODE_ALL) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
+        return LY_SUCCESS;
+    }
+
+    if (arg_count) {
+        if (args[0]->type != LYXP_SET_NODE_SET) {
+            LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]),
+                    "local-name(node-set?)");
+            return LY_EVALID;
+        } else if (!args[0]->used) {
+            set_fill_string(set, "", 0);
+            return LY_SUCCESS;
+        }
+
+        /* we need the set sorted, it affects the result */
+        assert(!set_sort(args[0]));
+
+        item = &args[0]->val.nodes[0];
+    } else {
+        if (set->type != LYXP_SET_NODE_SET) {
+            LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "local-name(node-set?)");
+            return LY_EVALID;
+        } else if (!set->used) {
+            set_fill_string(set, "", 0);
+            return LY_SUCCESS;
+        }
+
+        /* we need the set sorted, it affects the result */
+        assert(!set_sort(set));
+
+        item = &set->val.nodes[0];
+    }
+
+    switch (item->type) {
+    case LYXP_NODE_NONE:
+        LOGINT_RET(set->ctx);
+    case LYXP_NODE_ROOT:
+    case LYXP_NODE_ROOT_CONFIG:
+    case LYXP_NODE_TEXT:
+        set_fill_string(set, "", 0);
+        break;
+    case LYXP_NODE_ELEM:
+        set_fill_string(set, item->node->schema->name, strlen(item->node->schema->name));
+        break;
+    case LYXP_NODE_META:
+        set_fill_string(set, ((struct lyd_meta *)item->node)->name, strlen(((struct lyd_meta *)item->node)->name));
+        break;
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath name(node-set?) function. Returns LYXP_SET_STRING
+ *        with the node name fully qualified (with namespace) from the argument or the context.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_name(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
+{
+    struct lyxp_set_node *item;
+    struct lys_module *mod = NULL;
+    char *str;
+    const char *name = NULL;
+
+    if (options & LYXP_SCNODE_ALL) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
+        return LY_SUCCESS;
+    }
+
+    if (arg_count) {
+        if (args[0]->type != LYXP_SET_NODE_SET) {
+            LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "name(node-set?)");
+            return LY_EVALID;
+        } else if (!args[0]->used) {
+            set_fill_string(set, "", 0);
+            return LY_SUCCESS;
+        }
+
+        /* we need the set sorted, it affects the result */
+        assert(!set_sort(args[0]));
+
+        item = &args[0]->val.nodes[0];
+    } else {
+        if (set->type != LYXP_SET_NODE_SET) {
+            LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "name(node-set?)");
+            return LY_EVALID;
+        } else if (!set->used) {
+            set_fill_string(set, "", 0);
+            return LY_SUCCESS;
+        }
+
+        /* we need the set sorted, it affects the result */
+        assert(!set_sort(set));
+
+        item = &set->val.nodes[0];
+    }
+
+    switch (item->type) {
+    case LYXP_NODE_NONE:
+        LOGINT_RET(set->ctx);
+    case LYXP_NODE_ROOT:
+    case LYXP_NODE_ROOT_CONFIG:
+    case LYXP_NODE_TEXT:
+        /* keep NULL */
+        break;
+    case LYXP_NODE_ELEM:
+        mod = item->node->schema->module;
+        name = item->node->schema->name;
+        break;
+    case LYXP_NODE_META:
+        mod = ((struct lyd_meta *)item->node)->annotation->module;
+        name = ((struct lyd_meta *)item->node)->name;
+        break;
+    }
+
+    if (mod && name) {
+        int rc = asprintf(&str, "%s:%s", ly_get_prefix(mod, set->format, set->prefix_data), name);
+
+        LY_CHECK_ERR_RET(rc == -1, LOGMEM(set->ctx), LY_EMEM);
+        set_fill_string(set, str, strlen(str));
+        free(str);
+    } else {
+        set_fill_string(set, "", 0);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath namespace-uri(node-set?) function. Returns LYXP_SET_STRING
+ *        with the namespace of the node from the argument or the context.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINVAL for wrong arguments on schema)
+ */
+static LY_ERR
+xpath_namespace_uri(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
+{
+    struct lyxp_set_node *item;
+    struct lys_module *mod;
+
+    /* suppress unused variable warning */
+    (void)options;
+
+    if (options & LYXP_SCNODE_ALL) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return LY_SUCCESS;
+    }
+
+    if (arg_count) {
+        if (args[0]->type != LYXP_SET_NODE_SET) {
+            LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]),
+                    "namespace-uri(node-set?)");
+            return LY_EVALID;
+        } else if (!args[0]->used) {
+            set_fill_string(set, "", 0);
+            return LY_SUCCESS;
+        }
+
+        /* we need the set sorted, it affects the result */
+        assert(!set_sort(args[0]));
+
+        item = &args[0]->val.nodes[0];
+    } else {
+        if (set->type != LYXP_SET_NODE_SET) {
+            LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "namespace-uri(node-set?)");
+            return LY_EVALID;
+        } else if (!set->used) {
+            set_fill_string(set, "", 0);
+            return LY_SUCCESS;
+        }
+
+        /* we need the set sorted, it affects the result */
+        assert(!set_sort(set));
+
+        item = &set->val.nodes[0];
+    }
+
+    switch (item->type) {
+    case LYXP_NODE_NONE:
+        LOGINT_RET(set->ctx);
+    case LYXP_NODE_ROOT:
+    case LYXP_NODE_ROOT_CONFIG:
+    case LYXP_NODE_TEXT:
+        set_fill_string(set, "", 0);
+        break;
+    case LYXP_NODE_ELEM:
+    case LYXP_NODE_META:
+        if (item->type == LYXP_NODE_ELEM) {
+            mod = item->node->schema->module;
+        } else { /* LYXP_NODE_META */
+            /* annotations */
+            mod = ((struct lyd_meta *)item->node)->annotation->module;
+        }
+
+        set_fill_string(set, mod->ns, strlen(mod->ns));
+        break;
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath normalize-space(string?) function. Returns LYXP_SET_STRING
+ *        with normalized value (no leading, trailing, double white spaces) of the node
+ *        from the argument or the context.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_normalize_space(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
+{
+    uint32_t i, new_used;
+    char *new;
+    ly_bool have_spaces = 0, space_before = 0;
+    struct lysc_node_leaf *sleaf;
+    LY_ERR rc = LY_SUCCESS;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if (arg_count && (args[0]->type == LYXP_SET_SCNODE_SET) &&
+                (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
+                        sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    if (arg_count) {
+        set_fill_set(set, args[0]);
+    }
+    rc = lyxp_set_cast(set, LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+
+    /* is there any normalization necessary? */
+    for (i = 0; set->val.str[i]; ++i) {
+        if (is_xmlws(set->val.str[i])) {
+            if ((i == 0) || space_before || (!set->val.str[i + 1])) {
+                have_spaces = 1;
+                break;
+            }
+            space_before = 1;
+        } else {
+            space_before = 0;
+        }
+    }
+
+    /* yep, there is */
+    if (have_spaces) {
+        /* it's enough, at least one character will go, makes space for ending '\0' */
+        new = malloc(strlen(set->val.str) * sizeof(char));
+        LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
+        new_used = 0;
+
+        space_before = 0;
+        for (i = 0; set->val.str[i]; ++i) {
+            if (is_xmlws(set->val.str[i])) {
+                if ((i == 0) || space_before) {
+                    space_before = 1;
+                    continue;
+                } else {
+                    space_before = 1;
+                }
+            } else {
+                space_before = 0;
+            }
+
+            new[new_used] = (space_before ? ' ' : set->val.str[i]);
+            ++new_used;
+        }
+
+        /* at worst there is one trailing space now */
+        if (new_used && is_xmlws(new[new_used - 1])) {
+            --new_used;
+        }
+
+        new = ly_realloc(new, (new_used + 1) * sizeof(char));
+        LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
+        new[new_used] = '\0';
+
+        free(set->val.str);
+        set->val.str = new;
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath not(boolean) function. Returns LYXP_SET_BOOLEAN
+ *        with the argument converted to boolean and logically inverted.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_not(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    if (options & LYXP_SCNODE_ALL) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
+        return LY_SUCCESS;
+    }
+
+    lyxp_set_cast(args[0], LYXP_SET_BOOLEAN);
+    if (args[0]->val.bln) {
+        set_fill_boolean(set, 0);
+    } else {
+        set_fill_boolean(set, 1);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath number(object?) function. Returns LYXP_SET_NUMBER
+ *        with the number representation of either the argument or the context.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_number(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR rc;
+
+    if (options & LYXP_SCNODE_ALL) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return LY_SUCCESS;
+    }
+
+    if (arg_count) {
+        rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
+        LY_CHECK_RET(rc);
+        set_fill_set(set, args[0]);
+    } else {
+        rc = lyxp_set_cast(set, LYXP_SET_NUMBER);
+        LY_CHECK_RET(rc);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath position() function. Returns LYXP_SET_NUMBER
+ *        with the context position.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_position(struct lyxp_set **UNUSED(args), uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    if (options & LYXP_SCNODE_ALL) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
+        return LY_SUCCESS;
+    }
+
+    if (set->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "position()");
+        return LY_EVALID;
+    } else if (!set->used) {
+        set_fill_number(set, 0);
+        return LY_SUCCESS;
+    }
+
+    set_fill_number(set, set->ctx_pos);
+
+    /* UNUSED in 'Release' build type */
+    (void)options;
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the YANG 1.1 re-match(string, string) function. Returns LYXP_SET_BOOLEAN
+ *        depending on whether the second argument regex matches the first argument string. For details refer to
+ *        YANG 1.1 RFC section 10.2.1.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_re_match(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    struct lysc_pattern **patterns = NULL, **pattern;
+    struct lysc_node_leaf *sleaf;
+    LY_ERR rc = LY_SUCCESS;
+    struct ly_err_item *err;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+
+        if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+    rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+
+    LY_ARRAY_NEW_RET(set->ctx, patterns, pattern, LY_EMEM);
+    *pattern = calloc(1, sizeof **pattern);
+    LOG_LOCSET(NULL, set->cur_node, NULL, NULL);
+    rc = lys_compile_type_pattern_check(set->ctx, args[1]->val.str, &(*pattern)->code);
+    if (set->cur_node) {
+        LOG_LOCBACK(0, 1, 0, 0);
+    }
+    if (rc != LY_SUCCESS) {
+        LY_ARRAY_FREE(patterns);
+        return rc;
+    }
+
+    rc = lyplg_type_validate_patterns(patterns, args[0]->val.str, strlen(args[0]->val.str), &err);
+    pcre2_code_free((*pattern)->code);
+    free(*pattern);
+    LY_ARRAY_FREE(patterns);
+    if (rc && (rc != LY_EVALID)) {
+        ly_err_print(set->ctx, err);
+        ly_err_free(err);
+        return rc;
+    }
+
+    if (rc == LY_EVALID) {
+        ly_err_free(err);
+        set_fill_boolean(set, 0);
+    } else {
+        set_fill_boolean(set, 1);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath round(number) function. Returns LYXP_SET_NUMBER
+ *        with the rounded first argument. For details refer to
+ *        http://www.w3.org/TR/1999/REC-xpath-19991116/#function-round.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_round(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    struct lysc_node_leaf *sleaf;
+    LY_ERR rc = LY_SUCCESS;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if (args[0]->type != LYXP_SET_SCNODE_SET) {
+            LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
+        } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
+                        sleaf->name);
+            } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_DEC64)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"decimal64\".", __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
+    LY_CHECK_RET(rc);
+
+    /* cover only the cases where floor can't be used */
+    if ((args[0]->val.num == -0.0f) || ((args[0]->val.num < 0) && (args[0]->val.num >= -0.5))) {
+        set_fill_number(set, -0.0f);
+    } else {
+        args[0]->val.num += 0.5;
+        rc = xpath_floor(args, 1, args[0], options);
+        LY_CHECK_RET(rc);
+        set_fill_number(set, args[0]->val.num);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath starts-with(string, string) function.
+ *        Returns LYXP_SET_BOOLEAN whether the second argument is
+ *        the prefix of the first or not.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_starts_with(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    struct lysc_node_leaf *sleaf;
+    LY_ERR rc = LY_SUCCESS;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+
+        if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+    rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+
+    if (strncmp(args[0]->val.str, args[1]->val.str, strlen(args[1]->val.str))) {
+        set_fill_boolean(set, 0);
+    } else {
+        set_fill_boolean(set, 1);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath string(object?) function. Returns LYXP_SET_STRING
+ *        with the string representation of either the argument or the context.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_string(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR rc;
+
+    if (options & LYXP_SCNODE_ALL) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return LY_SUCCESS;
+    }
+
+    if (arg_count) {
+        rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
+        LY_CHECK_RET(rc);
+        set_fill_set(set, args[0]);
+    } else {
+        rc = lyxp_set_cast(set, LYXP_SET_STRING);
+        LY_CHECK_RET(rc);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath string-length(string?) function. Returns LYXP_SET_NUMBER
+ *        with the length of the string in either the argument or the context.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_string_length(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
+{
+    struct lysc_node_leaf *sleaf;
+    LY_ERR rc = LY_SUCCESS;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if (arg_count && (args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+        if (!arg_count && (set->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #0 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #0 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    if (arg_count) {
+        rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
+        LY_CHECK_RET(rc);
+        set_fill_number(set, strlen(args[0]->val.str));
+    } else {
+        rc = lyxp_set_cast(set, LYXP_SET_STRING);
+        LY_CHECK_RET(rc);
+        set_fill_number(set, strlen(set->val.str));
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath substring(string, number, number?) function.
+ *        Returns LYXP_SET_STRING substring of the first argument starting
+ *        on the second argument index ending on the third argument index,
+ *        indexed from 1. For exact definition refer to
+ *        http://www.w3.org/TR/1999/REC-xpath-19991116/#function-substring.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_substring(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
+{
+    int64_t start;
+    int32_t len;
+    uint32_t str_start, str_len, pos;
+    struct lysc_node_leaf *sleaf;
+    LY_ERR rc = LY_SUCCESS;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+
+        if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_numeric_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
+            }
+        }
+
+        if ((arg_count == 3) && (args[2]->type == LYXP_SET_SCNODE_SET) &&
+                (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[2]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #3 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_numeric_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #3 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+
+    /* start */
+    if (xpath_round(&args[1], 1, args[1], options)) {
+        return -1;
+    }
+    if (isfinite(args[1]->val.num)) {
+        start = args[1]->val.num - 1;
+    } else if (isinf(args[1]->val.num) && signbit(args[1]->val.num)) {
+        start = INT32_MIN;
+    } else {
+        start = INT32_MAX;
+    }
+
+    /* len */
+    if (arg_count == 3) {
+        rc = xpath_round(&args[2], 1, args[2], options);
+        LY_CHECK_RET(rc);
+        if (isnan(args[2]->val.num) || signbit(args[2]->val.num)) {
+            len = 0;
+        } else if (isfinite(args[2]->val.num)) {
+            len = args[2]->val.num;
+        } else {
+            len = INT32_MAX;
+        }
+    } else {
+        len = INT32_MAX;
+    }
+
+    /* find matching character positions */
+    str_start = 0;
+    str_len = 0;
+    for (pos = 0; args[0]->val.str[pos]; ++pos) {
+        if (pos < start) {
+            ++str_start;
+        } else if (pos < start + len) {
+            ++str_len;
+        } else {
+            break;
+        }
+    }
+
+    set_fill_string(set, args[0]->val.str + str_start, str_len);
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath substring-after(string, string) function.
+ *        Returns LYXP_SET_STRING with the string succeeding the occurance
+ *        of the second argument in the first or an empty string.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_substring_after(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    char *ptr;
+    struct lysc_node_leaf *sleaf;
+    LY_ERR rc = LY_SUCCESS;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+
+        if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+    rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+
+    ptr = strstr(args[0]->val.str, args[1]->val.str);
+    if (ptr) {
+        set_fill_string(set, ptr + strlen(args[1]->val.str), strlen(ptr + strlen(args[1]->val.str)));
+    } else {
+        set_fill_string(set, "", 0);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath substring-before(string, string) function.
+ *        Returns LYXP_SET_STRING with the string preceding the occurance
+ *        of the second argument in the first or an empty string.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_substring_before(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    char *ptr;
+    struct lysc_node_leaf *sleaf;
+    LY_ERR rc = LY_SUCCESS;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+
+        if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+    rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+
+    ptr = strstr(args[0]->val.str, args[1]->val.str);
+    if (ptr) {
+        set_fill_string(set, args[0]->val.str, ptr - args[0]->val.str);
+    } else {
+        set_fill_string(set, "", 0);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath sum(node-set) function. Returns LYXP_SET_NUMBER
+ *        with the sum of all the nodes in the context.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_sum(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    long double num;
+    char *str;
+    uint32_t i;
+    struct lyxp_set set_item;
+    struct lysc_node_leaf *sleaf;
+    LY_ERR rc = LY_SUCCESS;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if (args[0]->type == LYXP_SET_SCNODE_SET) {
+            for (i = 0; i < args[0]->used; ++i) {
+                if (args[0]->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
+                    sleaf = (struct lysc_node_leaf *)args[0]->val.scnodes[i].scnode;
+                    if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                        LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__,
+                                lys_nodetype2str(sleaf->nodetype), sleaf->name);
+                    } else if (!warn_is_numeric_type(sleaf->type)) {
+                        LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
+                    }
+                }
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    set_fill_number(set, 0);
+
+    if (args[0]->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "sum(node-set)");
+        return LY_EVALID;
+    } else if (!args[0]->used) {
+        return LY_SUCCESS;
+    }
+
+    set_init(&set_item, set);
+
+    set_item.type = LYXP_SET_NODE_SET;
+    set_item.val.nodes = calloc(1, sizeof *set_item.val.nodes);
+    LY_CHECK_ERR_RET(!set_item.val.nodes, LOGMEM(set->ctx), LY_EMEM);
+
+    set_item.used = 1;
+    set_item.size = 1;
+
+    for (i = 0; i < args[0]->used; ++i) {
+        set_item.val.nodes[0] = args[0]->val.nodes[i];
+
+        rc = cast_node_set_to_string(&set_item, &str);
+        LY_CHECK_RET(rc);
+        num = cast_string_to_number(str);
+        free(str);
+        set->val.num += num;
+    }
+
+    free(set_item.val.nodes);
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath translate(string, string, string) function.
+ *        Returns LYXP_SET_STRING with the first argument with the characters
+ *        from the second argument replaced by those on the corresponding
+ *        positions in the third argument.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_translate(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    uint32_t i, j, new_used;
+    char *new;
+    ly_bool have_removed;
+    struct lysc_node_leaf *sleaf;
+    LY_ERR rc = LY_SUCCESS;
+
+    if (options & LYXP_SCNODE_ALL) {
+        if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+
+        if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+
+        if ((args[2]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[2]))) {
+            if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
+                LOGWRN(set->ctx, "Argument #3 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
+            } else if (!warn_is_string_type(sleaf->type)) {
+                LOGWRN(set->ctx, "Argument #3 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
+            }
+        }
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return rc;
+    }
+
+    rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+    rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+    rc = lyxp_set_cast(args[2], LYXP_SET_STRING);
+    LY_CHECK_RET(rc);
+
+    new = malloc((strlen(args[0]->val.str) + 1) * sizeof(char));
+    LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
+    new_used = 0;
+
+    have_removed = 0;
+    for (i = 0; args[0]->val.str[i]; ++i) {
+        ly_bool found = 0;
+
+        for (j = 0; args[1]->val.str[j]; ++j) {
+            if (args[0]->val.str[i] == args[1]->val.str[j]) {
+                /* removing this char */
+                if (j >= strlen(args[2]->val.str)) {
+                    have_removed = 1;
+                    found = 1;
+                    break;
+                }
+                /* replacing this char */
+                new[new_used] = args[2]->val.str[j];
+                ++new_used;
+                found = 1;
+                break;
+            }
+        }
+
+        /* copying this char */
+        if (!found) {
+            new[new_used] = args[0]->val.str[i];
+            ++new_used;
+        }
+    }
+
+    if (have_removed) {
+        new = ly_realloc(new, (new_used + 1) * sizeof(char));
+        LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
+    }
+    new[new_used] = '\0';
+
+    lyxp_set_free_content(set);
+    set->type = LYXP_SET_STRING;
+    set->val.str = new;
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath true() function. Returns LYXP_SET_BOOLEAN
+ *        with true value.
+ *
+ * @param[in] args Array of arguments.
+ * @param[in] arg_count Count of elements in @p args.
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_true(struct lyxp_set **UNUSED(args), uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
+{
+    if (options & LYXP_SCNODE_ALL) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
+        return LY_SUCCESS;
+    }
+
+    set_fill_boolean(set, 1);
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Execute the XPath node() processing instruction (node type). Returns LYXP_SET_NODE_SET
+ *        with only nodes from the context.
+ *
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] axis Axis to search on.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_pi_node(struct lyxp_set *set, enum lyxp_axis axis, uint32_t options)
+{
+    if (options & LYXP_SCNODE_ALL) {
+        return moveto_scnode(set, NULL, NULL, axis, options);
+    }
+
+    if (set->type != LYXP_SET_NODE_SET) {
+        lyxp_set_free_content(set);
+        return LY_SUCCESS;
+    }
+
+    /* just like moving to a node with no restrictions */
+    return moveto_node(set, NULL, NULL, axis, options);
+}
+
+/**
+ * @brief Execute the XPath text() processing instruction (node type). Returns LYXP_SET_NODE_SET
+ *        with the text content of the nodes in the context.
+ *
+ * @param[in,out] set Context and result set at the same time.
+ * @param[in] axis Axis to search on.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+xpath_pi_text(struct lyxp_set *set, enum lyxp_axis axis, uint32_t options)
+{
+    uint32_t i;
+
+    if (options & LYXP_SCNODE_ALL) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        return LY_SUCCESS;
+    }
+
+    if (set->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "text()");
+        return LY_EVALID;
+    }
+
+    if (axis != LYXP_AXIS_CHILD) {
+        /* even following and preceding axescan return text nodes, but whatever */
+        lyxp_set_free_content(set);
+        return LY_SUCCESS;
+    }
+
+    for (i = 0; i < set->used; ++i) {
+        switch (set->val.nodes[i].type) {
+        case LYXP_NODE_NONE:
+            LOGINT_RET(set->ctx);
+        case LYXP_NODE_ELEM:
+            if (set->val.nodes[i].node->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
+                set->val.nodes[i].type = LYXP_NODE_TEXT;
+                break;
+            }
+        /* fall through */
+        case LYXP_NODE_ROOT:
+        case LYXP_NODE_ROOT_CONFIG:
+        case LYXP_NODE_TEXT:
+        case LYXP_NODE_META:
+            set_remove_node_none(set, i);
+            break;
+        }
+    }
+    set_remove_nodes_none(set);
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Skip prefix and return corresponding model if there is a prefix. Logs directly.
+ *
+ * XPath @p set is expected to be a (sc)node set!
+ *
+ * @param[in,out] qname Qualified node name. If includes prefix, it is skipped.
+ * @param[in,out] qname_len Length of @p qname, is updated accordingly.
+ * @param[in] set Set with general XPath context.
+ * @param[in] ctx_scnode Context node to inherit module for unprefixed node for ::LY_PREF_JSON.
+ * @param[out] moveto_mod Expected module of a matching node.
+ * @return LY_ERR
+ */
+static LY_ERR
+moveto_resolve_model(const char **qname, uint32_t *qname_len, const struct lyxp_set *set,
+        const struct lysc_node *ctx_scnode, const struct lys_module **moveto_mod)
+{
+    const struct lys_module *mod = NULL;
+    const char *ptr;
+    size_t pref_len;
+
+    assert((set->type == LYXP_SET_NODE_SET) || (set->type == LYXP_SET_SCNODE_SET));
+
+    if ((ptr = ly_strnchr(*qname, ':', *qname_len))) {
+        /* specific module */
+        pref_len = ptr - *qname;
+        mod = ly_resolve_prefix(set->ctx, *qname, pref_len, set->format, set->prefix_data);
+
+        /* check for errors and non-implemented modules, as they are not valid */
+        if (!mod || !mod->implemented) {
+            LOGVAL(set->ctx, LY_VCODE_XP_INMOD, pref_len, *qname);
+            return LY_EVALID;
+        }
+
+        *qname += pref_len + 1;
+        *qname_len -= pref_len + 1;
+    } else if (((*qname)[0] == '*') && (*qname_len == 1)) {
+        /* all modules - special case */
+        mod = NULL;
+    } else {
+        switch (set->format) {
+        case LY_VALUE_SCHEMA:
+        case LY_VALUE_SCHEMA_RESOLVED:
+            /* current module */
+            mod = set->cur_mod;
+            break;
+        case LY_VALUE_CANON:
+        case LY_VALUE_JSON:
+        case LY_VALUE_LYB:
+        case LY_VALUE_STR_NS:
+            /* inherit parent (context node) module */
+            if (ctx_scnode) {
+                mod = ctx_scnode->module;
+            } else {
+                mod = NULL;
+            }
+            break;
+        case LY_VALUE_XML:
+            /* all nodes need to be prefixed */
+            LOGVAL(set->ctx, LYVE_DATA, "Non-prefixed node \"%.*s\" in XML xpath found.", *qname_len, *qname);
+            return LY_EVALID;
+        }
+    }
+
+    *moveto_mod = mod;
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Move context @p set to the root. Handles absolute path.
+ *        Result is LYXP_SET_NODE_SET.
+ *
+ * @param[in,out] set Set to use.
+ * @param[in] options Xpath options.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+moveto_root(struct lyxp_set *set, uint32_t options)
+{
+    assert(!(options & LYXP_SKIP_EXPR));
+
+    if (options & LYXP_SCNODE_ALL) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
+        LY_CHECK_RET(set_scnode_insert_node(set, NULL, set->root_type, LYXP_AXIS_SELF, NULL));
+    } else {
+        set->type = LYXP_SET_NODE_SET;
+        set->used = 0;
+        set_insert_node(set, NULL, 0, set->root_type, 0);
+        set->non_child_axis = 0;
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Check @p node as a part of NameTest processing.
+ *
+ * @param[in] node Node to check.
+ * @param[in] node_type Node type of @p node.
+ * @param[in] set Set to read general context from.
+ * @param[in] node_name Node name in the dictionary to move to, NULL for any node.
+ * @param[in] moveto_mod Expected module of the node, NULL for no prefix.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_ENOT if node does not match, LY_EINCOMPLETE on unresolved when,
+ * LY_EINVAL if neither node nor any children match)
+ */
+static LY_ERR
+moveto_node_check(const struct lyd_node *node, enum lyxp_node_type node_type, const struct lyxp_set *set,
+        const char *node_name, const struct lys_module *moveto_mod, uint32_t options)
+{
+    if ((node_type == LYXP_NODE_ROOT_CONFIG) || (node_type == LYXP_NODE_ROOT)) {
+        assert(node_type == set->root_type);
+
+        if (node_name || moveto_mod) {
+            /* root will not match a specific node */
+            return LY_ENOT;
+        }
+        return LY_SUCCESS;
+    } else if (node_type != LYXP_NODE_ELEM) {
+        /* other types will not match */
+        return LY_ENOT;
+    }
+
+    if (!node->schema) {
+        /* opaque node never matches */
+        return LY_ENOT;
+    }
+
+    /* module check */
+    if (moveto_mod) {
+        if ((set->ctx == LYD_CTX(node)) && (node->schema->module != moveto_mod)) {
+            return LY_ENOT;
+        } else if ((set->ctx != LYD_CTX(node)) && strcmp(node->schema->module->name, moveto_mod->name)) {
+            return LY_ENOT;
+        }
+    }
+
+    /* context check */
+    if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (node->schema->flags & LYS_CONFIG_R)) {
+        return LY_EINVAL;
+    } else if (set->context_op && (node->schema->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) &&
+            (node->schema != set->context_op)) {
+        return LY_EINVAL;
+    }
+
+    /* name check */
+    if (node_name) {
+        if ((set->ctx == LYD_CTX(node)) && (node->schema->name != node_name)) {
+            return LY_ENOT;
+        } else if ((set->ctx != LYD_CTX(node)) && strcmp(node->schema->name, node_name)) {
+            return LY_ENOT;
+        }
+    }
+
+    /* when check, accept the context node because it should only be the path ".", we have checked the when is valid before */
+    if (!(options & LYXP_IGNORE_WHEN) && lysc_has_when(node->schema) && !(node->flags & LYD_WHEN_TRUE) &&
+            (node != set->cur_node)) {
+        return LY_EINCOMPLETE;
+    }
+
+    /* match */
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Get the next node in a forward DFS.
+ *
+ * @param[in] iter Last returned node.
+ * @param[in] stop Node to stop the search on and not return.
+ * @return Next node, NULL if there are no more.
+ */
+static const struct lyd_node *
+moveto_axis_node_next_dfs_forward(const struct lyd_node *iter, const struct lyd_node *stop)
+{
+    const struct lyd_node *next = NULL;
+
+    /* 1) child */
+    next = lyd_child(iter);
+    if (!next) {
+        if (iter == stop) {
+            /* reached stop, no more descendants */
+            return NULL;
+        }
+        /* 2) child next sibling */
+        next = iter->next;
+    }
+    while (!next) {
+        iter = lyd_parent(iter);
+        if ((!stop && !iter) || (stop && (lyd_parent(iter) == lyd_parent(stop)))) {
+            return NULL;
+        }
+        next = iter->next;
+    }
+
+    return next;
+}
+
+/**
+ * @brief Get the next node in a backward DFS.
+ *
+ * @param[in] iter Last returned node.
+ * @param[in] stop Node to stop the search on and not return.
+ * @return Next node, NULL if there are no more.
+ */
+static const struct lyd_node *
+moveto_axis_node_next_dfs_backward(const struct lyd_node *iter, const struct lyd_node *stop)
+{
+    const struct lyd_node *next = NULL;
+
+    /* 1) previous sibling innermost last child */
+    next = iter->prev->next ? iter->prev : NULL;
+    while (next && lyd_child(next)) {
+        next = lyd_child(next);
+        next = next->prev;
+    }
+
+    if (!next) {
+        /* 2) parent */
+        iter = lyd_parent(iter);
+        if ((!stop && !iter) || (stop && (lyd_parent(iter) == lyd_parent(stop)))) {
+            return NULL;
+        }
+        next = iter;
+    }
+
+    return next;
+}
+
+/**
+ * @brief Get the first node on an axis for a context node.
+ *
+ * @param[in,out] iter NULL, updated to the next node.
+ * @param[in,out] iter_type Node type 0 of @p iter, updated to the node type of the next node.
+ * @param[in] node Context node.
+ * @param[in] node_type Type of @p node.
+ * @param[in] axis Axis to use.
+ * @param[in] set XPath set with the general context.
+ * @return LY_SUCCESS on success.
+ * @return LY_ENOTFOUND if no next node found.
+ */
+static LY_ERR
+moveto_axis_node_next_first(const struct lyd_node **iter, enum lyxp_node_type *iter_type, const struct lyd_node *node,
+        enum lyxp_node_type node_type, enum lyxp_axis axis, struct lyxp_set *set)
+{
+    const struct lyd_node *next = NULL;
+    enum lyxp_node_type next_type = 0;
+
+    assert(!*iter);
+    assert(!*iter_type);
+
+    switch (axis) {
+    case LYXP_AXIS_ANCESTOR_OR_SELF:
+    case LYXP_AXIS_DESCENDANT_OR_SELF:
+    case LYXP_AXIS_SELF:
+        /* return the context node */
+        next = node;
+        next_type = node_type;
+        break;
+
+    case LYXP_AXIS_ANCESTOR:
+    case LYXP_AXIS_PARENT:
+        if (node_type == LYXP_NODE_ELEM) {
+            next = lyd_parent(node);
+            next_type = next ? LYXP_NODE_ELEM : set->root_type;
+        } else if (node_type == LYXP_NODE_TEXT) {
+            next = node;
+            next_type = LYXP_NODE_ELEM;
+        } else if (node_type == LYXP_NODE_META) {
+            next = ((struct lyd_meta *)node)->parent;
+            next_type = LYXP_NODE_ELEM;
+        } /* else root does not have a parent */
+        break;
+
+    case LYXP_AXIS_CHILD:
+        if ((node_type == LYXP_NODE_ROOT_CONFIG) || (node_type == LYXP_NODE_ROOT)) {
+            assert(!node);
+
+            /* search in all the trees */
+            next = set->tree;
+            next_type = next ? LYXP_NODE_ELEM : 0;
+        } else {
+            /* search in children */
+            next = lyd_child(node);
+            next_type = next ? LYXP_NODE_ELEM : 0;
+        }
+        break;
+
+    case LYXP_AXIS_DESCENDANT:
+        if ((node_type == LYXP_NODE_ROOT_CONFIG) || (node_type == LYXP_NODE_ROOT)) {
+            /* top-level nodes */
+            next = set->tree;
+            next_type = LYXP_NODE_ELEM;
+        } else if (node_type == LYXP_NODE_ELEM) {
+            /* start from the context node */
+            next = moveto_axis_node_next_dfs_forward(node, node);
+            next_type = next ? LYXP_NODE_ELEM : 0;
+        } /* else no children */
+        break;
+
+    case LYXP_AXIS_FOLLOWING:
+    case LYXP_AXIS_FOLLOWING_SIBLING:
+        if (node_type == LYXP_NODE_ELEM) {
+            /* first next sibling */
+            next = node->next;
+            next_type = next ? LYXP_NODE_ELEM : 0;
+        } /* else no sibling */
+        break;
+
+    case LYXP_AXIS_PRECEDING:
+        if ((node_type == LYXP_NODE_ELEM) && node->prev->next) {
+            /* skip ancestors */
+            next = moveto_axis_node_next_dfs_backward(node, NULL);
+            assert(next);
+            next_type = LYXP_NODE_ELEM;
+        } /* else no sibling */
+        break;
+
+    case LYXP_AXIS_PRECEDING_SIBLING:
+        if (node_type == LYXP_NODE_ELEM) {
+            /* first previous sibling */
+            next = node->prev->next ? node->prev : NULL;
+            next_type = next ? LYXP_NODE_ELEM : 0;
+        } /* else no sibling */
+        break;
+
+    case LYXP_AXIS_ATTRIBUTE:
+        /* handled specially */
+        assert(0);
+        LOGINT(set->ctx);
+        break;
+    }
+
+    *iter = next;
+    *iter_type = next_type;
+    return next_type ? LY_SUCCESS : LY_ENOTFOUND;
+}
+
+/**
+ * @brief Iterate over all nodes on an axis for a context node.
+ *
+ * @param[in,out] iter Last returned node, start with NULL, updated to the next node.
+ * @param[in,out] iter_type Node type of @p iter, start with 0, updated to the node type of the next node.
+ * @param[in] node Context node.
+ * @param[in] node_type Type of @p node.
+ * @param[in] axis Axis to use.
+ * @param[in] set XPath set with the general context.
+ * @return LY_SUCCESS on success.
+ * @return LY_ENOTFOUND if no next node found.
+ */
+static LY_ERR
+moveto_axis_node_next(const struct lyd_node **iter, enum lyxp_node_type *iter_type, const struct lyd_node *node,
+        enum lyxp_node_type node_type, enum lyxp_axis axis, struct lyxp_set *set)
+{
+    const struct lyd_node *next = NULL;
+    enum lyxp_node_type next_type = 0;
+
+    if (!*iter_type) {
+        /* first returned node */
+        return moveto_axis_node_next_first(iter, iter_type, node, node_type, axis, set);
+    }
+
+    switch (axis) {
+    case LYXP_AXIS_ANCESTOR_OR_SELF:
+        if ((*iter == node) && (*iter_type == node_type)) {
+            /* fake first ancestor, we returned self before */
+            *iter = NULL;
+            *iter_type = 0;
+            return moveto_axis_node_next_first(iter, iter_type, node, node_type, LYXP_AXIS_ANCESTOR, set);
+        } /* else continue ancestor */
+
+    /* fallthrough */
+    case LYXP_AXIS_ANCESTOR:
+        if (*iter_type == LYXP_NODE_ELEM) {
+            /* iter parent */
+            next = lyd_parent(*iter);
+            next_type = next ? LYXP_NODE_ELEM : set->root_type;
+        } /* else root, no ancestors */
+        break;
+
+    case LYXP_AXIS_CHILD:
+        assert(*iter_type == LYXP_NODE_ELEM);
+
+        /* next sibling (child) */
+        next = (*iter)->next;
+        next_type = next ? LYXP_NODE_ELEM : 0;
+        break;
+
+    case LYXP_AXIS_DESCENDANT_OR_SELF:
+        if ((*iter == node) && (*iter_type == node_type)) {
+            /* fake first descendant, we returned self before */
+            *iter = NULL;
+            *iter_type = 0;
+            return moveto_axis_node_next_first(iter, iter_type, node, node_type, LYXP_AXIS_DESCENDANT, set);
+        } /* else continue descendant */
+
+    /* fallthrough */
+    case LYXP_AXIS_DESCENDANT:
+        assert(*iter_type == LYXP_NODE_ELEM);
+        next = moveto_axis_node_next_dfs_forward(*iter, node);
+        next_type = next ? LYXP_NODE_ELEM : 0;
+        break;
+
+    case LYXP_AXIS_FOLLOWING:
+        assert(*iter_type == LYXP_NODE_ELEM);
+        next = moveto_axis_node_next_dfs_forward(*iter, NULL);
+        next_type = next ? LYXP_NODE_ELEM : 0;
+        break;
+
+    case LYXP_AXIS_FOLLOWING_SIBLING:
+        assert(*iter_type == LYXP_NODE_ELEM);
+
+        /* next sibling */
+        next = (*iter)->next;
+        next_type = next ? LYXP_NODE_ELEM : 0;
+        break;
+
+    case LYXP_AXIS_PARENT:
+    case LYXP_AXIS_SELF:
+        /* parent/self was returned before */
+        break;
+
+    case LYXP_AXIS_PRECEDING:
+        assert(*iter_type == LYXP_NODE_ELEM);
+        next = moveto_axis_node_next_dfs_backward(*iter, NULL);
+        next_type = next ? LYXP_NODE_ELEM : 0;
+        break;
+
+    case LYXP_AXIS_PRECEDING_SIBLING:
+        assert(*iter_type == LYXP_NODE_ELEM);
+
+        /* previous sibling */
+        next = (*iter)->prev->next ? (*iter)->prev : NULL;
+        next_type = next ? LYXP_NODE_ELEM : 0;
+        break;
+
+    case LYXP_AXIS_ATTRIBUTE:
+        /* handled specially */
+        assert(0);
+        LOGINT(set->ctx);
+        break;
+    }
+
+    *iter = next;
+    *iter_type = next_type;
+    return next_type ? LY_SUCCESS : LY_ENOTFOUND;
+}
+
+/**
+ * @brief Move context @p set to a node. Result is LYXP_SET_NODE_SET. Context position aware.
+ *
+ * @param[in,out] set Set to use.
+ * @param[in] moveto_mod Matching node module, NULL for no prefix.
+ * @param[in] ncname Matching node name in the dictionary, NULL for any.
+ * @param[in] axis Axis to search on.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+moveto_node(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, enum lyxp_axis axis,
+        uint32_t options)
+{
+    LY_ERR r, rc = LY_SUCCESS;
+    const struct lyd_node *iter;
+    enum lyxp_node_type iter_type;
+    struct lyxp_set result;
+    uint32_t i;
+
+    if (options & LYXP_SKIP_EXPR) {
+        return LY_SUCCESS;
+    }
+
+    if (set->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
+        return LY_EVALID;
+    }
+
+    /* init result set */
+    set_init(&result, set);
+
+    for (i = 0; i < set->used; ++i) {
+        /* iterate over all the nodes on the axis of the node */
+        iter = NULL;
+        iter_type = 0;
+        while (!moveto_axis_node_next(&iter, &iter_type, set->val.nodes[i].node, set->val.nodes[i].type, axis, set)) {
+            r = moveto_node_check(iter, iter_type, set, ncname, moveto_mod, options);
+            if (r == LY_EINCOMPLETE) {
+                rc = r;
+                goto cleanup;
+            } else if (r) {
+                continue;
+            }
+
+            /* check for duplicates if they are possible */
+            switch (axis) {
+            case LYXP_AXIS_ANCESTOR:
+            case LYXP_AXIS_ANCESTOR_OR_SELF:
+            case LYXP_AXIS_DESCENDANT:
+            case LYXP_AXIS_DESCENDANT_OR_SELF:
+            case LYXP_AXIS_FOLLOWING:
+            case LYXP_AXIS_FOLLOWING_SIBLING:
+            case LYXP_AXIS_PARENT:
+            case LYXP_AXIS_PRECEDING:
+            case LYXP_AXIS_PRECEDING_SIBLING:
+                result.non_child_axis = 1;
+                if (set_dup_node_check(&result, iter, iter_type, -1)) {
+                    continue;
+                }
+                break;
+            case LYXP_AXIS_CHILD:
+            case LYXP_AXIS_SELF:
+                break;
+            case LYXP_AXIS_ATTRIBUTE:
+                /* handled specially */
+                assert(0);
+                LOGINT(set->ctx);
+                break;
+            }
+
+            /* matching node */
+            set_insert_node(&result, iter, 0, iter_type, result.used);
+        }
+    }
+
+    /* move result to the set */
+    lyxp_set_free_content(set);
+    *set = result;
+    result.type = LYXP_SET_NUMBER;
+
+    /* sort the final set if the document order could have been broken */
+    if (set->non_child_axis) {
+        set_sort(set);
+    } else {
+        assert(!set_sort(set));
+    }
+
+cleanup:
+    lyxp_set_free_content(&result);
+    return rc;
+}
+
+/**
+ * @brief Move context @p set to child nodes using hashes. Result is LYXP_SET_NODE_SET. Context position aware.
+ *
+ * @param[in,out] set Set to use.
+ * @param[in] scnode Matching node schema.
+ * @param[in] predicates If @p scnode is ::LYS_LIST or ::LYS_LEAFLIST, the predicates specifying a single instance.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+moveto_node_hash_child(struct lyxp_set *set, const struct lysc_node *scnode, const struct ly_path_predicate *predicates,
+        uint32_t options)
+{
+    LY_ERR ret = LY_SUCCESS, r;
+    uint32_t i;
+    const struct lyd_node *siblings;
+    struct lyxp_set result;
+    struct lyd_node *sub, *inst = NULL;
+
+    assert(scnode && (!(scnode->nodetype & (LYS_LIST | LYS_LEAFLIST)) || predicates));
+
+    /* init result set */
+    set_init(&result, set);
+
+    if (options & LYXP_SKIP_EXPR) {
+        goto cleanup;
+    }
+
+    if (set->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
+        ret = LY_EVALID;
+        goto cleanup;
+    }
+
+    /* context check for all the nodes since we have the schema node */
+    if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (scnode->flags & LYS_CONFIG_R)) {
+        lyxp_set_free_content(set);
+        goto cleanup;
+    } else if (set->context_op && (scnode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) &&
+            (scnode != set->context_op)) {
+        lyxp_set_free_content(set);
+        goto cleanup;
+    }
+
+    /* create specific data instance if needed */
+    if (scnode->nodetype == LYS_LIST) {
+        LY_CHECK_GOTO(ret = lyd_create_list(scnode, predicates, &inst), cleanup);
+    } else if (scnode->nodetype == LYS_LEAFLIST) {
+        LY_CHECK_GOTO(ret = lyd_create_term2(scnode, &predicates[0].value, &inst), cleanup);
+    }
+
+    for (i = 0; i < set->used; ++i) {
+        siblings = NULL;
+
+        if ((set->val.nodes[i].type == LYXP_NODE_ROOT_CONFIG) || (set->val.nodes[i].type == LYXP_NODE_ROOT)) {
+            assert(!set->val.nodes[i].node);
+
+            /* search in all the trees */
+            siblings = set->tree;
+        } else if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
+            /* search in children */
+            siblings = lyd_child(set->val.nodes[i].node);
+        }
+
+        /* find the node using hashes */
+        if (inst) {
+            r = lyd_find_sibling_first(siblings, inst, &sub);
+        } else {
+            r = lyd_find_sibling_val(siblings, scnode, NULL, 0, &sub);
+        }
+        LY_CHECK_ERR_GOTO(r && (r != LY_ENOTFOUND), ret = r, cleanup);
+
+        /* when check */
+        if (!(options & LYXP_IGNORE_WHEN) && sub && lysc_has_when(sub->schema) && !(sub->flags & LYD_WHEN_TRUE)) {
+            ret = LY_EINCOMPLETE;
+            goto cleanup;
+        }
+
+        if (sub) {
+            /* pos filled later */
+            set_insert_node(&result, sub, 0, LYXP_NODE_ELEM, result.used);
+        }
+    }
+
+    /* move result to the set */
+    lyxp_set_free_content(set);
+    *set = result;
+    result.type = LYXP_SET_NUMBER;
+    assert(!set_sort(set));
+
+cleanup:
+    lyxp_set_free_content(&result);
+    lyd_free_tree(inst);
+    return ret;
+}
+
+/**
+ * @brief Check @p node as a part of schema NameTest processing.
+ *
+ * @param[in] node Schema node to check.
+ * @param[in] ctx_scnode Context node.
+ * @param[in] set Set to read general context from.
+ * @param[in] node_name Node name in the dictionary to move to, NULL for any nodes.
+ * @param[in] moveto_mod Expected module of the node, NULL for no prefix.
+ * @return LY_ERR (LY_ENOT if node does not match, LY_EINVAL if neither node nor any children match)
+ */
+static LY_ERR
+moveto_scnode_check(const struct lysc_node *node, const struct lysc_node *ctx_scnode, const struct lyxp_set *set,
+        const char *node_name, const struct lys_module *moveto_mod)
+{
+    if (!moveto_mod && node_name) {
+        switch (set->format) {
+        case LY_VALUE_SCHEMA:
+        case LY_VALUE_SCHEMA_RESOLVED:
+            /* use current module */
+            moveto_mod = set->cur_mod;
+            break;
+        case LY_VALUE_JSON:
+        case LY_VALUE_LYB:
+        case LY_VALUE_STR_NS:
+            /* inherit module of the context node, if any */
+            if (ctx_scnode) {
+                moveto_mod = ctx_scnode->module;
+            }
+            break;
+        case LY_VALUE_CANON:
+        case LY_VALUE_XML:
+            /* not defined */
+            LOGINT(set->ctx);
+            return LY_EINVAL;
+        }
+    }
+
+    if (!node) {
+        /* root will not match a specific node */
+        if (node_name || moveto_mod) {
+            return LY_ENOT;
+        }
+        return LY_SUCCESS;
+    }
+
+    /* module check */
+    if (moveto_mod && (node->module != moveto_mod)) {
+        return LY_ENOT;
+    }
+
+    /* context check */
+    if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (node->flags & LYS_CONFIG_R)) {
+        return LY_EINVAL;
+    } else if (set->context_op && (node->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) && (node != set->context_op)) {
+        return LY_EINVAL;
+    }
+
+    /* name check */
+    if (node_name && (node->name != node_name)) {
+        return LY_ENOT;
+    }
+
+    /* match */
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Get the next node in a forward schema node DFS.
+ *
+ * @param[in] iter Last returned node.
+ * @param[in] stop Node to stop the search on and not return.
+ * @param[in] getnext_opts Options for ::lys_getnext().
+ * @return Next node, NULL if there are no more.
+ */
+static const struct lysc_node *
+moveto_axis_scnode_next_dfs_forward(const struct lysc_node *iter, const struct lysc_node *stop, uint32_t getnext_opts)
+{
+    const struct lysc_node *next = NULL;
+
+    next = lysc_node_child(iter);
+    if (!next) {
+        /* no children, try siblings */
+        if ((iter == stop) || !lysc_data_parent(iter)) {
+            /* we are done, no next element to process */
+            return NULL;
+        }
+
+        next = lys_getnext(iter, lysc_data_parent(iter), NULL, getnext_opts);
+    }
+    while (!next && iter) {
+        /* parent is already processed, go to its sibling */
+        iter = iter->parent;
+        if ((iter == stop) || !lysc_data_parent(iter)) {
+            /* we are done, no next element to process */
+            return NULL;
+        }
+        next = lys_getnext(iter, lysc_data_parent(iter), NULL, getnext_opts);
+    }
+
+    return next;
+}
+
+/**
+ * @brief Consider schema node based on its in_ctx enum value.
+ *
+ * @param[in,out] in_ctx In_ctx enum of the schema node, may be updated.
+ * @param[in] axis Axis to use.
+ * @return LY_SUCCESS on success.
+ * @return LY_ENOT if the node should not be returned.
+ */
+static LY_ERR
+moveto_axis_scnode_next_in_ctx(int32_t *in_ctx, enum lyxp_axis axis)
+{
+    switch (axis) {
+    case LYXP_AXIS_SELF:
+        if ((*in_ctx == LYXP_SET_SCNODE_START) || (*in_ctx == LYXP_SET_SCNODE_ATOM_CTX)) {
+            /* additionally put the start node into context */
+            *in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
+            return LY_SUCCESS;
+        }
+        break;
+    case LYXP_AXIS_PARENT:
+    case LYXP_AXIS_ANCESTOR_OR_SELF:
+    case LYXP_AXIS_ANCESTOR:
+    case LYXP_AXIS_DESCENDANT_OR_SELF:
+    case LYXP_AXIS_DESCENDANT:
+    case LYXP_AXIS_FOLLOWING:
+    case LYXP_AXIS_FOLLOWING_SIBLING:
+    case LYXP_AXIS_PRECEDING:
+    case LYXP_AXIS_PRECEDING_SIBLING:
+    case LYXP_AXIS_CHILD:
+        if (*in_ctx == LYXP_SET_SCNODE_START) {
+            /* remember that context node was used */
+            *in_ctx = LYXP_SET_SCNODE_START_USED;
+            return LY_SUCCESS;
+        } else if (*in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
+            /* traversed */
+            *in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
+            return LY_SUCCESS;
+        }
+        break;
+    case LYXP_AXIS_ATTRIBUTE:
+        /* unreachable */
+        assert(0);
+        LOGINT(NULL);
+        break;
+    }
+
+    return LY_ENOT;
+}
+
+/**
+ * @brief Get previous sibling for a schema node.
+ *
+ * @param[in] scnode Schema node.
+ * @param[in] getnext_opts Options for ::lys_getnext().
+ * @return Previous sibling, NULL if none.
+ */
+static const struct lysc_node *
+moveto_axis_scnode_preceding_sibling(const struct lysc_node *scnode, uint32_t getnext_opts)
+{
+    const struct lysc_node *next = NULL, *prev = NULL;
+
+    while ((next = lys_getnext(next, lysc_data_parent(scnode), scnode->module->compiled, getnext_opts))) {
+        if (next == scnode) {
+            break;
+        }
+
+        prev = next;
+    }
+
+    return prev;
+}
+
+/**
+ * @brief Get the first schema node on an axis for a context node.
+ *
+ * @param[in,out] iter Last returned node, start with NULL, updated to the next node.
+ * @param[in,out] iter_type Node type of @p iter, start with 0, updated to the node type of the next node.
+ * @param[in,out] iter_mod Internal module iterator, do not change.
+ * @param[in,out] iter_mod_idx Internal module index iterator, do not change.
+ * @param[in] scnode Context node.
+ * @param[in] node_type Type of @p scnode.
+ * @param[in] in_ctx In_ctx enum of @p scnode.
+ * @param[in] axis Axis to use.
+ * @param[in] set XPath set with the general context.
+ * @param[in] getnext_opts Options for ::lys_getnext().
+ * @return LY_SUCCESS on success.
+ * @return LY_ENOTFOUND if no next node found.
+ */
+static LY_ERR
+moveto_axis_scnode_next_first(const struct lysc_node **iter, enum lyxp_node_type *iter_type, const struct lys_module **iter_mod,
+        uint32_t *iter_mod_idx, const struct lysc_node *scnode, enum lyxp_node_type node_type, enum lyxp_axis axis,
+        struct lyxp_set *set, uint32_t getnext_opts)
+{
+    const struct lysc_node *next = NULL;
+    enum lyxp_node_type next_type = 0;
+
+    assert(!*iter);
+    assert(!*iter_type);
+
+    *iter_mod = NULL;
+    *iter_mod_idx = 0;
+
+    switch (axis) {
+    case LYXP_AXIS_ANCESTOR_OR_SELF:
+    case LYXP_AXIS_DESCENDANT_OR_SELF:
+    case LYXP_AXIS_SELF:
+        if ((node_type == LYXP_NODE_ROOT_CONFIG) || (node_type == LYXP_NODE_ROOT) || (node_type == LYXP_NODE_ELEM)) {
+            /* just return the node */
+            next = scnode;
+            next_type = node_type;
+        }
+        break;
+
+    case LYXP_AXIS_ANCESTOR:
+    case LYXP_AXIS_PARENT:
+        if (node_type == LYXP_NODE_ELEM) {
+            next = lysc_data_parent(scnode);
+            next_type = next ? LYXP_NODE_ELEM : set->root_type;
+        } /* else no parent */
+        break;
+
+    case LYXP_AXIS_DESCENDANT:
+    case LYXP_AXIS_CHILD:
+        if ((node_type == LYXP_NODE_ROOT_CONFIG) || (node_type == LYXP_NODE_ROOT)) {
+            /* it can actually be in any module, it's all <running>, and even if it's moveto_mod (if set),
+             * it can be in a top-level augment */
+            while ((*iter_mod = ly_ctx_get_module_iter(set->ctx, iter_mod_idx))) {
+                /* module may not be implemented or not compiled yet */
+                if (!(*iter_mod)->compiled) {
+                    continue;
+                }
+
+                /* get next node */
+                if ((next = lys_getnext(NULL, NULL, (*iter_mod)->compiled, getnext_opts))) {
+                    next_type = LYXP_NODE_ELEM;
+                    break;
+                }
+            }
+        } else if (node_type == LYXP_NODE_ELEM) {
+            /* get next node */
+            next = lys_getnext(NULL, scnode, NULL, getnext_opts);
+            next_type = next ? LYXP_NODE_ELEM : 0;
+        }
+        break;
+
+    case LYXP_AXIS_FOLLOWING:
+    case LYXP_AXIS_FOLLOWING_SIBLING:
+        if (node_type == LYXP_NODE_ELEM) {
+            /* first next sibling */
+            next = lys_getnext(scnode, lysc_data_parent(scnode), scnode->module->compiled, getnext_opts);
+            next_type = next ? LYXP_NODE_ELEM : 0;
+        } /* else no sibling */
+        break;
+
+    case LYXP_AXIS_PRECEDING:
+    case LYXP_AXIS_PRECEDING_SIBLING:
+        if (node_type == LYXP_NODE_ELEM) {
+            /* first parent sibling */
+            next = lys_getnext(NULL, lysc_data_parent(scnode), scnode->module->compiled, getnext_opts);
+            if (next == scnode) {
+                /* no preceding sibling */
+                next = NULL;
+            }
+            next_type = next ? LYXP_NODE_ELEM : 0;
+        } /* else no sibling */
+        break;
+
+    case LYXP_AXIS_ATTRIBUTE:
+        /* unreachable */
+        assert(0);
+        LOGINT(set->ctx);
+        break;
+    }
+
+    *iter = next;
+    *iter_type = next_type;
+    return next_type ? LY_SUCCESS : LY_ENOTFOUND;
+}
+
+/**
+ * @brief Iterate over all schema nodes on an axis for a context node.
+ *
+ * @param[in,out] iter Last returned node, start with NULL, updated to the next node.
+ * @param[in,out] iter_type Node type of @p iter, start with 0, updated to the node type of the next node.
+ * @param[in,out] iter_mod Internal module iterator, do not change.
+ * @param[in,out] iter_mod_idx Internal module index iterator, do not change.
+ * @param[in] scnode Context node.
+ * @param[in] node_type Type of @p scnode.
+ * @param[in] axis Axis to use.
+ * @param[in] set XPath set with the general context.
+ * @param[in] getnext_opts Options for ::lys_getnext().
+ * @return LY_SUCCESS on success.
+ * @return LY_ENOTFOUND if no next node found.
+ */
+static LY_ERR
+moveto_axis_scnode_next(const struct lysc_node **iter, enum lyxp_node_type *iter_type, const struct lys_module **iter_mod,
+        uint32_t *iter_mod_idx, const struct lysc_node *scnode, enum lyxp_node_type node_type, enum lyxp_axis axis,
+        struct lyxp_set *set, uint32_t getnext_opts)
+{
+    const struct lysc_node *next = NULL, *dfs_stop;
+    enum lyxp_node_type next_type = 0;
+
+    if (!*iter_type) {
+        /* first returned node */
+        return moveto_axis_scnode_next_first(iter, iter_type, iter_mod, iter_mod_idx, scnode, node_type, axis, set,
+                getnext_opts);
+    }
+
+    switch (axis) {
+    case LYXP_AXIS_PARENT:
+    case LYXP_AXIS_SELF:
+        /* parent/self was returned before */
+        break;
+
+    case LYXP_AXIS_ANCESTOR_OR_SELF:
+        if ((*iter == scnode) && (*iter_type == node_type)) {
+            /* fake first ancestor, we returned self before */
+            *iter = NULL;
+            *iter_type = 0;
+            return moveto_axis_scnode_next_first(iter, iter_type, iter_mod, iter_mod_idx, scnode, node_type,
+                    LYXP_AXIS_ANCESTOR, set, getnext_opts);
+        } /* else continue ancestor */
+
+    /* fallthrough */
+    case LYXP_AXIS_ANCESTOR:
+        if (*iter_type == LYXP_NODE_ELEM) {
+            next = lysc_data_parent(*iter);
+            next_type = next ? LYXP_NODE_ELEM : set->root_type;
+        } /* else no ancestor */
+        break;
+
+    case LYXP_AXIS_DESCENDANT_OR_SELF:
+        if ((*iter == scnode) && (*iter_type == node_type)) {
+            /* fake first descendant, we returned self before */
+            *iter = NULL;
+            *iter_type = 0;
+            return moveto_axis_scnode_next_first(iter, iter_type, iter_mod, iter_mod_idx, scnode, node_type,
+                    LYXP_AXIS_DESCENDANT, set, getnext_opts);
+        } /* else DFS until context node */
+        dfs_stop = scnode;
+
+    /* fallthrough */
+    case LYXP_AXIS_DESCENDANT:
+        if (axis == LYXP_AXIS_DESCENDANT) {
+            /* DFS until the context node */
+            dfs_stop = scnode;
+        }
+
+    /* fallthrough */
+    case LYXP_AXIS_PRECEDING:
+        if (axis == LYXP_AXIS_PRECEDING) {
+            /* DFS until the previous sibling */
+            dfs_stop = moveto_axis_scnode_preceding_sibling(scnode, getnext_opts);
+            assert(dfs_stop);
+
+            if (*iter == dfs_stop) {
+                /* we are done */
+                break;
+            }
+        }
+
+    /* fallthrough */
+    case LYXP_AXIS_FOLLOWING:
+        if (axis == LYXP_AXIS_FOLLOWING) {
+            /* DFS through the whole module */
+            dfs_stop = NULL;
+        }
+
+        /* nested nodes */
+        assert(*iter);
+        next = moveto_axis_scnode_next_dfs_forward(*iter, dfs_stop, getnext_opts);
+        if (next) {
+            next_type = LYXP_NODE_ELEM;
+            break;
+        } /* else get next top-level node just like a child */
+
+    /* fallthrough */
+    case LYXP_AXIS_CHILD:
+    case LYXP_AXIS_FOLLOWING_SIBLING:
+        if (!*iter_mod) {
+            /* nodes from a single module */
+            if ((next = lys_getnext(*iter, lysc_data_parent(*iter), (*iter)->module->compiled, getnext_opts))) {
+                next_type = LYXP_NODE_ELEM;
+                break;
+            }
+
+            assert(scnode);
+            if ((axis != LYXP_AXIS_CHILD) && !lysc_data_parent(scnode)) {
+                /* iterating over top-level nodes, find next */
+                while (lysc_data_parent(*iter)) {
+                    *iter = lysc_data_parent(*iter);
+                }
+                if ((next = lys_getnext(*iter, NULL, (*iter)->module->compiled, getnext_opts))) {
+                    next_type = LYXP_NODE_ELEM;
+                    break;
+                }
+            }
+        }
+
+        while (*iter_mod) {
+            /* module top-level nodes */
+            if ((next = lys_getnext(*iter, NULL, (*iter_mod)->compiled, getnext_opts))) {
+                next_type = LYXP_NODE_ELEM;
+                break;
+            }
+
+            /* get next module */
+            while ((*iter_mod = ly_ctx_get_module_iter(set->ctx, iter_mod_idx))) {
+                /* module may not be implemented or not compiled yet */
+                if ((*iter_mod)->compiled) {
+                    break;
+                }
+            }
+
+            /* new module, start over */
+            *iter = NULL;
+        }
+        break;
+
+    case LYXP_AXIS_PRECEDING_SIBLING:
+        assert(*iter);
+
+        /* next parent sibling until scnode */
+        next = lys_getnext(*iter, lysc_data_parent(*iter), (*iter)->module->compiled, getnext_opts);
+        if (next == scnode) {
+            /* no previous sibling */
+            next = NULL;
+        }
+        next_type = next ? LYXP_NODE_ELEM : 0;
+        break;
+
+    case LYXP_AXIS_ATTRIBUTE:
+        /* unreachable */
+        assert(0);
+        LOGINT(set->ctx);
+        break;
+    }
+
+    *iter = next;
+    *iter_type = next_type;
+    return next_type ? LY_SUCCESS : LY_ENOTFOUND;
+}
+
+/**
+ * @brief Move context @p set to a schema node. Result is LYXP_SET_SCNODE_SET (or LYXP_SET_EMPTY).
+ *
+ * @param[in,out] set Set to use.
+ * @param[in] moveto_mod Matching node module, NULL for no prefix.
+ * @param[in] ncname Matching node name in the dictionary, NULL for any.
+ * @param[in] axis Axis to search on.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+moveto_scnode(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, enum lyxp_axis axis,
+        uint32_t options)
+{
+    ly_bool temp_ctx = 0;
+    uint32_t getnext_opts, orig_used, i, mod_idx, idx;
+    const struct lys_module *mod;
+    const struct lysc_node *iter;
+    enum lyxp_node_type iter_type;
+
+    if (options & LYXP_SKIP_EXPR) {
+        return LY_SUCCESS;
+    }
+
+    if (set->type != LYXP_SET_SCNODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
+        return LY_EVALID;
+    }
+
+    /* getnext opts */
+    getnext_opts = 0;
+    if (options & LYXP_SCNODE_OUTPUT) {
+        getnext_opts |= LYS_GETNEXT_OUTPUT;
+    }
+
+    orig_used = set->used;
+    for (i = 0; i < orig_used; ++i) {
+        /* update in_ctx first */
+        if (moveto_axis_scnode_next_in_ctx(&set->val.scnodes[i].in_ctx, axis)) {
+            /* not usable, skip */
+            continue;
+        }
+
+        iter = NULL;
+        iter_type = 0;
+        while (!moveto_axis_scnode_next(&iter, &iter_type, &mod, &mod_idx, set->val.scnodes[i].scnode,
+                set->val.scnodes[i].type, axis, set, getnext_opts)) {
+            if (moveto_scnode_check(iter, NULL, set, ncname, moveto_mod)) {
+                continue;
+            }
+
+            /* insert */
+            LY_CHECK_RET(set_scnode_insert_node(set, iter, iter_type, axis, &idx));
+
+            /* we need to prevent these nodes from being considered in this moveto */
+            if ((idx < orig_used) && (idx > i)) {
+                set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_NEW_CTX;
+                temp_ctx = 1;
+            }
+        }
+
+        if (moveto_mod && ncname && ((axis == LYXP_AXIS_DESCENDANT) || (axis == LYXP_AXIS_CHILD)) &&
+                (set->val.scnodes[i].type == LYXP_NODE_ELEM) && !ly_nested_ext_schema(NULL, set->val.scnodes[i].scnode,
+                moveto_mod->name, strlen(moveto_mod->name), LY_VALUE_JSON, NULL, ncname, strlen(ncname), &iter, NULL)) {
+            /* there is a matching node from an extension, use it */
+            LY_CHECK_RET(set_scnode_insert_node(set, iter, LYXP_NODE_ELEM, axis, &idx));
+            if ((idx < orig_used) && (idx > i)) {
+                set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_NEW_CTX;
+                temp_ctx = 1;
+            }
+        }
+    }
+
+    /* correct temporary in_ctx values */
+    if (temp_ctx) {
+        for (i = 0; i < orig_used; ++i) {
+            if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_NEW_CTX) {
+                set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
+            }
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Move context @p set to a child node and all its descendants. Result is LYXP_SET_NODE_SET.
+ *        Context position aware.
+ *
+ * @param[in] set Set to use.
+ * @param[in] moveto_mod Matching node module, NULL for no prefix.
+ * @param[in] ncname Matching node name in the dictionary, NULL for any.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+moveto_node_alldesc_child(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, uint32_t options)
+{
+    uint32_t i;
+    const struct lyd_node *next, *elem, *start;
+    struct lyxp_set ret_set;
+    LY_ERR rc;
+
+    if (options & LYXP_SKIP_EXPR) {
+        return LY_SUCCESS;
+    }
+
+    if (set->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
+        return LY_EVALID;
+    }
+
+    /* replace the original nodes (and throws away all text and meta nodes, root is replaced by a child) */
+    rc = xpath_pi_node(set, LYXP_AXIS_CHILD, options);
+    LY_CHECK_RET(rc);
+
+    /* this loop traverses all the nodes in the set and adds/keeps only those that match qname */
+    set_init(&ret_set, set);
+    for (i = 0; i < set->used; ++i) {
+
+        /* TREE DFS */
+        start = set->val.nodes[i].node;
+        for (elem = next = start; elem; elem = next) {
+            rc = moveto_node_check(elem, LYXP_NODE_ELEM, set, ncname, moveto_mod, options);
+            if (!rc) {
+                /* add matching node into result set */
+                set_insert_node(&ret_set, elem, 0, LYXP_NODE_ELEM, ret_set.used);
+                if (set_dup_node_check(set, elem, LYXP_NODE_ELEM, i)) {
+                    /* the node is a duplicate, we'll process it later in the set */
+                    goto skip_children;
+                }
+            } else if (rc == LY_EINCOMPLETE) {
+                return rc;
+            } else if (rc == LY_EINVAL) {
+                goto skip_children;
+            }
+
+            /* TREE DFS NEXT ELEM */
+            /* select element for the next run - children first */
+            next = lyd_child(elem);
+            if (!next) {
+skip_children:
+                /* no children, so try siblings, but only if it's not the start,
+                 * that is considered to be the root and it's siblings are not traversed */
+                if (elem != start) {
+                    next = elem->next;
+                } else {
+                    break;
+                }
+            }
+            while (!next) {
+                /* no siblings, go back through the parents */
+                if (lyd_parent(elem) == start) {
+                    /* we are done, no next element to process */
+                    break;
+                }
+                /* parent is already processed, go to its sibling */
+                elem = lyd_parent(elem);
+                next = elem->next;
+            }
+        }
+    }
+
+    /* make the temporary set the current one */
+    ret_set.ctx_pos = set->ctx_pos;
+    ret_set.ctx_size = set->ctx_size;
+    lyxp_set_free_content(set);
+    memcpy(set, &ret_set, sizeof *set);
+    assert(!set_sort(set));
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Move context @p set to a child schema node and all its descendants starting from a node.
+ * Result is LYXP_SET_NODE_SET.
+ *
+ * @param[in] set Set to use.
+ * @param[in] start Start node whose subtree to add.
+ * @param[in] start_idx Index of @p start in @p set.
+ * @param[in] moveto_mod Matching node module, NULL for no prefix.
+ * @param[in] ncname Matching node name in the dictionary, NULL for any.
+ * @param[in] options XPath options.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+moveto_scnode_dfs(struct lyxp_set *set, const struct lysc_node *start, uint32_t start_idx,
+        const struct lys_module *moveto_mod, const char *ncname, uint32_t options)
+{
+    const struct lysc_node *next, *elem;
+    uint32_t idx;
+    LY_ERR rc;
+
+    /* TREE DFS */
+    for (elem = next = start; elem; elem = next) {
+        if ((elem == start) || (elem->nodetype & (LYS_CHOICE | LYS_CASE))) {
+            /* schema-only nodes, skip root */
+            goto next_iter;
+        }
+
+        rc = moveto_scnode_check(elem, start, set, ncname, moveto_mod);
+        if (!rc) {
+            if (lyxp_set_scnode_contains(set, elem, LYXP_NODE_ELEM, start_idx, &idx)) {
+                set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
+                if (idx > start_idx) {
+                    /* we will process it later in the set */
+                    goto skip_children;
+                }
+            } else {
+                LY_CHECK_RET(set_scnode_insert_node(set, elem, LYXP_NODE_ELEM, LYXP_AXIS_DESCENDANT, NULL));
+            }
+        } else if (rc == LY_EINVAL) {
+            goto skip_children;
+        }
+
+next_iter:
+        /* TREE DFS NEXT ELEM */
+        /* select element for the next run - children first */
+        next = lysc_node_child(elem);
+        if (next && (next->nodetype == LYS_INPUT) && (options & LYXP_SCNODE_OUTPUT)) {
+            next = next->next;
+        } else if (next && (next->nodetype == LYS_OUTPUT) && !(options & LYXP_SCNODE_OUTPUT)) {
+            next = next->next;
+        }
+        if (!next) {
+skip_children:
+            /* no children, so try siblings, but only if it's not the start,
+             * that is considered to be the root and it's siblings are not traversed */
+            if (elem != start) {
+                next = elem->next;
+            } else {
+                break;
+            }
+        }
+        while (!next) {
+            /* no siblings, go back through the parents */
+            if (elem->parent == start) {
+                /* we are done, no next element to process */
+                break;
+            }
+            /* parent is already processed, go to its sibling */
+            elem = elem->parent;
+            next = elem->next;
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Move context @p set to a child schema node and all its descendants. Result is LYXP_SET_NODE_SET.
+ *
+ * @param[in] set Set to use.
+ * @param[in] moveto_mod Matching node module, NULL for no prefix.
+ * @param[in] ncname Matching node name in the dictionary, NULL for any.
+ * @param[in] options XPath options.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+moveto_scnode_alldesc_child(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, uint32_t options)
+{
+    uint32_t i, orig_used, mod_idx;
+    const struct lys_module *mod;
+    const struct lysc_node *root;
+
+    if (options & LYXP_SKIP_EXPR) {
+        return LY_SUCCESS;
+    }
+
+    if (set->type != LYXP_SET_SCNODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
+        return LY_EVALID;
+    }
+
+    orig_used = set->used;
+    for (i = 0; i < orig_used; ++i) {
+        if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
+            if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START) {
+                continue;
+            }
+
+            /* remember context node */
+            set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
+        } else {
+            set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
+        }
+
+        if ((set->val.scnodes[i].type == LYXP_NODE_ROOT_CONFIG) || (set->val.scnodes[i].type == LYXP_NODE_ROOT)) {
+            /* traverse all top-level nodes in all the modules */
+            mod_idx = 0;
+            while ((mod = ly_ctx_get_module_iter(set->ctx, &mod_idx))) {
+                /* module may not be implemented or not compiled yet */
+                if (!mod->compiled) {
+                    continue;
+                }
+
+                root = NULL;
+                /* no getnext opts needed */
+                while ((root = lys_getnext(root, NULL, mod->compiled, 0))) {
+                    LY_CHECK_RET(moveto_scnode_dfs(set, root, i, moveto_mod, ncname, options));
+                }
+            }
+
+        } else if (set->val.scnodes[i].type == LYXP_NODE_ELEM) {
+            /* add all the descendants recursively */
+            LY_CHECK_RET(moveto_scnode_dfs(set, set->val.scnodes[i].scnode, i, moveto_mod, ncname, options));
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Move context @p set to an attribute. Result is LYXP_SET_NODE_SET.
+ *        Indirectly context position aware.
+ *
+ * @param[in,out] set Set to use.
+ * @param[in] mod Matching metadata module, NULL for any.
+ * @param[in] ncname Matching metadata name in the dictionary, NULL for any.
+ * @param[in] options XPath options.
+ * @return LY_ERR
+ */
+static LY_ERR
+moveto_attr(struct lyxp_set *set, const struct lys_module *mod, const char *ncname, uint32_t options)
+{
+    struct lyd_meta *sub;
+
+    if (options & LYXP_SKIP_EXPR) {
+        return LY_SUCCESS;
+    }
+
+    if (set->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
+        return LY_EVALID;
+    }
+
+    for (uint32_t i = 0; i < set->used; ) {
+        ly_bool replaced = 0;
+
+        /* only attributes of an elem (not dummy) can be in the result, skip all the rest;
+         * our attributes are always qualified */
+        if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
+            for (sub = set->val.nodes[i].node->meta; sub; sub = sub->next) {
+
+                /* check "namespace" */
+                if (mod && (sub->annotation->module != mod)) {
+                    continue;
+                }
+
+                if (!ncname || (sub->name == ncname)) {
+                    /* match */
+                    if (!replaced) {
+                        set->val.meta[i].meta = sub;
+                        set->val.meta[i].type = LYXP_NODE_META;
+                        /* pos does not change */
+                        replaced = 1;
+                    } else {
+                        set_insert_node(set, (struct lyd_node *)sub, set->val.nodes[i].pos, LYXP_NODE_META, i + 1);
+                    }
+                    ++i;
+                }
+            }
+        }
+
+        if (!replaced) {
+            /* no match */
+            set_remove_node(set, i);
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Move context @p set1 to union with @p set2. @p set2 is emptied afterwards.
+ *        Result is LYXP_SET_NODE_SET. Context position aware.
+ *
+ * @param[in,out] set1 Set to use for the result.
+ * @param[in] set2 Set that is copied to @p set1.
+ * @return LY_ERR
+ */
+static LY_ERR
+moveto_union(struct lyxp_set *set1, struct lyxp_set *set2)
+{
+    LY_ERR rc;
+
+    if ((set1->type != LYXP_SET_NODE_SET) || (set2->type != LYXP_SET_NODE_SET)) {
+        LOGVAL(set1->ctx, LY_VCODE_XP_INOP_2, "union", print_set_type(set1), print_set_type(set2));
+        return LY_EVALID;
+    }
+
+    /* set2 is empty or both set1 and set2 */
+    if (!set2->used) {
+        return LY_SUCCESS;
+    }
+
+    if (!set1->used) {
+        /* release hidden allocated data (lyxp_set.size) */
+        lyxp_set_free_content(set1);
+        /* direct copying of the entire structure */
+        memcpy(set1, set2, sizeof *set1);
+        /* dynamic memory belongs to set1 now, do not free */
+        memset(set2, 0, sizeof *set2);
+        return LY_SUCCESS;
+    }
+
+    /* we assume sets are sorted */
+    assert(!set_sort(set1) && !set_sort(set2));
+
+    /* sort, remove duplicates */
+    rc = set_sorted_merge(set1, set2);
+    LY_CHECK_RET(rc);
+
+    /* final set must be sorted */
+    assert(!set_sort(set1));
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Move context @p set to an attribute in any of the descendants. Result is LYXP_SET_NODE_SET.
+ *        Context position aware.
+ *
+ * @param[in,out] set Set to use.
+ * @param[in] mod Matching metadata module, NULL for any.
+ * @param[in] ncname Matching metadata name in the dictionary, NULL for any.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static int
+moveto_attr_alldesc(struct lyxp_set *set, const struct lys_module *mod, const char *ncname, uint32_t options)
+{
+    struct lyd_meta *sub;
+    struct lyxp_set *set_all_desc = NULL;
+    LY_ERR rc;
+
+    if (options & LYXP_SKIP_EXPR) {
+        return LY_SUCCESS;
+    }
+
+    if (set->type != LYXP_SET_NODE_SET) {
+        LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
+        return LY_EVALID;
+    }
+
+    /* can be optimized similarly to moveto_node_alldesc() and save considerable amount of memory,
+     * but it likely won't be used much, so it's a waste of time */
+    /* copy the context */
+    set_all_desc = set_copy(set);
+    /* get all descendant nodes (the original context nodes are removed) */
+    rc = moveto_node_alldesc_child(set_all_desc, NULL, NULL, options);
+    if (rc != LY_SUCCESS) {
+        lyxp_set_free(set_all_desc);
+        return rc;
+    }
+    /* prepend the original context nodes */
+    rc = moveto_union(set, set_all_desc);
+    if (rc != LY_SUCCESS) {
+        lyxp_set_free(set_all_desc);
+        return rc;
+    }
+    lyxp_set_free(set_all_desc);
+
+    for (uint32_t i = 0; i < set->used; ) {
+        ly_bool replaced = 0;
+
+        /* only attributes of an elem can be in the result, skip all the rest,
+         * we have all attributes qualified in lyd tree */
+        if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
+            for (sub = set->val.nodes[i].node->meta; sub; sub = sub->next) {
+                /* check "namespace" */
+                if (mod && (sub->annotation->module != mod)) {
+                    continue;
+                }
+
+                if (!ncname || (sub->name == ncname)) {
+                    /* match */
+                    if (!replaced) {
+                        set->val.meta[i].meta = sub;
+                        set->val.meta[i].type = LYXP_NODE_META;
+                        /* pos does not change */
+                        replaced = 1;
+                    } else {
+                        set_insert_node(set, (struct lyd_node *)sub, set->val.meta[i].pos, LYXP_NODE_META, i + 1);
+                    }
+                    ++i;
+                }
+            }
+        }
+
+        if (!replaced) {
+            /* no match */
+            set_remove_node(set, i);
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Move context @p set1 single item to the result of a comparison.
+ *
+ * @param[in] set1 First set with the item to compare.
+ * @param[in] idx1 Index of the item in @p set1.
+ * @param[in] set2 Second set.
+ * @param[in] op Comparison operator to process.
+ * @param[in] switch_operands Whether to switch sets as operands; whether it is `set1 op set2` or `set2 op set1`.
+ * @param[out] result Result of the comparison.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+moveto_op_comp_item(const struct lyxp_set *set1, uint32_t idx1, struct lyxp_set *set2, const char *op,
+        ly_bool switch_operands, ly_bool *result)
+{
+    struct lyxp_set tmp1 = {0};
+    LY_ERR rc = LY_SUCCESS;
+
+    assert(set1->type == LYXP_SET_NODE_SET);
+
+    /* cast set1 */
+    switch (set2->type) {
+    case LYXP_SET_NUMBER:
+        rc = set_comp_cast(&tmp1, set1, LYXP_SET_NUMBER, idx1);
+        break;
+    case LYXP_SET_BOOLEAN:
+        rc = set_comp_cast(&tmp1, set1, LYXP_SET_BOOLEAN, idx1);
+        break;
+    default:
+        rc = set_comp_cast(&tmp1, set1, LYXP_SET_STRING, idx1);
+        break;
+    }
+    LY_CHECK_GOTO(rc, cleanup);
+
+    /* canonize set2 */
+    LY_CHECK_GOTO(rc = set_comp_canonize(set2, &set1->val.nodes[idx1]), cleanup);
+
+    /* compare recursively and store the result */
+    if (switch_operands) {
+        LY_CHECK_GOTO(rc = moveto_op_comp(set2, &tmp1, op, result), cleanup);
+    } else {
+        LY_CHECK_GOTO(rc = moveto_op_comp(&tmp1, set2, op, result), cleanup);
+    }
+
+cleanup:
+    lyxp_set_free_content(&tmp1);
+    return rc;
+}
+
+/**
+ * @brief Move context @p set1 to the result of a comparison. Handles '=', '!=', '<=', '<', '>=', or '>'.
+ *        Result is LYXP_SET_BOOLEAN. Indirectly context position aware.
+ *
+ * @param[in] set1 Set acting as the first operand for @p op.
+ * @param[in] set2 Set acting as the second operand for @p op.
+ * @param[in] op Comparison operator to process.
+ * @param[out] result Result of the comparison.
+ * @return LY_ERR
+ */
+static LY_ERR
+moveto_op_comp(struct lyxp_set *set1, struct lyxp_set *set2, const char *op, ly_bool *result)
+{
+    /*
+     * NODE SET + NODE SET = NODE SET + STRING /(1 NODE SET) 2 STRING
+     * NODE SET + STRING = STRING + STRING     /1 STRING (2 STRING)
+     * NODE SET + NUMBER = NUMBER + NUMBER     /1 NUMBER (2 NUMBER)
+     * NODE SET + BOOLEAN = BOOLEAN + BOOLEAN  /1 BOOLEAN (2 BOOLEAN)
+     * STRING + NODE SET = STRING + STRING     /(1 STRING) 2 STRING
+     * NUMBER + NODE SET = NUMBER + NUMBER     /(1 NUMBER) 2 NUMBER
+     * BOOLEAN + NODE SET = BOOLEAN + BOOLEAN  /(1 BOOLEAN) 2 BOOLEAN
+     *
+     * '=' or '!='
+     * BOOLEAN + BOOLEAN
+     * BOOLEAN + STRING = BOOLEAN + BOOLEAN    /(1 BOOLEAN) 2 BOOLEAN
+     * BOOLEAN + NUMBER = BOOLEAN + BOOLEAN    /(1 BOOLEAN) 2 BOOLEAN
+     * STRING + BOOLEAN = BOOLEAN + BOOLEAN    /1 BOOLEAN (2 BOOLEAN)
+     * NUMBER + BOOLEAN = BOOLEAN + BOOLEAN    /1 BOOLEAN (2 BOOLEAN)
+     * NUMBER + NUMBER
+     * NUMBER + STRING = NUMBER + NUMBER       /(1 NUMBER) 2 NUMBER
+     * STRING + NUMBER = NUMBER + NUMBER       /1 NUMBER (2 NUMBER)
+     * STRING + STRING
+     *
+     * '<=', '<', '>=', '>'
+     * NUMBER + NUMBER
+     * BOOLEAN + BOOLEAN = NUMBER + NUMBER     /1 NUMBER, 2 NUMBER
+     * BOOLEAN + NUMBER = NUMBER + NUMBER      /1 NUMBER (2 NUMBER)
+     * BOOLEAN + STRING = NUMBER + NUMBER      /1 NUMBER, 2 NUMBER
+     * NUMBER + STRING = NUMBER + NUMBER       /(1 NUMBER) 2 NUMBER
+     * STRING + STRING = NUMBER + NUMBER       /1 NUMBER, 2 NUMBER
+     * STRING + NUMBER = NUMBER + NUMBER       /1 NUMBER (2 NUMBER)
+     * NUMBER + BOOLEAN = NUMBER + NUMBER      /(1 NUMBER) 2 NUMBER
+     * STRING + BOOLEAN = NUMBER + NUMBER      /(1 NUMBER) 2 NUMBER
+     */
+    uint32_t i;
+    LY_ERR rc;
+
+    /* iterative evaluation with node-sets */
+    if ((set1->type == LYXP_SET_NODE_SET) || (set2->type == LYXP_SET_NODE_SET)) {
+        if (set1->type == LYXP_SET_NODE_SET) {
+            for (i = 0; i < set1->used; ++i) {
+                /* evaluate for the single item */
+                LY_CHECK_RET(moveto_op_comp_item(set1, i, set2, op, 0, result));
+
+                /* lazy evaluation until true */
+                if (*result) {
+                    return LY_SUCCESS;
+                }
+            }
+        } else {
+            for (i = 0; i < set2->used; ++i) {
+                /* evaluate for the single item */
+                LY_CHECK_RET(moveto_op_comp_item(set2, i, set1, op, 1, result));
+
+                /* lazy evaluation until true */
+                if (*result) {
+                    return LY_SUCCESS;
+                }
+            }
+        }
+
+        /* false for all the nodes */
+        *result = 0;
+        return LY_SUCCESS;
+    }
+
+    /* first convert properly */
+    if ((op[0] == '=') || (op[0] == '!')) {
+        if ((set1->type == LYXP_SET_BOOLEAN) || (set2->type == LYXP_SET_BOOLEAN)) {
+            lyxp_set_cast(set1, LYXP_SET_BOOLEAN);
+            lyxp_set_cast(set2, LYXP_SET_BOOLEAN);
+        } else if ((set1->type == LYXP_SET_NUMBER) || (set2->type == LYXP_SET_NUMBER)) {
+            rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
+            LY_CHECK_RET(rc);
+            rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
+            LY_CHECK_RET(rc);
+        } /* else we have 2 strings */
+    } else {
+        rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
+        LY_CHECK_RET(rc);
+        rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
+        LY_CHECK_RET(rc);
+    }
+
+    assert(set1->type == set2->type);
+
+    /* compute result */
+    if (op[0] == '=') {
+        if (set1->type == LYXP_SET_BOOLEAN) {
+            *result = (set1->val.bln == set2->val.bln);
+        } else if (set1->type == LYXP_SET_NUMBER) {
+            *result = (set1->val.num == set2->val.num);
+        } else {
+            assert(set1->type == LYXP_SET_STRING);
+            *result = strcmp(set1->val.str, set2->val.str) ? 0 : 1;
+        }
+    } else if (op[0] == '!') {
+        if (set1->type == LYXP_SET_BOOLEAN) {
+            *result = (set1->val.bln != set2->val.bln);
+        } else if (set1->type == LYXP_SET_NUMBER) {
+            *result = (set1->val.num != set2->val.num);
+        } else {
+            assert(set1->type == LYXP_SET_STRING);
+            *result = strcmp(set1->val.str, set2->val.str) ? 1 : 0;
+        }
+    } else {
+        assert(set1->type == LYXP_SET_NUMBER);
+        if (op[0] == '<') {
+            if (op[1] == '=') {
+                *result = (set1->val.num <= set2->val.num);
+            } else {
+                *result = (set1->val.num < set2->val.num);
+            }
+        } else {
+            if (op[1] == '=') {
+                *result = (set1->val.num >= set2->val.num);
+            } else {
+                *result = (set1->val.num > set2->val.num);
+            }
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Move context @p set to the result of a basic operation. Handles '+', '-', unary '-', '*', 'div',
+ *        or 'mod'. Result is LYXP_SET_NUMBER. Indirectly context position aware.
+ *
+ * @param[in,out] set1 Set to use for the result.
+ * @param[in] set2 Set acting as the second operand for @p op.
+ * @param[in] op Operator to process.
+ * @return LY_ERR
+ */
+static LY_ERR
+moveto_op_math(struct lyxp_set *set1, struct lyxp_set *set2, const char *op)
+{
+    LY_ERR rc;
+
+    /* unary '-' */
+    if (!set2 && (op[0] == '-')) {
+        rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
+        LY_CHECK_RET(rc);
+        set1->val.num *= -1;
+        lyxp_set_free(set2);
+        return LY_SUCCESS;
+    }
+
+    assert(set1 && set2);
+
+    rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
+    LY_CHECK_RET(rc);
+    rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
+    LY_CHECK_RET(rc);
+
+    switch (op[0]) {
+    /* '+' */
+    case '+':
+        set1->val.num += set2->val.num;
+        break;
+
+    /* '-' */
+    case '-':
+        set1->val.num -= set2->val.num;
+        break;
+
+    /* '*' */
+    case '*':
+        set1->val.num *= set2->val.num;
+        break;
+
+    /* 'div' */
+    case 'd':
+        set1->val.num /= set2->val.num;
+        break;
+
+    /* 'mod' */
+    case 'm':
+        set1->val.num = ((long long)set1->val.num) % ((long long)set2->val.num);
+        break;
+
+    default:
+        LOGINT_RET(set1->ctx);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Evaluate Predicate. Logs directly on error.
+ *
+ * [9] Predicate ::= '[' Expr ']'
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @param[in] axis Axis to search on.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_predicate(const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set, uint32_t options, enum lyxp_axis axis)
+{
+    LY_ERR rc;
+    uint32_t i, orig_exp, orig_pos, orig_size;
+    int32_t pred_in_ctx;
+    ly_bool reverse_axis = 0;
+    struct lyxp_set set2 = {0};
+
+    /* '[' */
+    LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+            lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+    ++(*tok_idx);
+
+    if (options & LYXP_SKIP_EXPR) {
+only_parse:
+        rc = eval_expr_select(exp, tok_idx, 0, set, options | LYXP_SKIP_EXPR);
+        LY_CHECK_RET(rc);
+    } else if (set->type == LYXP_SET_NODE_SET) {
+        /* we (possibly) need the set sorted, it can affect the result (if the predicate result is a number) */
+        assert(!set_sort(set));
+
+        /* empty set, nothing to evaluate */
+        if (!set->used) {
+            goto only_parse;
+        }
+
+        /* decide forward or reverse axis */
+        switch (axis) {
+        case LYXP_AXIS_ANCESTOR:
+        case LYXP_AXIS_ANCESTOR_OR_SELF:
+        case LYXP_AXIS_PRECEDING:
+        case LYXP_AXIS_PRECEDING_SIBLING:
+            reverse_axis = 1;
+            break;
+        case LYXP_AXIS_DESCENDANT:
+        case LYXP_AXIS_DESCENDANT_OR_SELF:
+        case LYXP_AXIS_FOLLOWING:
+        case LYXP_AXIS_FOLLOWING_SIBLING:
+        case LYXP_AXIS_PARENT:
+        case LYXP_AXIS_CHILD:
+        case LYXP_AXIS_SELF:
+        case LYXP_AXIS_ATTRIBUTE:
+            reverse_axis = 0;
+            break;
+        }
+
+        orig_exp = *tok_idx;
+        orig_pos = reverse_axis ? set->used + 1 : 0;
+        orig_size = set->used;
+        for (i = 0; i < set->used; ++i) {
+            set_init(&set2, set);
+            set_insert_node(&set2, set->val.nodes[i].node, set->val.nodes[i].pos, set->val.nodes[i].type, 0);
+
+            /* remember the node context position for position() and context size for last() */
+            orig_pos += reverse_axis ? -1 : 1;
+
+            set2.ctx_pos = orig_pos;
+            set2.ctx_size = orig_size;
+            *tok_idx = orig_exp;
+
+            rc = eval_expr_select(exp, tok_idx, 0, &set2, options);
+            if (rc != LY_SUCCESS) {
+                lyxp_set_free_content(&set2);
+                return rc;
+            }
+
+            /* number is a proximity position */
+            if (set2.type == LYXP_SET_NUMBER) {
+                if ((long long)set2.val.num == orig_pos) {
+                    set2.val.num = 1;
+                } else {
+                    set2.val.num = 0;
+                }
+            }
+            lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
+
+            /* predicate satisfied or not? */
+            if (!set2.val.bln) {
+                set_remove_node_none(set, i);
+            }
+        }
+        set_remove_nodes_none(set);
+
+    } else if (set->type == LYXP_SET_SCNODE_SET) {
+        for (i = 0; i < set->used; ++i) {
+            if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
+                /* there is a currently-valid node */
+                break;
+            }
+        }
+        /* empty set, nothing to evaluate */
+        if (i == set->used) {
+            goto only_parse;
+        }
+
+        orig_exp = *tok_idx;
+
+        /* set special in_ctx to all the valid snodes */
+        pred_in_ctx = set_scnode_new_in_ctx(set);
+
+        /* use the valid snodes one-by-one */
+        for (i = 0; i < set->used; ++i) {
+            if (set->val.scnodes[i].in_ctx != pred_in_ctx) {
+                continue;
+            }
+            set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
+
+            *tok_idx = orig_exp;
+
+            rc = eval_expr_select(exp, tok_idx, 0, set, options);
+            LY_CHECK_RET(rc);
+
+            set->val.scnodes[i].in_ctx = pred_in_ctx;
+        }
+
+        /* restore the state as it was before the predicate */
+        for (i = 0; i < set->used; ++i) {
+            if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
+                set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
+            } else if (set->val.scnodes[i].in_ctx == pred_in_ctx) {
+                set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
+            }
+        }
+
+    } else {
+        set2.type = LYXP_SET_NODE_SET;
+        set_fill_set(&set2, set);
+
+        rc = eval_expr_select(exp, tok_idx, 0, &set2, options);
+        if (rc != LY_SUCCESS) {
+            lyxp_set_free_content(&set2);
+            return rc;
+        }
+
+        lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
+        if (!set2.val.bln) {
+            lyxp_set_free_content(set);
+        }
+        lyxp_set_free_content(&set2);
+    }
+
+    /* ']' */
+    assert(exp->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
+    LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+            lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+    ++(*tok_idx);
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Evaluate Literal. Logs directly on error.
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in,out] set Context and result set. On NULL the rule is only parsed.
+ */
+static void
+eval_literal(const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set)
+{
+    if (set) {
+        if (exp->tok_len[*tok_idx] == 2) {
+            set_fill_string(set, "", 0);
+        } else {
+            set_fill_string(set, &exp->expr[exp->tok_pos[*tok_idx] + 1], exp->tok_len[*tok_idx] - 2);
+        }
+    }
+    LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
+            lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+    ++(*tok_idx);
+}
+
+/**
+ * @brief Check that a nametest in a predicate matches a key node.
+ *
+ * @param[in] nametest Nametest to check.
+ * @param[in] len Length of @p nametest.
+ * @param[in] ctx_scnode Found schema node as the context for the predicate.
+ * @param[in] set Context set.
+ * @param[in] key Expected key node.
+ * @return LY_SUCCESS on success,
+ * @return LY_ENOT if a predicate could not be compiled.
+ * @return LY_ERR on any error.
+ */
+static LY_ERR
+eval_name_test_try_compile_predicate_key(const char *nametest, uint32_t len, const struct lysc_node *ctx_scnode,
+        const struct lyxp_set *set, const struct lysc_node *key)
+{
+    const struct lys_module *mod;
+
+    /* prefix (module) */
+    LY_CHECK_RET(moveto_resolve_model(&nametest, &len, set, ctx_scnode, &mod));
+    if (mod != key->module) {
+        return LY_ENOT;
+    }
+
+    /* node name */
+    if (ly_strncmp(key->name, nametest, len)) {
+        return LY_ENOT;
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Append a simple predicate for the node.
+ *
+ * @param[in] exp Full parsed XPath expression.
+ * @param[in] tok_idx Predicate start index in @p exp.
+ * @param[in] end_tok_idx Predicate end index in @p exp.
+ * @param[in] ctx_scnode Found schema node as the context for the predicate.
+ * @param[in] set Context set.
+ * @param[in] pred_node Node with the value referenced in the predicate.
+ * @param[in,out] pred Predicate to append to.
+ * @param[in,out] pred_len Length of @p pred, is updated.
+ * @return LY_SUCCESS on success,
+ * @return LY_ENOT if a predicate could not be compiled.
+ * @return LY_ERR on any error.
+ */
+static LY_ERR
+eval_name_test_try_compile_predicate_append(const struct lyxp_expr *exp, uint32_t tok_idx, uint32_t end_tok_idx,
+        const struct lysc_node *ctx_scnode, const struct lyxp_set *set, const struct lysc_node *pred_node, char **pred,
+        uint32_t *pred_len)
+{
+    LY_ERR rc = LY_SUCCESS;
+    uint32_t i;
+    const struct lyd_node *siblings;
+    struct lyd_node *ctx_node;
+    const struct lysc_node *sparent, *cur_scnode;
+    struct lyxp_expr *val_exp = NULL;
+    struct lyxp_set set2 = {0};
+    char quot;
+
+    /* duplicate the value expression */
+    LY_CHECK_GOTO(rc = lyxp_expr_dup(set->ctx, exp, tok_idx, end_tok_idx, &val_exp), cleanup);
+
+    /* get its atoms */
+    cur_scnode = set->cur_node ? set->cur_node->schema : NULL;
+    LY_CHECK_GOTO(rc = lyxp_atomize(set->ctx, val_exp, set->cur_mod, set->format, set->prefix_data, cur_scnode,
+            ctx_scnode, &set2, LYXP_SCNODE), cleanup);
+
+    /* check whether we can compile a single predicate (evaluation result value is always the same) */
+    for (i = 0; i < set2.used; ++i) {
+        if ((set2.val.scnodes[i].type != LYXP_NODE_ELEM) || (set2.val.scnodes[i].in_ctx < LYXP_SET_SCNODE_ATOM_NODE)) {
+            /* skip root and context node */
+            continue;
+        }
+
+        /* 1) context node descendants are traversed - do best-effort detection of the value dependency on the
+         * context node instance */
+        if ((set2.val.scnodes[i].axis == LYXP_AXIS_CHILD) && (set2.val.scnodes[i].scnode->parent == ctx_scnode)) {
+            /* 1.1) context node child was accessed on the child axis, certain dependency */
+            rc = LY_ENOT;
+            goto cleanup;
+        }
+        if ((set2.val.scnodes[i].axis == LYXP_AXIS_DESCENDANT) || (set2.val.scnodes[i].axis == LYXP_AXIS_DESCENDANT_OR_SELF)) {
+            for (sparent = set2.val.scnodes[i].scnode->parent; sparent && (sparent != ctx_scnode); sparent = sparent->parent) {}
+            if (sparent) {
+                /* 1.2) context node descendant was accessed on the descendant axis, probable dependency */
+                rc = LY_ENOT;
+                goto cleanup;
+            }
+        }
+
+        /* 2) multi-instance nodes (list or leaf-list) are traversed - all the instances need to be considered,
+         * but the current node can be safely ignored, it is always the same data instance */
+        if ((set2.val.scnodes[i].scnode->nodetype & (LYS_LIST | LYS_LEAFLIST)) && (cur_scnode != set2.val.scnodes[i].scnode)) {
+            rc = LY_ENOT;
+            goto cleanup;
+        }
+    }
+
+    /* get any data instance of the context node, we checked it makes no difference */
+    siblings = set->val.nodes[0].node ? lyd_child(set->val.nodes[0].node) : set->tree;
+    LY_CHECK_GOTO(rc = lyd_find_sibling_schema(siblings, ctx_scnode, &ctx_node), cleanup);
+
+    /* evaluate the value subexpression with the root context node */
+    lyxp_set_free_content(&set2);
+    LY_CHECK_GOTO(rc = lyxp_eval(set->ctx, val_exp, set->cur_mod, set->format, set->prefix_data, set->cur_node,
+            ctx_node, set->tree, NULL, &set2, 0), cleanup);
+
+    /* cast it into a string */
+    LY_CHECK_GOTO(rc = lyxp_set_cast(&set2, LYXP_SET_STRING), cleanup);
+
+    /* append the JSON predicate */
+    *pred = ly_realloc(*pred, *pred_len + 1 + strlen(pred_node->name) + 2 + strlen(set2.val.str) + 3);
+    LY_CHECK_ERR_GOTO(!*pred, LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
+    quot = strchr(set2.val.str, '\'') ? '\"' : '\'';
+    *pred_len += sprintf(*pred + *pred_len, "[%s=%c%s%c]", pred_node->name, quot, set2.val.str, quot);
+
+cleanup:
+    lyxp_expr_free(set->ctx, val_exp);
+    lyxp_set_free_content(&set2);
+    return rc;
+}
+
+/**
+ * @brief Try to compile list or leaf-list predicate in the known format to be used for hash-based instance search.
+ *
+ * @param[in] exp Full parsed XPath expression.
+ * @param[in,out] tok_idx Index in @p exp at the beginning of the predicate, is updated on success.
+ * @param[in] ctx_scnode Found schema node as the context for the predicate.
+ * @param[in] set Context set.
+ * @param[out] predicates Parsed predicates.
+ * @param[out] pred_type Type of @p predicates.
+ * @return LY_SUCCESS on success,
+ * @return LY_ENOT if a predicate could not be compiled.
+ * @return LY_ERR on any error.
+ */
+static LY_ERR
+eval_name_test_try_compile_predicates(const struct lyxp_expr *exp, uint32_t *tok_idx, const struct lysc_node *ctx_scnode,
+        const struct lyxp_set *set, struct ly_path_predicate **predicates, enum ly_path_pred_type *pred_type)
+{
+    LY_ERR rc = LY_SUCCESS;
+    uint32_t e_idx, val_start_idx, pred_idx = 0, temp_lo = 0, pred_len = 0, nested_pred;
+    const struct lysc_node *key;
+    char *pred = NULL;
+    struct lyxp_expr *exp2 = NULL;
+
+    assert(ctx_scnode->nodetype & (LYS_LIST | LYS_LEAFLIST));
+
+    /* turn logging off */
+    ly_temp_log_options(&temp_lo);
+
+    if (ctx_scnode->nodetype == LYS_LIST) {
+        /* check for predicates "[key1=...][key2=...]..." */
+
+        /* get key count */
+        if (ctx_scnode->flags & LYS_KEYLESS) {
+            rc = LY_ENOT;
+            goto cleanup;
+        }
+
+        /* learn where the predicates end */
+        e_idx = *tok_idx;
+        for (key = lysc_node_child(ctx_scnode); key && (key->flags & LYS_KEY); key = key->next) {
+            /* '[' */
+            if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
+                rc = LY_ENOT;
+                goto cleanup;
+            }
+            ++e_idx;
+
+            if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_NAMETEST)) {
+                /* not a key */
+                rc = LY_ENOT;
+                goto cleanup;
+            }
+
+            /* check key */
+            LY_CHECK_GOTO(rc = eval_name_test_try_compile_predicate_key(exp->expr + exp->tok_pos[e_idx],
+                    exp->tok_len[e_idx], ctx_scnode, set, key), cleanup);
+
+            ++e_idx;
+
+            if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_OPER_EQUAL)) {
+                /* not '=' */
+                rc = LY_ENOT;
+                goto cleanup;
+            }
+            ++e_idx;
+
+            /* value start */
+            val_start_idx = e_idx;
+
+            /* ']' */
+            nested_pred = 1;
+            do {
+                ++e_idx;
+
+                if ((nested_pred == 1) && !lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_OPER_LOG)) {
+                    /* higher priority than '=' */
+                    rc = LY_ENOT;
+                    goto cleanup;
+                } else if (!lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
+                    /* nested predicate */
+                    ++nested_pred;
+                } else if (!lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK2)) {
+                    /* predicate end */
+                    --nested_pred;
+                }
+            } while (nested_pred);
+
+            /* try to evaluate the value */
+            LY_CHECK_GOTO(rc = eval_name_test_try_compile_predicate_append(exp, val_start_idx, e_idx - 1, ctx_scnode,
+                    set, key, &pred, &pred_len), cleanup);
+
+            ++e_idx;
+        }
+    } else {
+        /* check for predicate "[.=...]" */
+
+        /* learn just where this single predicate ends */
+        e_idx = *tok_idx;
+
+        /* '[' */
+        if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
+            rc = LY_ENOT;
+            goto cleanup;
+        }
+        ++e_idx;
+
+        if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_DOT)) {
+            /* not the node value */
+            rc = LY_ENOT;
+            goto cleanup;
+        }
+        ++e_idx;
+
+        if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_OPER_EQUAL)) {
+            /* not '=' */
+            rc = LY_ENOT;
+            goto cleanup;
+        }
+        ++e_idx;
+
+        /* value start */
+        val_start_idx = e_idx;
+
+        /* ']' */
+        nested_pred = 1;
+        do {
+            ++e_idx;
+
+            if ((nested_pred == 1) && !lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_OPER_LOG)) {
+                /* higher priority than '=' */
+                rc = LY_ENOT;
+                goto cleanup;
+            } else if (!lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
+                /* nested predicate */
+                ++nested_pred;
+            } else if (!lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK2)) {
+                /* predicate end */
+                --nested_pred;
+            }
+        } while (nested_pred);
+
+        /* try to evaluate the value */
+        LY_CHECK_GOTO(rc = eval_name_test_try_compile_predicate_append(exp, val_start_idx, e_idx - 1, ctx_scnode, set,
+                ctx_scnode, &pred, &pred_len), cleanup);
+
+        ++e_idx;
+    }
+
+    /* parse the predicate(s) */
+    LY_CHECK_GOTO(rc = ly_path_parse_predicate(set->ctx, ctx_scnode, pred, pred_len, LY_PATH_PREFIX_OPTIONAL,
+            LY_PATH_PRED_SIMPLE, &exp2), cleanup);
+
+    /* compile */
+    rc = ly_path_compile_predicate(set->ctx, set->cur_node ? set->cur_node->schema : NULL, set->cur_mod, ctx_scnode, exp2,
+            &pred_idx, LY_VALUE_JSON, NULL, predicates, pred_type);
+    LY_CHECK_GOTO(rc, cleanup);
+
+    /* success, the predicate must include all the needed information for hash-based search */
+    *tok_idx = e_idx;
+
+cleanup:
+    ly_temp_log_options(NULL);
+    lyxp_expr_free(set->ctx, exp2);
+    free(pred);
+    return rc;
+}
+
+/**
+ * @brief Search for/check the next schema node that could be the only matching schema node meaning the
+ * data node(s) could be found using a single hash-based search.
+ *
+ * @param[in] ctx libyang context.
+ * @param[in] node Next context node to check.
+ * @param[in] name Expected node name.
+ * @param[in] name_len Length of @p name.
+ * @param[in] moveto_mod Expected node module, can be NULL for JSON format with no prefix.
+ * @param[in] root_type XPath root type.
+ * @param[in] format Prefix format.
+ * @param[in,out] found Previously found node, is updated.
+ * @return LY_SUCCESS on success,
+ * @return LY_ENOT if the whole check failed and hashes cannot be used.
+ */
+static LY_ERR
+eval_name_test_with_predicate_get_scnode(const struct ly_ctx *ctx, const struct lyd_node *node, const char *name,
+        uint32_t name_len, const struct lys_module *moveto_mod, enum lyxp_node_type root_type, LY_VALUE_FORMAT format,
+        const struct lysc_node **found)
+{
+    const struct lysc_node *scnode;
+    const struct lys_module *mod;
+    uint32_t idx = 0;
+
+    assert((format == LY_VALUE_JSON) || moveto_mod);
+
+continue_search:
+    scnode = NULL;
+    if (!node) {
+        if ((format == LY_VALUE_JSON) && !moveto_mod) {
+            /* search all modules for a single match */
+            while ((mod = ly_ctx_get_module_iter(ctx, &idx))) {
+                if (!mod->implemented) {
+                    continue;
+                }
+
+                scnode = lys_find_child(NULL, mod, name, name_len, 0, 0);
+                if (scnode) {
+                    /* we have found a match */
+                    break;
+                }
+            }
+
+            if (!scnode) {
+                /* all modules searched */
+                idx = 0;
+            }
+        } else {
+            /* search in top-level */
+            scnode = lys_find_child(NULL, moveto_mod, name, name_len, 0, 0);
+        }
+    } else if (!*found || (lysc_data_parent(*found) != node->schema)) {
+        if ((format == LY_VALUE_JSON) && !moveto_mod) {
+            /* we must adjust the module to inherit the one from the context node */
+            moveto_mod = node->schema->module;
+        }
+
+        /* search in children, do not repeat the same search */
+        scnode = lys_find_child(node->schema, moveto_mod, name, name_len, 0, 0);
+    } /* else skip redundant search */
+
+    /* additional context check */
+    if (scnode && (root_type == LYXP_NODE_ROOT_CONFIG) && (scnode->flags & LYS_CONFIG_R)) {
+        scnode = NULL;
+    }
+
+    if (scnode) {
+        if (*found) {
+            /* we found a schema node with the same name but at different level, give up, too complicated
+             * (more hash-based searches would be required, not supported) */
+            return LY_ENOT;
+        } else {
+            /* remember the found schema node and continue to make sure it can be used */
+            *found = scnode;
+        }
+    }
+
+    if (idx) {
+        /* continue searching all the following models */
+        goto continue_search;
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Generate message when no matching schema nodes were found for a path segment.
+ *
+ * @param[in] set XPath set.
+ * @param[in] scparent Previous schema parent in the context, if only one.
+ * @param[in] ncname XPath NCName being evaluated.
+ * @param[in] ncname_len Length of @p ncname.
+ * @param[in] expr Whole XPath expression.
+ * @param[in] options XPath options.
+ */
+static void
+eval_name_test_scnode_no_match_msg(struct lyxp_set *set, const struct lyxp_set_scnode *scparent, const char *ncname,
+        uint32_t ncname_len, const char *expr, uint32_t options)
+{
+    const char *format;
+    char *path = NULL, *ppath = NULL;
+
+    path = lysc_path(set->cur_scnode, LYSC_PATH_LOG, NULL, 0);
+    if (scparent) {
+        /* generate path for the parent */
+        if (scparent->type == LYXP_NODE_ELEM) {
+            ppath = lysc_path(scparent->scnode, LYSC_PATH_LOG, NULL, 0);
+        } else if (scparent->type == LYXP_NODE_ROOT) {
+            ppath = strdup("<root>");
+        } else if (scparent->type == LYXP_NODE_ROOT_CONFIG) {
+            ppath = strdup("<config-root>");
+        }
+    }
+    if (ppath) {
+        format = "Schema node \"%.*s\" for parent \"%s\" not found; in expr \"%.*s\" with context node \"%s\".";
+        if (options & LYXP_SCNODE_ERROR) {
+            LOGERR(set->ctx, LY_EVALID, format, ncname_len, ncname, ppath, (ncname - expr) + ncname_len, expr, path);
+        } else {
+            LOGWRN(set->ctx, format, ncname_len, ncname, ppath, (ncname - expr) + ncname_len, expr, path);
+        }
+    } else {
+        format = "Schema node \"%.*s\" not found; in expr \"%.*s\" with context node \"%s\".";
+        if (options & LYXP_SCNODE_ERROR) {
+            LOGERR(set->ctx, LY_EVALID, format, ncname_len, ncname, (ncname - expr) + ncname_len, expr, path);
+        } else {
+            LOGWRN(set->ctx, format, ncname_len, ncname, (ncname - expr) + ncname_len, expr, path);
+        }
+    }
+    free(path);
+    free(ppath);
+}
+
+/**
+ * @brief Evaluate NameTest and any following Predicates. Logs directly on error.
+ *
+ * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
+ * [6] NodeTest ::= NameTest | NodeType '(' ')'
+ * [7] NameTest ::= '*' | NCName ':' '*' | QName
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] axis What axis to search on.
+ * @param[in] all_desc Whether to search all the descendants or children only.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when, LY_ENOT for not found schema node)
+ */
+static LY_ERR
+eval_name_test_with_predicate(const struct lyxp_expr *exp, uint32_t *tok_idx, enum lyxp_axis axis, ly_bool all_desc,
+        struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR rc = LY_SUCCESS, r;
+    const char *ncname, *ncname_dict = NULL;
+    uint32_t i, ncname_len;
+    const struct lys_module *moveto_mod = NULL;
+    const struct lysc_node *scnode = NULL;
+    struct ly_path_predicate *predicates = NULL;
+    enum ly_path_pred_type pred_type = 0;
+    int scnode_skip_pred = 0;
+
+    LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+            lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+    ++(*tok_idx);
+
+    if (options & LYXP_SKIP_EXPR) {
+        goto moveto;
+    }
+
+    ncname = &exp->expr[exp->tok_pos[*tok_idx - 1]];
+    ncname_len = exp->tok_len[*tok_idx - 1];
+
+    if ((ncname[0] == '*') && (ncname_len == 1)) {
+        /* all nodes will match */
+        goto moveto;
+    }
+
+    /* parse (and skip) module name */
+    rc = moveto_resolve_model(&ncname, &ncname_len, set, NULL, &moveto_mod);
+    LY_CHECK_GOTO(rc, cleanup);
+
+    if ((ncname[0] == '*') && (ncname_len == 1)) {
+        /* all nodes from the module will match */
+        goto moveto;
+    }
+
+    if (((set->format == LY_VALUE_JSON) || moveto_mod) && (axis == LYXP_AXIS_CHILD) && !all_desc &&
+            (set->type == LYXP_SET_NODE_SET)) {
+        /* find the matching schema node in some parent in the context */
+        for (i = 0; i < set->used; ++i) {
+            if (eval_name_test_with_predicate_get_scnode(set->ctx, set->val.nodes[i].node, ncname, ncname_len,
+                    moveto_mod, set->root_type, set->format, &scnode)) {
+                /* check failed */
+                scnode = NULL;
+                break;
+            }
+        }
+
+        if (scnode && (scnode->nodetype & (LYS_LIST | LYS_LEAFLIST))) {
+            /* try to create the predicates */
+            if (eval_name_test_try_compile_predicates(exp, tok_idx, scnode, set, &predicates, &pred_type)) {
+                /* hashes cannot be used */
+                scnode = NULL;
+            }
+        }
+    }
+
+    if (!scnode) {
+        /* we are not able to match based on a schema node and not all the modules match ("*"),
+         * use dictionary for efficient comparison */
+        LY_CHECK_GOTO(rc = lydict_insert(set->ctx, ncname, ncname_len, &ncname_dict), cleanup);
+    }
+
+moveto:
+    /* move to the attribute(s), data node(s), or schema node(s) */
+    if (axis == LYXP_AXIS_ATTRIBUTE) {
+        if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
+            set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
+        } else {
+            if (all_desc) {
+                rc = moveto_attr_alldesc(set, moveto_mod, ncname_dict, options);
+            } else {
+                rc = moveto_attr(set, moveto_mod, ncname_dict, options);
+            }
+            LY_CHECK_GOTO(rc, cleanup);
+        }
+    } else {
+        if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
+            const struct lyxp_set_scnode *scparent = NULL;
+            ly_bool found = 0;
+
+            /* remember parent if there is only one, to print in the warning */
+            for (i = 0; i < set->used; ++i) {
+                if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
+                    if (!scparent) {
+                        /* remember the context node */
+                        scparent = &set->val.scnodes[i];
+                    } else {
+                        /* several context nodes, no reasonable error possible */
+                        scparent = NULL;
+                        break;
+                    }
+                }
+            }
+
+            if (all_desc && (axis == LYXP_AXIS_CHILD)) {
+                /* efficient evaluation that does not add all the descendants into the set */
+                rc = moveto_scnode_alldesc_child(set, moveto_mod, ncname_dict, options);
+            } else {
+                if (all_desc) {
+                    /* "//" == "/descendant-or-self::node()/" */
+                    rc = xpath_pi_node(set, LYXP_AXIS_DESCENDANT_OR_SELF, options);
+                    LY_CHECK_GOTO(rc, cleanup);
+                }
+                rc = moveto_scnode(set, moveto_mod, ncname_dict, axis, options);
+            }
+            LY_CHECK_GOTO(rc, cleanup);
+
+            i = set->used;
+            do {
+                --i;
+                if (set->val.scnodes[i].in_ctx > LYXP_SET_SCNODE_ATOM_NODE) {
+                    found = 1;
+                    break;
+                }
+            } while (i);
+            if (!found) {
+                /* generate message */
+                eval_name_test_scnode_no_match_msg(set, scparent, ncname, ncname_len, exp->expr, options);
+
+                if (options & LYXP_SCNODE_ERROR) {
+                    /* error */
+                    rc = LY_EVALID;
+                    goto cleanup;
+                }
+
+                /* skip the predicates and the rest of this path to not generate invalid warnings */
+                rc = LY_ENOT;
+                scnode_skip_pred = 1;
+            }
+        } else {
+            if (all_desc && (axis == LYXP_AXIS_CHILD)) {
+                /* efficient evaluation */
+                rc = moveto_node_alldesc_child(set, moveto_mod, ncname_dict, options);
+            } else if (scnode && (axis == LYXP_AXIS_CHILD)) {
+                /* we can find the child nodes using hashes */
+                rc = moveto_node_hash_child(set, scnode, predicates, options);
+            } else {
+                if (all_desc) {
+                    /* "//" == "/descendant-or-self::node()/" */
+                    rc = xpath_pi_node(set, LYXP_AXIS_DESCENDANT_OR_SELF, options);
+                    LY_CHECK_GOTO(rc, cleanup);
+                }
+                rc = moveto_node(set, moveto_mod, ncname_dict, axis, options);
+            }
+            LY_CHECK_GOTO(rc, cleanup);
+        }
+    }
+
+    if (scnode_skip_pred) {
+        /* skip predicates */
+        options |= LYXP_SKIP_EXPR;
+    }
+
+    /* Predicate* */
+    while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
+        r = eval_predicate(exp, tok_idx, set, options, axis);
+        LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
+    }
+
+cleanup:
+    if (scnode_skip_pred) {
+        /* restore options */
+        options &= ~LYXP_SKIP_EXPR;
+    }
+    if (!(options & LYXP_SKIP_EXPR)) {
+        lydict_remove(set->ctx, ncname_dict);
+        ly_path_predicates_free(set->ctx, pred_type, predicates);
+    }
+    return rc;
+}
+
+/**
+ * @brief Evaluate NodeType and any following Predicates. Logs directly on error.
+ *
+ * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
+ * [6] NodeTest ::= NameTest | NodeType '(' ')'
+ * [8] NodeType ::= 'text' | 'node'
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] axis Axis to search on.
+ * @param[in] all_desc Whether to search all the descendants or axis only.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_node_type_with_predicate(const struct lyxp_expr *exp, uint32_t *tok_idx, enum lyxp_axis axis, ly_bool all_desc,
+        struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR rc;
+
+    (void)all_desc;
+
+    if (!(options & LYXP_SKIP_EXPR)) {
+        assert(exp->tok_len[*tok_idx] == 4);
+        if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "node", 4)) {
+            rc = xpath_pi_node(set, axis, options);
+        } else {
+            assert(!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "text", 4));
+            rc = xpath_pi_text(set, axis, options);
+        }
+        LY_CHECK_RET(rc);
+    }
+    LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+            lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+    ++(*tok_idx);
+
+    /* '(' */
+    assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
+    LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+            lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+    ++(*tok_idx);
+
+    /* ')' */
+    assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
+    LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+            lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+    ++(*tok_idx);
+
+    /* Predicate* */
+    while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
+        rc = eval_predicate(exp, tok_idx, set, options, axis);
+        LY_CHECK_RET(rc);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Evaluate RelativeLocationPath. Logs directly on error.
+ *
+ * [4] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
+ * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
+ * [6] NodeTest ::= NameTest | NodeType '(' ')'
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] all_desc Whether to search all the descendants or children only.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (YL_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_relative_location_path(const struct lyxp_expr *exp, uint32_t *tok_idx, ly_bool all_desc, struct lyxp_set *set,
+        uint32_t options)
+{
+    LY_ERR rc = LY_SUCCESS;
+    enum lyxp_axis axis;
+    int scnode_skip_path = 0;
+
+    goto step;
+    do {
+        /* evaluate '/' or '//' */
+        if (exp->tok_len[*tok_idx] == 1) {
+            all_desc = 0;
+        } else {
+            assert(exp->tok_len[*tok_idx] == 2);
+            all_desc = 1;
+        }
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+
+step:
+        /* AxisSpecifier */
+        if (exp->tokens[*tok_idx] == LYXP_TOKEN_AXISNAME) {
+            axis = str2axis(exp->expr + exp->tok_pos[*tok_idx], exp->tok_len[*tok_idx]);
+
+            LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                    lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+            ++(*tok_idx);
+
+            assert(exp->tokens[*tok_idx] == LYXP_TOKEN_DCOLON);
+            LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                    lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+            ++(*tok_idx);
+        } else if (exp->tokens[*tok_idx] == LYXP_TOKEN_AT) {
+            axis = LYXP_AXIS_ATTRIBUTE;
+
+            LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                    lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+            ++(*tok_idx);
+        } else {
+            /* default */
+            axis = LYXP_AXIS_CHILD;
+        }
+
+        /* NodeTest Predicate* */
+        switch (exp->tokens[*tok_idx]) {
+        case LYXP_TOKEN_DOT:
+            /* evaluate '.' */
+            if (!(options & LYXP_SKIP_EXPR)) {
+                if (((options & LYXP_SCNODE_ALL) && (set->type != LYXP_SET_SCNODE_SET)) ||
+                        (!(options & LYXP_SCNODE_ALL) && (set->type != LYXP_SET_NODE_SET))) {
+                    LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
+                    rc = LY_EVALID;
+                    goto cleanup;
+                }
+
+                if (all_desc) {
+                    rc = xpath_pi_node(set, LYXP_AXIS_DESCENDANT_OR_SELF, options);
+                    LY_CHECK_GOTO(rc, cleanup);
+                }
+                rc = xpath_pi_node(set, LYXP_AXIS_SELF, options);
+                LY_CHECK_GOTO(rc, cleanup);
+            }
+            LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
+                    lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+            ++(*tok_idx);
+            break;
+
+        case LYXP_TOKEN_DDOT:
+            /* evaluate '..' */
+            if (!(options & LYXP_SKIP_EXPR)) {
+                if (((options & LYXP_SCNODE_ALL) && (set->type != LYXP_SET_SCNODE_SET)) ||
+                        (!(options & LYXP_SCNODE_ALL) && (set->type != LYXP_SET_NODE_SET))) {
+                    LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
+                    rc = LY_EVALID;
+                    goto cleanup;
+                }
+
+                if (all_desc) {
+                    rc = xpath_pi_node(set, LYXP_AXIS_DESCENDANT_OR_SELF, options);
+                    LY_CHECK_GOTO(rc, cleanup);
+                }
+                rc = xpath_pi_node(set, LYXP_AXIS_PARENT, options);
+                LY_CHECK_GOTO(rc, cleanup);
+            }
+            LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                    lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+            ++(*tok_idx);
+            break;
+
+        case LYXP_TOKEN_NAMETEST:
+            /* evaluate NameTest Predicate* */
+            rc = eval_name_test_with_predicate(exp, tok_idx, axis, all_desc, set, options);
+            if (rc == LY_ENOT) {
+                assert(options & LYXP_SCNODE_ALL);
+                /* skip the rest of this path */
+                rc = LY_SUCCESS;
+                scnode_skip_path = 1;
+                options |= LYXP_SKIP_EXPR;
+            }
+            LY_CHECK_GOTO(rc, cleanup);
+            break;
+
+        case LYXP_TOKEN_NODETYPE:
+            /* evaluate NodeType Predicate* */
+            rc = eval_node_type_with_predicate(exp, tok_idx, axis, all_desc, set, options);
+            LY_CHECK_GOTO(rc, cleanup);
+            break;
+
+        default:
+            LOGINT(set->ctx);
+            rc = LY_EINT;
+            goto cleanup;
+        }
+    } while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH));
+
+cleanup:
+    if (scnode_skip_path) {
+        options &= ~LYXP_SKIP_EXPR;
+    }
+    return rc;
+}
+
+/**
+ * @brief Evaluate AbsoluteLocationPath. Logs directly on error.
+ *
+ * [3] AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_absolute_location_path(const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set, uint32_t options)
+{
+    ly_bool all_desc;
+
+    if (!(options & LYXP_SKIP_EXPR)) {
+        /* no matter what tokens follow, we need to be at the root */
+        LY_CHECK_RET(moveto_root(set, options));
+    }
+
+    /* '/' RelativeLocationPath? */
+    if (exp->tok_len[*tok_idx] == 1) {
+        /* evaluate '/' - deferred */
+        all_desc = 0;
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+
+        if (lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NONE)) {
+            return LY_SUCCESS;
+        }
+        switch (exp->tokens[*tok_idx]) {
+        case LYXP_TOKEN_DOT:
+        case LYXP_TOKEN_DDOT:
+        case LYXP_TOKEN_AXISNAME:
+        case LYXP_TOKEN_AT:
+        case LYXP_TOKEN_NAMETEST:
+        case LYXP_TOKEN_NODETYPE:
+            LY_CHECK_RET(eval_relative_location_path(exp, tok_idx, all_desc, set, options));
+            break;
+        default:
+            break;
+        }
+
+    } else {
+        /* '//' RelativeLocationPath */
+        /* evaluate '//' - deferred so as not to waste memory by remembering all the nodes */
+        all_desc = 1;
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+
+        LY_CHECK_RET(eval_relative_location_path(exp, tok_idx, all_desc, set, options));
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Evaluate FunctionCall. Logs directly on error.
+ *
+ * [11] FunctionCall ::= FunctionName '(' ( Expr ( ',' Expr )* )? ')'
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_function_call(const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR rc;
+
+    LY_ERR (*xpath_func)(struct lyxp_set **, uint32_t, struct lyxp_set *, uint32_t) = NULL;
+    uint32_t arg_count = 0, i;
+    struct lyxp_set **args = NULL, **args_aux;
+
+    if (!(options & LYXP_SKIP_EXPR)) {
+        /* FunctionName */
+        switch (exp->tok_len[*tok_idx]) {
+        case 3:
+            if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "not", 3)) {
+                xpath_func = &xpath_not;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "sum", 3)) {
+                xpath_func = &xpath_sum;
+            }
+            break;
+        case 4:
+            if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "lang", 4)) {
+                xpath_func = &xpath_lang;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "last", 4)) {
+                xpath_func = &xpath_last;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "name", 4)) {
+                xpath_func = &xpath_name;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "true", 4)) {
+                xpath_func = &xpath_true;
+            }
+            break;
+        case 5:
+            if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "count", 5)) {
+                xpath_func = &xpath_count;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "false", 5)) {
+                xpath_func = &xpath_false;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "floor", 5)) {
+                xpath_func = &xpath_floor;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "round", 5)) {
+                xpath_func = &xpath_round;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "deref", 5)) {
+                xpath_func = &xpath_deref;
+            }
+            break;
+        case 6:
+            if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "concat", 6)) {
+                xpath_func = &xpath_concat;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "number", 6)) {
+                xpath_func = &xpath_number;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string", 6)) {
+                xpath_func = &xpath_string;
+            }
+            break;
+        case 7:
+            if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "boolean", 7)) {
+                xpath_func = &xpath_boolean;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "ceiling", 7)) {
+                xpath_func = &xpath_ceiling;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "current", 7)) {
+                xpath_func = &xpath_current;
+            }
+            break;
+        case 8:
+            if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "contains", 8)) {
+                xpath_func = &xpath_contains;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "position", 8)) {
+                xpath_func = &xpath_position;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "re-match", 8)) {
+                xpath_func = &xpath_re_match;
+            }
+            break;
+        case 9:
+            if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring", 9)) {
+                xpath_func = &xpath_substring;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "translate", 9)) {
+                xpath_func = &xpath_translate;
+            }
+            break;
+        case 10:
+            if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "local-name", 10)) {
+                xpath_func = &xpath_local_name;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "enum-value", 10)) {
+                xpath_func = &xpath_enum_value;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "bit-is-set", 10)) {
+                xpath_func = &xpath_bit_is_set;
+            }
+            break;
+        case 11:
+            if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "starts-with", 11)) {
+                xpath_func = &xpath_starts_with;
+            }
+            break;
+        case 12:
+            if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from", 12)) {
+                xpath_func = &xpath_derived_from;
+            }
+            break;
+        case 13:
+            if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "namespace-uri", 13)) {
+                xpath_func = &xpath_namespace_uri;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string-length", 13)) {
+                xpath_func = &xpath_string_length;
+            }
+            break;
+        case 15:
+            if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "normalize-space", 15)) {
+                xpath_func = &xpath_normalize_space;
+            } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-after", 15)) {
+                xpath_func = &xpath_substring_after;
+            }
+            break;
+        case 16:
+            if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-before", 16)) {
+                xpath_func = &xpath_substring_before;
+            }
+            break;
+        case 20:
+            if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from-or-self", 20)) {
+                xpath_func = &xpath_derived_from_or_self;
+            }
+            break;
+        }
+
+        if (!xpath_func) {
+            LOGVAL(set->ctx, LY_VCODE_XP_INFUNC, exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]]);
+            return LY_EVALID;
+        }
+    }
+
+    LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+            lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+    ++(*tok_idx);
+
+    /* '(' */
+    assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
+    LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+            lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+    ++(*tok_idx);
+
+    /* ( Expr ( ',' Expr )* )? */
+    if (exp->tokens[*tok_idx] != LYXP_TOKEN_PAR2) {
+        if (!(options & LYXP_SKIP_EXPR)) {
+            args = malloc(sizeof *args);
+            LY_CHECK_ERR_GOTO(!args, LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
+            arg_count = 1;
+            args[0] = set_copy(set);
+            if (!args[0]) {
+                rc = LY_EMEM;
+                goto cleanup;
+            }
+
+            rc = eval_expr_select(exp, tok_idx, 0, args[0], options);
+            LY_CHECK_GOTO(rc, cleanup);
+        } else {
+            rc = eval_expr_select(exp, tok_idx, 0, set, options | LYXP_SKIP_EXPR);
+            LY_CHECK_GOTO(rc, cleanup);
+        }
+    }
+    while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_COMMA)) {
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+
+        if (!(options & LYXP_SKIP_EXPR)) {
+            ++arg_count;
+            args_aux = realloc(args, arg_count * sizeof *args);
+            LY_CHECK_ERR_GOTO(!args_aux, arg_count--; LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
+            args = args_aux;
+            args[arg_count - 1] = set_copy(set);
+            if (!args[arg_count - 1]) {
+                rc = LY_EMEM;
+                goto cleanup;
+            }
+
+            rc = eval_expr_select(exp, tok_idx, 0, args[arg_count - 1], options);
+            LY_CHECK_GOTO(rc, cleanup);
+        } else {
+            rc = eval_expr_select(exp, tok_idx, 0, set, options | LYXP_SKIP_EXPR);
+            LY_CHECK_GOTO(rc, cleanup);
+        }
+    }
+
+    /* ')' */
+    assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
+    LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+            lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+    ++(*tok_idx);
+
+    if (!(options & LYXP_SKIP_EXPR)) {
+        /* evaluate function */
+        rc = xpath_func(args, arg_count, set, options);
+
+        if (options & LYXP_SCNODE_ALL) {
+            /* merge all nodes from arg evaluations */
+            for (i = 0; i < arg_count; ++i) {
+                set_scnode_clear_ctx(args[i], LYXP_SET_SCNODE_ATOM_NODE);
+                lyxp_set_scnode_merge(set, args[i]);
+            }
+        }
+    } else {
+        rc = LY_SUCCESS;
+    }
+
+cleanup:
+    for (i = 0; i < arg_count; ++i) {
+        lyxp_set_free(args[i]);
+    }
+    free(args);
+    return rc;
+}
+
+/**
+ * @brief Evaluate Number. Logs directly on error.
+ *
+ * @param[in] ctx Context for errors.
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in,out] set Context and result set. On NULL the rule is only parsed.
+ * @return LY_ERR
+ */
+static LY_ERR
+eval_number(struct ly_ctx *ctx, const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set)
+{
+    long double num;
+    char *endptr;
+
+    if (set) {
+        errno = 0;
+        num = strtold(&exp->expr[exp->tok_pos[*tok_idx]], &endptr);
+        if (errno) {
+            LOGVAL(ctx, LY_VCODE_XP_INTOK, "Unknown", &exp->expr[exp->tok_pos[*tok_idx]]);
+            LOGVAL(ctx, LYVE_XPATH, "Failed to convert \"%.*s\" into a long double (%s).",
+                    exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]], strerror(errno));
+            return LY_EVALID;
+        } else if (endptr - &exp->expr[exp->tok_pos[*tok_idx]] != exp->tok_len[*tok_idx]) {
+            LOGVAL(ctx, LY_VCODE_XP_INTOK, "Unknown", &exp->expr[exp->tok_pos[*tok_idx]]);
+            LOGVAL(ctx, LYVE_XPATH, "Failed to convert \"%.*s\" into a long double.",
+                    exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]]);
+            return LY_EVALID;
+        }
+
+        set_fill_number(set, num);
+    }
+
+    LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
+            lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+    ++(*tok_idx);
+    return LY_SUCCESS;
+}
+
+LY_ERR
+lyxp_vars_find(struct lyxp_var *vars, const char *name, size_t name_len, struct lyxp_var **var)
+{
+    LY_ERR ret = LY_ENOTFOUND;
+    LY_ARRAY_COUNT_TYPE u;
+
+    assert(vars && name);
+
+    name_len = name_len ? name_len : strlen(name);
+
+    LY_ARRAY_FOR(vars, u) {
+        if (!strncmp(vars[u].name, name, name_len)) {
+            ret = LY_SUCCESS;
+            break;
+        }
+    }
+
+    if (var && !ret) {
+        *var = &vars[u];
+    }
+
+    return ret;
+}
+
+/**
+ * @brief Evaluate VariableReference.
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] vars [Sized array](@ref sizedarrays) of XPath variables.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+eval_variable_reference(const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR ret;
+    const char *name;
+    struct lyxp_var *var;
+    const struct lyxp_var *vars;
+    struct lyxp_expr *tokens = NULL;
+    uint32_t token_index, name_len;
+
+    vars = set->vars;
+
+    /* find out the name and value of the variable */
+    name = &exp->expr[exp->tok_pos[*tok_idx]];
+    name_len = exp->tok_len[*tok_idx];
+    ret = lyxp_vars_find((struct lyxp_var *)vars, name, name_len, &var);
+    LY_CHECK_ERR_RET(ret, LOGERR(set->ctx, ret, "XPath variable \"%.*s\" not defined.", (int)name_len, name), ret);
+
+    /* parse value */
+    ret = lyxp_expr_parse(set->ctx, var->value, 0, 1, &tokens);
+    LY_CHECK_GOTO(ret, cleanup);
+
+    /* evaluate value */
+    token_index = 0;
+    ret = eval_expr_select(tokens, &token_index, 0, set, options);
+    LY_CHECK_GOTO(ret, cleanup);
+
+cleanup:
+    lyxp_expr_free(set->ctx, tokens);
+
+    return ret;
+}
+
+/**
+ * @brief Evaluate PathExpr. Logs directly on error.
+ *
+ * [12] PathExpr ::= LocationPath | PrimaryExpr Predicate*
+ *                 | PrimaryExpr Predicate* '/' RelativeLocationPath
+ *                 | PrimaryExpr Predicate* '//' RelativeLocationPath
+ * [2] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
+ * [10] PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_path_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set, uint32_t options)
+{
+    ly_bool all_desc;
+    LY_ERR rc;
+
+    switch (exp->tokens[*tok_idx]) {
+    case LYXP_TOKEN_PAR1:
+        /* '(' Expr ')' */
+
+        /* '(' */
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+
+        /* Expr */
+        rc = eval_expr_select(exp, tok_idx, 0, set, options);
+        LY_CHECK_RET(rc);
+
+        /* ')' */
+        assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+
+        goto predicate;
+
+    case LYXP_TOKEN_DOT:
+    case LYXP_TOKEN_DDOT:
+    case LYXP_TOKEN_AXISNAME:
+    case LYXP_TOKEN_AT:
+    case LYXP_TOKEN_NAMETEST:
+    case LYXP_TOKEN_NODETYPE:
+        /* RelativeLocationPath */
+        rc = eval_relative_location_path(exp, tok_idx, 0, set, options);
+        LY_CHECK_RET(rc);
+        break;
+
+    case LYXP_TOKEN_VARREF:
+        /* VariableReference */
+        rc = eval_variable_reference(exp, tok_idx, set, options);
+        LY_CHECK_RET(rc);
+        ++(*tok_idx);
+
+        goto predicate;
+
+    case LYXP_TOKEN_FUNCNAME:
+        /* FunctionCall */
+        rc = eval_function_call(exp, tok_idx, set, options);
+        LY_CHECK_RET(rc);
+
+        goto predicate;
+
+    case LYXP_TOKEN_OPER_PATH:
+    case LYXP_TOKEN_OPER_RPATH:
+        /* AbsoluteLocationPath */
+        rc = eval_absolute_location_path(exp, tok_idx, set, options);
+        LY_CHECK_RET(rc);
+        break;
+
+    case LYXP_TOKEN_LITERAL:
+        /* Literal */
+        if ((options & LYXP_SKIP_EXPR) || (options & LYXP_SCNODE_ALL)) {
+            if (!(options & LYXP_SKIP_EXPR)) {
+                set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+            }
+            eval_literal(exp, tok_idx, NULL);
+        } else {
+            eval_literal(exp, tok_idx, set);
+        }
+
+        goto predicate;
+
+    case LYXP_TOKEN_NUMBER:
+        /* Number */
+        if ((options & LYXP_SKIP_EXPR) || (options & LYXP_SCNODE_ALL)) {
+            if (!(options & LYXP_SKIP_EXPR)) {
+                set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+            }
+            rc = eval_number(NULL, exp, tok_idx, NULL);
+        } else {
+            rc = eval_number(set->ctx, exp, tok_idx, set);
+        }
+        LY_CHECK_RET(rc);
+
+        goto predicate;
+
+    default:
+        LOGVAL(set->ctx, LY_VCODE_XP_INTOK, lyxp_token2str(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
+        return LY_EVALID;
+    }
+
+    return LY_SUCCESS;
+
+predicate:
+    /* Predicate* */
+    while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
+        rc = eval_predicate(exp, tok_idx, set, options, LYXP_AXIS_CHILD);
+        LY_CHECK_RET(rc);
+    }
+
+    /* ('/' or '//') RelativeLocationPath */
+    if (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH)) {
+
+        /* evaluate '/' or '//' */
+        if (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH) {
+            all_desc = 0;
+        } else {
+            all_desc = 1;
+        }
+
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+
+        rc = eval_relative_location_path(exp, tok_idx, all_desc, set, options);
+        LY_CHECK_RET(rc);
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Evaluate UnionExpr. Logs directly on error.
+ *
+ * [20] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] repeat How many times this expression is repeated.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_union_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR rc = LY_SUCCESS;
+    struct lyxp_set orig_set, set2;
+    uint32_t i;
+
+    assert(repeat);
+
+    set_init(&orig_set, set);
+    set_init(&set2, set);
+
+    set_fill_set(&orig_set, set);
+
+    rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, set, options);
+    LY_CHECK_GOTO(rc, cleanup);
+
+    /* ('|' PathExpr)* */
+    for (i = 0; i < repeat; ++i) {
+        assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_UNI);
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+
+        if (options & LYXP_SKIP_EXPR) {
+            rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, set, options);
+            LY_CHECK_GOTO(rc, cleanup);
+            continue;
+        }
+
+        set_fill_set(&set2, &orig_set);
+        rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, &set2, options);
+        LY_CHECK_GOTO(rc, cleanup);
+
+        /* eval */
+        if (options & LYXP_SCNODE_ALL) {
+            lyxp_set_scnode_merge(set, &set2);
+        } else {
+            rc = moveto_union(set, &set2);
+            LY_CHECK_GOTO(rc, cleanup);
+        }
+    }
+
+cleanup:
+    lyxp_set_free_content(&orig_set);
+    lyxp_set_free_content(&set2);
+    return rc;
+}
+
+/**
+ * @brief Evaluate UnaryExpr. Logs directly on error.
+ *
+ * [19] UnaryExpr ::= UnionExpr | '-' UnaryExpr
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] repeat How many times this expression is repeated.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_unary_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR rc;
+    uint32_t this_op, i;
+
+    assert(repeat);
+
+    /* ('-')+ */
+    this_op = *tok_idx;
+    for (i = 0; i < repeat; ++i) {
+        assert(!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) && (exp->expr[exp->tok_pos[*tok_idx]] == '-'));
+
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+    }
+
+    rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNARY, set, options);
+    LY_CHECK_RET(rc);
+
+    if (!(options & LYXP_SKIP_EXPR) && (repeat % 2)) {
+        if (options & LYXP_SCNODE_ALL) {
+            warn_operands(set->ctx, set, NULL, 1, exp->expr, exp->tok_pos[this_op]);
+        } else {
+            rc = moveto_op_math(set, NULL, &exp->expr[exp->tok_pos[this_op]]);
+            LY_CHECK_RET(rc);
+        }
+    }
+
+    return LY_SUCCESS;
+}
+
+/**
+ * @brief Evaluate MultiplicativeExpr. Logs directly on error.
+ *
+ * [18] MultiplicativeExpr ::= UnaryExpr
+ *                     | MultiplicativeExpr '*' UnaryExpr
+ *                     | MultiplicativeExpr 'div' UnaryExpr
+ *                     | MultiplicativeExpr 'mod' UnaryExpr
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] repeat How many times this expression is repeated.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_multiplicative_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set,
+        uint32_t options)
+{
+    LY_ERR rc;
+    uint32_t i, this_op;
+    struct lyxp_set orig_set, set2;
+
+    assert(repeat);
+
+    set_init(&orig_set, set);
+    set_init(&set2, set);
+
+    set_fill_set(&orig_set, set);
+
+    rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, set, options);
+    LY_CHECK_GOTO(rc, cleanup);
+
+    /* ('*' / 'div' / 'mod' UnaryExpr)* */
+    for (i = 0; i < repeat; ++i) {
+        this_op = *tok_idx;
+
+        assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_MATH);
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+
+        if (options & LYXP_SKIP_EXPR) {
+            rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, set, options);
+            LY_CHECK_GOTO(rc, cleanup);
+            continue;
+        }
+
+        set_fill_set(&set2, &orig_set);
+        rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, &set2, options);
+        LY_CHECK_GOTO(rc, cleanup);
+
+        /* eval */
+        if (options & LYXP_SCNODE_ALL) {
+            warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
+            lyxp_set_scnode_merge(set, &set2);
+            set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        } else {
+            rc = moveto_op_math(set, &set2, &exp->expr[exp->tok_pos[this_op]]);
+            LY_CHECK_GOTO(rc, cleanup);
+        }
+    }
+
+cleanup:
+    lyxp_set_free_content(&orig_set);
+    lyxp_set_free_content(&set2);
+    return rc;
+}
+
+/**
+ * @brief Evaluate AdditiveExpr. Logs directly on error.
+ *
+ * [17] AdditiveExpr ::= MultiplicativeExpr
+ *                     | AdditiveExpr '+' MultiplicativeExpr
+ *                     | AdditiveExpr '-' MultiplicativeExpr
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] repeat How many times this expression is repeated.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_additive_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR rc;
+    uint32_t i, this_op;
+    struct lyxp_set orig_set, set2;
+
+    assert(repeat);
+
+    set_init(&orig_set, set);
+    set_init(&set2, set);
+
+    set_fill_set(&orig_set, set);
+
+    rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, set, options);
+    LY_CHECK_GOTO(rc, cleanup);
+
+    /* ('+' / '-' MultiplicativeExpr)* */
+    for (i = 0; i < repeat; ++i) {
+        this_op = *tok_idx;
+
+        assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_MATH);
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+
+        if (options & LYXP_SKIP_EXPR) {
+            rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, set, options);
+            LY_CHECK_GOTO(rc, cleanup);
+            continue;
+        }
+
+        set_fill_set(&set2, &orig_set);
+        rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, &set2, options);
+        LY_CHECK_GOTO(rc, cleanup);
+
+        /* eval */
+        if (options & LYXP_SCNODE_ALL) {
+            warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
+            lyxp_set_scnode_merge(set, &set2);
+            set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        } else {
+            rc = moveto_op_math(set, &set2, &exp->expr[exp->tok_pos[this_op]]);
+            LY_CHECK_GOTO(rc, cleanup);
+        }
+    }
+
+cleanup:
+    lyxp_set_free_content(&orig_set);
+    lyxp_set_free_content(&set2);
+    return rc;
+}
+
+/**
+ * @brief Evaluate RelationalExpr. Logs directly on error.
+ *
+ * [16] RelationalExpr ::= AdditiveExpr
+ *                       | RelationalExpr '<' AdditiveExpr
+ *                       | RelationalExpr '>' AdditiveExpr
+ *                       | RelationalExpr '<=' AdditiveExpr
+ *                       | RelationalExpr '>=' AdditiveExpr
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] repeat How many times this expression is repeated.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_relational_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR rc;
+    uint32_t i, this_op;
+    struct lyxp_set orig_set, set2;
+
+    assert(repeat);
+
+    set_init(&orig_set, set);
+    set_init(&set2, set);
+
+    set_fill_set(&orig_set, set);
+
+    rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, set, options);
+    LY_CHECK_GOTO(rc, cleanup);
+
+    /* ('<' / '>' / '<=' / '>=' AdditiveExpr)* */
+    for (i = 0; i < repeat; ++i) {
+        this_op = *tok_idx;
+
+        assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_COMP);
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+
+        if (options & LYXP_SKIP_EXPR) {
+            rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, set, options);
+            LY_CHECK_GOTO(rc, cleanup);
+            continue;
+        }
+
+        set_fill_set(&set2, &orig_set);
+        rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, &set2, options);
+        LY_CHECK_GOTO(rc, cleanup);
+
+        /* eval */
+        if (options & LYXP_SCNODE_ALL) {
+            warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
+            lyxp_set_scnode_merge(set, &set2);
+            set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        } else {
+            ly_bool result;
+
+            rc = moveto_op_comp(set, &set2, &exp->expr[exp->tok_pos[this_op]], &result);
+            LY_CHECK_GOTO(rc, cleanup);
+            set_fill_boolean(set, result);
+        }
+    }
+
+cleanup:
+    lyxp_set_free_content(&orig_set);
+    lyxp_set_free_content(&set2);
+    return rc;
+}
+
+/**
+ * @brief Evaluate EqualityExpr. Logs directly on error.
+ *
+ * [15] EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr
+ *                     | EqualityExpr '!=' RelationalExpr
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] repeat How many times this expression is repeated.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_equality_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR rc;
+    uint32_t i, this_op;
+    struct lyxp_set orig_set, set2;
+
+    assert(repeat);
+
+    set_init(&orig_set, set);
+    set_init(&set2, set);
+
+    set_fill_set(&orig_set, set);
+
+    rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, set, options);
+    LY_CHECK_GOTO(rc, cleanup);
+
+    /* ('=' / '!=' RelationalExpr)* */
+    for (i = 0; i < repeat; ++i) {
+        this_op = *tok_idx;
+
+        assert((exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL) || (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_NEQUAL));
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+
+        if (options & LYXP_SKIP_EXPR) {
+            rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, set, options);
+            LY_CHECK_GOTO(rc, cleanup);
+            continue;
+        }
+
+        set_fill_set(&set2, &orig_set);
+        rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, &set2, options);
+        LY_CHECK_GOTO(rc, cleanup);
+
+        /* eval */
+        if (options & LYXP_SCNODE_ALL) {
+            warn_operands(set->ctx, set, &set2, 0, exp->expr, exp->tok_pos[this_op - 1]);
+            warn_equality_value(exp, set, *tok_idx - 1, this_op - 1, *tok_idx - 1);
+            warn_equality_value(exp, &set2, this_op - 1, this_op - 1, *tok_idx - 1);
+            lyxp_set_scnode_merge(set, &set2);
+            set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
+        } else {
+            ly_bool result;
+
+            rc = moveto_op_comp(set, &set2, &exp->expr[exp->tok_pos[this_op]], &result);
+            LY_CHECK_GOTO(rc, cleanup);
+            set_fill_boolean(set, result);
+        }
+    }
+
+cleanup:
+    lyxp_set_free_content(&orig_set);
+    lyxp_set_free_content(&set2);
+    return rc;
+}
+
+/**
+ * @brief Evaluate AndExpr. Logs directly on error.
+ *
+ * [14] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] repeat How many times this expression is repeated.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_and_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR rc;
+    struct lyxp_set orig_set, set2;
+    uint32_t i;
+
+    assert(repeat);
+
+    set_init(&orig_set, set);
+    set_init(&set2, set);
+
+    set_fill_set(&orig_set, set);
+
+    rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, set, options);
+    LY_CHECK_GOTO(rc, cleanup);
+
+    /* cast to boolean, we know that will be the final result */
+    if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
+    } else {
+        lyxp_set_cast(set, LYXP_SET_BOOLEAN);
+    }
+
+    /* ('and' EqualityExpr)* */
+    for (i = 0; i < repeat; ++i) {
+        assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_LOG);
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, ((options & LYXP_SKIP_EXPR) || !set->val.bln ? "skipped" : "parsed"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+
+        /* lazy evaluation */
+        if ((options & LYXP_SKIP_EXPR) || ((set->type == LYXP_SET_BOOLEAN) && !set->val.bln)) {
+            rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, set, options | LYXP_SKIP_EXPR);
+            LY_CHECK_GOTO(rc, cleanup);
+            continue;
+        }
+
+        set_fill_set(&set2, &orig_set);
+        rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, &set2, options);
+        LY_CHECK_GOTO(rc, cleanup);
+
+        /* eval - just get boolean value actually */
+        if (set->type == LYXP_SET_SCNODE_SET) {
+            set_scnode_clear_ctx(&set2, LYXP_SET_SCNODE_ATOM_NODE);
+            lyxp_set_scnode_merge(set, &set2);
+        } else {
+            lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
+            set_fill_set(set, &set2);
+        }
+    }
+
+cleanup:
+    lyxp_set_free_content(&orig_set);
+    lyxp_set_free_content(&set2);
+    return rc;
+}
+
+/**
+ * @brief Evaluate OrExpr. Logs directly on error.
+ *
+ * [13] OrExpr ::= AndExpr | OrExpr 'or' AndExpr
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] repeat How many times this expression is repeated.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_or_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR rc;
+    struct lyxp_set orig_set, set2;
+    uint32_t i;
+
+    assert(repeat);
+
+    set_init(&orig_set, set);
+    set_init(&set2, set);
+
+    set_fill_set(&orig_set, set);
+
+    rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, set, options);
+    LY_CHECK_GOTO(rc, cleanup);
+
+    /* cast to boolean, we know that will be the final result */
+    if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
+        set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
+    } else {
+        lyxp_set_cast(set, LYXP_SET_BOOLEAN);
+    }
+
+    /* ('or' AndExpr)* */
+    for (i = 0; i < repeat; ++i) {
+        assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_LOG);
+        LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, ((options & LYXP_SKIP_EXPR) || set->val.bln ? "skipped" : "parsed"),
+                lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
+        ++(*tok_idx);
+
+        /* lazy evaluation */
+        if ((options & LYXP_SKIP_EXPR) || ((set->type == LYXP_SET_BOOLEAN) && set->val.bln)) {
+            rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, set, options | LYXP_SKIP_EXPR);
+            LY_CHECK_GOTO(rc, cleanup);
+            continue;
+        }
+
+        set_fill_set(&set2, &orig_set);
+        /* expr_type cound have been LYXP_EXPR_NONE in all these later calls (except for the first one),
+         * but it does not matter */
+        rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, &set2, options);
+        LY_CHECK_GOTO(rc, cleanup);
+
+        /* eval - just get boolean value actually */
+        if (set->type == LYXP_SET_SCNODE_SET) {
+            set_scnode_clear_ctx(&set2, LYXP_SET_SCNODE_ATOM_NODE);
+            lyxp_set_scnode_merge(set, &set2);
+        } else {
+            lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
+            set_fill_set(set, &set2);
+        }
+    }
+
+cleanup:
+    lyxp_set_free_content(&orig_set);
+    lyxp_set_free_content(&set2);
+    return rc;
+}
+
+/**
+ * @brief Decide what expression is at the pointer @p tok_idx and evaluate it accordingly.
+ *
+ * @param[in] exp Parsed XPath expression.
+ * @param[in] tok_idx Position in the expression @p exp.
+ * @param[in] etype Expression type to evaluate.
+ * @param[in,out] set Context and result set.
+ * @param[in] options XPath options.
+ * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
+ */
+static LY_ERR
+eval_expr_select(const struct lyxp_expr *exp, uint32_t *tok_idx, enum lyxp_expr_type etype, struct lyxp_set *set,
+        uint32_t options)
+{
+    uint32_t i, count;
+    enum lyxp_expr_type next_etype;
+    LY_ERR rc;
+
+    /* process operator repeats */
+    if (!exp->repeat[*tok_idx]) {
+        next_etype = LYXP_EXPR_NONE;
+    } else {
+        /* find etype repeat */
+        for (i = 0; exp->repeat[*tok_idx][i] > etype; ++i) {}
+
+        /* select one-priority lower because etype expression called us */
+        if (i) {
+            next_etype = exp->repeat[*tok_idx][i - 1];
+            /* count repeats for that expression */
+            for (count = 0; i && exp->repeat[*tok_idx][i - 1] == next_etype; ++count, --i) {}
+        } else {
+            next_etype = LYXP_EXPR_NONE;
+        }
+    }
+
+    /* decide what expression are we parsing based on the repeat */
+    switch (next_etype) {
+    case LYXP_EXPR_OR:
+        rc = eval_or_expr(exp, tok_idx, count, set, options);
+        break;
+    case LYXP_EXPR_AND:
+        rc = eval_and_expr(exp, tok_idx, count, set, options);
+        break;
+    case LYXP_EXPR_EQUALITY:
+        rc = eval_equality_expr(exp, tok_idx, count, set, options);
+        break;
+    case LYXP_EXPR_RELATIONAL:
+        rc = eval_relational_expr(exp, tok_idx, count, set, options);
+        break;
+    case LYXP_EXPR_ADDITIVE:
+        rc = eval_additive_expr(exp, tok_idx, count, set, options);
+        break;
+    case LYXP_EXPR_MULTIPLICATIVE:
+        rc = eval_multiplicative_expr(exp, tok_idx, count, set, options);
+        break;
+    case LYXP_EXPR_UNARY:
+        rc = eval_unary_expr(exp, tok_idx, count, set, options);
+        break;
+    case LYXP_EXPR_UNION:
+        rc = eval_union_expr(exp, tok_idx, count, set, options);
+        break;
+    case LYXP_EXPR_NONE:
+        rc = eval_path_expr(exp, tok_idx, set, options);
+        break;
+    default:
+        LOGINT_RET(set->ctx);
+    }
+
+    return rc;
+}
+
+/**
+ * @brief Get root type.
+ *
+ * @param[in] ctx_node Context node.
+ * @param[in] ctx_scnode Schema context node.
+ * @param[in] options XPath options.
+ * @return Root type.
+ */
+static enum lyxp_node_type
+lyxp_get_root_type(const struct lyd_node *ctx_node, const struct lysc_node *ctx_scnode, uint32_t options)
+{
+    const struct lysc_node *op;
+
+    /* explicit */
+    if (options & LYXP_ACCESS_TREE_ALL) {
+        return LYXP_NODE_ROOT;
+    } else if (options & LYXP_ACCESS_TREE_CONFIG) {
+        return LYXP_NODE_ROOT_CONFIG;
+    }
+
+    if (options & LYXP_SCNODE_ALL) {
+        /* schema */
+        for (op = ctx_scnode; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
+
+        if (op || (options & LYXP_SCNODE)) {
+            /* general root that can access everything */
+            return LYXP_NODE_ROOT;
+        } else if (!ctx_scnode || (ctx_scnode->flags & LYS_CONFIG_W)) {
+            /* root context node can access only config data (because we said so, it is unspecified) */
+            return LYXP_NODE_ROOT_CONFIG;
+        }
+        return LYXP_NODE_ROOT;
+    }
+
+    /* data */
+    op = ctx_node ? ctx_node->schema : NULL;
+    for ( ; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
+
+    if (op || !(options & LYXP_SCHEMA)) {
+        /* general root that can access everything */
+        return LYXP_NODE_ROOT;
+    } else if (!ctx_node || !ctx_node->schema || (ctx_node->schema->flags & LYS_CONFIG_W)) {
+        /* root context node can access only config data (because we said so, it is unspecified) */
+        return LYXP_NODE_ROOT_CONFIG;
+    }
+    return LYXP_NODE_ROOT;
+}
+
+LY_ERR
+lyxp_eval(const struct ly_ctx *ctx, const struct lyxp_expr *exp, const struct lys_module *cur_mod,
+        LY_VALUE_FORMAT format, void *prefix_data, const struct lyd_node *cur_node, const struct lyd_node *ctx_node,
+        const struct lyd_node *tree, const struct lyxp_var *vars, struct lyxp_set *set, uint32_t options)
+{
+    uint32_t tok_idx = 0;
+    LY_ERR rc;
+
+    LY_CHECK_ARG_RET(ctx, ctx, exp, set, LY_EINVAL);
+    if (!cur_mod && ((format == LY_VALUE_SCHEMA) || (format == LY_VALUE_SCHEMA_RESOLVED))) {
+        LOGERR(ctx, LY_EINVAL, "Current module must be set if schema format is used.");
+        return LY_EINVAL;
+    }
+
+    if (tree) {
+        /* adjust the pointer to be the first top-level sibling */
+        while (tree->parent) {
+            tree = lyd_parent(tree);
+        }
+        tree = lyd_first_sibling(tree);
+
+        if (lysc_data_parent(tree->schema)) {
+            /* unable to evaluate absolute paths */
+            LOGERR(ctx, LY_EINVAL, "Data node \"%s\" has no parent but is not instance of a top-level schema node.",
+                    LYD_NAME(tree));
+            return LY_EINVAL;
+        }
+    }
+
+    /* prepare set for evaluation */
+    memset(set, 0, sizeof *set);
+    set->type = LYXP_SET_NODE_SET;
+    set->root_type = lyxp_get_root_type(ctx_node, NULL, options);
+    set_insert_node(set, (struct lyd_node *)ctx_node, 0, ctx_node ? LYXP_NODE_ELEM : set->root_type, 0);
+
+    set->ctx = (struct ly_ctx *)ctx;
+    set->cur_node = cur_node;
+    for (set->context_op = cur_node ? cur_node->schema : NULL;
+            set->context_op && !(set->context_op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF));
+            set->context_op = set->context_op->parent) {}
+    set->tree = tree;
+    set->cur_mod = cur_mod;
+    set->format = format;
+    set->prefix_data = prefix_data;
+    set->vars = vars;
+
+    LOG_LOCSET(NULL, set->cur_node, NULL, NULL);
+
+    /* evaluate */
+    rc = eval_expr_select(exp, &tok_idx, 0, set, options);
+    if (rc != LY_SUCCESS) {
+        lyxp_set_free_content(set);
+    }
+
+    if (set->cur_node) {
+        LOG_LOCBACK(0, 1, 0, 0);
+    }
+    return rc;
+}
+
+#if 0
+
+/* full xml printing of set elements, not used currently */
+
+void
+lyxp_set_print_xml(FILE *f, struct lyxp_set *set)
+{
+    uint32_t i;
+    char *str_num;
+    struct lyout out;
+
+    memset(&out, 0, sizeof out);
+
+    out.type = LYOUT_STREAM;
+    out.method.f = f;
+
+    switch (set->type) {
+    case LYXP_SET_EMPTY:
+        ly_print_(&out, "Empty XPath set\n\n");
+        break;
+    case LYXP_SET_BOOLEAN:
+        ly_print_(&out, "Boolean XPath set:\n");
+        ly_print_(&out, "%s\n\n", set->value.bool ? "true" : "false");
+        break;
+    case LYXP_SET_STRING:
+        ly_print_(&out, "String XPath set:\n");
+        ly_print_(&out, "\"%s\"\n\n", set->value.str);
+        break;
+    case LYXP_SET_NUMBER:
+        ly_print_(&out, "Number XPath set:\n");
+
+        if (isnan(set->value.num)) {
+            str_num = strdup("NaN");
+        } else if ((set->value.num == 0) || (set->value.num == -0.0f)) {
+            str_num = strdup("0");
+        } else if (isinf(set->value.num) && !signbit(set->value.num)) {
+            str_num = strdup("Infinity");
+        } else if (isinf(set->value.num) && signbit(set->value.num)) {
+            str_num = strdup("-Infinity");
+        } else if ((long long)set->value.num == set->value.num) {
+            if (asprintf(&str_num, "%lld", (long long)set->value.num) == -1) {
+                str_num = NULL;
+            }
+        } else {
+            if (asprintf(&str_num, "%03.1Lf", set->value.num) == -1) {
+                str_num = NULL;
+            }
+        }
+        if (!str_num) {
+            LOGMEM;
+            return;
+        }
+        ly_print_(&out, "%s\n\n", str_num);
+        free(str_num);
+        break;
+    case LYXP_SET_NODE_SET:
+        ly_print_(&out, "Node XPath set:\n");
+
+        for (i = 0; i < set->used; ++i) {
+            ly_print_(&out, "%d. ", i + 1);
+            switch (set->node_type[i]) {
+            case LYXP_NODE_ROOT_ALL:
+                ly_print_(&out, "ROOT all\n\n");
+                break;
+            case LYXP_NODE_ROOT_CONFIG:
+                ly_print_(&out, "ROOT config\n\n");
+                break;
+            case LYXP_NODE_ROOT_STATE:
+                ly_print_(&out, "ROOT state\n\n");
+                break;
+            case LYXP_NODE_ROOT_NOTIF:
+                ly_print_(&out, "ROOT notification \"%s\"\n\n", set->value.nodes[i]->schema->name);
+                break;
+            case LYXP_NODE_ROOT_RPC:
+                ly_print_(&out, "ROOT rpc \"%s\"\n\n", set->value.nodes[i]->schema->name);
+                break;
+            case LYXP_NODE_ROOT_OUTPUT:
+                ly_print_(&out, "ROOT output \"%s\"\n\n", set->value.nodes[i]->schema->name);
+                break;
+            case LYXP_NODE_ELEM:
+                ly_print_(&out, "ELEM \"%s\"\n", set->value.nodes[i]->schema->name);
+                xml_print_node(&out, 1, set->value.nodes[i], 1, LYP_FORMAT);
+                ly_print_(&out, "\n");
+                break;
+            case LYXP_NODE_TEXT:
+                ly_print_(&out, "TEXT \"%s\"\n\n", ((struct lyd_node_leaf_list *)set->value.nodes[i])->value_str);
+                break;
+            case LYXP_NODE_ATTR:
+                ly_print_(&out, "ATTR \"%s\" = \"%s\"\n\n", set->value.attrs[i]->name, set->value.attrs[i]->value);
+                break;
+            }
+        }
+        break;
+    }
+}
+
+#endif
+
+LY_ERR
+lyxp_set_cast(struct lyxp_set *set, enum lyxp_set_type target)
+{
+    long double num;
+    char *str;
+    LY_ERR rc;
+
+    if (!set || (set->type == target)) {
+        return LY_SUCCESS;
+    }
+
+    /* it's not possible to convert anything into a node set */
+    assert(target != LYXP_SET_NODE_SET);
+
+    if (set->type == LYXP_SET_SCNODE_SET) {
+        lyxp_set_free_content(set);
+        return LY_EINVAL;
+    }
+
+    /* to STRING */
+    if ((target == LYXP_SET_STRING) || ((target == LYXP_SET_NUMBER) && (set->type == LYXP_SET_NODE_SET))) {
+        switch (set->type) {
+        case LYXP_SET_NUMBER:
+            if (isnan(set->val.num)) {
+                set->val.str = strdup("NaN");
+                LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
+            } else if ((set->val.num == 0) || (set->val.num == -0.0f)) {
+                set->val.str = strdup("0");
+                LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
+            } else if (isinf(set->val.num) && !signbit(set->val.num)) {
+                set->val.str = strdup("Infinity");
+                LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
+            } else if (isinf(set->val.num) && signbit(set->val.num)) {
+                set->val.str = strdup("-Infinity");
+                LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
+            } else if ((long long)set->val.num == set->val.num) {
+                if (asprintf(&str, "%lld", (long long)set->val.num) == -1) {
+                    LOGMEM_RET(set->ctx);
+                }
+                set->val.str = str;
+            } else {
+                if (asprintf(&str, "%03.1Lf", set->val.num) == -1) {
+                    LOGMEM_RET(set->ctx);
+                }
+                set->val.str = str;
+            }
+            break;
+        case LYXP_SET_BOOLEAN:
+            if (set->val.bln) {
+                set->val.str = strdup("true");
+            } else {
+                set->val.str = strdup("false");
+            }
+            LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), LY_EMEM);
+            break;
+        case LYXP_SET_NODE_SET:
+            /* we need the set sorted, it affects the result */
+            assert(!set_sort(set));
+
+            rc = cast_node_set_to_string(set, &str);
+            LY_CHECK_RET(rc);
+            lyxp_set_free_content(set);
+            set->val.str = str;
+            break;
+        default:
+            LOGINT_RET(set->ctx);
+        }
+        set->type = LYXP_SET_STRING;
+    }
+
+    /* to NUMBER */
+    if (target == LYXP_SET_NUMBER) {
+        switch (set->type) {
+        case LYXP_SET_STRING:
+            num = cast_string_to_number(set->val.str);
+            lyxp_set_free_content(set);
+            set->val.num = num;
+            break;
+        case LYXP_SET_BOOLEAN:
+            if (set->val.bln) {
+                set->val.num = 1;
+            } else {
+                set->val.num = 0;
+            }
+            break;
+        default:
+            LOGINT_RET(set->ctx);
+        }
+        set->type = LYXP_SET_NUMBER;
+    }
+
+    /* to BOOLEAN */
+    if (target == LYXP_SET_BOOLEAN) {
+        switch (set->type) {
+        case LYXP_SET_NUMBER:
+            if ((set->val.num == 0) || (set->val.num == -0.0f) || isnan(set->val.num)) {
+                set->val.bln = 0;
+            } else {
+                set->val.bln = 1;
+            }
+            break;
+        case LYXP_SET_STRING:
+            if (set->val.str[0]) {
+                lyxp_set_free_content(set);
+                set->val.bln = 1;
+            } else {
+                lyxp_set_free_content(set);
+                set->val.bln = 0;
+            }
+            break;
+        case LYXP_SET_NODE_SET:
+            if (set->used) {
+                lyxp_set_free_content(set);
+                set->val.bln = 1;
+            } else {
+                lyxp_set_free_content(set);
+                set->val.bln = 0;
+            }
+            break;
+        default:
+            LOGINT_RET(set->ctx);
+        }
+        set->type = LYXP_SET_BOOLEAN;
+    }
+
+    return LY_SUCCESS;
+}
+
+LY_ERR
+lyxp_atomize(const struct ly_ctx *ctx, const struct lyxp_expr *exp, const struct lys_module *cur_mod,
+        LY_VALUE_FORMAT format, void *prefix_data, const struct lysc_node *cur_scnode,
+        const struct lysc_node *ctx_scnode, struct lyxp_set *set, uint32_t options)
+{
+    LY_ERR ret;
+    uint32_t tok_idx = 0;
+
+    LY_CHECK_ARG_RET(ctx, ctx, exp, set, LY_EINVAL);
+    if (!cur_mod && ((format == LY_VALUE_SCHEMA) || (format == LY_VALUE_SCHEMA_RESOLVED))) {
+        LOGARG(NULL, "Current module must be set if schema format is used.");
+        return LY_EINVAL;
+    }
+
+    /* prepare set for evaluation */
+    memset(set, 0, sizeof *set);
+    set->type = LYXP_SET_SCNODE_SET;
+    set->root_type = lyxp_get_root_type(NULL, ctx_scnode, options);
+    LY_CHECK_RET(set_scnode_insert_node(set, ctx_scnode, ctx_scnode ? LYXP_NODE_ELEM : set->root_type, LYXP_AXIS_SELF, NULL));
+    set->val.scnodes[0].in_ctx = LYXP_SET_SCNODE_START;
+
+    set->ctx = (struct ly_ctx *)ctx;
+    set->cur_scnode = cur_scnode;
+    for (set->context_op = cur_scnode;
+            set->context_op && !(set->context_op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF));
+            set->context_op = set->context_op->parent) {}
+    set->cur_mod = cur_mod;
+    set->format = format;
+    set->prefix_data = prefix_data;
+
+    LOG_LOCSET(set->cur_scnode, NULL, NULL, NULL);
+
+    /* evaluate */
+    ret = eval_expr_select(exp, &tok_idx, 0, set, options);
+
+    LOG_LOCBACK(set->cur_scnode ? 1 : 0, 0, 0, 0);
+    return ret;
+}
+
+LIBYANG_API_DEF const char *
+lyxp_get_expr(const struct lyxp_expr *path)
+{
+    if (!path) {
+        return NULL;
+    }
+
+    return path->expr;
+}