summaryrefslogtreecommitdiffstats
path: root/src/path.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/path.c')
-rw-r--r--src/path.c1193
1 files changed, 1193 insertions, 0 deletions
diff --git a/src/path.c b/src/path.c
new file mode 100644
index 0000000..72e5fb5
--- /dev/null
+++ b/src/path.c
@@ -0,0 +1,1193 @@
+/**
+ * @file path.c
+ * @author Michal Vasko <mvasko@cesnet.cz>
+ * @brief Path functions
+ *
+ * Copyright (c) 2020 CESNET, z.s.p.o.
+ *
+ * This source code is licensed under BSD 3-Clause License (the "License").
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://opensource.org/licenses/BSD-3-Clause
+ */
+#include "path.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+#include "compat.h"
+#include "log.h"
+#include "plugins_types.h"
+#include "schema_compile.h"
+#include "set.h"
+#include "tree.h"
+#include "tree_data_internal.h"
+#include "tree_edit.h"
+#include "tree_schema.h"
+#include "tree_schema_internal.h"
+#include "xpath.h"
+
+#define LOGVAL_P(CTX, CUR_NODE, CODE, ...) ly_vlog(CTX, (CUR_NODE) ? LY_VLOG_LYSC : LY_VLOG_NONE, CUR_NODE, CODE, ##__VA_ARGS__)
+
+/**
+ * @brief Check predicate syntax.
+ *
+ * @param[in] ctx libyang context.
+ * @param[in] cur_node Current (original context) node.
+ * @param[in] exp Parsed predicate.
+ * @param[in,out] tok_idx Index in @p exp, is adjusted.
+ * @param[in] prefix Prefix option.
+ * @param[in] pred Predicate option.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+ly_path_check_predicate(const struct ly_ctx *ctx, const struct lysc_node *cur_node, const struct lyxp_expr *exp,
+ uint32_t *tok_idx, uint8_t prefix, uint8_t pred)
+{
+ LY_ERR ret = LY_SUCCESS;
+ struct ly_set *set = NULL;
+ uint32_t i;
+ const char *name;
+ size_t name_len;
+
+ LOG_LOCSET(cur_node, NULL, NULL, NULL);
+
+ if (!lyxp_next_token(NULL, exp, tok_idx, LYXP_TOKEN_BRACK1)) {
+ /* '[' */
+
+ if (((pred == LY_PATH_PRED_SIMPLE) || (pred == LY_PATH_PRED_KEYS)) &&
+ !lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NAMETEST)) {
+ ret = ly_set_new(&set);
+ LY_CHECK_GOTO(ret, cleanup);
+
+ do {
+ /* NameTest is always expected here */
+ LY_CHECK_GOTO(lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NAMETEST), token_error);
+
+ /* check prefix based on the options */
+ name = strnstr(exp->expr + exp->tok_pos[*tok_idx], ":", exp->tok_len[*tok_idx]);
+ if ((prefix == LY_PATH_PREFIX_MANDATORY) && !name) {
+ LOGVAL(ctx, LYVE_XPATH, "Prefix missing for \"%.*s\" in path.", exp->tok_len[*tok_idx],
+ exp->expr + exp->tok_pos[*tok_idx]);
+ goto token_error;
+ } else if ((prefix == LY_PATH_PREFIX_STRICT_INHERIT) && name) {
+ LOGVAL(ctx, LYVE_XPATH, "Redundant prefix for \"%.*s\" in path.", exp->tok_len[*tok_idx],
+ exp->expr + exp->tok_pos[*tok_idx]);
+ goto token_error;
+ }
+ if (!name) {
+ name = exp->expr + exp->tok_pos[*tok_idx];
+ name_len = exp->tok_len[*tok_idx];
+ } else {
+ ++name;
+ name_len = exp->tok_len[*tok_idx] - (name - (exp->expr + exp->tok_pos[*tok_idx]));
+ }
+
+ /* check whether it was not already specified */
+ for (i = 0; i < set->count; ++i) {
+ /* all the keys must be from the same module so this comparison should be fine */
+ if (!strncmp(set->objs[i], name, name_len) &&
+ lysp_check_identifierchar(NULL, ((char *)set->objs[i])[name_len], 0, NULL)) {
+ LOGVAL(ctx, LYVE_XPATH, "Duplicate predicate key \"%.*s\" in path.", (int)name_len, name);
+ goto token_error;
+ }
+ }
+
+ /* add it into the set */
+ ret = ly_set_add(set, (void *)name, 1, NULL);
+ LY_CHECK_GOTO(ret, cleanup);
+
+ /* NameTest */
+ ++(*tok_idx);
+
+ /* '=' */
+ LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_OPER_EQUAL), token_error);
+
+ /* Literal or Number */
+ LY_CHECK_GOTO(lyxp_next_token2(ctx, exp, tok_idx, LYXP_TOKEN_LITERAL, LYXP_TOKEN_NUMBER), token_error);
+
+ /* ']' */
+ LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_BRACK2), token_error);
+
+ /* '[' */
+ } while (!lyxp_next_token(NULL, exp, tok_idx, LYXP_TOKEN_BRACK1));
+
+ } else if ((pred == LY_PATH_PRED_SIMPLE) && !lyxp_next_token(NULL, exp, tok_idx, LYXP_TOKEN_DOT)) {
+ /* '.' */
+
+ /* '=' */
+ LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_OPER_EQUAL), token_error);
+
+ /* Literal or Number */
+ LY_CHECK_GOTO(lyxp_next_token2(ctx, exp, tok_idx, LYXP_TOKEN_LITERAL, LYXP_TOKEN_NUMBER), token_error);
+
+ /* ']' */
+ LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_BRACK2), token_error);
+
+ } else if ((pred == LY_PATH_PRED_SIMPLE) && !lyxp_next_token(NULL, exp, tok_idx, LYXP_TOKEN_NUMBER)) {
+ /* Number */
+
+ /* check for index 0 */
+ if (!atoi(exp->expr + exp->tok_pos[*tok_idx - 1])) {
+ LOGVAL(ctx, LYVE_XPATH, "Invalid positional predicate \"%.*s\".", (int)exp->tok_len[*tok_idx - 1],
+ exp->expr + exp->tok_pos[*tok_idx - 1]);
+ goto token_error;
+ }
+
+ /* ']' */
+ LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_BRACK2), token_error);
+
+ } else if ((pred == LY_PATH_PRED_LEAFREF) && !lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NAMETEST)) {
+ assert(prefix == LY_PATH_PREFIX_OPTIONAL);
+ ret = ly_set_new(&set);
+ LY_CHECK_GOTO(ret, cleanup);
+
+ do {
+ /* NameTest is always expected here */
+ LY_CHECK_GOTO(lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NAMETEST), token_error);
+
+ name = strnstr(exp->expr + exp->tok_pos[*tok_idx], ":", exp->tok_len[*tok_idx]);
+ if (!name) {
+ name = exp->expr + exp->tok_pos[*tok_idx];
+ name_len = exp->tok_len[*tok_idx];
+ } else {
+ ++name;
+ name_len = exp->tok_len[*tok_idx] - (name - (exp->expr + exp->tok_pos[*tok_idx]));
+ }
+
+ /* check whether it was not already specified */
+ for (i = 0; i < set->count; ++i) {
+ /* all the keys must be from the same module so this comparison should be fine */
+ if (!strncmp(set->objs[i], name, name_len) &&
+ lysp_check_identifierchar(NULL, ((char *)set->objs[i])[name_len], 0, NULL)) {
+ LOGVAL(ctx, LYVE_XPATH, "Duplicate predicate key \"%.*s\" in path.", (int)name_len, name);
+ goto token_error;
+ }
+ }
+
+ /* add it into the set */
+ ret = ly_set_add(set, (void *)name, 1, NULL);
+ LY_CHECK_GOTO(ret, cleanup);
+
+ /* NameTest */
+ ++(*tok_idx);
+
+ /* '=' */
+ LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_OPER_EQUAL), token_error);
+
+ /* FuncName */
+ LY_CHECK_GOTO(lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_FUNCNAME), token_error);
+ if ((exp->tok_len[*tok_idx] != ly_strlen_const("current")) ||
+ strncmp(exp->expr + exp->tok_pos[*tok_idx], "current", ly_strlen_const("current"))) {
+ LOGVAL(ctx, LYVE_XPATH, "Invalid function \"%.*s\" invocation in path.",
+ exp->tok_len[*tok_idx], exp->expr + exp->tok_pos[*tok_idx]);
+ goto token_error;
+ }
+ ++(*tok_idx);
+
+ /* '(' */
+ LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_PAR1), token_error);
+
+ /* ')' */
+ LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_PAR2), token_error);
+
+ /* '/' */
+ LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_OPER_PATH), token_error);
+
+ /* '..' */
+ LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_DDOT), token_error);
+ do {
+ /* '/' */
+ LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_OPER_PATH), token_error);
+ } while (!lyxp_next_token(NULL, exp, tok_idx, LYXP_TOKEN_DDOT));
+
+ /* NameTest */
+ LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_NAMETEST), token_error);
+
+ /* '/' */
+ while (!lyxp_next_token(NULL, exp, tok_idx, LYXP_TOKEN_OPER_PATH)) {
+ /* NameTest */
+ LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_NAMETEST), token_error);
+ }
+
+ /* ']' */
+ LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_BRACK2), token_error);
+
+ /* '[' */
+ } while (!lyxp_next_token(NULL, exp, tok_idx, LYXP_TOKEN_BRACK1));
+
+ } else if (lyxp_check_token(ctx, exp, *tok_idx, 0)) {
+ /* unexpected EOF */
+ goto token_error;
+ } else {
+ /* invalid token */
+ LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_token2str(exp->tokens[*tok_idx]), exp->expr + exp->tok_pos[*tok_idx]);
+ goto token_error;
+ }
+ }
+
+cleanup:
+ LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
+ ly_set_free(set, NULL);
+ return ret;
+
+token_error:
+ LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
+ ly_set_free(set, NULL);
+ return LY_EVALID;
+}
+
+LY_ERR
+ly_path_parse(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *str_path, size_t path_len,
+ ly_bool lref, uint8_t begin, uint8_t prefix, uint8_t pred, struct lyxp_expr **expr)
+{
+ LY_ERR ret = LY_SUCCESS;
+ struct lyxp_expr *exp = NULL;
+ uint32_t tok_idx, cur_len;
+ const char *cur_node, *prev_prefix = NULL, *ptr;
+
+ assert((begin == LY_PATH_BEGIN_ABSOLUTE) || (begin == LY_PATH_BEGIN_EITHER));
+ assert((prefix == LY_PATH_PREFIX_OPTIONAL) || (prefix == LY_PATH_PREFIX_MANDATORY) ||
+ (prefix == LY_PATH_PREFIX_STRICT_INHERIT));
+ assert((pred == LY_PATH_PRED_KEYS) || (pred == LY_PATH_PRED_SIMPLE) || (pred == LY_PATH_PRED_LEAFREF));
+
+ LOG_LOCSET(ctx_node, NULL, NULL, NULL);
+
+ /* parse as a generic XPath expression */
+ LY_CHECK_GOTO(ret = lyxp_expr_parse(ctx, str_path, path_len, 1, &exp), error);
+ tok_idx = 0;
+
+ if (begin == LY_PATH_BEGIN_EITHER) {
+ /* is the path relative? */
+ if (lyxp_next_token(NULL, exp, &tok_idx, LYXP_TOKEN_OPER_PATH)) {
+ /* relative path check specific to leafref */
+ if (lref) {
+ /* mandatory '..' */
+ LY_CHECK_ERR_GOTO(lyxp_next_token(ctx, exp, &tok_idx, LYXP_TOKEN_DDOT), ret = LY_EVALID, error);
+
+ do {
+ /* '/' */
+ LY_CHECK_ERR_GOTO(lyxp_next_token(ctx, exp, &tok_idx, LYXP_TOKEN_OPER_PATH), ret = LY_EVALID, error);
+
+ /* optional '..' */
+ } while (!lyxp_next_token(NULL, exp, &tok_idx, LYXP_TOKEN_DDOT));
+ }
+ }
+ } else {
+ /* '/' */
+ LY_CHECK_ERR_GOTO(lyxp_next_token(ctx, exp, &tok_idx, LYXP_TOKEN_OPER_PATH), ret = LY_EVALID, error);
+ }
+
+ do {
+ /* NameTest */
+ LY_CHECK_ERR_GOTO(lyxp_check_token(ctx, exp, tok_idx, LYXP_TOKEN_NAMETEST), ret = LY_EVALID, error);
+
+ /* check prefix based on the options */
+ cur_node = exp->expr + exp->tok_pos[tok_idx];
+ cur_len = exp->tok_len[tok_idx];
+ if (prefix == LY_PATH_PREFIX_MANDATORY) {
+ if (!strnstr(cur_node, ":", cur_len)) {
+ LOGVAL(ctx, LYVE_XPATH, "Prefix missing for \"%.*s\" in path.", cur_len, cur_node);
+ ret = LY_EVALID;
+ goto error;
+ }
+ } else if (prefix == LY_PATH_PREFIX_STRICT_INHERIT) {
+ if (!prev_prefix) {
+ /* the first node must have a prefix */
+ if (!strnstr(cur_node, ":", cur_len)) {
+ LOGVAL(ctx, LYVE_XPATH, "Prefix missing for \"%.*s\" in path.", cur_len, cur_node);
+ ret = LY_EVALID;
+ goto error;
+ }
+
+ /* remember the first prefix */
+ prev_prefix = cur_node;
+ } else {
+ /* the prefix must be different, if any */
+ ptr = strnstr(cur_node, ":", cur_len);
+ if (ptr) {
+ if (!strncmp(prev_prefix, cur_node, ptr - cur_node) && (prev_prefix[ptr - cur_node] == ':')) {
+ LOGVAL(ctx, LYVE_XPATH, "Duplicate prefix for \"%.*s\" in path.", cur_len, cur_node);
+ ret = LY_EVALID;
+ goto error;
+ }
+
+ /* remember this next prefix */
+ prev_prefix = cur_node;
+ }
+ }
+ }
+
+ ++tok_idx;
+
+ /* Predicate* */
+ LY_CHECK_GOTO(ret = ly_path_check_predicate(ctx, ctx_node, exp, &tok_idx, prefix, pred), error);
+
+ /* '/' */
+ } while (!lyxp_next_token(NULL, exp, &tok_idx, LYXP_TOKEN_OPER_PATH));
+
+ /* trailing token check */
+ if (exp->used > tok_idx) {
+ LOGVAL(ctx, LYVE_XPATH, "Unparsed characters \"%s\" left at the end of path.", exp->expr + exp->tok_pos[tok_idx]);
+ ret = LY_EVALID;
+ goto error;
+ }
+
+ *expr = exp;
+
+ LOG_LOCBACK(ctx_node ? 1 : 0, 0, 0, 0);
+ return LY_SUCCESS;
+
+error:
+ lyxp_expr_free(ctx, exp);
+ LOG_LOCBACK(ctx_node ? 1 : 0, 0, 0, 0);
+ return ret;
+}
+
+LY_ERR
+ly_path_parse_predicate(const struct ly_ctx *ctx, const struct lysc_node *cur_node, const char *str_path,
+ size_t path_len, uint8_t prefix, uint8_t pred, struct lyxp_expr **expr)
+{
+ LY_ERR ret = LY_SUCCESS;
+ struct lyxp_expr *exp = NULL;
+ uint32_t tok_idx;
+
+ assert((prefix == LY_PATH_PREFIX_OPTIONAL) || (prefix == LY_PATH_PREFIX_MANDATORY));
+ assert((pred == LY_PATH_PRED_KEYS) || (pred == LY_PATH_PRED_SIMPLE) || (pred == LY_PATH_PRED_LEAFREF));
+
+ LOG_LOCSET(cur_node, NULL, NULL, NULL);
+
+ /* parse as a generic XPath expression */
+ LY_CHECK_GOTO(ret = lyxp_expr_parse(ctx, str_path, path_len, 0, &exp), error);
+ tok_idx = 0;
+
+ LY_CHECK_GOTO(ret = ly_path_check_predicate(ctx, cur_node, exp, &tok_idx, prefix, pred), error);
+
+ /* trailing token check */
+ if (exp->used > tok_idx) {
+ LOGVAL(ctx, LYVE_XPATH, "Unparsed characters \"%s\" left at the end of predicate.",
+ exp->expr + exp->tok_pos[tok_idx]);
+ ret = LY_EVALID;
+ goto error;
+ }
+
+ *expr = exp;
+
+ LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
+ return LY_SUCCESS;
+
+error:
+ lyxp_expr_free(ctx, exp);
+ LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
+ return ret;
+}
+
+/**
+ * @brief Parse NameTest and get the corresponding schema node.
+ *
+ * @param[in] ctx libyang context.
+ * @param[in] cur_node Optional current (original context) node.
+ * @param[in] cur_mod Current module of the path (where the path is "instantiated"). Needed for ::LY_VALUE_SCHEMA
+ * and ::LY_VALUE_SCHEMA_RESOLVED.
+ * @param[in] prev_ctx_node Previous context node.
+ * @param[in] expr Parsed path.
+ * @param[in] tok_idx Index in @p expr.
+ * @param[in] format Format of the path.
+ * @param[in] prefix_data Format-specific data for resolving any prefixes (see ::ly_resolve_prefix).
+ * @param[in] top_ext Optional top-level extension to use for searching the schema node.
+ * @param[in] getnext_opts Options to be used for ::lys_getnext() calls.
+ * @param[out] snode Resolved schema node.
+ * @param[out] ext Optional extension instance of @p snode, if any.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+ly_path_compile_snode(const struct ly_ctx *ctx, const struct lysc_node *cur_node, const struct lys_module *cur_mod,
+ const struct lysc_node *prev_ctx_node, const struct lyxp_expr *expr, uint32_t tok_idx, LY_VALUE_FORMAT format,
+ void *prefix_data, const struct lysc_ext_instance *top_ext, uint32_t getnext_opts, const struct lysc_node **snode,
+ struct lysc_ext_instance **ext)
+{
+ LY_ERR ret;
+ const struct lys_module *mod = NULL;
+ struct lysc_ext_instance *e = NULL;
+ const char *pref, *name;
+ size_t len, name_len;
+
+ assert(expr->tokens[tok_idx] == LYXP_TOKEN_NAMETEST);
+
+ *snode = NULL;
+ if (ext) {
+ *ext = NULL;
+ }
+
+ /* get prefix */
+ if ((pref = strnstr(expr->expr + expr->tok_pos[tok_idx], ":", expr->tok_len[tok_idx]))) {
+ len = pref - (expr->expr + expr->tok_pos[tok_idx]);
+ pref = expr->expr + expr->tok_pos[tok_idx];
+ } else {
+ len = 0;
+ }
+
+ /* set name */
+ if (pref) {
+ name = pref + len + 1;
+ name_len = expr->tok_len[tok_idx] - len - 1;
+ } else {
+ name = expr->expr + expr->tok_pos[tok_idx];
+ name_len = expr->tok_len[tok_idx];
+ }
+
+ /* find node module */
+ if (pref) {
+ LOG_LOCSET(cur_node, NULL, NULL, NULL);
+
+ mod = ly_resolve_prefix(prev_ctx_node ? prev_ctx_node->module->ctx : ctx, pref, len, format, prefix_data);
+ if ((!mod || !mod->implemented) && prev_ctx_node) {
+ /* check for nested ext data */
+ ret = ly_nested_ext_schema(NULL, prev_ctx_node, pref, len, format, prefix_data, name, name_len, snode, &e);
+ if (!ret) {
+ goto success;
+ } else if (ret != LY_ENOT) {
+ goto error;
+ }
+ }
+
+ if (!mod) {
+ LOGVAL(ctx, LYVE_XPATH, "No module connected with the prefix \"%.*s\" found (prefix format %s).",
+ (int)len, pref, ly_format2str(format));
+ ret = LY_EVALID;
+ goto error;
+ } else if (!mod->implemented) {
+ LOGVAL(ctx, LYVE_XPATH, "Not implemented module \"%s\" in path.", mod->name);
+ ret = LY_EVALID;
+ goto error;
+ }
+
+ LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
+ } else {
+ switch (format) {
+ case LY_VALUE_SCHEMA:
+ case LY_VALUE_SCHEMA_RESOLVED:
+ if (!cur_mod) {
+ LOGINT_RET(ctx);
+ }
+ /* use current module */
+ mod = cur_mod;
+ break;
+ case LY_VALUE_JSON:
+ case LY_VALUE_LYB:
+ if (!prev_ctx_node) {
+ LOGINT_RET(ctx);
+ }
+ /* inherit module of the previous node */
+ mod = prev_ctx_node->module;
+ break;
+ case LY_VALUE_CANON:
+ case LY_VALUE_XML:
+ case LY_VALUE_STR_NS:
+ /* not really defined or accepted */
+ LOGINT_RET(ctx);
+ }
+ }
+
+ /* find schema node */
+ if (!prev_ctx_node && top_ext) {
+ *snode = lysc_ext_find_node(top_ext, mod, name, name_len, 0, getnext_opts);
+ } else {
+ *snode = lys_find_child(prev_ctx_node, mod, name, name_len, 0, getnext_opts);
+ if (!(*snode) && prev_ctx_node) {
+ ret = ly_nested_ext_schema(NULL, prev_ctx_node, pref, len, format, prefix_data, name, name_len, snode, &e);
+ LY_CHECK_RET(ret && (ret != LY_ENOT), ret);
+ }
+ }
+ if (!(*snode)) {
+ LOGVAL(ctx, LYVE_XPATH, "Not found node \"%.*s\" in path.", (int)name_len, name);
+ return LY_ENOTFOUND;
+ }
+
+success:
+ if (ext) {
+ *ext = e;
+ }
+ return LY_SUCCESS;
+
+error:
+ LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
+ return ret;
+}
+
+LY_ERR
+ly_path_compile_predicate(const struct ly_ctx *ctx, const struct lysc_node *cur_node, const struct lys_module *cur_mod,
+ const struct lysc_node *ctx_node, const struct lyxp_expr *expr, uint32_t *tok_idx, LY_VALUE_FORMAT format,
+ void *prefix_data, struct ly_path_predicate **predicates, enum ly_path_pred_type *pred_type)
+{
+ LY_ERR ret = LY_SUCCESS;
+ struct ly_path_predicate *p;
+ const struct lysc_node *key;
+ const char *val;
+ size_t val_len, key_count;
+
+ assert(ctx && ctx_node);
+
+ LOG_LOCSET(cur_node, NULL, NULL, NULL);
+
+ *pred_type = 0;
+
+ if (lyxp_next_token(NULL, expr, tok_idx, LYXP_TOKEN_BRACK1)) {
+ /* '[', no predicate */
+ goto cleanup; /* LY_SUCCESS */
+ }
+
+ if (expr->tokens[*tok_idx] == LYXP_TOKEN_NAMETEST) {
+ if (ctx_node->nodetype != LYS_LIST) {
+ LOGVAL(ctx, LYVE_XPATH, "List predicate defined for %s \"%s\" in path.",
+ lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
+ ret = LY_EVALID;
+ goto cleanup;
+ } else if (ctx_node->flags & LYS_KEYLESS) {
+ LOGVAL(ctx, LYVE_XPATH, "List predicate defined for keyless %s \"%s\" in path.",
+ lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
+ ret = LY_EVALID;
+ goto cleanup;
+ }
+
+ do {
+ /* NameTest, find the key */
+ LY_CHECK_RET(ly_path_compile_snode(ctx, cur_node, cur_mod, ctx_node, expr, *tok_idx, format, prefix_data,
+ NULL, 0, &key, NULL));
+ if ((key->nodetype != LYS_LEAF) || !(key->flags & LYS_KEY)) {
+ LOGVAL(ctx, LYVE_XPATH, "Key expected instead of %s \"%s\" in path.", lys_nodetype2str(key->nodetype),
+ key->name);
+ ret = LY_EVALID;
+ goto cleanup;
+ }
+ ++(*tok_idx);
+
+ if (!*pred_type) {
+ /* new predicate */
+ *pred_type = LY_PATH_PREDTYPE_LIST;
+ }
+ assert(*pred_type == LY_PATH_PREDTYPE_LIST);
+ LY_ARRAY_NEW_GOTO(ctx, *predicates, p, ret, cleanup);
+ p->key = key;
+
+ /* '=' */
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL);
+ ++(*tok_idx);
+
+ /* Literal or Number */
+ assert((expr->tokens[*tok_idx] == LYXP_TOKEN_LITERAL) || (expr->tokens[*tok_idx] == LYXP_TOKEN_NUMBER));
+ if (expr->tokens[*tok_idx] == LYXP_TOKEN_LITERAL) {
+ /* skip quotes */
+ val = expr->expr + expr->tok_pos[*tok_idx] + 1;
+ val_len = expr->tok_len[*tok_idx] - 2;
+ } else {
+ val = expr->expr + expr->tok_pos[*tok_idx];
+ val_len = expr->tok_len[*tok_idx];
+ }
+
+ /* store the value */
+ LOG_LOCSET(key, NULL, NULL, NULL);
+ ret = lyd_value_store(ctx, &p->value, ((struct lysc_node_leaf *)key)->type, val, val_len, NULL, format,
+ prefix_data, LYD_HINT_DATA, key, NULL);
+ LOG_LOCBACK(key ? 1 : 0, 0, 0, 0);
+ LY_CHECK_ERR_GOTO(ret, p->value.realtype = NULL, cleanup);
+ ++(*tok_idx);
+
+ /* "allocate" the type to avoid problems when freeing the value after the type was freed */
+ LY_ATOMIC_INC_BARRIER(((struct lysc_type *)p->value.realtype)->refcount);
+
+ /* ']' */
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
+ ++(*tok_idx);
+
+ /* another predicate follows? */
+ } while (!lyxp_next_token(NULL, expr, tok_idx, LYXP_TOKEN_BRACK1));
+
+ /* check that all keys were set */
+ key_count = 0;
+ for (key = lysc_node_child(ctx_node); key && (key->flags & LYS_KEY); key = key->next) {
+ ++key_count;
+ }
+ if (LY_ARRAY_COUNT(*predicates) != key_count) {
+ /* names (keys) are unique - it was checked when parsing */
+ LOGVAL(ctx, LYVE_XPATH, "Predicate missing for a key of %s \"%s\" in path.",
+ lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
+ ly_path_predicates_free(ctx, LY_PATH_PREDTYPE_LIST, *predicates);
+ *predicates = NULL;
+ ret = LY_EVALID;
+ goto cleanup;
+ }
+
+ } else if (expr->tokens[*tok_idx] == LYXP_TOKEN_DOT) {
+ if (ctx_node->nodetype != LYS_LEAFLIST) {
+ LOGVAL(ctx, LYVE_XPATH, "Leaf-list predicate defined for %s \"%s\" in path.",
+ lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
+ ret = LY_EVALID;
+ goto cleanup;
+ }
+ ++(*tok_idx);
+
+ /* new predicate */
+ *pred_type = LY_PATH_PREDTYPE_LEAFLIST;
+ LY_ARRAY_NEW_GOTO(ctx, *predicates, p, ret, cleanup);
+
+ /* '=' */
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL);
+ ++(*tok_idx);
+
+ /* Literal or Number */
+ assert((expr->tokens[*tok_idx] == LYXP_TOKEN_LITERAL) || (expr->tokens[*tok_idx] == LYXP_TOKEN_NUMBER));
+ if (expr->tokens[*tok_idx] == LYXP_TOKEN_LITERAL) {
+ /* skip quotes */
+ val = expr->expr + expr->tok_pos[*tok_idx] + 1;
+ val_len = expr->tok_len[*tok_idx] - 2;
+ } else {
+ val = expr->expr + expr->tok_pos[*tok_idx];
+ val_len = expr->tok_len[*tok_idx];
+ }
+
+ /* store the value */
+ LOG_LOCSET(ctx_node, NULL, NULL, NULL);
+ ret = lyd_value_store(ctx, &p->value, ((struct lysc_node_leaflist *)ctx_node)->type, val, val_len, NULL, format,
+ prefix_data, LYD_HINT_DATA, ctx_node, NULL);
+ LOG_LOCBACK(ctx_node ? 1 : 0, 0, 0, 0);
+ LY_CHECK_ERR_GOTO(ret, p->value.realtype = NULL, cleanup);
+ ++(*tok_idx);
+
+ /* "allocate" the type to avoid problems when freeing the value after the type was freed */
+ LY_ATOMIC_INC_BARRIER(((struct lysc_type *)p->value.realtype)->refcount);
+
+ /* ']' */
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
+ ++(*tok_idx);
+ } else {
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_NUMBER);
+ if (!(ctx_node->nodetype & (LYS_LEAFLIST | LYS_LIST))) {
+ ret = LY_EVALID;
+ LOGVAL(ctx, LYVE_XPATH, "Positional predicate defined for %s \"%s\" in path.",
+ lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
+ goto cleanup;
+ } else if (ctx_node->flags & LYS_CONFIG_W) {
+ ret = LY_EVALID;
+ LOGVAL(ctx, LYVE_XPATH, "Positional predicate defined for configuration %s \"%s\" in path.",
+ lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
+ goto cleanup;
+ }
+
+ /* new predicate */
+ *pred_type = LY_PATH_PREDTYPE_POSITION;
+ LY_ARRAY_NEW_GOTO(ctx, *predicates, p, ret, cleanup);
+
+ /* syntax was already checked */
+ p->position = strtoull(expr->expr + expr->tok_pos[*tok_idx], (char **)&val, LY_BASE_DEC);
+ ++(*tok_idx);
+
+ /* ']' */
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
+ ++(*tok_idx);
+ }
+
+cleanup:
+ LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
+ return ret;
+}
+
+/**
+ * @brief Compile leafref predicate. Actually, it is only checked.
+ *
+ * @param[in] ctx_node Context node, node for which the predicate is defined.
+ * @param[in] cur_node Current (original context) node.
+ * @param[in] expr Parsed path.
+ * @param[in,out] tok_idx Index in @p expr, is adjusted for parsed tokens.
+ * @param[in] format Format of the path.
+ * @param[in] prefix_data Format-specific data for resolving any prefixes (see ::ly_resolve_prefix).
+ * @return LY_ERR value.
+ */
+static LY_ERR
+ly_path_compile_predicate_leafref(const struct lysc_node *ctx_node, const struct lysc_node *cur_node,
+ const struct lyxp_expr *expr, uint32_t *tok_idx, LY_VALUE_FORMAT format, void *prefix_data)
+{
+ LY_ERR ret = LY_SUCCESS;
+ const struct lysc_node *key, *node, *node2;
+ struct ly_ctx *ctx = cur_node->module->ctx;
+
+ if (lyxp_next_token(NULL, expr, tok_idx, LYXP_TOKEN_BRACK1)) {
+ /* '[', no predicate */
+ goto cleanup; /* LY_SUCCESS */
+ }
+
+ if (ctx_node->nodetype != LYS_LIST) {
+ LOGVAL(ctx, LYVE_XPATH, "List predicate defined for %s \"%s\" in path.",
+ lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
+ ret = LY_EVALID;
+ goto cleanup;
+ } else if (ctx_node->flags & LYS_KEYLESS) {
+ LOGVAL(ctx, LYVE_XPATH, "List predicate defined for keyless %s \"%s\" in path.",
+ lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
+ ret = LY_EVALID;
+ goto cleanup;
+ }
+
+ do {
+ /* NameTest, find the key */
+ ret = ly_path_compile_snode(ctx, cur_node, cur_node->module, ctx_node, expr, *tok_idx, format, prefix_data,
+ NULL, 0, &key, NULL);
+ LY_CHECK_GOTO(ret, cleanup);
+ if ((key->nodetype != LYS_LEAF) || !(key->flags & LYS_KEY)) {
+ LOGVAL(ctx, LYVE_XPATH, "Key expected instead of %s \"%s\" in path.",
+ lys_nodetype2str(key->nodetype), key->name);
+ ret = LY_EVALID;
+ goto cleanup;
+ }
+ ++(*tok_idx);
+
+ /* we are not actually compiling, throw the key away */
+ (void)key;
+
+ /* '=' */
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL);
+ ++(*tok_idx);
+
+ /* FuncName */
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_FUNCNAME);
+ ++(*tok_idx);
+
+ /* evaluating from the "current()" node */
+ node = cur_node;
+
+ /* '(' */
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
+ ++(*tok_idx);
+
+ /* ')' */
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
+ ++(*tok_idx);
+
+ do {
+ /* '/' */
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH);
+ ++(*tok_idx);
+
+ /* go to parent */
+ if (!node) {
+ LOGVAL(ctx, LYVE_XPATH, "Too many parent references in path.");
+ ret = LY_EVALID;
+ goto cleanup;
+ }
+ node = lysc_data_parent(node);
+
+ /* '..' */
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_DDOT);
+ ++(*tok_idx);
+ } while (expr->tokens[*tok_idx + 1] == LYXP_TOKEN_DDOT);
+
+ do {
+ /* '/' */
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH);
+ ++(*tok_idx);
+
+ /* NameTest */
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_NAMETEST);
+ LY_CHECK_RET(ly_path_compile_snode(ctx, cur_node, cur_node->module, node, expr, *tok_idx, format,
+ prefix_data, NULL, 0, &node2, NULL));
+ node = node2;
+ ++(*tok_idx);
+ } while ((*tok_idx + 1 < expr->used) && (expr->tokens[*tok_idx + 1] == LYXP_TOKEN_NAMETEST));
+
+ /* check the last target node */
+ if (node->nodetype != LYS_LEAF) {
+ LOGVAL(ctx, LYVE_XPATH, "Leaf expected instead of %s \"%s\" in leafref predicate in path.",
+ lys_nodetype2str(node->nodetype), node->name);
+ ret = LY_EVALID;
+ goto cleanup;
+ }
+
+ /* we are not actually compiling, throw the rightside node away */
+ (void)node;
+
+ /* ']' */
+ assert(expr->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
+ ++(*tok_idx);
+
+ /* another predicate follows? */
+ } while (!lyxp_next_token(NULL, expr, tok_idx, LYXP_TOKEN_BRACK1));
+
+cleanup:
+ return (ret == LY_ENOTFOUND) ? LY_EVALID : ret;
+}
+
+/**
+ * @brief Compile path into ly_path structure. Any predicates of a leafref are only checked, not compiled.
+ *
+ * @param[in] ctx libyang context.
+ * @param[in] cur_mod Current module of the path (where it was "instantiated"), ignored of @p lref. Used for nodes
+ * without a prefix for ::LY_VALUE_SCHEMA and ::LY_VALUE_SCHEMA_RESOLVED format.
+ * @param[in] ctx_node Optional context node, mandatory of @p lref.
+ * @param[in] top_ext Extension instance containing the definition of the data being created. It is used to find the top-level
+ * node inside the extension instance instead of a module. Note that this is the case not only if the @p ctx_node is NULL,
+ * but also if the relative path starting in @p ctx_node reaches the document root via double dots.
+ * @param[in] expr Parsed path.
+ * @param[in] lref Whether leafref is being compiled or not.
+ * @param[in] oper Oper option (@ref path_oper_options).
+ * @param[in] target Target option (@ref path_target_options).
+ * @param[in] limit_access_tree Whether to limit accessible tree as described in
+ * [XPath context](https://datatracker.ietf.org/doc/html/rfc7950#section-6.4.1).
+ * @param[in] format Format of the path.
+ * @param[in] prefix_data Format-specific data for resolving any prefixes (see ::ly_resolve_prefix).
+ * @param[out] path Compiled path.
+ * @return LY_ERECOMPILE, only if @p lref.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+_ly_path_compile(const struct ly_ctx *ctx, const struct lys_module *cur_mod, const struct lysc_node *ctx_node,
+ const struct lysc_ext_instance *top_ext, const struct lyxp_expr *expr, ly_bool lref, uint8_t oper, uint8_t target,
+ ly_bool limit_access_tree, LY_VALUE_FORMAT format, void *prefix_data, struct ly_path **path)
+{
+ LY_ERR ret = LY_SUCCESS;
+ uint32_t tok_idx = 0, getnext_opts;
+ const struct lysc_node *node2, *cur_node, *op;
+ struct ly_path *p = NULL;
+ struct lysc_ext_instance *ext = NULL;
+
+ assert(ctx);
+ assert(!lref || ctx_node);
+ assert((oper == LY_PATH_OPER_INPUT) || (oper == LY_PATH_OPER_OUTPUT));
+ assert((target == LY_PATH_TARGET_SINGLE) || (target == LY_PATH_TARGET_MANY));
+
+ if (!limit_access_tree) {
+ op = NULL;
+ } else {
+ /* find operation, if we are in any */
+ for (op = ctx_node; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
+ }
+
+ *path = NULL;
+
+ /* remember original context node */
+ cur_node = ctx_node;
+ LOG_LOCSET(cur_node, NULL, NULL, NULL);
+
+ if (oper == LY_PATH_OPER_OUTPUT) {
+ getnext_opts = LYS_GETNEXT_OUTPUT;
+ } else {
+ getnext_opts = 0;
+ }
+
+ if (expr->tokens[tok_idx] == LYXP_TOKEN_OPER_PATH) {
+ /* absolute path */
+ ctx_node = NULL;
+
+ ++tok_idx;
+ } else {
+ /* relative path */
+ if (!ctx_node) {
+ LOGVAL(ctx, LYVE_XPATH, "No initial schema parent for a relative path.");
+ ret = LY_EVALID;
+ goto cleanup;
+ }
+
+ /* go up the parents for leafref */
+ while (lref && (expr->tokens[tok_idx] == LYXP_TOKEN_DDOT)) {
+ if (!ctx_node) {
+ LOGVAL(ctx, LYVE_XPATH, "Too many parent references in path.");
+ ret = LY_EVALID;
+ goto cleanup;
+ }
+
+ /* get parent */
+ ctx_node = lysc_data_parent(ctx_node);
+
+ ++tok_idx;
+
+ assert(expr->tokens[tok_idx] == LYXP_TOKEN_OPER_PATH);
+ ++tok_idx;
+ }
+ }
+
+ do {
+ /* check last compiled inner node, whether it is uniquely identified (even key-less list) */
+ if (p && !lref && (target == LY_PATH_TARGET_SINGLE) && (p->node->nodetype == LYS_LIST) && !p->predicates) {
+ LOGVAL(ctx, LYVE_XPATH, "Predicate missing for %s \"%s\" in path.",
+ lys_nodetype2str(p->node->nodetype), p->node->name);
+ ret = LY_EVALID;
+ goto cleanup;
+ }
+
+ /* NameTest */
+ LY_CHECK_ERR_GOTO(lyxp_check_token(ctx, expr, tok_idx, LYXP_TOKEN_NAMETEST), ret = LY_EVALID, cleanup);
+
+ /* get schema node */
+ LY_CHECK_GOTO(ret = ly_path_compile_snode(ctx, cur_node, cur_mod, ctx_node, expr, tok_idx, format, prefix_data,
+ top_ext, getnext_opts, &node2, &ext), cleanup);
+ ++tok_idx;
+ if ((op && (node2->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) && (node2 != op))) {
+ LOGVAL(ctx, LYVE_XPATH, "Not found node \"%s\" in path.", node2->name);
+ ret = LY_EVALID;
+ goto cleanup;
+ }
+ ctx_node = node2;
+
+ /* new path segment */
+ LY_ARRAY_NEW_GOTO(ctx, *path, p, ret, cleanup);
+ p->node = ctx_node;
+ p->ext = ext;
+
+ /* compile any predicates */
+ if (lref) {
+ ret = ly_path_compile_predicate_leafref(ctx_node, cur_node, expr, &tok_idx, format, prefix_data);
+ } else {
+ ret = ly_path_compile_predicate(ctx, cur_node, cur_mod, ctx_node, expr, &tok_idx, format, prefix_data,
+ &p->predicates, &p->pred_type);
+ }
+ LY_CHECK_GOTO(ret, cleanup);
+ } while (!lyxp_next_token(NULL, expr, &tok_idx, LYXP_TOKEN_OPER_PATH));
+
+ /* check leftover tokens */
+ if (tok_idx < expr->used) {
+ LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_token2str(expr->tokens[tok_idx]), &expr->expr[expr->tok_pos[tok_idx]]);
+ ret = LY_EVALID;
+ goto cleanup;
+ }
+
+ /* check last compiled node */
+ if (!lref && (target == LY_PATH_TARGET_SINGLE) && (p->node->nodetype & (LYS_LIST | LYS_LEAFLIST)) && !p->predicates) {
+ LOGVAL(ctx, LYVE_XPATH, "Predicate missing for %s \"%s\" in path.",
+ lys_nodetype2str(p->node->nodetype), p->node->name);
+ ret = LY_EVALID;
+ goto cleanup;
+ }
+
+cleanup:
+ if (ret) {
+ ly_path_free(ctx, *path);
+ *path = NULL;
+ }
+ LOG_LOCBACK(1, 0, 0, 0);
+ return (ret == LY_ENOTFOUND) ? LY_EVALID : ret;
+}
+
+LY_ERR
+ly_path_compile(const struct ly_ctx *ctx, const struct lys_module *cur_mod, const struct lysc_node *ctx_node,
+ const struct lysc_ext_instance *top_ext, const struct lyxp_expr *expr, uint8_t oper, uint8_t target,
+ ly_bool limit_access_tree, LY_VALUE_FORMAT format, void *prefix_data, struct ly_path **path)
+{
+ return _ly_path_compile(ctx, cur_mod, ctx_node, top_ext, expr, 0, oper, target, limit_access_tree, format,
+ prefix_data, path);
+}
+
+LY_ERR
+ly_path_compile_leafref(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const struct lysc_ext_instance *top_ext,
+ const struct lyxp_expr *expr, uint8_t oper, uint8_t target, LY_VALUE_FORMAT format, void *prefix_data,
+ struct ly_path **path)
+{
+ return _ly_path_compile(ctx, ctx_node->module, ctx_node, top_ext, expr, 1, oper, target, 1, format, prefix_data, path);
+}
+
+LY_ERR
+ly_path_eval_partial(const struct ly_path *path, const struct lyd_node *start, LY_ARRAY_COUNT_TYPE *path_idx,
+ struct lyd_node **match)
+{
+ LY_ARRAY_COUNT_TYPE u;
+ struct lyd_node *prev_node = NULL, *elem, *node = NULL, *target;
+ uint64_t pos;
+
+ assert(path && start);
+
+ if (lysc_data_parent(path[0].node)) {
+ /* relative path, start from the parent children */
+ start = lyd_child(start);
+ } else {
+ /* absolute path, start from the first top-level sibling */
+ while (start->parent) {
+ start = lyd_parent(start);
+ }
+ while (start->prev->next) {
+ start = start->prev;
+ }
+ }
+
+ LY_ARRAY_FOR(path, u) {
+ switch (path[u].pred_type) {
+ case LY_PATH_PREDTYPE_POSITION:
+ /* we cannot use hashes and want an instance on a specific position */
+ pos = 1;
+ node = NULL;
+ LYD_LIST_FOR_INST(start, path[u].node, elem) {
+ if (pos == path[u].predicates[0].position) {
+ node = elem;
+ break;
+ }
+ ++pos;
+ }
+ break;
+ case LY_PATH_PREDTYPE_LEAFLIST:
+ /* we will use hashes to find one leaf-list instance */
+ LY_CHECK_RET(lyd_create_term2(path[u].node, &path[u].predicates[0].value, &target));
+ lyd_find_sibling_first(start, target, &node);
+ lyd_free_tree(target);
+ break;
+ case LY_PATH_PREDTYPE_LIST:
+ /* we will use hashes to find one list instance */
+ LY_CHECK_RET(lyd_create_list(path[u].node, path[u].predicates, &target));
+ lyd_find_sibling_first(start, target, &node);
+ lyd_free_tree(target);
+ break;
+ case LY_PATH_PREDTYPE_NONE:
+ /* we will use hashes to find one any/container/leaf instance */
+ lyd_find_sibling_val(start, path[u].node, NULL, 0, &node);
+ break;
+ }
+
+ if (!node) {
+ /* no matching nodes */
+ break;
+ }
+
+ /* rememeber previous node */
+ prev_node = node;
+
+ /* next path segment, if any */
+ start = lyd_child(node);
+ }
+
+ if (node) {
+ /* we have found the full path */
+ if (path_idx) {
+ *path_idx = u;
+ }
+ if (match) {
+ *match = node;
+ }
+ return LY_SUCCESS;
+
+ } else if (prev_node) {
+ /* we have found only some partial match */
+ if (path_idx) {
+ *path_idx = u - 1;
+ }
+ if (match) {
+ *match = prev_node;
+ }
+ return LY_EINCOMPLETE;
+ }
+
+ /* we have not found any nodes */
+ if (path_idx) {
+ *path_idx = 0;
+ }
+ if (match) {
+ *match = NULL;
+ }
+ return LY_ENOTFOUND;
+}
+
+LY_ERR
+ly_path_eval(const struct ly_path *path, const struct lyd_node *start, struct lyd_node **match)
+{
+ LY_ERR ret;
+ struct lyd_node *m;
+
+ ret = ly_path_eval_partial(path, start, NULL, &m);
+
+ if (ret == LY_SUCCESS) {
+ /* last node was found */
+ if (match) {
+ *match = m;
+ }
+ return LY_SUCCESS;
+ }
+
+ /* not a full match */
+ if (match) {
+ *match = NULL;
+ }
+ return LY_ENOTFOUND;
+}
+
+LY_ERR
+ly_path_dup(const struct ly_ctx *ctx, const struct ly_path *path, struct ly_path **dup)
+{
+ LY_ARRAY_COUNT_TYPE u, v;
+
+ if (!path) {
+ return LY_SUCCESS;
+ }
+
+ LY_ARRAY_CREATE_RET(ctx, *dup, LY_ARRAY_COUNT(path), LY_EMEM);
+ LY_ARRAY_FOR(path, u) {
+ LY_ARRAY_INCREMENT(*dup);
+ (*dup)[u].node = path[u].node;
+ if (path[u].predicates) {
+ LY_ARRAY_CREATE_RET(ctx, (*dup)[u].predicates, LY_ARRAY_COUNT(path[u].predicates), LY_EMEM);
+ (*dup)[u].pred_type = path[u].pred_type;
+ LY_ARRAY_FOR(path[u].predicates, v) {
+ struct ly_path_predicate *pred = &path[u].predicates[v];
+
+ LY_ARRAY_INCREMENT((*dup)[u].predicates);
+ switch (path[u].pred_type) {
+ case LY_PATH_PREDTYPE_POSITION:
+ /* position-predicate */
+ (*dup)[u].predicates[v].position = pred->position;
+ break;
+ case LY_PATH_PREDTYPE_LIST:
+ case LY_PATH_PREDTYPE_LEAFLIST:
+ /* key-predicate or leaf-list-predicate */
+ (*dup)[u].predicates[v].key = pred->key;
+ pred->value.realtype->plugin->duplicate(ctx, &pred->value, &(*dup)[u].predicates[v].value);
+ LY_ATOMIC_INC_BARRIER(((struct lysc_type *)pred->value.realtype)->refcount);
+ break;
+ case LY_PATH_PREDTYPE_NONE:
+ break;
+ }
+ }
+ }
+ }
+
+ return LY_SUCCESS;
+}
+
+void
+ly_path_predicates_free(const struct ly_ctx *ctx, enum ly_path_pred_type pred_type, struct ly_path_predicate *predicates)
+{
+ LY_ARRAY_COUNT_TYPE u;
+ struct lysf_ctx fctx = {.ctx = (struct ly_ctx *)ctx};
+
+ if (!predicates) {
+ return;
+ }
+
+ LY_ARRAY_FOR(predicates, u) {
+ switch (pred_type) {
+ case LY_PATH_PREDTYPE_POSITION:
+ case LY_PATH_PREDTYPE_NONE:
+ /* nothing to free */
+ break;
+ case LY_PATH_PREDTYPE_LIST:
+ case LY_PATH_PREDTYPE_LEAFLIST:
+ if (predicates[u].value.realtype) {
+ predicates[u].value.realtype->plugin->free(ctx, &predicates[u].value);
+ lysc_type_free(&fctx, (struct lysc_type *)predicates[u].value.realtype);
+ }
+ break;
+ }
+ }
+ LY_ARRAY_FREE(predicates);
+}
+
+void
+ly_path_free(const struct ly_ctx *ctx, struct ly_path *path)
+{
+ LY_ARRAY_COUNT_TYPE u;
+
+ if (!path) {
+ return;
+ }
+
+ LY_ARRAY_FOR(path, u) {
+ ly_path_predicates_free(ctx, path[u].pred_type, path[u].predicates);
+ }
+ LY_ARRAY_FREE(path);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-03 23:30:06 +0000