blob: 2b0bcfe0de3a3a481b2671ffd86011df60a41917 [file] [log] [blame]
Radek Krejcib1646a92018-11-02 16:08:26 +01001/**
2 * @file xpath.c
3 * @author Michal Vasko <mvasko@cesnet.cz>
4 * @brief YANG XPath evaluation functions
5 *
Michal Vasko49fec8e2022-05-24 10:28:33 +02006 * Copyright (c) 2015 - 2022 CESNET, z.s.p.o.
Radek Krejcib1646a92018-11-02 16:08:26 +01007 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
Christian Hopps32874e12021-05-01 09:43:54 -040014#define _GNU_SOURCE /* asprintf, strdup */
Radek Krejcib1646a92018-11-02 16:08:26 +010015
Radek Krejci535ea9f2020-05-29 16:01:05 +020016#include "xpath.h"
Radek Krejcib1646a92018-11-02 16:08:26 +010017
Radek Krejci535ea9f2020-05-29 16:01:05 +020018#include <assert.h>
Radek Krejcib1646a92018-11-02 16:08:26 +010019#include <ctype.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020020#include <errno.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020021#include <math.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020022#include <stdint.h>
Radek Krejcib1646a92018-11-02 16:08:26 +010023#include <stdio.h>
24#include <stdlib.h>
Radek Krejcib1646a92018-11-02 16:08:26 +010025#include <string.h>
Radek Krejcib1646a92018-11-02 16:08:26 +010026
Radek Krejci535ea9f2020-05-29 16:01:05 +020027#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020028#include "compat.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020029#include "context.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020030#include "dict.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020031#include "hash_table.h"
Radek Krejci47fab892020-11-05 17:02:41 +010032#include "out.h"
Radek Krejci7931b192020-06-25 17:05:03 +020033#include "parser_data.h"
Michal Vasko004d3152020-06-11 19:59:22 +020034#include "path.h"
Michal Vasko03ff5a72019-09-11 13:49:33 +020035#include "plugins_types.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020036#include "printer_data.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020037#include "schema_compile_node.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020038#include "tree.h"
Radek Krejci77114102021-03-10 15:21:57 +010039#include "tree_data.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020040#include "tree_data_internal.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010041#include "tree_edit.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020042#include "tree_schema_internal.h"
43#include "xml.h"
Michal Vasko03ff5a72019-09-11 13:49:33 +020044
Michal Vasko7333cb32022-07-29 16:30:29 +020045static LY_ERR set_scnode_insert_node(struct lyxp_set *set, const struct lysc_node *node, enum lyxp_node_type node_type,
46 enum lyxp_axis axis, uint32_t *index_p);
Michal Vaskodd528af2022-08-08 14:35:07 +020047static LY_ERR reparse_or_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth);
48static LY_ERR eval_expr_select(const struct lyxp_expr *exp, uint32_t *tok_idx, enum lyxp_expr_type etype,
Michal Vasko40308e72020-10-20 16:38:40 +020049 struct lyxp_set *set, uint32_t options);
Michal Vaskofe1af042022-07-29 14:58:59 +020050static LY_ERR moveto_resolve_model(const char **qname, uint32_t *qname_len, const struct lyxp_set *set,
Michal Vasko93923692021-05-07 15:28:02 +020051 const struct lysc_node *ctx_scnode, const struct lys_module **moveto_mod);
Michal Vasko47da6562022-07-14 15:43:15 +020052static LY_ERR moveto_axis_node_next(const struct lyd_node **iter, enum lyxp_node_type *iter_type,
53 const struct lyd_node *node, enum lyxp_node_type node_type, enum lyxp_axis axis, struct lyxp_set *set);
Michal Vasko49fec8e2022-05-24 10:28:33 +020054static LY_ERR moveto_node(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname,
55 enum lyxp_axis axis, uint32_t options);
56static LY_ERR moveto_scnode(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname,
57 enum lyxp_axis axis, uint32_t options);
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +020058static LY_ERR moveto_op_comp(struct lyxp_set *set1, struct lyxp_set *set2, const char *op, ly_bool *result);
Michal Vasko03ff5a72019-09-11 13:49:33 +020059
aPiecek96dc1e32021-10-08 15:45:59 +020060/* Functions are divided into the following basic classes:
61 *
62 * (re)parse functions:
63 * Parse functions parse the expression into
64 * tokens (syntactic analysis).
65 * Reparse functions perform semantic analysis
66 * (do not save the result, just a check) of
67 * the expression and fill repeat indices.
68 *
69 * warn functions:
70 * Warn functions check specific reasonable conditions for schema XPath
71 * and print a warning if they are not satisfied.
72 *
73 * moveto functions:
74 * They and only they actually change the context (set).
75 *
76 * eval functions:
77 * They execute a parsed XPath expression on some data subtree.
78 */
79
Michal Vasko03ff5a72019-09-11 13:49:33 +020080/**
81 * @brief Print the type of an XPath \p set.
82 *
83 * @param[in] set Set to use.
84 * @return Set type string.
85 */
86static const char *
87print_set_type(struct lyxp_set *set)
88{
89 switch (set->type) {
Michal Vasko03ff5a72019-09-11 13:49:33 +020090 case LYXP_SET_NODE_SET:
91 return "node set";
92 case LYXP_SET_SCNODE_SET:
93 return "schema node set";
94 case LYXP_SET_BOOLEAN:
95 return "boolean";
96 case LYXP_SET_NUMBER:
97 return "number";
98 case LYXP_SET_STRING:
99 return "string";
100 }
101
102 return NULL;
103}
104
Michal Vasko24cddf82020-06-01 08:17:01 +0200105const char *
Michal Vasko49fec8e2022-05-24 10:28:33 +0200106lyxp_token2str(enum lyxp_token tok)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200107{
108 switch (tok) {
109 case LYXP_TOKEN_PAR1:
110 return "(";
111 case LYXP_TOKEN_PAR2:
112 return ")";
113 case LYXP_TOKEN_BRACK1:
114 return "[";
115 case LYXP_TOKEN_BRACK2:
116 return "]";
117 case LYXP_TOKEN_DOT:
118 return ".";
119 case LYXP_TOKEN_DDOT:
120 return "..";
121 case LYXP_TOKEN_AT:
122 return "@";
123 case LYXP_TOKEN_COMMA:
124 return ",";
125 case LYXP_TOKEN_NAMETEST:
126 return "NameTest";
127 case LYXP_TOKEN_NODETYPE:
128 return "NodeType";
aPiecekfba75362021-10-07 12:39:48 +0200129 case LYXP_TOKEN_VARREF:
130 return "VariableReference";
Michal Vasko03ff5a72019-09-11 13:49:33 +0200131 case LYXP_TOKEN_FUNCNAME:
132 return "FunctionName";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200133 case LYXP_TOKEN_OPER_LOG:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200134 return "Operator(Logic)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200135 case LYXP_TOKEN_OPER_EQUAL:
136 return "Operator(Equal)";
137 case LYXP_TOKEN_OPER_NEQUAL:
138 return "Operator(Non-equal)";
139 case LYXP_TOKEN_OPER_COMP:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200140 return "Operator(Comparison)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200141 case LYXP_TOKEN_OPER_MATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200142 return "Operator(Math)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200143 case LYXP_TOKEN_OPER_UNI:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200144 return "Operator(Union)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200145 case LYXP_TOKEN_OPER_PATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200146 return "Operator(Path)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200147 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko14676352020-05-29 11:35:55 +0200148 return "Operator(Recursive Path)";
Michal Vasko03ff5a72019-09-11 13:49:33 +0200149 case LYXP_TOKEN_LITERAL:
150 return "Literal";
151 case LYXP_TOKEN_NUMBER:
152 return "Number";
153 default:
154 LOGINT(NULL);
155 return "";
156 }
157}
158
159/**
Michal Vasko49fec8e2022-05-24 10:28:33 +0200160 * @brief Transform string into an axis.
161 *
162 * @param[in] str String to transform.
163 * @param[in] str_len Length of @p str.
164 * @return Transformed axis.
165 */
166static enum lyxp_axis
Michal Vaskodd528af2022-08-08 14:35:07 +0200167str2axis(const char *str, uint32_t str_len)
Michal Vasko49fec8e2022-05-24 10:28:33 +0200168{
169 switch (str_len) {
170 case 4:
171 assert(!strncmp("self", str, str_len));
172 return LYXP_AXIS_SELF;
173 case 5:
174 assert(!strncmp("child", str, str_len));
175 return LYXP_AXIS_CHILD;
176 case 6:
177 assert(!strncmp("parent", str, str_len));
178 return LYXP_AXIS_PARENT;
179 case 8:
180 assert(!strncmp("ancestor", str, str_len));
181 return LYXP_AXIS_ANCESTOR;
182 case 9:
183 if (str[0] == 'a') {
184 assert(!strncmp("attribute", str, str_len));
185 return LYXP_AXIS_ATTRIBUTE;
186 } else if (str[0] == 'f') {
187 assert(!strncmp("following", str, str_len));
188 return LYXP_AXIS_FOLLOWING;
189 } else {
190 assert(!strncmp("preceding", str, str_len));
191 return LYXP_AXIS_PRECEDING;
192 }
193 break;
194 case 10:
195 assert(!strncmp("descendant", str, str_len));
196 return LYXP_AXIS_DESCENDANT;
197 case 16:
198 assert(!strncmp("ancestor-or-self", str, str_len));
199 return LYXP_AXIS_ANCESTOR_OR_SELF;
200 case 17:
201 if (str[0] == 'f') {
202 assert(!strncmp("following-sibling", str, str_len));
203 return LYXP_AXIS_FOLLOWING_SIBLING;
204 } else {
205 assert(!strncmp("preceding-sibling", str, str_len));
206 return LYXP_AXIS_PRECEDING_SIBLING;
207 }
208 break;
209 case 18:
210 assert(!strncmp("descendant-or-self", str, str_len));
211 return LYXP_AXIS_DESCENDANT_OR_SELF;
212 }
213
214 LOGINT(NULL);
215 return 0;
216}
217
218/**
Michal Vasko03ff5a72019-09-11 13:49:33 +0200219 * @brief Print the whole expression \p exp to debug output.
220 *
221 * @param[in] exp Expression to use.
222 */
223static void
Michal Vasko40308e72020-10-20 16:38:40 +0200224print_expr_struct_debug(const struct lyxp_expr *exp)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200225{
Radek Krejcif13b87b2020-12-01 22:02:17 +0100226#define MSG_BUFFER_SIZE 128
227 char tmp[MSG_BUFFER_SIZE];
Michal Vasko1fdd8fa2021-01-08 09:21:45 +0100228 uint32_t i, j;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200229
Radek Krejci52b6d512020-10-12 12:33:17 +0200230 if (!exp || (ly_ll < LY_LLDBG)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200231 return;
232 }
233
234 LOGDBG(LY_LDGXPATH, "expression \"%s\":", exp->expr);
235 for (i = 0; i < exp->used; ++i) {
Michal Vasko49fec8e2022-05-24 10:28:33 +0200236 sprintf(tmp, "\ttoken %s, in expression \"%.*s\"", lyxp_token2str(exp->tokens[i]), exp->tok_len[i],
Michal Vasko69730152020-10-09 16:30:07 +0200237 &exp->expr[exp->tok_pos[i]]);
Michal Vasko23049552021-03-04 15:57:44 +0100238 if (exp->repeat && exp->repeat[i]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200239 sprintf(tmp + strlen(tmp), " (repeat %d", exp->repeat[i][0]);
240 for (j = 1; exp->repeat[i][j]; ++j) {
241 sprintf(tmp + strlen(tmp), ", %d", exp->repeat[i][j]);
242 }
243 strcat(tmp, ")");
244 }
245 LOGDBG(LY_LDGXPATH, tmp);
246 }
Radek Krejcif13b87b2020-12-01 22:02:17 +0100247#undef MSG_BUFFER_SIZE
Michal Vasko03ff5a72019-09-11 13:49:33 +0200248}
249
250#ifndef NDEBUG
251
252/**
253 * @brief Print XPath set content to debug output.
254 *
255 * @param[in] set Set to print.
256 */
257static void
258print_set_debug(struct lyxp_set *set)
259{
260 uint32_t i;
261 char *str;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200262 struct lyxp_set_node *item;
263 struct lyxp_set_scnode *sitem;
264
Radek Krejci52b6d512020-10-12 12:33:17 +0200265 if (ly_ll < LY_LLDBG) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200266 return;
267 }
268
269 switch (set->type) {
270 case LYXP_SET_NODE_SET:
271 LOGDBG(LY_LDGXPATH, "set NODE SET:");
272 for (i = 0; i < set->used; ++i) {
273 item = &set->val.nodes[i];
274
275 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +0100276 case LYXP_NODE_NONE:
277 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): NONE", i + 1, item->pos);
278 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200279 case LYXP_NODE_ROOT:
280 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ROOT", i + 1, item->pos);
281 break;
282 case LYXP_NODE_ROOT_CONFIG:
283 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ROOT CONFIG", i + 1, item->pos);
284 break;
285 case LYXP_NODE_ELEM:
Michal Vasko9e685082021-01-29 14:49:09 +0100286 if ((item->node->schema->nodetype == LYS_LIST) && (lyd_child(item->node)->schema->nodetype == LYS_LEAF)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200287 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s (1st child val: %s)", i + 1, item->pos,
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200288 item->node->schema->name, lyd_get_value(lyd_child(item->node)));
Michal Vasko9e685082021-01-29 14:49:09 +0100289 } else if (item->node->schema->nodetype == LYS_LEAFLIST) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200290 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s (val: %s)", i + 1, item->pos,
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200291 item->node->schema->name, lyd_get_value(item->node));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200292 } else {
293 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s", i + 1, item->pos, item->node->schema->name);
294 }
295 break;
296 case LYXP_NODE_TEXT:
297 if (item->node->schema->nodetype & LYS_ANYDATA) {
298 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): TEXT <%s>", i + 1, item->pos,
Michal Vasko69730152020-10-09 16:30:07 +0200299 item->node->schema->nodetype == LYS_ANYXML ? "anyxml" : "anydata");
Michal Vasko03ff5a72019-09-11 13:49:33 +0200300 } else {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200301 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): TEXT %s", i + 1, item->pos, lyd_get_value(item->node));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200302 }
303 break;
Michal Vasko9f96a052020-03-10 09:41:45 +0100304 case LYXP_NODE_META:
305 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): META %s = %s", i + 1, item->pos, set->val.meta[i].meta->name,
Michal Vasko69730152020-10-09 16:30:07 +0200306 set->val.meta[i].meta->value);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200307 break;
308 }
309 }
310 break;
311
312 case LYXP_SET_SCNODE_SET:
313 LOGDBG(LY_LDGXPATH, "set SCNODE SET:");
314 for (i = 0; i < set->used; ++i) {
315 sitem = &set->val.scnodes[i];
316
317 switch (sitem->type) {
318 case LYXP_NODE_ROOT:
319 LOGDBG(LY_LDGXPATH, "\t%d (%u): ROOT", i + 1, sitem->in_ctx);
320 break;
321 case LYXP_NODE_ROOT_CONFIG:
322 LOGDBG(LY_LDGXPATH, "\t%d (%u): ROOT CONFIG", i + 1, sitem->in_ctx);
323 break;
324 case LYXP_NODE_ELEM:
325 LOGDBG(LY_LDGXPATH, "\t%d (%u): ELEM %s", i + 1, sitem->in_ctx, sitem->scnode->name);
326 break;
327 default:
328 LOGINT(NULL);
329 break;
330 }
331 }
332 break;
333
Michal Vasko03ff5a72019-09-11 13:49:33 +0200334 case LYXP_SET_BOOLEAN:
335 LOGDBG(LY_LDGXPATH, "set BOOLEAN");
Michal Vasko004d3152020-06-11 19:59:22 +0200336 LOGDBG(LY_LDGXPATH, "\t%s", (set->val.bln ? "true" : "false"));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200337 break;
338
339 case LYXP_SET_STRING:
340 LOGDBG(LY_LDGXPATH, "set STRING");
341 LOGDBG(LY_LDGXPATH, "\t%s", set->val.str);
342 break;
343
344 case LYXP_SET_NUMBER:
345 LOGDBG(LY_LDGXPATH, "set NUMBER");
346
347 if (isnan(set->val.num)) {
348 str = strdup("NaN");
349 } else if ((set->val.num == 0) || (set->val.num == -0.0f)) {
350 str = strdup("0");
351 } else if (isinf(set->val.num) && !signbit(set->val.num)) {
352 str = strdup("Infinity");
353 } else if (isinf(set->val.num) && signbit(set->val.num)) {
354 str = strdup("-Infinity");
355 } else if ((long long)set->val.num == set->val.num) {
356 if (asprintf(&str, "%lld", (long long)set->val.num) == -1) {
357 str = NULL;
358 }
359 } else {
360 if (asprintf(&str, "%03.1Lf", set->val.num) == -1) {
361 str = NULL;
362 }
363 }
364 LY_CHECK_ERR_RET(!str, LOGMEM(NULL), );
365
366 LOGDBG(LY_LDGXPATH, "\t%s", str);
367 free(str);
368 }
369}
370
371#endif
372
373/**
374 * @brief Realloc the string \p str.
375 *
376 * @param[in] ctx libyang context for logging.
377 * @param[in] needed How much free space is required.
378 * @param[in,out] str Pointer to the string to use.
379 * @param[in,out] used Used bytes in \p str.
380 * @param[in,out] size Allocated bytes in \p str.
381 * @return LY_ERR
382 */
383static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +0200384cast_string_realloc(const struct ly_ctx *ctx, uint64_t needed, char **str, uint32_t *used, uint32_t *size)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200385{
Michal Vasko2291ab92022-08-08 08:53:12 +0200386 if (*size - (unsigned)*used < needed) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200387 do {
Michal Vaskodd528af2022-08-08 14:35:07 +0200388 if ((UINT32_MAX - *size) < LYXP_STRING_CAST_SIZE_STEP) {
389 LOGERR(ctx, LY_EINVAL, "XPath string length limit (%" PRIu32 ") reached.", UINT32_MAX);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200390 return LY_EINVAL;
391 }
392 *size += LYXP_STRING_CAST_SIZE_STEP;
Michal Vasko2291ab92022-08-08 08:53:12 +0200393 } while (*size - (unsigned)*used < needed);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200394 *str = ly_realloc(*str, *size * sizeof(char));
395 LY_CHECK_ERR_RET(!(*str), LOGMEM(ctx), LY_EMEM);
396 }
397
398 return LY_SUCCESS;
399}
400
401/**
402 * @brief Cast nodes recursively to one string @p str.
403 *
Michal Vasko47da6562022-07-14 15:43:15 +0200404 * @param[in] node Node to cast, NULL if root.
405 * @param[in] set XPath set.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200406 * @param[in] indent Current indent.
407 * @param[in,out] str Resulting string.
408 * @param[in,out] used Used bytes in @p str.
409 * @param[in,out] size Allocated bytes in @p str.
Michal Vasko47da6562022-07-14 15:43:15 +0200410 * @return LY_ERR value.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200411 */
412static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +0200413cast_string_recursive(const struct lyd_node *node, struct lyxp_set *set, uint32_t indent, char **str, uint32_t *used,
414 uint32_t *size)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200415{
Radek Krejci7f769d72020-07-11 23:13:56 +0200416 char *buf, *line, *ptr = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200417 const char *value_str;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200418 const struct lyd_node *child;
Michal Vasko47da6562022-07-14 15:43:15 +0200419 enum lyxp_node_type child_type;
Michal Vasko60ea6352020-06-29 13:39:39 +0200420 struct lyd_node *tree;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200421 struct lyd_node_any *any;
422 LY_ERR rc;
423
Michal Vasko47da6562022-07-14 15:43:15 +0200424 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && node && (node->schema->flags & LYS_CONFIG_R)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200425 return LY_SUCCESS;
426 }
427
Michal Vasko47da6562022-07-14 15:43:15 +0200428 if (!node) {
429 /* fake container */
430 LY_CHECK_RET(cast_string_realloc(set->ctx, 1, str, used, size));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200431 strcpy(*str + (*used - 1), "\n");
432 ++(*used);
433
434 ++indent;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200435
Michal Vasko47da6562022-07-14 15:43:15 +0200436 /* print all the top-level nodes */
437 child = NULL;
438 child_type = 0;
439 while (!moveto_axis_node_next(&child, &child_type, NULL, set->root_type, LYXP_AXIS_CHILD, set)) {
440 LY_CHECK_RET(cast_string_recursive(child, set, indent, str, used, size));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200441 }
442
Michal Vasko47da6562022-07-14 15:43:15 +0200443 /* end fake container */
444 LY_CHECK_RET(cast_string_realloc(set->ctx, 1, str, used, size));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200445 strcpy(*str + (*used - 1), "\n");
446 ++(*used);
447
448 --indent;
Michal Vasko47da6562022-07-14 15:43:15 +0200449 } else {
450 switch (node->schema->nodetype) {
451 case LYS_CONTAINER:
452 case LYS_LIST:
453 case LYS_RPC:
454 case LYS_NOTIF:
455 LY_CHECK_RET(cast_string_realloc(set->ctx, 1, str, used, size));
456 strcpy(*str + (*used - 1), "\n");
457 ++(*used);
458
459 for (child = lyd_child(node); child; child = child->next) {
460 LY_CHECK_RET(cast_string_recursive(child, set, indent + 1, str, used, size));
461 }
462
463 break;
464
465 case LYS_LEAF:
466 case LYS_LEAFLIST:
467 value_str = lyd_get_value(node);
468
469 /* print indent */
470 LY_CHECK_RET(cast_string_realloc(set->ctx, indent * 2 + strlen(value_str) + 1, str, used, size));
471 memset(*str + (*used - 1), ' ', indent * 2);
472 *used += indent * 2;
473
474 /* print value */
475 if (*used == 1) {
476 sprintf(*str + (*used - 1), "%s", value_str);
477 *used += strlen(value_str);
478 } else {
479 sprintf(*str + (*used - 1), "%s\n", value_str);
480 *used += strlen(value_str) + 1;
481 }
482
483 break;
484
485 case LYS_ANYXML:
486 case LYS_ANYDATA:
487 any = (struct lyd_node_any *)node;
488 if (!(void *)any->value.tree) {
489 /* no content */
490 buf = strdup("");
491 LY_CHECK_ERR_RET(!buf, LOGMEM(set->ctx), LY_EMEM);
492 } else {
493 struct ly_out *out;
494
495 if (any->value_type == LYD_ANYDATA_LYB) {
496 /* try to parse it into a data tree */
497 if (lyd_parse_data_mem((struct ly_ctx *)set->ctx, any->value.mem, LYD_LYB,
498 LYD_PARSE_ONLY | LYD_PARSE_STRICT, 0, &tree) == LY_SUCCESS) {
499 /* successfully parsed */
500 free(any->value.mem);
501 any->value.tree = tree;
502 any->value_type = LYD_ANYDATA_DATATREE;
503 }
504 /* error is covered by the following switch where LYD_ANYDATA_LYB causes failure */
505 }
506
507 switch (any->value_type) {
508 case LYD_ANYDATA_STRING:
509 case LYD_ANYDATA_XML:
510 case LYD_ANYDATA_JSON:
511 buf = strdup(any->value.json);
512 LY_CHECK_ERR_RET(!buf, LOGMEM(set->ctx), LY_EMEM);
513 break;
514 case LYD_ANYDATA_DATATREE:
515 LY_CHECK_RET(ly_out_new_memory(&buf, 0, &out));
516 rc = lyd_print_all(out, any->value.tree, LYD_XML, 0);
517 ly_out_free(out, NULL, 0);
518 LY_CHECK_RET(rc < 0, -rc);
519 break;
520 case LYD_ANYDATA_LYB:
521 LOGERR(set->ctx, LY_EINVAL, "Cannot convert LYB anydata into string.");
522 return LY_EINVAL;
523 }
524 }
525
526 line = strtok_r(buf, "\n", &ptr);
527 do {
528 rc = cast_string_realloc(set->ctx, indent * 2 + strlen(line) + 1, str, used, size);
529 if (rc != LY_SUCCESS) {
530 free(buf);
531 return rc;
532 }
533 memset(*str + (*used - 1), ' ', indent * 2);
534 *used += indent * 2;
535
536 strcpy(*str + (*used - 1), line);
537 *used += strlen(line);
538
539 strcpy(*str + (*used - 1), "\n");
540 *used += 1;
541 } while ((line = strtok_r(NULL, "\n", &ptr)));
542
543 free(buf);
544 break;
545
546 default:
547 LOGINT_RET(set->ctx);
548 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200549 }
550
551 return LY_SUCCESS;
552}
553
554/**
555 * @brief Cast an element into a string.
556 *
Michal Vasko47da6562022-07-14 15:43:15 +0200557 * @param[in] node Node to cast, NULL if root.
558 * @param[in] set XPath set.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200559 * @param[out] str Element cast to dynamically-allocated string.
560 * @return LY_ERR
561 */
562static LY_ERR
Michal Vasko47da6562022-07-14 15:43:15 +0200563cast_string_elem(const struct lyd_node *node, struct lyxp_set *set, char **str)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200564{
Michal Vaskodd528af2022-08-08 14:35:07 +0200565 uint32_t used, size;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200566 LY_ERR rc;
567
568 *str = malloc(LYXP_STRING_CAST_SIZE_START * sizeof(char));
Michal Vasko47da6562022-07-14 15:43:15 +0200569 LY_CHECK_ERR_RET(!*str, LOGMEM(set->ctx), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200570 (*str)[0] = '\0';
571 used = 1;
572 size = LYXP_STRING_CAST_SIZE_START;
573
Michal Vasko47da6562022-07-14 15:43:15 +0200574 rc = cast_string_recursive(node, set, 0, str, &used, &size);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200575 if (rc != LY_SUCCESS) {
576 free(*str);
577 return rc;
578 }
579
580 if (size > used) {
581 *str = ly_realloc(*str, used * sizeof(char));
Michal Vasko47da6562022-07-14 15:43:15 +0200582 LY_CHECK_ERR_RET(!*str, LOGMEM(set->ctx), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200583 }
584 return LY_SUCCESS;
585}
586
587/**
588 * @brief Cast a LYXP_SET_NODE_SET set into a string.
589 * Context position aware.
590 *
591 * @param[in] set Set to cast.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200592 * @param[out] str Cast dynamically-allocated string.
593 * @return LY_ERR
594 */
595static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100596cast_node_set_to_string(struct lyxp_set *set, char **str)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200597{
Michal Vaskoaa677062021-03-09 13:52:53 +0100598 if (!set->used) {
599 *str = strdup("");
600 if (!*str) {
601 LOGMEM_RET(set->ctx);
602 }
603 return LY_SUCCESS;
604 }
605
Michal Vasko03ff5a72019-09-11 13:49:33 +0200606 switch (set->val.nodes[0].type) {
Michal Vasko2caefc12019-11-14 16:07:56 +0100607 case LYXP_NODE_NONE:
608 /* invalid */
609 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200610 case LYXP_NODE_ROOT:
611 case LYXP_NODE_ROOT_CONFIG:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200612 case LYXP_NODE_ELEM:
613 case LYXP_NODE_TEXT:
Michal Vasko47da6562022-07-14 15:43:15 +0200614 return cast_string_elem(set->val.nodes[0].node, set, str);
Michal Vasko9f96a052020-03-10 09:41:45 +0100615 case LYXP_NODE_META:
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200616 *str = strdup(lyd_get_meta_value(set->val.meta[0].meta));
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200617 if (!*str) {
618 LOGMEM_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200619 }
620 return LY_SUCCESS;
621 }
622
623 LOGINT_RET(set->ctx);
624}
625
626/**
627 * @brief Cast a string into an XPath number.
628 *
629 * @param[in] str String to use.
630 * @return Cast number.
631 */
632static long double
633cast_string_to_number(const char *str)
634{
635 long double num;
636 char *ptr;
637
638 errno = 0;
639 num = strtold(str, &ptr);
640 if (errno || *ptr) {
641 num = NAN;
642 }
643 return num;
644}
645
646/**
647 * @brief Callback for checking value equality.
648 *
Michal Vasko62524a92021-02-26 10:08:50 +0100649 * Implementation of ::lyht_value_equal_cb.
Radek Krejci857189e2020-09-01 13:26:36 +0200650 *
Michal Vasko03ff5a72019-09-11 13:49:33 +0200651 * @param[in] val1_p First value.
652 * @param[in] val2_p Second value.
653 * @param[in] mod Whether hash table is being modified.
654 * @param[in] cb_data Callback data.
Radek Krejci857189e2020-09-01 13:26:36 +0200655 * @return Boolean value whether values are equal or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200656 */
Radek Krejci857189e2020-09-01 13:26:36 +0200657static ly_bool
658set_values_equal_cb(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *UNUSED(cb_data))
Michal Vasko03ff5a72019-09-11 13:49:33 +0200659{
660 struct lyxp_set_hash_node *val1, *val2;
661
662 val1 = (struct lyxp_set_hash_node *)val1_p;
663 val2 = (struct lyxp_set_hash_node *)val2_p;
664
665 if ((val1->node == val2->node) && (val1->type == val2->type)) {
666 return 1;
667 }
668
669 return 0;
670}
671
672/**
673 * @brief Insert node and its hash into set.
674 *
675 * @param[in] set et to insert to.
676 * @param[in] node Node with hash.
677 * @param[in] type Node type.
678 */
679static void
680set_insert_node_hash(struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type)
681{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200682 LY_ERR r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200683 uint32_t i, hash;
684 struct lyxp_set_hash_node hnode;
685
686 if (!set->ht && (set->used >= LYD_HT_MIN_ITEMS)) {
687 /* create hash table and add all the nodes */
688 set->ht = lyht_new(1, sizeof(struct lyxp_set_hash_node), set_values_equal_cb, NULL, 1);
689 for (i = 0; i < set->used; ++i) {
690 hnode.node = set->val.nodes[i].node;
691 hnode.type = set->val.nodes[i].type;
692
693 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
694 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
695 hash = dict_hash_multi(hash, NULL, 0);
696
697 r = lyht_insert(set->ht, &hnode, hash, NULL);
698 assert(!r);
699 (void)r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200700
Michal Vasko9d6befd2019-12-11 14:56:56 +0100701 if (hnode.node == node) {
702 /* it was just added, do not add it twice */
703 node = NULL;
704 }
705 }
706 }
707
708 if (set->ht && node) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200709 /* add the new node into hash table */
710 hnode.node = node;
711 hnode.type = type;
712
713 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
714 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
715 hash = dict_hash_multi(hash, NULL, 0);
716
717 r = lyht_insert(set->ht, &hnode, hash, NULL);
718 assert(!r);
719 (void)r;
720 }
721}
722
723/**
724 * @brief Remove node and its hash from set.
725 *
726 * @param[in] set Set to remove from.
727 * @param[in] node Node to remove.
728 * @param[in] type Node type.
729 */
730static void
731set_remove_node_hash(struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type)
732{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200733 LY_ERR r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200734 struct lyxp_set_hash_node hnode;
735 uint32_t hash;
736
737 if (set->ht) {
738 hnode.node = node;
739 hnode.type = type;
740
741 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
742 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
743 hash = dict_hash_multi(hash, NULL, 0);
744
745 r = lyht_remove(set->ht, &hnode, hash);
746 assert(!r);
747 (void)r;
748
749 if (!set->ht->used) {
750 lyht_free(set->ht);
751 set->ht = NULL;
752 }
753 }
754}
755
756/**
757 * @brief Check whether node is in set based on its hash.
758 *
759 * @param[in] set Set to search in.
760 * @param[in] node Node to search for.
761 * @param[in] type Node type.
762 * @param[in] skip_idx Index in @p set to skip.
763 * @return LY_ERR
764 */
765static LY_ERR
766set_dup_node_hash_check(const struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type, int skip_idx)
767{
768 struct lyxp_set_hash_node hnode, *match_p;
769 uint32_t hash;
770
771 hnode.node = node;
772 hnode.type = type;
773
774 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
775 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
776 hash = dict_hash_multi(hash, NULL, 0);
777
778 if (!lyht_find(set->ht, &hnode, hash, (void **)&match_p)) {
779 if ((skip_idx > -1) && (set->val.nodes[skip_idx].node == match_p->node) && (set->val.nodes[skip_idx].type == match_p->type)) {
780 /* we found it on the index that should be skipped, find another */
781 hnode = *match_p;
782 if (lyht_find_next(set->ht, &hnode, hash, (void **)&match_p)) {
783 /* none other found */
784 return LY_SUCCESS;
785 }
786 }
787
788 return LY_EEXIST;
789 }
790
791 /* not found */
792 return LY_SUCCESS;
793}
794
Michal Vaskod3678892020-05-21 10:06:58 +0200795void
796lyxp_set_free_content(struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200797{
798 if (!set) {
799 return;
800 }
801
802 if (set->type == LYXP_SET_NODE_SET) {
803 free(set->val.nodes);
804 lyht_free(set->ht);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200805 } else if (set->type == LYXP_SET_SCNODE_SET) {
806 free(set->val.scnodes);
Michal Vaskod3678892020-05-21 10:06:58 +0200807 lyht_free(set->ht);
808 } else {
809 if (set->type == LYXP_SET_STRING) {
810 free(set->val.str);
811 }
812 set->type = LYXP_SET_NODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200813 }
Michal Vaskod3678892020-05-21 10:06:58 +0200814
815 set->val.nodes = NULL;
816 set->used = 0;
817 set->size = 0;
818 set->ht = NULL;
819 set->ctx_pos = 0;
aPiecek748da732021-06-01 09:56:43 +0200820 set->ctx_size = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200821}
822
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100823/**
824 * @brief Free dynamically-allocated set.
825 *
826 * @param[in] set Set to free.
827 */
828static void
Michal Vasko03ff5a72019-09-11 13:49:33 +0200829lyxp_set_free(struct lyxp_set *set)
830{
831 if (!set) {
832 return;
833 }
834
Michal Vaskod3678892020-05-21 10:06:58 +0200835 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200836 free(set);
837}
838
839/**
840 * @brief Initialize set context.
841 *
842 * @param[in] new Set to initialize.
843 * @param[in] set Arbitrary initialized set.
844 */
845static void
Michal Vasko4c7763f2020-07-27 17:40:37 +0200846set_init(struct lyxp_set *new, const struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200847{
848 memset(new, 0, sizeof *new);
Michal Vasko02a77382019-09-12 11:47:35 +0200849 if (set) {
Michal Vasko306e2832022-07-25 09:15:17 +0200850 new->non_child_axis = set->non_child_axis;
Michal Vasko02a77382019-09-12 11:47:35 +0200851 new->ctx = set->ctx;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200852 new->cur_node = set->cur_node;
Michal Vasko588112f2019-12-10 14:51:53 +0100853 new->root_type = set->root_type;
Michal Vasko6b26e742020-07-17 15:02:10 +0200854 new->context_op = set->context_op;
Michal Vaskof03ed032020-03-04 13:31:44 +0100855 new->tree = set->tree;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200856 new->cur_mod = set->cur_mod;
Michal Vasko02a77382019-09-12 11:47:35 +0200857 new->format = set->format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200858 new->prefix_data = set->prefix_data;
aPiecekfba75362021-10-07 12:39:48 +0200859 new->vars = set->vars;
Michal Vasko02a77382019-09-12 11:47:35 +0200860 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200861}
862
863/**
864 * @brief Create a deep copy of a set.
865 *
866 * @param[in] set Set to copy.
867 * @return Copy of @p set.
868 */
869static struct lyxp_set *
870set_copy(struct lyxp_set *set)
871{
872 struct lyxp_set *ret;
Michal Vasko1fdd8fa2021-01-08 09:21:45 +0100873 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200874
875 if (!set) {
876 return NULL;
877 }
878
879 ret = malloc(sizeof *ret);
880 LY_CHECK_ERR_RET(!ret, LOGMEM(set->ctx), NULL);
881 set_init(ret, set);
882
883 if (set->type == LYXP_SET_SCNODE_SET) {
884 ret->type = set->type;
885
886 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100887 if ((set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) ||
888 (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_START)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +0200889 uint32_t idx;
Michal Vasko26bbb272022-08-02 14:54:33 +0200890
Michal Vasko7333cb32022-07-29 16:30:29 +0200891 LY_CHECK_ERR_RET(set_scnode_insert_node(ret, set->val.scnodes[i].scnode, set->val.scnodes[i].type,
892 set->val.scnodes[i].axis, &idx), lyxp_set_free(ret), NULL);
Michal Vasko3f27c522020-01-06 08:37:49 +0100893 /* coverity seems to think scnodes can be NULL */
Radek Krejciaa6b53f2020-08-27 15:19:03 +0200894 if (!ret->val.scnodes) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200895 lyxp_set_free(ret);
896 return NULL;
897 }
Michal Vaskoba716542019-12-16 10:01:58 +0100898 ret->val.scnodes[idx].in_ctx = set->val.scnodes[i].in_ctx;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200899 }
900 }
901 } else if (set->type == LYXP_SET_NODE_SET) {
902 ret->type = set->type;
Michal Vasko08e9b112021-06-11 15:41:17 +0200903 if (set->used) {
904 ret->val.nodes = malloc(set->used * sizeof *ret->val.nodes);
905 LY_CHECK_ERR_RET(!ret->val.nodes, LOGMEM(set->ctx); free(ret), NULL);
906 memcpy(ret->val.nodes, set->val.nodes, set->used * sizeof *ret->val.nodes);
907 } else {
908 ret->val.nodes = NULL;
909 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200910
911 ret->used = ret->size = set->used;
912 ret->ctx_pos = set->ctx_pos;
913 ret->ctx_size = set->ctx_size;
Michal Vasko4a04e542021-02-01 08:58:30 +0100914 if (set->ht) {
915 ret->ht = lyht_dup(set->ht);
916 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200917 } else {
Radek Krejci0f969882020-08-21 16:56:47 +0200918 memcpy(ret, set, sizeof *ret);
919 if (set->type == LYXP_SET_STRING) {
920 ret->val.str = strdup(set->val.str);
921 LY_CHECK_ERR_RET(!ret->val.str, LOGMEM(set->ctx); free(ret), NULL);
922 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200923 }
924
925 return ret;
926}
927
928/**
929 * @brief Fill XPath set with a string. Any current data are disposed of.
930 *
931 * @param[in] set Set to fill.
932 * @param[in] string String to fill into \p set.
933 * @param[in] str_len Length of \p string. 0 is a valid value!
934 */
935static void
Michal Vaskodd528af2022-08-08 14:35:07 +0200936set_fill_string(struct lyxp_set *set, const char *string, uint32_t str_len)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200937{
Michal Vaskod3678892020-05-21 10:06:58 +0200938 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200939
940 set->type = LYXP_SET_STRING;
941 if ((str_len == 0) && (string[0] != '\0')) {
942 string = "";
943 }
944 set->val.str = strndup(string, str_len);
945}
946
947/**
948 * @brief Fill XPath set with a number. Any current data are disposed of.
949 *
950 * @param[in] set Set to fill.
951 * @param[in] number Number to fill into \p set.
952 */
953static void
954set_fill_number(struct lyxp_set *set, long double number)
955{
Michal Vaskod3678892020-05-21 10:06:58 +0200956 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200957
958 set->type = LYXP_SET_NUMBER;
959 set->val.num = number;
960}
961
962/**
963 * @brief Fill XPath set with a boolean. Any current data are disposed of.
964 *
965 * @param[in] set Set to fill.
966 * @param[in] boolean Boolean to fill into \p set.
967 */
968static void
Radek Krejci857189e2020-09-01 13:26:36 +0200969set_fill_boolean(struct lyxp_set *set, ly_bool boolean)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200970{
Michal Vaskod3678892020-05-21 10:06:58 +0200971 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200972
973 set->type = LYXP_SET_BOOLEAN;
Michal Vasko004d3152020-06-11 19:59:22 +0200974 set->val.bln = boolean;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200975}
976
977/**
978 * @brief Fill XPath set with the value from another set (deep assign).
979 * Any current data are disposed of.
980 *
981 * @param[in] trg Set to fill.
982 * @param[in] src Source set to copy into \p trg.
983 */
984static void
Michal Vasko4c7763f2020-07-27 17:40:37 +0200985set_fill_set(struct lyxp_set *trg, const struct lyxp_set *src)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200986{
987 if (!trg || !src) {
988 return;
989 }
990
991 if (trg->type == LYXP_SET_NODE_SET) {
992 free(trg->val.nodes);
993 } else if (trg->type == LYXP_SET_STRING) {
994 free(trg->val.str);
995 }
996 set_init(trg, src);
997
998 if (src->type == LYXP_SET_SCNODE_SET) {
999 trg->type = LYXP_SET_SCNODE_SET;
1000 trg->used = src->used;
1001 trg->size = src->used;
1002
Michal Vasko08e9b112021-06-11 15:41:17 +02001003 if (trg->size) {
1004 trg->val.scnodes = ly_realloc(trg->val.scnodes, trg->size * sizeof *trg->val.scnodes);
1005 LY_CHECK_ERR_RET(!trg->val.scnodes, LOGMEM(src->ctx); memset(trg, 0, sizeof *trg), );
1006 memcpy(trg->val.scnodes, src->val.scnodes, src->used * sizeof *src->val.scnodes);
1007 } else {
1008 trg->val.scnodes = NULL;
1009 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02001010 } else if (src->type == LYXP_SET_BOOLEAN) {
Michal Vasko004d3152020-06-11 19:59:22 +02001011 set_fill_boolean(trg, src->val.bln);
Michal Vasko44f3d2c2020-08-24 09:49:38 +02001012 } else if (src->type == LYXP_SET_NUMBER) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001013 set_fill_number(trg, src->val.num);
1014 } else if (src->type == LYXP_SET_STRING) {
1015 set_fill_string(trg, src->val.str, strlen(src->val.str));
1016 } else {
1017 if (trg->type == LYXP_SET_NODE_SET) {
1018 free(trg->val.nodes);
1019 } else if (trg->type == LYXP_SET_STRING) {
1020 free(trg->val.str);
1021 }
1022
Michal Vaskod3678892020-05-21 10:06:58 +02001023 assert(src->type == LYXP_SET_NODE_SET);
1024
1025 trg->type = LYXP_SET_NODE_SET;
1026 trg->used = src->used;
1027 trg->size = src->used;
1028 trg->ctx_pos = src->ctx_pos;
1029 trg->ctx_size = src->ctx_size;
1030
Michal Vasko08e9b112021-06-11 15:41:17 +02001031 if (trg->size) {
1032 trg->val.nodes = malloc(trg->size * sizeof *trg->val.nodes);
1033 LY_CHECK_ERR_RET(!trg->val.nodes, LOGMEM(src->ctx); memset(trg, 0, sizeof *trg), );
1034 memcpy(trg->val.nodes, src->val.nodes, src->used * sizeof *src->val.nodes);
1035 } else {
1036 trg->val.nodes = NULL;
1037 }
Michal Vaskod3678892020-05-21 10:06:58 +02001038 if (src->ht) {
1039 trg->ht = lyht_dup(src->ht);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001040 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02001041 trg->ht = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001042 }
1043 }
1044}
1045
1046/**
1047 * @brief Clear context of all schema nodes.
1048 *
1049 * @param[in] set Set to clear.
Michal Vasko1a09b212021-05-06 13:00:10 +02001050 * @param[in] new_ctx New context state for all the nodes currently in the context.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001051 */
1052static void
Michal Vasko1a09b212021-05-06 13:00:10 +02001053set_scnode_clear_ctx(struct lyxp_set *set, int32_t new_ctx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001054{
1055 uint32_t i;
1056
1057 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01001058 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko1a09b212021-05-06 13:00:10 +02001059 set->val.scnodes[i].in_ctx = new_ctx;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001060 } else if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_START) {
1061 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001062 }
1063 }
1064}
1065
1066/**
1067 * @brief Remove a node from a set. Removing last node changes
1068 * set into LYXP_SET_EMPTY. Context position aware.
1069 *
1070 * @param[in] set Set to use.
1071 * @param[in] idx Index from @p set of the node to be removed.
1072 */
1073static void
1074set_remove_node(struct lyxp_set *set, uint32_t idx)
1075{
1076 assert(set && (set->type == LYXP_SET_NODE_SET));
1077 assert(idx < set->used);
1078
1079 set_remove_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
1080
1081 --set->used;
Michal Vasko08e9b112021-06-11 15:41:17 +02001082 if (idx < set->used) {
1083 memmove(&set->val.nodes[idx], &set->val.nodes[idx + 1], (set->used - idx) * sizeof *set->val.nodes);
1084 } else if (!set->used) {
Michal Vaskod3678892020-05-21 10:06:58 +02001085 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001086 }
1087}
1088
1089/**
Michal Vasko2caefc12019-11-14 16:07:56 +01001090 * @brief Remove a node from a set by setting its type to LYXP_NODE_NONE.
Michal Vasko57eab132019-09-24 11:46:26 +02001091 *
1092 * @param[in] set Set to use.
1093 * @param[in] idx Index from @p set of the node to be removed.
1094 */
1095static void
Michal Vasko2caefc12019-11-14 16:07:56 +01001096set_remove_node_none(struct lyxp_set *set, uint32_t idx)
Michal Vasko57eab132019-09-24 11:46:26 +02001097{
1098 assert(set && (set->type == LYXP_SET_NODE_SET));
1099 assert(idx < set->used);
1100
Michal Vasko2caefc12019-11-14 16:07:56 +01001101 if (set->val.nodes[idx].type == LYXP_NODE_ELEM) {
1102 set_remove_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
1103 }
1104 set->val.nodes[idx].type = LYXP_NODE_NONE;
Michal Vasko57eab132019-09-24 11:46:26 +02001105}
1106
1107/**
Michal Vasko2caefc12019-11-14 16:07:56 +01001108 * @brief Remove all LYXP_NODE_NONE nodes from a set. Removing last node changes
Michal Vasko57eab132019-09-24 11:46:26 +02001109 * set into LYXP_SET_EMPTY. Context position aware.
1110 *
1111 * @param[in] set Set to consolidate.
1112 */
1113static void
Michal Vasko2caefc12019-11-14 16:07:56 +01001114set_remove_nodes_none(struct lyxp_set *set)
Michal Vasko57eab132019-09-24 11:46:26 +02001115{
Michal Vasko1fdd8fa2021-01-08 09:21:45 +01001116 uint32_t i, orig_used, end = 0;
1117 int64_t start;
Michal Vasko57eab132019-09-24 11:46:26 +02001118
Michal Vaskod3678892020-05-21 10:06:58 +02001119 assert(set);
Michal Vasko57eab132019-09-24 11:46:26 +02001120
1121 orig_used = set->used;
1122 set->used = 0;
Michal Vaskod989ba02020-08-24 10:59:24 +02001123 for (i = 0; i < orig_used; ) {
Michal Vasko57eab132019-09-24 11:46:26 +02001124 start = -1;
1125 do {
Michal Vasko2caefc12019-11-14 16:07:56 +01001126 if ((set->val.nodes[i].type != LYXP_NODE_NONE) && (start == -1)) {
Michal Vasko57eab132019-09-24 11:46:26 +02001127 start = i;
Michal Vasko2caefc12019-11-14 16:07:56 +01001128 } else if ((start > -1) && (set->val.nodes[i].type == LYXP_NODE_NONE)) {
Michal Vasko57eab132019-09-24 11:46:26 +02001129 end = i;
1130 ++i;
1131 break;
1132 }
1133
1134 ++i;
1135 if (i == orig_used) {
1136 end = i;
1137 }
1138 } while (i < orig_used);
1139
1140 if (start > -1) {
1141 /* move the whole chunk of valid nodes together */
1142 if (set->used != (unsigned)start) {
1143 memmove(&set->val.nodes[set->used], &set->val.nodes[start], (end - start) * sizeof *set->val.nodes);
1144 }
1145 set->used += end - start;
1146 }
1147 }
Michal Vasko57eab132019-09-24 11:46:26 +02001148}
1149
1150/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02001151 * @brief Check for duplicates in a node set.
1152 *
1153 * @param[in] set Set to check.
1154 * @param[in] node Node to look for in @p set.
1155 * @param[in] node_type Type of @p node.
1156 * @param[in] skip_idx Index from @p set to skip.
1157 * @return LY_ERR
1158 */
1159static LY_ERR
1160set_dup_node_check(const struct lyxp_set *set, const struct lyd_node *node, enum lyxp_node_type node_type, int skip_idx)
1161{
1162 uint32_t i;
1163
Michal Vasko2caefc12019-11-14 16:07:56 +01001164 if (set->ht && node) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001165 return set_dup_node_hash_check(set, (struct lyd_node *)node, node_type, skip_idx);
1166 }
1167
1168 for (i = 0; i < set->used; ++i) {
1169 if ((skip_idx > -1) && (i == (unsigned)skip_idx)) {
1170 continue;
1171 }
1172
1173 if ((set->val.nodes[i].node == node) && (set->val.nodes[i].type == node_type)) {
1174 return LY_EEXIST;
1175 }
1176 }
1177
1178 return LY_SUCCESS;
1179}
1180
Radek Krejci857189e2020-09-01 13:26:36 +02001181ly_bool
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001182lyxp_set_scnode_contains(struct lyxp_set *set, const struct lysc_node *node, enum lyxp_node_type node_type, int skip_idx,
1183 uint32_t *index_p)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001184{
1185 uint32_t i;
1186
1187 for (i = 0; i < set->used; ++i) {
1188 if ((skip_idx > -1) && (i == (unsigned)skip_idx)) {
1189 continue;
1190 }
1191
1192 if ((set->val.scnodes[i].scnode == node) && (set->val.scnodes[i].type == node_type)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001193 if (index_p) {
1194 *index_p = i;
1195 }
1196 return 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001197 }
1198 }
1199
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001200 return 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001201}
1202
Michal Vaskoecd62de2019-11-13 12:35:11 +01001203void
1204lyxp_set_scnode_merge(struct lyxp_set *set1, struct lyxp_set *set2)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001205{
1206 uint32_t orig_used, i, j;
1207
Michal Vaskod3678892020-05-21 10:06:58 +02001208 assert((set1->type == LYXP_SET_SCNODE_SET) && (set2->type == LYXP_SET_SCNODE_SET));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001209
Michal Vaskod3678892020-05-21 10:06:58 +02001210 if (!set2->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001211 return;
1212 }
1213
Michal Vaskod3678892020-05-21 10:06:58 +02001214 if (!set1->used) {
aPiecekadc1e4f2021-10-07 11:15:12 +02001215 /* release hidden allocated data (lyxp_set.size) */
1216 lyxp_set_free_content(set1);
1217 /* direct copying of the entire structure */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001218 memcpy(set1, set2, sizeof *set1);
1219 return;
1220 }
1221
1222 if (set1->used + set2->used > set1->size) {
1223 set1->size = set1->used + set2->used;
1224 set1->val.scnodes = ly_realloc(set1->val.scnodes, set1->size * sizeof *set1->val.scnodes);
1225 LY_CHECK_ERR_RET(!set1->val.scnodes, LOGMEM(set1->ctx), );
1226 }
1227
1228 orig_used = set1->used;
1229
1230 for (i = 0; i < set2->used; ++i) {
1231 for (j = 0; j < orig_used; ++j) {
1232 /* detect duplicities */
1233 if (set1->val.scnodes[j].scnode == set2->val.scnodes[i].scnode) {
1234 break;
1235 }
1236 }
1237
Michal Vasko0587bce2020-12-10 12:19:21 +01001238 if (j < orig_used) {
1239 /* node is there, but update its status if needed */
1240 if (set1->val.scnodes[j].in_ctx == LYXP_SET_SCNODE_START_USED) {
1241 set1->val.scnodes[j].in_ctx = set2->val.scnodes[i].in_ctx;
Michal Vasko1a09b212021-05-06 13:00:10 +02001242 } else if ((set1->val.scnodes[j].in_ctx == LYXP_SET_SCNODE_ATOM_NODE) &&
1243 (set2->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL)) {
1244 set1->val.scnodes[j].in_ctx = set2->val.scnodes[i].in_ctx;
Michal Vasko0587bce2020-12-10 12:19:21 +01001245 }
1246 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001247 memcpy(&set1->val.scnodes[set1->used], &set2->val.scnodes[i], sizeof *set2->val.scnodes);
1248 ++set1->used;
1249 }
1250 }
1251
Michal Vaskod3678892020-05-21 10:06:58 +02001252 lyxp_set_free_content(set2);
1253 set2->type = LYXP_SET_SCNODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001254}
1255
1256/**
1257 * @brief Insert a node into a set. Context position aware.
1258 *
1259 * @param[in] set Set to use.
1260 * @param[in] node Node to insert to @p set.
1261 * @param[in] pos Sort position of @p node. If left 0, it is filled just before sorting.
1262 * @param[in] node_type Node type of @p node.
1263 * @param[in] idx Index in @p set to insert into.
1264 */
1265static void
1266set_insert_node(struct lyxp_set *set, const struct lyd_node *node, uint32_t pos, enum lyxp_node_type node_type, uint32_t idx)
1267{
Michal Vaskod3678892020-05-21 10:06:58 +02001268 assert(set && (set->type == LYXP_SET_NODE_SET));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001269
Michal Vaskod3678892020-05-21 10:06:58 +02001270 if (!set->size) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001271 /* first item */
1272 if (idx) {
1273 /* no real harm done, but it is a bug */
1274 LOGINT(set->ctx);
1275 idx = 0;
1276 }
1277 set->val.nodes = malloc(LYXP_SET_SIZE_START * sizeof *set->val.nodes);
1278 LY_CHECK_ERR_RET(!set->val.nodes, LOGMEM(set->ctx), );
1279 set->type = LYXP_SET_NODE_SET;
1280 set->used = 0;
1281 set->size = LYXP_SET_SIZE_START;
1282 set->ctx_pos = 1;
1283 set->ctx_size = 1;
1284 set->ht = NULL;
1285 } else {
1286 /* not an empty set */
1287 if (set->used == set->size) {
1288
1289 /* set is full */
Michal Vasko871df522022-04-06 12:14:41 +02001290 set->val.nodes = ly_realloc(set->val.nodes, (set->size * LYXP_SET_SIZE_MUL_STEP) * sizeof *set->val.nodes);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001291 LY_CHECK_ERR_RET(!set->val.nodes, LOGMEM(set->ctx), );
Michal Vasko871df522022-04-06 12:14:41 +02001292 set->size *= LYXP_SET_SIZE_MUL_STEP;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001293 }
1294
1295 if (idx > set->used) {
1296 LOGINT(set->ctx);
1297 idx = set->used;
1298 }
1299
1300 /* make space for the new node */
1301 if (idx < set->used) {
1302 memmove(&set->val.nodes[idx + 1], &set->val.nodes[idx], (set->used - idx) * sizeof *set->val.nodes);
1303 }
1304 }
1305
1306 /* finally assign the value */
1307 set->val.nodes[idx].node = (struct lyd_node *)node;
1308 set->val.nodes[idx].type = node_type;
1309 set->val.nodes[idx].pos = pos;
1310 ++set->used;
1311
Michal Vasko2416fdd2021-10-01 11:07:10 +02001312 /* add into hash table */
1313 set_insert_node_hash(set, (struct lyd_node *)node, node_type);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001314}
1315
Michal Vasko7333cb32022-07-29 16:30:29 +02001316/**
1317 * @brief Insert schema node into set.
1318 *
1319 * @param[in] set Set to insert into.
1320 * @param[in] node Node to insert.
1321 * @param[in] node_type Node type of @p node.
1322 * @param[in] axis Axis that @p node was reached on.
1323 * @param[out] index_p Optional pointer to store index if the inserted @p node.
1324 * @return LY_SUCCESS on success.
1325 * @return LY_EMEM on memory allocation failure.
1326 */
1327static LY_ERR
1328set_scnode_insert_node(struct lyxp_set *set, const struct lysc_node *node, enum lyxp_node_type node_type,
1329 enum lyxp_axis axis, uint32_t *index_p)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001330{
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001331 uint32_t index;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001332
1333 assert(set->type == LYXP_SET_SCNODE_SET);
1334
Michal Vasko871df522022-04-06 12:14:41 +02001335 if (!set->size) {
1336 /* first item */
1337 set->val.scnodes = malloc(LYXP_SET_SIZE_START * sizeof *set->val.scnodes);
1338 LY_CHECK_ERR_RET(!set->val.scnodes, LOGMEM(set->ctx), LY_EMEM);
1339 set->type = LYXP_SET_SCNODE_SET;
1340 set->used = 0;
1341 set->size = LYXP_SET_SIZE_START;
1342 set->ctx_pos = 1;
1343 set->ctx_size = 1;
1344 set->ht = NULL;
1345 }
1346
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001347 if (lyxp_set_scnode_contains(set, node, node_type, -1, &index)) {
Michal Vasko7333cb32022-07-29 16:30:29 +02001348 /* BUG if axes differs, this new one is thrown away */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001349 set->val.scnodes[index].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001350 } else {
1351 if (set->used == set->size) {
Michal Vasko871df522022-04-06 12:14:41 +02001352 set->val.scnodes = ly_realloc(set->val.scnodes, (set->size * LYXP_SET_SIZE_MUL_STEP) * sizeof *set->val.scnodes);
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001353 LY_CHECK_ERR_RET(!set->val.scnodes, LOGMEM(set->ctx), LY_EMEM);
Michal Vasko871df522022-04-06 12:14:41 +02001354 set->size *= LYXP_SET_SIZE_MUL_STEP;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001355 }
1356
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001357 index = set->used;
1358 set->val.scnodes[index].scnode = (struct lysc_node *)node;
1359 set->val.scnodes[index].type = node_type;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001360 set->val.scnodes[index].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko7333cb32022-07-29 16:30:29 +02001361 set->val.scnodes[index].axis = axis;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001362 ++set->used;
1363 }
1364
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001365 if (index_p) {
1366 *index_p = index;
1367 }
1368
1369 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001370}
1371
1372/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02001373 * @brief Set all nodes with ctx 1 to a new unique context value.
1374 *
1375 * @param[in] set Set to modify.
1376 * @return New context value.
1377 */
Michal Vasko5c4e5892019-11-14 12:31:38 +01001378static int32_t
Michal Vasko03ff5a72019-09-11 13:49:33 +02001379set_scnode_new_in_ctx(struct lyxp_set *set)
1380{
Michal Vasko5c4e5892019-11-14 12:31:38 +01001381 uint32_t i;
1382 int32_t ret_ctx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001383
1384 assert(set->type == LYXP_SET_SCNODE_SET);
1385
Radek Krejcif13b87b2020-12-01 22:02:17 +01001386 ret_ctx = LYXP_SET_SCNODE_ATOM_PRED_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001387retry:
1388 for (i = 0; i < set->used; ++i) {
1389 if (set->val.scnodes[i].in_ctx >= ret_ctx) {
1390 ret_ctx = set->val.scnodes[i].in_ctx + 1;
1391 goto retry;
1392 }
1393 }
1394 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01001395 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001396 set->val.scnodes[i].in_ctx = ret_ctx;
1397 }
1398 }
1399
1400 return ret_ctx;
1401}
1402
1403/**
1404 * @brief Get unique @p node position in the data.
1405 *
1406 * @param[in] node Node to find.
1407 * @param[in] node_type Node type of @p node.
1408 * @param[in] root Root node.
1409 * @param[in] root_type Type of the XPath @p root node.
1410 * @param[in] prev Node that we think is before @p node in DFS from @p root. Can optionally
1411 * be used to increase efficiency and start the DFS from this node.
1412 * @param[in] prev_pos Node @p prev position. Optional, but must be set if @p prev is set.
1413 * @return Node position.
1414 */
1415static uint32_t
1416get_node_pos(const struct lyd_node *node, enum lyxp_node_type node_type, const struct lyd_node *root,
Radek Krejci0f969882020-08-21 16:56:47 +02001417 enum lyxp_node_type root_type, const struct lyd_node **prev, uint32_t *prev_pos)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001418{
Michal Vasko56daf732020-08-10 10:57:18 +02001419 const struct lyd_node *elem = NULL, *top_sibling;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001420 uint32_t pos = 1;
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001421 ly_bool found = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001422
1423 assert(prev && prev_pos && !root->prev->next);
1424
1425 if ((node_type == LYXP_NODE_ROOT) || (node_type == LYXP_NODE_ROOT_CONFIG)) {
1426 return 0;
1427 }
1428
1429 if (*prev) {
1430 /* start from the previous element instead from the root */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001431 pos = *prev_pos;
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001432 for (top_sibling = *prev; top_sibling->parent; top_sibling = lyd_parent(top_sibling)) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001433 goto dfs_search;
1434 }
1435
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001436 LY_LIST_FOR(root, top_sibling) {
Michal Vasko56daf732020-08-10 10:57:18 +02001437 LYD_TREE_DFS_BEGIN(top_sibling, elem) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001438dfs_search:
Michal Vaskoa9309bb2021-07-09 09:31:55 +02001439 LYD_TREE_DFS_continue = 0;
1440
Michal Vasko56daf732020-08-10 10:57:18 +02001441 if (*prev && !elem) {
1442 /* resume previous DFS */
1443 elem = LYD_TREE_DFS_next = (struct lyd_node *)*prev;
1444 LYD_TREE_DFS_continue = 0;
1445 }
1446
Michal Vasko482a6822022-05-06 08:56:12 +02001447 if (!elem->schema || ((root_type == LYXP_NODE_ROOT_CONFIG) && (elem->schema->flags & LYS_CONFIG_R))) {
Michal Vasko56daf732020-08-10 10:57:18 +02001448 /* skip */
1449 LYD_TREE_DFS_continue = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001450 } else {
Michal Vasko56daf732020-08-10 10:57:18 +02001451 if (elem == node) {
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001452 found = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001453 break;
1454 }
Michal Vasko56daf732020-08-10 10:57:18 +02001455 ++pos;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001456 }
Michal Vasko56daf732020-08-10 10:57:18 +02001457
1458 LYD_TREE_DFS_END(top_sibling, elem);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001459 }
1460
1461 /* node found */
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001462 if (found) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001463 break;
1464 }
1465 }
1466
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001467 if (!found) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001468 if (!(*prev)) {
1469 /* we went from root and failed to find it, cannot be */
Michal Vaskob7be7a82020-08-20 09:09:04 +02001470 LOGINT(LYD_CTX(node));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001471 return 0;
1472 } else {
Michal Vasko56daf732020-08-10 10:57:18 +02001473 /* start the search again from the beginning */
1474 *prev = root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001475
Michal Vasko56daf732020-08-10 10:57:18 +02001476 top_sibling = root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001477 pos = 1;
1478 goto dfs_search;
1479 }
1480 }
1481
1482 /* remember the last found node for next time */
1483 *prev = node;
1484 *prev_pos = pos;
1485
1486 return pos;
1487}
1488
1489/**
1490 * @brief Assign (fill) missing node positions.
1491 *
1492 * @param[in] set Set to fill positions in.
1493 * @param[in] root Context root node.
1494 * @param[in] root_type Context root type.
1495 * @return LY_ERR
1496 */
1497static LY_ERR
1498set_assign_pos(struct lyxp_set *set, const struct lyd_node *root, enum lyxp_node_type root_type)
1499{
1500 const struct lyd_node *prev = NULL, *tmp_node;
1501 uint32_t i, tmp_pos = 0;
1502
1503 for (i = 0; i < set->used; ++i) {
1504 if (!set->val.nodes[i].pos) {
1505 tmp_node = NULL;
1506 switch (set->val.nodes[i].type) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001507 case LYXP_NODE_META:
1508 tmp_node = set->val.meta[i].meta->parent;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001509 if (!tmp_node) {
1510 LOGINT_RET(root->schema->module->ctx);
1511 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01001512 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001513 case LYXP_NODE_ELEM:
1514 case LYXP_NODE_TEXT:
1515 if (!tmp_node) {
1516 tmp_node = set->val.nodes[i].node;
1517 }
1518 set->val.nodes[i].pos = get_node_pos(tmp_node, set->val.nodes[i].type, root, root_type, &prev, &tmp_pos);
1519 break;
1520 default:
1521 /* all roots have position 0 */
1522 break;
1523 }
1524 }
1525 }
1526
1527 return LY_SUCCESS;
1528}
1529
1530/**
Michal Vasko9f96a052020-03-10 09:41:45 +01001531 * @brief Get unique @p meta position in the parent metadata.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001532 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001533 * @param[in] meta Metadata to use.
1534 * @return Metadata position.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001535 */
Michal Vaskodd528af2022-08-08 14:35:07 +02001536static uint32_t
Michal Vasko9f96a052020-03-10 09:41:45 +01001537get_meta_pos(struct lyd_meta *meta)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001538{
Michal Vaskodd528af2022-08-08 14:35:07 +02001539 uint32_t pos = 0;
Michal Vasko9f96a052020-03-10 09:41:45 +01001540 struct lyd_meta *meta2;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001541
Michal Vasko9f96a052020-03-10 09:41:45 +01001542 for (meta2 = meta->parent->meta; meta2 && (meta2 != meta); meta2 = meta2->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001543 ++pos;
1544 }
1545
Michal Vasko9f96a052020-03-10 09:41:45 +01001546 assert(meta2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001547 return pos;
1548}
1549
1550/**
1551 * @brief Compare 2 nodes in respect to XPath document order.
1552 *
1553 * @param[in] item1 1st node.
1554 * @param[in] item2 2nd node.
1555 * @return If 1st > 2nd returns 1, 1st == 2nd returns 0, and 1st < 2nd returns -1.
1556 */
1557static int
1558set_sort_compare(struct lyxp_set_node *item1, struct lyxp_set_node *item2)
1559{
Michal Vasko9f96a052020-03-10 09:41:45 +01001560 uint32_t meta_pos1 = 0, meta_pos2 = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001561
1562 if (item1->pos < item2->pos) {
1563 return -1;
1564 }
1565
1566 if (item1->pos > item2->pos) {
1567 return 1;
1568 }
1569
1570 /* node positions are equal, the fun case */
1571
1572 /* 1st ELEM - == - 2nd TEXT, 1st TEXT - == - 2nd ELEM */
1573 /* special case since text nodes are actually saved as their parents */
1574 if ((item1->node == item2->node) && (item1->type != item2->type)) {
1575 if (item1->type == LYXP_NODE_ELEM) {
1576 assert(item2->type == LYXP_NODE_TEXT);
1577 return -1;
1578 } else {
1579 assert((item1->type == LYXP_NODE_TEXT) && (item2->type == LYXP_NODE_ELEM));
1580 return 1;
1581 }
1582 }
1583
Michal Vasko9f96a052020-03-10 09:41:45 +01001584 /* we need meta positions now */
1585 if (item1->type == LYXP_NODE_META) {
1586 meta_pos1 = get_meta_pos((struct lyd_meta *)item1->node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001587 }
Michal Vasko9f96a052020-03-10 09:41:45 +01001588 if (item2->type == LYXP_NODE_META) {
1589 meta_pos2 = get_meta_pos((struct lyd_meta *)item2->node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001590 }
1591
Michal Vasko9f96a052020-03-10 09:41:45 +01001592 /* 1st ROOT - 2nd ROOT, 1st ELEM - 2nd ELEM, 1st TEXT - 2nd TEXT, 1st META - =pos= - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001593 /* check for duplicates */
1594 if (item1->node == item2->node) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001595 assert((item1->type == item2->type) && ((item1->type != LYXP_NODE_META) || (meta_pos1 == meta_pos2)));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001596 return 0;
1597 }
1598
Michal Vasko9f96a052020-03-10 09:41:45 +01001599 /* 1st ELEM - 2nd TEXT, 1st ELEM - any pos - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001600 /* elem is always first, 2nd node is after it */
1601 if (item1->type == LYXP_NODE_ELEM) {
1602 assert(item2->type != LYXP_NODE_ELEM);
1603 return -1;
1604 }
1605
Michal Vasko9f96a052020-03-10 09:41:45 +01001606 /* 1st TEXT - 2nd ELEM, 1st TEXT - any pos - 2nd META, 1st META - any pos - 2nd ELEM, 1st META - >pos> - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001607 /* 2nd is before 1st */
Michal Vasko69730152020-10-09 16:30:07 +02001608 if (((item1->type == LYXP_NODE_TEXT) &&
1609 ((item2->type == LYXP_NODE_ELEM) || (item2->type == LYXP_NODE_META))) ||
1610 ((item1->type == LYXP_NODE_META) && (item2->type == LYXP_NODE_ELEM)) ||
1611 (((item1->type == LYXP_NODE_META) && (item2->type == LYXP_NODE_META)) &&
1612 (meta_pos1 > meta_pos2))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001613 return 1;
1614 }
1615
Michal Vasko9f96a052020-03-10 09:41:45 +01001616 /* 1st META - any pos - 2nd TEXT, 1st META <pos< - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001617 /* 2nd is after 1st */
1618 return -1;
1619}
1620
1621/**
1622 * @brief Set cast for comparisons.
1623 *
Michal Vasko8abcecc2022-07-28 09:55:01 +02001624 * @param[in,out] trg Target set to cast source into.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001625 * @param[in] src Source set.
1626 * @param[in] type Target set type.
1627 * @param[in] src_idx Source set node index.
Michal Vasko8abcecc2022-07-28 09:55:01 +02001628 * @return LY_SUCCESS on success.
1629 * @return LY_ERR value on error.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001630 */
1631static LY_ERR
Michal Vasko8abcecc2022-07-28 09:55:01 +02001632set_comp_cast(struct lyxp_set *trg, const struct lyxp_set *src, enum lyxp_set_type type, uint32_t src_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001633{
1634 assert(src->type == LYXP_SET_NODE_SET);
1635
1636 set_init(trg, src);
1637
1638 /* insert node into target set */
1639 set_insert_node(trg, src->val.nodes[src_idx].node, src->val.nodes[src_idx].pos, src->val.nodes[src_idx].type, 0);
1640
1641 /* cast target set appropriately */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001642 return lyxp_set_cast(trg, type);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001643}
1644
Michal Vasko4c7763f2020-07-27 17:40:37 +02001645/**
1646 * @brief Set content canonization for comparisons.
1647 *
Michal Vasko8abcecc2022-07-28 09:55:01 +02001648 * @param[in,out] set Set to canonize.
Michal Vasko4c7763f2020-07-27 17:40:37 +02001649 * @param[in] xp_node Source XPath node/meta to use for canonization.
Michal Vasko8abcecc2022-07-28 09:55:01 +02001650 * @return LY_SUCCESS on success.
1651 * @return LY_ERR value on error.
Michal Vasko4c7763f2020-07-27 17:40:37 +02001652 */
1653static LY_ERR
Michal Vasko8abcecc2022-07-28 09:55:01 +02001654set_comp_canonize(struct lyxp_set *set, const struct lyxp_set_node *xp_node)
Michal Vasko4c7763f2020-07-27 17:40:37 +02001655{
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001656 const struct lysc_type *type = NULL;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001657 struct lyd_value val;
1658 struct ly_err_item *err = NULL;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001659 LY_ERR rc;
1660
1661 /* is there anything to canonize even? */
Michal Vasko8abcecc2022-07-28 09:55:01 +02001662 if (set->type == LYXP_SET_STRING) {
Michal Vasko4c7763f2020-07-27 17:40:37 +02001663 /* do we have a type to use for canonization? */
1664 if ((xp_node->type == LYXP_NODE_ELEM) && (xp_node->node->schema->nodetype & LYD_NODE_TERM)) {
1665 type = ((struct lyd_node_term *)xp_node->node)->value.realtype;
1666 } else if (xp_node->type == LYXP_NODE_META) {
1667 type = ((struct lyd_meta *)xp_node->node)->value.realtype;
1668 }
1669 }
1670 if (!type) {
Michal Vasko8abcecc2022-07-28 09:55:01 +02001671 /* no canonization needed/possible */
1672 return LY_SUCCESS;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001673 }
1674
Michal Vasko8abcecc2022-07-28 09:55:01 +02001675 /* check for built-in types without required canonization */
1676 if ((type->basetype == LY_TYPE_STRING) && (type->plugin->store == lyplg_type_store_string)) {
1677 /* string */
1678 return LY_SUCCESS;
1679 }
1680 if ((type->basetype == LY_TYPE_BOOL) && (type->plugin->store == lyplg_type_store_boolean)) {
1681 /* boolean */
1682 return LY_SUCCESS;
1683 }
1684 if ((type->basetype == LY_TYPE_ENUM) && (type->plugin->store == lyplg_type_store_enum)) {
1685 /* enumeration */
1686 return LY_SUCCESS;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001687 }
1688
Michal Vasko8abcecc2022-07-28 09:55:01 +02001689 /* print canonized string, ignore errors, the value may not satisfy schema constraints */
1690 rc = type->plugin->store(set->ctx, type, set->val.str, strlen(set->val.str), 0, set->format, set->prefix_data,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001691 LYD_HINT_DATA, xp_node->node->schema, &val, NULL, &err);
Michal Vasko4c7763f2020-07-27 17:40:37 +02001692 ly_err_free(err);
1693 if (rc) {
Michal Vasko8abcecc2022-07-28 09:55:01 +02001694 /* invalid value, function store automaticaly dealloc value when fail */
1695 return LY_SUCCESS;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001696 }
1697
Michal Vasko8abcecc2022-07-28 09:55:01 +02001698 /* use the canonized string value */
1699 free(set->val.str);
1700 set->val.str = strdup(lyd_value_get_canonical(set->ctx, &val));
1701 type->plugin->free(set->ctx, &val);
1702 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), LY_EMEM);
Michal Vasko4c7763f2020-07-27 17:40:37 +02001703
Michal Vasko4c7763f2020-07-27 17:40:37 +02001704 return LY_SUCCESS;
1705}
1706
Michal Vasko03ff5a72019-09-11 13:49:33 +02001707/**
1708 * @brief Bubble sort @p set into XPath document order.
Michal Vasko49fec8e2022-05-24 10:28:33 +02001709 * Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001710 *
1711 * @param[in] set Set to sort.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001712 * @return How many times the whole set was traversed - 1 (if set was sorted, returns 0).
1713 */
1714static int
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001715set_sort(struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001716{
1717 uint32_t i, j;
Radek Krejci1deb5be2020-08-26 16:43:36 +02001718 int ret = 0, cmp;
Radek Krejci857189e2020-09-01 13:26:36 +02001719 ly_bool inverted, change;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001720 const struct lyd_node *root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001721 struct lyxp_set_node item;
1722 struct lyxp_set_hash_node hnode;
1723 uint64_t hash;
1724
Michal Vasko3cf8fbf2020-05-27 15:21:21 +02001725 if ((set->type != LYXP_SET_NODE_SET) || (set->used < 2)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001726 return 0;
1727 }
1728
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001729 /* find first top-level node to be used as anchor for positions */
Michal Vasko4a7d4d62021-12-13 17:05:06 +01001730 for (root = set->tree; root->parent; root = lyd_parent(root)) {}
Michal Vaskod989ba02020-08-24 10:59:24 +02001731 for ( ; root->prev->next; root = root->prev) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001732
1733 /* fill positions */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001734 if (set_assign_pos(set, root, set->root_type)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001735 return -1;
1736 }
1737
Michal Vasko88a9e802022-05-24 10:50:28 +02001738#ifndef NDEBUG
Michal Vasko03ff5a72019-09-11 13:49:33 +02001739 LOGDBG(LY_LDGXPATH, "SORT BEGIN");
1740 print_set_debug(set);
Michal Vasko88a9e802022-05-24 10:50:28 +02001741#endif
Michal Vasko03ff5a72019-09-11 13:49:33 +02001742
1743 for (i = 0; i < set->used; ++i) {
1744 inverted = 0;
1745 change = 0;
1746
1747 for (j = 1; j < set->used - i; ++j) {
1748 /* compare node positions */
1749 if (inverted) {
1750 cmp = set_sort_compare(&set->val.nodes[j], &set->val.nodes[j - 1]);
1751 } else {
1752 cmp = set_sort_compare(&set->val.nodes[j - 1], &set->val.nodes[j]);
1753 }
1754
1755 /* swap if needed */
1756 if ((inverted && (cmp < 0)) || (!inverted && (cmp > 0))) {
1757 change = 1;
1758
1759 item = set->val.nodes[j - 1];
1760 set->val.nodes[j - 1] = set->val.nodes[j];
1761 set->val.nodes[j] = item;
1762 } else {
1763 /* whether node_pos1 should be smaller than node_pos2 or the other way around */
1764 inverted = !inverted;
1765 }
1766 }
1767
1768 ++ret;
1769
1770 if (!change) {
1771 break;
1772 }
1773 }
1774
Michal Vasko88a9e802022-05-24 10:50:28 +02001775#ifndef NDEBUG
Michal Vasko03ff5a72019-09-11 13:49:33 +02001776 LOGDBG(LY_LDGXPATH, "SORT END %d", ret);
1777 print_set_debug(set);
Michal Vasko88a9e802022-05-24 10:50:28 +02001778#endif
Michal Vasko03ff5a72019-09-11 13:49:33 +02001779
1780 /* check node hashes */
1781 if (set->used >= LYD_HT_MIN_ITEMS) {
1782 assert(set->ht);
1783 for (i = 0; i < set->used; ++i) {
1784 hnode.node = set->val.nodes[i].node;
1785 hnode.type = set->val.nodes[i].type;
1786
1787 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
1788 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
1789 hash = dict_hash_multi(hash, NULL, 0);
1790
1791 assert(!lyht_find(set->ht, &hnode, hash, NULL));
1792 }
1793 }
1794
1795 return ret - 1;
1796}
1797
Michal Vasko03ff5a72019-09-11 13:49:33 +02001798/**
1799 * @brief Merge 2 sorted sets into one.
1800 *
1801 * @param[in,out] trg Set to merge into. Duplicates are removed.
1802 * @param[in] src Set to be merged into @p trg. It is cast to #LYXP_SET_EMPTY on success.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001803 * @return LY_ERR
1804 */
1805static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001806set_sorted_merge(struct lyxp_set *trg, struct lyxp_set *src)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001807{
1808 uint32_t i, j, k, count, dup_count;
1809 int cmp;
1810 const struct lyd_node *root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001811
Michal Vaskod3678892020-05-21 10:06:58 +02001812 if ((trg->type != LYXP_SET_NODE_SET) || (src->type != LYXP_SET_NODE_SET)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001813 return LY_EINVAL;
1814 }
1815
Michal Vaskod3678892020-05-21 10:06:58 +02001816 if (!src->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001817 return LY_SUCCESS;
Michal Vaskod3678892020-05-21 10:06:58 +02001818 } else if (!trg->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001819 set_fill_set(trg, src);
Michal Vaskod3678892020-05-21 10:06:58 +02001820 lyxp_set_free_content(src);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001821 return LY_SUCCESS;
1822 }
1823
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001824 /* find first top-level node to be used as anchor for positions */
Michal Vasko0143b682021-12-13 17:13:09 +01001825 for (root = trg->tree; root->parent; root = lyd_parent(root)) {}
Michal Vaskod989ba02020-08-24 10:59:24 +02001826 for ( ; root->prev->next; root = root->prev) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001827
1828 /* fill positions */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001829 if (set_assign_pos(trg, root, trg->root_type) || set_assign_pos(src, root, src->root_type)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001830 return LY_EINT;
1831 }
1832
1833#ifndef NDEBUG
1834 LOGDBG(LY_LDGXPATH, "MERGE target");
1835 print_set_debug(trg);
1836 LOGDBG(LY_LDGXPATH, "MERGE source");
1837 print_set_debug(src);
1838#endif
1839
1840 /* make memory for the merge (duplicates are not detected yet, so space
1841 * will likely be wasted on them, too bad) */
1842 if (trg->size - trg->used < src->used) {
1843 trg->size = trg->used + src->used;
1844
1845 trg->val.nodes = ly_realloc(trg->val.nodes, trg->size * sizeof *trg->val.nodes);
1846 LY_CHECK_ERR_RET(!trg->val.nodes, LOGMEM(src->ctx), LY_EMEM);
1847 }
1848
1849 i = 0;
1850 j = 0;
1851 count = 0;
1852 dup_count = 0;
1853 do {
1854 cmp = set_sort_compare(&src->val.nodes[i], &trg->val.nodes[j]);
1855 if (!cmp) {
1856 if (!count) {
1857 /* duplicate, just skip it */
1858 ++i;
1859 ++j;
1860 } else {
1861 /* we are copying something already, so let's copy the duplicate too,
1862 * we are hoping that afterwards there are some more nodes to
1863 * copy and this way we can copy them all together */
1864 ++count;
1865 ++dup_count;
1866 ++i;
1867 ++j;
1868 }
1869 } else if (cmp < 0) {
1870 /* inserting src node into trg, just remember it for now */
1871 ++count;
1872 ++i;
1873
1874 /* insert the hash now */
1875 set_insert_node_hash(trg, src->val.nodes[i - 1].node, src->val.nodes[i - 1].type);
1876 } else if (count) {
1877copy_nodes:
1878 /* time to actually copy the nodes, we have found the largest block of nodes */
1879 memmove(&trg->val.nodes[j + (count - dup_count)],
1880 &trg->val.nodes[j],
1881 (trg->used - j) * sizeof *trg->val.nodes);
1882 memcpy(&trg->val.nodes[j - dup_count], &src->val.nodes[i - count], count * sizeof *src->val.nodes);
1883
1884 trg->used += count - dup_count;
1885 /* do not change i, except the copying above, we are basically doing exactly what is in the else branch below */
1886 j += count - dup_count;
1887
1888 count = 0;
1889 dup_count = 0;
1890 } else {
1891 ++j;
1892 }
1893 } while ((i < src->used) && (j < trg->used));
1894
1895 if ((i < src->used) || count) {
1896 /* insert all the hashes first */
1897 for (k = i; k < src->used; ++k) {
1898 set_insert_node_hash(trg, src->val.nodes[k].node, src->val.nodes[k].type);
1899 }
1900
1901 /* loop ended, but we need to copy something at trg end */
1902 count += src->used - i;
1903 i = src->used;
1904 goto copy_nodes;
1905 }
1906
1907 /* we are inserting hashes before the actual node insert, which causes
1908 * situations when there were initially not enough items for a hash table,
1909 * but even after some were inserted, hash table was not created (during
1910 * insertion the number of items is not updated yet) */
1911 if (!trg->ht && (trg->used >= LYD_HT_MIN_ITEMS)) {
1912 set_insert_node_hash(trg, NULL, 0);
1913 }
1914
1915#ifndef NDEBUG
1916 LOGDBG(LY_LDGXPATH, "MERGE result");
1917 print_set_debug(trg);
1918#endif
1919
Michal Vaskod3678892020-05-21 10:06:58 +02001920 lyxp_set_free_content(src);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001921 return LY_SUCCESS;
1922}
1923
Michal Vasko14676352020-05-29 11:35:55 +02001924LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02001925lyxp_check_token(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint32_t tok_idx, enum lyxp_token want_tok)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001926{
Michal Vasko004d3152020-06-11 19:59:22 +02001927 if (exp->used == tok_idx) {
Michal Vasko14676352020-05-29 11:35:55 +02001928 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001929 LOGVAL(ctx, LY_VCODE_XP_EOF);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001930 }
Michal Vasko14676352020-05-29 11:35:55 +02001931 return LY_EINCOMPLETE;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001932 }
1933
Michal Vasko004d3152020-06-11 19:59:22 +02001934 if (want_tok && (exp->tokens[tok_idx] != want_tok)) {
Michal Vasko14676352020-05-29 11:35:55 +02001935 if (ctx) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02001936 LOGVAL(ctx, LY_VCODE_XP_INTOK2, lyxp_token2str(exp->tokens[tok_idx]),
1937 &exp->expr[exp->tok_pos[tok_idx]], lyxp_token2str(want_tok));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001938 }
Michal Vasko14676352020-05-29 11:35:55 +02001939 return LY_ENOT;
1940 }
1941
1942 return LY_SUCCESS;
1943}
1944
Michal Vasko004d3152020-06-11 19:59:22 +02001945LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02001946lyxp_next_token(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint32_t *tok_idx, enum lyxp_token want_tok)
Michal Vasko004d3152020-06-11 19:59:22 +02001947{
1948 LY_CHECK_RET(lyxp_check_token(ctx, exp, *tok_idx, want_tok));
1949
1950 /* skip the token */
1951 ++(*tok_idx);
1952
1953 return LY_SUCCESS;
1954}
1955
Michal Vasko14676352020-05-29 11:35:55 +02001956/* just like lyxp_check_token() but tests for 2 tokens */
1957static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02001958exp_check_token2(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint32_t tok_idx, enum lyxp_token want_tok1,
Radek Krejci0f969882020-08-21 16:56:47 +02001959 enum lyxp_token want_tok2)
Michal Vasko14676352020-05-29 11:35:55 +02001960{
Michal Vasko004d3152020-06-11 19:59:22 +02001961 if (exp->used == tok_idx) {
Michal Vasko14676352020-05-29 11:35:55 +02001962 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001963 LOGVAL(ctx, LY_VCODE_XP_EOF);
Michal Vasko14676352020-05-29 11:35:55 +02001964 }
1965 return LY_EINCOMPLETE;
1966 }
1967
Michal Vasko004d3152020-06-11 19:59:22 +02001968 if ((exp->tokens[tok_idx] != want_tok1) && (exp->tokens[tok_idx] != want_tok2)) {
Michal Vasko14676352020-05-29 11:35:55 +02001969 if (ctx) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02001970 LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_token2str(exp->tokens[tok_idx]),
Michal Vasko0b468e62020-10-19 09:33:04 +02001971 &exp->expr[exp->tok_pos[tok_idx]]);
Michal Vasko14676352020-05-29 11:35:55 +02001972 }
1973 return LY_ENOT;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001974 }
1975
1976 return LY_SUCCESS;
1977}
1978
Michal Vasko4911eeb2021-06-28 11:23:05 +02001979LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02001980lyxp_next_token2(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint32_t *tok_idx, enum lyxp_token want_tok1,
Michal Vasko4911eeb2021-06-28 11:23:05 +02001981 enum lyxp_token want_tok2)
1982{
1983 LY_CHECK_RET(exp_check_token2(ctx, exp, *tok_idx, want_tok1, want_tok2));
1984
1985 /* skip the token */
1986 ++(*tok_idx);
1987
1988 return LY_SUCCESS;
1989}
1990
Michal Vasko03ff5a72019-09-11 13:49:33 +02001991/**
1992 * @brief Stack operation push on the repeat array.
1993 *
1994 * @param[in] exp Expression to use.
Michal Vasko004d3152020-06-11 19:59:22 +02001995 * @param[in] tok_idx Position in the expresion \p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001996 * @param[in] repeat_op_idx Index from \p exp of the operator token. This value is pushed.
1997 */
1998static void
Michal Vaskodd528af2022-08-08 14:35:07 +02001999exp_repeat_push(struct lyxp_expr *exp, uint32_t tok_idx, uint32_t repeat_op_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002000{
Michal Vaskodd528af2022-08-08 14:35:07 +02002001 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002002
Michal Vasko004d3152020-06-11 19:59:22 +02002003 if (exp->repeat[tok_idx]) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002004 for (i = 0; exp->repeat[tok_idx][i]; ++i) {}
Michal Vasko004d3152020-06-11 19:59:22 +02002005 exp->repeat[tok_idx] = realloc(exp->repeat[tok_idx], (i + 2) * sizeof *exp->repeat[tok_idx]);
2006 LY_CHECK_ERR_RET(!exp->repeat[tok_idx], LOGMEM(NULL), );
2007 exp->repeat[tok_idx][i] = repeat_op_idx;
2008 exp->repeat[tok_idx][i + 1] = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002009 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02002010 exp->repeat[tok_idx] = calloc(2, sizeof *exp->repeat[tok_idx]);
2011 LY_CHECK_ERR_RET(!exp->repeat[tok_idx], LOGMEM(NULL), );
2012 exp->repeat[tok_idx][0] = repeat_op_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002013 }
2014}
2015
2016/**
2017 * @brief Reparse Predicate. Logs directly on error.
2018 *
2019 * [7] Predicate ::= '[' Expr ']'
2020 *
2021 * @param[in] ctx Context for logging.
2022 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002023 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002024 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002025 * @return LY_ERR
2026 */
2027static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002028reparse_predicate(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002029{
2030 LY_ERR rc;
2031
Michal Vasko004d3152020-06-11 19:59:22 +02002032 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_BRACK1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002033 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002034 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002035
aPiecekbf968d92021-05-27 14:35:05 +02002036 rc = reparse_or_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002037 LY_CHECK_RET(rc);
2038
Michal Vasko004d3152020-06-11 19:59:22 +02002039 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_BRACK2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002040 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002041 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002042
2043 return LY_SUCCESS;
2044}
2045
2046/**
2047 * @brief Reparse RelativeLocationPath. Logs directly on error.
2048 *
2049 * [4] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
2050 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
2051 * [6] NodeTest ::= NameTest | NodeType '(' ')'
2052 *
2053 * @param[in] ctx Context for logging.
2054 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002055 * @param[in] tok_idx Position in the expression \p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002056 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002057 * @return LY_ERR (LY_EINCOMPLETE on forward reference)
2058 */
2059static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002060reparse_relative_location_path(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002061{
2062 LY_ERR rc;
2063
Michal Vasko004d3152020-06-11 19:59:22 +02002064 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002065 LY_CHECK_RET(rc);
2066
2067 goto step;
2068 do {
2069 /* '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02002070 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002071
Michal Vasko004d3152020-06-11 19:59:22 +02002072 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002073 LY_CHECK_RET(rc);
2074step:
2075 /* Step */
Michal Vasko004d3152020-06-11 19:59:22 +02002076 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002077 case LYXP_TOKEN_DOT:
Michal Vasko004d3152020-06-11 19:59:22 +02002078 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002079 break;
2080
2081 case LYXP_TOKEN_DDOT:
Michal Vasko004d3152020-06-11 19:59:22 +02002082 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002083 break;
2084
Michal Vasko49fec8e2022-05-24 10:28:33 +02002085 case LYXP_TOKEN_AXISNAME:
2086 ++(*tok_idx);
2087
2088 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_DCOLON);
2089 LY_CHECK_RET(rc);
2090
2091 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02002092 case LYXP_TOKEN_AT:
Michal Vasko004d3152020-06-11 19:59:22 +02002093 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002094
Michal Vasko004d3152020-06-11 19:59:22 +02002095 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002096 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002097 if ((exp->tokens[*tok_idx] != LYXP_TOKEN_NAMETEST) && (exp->tokens[*tok_idx] != LYXP_TOKEN_NODETYPE)) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02002098 LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_token2str(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002099 return LY_EVALID;
2100 }
Michal Vasko49fec8e2022-05-24 10:28:33 +02002101 if (exp->tokens[*tok_idx] == LYXP_TOKEN_NODETYPE) {
2102 goto reparse_nodetype;
2103 }
Radek Krejci0f969882020-08-21 16:56:47 +02002104 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02002105 case LYXP_TOKEN_NAMETEST:
Michal Vasko004d3152020-06-11 19:59:22 +02002106 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002107 goto reparse_predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002108
2109 case LYXP_TOKEN_NODETYPE:
Michal Vasko49fec8e2022-05-24 10:28:33 +02002110reparse_nodetype:
Michal Vasko004d3152020-06-11 19:59:22 +02002111 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002112
2113 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02002114 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002115 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002116 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002117
2118 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02002119 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002120 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002121 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002122
2123reparse_predicate:
2124 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002125 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
aPiecekbf968d92021-05-27 14:35:05 +02002126 rc = reparse_predicate(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002127 LY_CHECK_RET(rc);
2128 }
2129 break;
2130 default:
Michal Vasko49fec8e2022-05-24 10:28:33 +02002131 LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_token2str(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002132 return LY_EVALID;
2133 }
Michal Vasko004d3152020-06-11 19:59:22 +02002134 } while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH));
Michal Vasko03ff5a72019-09-11 13:49:33 +02002135
2136 return LY_SUCCESS;
2137}
2138
2139/**
2140 * @brief Reparse AbsoluteLocationPath. Logs directly on error.
2141 *
2142 * [3] AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
2143 *
2144 * @param[in] ctx Context for logging.
2145 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002146 * @param[in] tok_idx Position in the expression \p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002147 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002148 * @return LY_ERR
2149 */
2150static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002151reparse_absolute_location_path(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002152{
2153 LY_ERR rc;
2154
Michal Vasko004d3152020-06-11 19:59:22 +02002155 LY_CHECK_RET(exp_check_token2(ctx, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH));
Michal Vasko03ff5a72019-09-11 13:49:33 +02002156
2157 /* '/' RelativeLocationPath? */
Michal Vasko004d3152020-06-11 19:59:22 +02002158 if (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002159 /* '/' */
Michal Vasko004d3152020-06-11 19:59:22 +02002160 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002161
Michal Vasko004d3152020-06-11 19:59:22 +02002162 if (lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002163 return LY_SUCCESS;
2164 }
Michal Vasko004d3152020-06-11 19:59:22 +02002165 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002166 case LYXP_TOKEN_DOT:
2167 case LYXP_TOKEN_DDOT:
Michal Vasko49fec8e2022-05-24 10:28:33 +02002168 case LYXP_TOKEN_AXISNAME:
Michal Vasko03ff5a72019-09-11 13:49:33 +02002169 case LYXP_TOKEN_AT:
2170 case LYXP_TOKEN_NAMETEST:
2171 case LYXP_TOKEN_NODETYPE:
aPiecekbf968d92021-05-27 14:35:05 +02002172 rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002173 LY_CHECK_RET(rc);
Radek Krejci0f969882020-08-21 16:56:47 +02002174 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02002175 default:
2176 break;
2177 }
2178
Michal Vasko03ff5a72019-09-11 13:49:33 +02002179 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02002180 /* '//' RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02002181 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002182
aPiecekbf968d92021-05-27 14:35:05 +02002183 rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002184 LY_CHECK_RET(rc);
2185 }
2186
2187 return LY_SUCCESS;
2188}
2189
2190/**
2191 * @brief Reparse FunctionCall. Logs directly on error.
2192 *
2193 * [9] FunctionCall ::= FunctionName '(' ( Expr ( ',' Expr )* )? ')'
2194 *
2195 * @param[in] ctx Context for logging.
2196 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002197 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002198 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002199 * @return LY_ERR
2200 */
2201static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002202reparse_function_call(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002203{
Radek Krejci1deb5be2020-08-26 16:43:36 +02002204 int8_t min_arg_count = -1;
Michal Vaskodd528af2022-08-08 14:35:07 +02002205 uint32_t arg_count, max_arg_count = 0, func_tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002206 LY_ERR rc;
2207
Michal Vasko004d3152020-06-11 19:59:22 +02002208 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_FUNCNAME);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002209 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002210 func_tok_idx = *tok_idx;
2211 switch (exp->tok_len[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002212 case 3:
Michal Vasko004d3152020-06-11 19:59:22 +02002213 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "not", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002214 min_arg_count = 1;
2215 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002216 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "sum", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002217 min_arg_count = 1;
2218 max_arg_count = 1;
2219 }
2220 break;
2221 case 4:
Michal Vasko004d3152020-06-11 19:59:22 +02002222 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "lang", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002223 min_arg_count = 1;
2224 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002225 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "last", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002226 min_arg_count = 0;
2227 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002228 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "name", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002229 min_arg_count = 0;
2230 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002231 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "true", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002232 min_arg_count = 0;
2233 max_arg_count = 0;
2234 }
2235 break;
2236 case 5:
Michal Vasko004d3152020-06-11 19:59:22 +02002237 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "count", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002238 min_arg_count = 1;
2239 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002240 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "false", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002241 min_arg_count = 0;
2242 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002243 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "floor", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002244 min_arg_count = 1;
2245 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002246 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "round", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002247 min_arg_count = 1;
2248 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002249 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "deref", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002250 min_arg_count = 1;
2251 max_arg_count = 1;
2252 }
2253 break;
2254 case 6:
Michal Vasko004d3152020-06-11 19:59:22 +02002255 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "concat", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002256 min_arg_count = 2;
Radek Krejci1deb5be2020-08-26 16:43:36 +02002257 max_arg_count = UINT32_MAX;
Michal Vasko004d3152020-06-11 19:59:22 +02002258 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "number", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002259 min_arg_count = 0;
2260 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002261 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002262 min_arg_count = 0;
2263 max_arg_count = 1;
2264 }
2265 break;
2266 case 7:
Michal Vasko004d3152020-06-11 19:59:22 +02002267 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "boolean", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002268 min_arg_count = 1;
2269 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002270 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "ceiling", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002271 min_arg_count = 1;
2272 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002273 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "current", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002274 min_arg_count = 0;
2275 max_arg_count = 0;
2276 }
2277 break;
2278 case 8:
Michal Vasko004d3152020-06-11 19:59:22 +02002279 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "contains", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002280 min_arg_count = 2;
2281 max_arg_count = 2;
Michal Vasko004d3152020-06-11 19:59:22 +02002282 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "position", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002283 min_arg_count = 0;
2284 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002285 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "re-match", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002286 min_arg_count = 2;
2287 max_arg_count = 2;
2288 }
2289 break;
2290 case 9:
Michal Vasko004d3152020-06-11 19:59:22 +02002291 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002292 min_arg_count = 2;
2293 max_arg_count = 3;
Michal Vasko004d3152020-06-11 19:59:22 +02002294 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "translate", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002295 min_arg_count = 3;
2296 max_arg_count = 3;
2297 }
2298 break;
2299 case 10:
Michal Vasko004d3152020-06-11 19:59:22 +02002300 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "local-name", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002301 min_arg_count = 0;
2302 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002303 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "enum-value", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002304 min_arg_count = 1;
2305 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002306 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "bit-is-set", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002307 min_arg_count = 2;
2308 max_arg_count = 2;
2309 }
2310 break;
2311 case 11:
Michal Vasko004d3152020-06-11 19:59:22 +02002312 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "starts-with", 11)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002313 min_arg_count = 2;
2314 max_arg_count = 2;
2315 }
2316 break;
2317 case 12:
Michal Vasko004d3152020-06-11 19:59:22 +02002318 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from", 12)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002319 min_arg_count = 2;
2320 max_arg_count = 2;
2321 }
2322 break;
2323 case 13:
Michal Vasko004d3152020-06-11 19:59:22 +02002324 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "namespace-uri", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002325 min_arg_count = 0;
2326 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002327 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string-length", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002328 min_arg_count = 0;
2329 max_arg_count = 1;
2330 }
2331 break;
2332 case 15:
Michal Vasko004d3152020-06-11 19:59:22 +02002333 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "normalize-space", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002334 min_arg_count = 0;
2335 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002336 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-after", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002337 min_arg_count = 2;
2338 max_arg_count = 2;
2339 }
2340 break;
2341 case 16:
Michal Vasko004d3152020-06-11 19:59:22 +02002342 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-before", 16)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002343 min_arg_count = 2;
2344 max_arg_count = 2;
2345 }
2346 break;
2347 case 20:
Michal Vasko004d3152020-06-11 19:59:22 +02002348 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from-or-self", 20)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002349 min_arg_count = 2;
2350 max_arg_count = 2;
2351 }
2352 break;
2353 }
2354 if (min_arg_count == -1) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002355 LOGVAL(ctx, LY_VCODE_XP_INFUNC, exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002356 return LY_EINVAL;
2357 }
Michal Vasko004d3152020-06-11 19:59:22 +02002358 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002359
2360 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02002361 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002362 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002363 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002364
2365 /* ( Expr ( ',' Expr )* )? */
2366 arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002367 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002368 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002369 if (exp->tokens[*tok_idx] != LYXP_TOKEN_PAR2) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002370 ++arg_count;
aPiecekbf968d92021-05-27 14:35:05 +02002371 rc = reparse_or_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002372 LY_CHECK_RET(rc);
2373 }
Michal Vasko004d3152020-06-11 19:59:22 +02002374 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_COMMA)) {
2375 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002376
2377 ++arg_count;
aPiecekbf968d92021-05-27 14:35:05 +02002378 rc = reparse_or_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002379 LY_CHECK_RET(rc);
2380 }
2381
2382 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02002383 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002384 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002385 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002386
Radek Krejci857189e2020-09-01 13:26:36 +02002387 if ((arg_count < (uint32_t)min_arg_count) || (arg_count > max_arg_count)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002388 LOGVAL(ctx, LY_VCODE_XP_INARGCOUNT, arg_count, exp->tok_len[func_tok_idx], &exp->expr[exp->tok_pos[func_tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002389 return LY_EVALID;
2390 }
2391
2392 return LY_SUCCESS;
2393}
2394
2395/**
2396 * @brief Reparse PathExpr. Logs directly on error.
2397 *
2398 * [10] PathExpr ::= LocationPath | PrimaryExpr Predicate*
2399 * | PrimaryExpr Predicate* '/' RelativeLocationPath
2400 * | PrimaryExpr Predicate* '//' RelativeLocationPath
2401 * [2] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
aPiecekfba75362021-10-07 12:39:48 +02002402 * [8] PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
Michal Vasko03ff5a72019-09-11 13:49:33 +02002403 *
2404 * @param[in] ctx Context for logging.
2405 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002406 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002407 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002408 * @return LY_ERR
2409 */
2410static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002411reparse_path_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002412{
2413 LY_ERR rc;
2414
Michal Vasko004d3152020-06-11 19:59:22 +02002415 if (lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko14676352020-05-29 11:35:55 +02002416 return LY_EVALID;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002417 }
2418
Michal Vasko004d3152020-06-11 19:59:22 +02002419 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002420 case LYXP_TOKEN_PAR1:
2421 /* '(' Expr ')' Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002422 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002423
aPiecekbf968d92021-05-27 14:35:05 +02002424 rc = reparse_or_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002425 LY_CHECK_RET(rc);
2426
Michal Vasko004d3152020-06-11 19:59:22 +02002427 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002428 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002429 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002430 goto predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002431 case LYXP_TOKEN_DOT:
2432 case LYXP_TOKEN_DDOT:
Michal Vasko49fec8e2022-05-24 10:28:33 +02002433 case LYXP_TOKEN_AXISNAME:
Michal Vasko03ff5a72019-09-11 13:49:33 +02002434 case LYXP_TOKEN_AT:
2435 case LYXP_TOKEN_NAMETEST:
2436 case LYXP_TOKEN_NODETYPE:
2437 /* RelativeLocationPath */
aPiecekbf968d92021-05-27 14:35:05 +02002438 rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002439 LY_CHECK_RET(rc);
2440 break;
aPiecekfba75362021-10-07 12:39:48 +02002441 case LYXP_TOKEN_VARREF:
2442 /* VariableReference */
2443 ++(*tok_idx);
2444 goto predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002445 case LYXP_TOKEN_FUNCNAME:
2446 /* FunctionCall */
aPiecekbf968d92021-05-27 14:35:05 +02002447 rc = reparse_function_call(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002448 LY_CHECK_RET(rc);
2449 goto predicate;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002450 case LYXP_TOKEN_OPER_PATH:
2451 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +02002452 /* AbsoluteLocationPath */
aPiecekbf968d92021-05-27 14:35:05 +02002453 rc = reparse_absolute_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002454 LY_CHECK_RET(rc);
2455 break;
2456 case LYXP_TOKEN_LITERAL:
2457 /* Literal */
Michal Vasko004d3152020-06-11 19:59:22 +02002458 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002459 goto predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002460 case LYXP_TOKEN_NUMBER:
2461 /* Number */
Michal Vasko004d3152020-06-11 19:59:22 +02002462 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002463 goto predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002464 default:
Michal Vasko49fec8e2022-05-24 10:28:33 +02002465 LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_token2str(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002466 return LY_EVALID;
2467 }
2468
2469 return LY_SUCCESS;
2470
2471predicate:
2472 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002473 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
aPiecekbf968d92021-05-27 14:35:05 +02002474 rc = reparse_predicate(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002475 LY_CHECK_RET(rc);
2476 }
2477
2478 /* ('/' or '//') RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02002479 if (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002480
2481 /* '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02002482 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002483
aPiecekbf968d92021-05-27 14:35:05 +02002484 rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002485 LY_CHECK_RET(rc);
2486 }
2487
2488 return LY_SUCCESS;
2489}
2490
2491/**
2492 * @brief Reparse UnaryExpr. Logs directly on error.
2493 *
2494 * [17] UnaryExpr ::= UnionExpr | '-' UnaryExpr
2495 * [18] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
2496 *
2497 * @param[in] ctx Context for logging.
2498 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002499 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002500 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002501 * @return LY_ERR
2502 */
2503static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002504reparse_unary_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002505{
Michal Vaskodd528af2022-08-08 14:35:07 +02002506 uint32_t prev_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002507 LY_ERR rc;
2508
2509 /* ('-')* */
Michal Vasko004d3152020-06-11 19:59:22 +02002510 prev_exp = *tok_idx;
Michal Vasko69730152020-10-09 16:30:07 +02002511 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2512 (exp->expr[exp->tok_pos[*tok_idx]] == '-')) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002513 exp_repeat_push(exp, prev_exp, LYXP_EXPR_UNARY);
Michal Vasko004d3152020-06-11 19:59:22 +02002514 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002515 }
2516
2517 /* PathExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002518 prev_exp = *tok_idx;
aPiecekbf968d92021-05-27 14:35:05 +02002519 rc = reparse_path_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002520 LY_CHECK_RET(rc);
2521
2522 /* ('|' PathExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002523 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_UNI)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002524 exp_repeat_push(exp, prev_exp, LYXP_EXPR_UNION);
Michal Vasko004d3152020-06-11 19:59:22 +02002525 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002526
aPiecekbf968d92021-05-27 14:35:05 +02002527 rc = reparse_path_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002528 LY_CHECK_RET(rc);
2529 }
2530
2531 return LY_SUCCESS;
2532}
2533
2534/**
2535 * @brief Reparse AdditiveExpr. Logs directly on error.
2536 *
2537 * [15] AdditiveExpr ::= MultiplicativeExpr
2538 * | AdditiveExpr '+' MultiplicativeExpr
2539 * | AdditiveExpr '-' MultiplicativeExpr
2540 * [16] MultiplicativeExpr ::= UnaryExpr
2541 * | MultiplicativeExpr '*' UnaryExpr
2542 * | MultiplicativeExpr 'div' UnaryExpr
2543 * | MultiplicativeExpr 'mod' UnaryExpr
2544 *
2545 * @param[in] ctx Context for logging.
2546 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002547 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002548 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002549 * @return LY_ERR
2550 */
2551static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002552reparse_additive_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002553{
Michal Vaskodd528af2022-08-08 14:35:07 +02002554 uint32_t prev_add_exp, prev_mul_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002555 LY_ERR rc;
2556
Michal Vasko004d3152020-06-11 19:59:22 +02002557 prev_add_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002558 goto reparse_multiplicative_expr;
2559
2560 /* ('+' / '-' MultiplicativeExpr)* */
Michal Vasko69730152020-10-09 16:30:07 +02002561 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2562 ((exp->expr[exp->tok_pos[*tok_idx]] == '+') || (exp->expr[exp->tok_pos[*tok_idx]] == '-'))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002563 exp_repeat_push(exp, prev_add_exp, LYXP_EXPR_ADDITIVE);
Michal Vasko004d3152020-06-11 19:59:22 +02002564 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002565
2566reparse_multiplicative_expr:
2567 /* UnaryExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002568 prev_mul_exp = *tok_idx;
aPiecekbf968d92021-05-27 14:35:05 +02002569 rc = reparse_unary_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002570 LY_CHECK_RET(rc);
2571
2572 /* ('*' / 'div' / 'mod' UnaryExpr)* */
Michal Vasko69730152020-10-09 16:30:07 +02002573 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2574 ((exp->expr[exp->tok_pos[*tok_idx]] == '*') || (exp->tok_len[*tok_idx] == 3))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002575 exp_repeat_push(exp, prev_mul_exp, LYXP_EXPR_MULTIPLICATIVE);
Michal Vasko004d3152020-06-11 19:59:22 +02002576 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002577
aPiecekbf968d92021-05-27 14:35:05 +02002578 rc = reparse_unary_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002579 LY_CHECK_RET(rc);
2580 }
2581 }
2582
2583 return LY_SUCCESS;
2584}
2585
2586/**
2587 * @brief Reparse EqualityExpr. Logs directly on error.
2588 *
2589 * [13] EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr
2590 * | EqualityExpr '!=' RelationalExpr
2591 * [14] RelationalExpr ::= AdditiveExpr
2592 * | RelationalExpr '<' AdditiveExpr
2593 * | RelationalExpr '>' AdditiveExpr
2594 * | RelationalExpr '<=' AdditiveExpr
2595 * | RelationalExpr '>=' AdditiveExpr
2596 *
2597 * @param[in] ctx Context for logging.
2598 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002599 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002600 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002601 * @return LY_ERR
2602 */
2603static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002604reparse_equality_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002605{
Michal Vaskodd528af2022-08-08 14:35:07 +02002606 uint32_t prev_eq_exp, prev_rel_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002607 LY_ERR rc;
2608
Michal Vasko004d3152020-06-11 19:59:22 +02002609 prev_eq_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002610 goto reparse_additive_expr;
2611
2612 /* ('=' / '!=' RelationalExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002613 while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_EQUAL, LYXP_TOKEN_OPER_NEQUAL)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002614 exp_repeat_push(exp, prev_eq_exp, LYXP_EXPR_EQUALITY);
Michal Vasko004d3152020-06-11 19:59:22 +02002615 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002616
2617reparse_additive_expr:
2618 /* AdditiveExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002619 prev_rel_exp = *tok_idx;
aPiecekbf968d92021-05-27 14:35:05 +02002620 rc = reparse_additive_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002621 LY_CHECK_RET(rc);
2622
2623 /* ('<' / '>' / '<=' / '>=' AdditiveExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002624 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_COMP)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002625 exp_repeat_push(exp, prev_rel_exp, LYXP_EXPR_RELATIONAL);
Michal Vasko004d3152020-06-11 19:59:22 +02002626 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002627
aPiecekbf968d92021-05-27 14:35:05 +02002628 rc = reparse_additive_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002629 LY_CHECK_RET(rc);
2630 }
2631 }
2632
2633 return LY_SUCCESS;
2634}
2635
2636/**
2637 * @brief Reparse OrExpr. Logs directly on error.
2638 *
2639 * [11] OrExpr ::= AndExpr | OrExpr 'or' AndExpr
2640 * [12] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
2641 *
2642 * @param[in] ctx Context for logging.
2643 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002644 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002645 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002646 * @return LY_ERR
2647 */
2648static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002649reparse_or_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002650{
Michal Vaskodd528af2022-08-08 14:35:07 +02002651 uint32_t prev_or_exp, prev_and_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002652 LY_ERR rc;
2653
aPiecekbf968d92021-05-27 14:35:05 +02002654 ++depth;
2655 LY_CHECK_ERR_RET(depth > LYXP_MAX_BLOCK_DEPTH, LOGVAL(ctx, LY_VCODE_XP_DEPTH), LY_EINVAL);
2656
Michal Vasko004d3152020-06-11 19:59:22 +02002657 prev_or_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002658 goto reparse_equality_expr;
2659
2660 /* ('or' AndExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002661 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_LOG) && (exp->tok_len[*tok_idx] == 2)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002662 exp_repeat_push(exp, prev_or_exp, LYXP_EXPR_OR);
Michal Vasko004d3152020-06-11 19:59:22 +02002663 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002664
2665reparse_equality_expr:
2666 /* EqualityExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002667 prev_and_exp = *tok_idx;
aPiecekbf968d92021-05-27 14:35:05 +02002668 rc = reparse_equality_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002669 LY_CHECK_RET(rc);
2670
2671 /* ('and' EqualityExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002672 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_LOG) && (exp->tok_len[*tok_idx] == 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002673 exp_repeat_push(exp, prev_and_exp, LYXP_EXPR_AND);
Michal Vasko004d3152020-06-11 19:59:22 +02002674 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002675
aPiecekbf968d92021-05-27 14:35:05 +02002676 rc = reparse_equality_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002677 LY_CHECK_RET(rc);
2678 }
2679 }
2680
2681 return LY_SUCCESS;
2682}
Radek Krejcib1646a92018-11-02 16:08:26 +01002683
2684/**
2685 * @brief Parse NCName.
2686 *
2687 * @param[in] ncname Name to parse.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002688 * @return Length of @p ncname valid bytes.
Radek Krejcib1646a92018-11-02 16:08:26 +01002689 */
Michal Vasko49fec8e2022-05-24 10:28:33 +02002690static ssize_t
Radek Krejcib1646a92018-11-02 16:08:26 +01002691parse_ncname(const char *ncname)
2692{
Radek Krejci1deb5be2020-08-26 16:43:36 +02002693 uint32_t uc;
Radek Krejcid4270262019-01-07 15:07:25 +01002694 size_t size;
Michal Vasko49fec8e2022-05-24 10:28:33 +02002695 ssize_t len = 0;
Radek Krejcib1646a92018-11-02 16:08:26 +01002696
2697 LY_CHECK_RET(ly_getutf8(&ncname, &uc, &size), 0);
2698 if (!is_xmlqnamestartchar(uc) || (uc == ':')) {
2699 return len;
2700 }
2701
2702 do {
2703 len += size;
Radek Krejci9a564c92019-01-07 14:53:57 +01002704 if (!*ncname) {
2705 break;
2706 }
Radek Krejcid4270262019-01-07 15:07:25 +01002707 LY_CHECK_RET(ly_getutf8(&ncname, &uc, &size), -len);
Radek Krejcib1646a92018-11-02 16:08:26 +01002708 } while (is_xmlqnamechar(uc) && (uc != ':'));
2709
2710 return len;
2711}
2712
2713/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02002714 * @brief Add @p token into the expression @p exp.
Radek Krejcib1646a92018-11-02 16:08:26 +01002715 *
Michal Vasko03ff5a72019-09-11 13:49:33 +02002716 * @param[in] ctx Context for logging.
Radek Krejcib1646a92018-11-02 16:08:26 +01002717 * @param[in] exp Expression to use.
2718 * @param[in] token Token to add.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002719 * @param[in] tok_pos Token position in the XPath expression.
Radek Krejcib1646a92018-11-02 16:08:26 +01002720 * @param[in] tok_len Token length in the XPath expression.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002721 * @return LY_ERR
Radek Krejcib1646a92018-11-02 16:08:26 +01002722 */
2723static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002724exp_add_token(const struct ly_ctx *ctx, struct lyxp_expr *exp, enum lyxp_token token, uint32_t tok_pos, uint32_t tok_len)
Radek Krejcib1646a92018-11-02 16:08:26 +01002725{
2726 uint32_t prev;
2727
2728 if (exp->used == exp->size) {
2729 prev = exp->size;
2730 exp->size += LYXP_EXPR_SIZE_STEP;
2731 if (prev > exp->size) {
2732 LOGINT(ctx);
2733 return LY_EINT;
2734 }
2735
2736 exp->tokens = ly_realloc(exp->tokens, exp->size * sizeof *exp->tokens);
2737 LY_CHECK_ERR_RET(!exp->tokens, LOGMEM(ctx), LY_EMEM);
2738 exp->tok_pos = ly_realloc(exp->tok_pos, exp->size * sizeof *exp->tok_pos);
2739 LY_CHECK_ERR_RET(!exp->tok_pos, LOGMEM(ctx), LY_EMEM);
2740 exp->tok_len = ly_realloc(exp->tok_len, exp->size * sizeof *exp->tok_len);
2741 LY_CHECK_ERR_RET(!exp->tok_len, LOGMEM(ctx), LY_EMEM);
2742 }
2743
2744 exp->tokens[exp->used] = token;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002745 exp->tok_pos[exp->used] = tok_pos;
Radek Krejcib1646a92018-11-02 16:08:26 +01002746 exp->tok_len[exp->used] = tok_len;
2747 ++exp->used;
2748 return LY_SUCCESS;
2749}
2750
2751void
Michal Vasko14676352020-05-29 11:35:55 +02002752lyxp_expr_free(const struct ly_ctx *ctx, struct lyxp_expr *expr)
Radek Krejcib1646a92018-11-02 16:08:26 +01002753{
Michal Vaskodd528af2022-08-08 14:35:07 +02002754 uint32_t i;
Radek Krejcib1646a92018-11-02 16:08:26 +01002755
2756 if (!expr) {
2757 return;
2758 }
2759
2760 lydict_remove(ctx, expr->expr);
2761 free(expr->tokens);
2762 free(expr->tok_pos);
2763 free(expr->tok_len);
2764 if (expr->repeat) {
2765 for (i = 0; i < expr->used; ++i) {
2766 free(expr->repeat[i]);
2767 }
2768 }
2769 free(expr->repeat);
2770 free(expr);
2771}
2772
Michal Vasko49fec8e2022-05-24 10:28:33 +02002773/**
2774 * @brief Parse Axis name.
2775 *
2776 * @param[in] str String to parse.
2777 * @param[in] str_len Length of @p str.
2778 * @return LY_SUCCESS if an axis.
2779 * @return LY_ENOT otherwise.
2780 */
2781static LY_ERR
2782expr_parse_axis(const char *str, size_t str_len)
2783{
2784 switch (str_len) {
2785 case 4:
2786 if (!strncmp("self", str, str_len)) {
2787 return LY_SUCCESS;
2788 }
2789 break;
2790 case 5:
2791 if (!strncmp("child", str, str_len)) {
2792 return LY_SUCCESS;
2793 }
2794 break;
2795 case 6:
2796 if (!strncmp("parent", str, str_len)) {
2797 return LY_SUCCESS;
2798 }
2799 break;
2800 case 8:
2801 if (!strncmp("ancestor", str, str_len)) {
2802 return LY_SUCCESS;
2803 }
2804 break;
2805 case 9:
2806 if (!strncmp("attribute", str, str_len)) {
2807 return LY_SUCCESS;
2808 } else if (!strncmp("following", str, str_len)) {
2809 return LY_SUCCESS;
2810 } else if (!strncmp("namespace", str, str_len)) {
2811 LOGERR(NULL, LY_EINVAL, "Axis \"namespace\" not supported.");
2812 return LY_ENOT;
2813 } else if (!strncmp("preceding", str, str_len)) {
2814 return LY_SUCCESS;
2815 }
2816 break;
2817 case 10:
2818 if (!strncmp("descendant", str, str_len)) {
2819 return LY_SUCCESS;
2820 }
2821 break;
2822 case 16:
2823 if (!strncmp("ancestor-or-self", str, str_len)) {
2824 return LY_SUCCESS;
2825 }
2826 break;
2827 case 17:
2828 if (!strncmp("following-sibling", str, str_len)) {
2829 return LY_SUCCESS;
2830 } else if (!strncmp("preceding-sibling", str, str_len)) {
2831 return LY_SUCCESS;
2832 }
2833 break;
2834 case 18:
2835 if (!strncmp("descendant-or-self", str, str_len)) {
2836 return LY_SUCCESS;
2837 }
2838 break;
2839 }
2840
2841 return LY_ENOT;
2842}
2843
Radek Krejcif03a9e22020-09-18 20:09:31 +02002844LY_ERR
2845lyxp_expr_parse(const struct ly_ctx *ctx, const char *expr_str, size_t expr_len, ly_bool reparse, struct lyxp_expr **expr_p)
Radek Krejcib1646a92018-11-02 16:08:26 +01002846{
Radek Krejcif03a9e22020-09-18 20:09:31 +02002847 LY_ERR ret = LY_SUCCESS;
2848 struct lyxp_expr *expr;
Radek Krejcid4270262019-01-07 15:07:25 +01002849 size_t parsed = 0, tok_len;
Radek Krejcib1646a92018-11-02 16:08:26 +01002850 enum lyxp_token tok_type;
Michal Vasko49fec8e2022-05-24 10:28:33 +02002851 ly_bool prev_func_check = 0, prev_ntype_check = 0, has_axis;
Michal Vaskodd528af2022-08-08 14:35:07 +02002852 uint32_t tok_idx = 0;
Michal Vasko49fec8e2022-05-24 10:28:33 +02002853 ssize_t ncname_len;
Radek Krejcib1646a92018-11-02 16:08:26 +01002854
Radek Krejcif03a9e22020-09-18 20:09:31 +02002855 assert(expr_p);
2856
2857 if (!expr_str[0]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002858 LOGVAL(ctx, LY_VCODE_XP_EOF);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002859 return LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +02002860 }
2861
2862 if (!expr_len) {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002863 expr_len = strlen(expr_str);
Michal Vasko004d3152020-06-11 19:59:22 +02002864 }
Michal Vaskodd528af2022-08-08 14:35:07 +02002865 if (expr_len > UINT32_MAX) {
2866 LOGVAL(ctx, LYVE_XPATH, "XPath expression cannot be longer than %" PRIu32 " characters.", UINT32_MAX);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002867 return LY_EVALID;
Radek Krejcib1646a92018-11-02 16:08:26 +01002868 }
2869
2870 /* init lyxp_expr structure */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002871 expr = calloc(1, sizeof *expr);
2872 LY_CHECK_ERR_GOTO(!expr, LOGMEM(ctx); ret = LY_EMEM, error);
2873 LY_CHECK_GOTO(ret = lydict_insert(ctx, expr_str, expr_len, &expr->expr), error);
2874 expr->used = 0;
2875 expr->size = LYXP_EXPR_SIZE_START;
2876 expr->tokens = malloc(expr->size * sizeof *expr->tokens);
2877 LY_CHECK_ERR_GOTO(!expr->tokens, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002878
Radek Krejcif03a9e22020-09-18 20:09:31 +02002879 expr->tok_pos = malloc(expr->size * sizeof *expr->tok_pos);
2880 LY_CHECK_ERR_GOTO(!expr->tok_pos, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002881
Radek Krejcif03a9e22020-09-18 20:09:31 +02002882 expr->tok_len = malloc(expr->size * sizeof *expr->tok_len);
2883 LY_CHECK_ERR_GOTO(!expr->tok_len, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002884
Michal Vasko004d3152020-06-11 19:59:22 +02002885 /* make expr 0-terminated */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002886 expr_str = expr->expr;
Michal Vasko004d3152020-06-11 19:59:22 +02002887
Radek Krejcif03a9e22020-09-18 20:09:31 +02002888 while (is_xmlws(expr_str[parsed])) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002889 ++parsed;
2890 }
2891
2892 do {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002893 if (expr_str[parsed] == '(') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002894
2895 /* '(' */
2896 tok_len = 1;
2897 tok_type = LYXP_TOKEN_PAR1;
2898
Michal Vasko49fec8e2022-05-24 10:28:33 +02002899 if (prev_ntype_check && expr->used && (expr->tokens[expr->used - 1] == LYXP_TOKEN_NAMETEST) &&
2900 (((expr->tok_len[expr->used - 1] == 4) &&
2901 (!strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "node", 4) ||
2902 !strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "text", 4))) ||
2903 ((expr->tok_len[expr->used - 1] == 7) &&
2904 !strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "comment", 7)))) {
2905 /* it is NodeType after all */
2906 expr->tokens[expr->used - 1] = LYXP_TOKEN_NODETYPE;
2907
2908 prev_ntype_check = 0;
2909 prev_func_check = 0;
2910 } else if (prev_func_check && expr->used && (expr->tokens[expr->used - 1] == LYXP_TOKEN_NAMETEST)) {
2911 /* it is FunctionName after all */
2912 expr->tokens[expr->used - 1] = LYXP_TOKEN_FUNCNAME;
2913
2914 prev_ntype_check = 0;
2915 prev_func_check = 0;
Radek Krejcib1646a92018-11-02 16:08:26 +01002916 }
2917
Radek Krejcif03a9e22020-09-18 20:09:31 +02002918 } else if (expr_str[parsed] == ')') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002919
2920 /* ')' */
2921 tok_len = 1;
2922 tok_type = LYXP_TOKEN_PAR2;
2923
Radek Krejcif03a9e22020-09-18 20:09:31 +02002924 } else if (expr_str[parsed] == '[') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002925
2926 /* '[' */
2927 tok_len = 1;
2928 tok_type = LYXP_TOKEN_BRACK1;
2929
Radek Krejcif03a9e22020-09-18 20:09:31 +02002930 } else if (expr_str[parsed] == ']') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002931
2932 /* ']' */
2933 tok_len = 1;
2934 tok_type = LYXP_TOKEN_BRACK2;
2935
Radek Krejcif03a9e22020-09-18 20:09:31 +02002936 } else if (!strncmp(&expr_str[parsed], "..", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002937
2938 /* '..' */
2939 tok_len = 2;
2940 tok_type = LYXP_TOKEN_DDOT;
2941
Radek Krejcif03a9e22020-09-18 20:09:31 +02002942 } else if ((expr_str[parsed] == '.') && (!isdigit(expr_str[parsed + 1]))) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002943
2944 /* '.' */
2945 tok_len = 1;
2946 tok_type = LYXP_TOKEN_DOT;
2947
Radek Krejcif03a9e22020-09-18 20:09:31 +02002948 } else if (expr_str[parsed] == '@') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002949
2950 /* '@' */
2951 tok_len = 1;
2952 tok_type = LYXP_TOKEN_AT;
2953
Radek Krejcif03a9e22020-09-18 20:09:31 +02002954 } else if (expr_str[parsed] == ',') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002955
2956 /* ',' */
2957 tok_len = 1;
2958 tok_type = LYXP_TOKEN_COMMA;
2959
Radek Krejcif03a9e22020-09-18 20:09:31 +02002960 } else if (expr_str[parsed] == '\'') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002961
2962 /* Literal with ' */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002963 for (tok_len = 1; (expr_str[parsed + tok_len] != '\0') && (expr_str[parsed + tok_len] != '\''); ++tok_len) {}
2964 LY_CHECK_ERR_GOTO(expr_str[parsed + tok_len] == '\0',
Radek Krejci2efc45b2020-12-22 16:25:44 +01002965 LOGVAL(ctx, LY_VCODE_XP_EOE, expr_str[parsed], &expr_str[parsed]); ret = LY_EVALID,
Michal Vasko69730152020-10-09 16:30:07 +02002966 error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002967 ++tok_len;
2968 tok_type = LYXP_TOKEN_LITERAL;
2969
Radek Krejcif03a9e22020-09-18 20:09:31 +02002970 } else if (expr_str[parsed] == '\"') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002971
2972 /* Literal with " */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002973 for (tok_len = 1; (expr_str[parsed + tok_len] != '\0') && (expr_str[parsed + tok_len] != '\"'); ++tok_len) {}
2974 LY_CHECK_ERR_GOTO(expr_str[parsed + tok_len] == '\0',
Radek Krejci2efc45b2020-12-22 16:25:44 +01002975 LOGVAL(ctx, LY_VCODE_XP_EOE, expr_str[parsed], &expr_str[parsed]); ret = LY_EVALID,
Michal Vasko69730152020-10-09 16:30:07 +02002976 error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002977 ++tok_len;
2978 tok_type = LYXP_TOKEN_LITERAL;
2979
Radek Krejcif03a9e22020-09-18 20:09:31 +02002980 } else if ((expr_str[parsed] == '.') || (isdigit(expr_str[parsed]))) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002981
2982 /* Number */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002983 for (tok_len = 0; isdigit(expr_str[parsed + tok_len]); ++tok_len) {}
2984 if (expr_str[parsed + tok_len] == '.') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002985 ++tok_len;
Radek Krejcif03a9e22020-09-18 20:09:31 +02002986 for ( ; isdigit(expr_str[parsed + tok_len]); ++tok_len) {}
Radek Krejcib1646a92018-11-02 16:08:26 +01002987 }
2988 tok_type = LYXP_TOKEN_NUMBER;
2989
aPiecekfba75362021-10-07 12:39:48 +02002990 } else if (expr_str[parsed] == '$') {
2991
2992 /* VariableReference */
2993 parsed++;
Michal Vasko49fec8e2022-05-24 10:28:33 +02002994 ncname_len = parse_ncname(&expr_str[parsed]);
aPiecekfba75362021-10-07 12:39:48 +02002995 LY_CHECK_ERR_GOTO(ncname_len < 1, LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed - ncname_len],
2996 parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
2997 tok_len = ncname_len;
2998 LY_CHECK_ERR_GOTO(expr_str[parsed + tok_len] == ':',
2999 LOGVAL(ctx, LYVE_XPATH, "Variable with prefix is not supported."); ret = LY_EVALID,
3000 error);
3001 tok_type = LYXP_TOKEN_VARREF;
3002
Radek Krejcif03a9e22020-09-18 20:09:31 +02003003 } else if (expr_str[parsed] == '/') {
Radek Krejcib1646a92018-11-02 16:08:26 +01003004
3005 /* Operator '/', '//' */
Radek Krejcif03a9e22020-09-18 20:09:31 +02003006 if (!strncmp(&expr_str[parsed], "//", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003007 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003008 tok_type = LYXP_TOKEN_OPER_RPATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01003009 } else {
3010 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003011 tok_type = LYXP_TOKEN_OPER_PATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01003012 }
Radek Krejcib1646a92018-11-02 16:08:26 +01003013
Radek Krejcif03a9e22020-09-18 20:09:31 +02003014 } else if (!strncmp(&expr_str[parsed], "!=", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003015
Michal Vasko3e48bf32020-06-01 08:39:07 +02003016 /* Operator '!=' */
Radek Krejcib1646a92018-11-02 16:08:26 +01003017 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003018 tok_type = LYXP_TOKEN_OPER_NEQUAL;
3019
Radek Krejcif03a9e22020-09-18 20:09:31 +02003020 } else if (!strncmp(&expr_str[parsed], "<=", 2) || !strncmp(&expr_str[parsed], ">=", 2)) {
Michal Vasko3e48bf32020-06-01 08:39:07 +02003021
3022 /* Operator '<=', '>=' */
3023 tok_len = 2;
3024 tok_type = LYXP_TOKEN_OPER_COMP;
Radek Krejcib1646a92018-11-02 16:08:26 +01003025
Radek Krejcif03a9e22020-09-18 20:09:31 +02003026 } else if (expr_str[parsed] == '|') {
Radek Krejcib1646a92018-11-02 16:08:26 +01003027
3028 /* Operator '|' */
3029 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003030 tok_type = LYXP_TOKEN_OPER_UNI;
Radek Krejcib1646a92018-11-02 16:08:26 +01003031
Radek Krejcif03a9e22020-09-18 20:09:31 +02003032 } else if ((expr_str[parsed] == '+') || (expr_str[parsed] == '-')) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003033
3034 /* Operator '+', '-' */
3035 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003036 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01003037
Radek Krejcif03a9e22020-09-18 20:09:31 +02003038 } else if (expr_str[parsed] == '=') {
Radek Krejcib1646a92018-11-02 16:08:26 +01003039
Michal Vasko3e48bf32020-06-01 08:39:07 +02003040 /* Operator '=' */
Radek Krejcib1646a92018-11-02 16:08:26 +01003041 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003042 tok_type = LYXP_TOKEN_OPER_EQUAL;
3043
Radek Krejcif03a9e22020-09-18 20:09:31 +02003044 } else if ((expr_str[parsed] == '<') || (expr_str[parsed] == '>')) {
Michal Vasko3e48bf32020-06-01 08:39:07 +02003045
3046 /* Operator '<', '>' */
3047 tok_len = 1;
3048 tok_type = LYXP_TOKEN_OPER_COMP;
Radek Krejcib1646a92018-11-02 16:08:26 +01003049
Michal Vasko69730152020-10-09 16:30:07 +02003050 } else if (expr->used && (expr->tokens[expr->used - 1] != LYXP_TOKEN_AT) &&
3051 (expr->tokens[expr->used - 1] != LYXP_TOKEN_PAR1) &&
3052 (expr->tokens[expr->used - 1] != LYXP_TOKEN_BRACK1) &&
3053 (expr->tokens[expr->used - 1] != LYXP_TOKEN_COMMA) &&
3054 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_LOG) &&
3055 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_EQUAL) &&
3056 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_NEQUAL) &&
3057 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_COMP) &&
3058 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_MATH) &&
3059 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_UNI) &&
3060 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_PATH) &&
3061 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_RPATH)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003062
3063 /* Operator '*', 'or', 'and', 'mod', or 'div' */
Radek Krejcif03a9e22020-09-18 20:09:31 +02003064 if (expr_str[parsed] == '*') {
Radek Krejcib1646a92018-11-02 16:08:26 +01003065 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003066 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01003067
Radek Krejcif03a9e22020-09-18 20:09:31 +02003068 } else if (!strncmp(&expr_str[parsed], "or", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003069 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003070 tok_type = LYXP_TOKEN_OPER_LOG;
Radek Krejcib1646a92018-11-02 16:08:26 +01003071
Radek Krejcif03a9e22020-09-18 20:09:31 +02003072 } else if (!strncmp(&expr_str[parsed], "and", 3)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003073 tok_len = 3;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003074 tok_type = LYXP_TOKEN_OPER_LOG;
Radek Krejcib1646a92018-11-02 16:08:26 +01003075
Radek Krejcif03a9e22020-09-18 20:09:31 +02003076 } else if (!strncmp(&expr_str[parsed], "mod", 3) || !strncmp(&expr_str[parsed], "div", 3)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003077 tok_len = 3;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003078 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01003079
Michal Vasko49fec8e2022-05-24 10:28:33 +02003080 } else if (prev_ntype_check || prev_func_check) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003081 LOGVAL(ctx, LYVE_XPATH, "Invalid character 0x%x ('%c'), perhaps \"%.*s\" is supposed to be a function call.",
Michal Vasko69730152020-10-09 16:30:07 +02003082 expr_str[parsed], expr_str[parsed], expr->tok_len[expr->used - 1], &expr->expr[expr->tok_pos[expr->used - 1]]);
Radek Krejcif03a9e22020-09-18 20:09:31 +02003083 ret = LY_EVALID;
Radek Krejcib1646a92018-11-02 16:08:26 +01003084 goto error;
3085 } else {
Michal Vasko774ce402021-04-14 15:35:06 +02003086 LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed], parsed + 1, expr_str);
Radek Krejcif03a9e22020-09-18 20:09:31 +02003087 ret = LY_EVALID;
Radek Krejcib1646a92018-11-02 16:08:26 +01003088 goto error;
3089 }
Radek Krejcib1646a92018-11-02 16:08:26 +01003090 } else {
3091
Michal Vasko49fec8e2022-05-24 10:28:33 +02003092 /* (AxisName '::')? ((NCName ':')? '*' | QName) or NodeType/FunctionName */
3093 if (expr_str[parsed] == '*') {
3094 ncname_len = 1;
3095 } else {
3096 ncname_len = parse_ncname(&expr_str[parsed]);
3097 LY_CHECK_ERR_GOTO(ncname_len < 1, LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed - ncname_len],
3098 parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
3099 }
Radek Krejcib1646a92018-11-02 16:08:26 +01003100 tok_len = ncname_len;
3101
Michal Vasko49fec8e2022-05-24 10:28:33 +02003102 has_axis = 0;
3103 if (!strncmp(&expr_str[parsed + tok_len], "::", 2)) {
3104 /* axis */
3105 LY_CHECK_ERR_GOTO(expr_parse_axis(&expr_str[parsed], ncname_len),
3106 LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed], parsed + 1, expr_str); ret = LY_EVALID, error);
3107 tok_type = LYXP_TOKEN_AXISNAME;
3108
3109 LY_CHECK_GOTO(ret = exp_add_token(ctx, expr, tok_type, parsed, tok_len), error);
3110 parsed += tok_len;
3111
3112 /* '::' */
3113 tok_len = 2;
3114 tok_type = LYXP_TOKEN_DCOLON;
3115
3116 LY_CHECK_GOTO(ret = exp_add_token(ctx, expr, tok_type, parsed, tok_len), error);
3117 parsed += tok_len;
3118
3119 if (expr_str[parsed] == '*') {
3120 ncname_len = 1;
3121 } else {
3122 ncname_len = parse_ncname(&expr_str[parsed]);
3123 LY_CHECK_ERR_GOTO(ncname_len < 1, LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed - ncname_len],
3124 parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
3125 }
3126 tok_len = ncname_len;
3127
3128 has_axis = 1;
3129 }
3130
Radek Krejcif03a9e22020-09-18 20:09:31 +02003131 if (expr_str[parsed + tok_len] == ':') {
Radek Krejcib1646a92018-11-02 16:08:26 +01003132 ++tok_len;
Radek Krejcif03a9e22020-09-18 20:09:31 +02003133 if (expr_str[parsed + tok_len] == '*') {
Radek Krejcib1646a92018-11-02 16:08:26 +01003134 ++tok_len;
3135 } else {
Radek Krejcif03a9e22020-09-18 20:09:31 +02003136 ncname_len = parse_ncname(&expr_str[parsed + tok_len]);
Michal Vaskoe2be5462021-08-04 10:49:42 +02003137 LY_CHECK_ERR_GOTO(ncname_len < 1, LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed - ncname_len],
Michal Vasko774ce402021-04-14 15:35:06 +02003138 parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01003139 tok_len += ncname_len;
3140 }
Michal Vasko49fec8e2022-05-24 10:28:33 +02003141 /* remove old flags to prevent ambiguities */
3142 prev_ntype_check = 0;
3143 prev_func_check = 0;
Radek Krejcib1646a92018-11-02 16:08:26 +01003144 tok_type = LYXP_TOKEN_NAMETEST;
3145 } else {
Michal Vasko49fec8e2022-05-24 10:28:33 +02003146 /* if not '*', there is no prefix so it can still be NodeType/FunctionName, we can't finally decide now */
3147 prev_ntype_check = (expr_str[parsed] == '*') ? 0 : 1;
3148 prev_func_check = (prev_ntype_check && !has_axis) ? 1 : 0;
Radek Krejcib1646a92018-11-02 16:08:26 +01003149 tok_type = LYXP_TOKEN_NAMETEST;
3150 }
3151 }
3152
3153 /* store the token, move on to the next one */
Radek Krejcif03a9e22020-09-18 20:09:31 +02003154 LY_CHECK_GOTO(ret = exp_add_token(ctx, expr, tok_type, parsed, tok_len), error);
Radek Krejcib1646a92018-11-02 16:08:26 +01003155 parsed += tok_len;
Radek Krejcif03a9e22020-09-18 20:09:31 +02003156 while (is_xmlws(expr_str[parsed])) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003157 ++parsed;
3158 }
3159
Radek Krejcif03a9e22020-09-18 20:09:31 +02003160 } while (expr_str[parsed]);
Radek Krejcib1646a92018-11-02 16:08:26 +01003161
Michal Vasko004d3152020-06-11 19:59:22 +02003162 if (reparse) {
3163 /* prealloc repeat */
Radek Krejcif03a9e22020-09-18 20:09:31 +02003164 expr->repeat = calloc(expr->size, sizeof *expr->repeat);
3165 LY_CHECK_ERR_GOTO(!expr->repeat, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01003166
Michal Vasko004d3152020-06-11 19:59:22 +02003167 /* fill repeat */
aPiecekbf968d92021-05-27 14:35:05 +02003168 LY_CHECK_ERR_GOTO(reparse_or_expr(ctx, expr, &tok_idx, 0), ret = LY_EVALID, error);
Radek Krejcif03a9e22020-09-18 20:09:31 +02003169 if (expr->used > tok_idx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003170 LOGVAL(ctx, LYVE_XPATH, "Unparsed characters \"%s\" left at the end of an XPath expression.",
Michal Vasko69730152020-10-09 16:30:07 +02003171 &expr->expr[expr->tok_pos[tok_idx]]);
Radek Krejcif03a9e22020-09-18 20:09:31 +02003172 ret = LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +02003173 goto error;
3174 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003175 }
3176
Radek Krejcif03a9e22020-09-18 20:09:31 +02003177 print_expr_struct_debug(expr);
3178 *expr_p = expr;
3179 return LY_SUCCESS;
Radek Krejcib1646a92018-11-02 16:08:26 +01003180
3181error:
Radek Krejcif03a9e22020-09-18 20:09:31 +02003182 lyxp_expr_free(ctx, expr);
3183 return ret;
Radek Krejcib1646a92018-11-02 16:08:26 +01003184}
3185
Michal Vasko1734be92020-09-22 08:55:10 +02003186LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02003187lyxp_expr_dup(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint32_t start_idx, uint32_t end_idx,
Michal Vaskoe33134a2022-07-29 14:54:40 +02003188 struct lyxp_expr **dup_p)
Michal Vasko004d3152020-06-11 19:59:22 +02003189{
Michal Vasko1734be92020-09-22 08:55:10 +02003190 LY_ERR ret = LY_SUCCESS;
3191 struct lyxp_expr *dup = NULL;
Michal Vaskod59039d2022-09-09 09:07:30 +02003192 uint32_t used = 0, i, j, expr_len;
Michal Vaskoe33134a2022-07-29 14:54:40 +02003193 const char *expr_start;
3194
3195 assert((!start_idx && !end_idx) || ((start_idx < exp->used) && (end_idx < exp->used) && (start_idx <= end_idx)));
Michal Vasko004d3152020-06-11 19:59:22 +02003196
Michal Vasko7f45cf22020-10-01 12:49:44 +02003197 if (!exp) {
3198 goto cleanup;
3199 }
3200
Michal Vaskoe33134a2022-07-29 14:54:40 +02003201 if (!start_idx && !end_idx) {
3202 end_idx = exp->used - 1;
3203 }
3204
3205 expr_start = exp->expr + exp->tok_pos[start_idx];
3206 expr_len = (exp->tok_pos[end_idx] + exp->tok_len[end_idx]) - exp->tok_pos[start_idx];
3207
Michal Vasko004d3152020-06-11 19:59:22 +02003208 dup = calloc(1, sizeof *dup);
Michal Vasko1734be92020-09-22 08:55:10 +02003209 LY_CHECK_ERR_GOTO(!dup, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02003210
Michal Vasko08e9b112021-06-11 15:41:17 +02003211 if (exp->used) {
Michal Vaskoe33134a2022-07-29 14:54:40 +02003212 used = (end_idx - start_idx) + 1;
3213
3214 dup->tokens = malloc(used * sizeof *dup->tokens);
Michal Vasko08e9b112021-06-11 15:41:17 +02003215 LY_CHECK_ERR_GOTO(!dup->tokens, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vaskoe33134a2022-07-29 14:54:40 +02003216 memcpy(dup->tokens, exp->tokens + start_idx, used * sizeof *dup->tokens);
Michal Vasko004d3152020-06-11 19:59:22 +02003217
Michal Vaskoe33134a2022-07-29 14:54:40 +02003218 dup->tok_pos = malloc(used * sizeof *dup->tok_pos);
Michal Vasko08e9b112021-06-11 15:41:17 +02003219 LY_CHECK_ERR_GOTO(!dup->tok_pos, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vaskoe33134a2022-07-29 14:54:40 +02003220 memcpy(dup->tok_pos, exp->tok_pos + start_idx, used * sizeof *dup->tok_pos);
Michal Vasko004d3152020-06-11 19:59:22 +02003221
Michal Vaskoe33134a2022-07-29 14:54:40 +02003222 if (start_idx) {
3223 /* fix the indices in the expression */
3224 for (i = 0; i < used; ++i) {
3225 dup->tok_pos[i] -= expr_start - exp->expr;
3226 }
3227 }
3228
3229 dup->tok_len = malloc(used * sizeof *dup->tok_len);
Michal Vasko08e9b112021-06-11 15:41:17 +02003230 LY_CHECK_ERR_GOTO(!dup->tok_len, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vaskoe33134a2022-07-29 14:54:40 +02003231 memcpy(dup->tok_len, exp->tok_len + start_idx, used * sizeof *dup->tok_len);
Michal Vasko004d3152020-06-11 19:59:22 +02003232
Michal Vasko79a7a872022-06-17 09:00:48 +02003233 if (exp->repeat) {
Michal Vaskoe33134a2022-07-29 14:54:40 +02003234 dup->repeat = malloc(used * sizeof *dup->repeat);
Michal Vasko79a7a872022-06-17 09:00:48 +02003235 LY_CHECK_ERR_GOTO(!dup->repeat, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vaskoe33134a2022-07-29 14:54:40 +02003236 for (i = start_idx; i <= end_idx; ++i) {
Michal Vasko79a7a872022-06-17 09:00:48 +02003237 if (!exp->repeat[i]) {
Michal Vaskoe33134a2022-07-29 14:54:40 +02003238 dup->repeat[i - start_idx] = NULL;
Michal Vasko79a7a872022-06-17 09:00:48 +02003239 } else {
3240 for (j = 0; exp->repeat[i][j]; ++j) {}
3241 /* the ending 0 as well */
3242 ++j;
Michal Vasko004d3152020-06-11 19:59:22 +02003243
Michal Vaskoe33134a2022-07-29 14:54:40 +02003244 dup->repeat[i - start_idx] = malloc(j * sizeof **dup->repeat);
3245 LY_CHECK_ERR_GOTO(!dup->repeat[i - start_idx], LOGMEM(ctx); ret = LY_EMEM, cleanup);
3246 memcpy(dup->repeat[i - start_idx], exp->repeat[i], j * sizeof **dup->repeat);
Michal Vasko79a7a872022-06-17 09:00:48 +02003247 }
Michal Vasko08e9b112021-06-11 15:41:17 +02003248 }
Michal Vasko004d3152020-06-11 19:59:22 +02003249 }
3250 }
3251
Michal Vaskoe33134a2022-07-29 14:54:40 +02003252 dup->used = used;
3253 dup->size = used;
3254
3255 /* copy only subexpression */
3256 LY_CHECK_GOTO(ret = lydict_insert(ctx, expr_start, expr_len, &dup->expr), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02003257
Michal Vasko1734be92020-09-22 08:55:10 +02003258cleanup:
3259 if (ret) {
3260 lyxp_expr_free(ctx, dup);
3261 } else {
3262 *dup_p = dup;
3263 }
3264 return ret;
Michal Vasko004d3152020-06-11 19:59:22 +02003265}
3266
Michal Vasko03ff5a72019-09-11 13:49:33 +02003267/**
3268 * @brief Get the last-added schema node that is currently in the context.
3269 *
3270 * @param[in] set Set to search in.
3271 * @return Last-added schema context node, NULL if no node is in context.
3272 */
3273static struct lysc_node *
3274warn_get_scnode_in_ctx(struct lyxp_set *set)
3275{
3276 uint32_t i;
3277
3278 if (!set || (set->type != LYXP_SET_SCNODE_SET)) {
3279 return NULL;
3280 }
3281
3282 i = set->used;
3283 do {
3284 --i;
Radek Krejcif13b87b2020-12-01 22:02:17 +01003285 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003286 /* if there are more, simply return the first found (last added) */
3287 return set->val.scnodes[i].scnode;
3288 }
3289 } while (i);
3290
3291 return NULL;
3292}
3293
3294/**
3295 * @brief Test whether a type is numeric - integer type or decimal64.
3296 *
3297 * @param[in] type Type to test.
Radek Krejci857189e2020-09-01 13:26:36 +02003298 * @return Boolean value whether @p type is numeric type or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003299 */
Radek Krejci857189e2020-09-01 13:26:36 +02003300static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003301warn_is_numeric_type(struct lysc_type *type)
3302{
3303 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003304 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003305 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003306
3307 switch (type->basetype) {
3308 case LY_TYPE_DEC64:
3309 case LY_TYPE_INT8:
3310 case LY_TYPE_UINT8:
3311 case LY_TYPE_INT16:
3312 case LY_TYPE_UINT16:
3313 case LY_TYPE_INT32:
3314 case LY_TYPE_UINT32:
3315 case LY_TYPE_INT64:
3316 case LY_TYPE_UINT64:
3317 return 1;
3318 case LY_TYPE_UNION:
3319 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003320 LY_ARRAY_FOR(uni->types, u) {
3321 ret = warn_is_numeric_type(uni->types[u]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003322 if (ret) {
3323 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003324 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003325 }
3326 }
3327 /* did not find any suitable type */
3328 return 0;
3329 case LY_TYPE_LEAFREF:
3330 return warn_is_numeric_type(((struct lysc_type_leafref *)type)->realtype);
3331 default:
3332 return 0;
3333 }
3334}
3335
3336/**
3337 * @brief Test whether a type is string-like - no integers, decimal64 or binary.
3338 *
3339 * @param[in] type Type to test.
Radek Krejci857189e2020-09-01 13:26:36 +02003340 * @return Boolean value whether @p type's basetype is string type or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003341 */
Radek Krejci857189e2020-09-01 13:26:36 +02003342static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003343warn_is_string_type(struct lysc_type *type)
3344{
3345 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003346 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003347 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003348
3349 switch (type->basetype) {
3350 case LY_TYPE_BITS:
3351 case LY_TYPE_ENUM:
3352 case LY_TYPE_IDENT:
3353 case LY_TYPE_INST:
3354 case LY_TYPE_STRING:
3355 return 1;
3356 case LY_TYPE_UNION:
3357 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003358 LY_ARRAY_FOR(uni->types, u) {
3359 ret = warn_is_string_type(uni->types[u]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003360 if (ret) {
3361 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003362 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003363 }
3364 }
3365 /* did not find any suitable type */
3366 return 0;
3367 case LY_TYPE_LEAFREF:
3368 return warn_is_string_type(((struct lysc_type_leafref *)type)->realtype);
3369 default:
3370 return 0;
3371 }
3372}
3373
3374/**
3375 * @brief Test whether a type is one specific type.
3376 *
3377 * @param[in] type Type to test.
3378 * @param[in] base Expected type.
Radek Krejci857189e2020-09-01 13:26:36 +02003379 * @return Boolean value whether the given @p type is of the specific basetype @p base.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003380 */
Radek Krejci857189e2020-09-01 13:26:36 +02003381static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003382warn_is_specific_type(struct lysc_type *type, LY_DATA_TYPE base)
3383{
3384 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003385 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003386 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003387
3388 if (type->basetype == base) {
3389 return 1;
3390 } else if (type->basetype == LY_TYPE_UNION) {
3391 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003392 LY_ARRAY_FOR(uni->types, u) {
3393 ret = warn_is_specific_type(uni->types[u], base);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003394 if (ret) {
3395 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003396 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003397 }
3398 }
3399 /* did not find any suitable type */
3400 return 0;
3401 } else if (type->basetype == LY_TYPE_LEAFREF) {
3402 return warn_is_specific_type(((struct lysc_type_leafref *)type)->realtype, base);
3403 }
3404
3405 return 0;
3406}
3407
3408/**
3409 * @brief Get next type of a (union) type.
3410 *
3411 * @param[in] type Base type.
3412 * @param[in] prev_type Previously returned type.
3413 * @return Next type or NULL.
3414 */
3415static struct lysc_type *
3416warn_is_equal_type_next_type(struct lysc_type *type, struct lysc_type *prev_type)
3417{
3418 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003419 ly_bool found = 0;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003420 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003421
3422 switch (type->basetype) {
3423 case LY_TYPE_UNION:
3424 uni = (struct lysc_type_union *)type;
3425 if (!prev_type) {
3426 return uni->types[0];
3427 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003428 LY_ARRAY_FOR(uni->types, u) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003429 if (found) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003430 return uni->types[u];
Michal Vasko03ff5a72019-09-11 13:49:33 +02003431 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003432 if (prev_type == uni->types[u]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003433 found = 1;
3434 }
3435 }
3436 return NULL;
3437 default:
3438 if (prev_type) {
3439 assert(type == prev_type);
3440 return NULL;
3441 } else {
3442 return type;
3443 }
3444 }
3445}
3446
3447/**
3448 * @brief Test whether 2 types have a common type.
3449 *
3450 * @param[in] type1 First type.
3451 * @param[in] type2 Second type.
3452 * @return 1 if they do, 0 otherwise.
3453 */
3454static int
3455warn_is_equal_type(struct lysc_type *type1, struct lysc_type *type2)
3456{
3457 struct lysc_type *t1, *rt1, *t2, *rt2;
3458
3459 t1 = NULL;
3460 while ((t1 = warn_is_equal_type_next_type(type1, t1))) {
3461 if (t1->basetype == LY_TYPE_LEAFREF) {
3462 rt1 = ((struct lysc_type_leafref *)t1)->realtype;
3463 } else {
3464 rt1 = t1;
3465 }
3466
3467 t2 = NULL;
3468 while ((t2 = warn_is_equal_type_next_type(type2, t2))) {
3469 if (t2->basetype == LY_TYPE_LEAFREF) {
3470 rt2 = ((struct lysc_type_leafref *)t2)->realtype;
3471 } else {
3472 rt2 = t2;
3473 }
3474
3475 if (rt2->basetype == rt1->basetype) {
3476 /* match found */
3477 return 1;
3478 }
3479 }
3480 }
3481
3482 return 0;
3483}
3484
3485/**
Michal Vaskoaa956522021-11-11 10:45:34 +01003486 * @brief Print warning with information about the XPath subexpression that caused previous warning.
3487 *
3488 * @param[in] ctx Context for logging.
3489 * @param[in] tok_pos Index of the subexpression in the whole expression.
3490 * @param[in] subexpr Subexpression start.
3491 * @param[in] subexpr_len Length of @p subexpr to print.
3492 * @param[in] cur_scnode Expression context node.
3493 */
3494static void
Michal Vaskodd528af2022-08-08 14:35:07 +02003495warn_subexpr_log(const struct ly_ctx *ctx, uint32_t tok_pos, const char *subexpr, int subexpr_len,
Michal Vaskoaa956522021-11-11 10:45:34 +01003496 const struct lysc_node *cur_scnode)
3497{
3498 char *path;
3499
3500 path = lysc_path(cur_scnode, LYSC_PATH_LOG, NULL, 0);
Michal Vaskodd528af2022-08-08 14:35:07 +02003501 LOGWRN(ctx, "Previous warning generated by XPath subexpression[%" PRIu32 "] \"%.*s\" with context node \"%s\".",
Michal Vaskoaa956522021-11-11 10:45:34 +01003502 tok_pos, subexpr_len, subexpr, path);
3503 free(path);
3504}
3505
3506/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02003507 * @brief Check both operands of comparison operators.
3508 *
3509 * @param[in] ctx Context for errors.
3510 * @param[in] set1 First operand set.
3511 * @param[in] set2 Second operand set.
3512 * @param[in] numbers_only Whether accept only numbers or other types are fine too (for '=' and '!=').
3513 * @param[in] expr Start of the expression to print with the warning.
3514 * @param[in] tok_pos Token position.
3515 */
3516static void
Michal Vaskoaa956522021-11-11 10:45:34 +01003517warn_operands(struct ly_ctx *ctx, struct lyxp_set *set1, struct lyxp_set *set2, ly_bool numbers_only, const char *expr,
Michal Vaskodd528af2022-08-08 14:35:07 +02003518 uint32_t tok_pos)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003519{
3520 struct lysc_node_leaf *node1, *node2;
Radek Krejci857189e2020-09-01 13:26:36 +02003521 ly_bool leaves = 1, warning = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003522
3523 node1 = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set1);
3524 node2 = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set2);
3525
3526 if (!node1 && !node2) {
3527 /* no node-sets involved, nothing to do */
3528 return;
3529 }
3530
3531 if (node1) {
3532 if (!(node1->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3533 LOGWRN(ctx, "Node type %s \"%s\" used as operand.", lys_nodetype2str(node1->nodetype), node1->name);
3534 warning = 1;
3535 leaves = 0;
3536 } else if (numbers_only && !warn_is_numeric_type(node1->type)) {
3537 LOGWRN(ctx, "Node \"%s\" is not of a numeric type, but used where it was expected.", node1->name);
3538 warning = 1;
3539 }
3540 }
3541
3542 if (node2) {
3543 if (!(node2->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3544 LOGWRN(ctx, "Node type %s \"%s\" used as operand.", lys_nodetype2str(node2->nodetype), node2->name);
3545 warning = 1;
3546 leaves = 0;
3547 } else if (numbers_only && !warn_is_numeric_type(node2->type)) {
3548 LOGWRN(ctx, "Node \"%s\" is not of a numeric type, but used where it was expected.", node2->name);
3549 warning = 1;
3550 }
3551 }
3552
3553 if (node1 && node2 && leaves && !numbers_only) {
Michal Vasko69730152020-10-09 16:30:07 +02003554 if ((warn_is_numeric_type(node1->type) && !warn_is_numeric_type(node2->type)) ||
3555 (!warn_is_numeric_type(node1->type) && warn_is_numeric_type(node2->type)) ||
3556 (!warn_is_numeric_type(node1->type) && !warn_is_numeric_type(node2->type) &&
3557 !warn_is_equal_type(node1->type, node2->type))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003558 LOGWRN(ctx, "Incompatible types of operands \"%s\" and \"%s\" for comparison.", node1->name, node2->name);
3559 warning = 1;
3560 }
3561 }
3562
3563 if (warning) {
Michal Vaskoaa956522021-11-11 10:45:34 +01003564 warn_subexpr_log(ctx, tok_pos, expr + tok_pos, 20, set1->cur_scnode);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003565 }
3566}
3567
3568/**
3569 * @brief Check that a value is valid for a leaf. If not applicable, does nothing.
3570 *
3571 * @param[in] exp Parsed XPath expression.
3572 * @param[in] set Set with the leaf/leaf-list.
3573 * @param[in] val_exp Index of the value (literal/number) in @p exp.
3574 * @param[in] equal_exp Index of the start of the equality expression in @p exp.
3575 * @param[in] last_equal_exp Index of the end of the equality expression in @p exp.
3576 */
3577static void
Michal Vaskodd528af2022-08-08 14:35:07 +02003578warn_equality_value(const struct lyxp_expr *exp, struct lyxp_set *set, uint32_t val_exp, uint32_t equal_exp,
3579 uint32_t last_equal_exp)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003580{
3581 struct lysc_node *scnode;
3582 struct lysc_type *type;
3583 char *value;
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003584 struct lyd_value storage;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003585 LY_ERR rc;
3586 struct ly_err_item *err = NULL;
3587
Michal Vasko69730152020-10-09 16:30:07 +02003588 if ((scnode = warn_get_scnode_in_ctx(set)) && (scnode->nodetype & (LYS_LEAF | LYS_LEAFLIST)) &&
3589 ((exp->tokens[val_exp] == LYXP_TOKEN_LITERAL) || (exp->tokens[val_exp] == LYXP_TOKEN_NUMBER))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003590 /* check that the node can have the specified value */
3591 if (exp->tokens[val_exp] == LYXP_TOKEN_LITERAL) {
3592 value = strndup(exp->expr + exp->tok_pos[val_exp] + 1, exp->tok_len[val_exp] - 2);
3593 } else {
3594 value = strndup(exp->expr + exp->tok_pos[val_exp], exp->tok_len[val_exp]);
3595 }
3596 if (!value) {
3597 LOGMEM(set->ctx);
3598 return;
3599 }
3600
3601 if ((((struct lysc_node_leaf *)scnode)->type->basetype == LY_TYPE_IDENT) && !strchr(value, ':')) {
3602 LOGWRN(set->ctx, "Identityref \"%s\" comparison with identity \"%s\" without prefix, consider adding"
Michal Vasko69730152020-10-09 16:30:07 +02003603 " a prefix or best using \"derived-from(-or-self)()\" functions.", scnode->name, value);
Michal Vaskoaa956522021-11-11 10:45:34 +01003604 warn_subexpr_log(set->ctx, exp->tok_pos[equal_exp], exp->expr + exp->tok_pos[equal_exp],
Radek Krejci0f969882020-08-21 16:56:47 +02003605 (exp->tok_pos[last_equal_exp] - exp->tok_pos[equal_exp]) + exp->tok_len[last_equal_exp],
Michal Vaskoaa956522021-11-11 10:45:34 +01003606 set->cur_scnode);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003607 }
3608
3609 type = ((struct lysc_node_leaf *)scnode)->type;
3610 if (type->basetype != LY_TYPE_IDENT) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003611 rc = type->plugin->store(set->ctx, type, value, strlen(value), 0, set->format, set->prefix_data,
Michal Vasko405cc9e2020-12-01 12:01:27 +01003612 LYD_HINT_DATA, scnode, &storage, NULL, &err);
Michal Vaskobf42e832020-11-23 16:59:42 +01003613 if (rc == LY_EINCOMPLETE) {
3614 rc = LY_SUCCESS;
3615 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003616
3617 if (err) {
3618 LOGWRN(set->ctx, "Invalid value \"%s\" which does not fit the type (%s).", value, err->msg);
3619 ly_err_free(err);
3620 } else if (rc != LY_SUCCESS) {
3621 LOGWRN(set->ctx, "Invalid value \"%s\" which does not fit the type.", value);
3622 }
3623 if (rc != LY_SUCCESS) {
Michal Vaskoaa956522021-11-11 10:45:34 +01003624 warn_subexpr_log(set->ctx, exp->tok_pos[equal_exp], exp->expr + exp->tok_pos[equal_exp],
Radek Krejci0f969882020-08-21 16:56:47 +02003625 (exp->tok_pos[last_equal_exp] - exp->tok_pos[equal_exp]) + exp->tok_len[last_equal_exp],
Michal Vaskoaa956522021-11-11 10:45:34 +01003626 set->cur_scnode);
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003627 } else {
3628 type->plugin->free(set->ctx, &storage);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003629 }
3630 }
3631 free(value);
3632 }
3633}
3634
3635/*
3636 * XPath functions
3637 */
3638
3639/**
3640 * @brief Execute the YANG 1.1 bit-is-set(node-set, string) function. Returns LYXP_SET_BOOLEAN
3641 * depending on whether the first node bit value from the second argument is set.
3642 *
3643 * @param[in] args Array of arguments.
3644 * @param[in] arg_count Count of elements in @p args.
3645 * @param[in,out] set Context and result set at the same time.
3646 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003647 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003648 */
3649static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02003650xpath_bit_is_set(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003651{
3652 struct lyd_node_term *leaf;
3653 struct lysc_node_leaf *sleaf;
Michal Vasko2588b952021-07-29 07:43:26 +02003654 struct lyd_value_bits *bits;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003655 LY_ERR rc = LY_SUCCESS;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003656 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003657
3658 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003659 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003660 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko5676f4e2021-04-06 17:14:45 +02003661 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3662 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3663 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3664 sleaf->name);
3665 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_BITS)) {
3666 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"bits\".", __func__, sleaf->name);
3667 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003668 }
3669
3670 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
3671 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003672 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3673 sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003674 } else if (!warn_is_string_type(sleaf->type)) {
3675 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003676 }
3677 }
Michal Vasko1a09b212021-05-06 13:00:10 +02003678 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003679 return rc;
3680 }
3681
Michal Vaskod3678892020-05-21 10:06:58 +02003682 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003683 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "bit-is-set(node-set, string)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02003684 return LY_EVALID;
3685 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003686 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003687 LY_CHECK_RET(rc);
3688
3689 set_fill_boolean(set, 0);
Michal Vaskod3678892020-05-21 10:06:58 +02003690 if (args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003691 leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
Michal Vasko2588b952021-07-29 07:43:26 +02003692 if ((leaf->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST)) && (leaf->value.realtype->basetype == LY_TYPE_BITS)) {
3693 LYD_VALUE_GET(&leaf->value, bits);
3694 LY_ARRAY_FOR(bits->items, u) {
3695 if (!strcmp(bits->items[u]->name, args[1]->val.str)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003696 set_fill_boolean(set, 1);
3697 break;
3698 }
3699 }
3700 }
3701 }
3702
3703 return LY_SUCCESS;
3704}
3705
3706/**
3707 * @brief Execute the XPath boolean(object) function. Returns LYXP_SET_BOOLEAN
3708 * with the argument converted to boolean.
3709 *
3710 * @param[in] args Array of arguments.
3711 * @param[in] arg_count Count of elements in @p args.
3712 * @param[in,out] set Context and result set at the same time.
3713 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003714 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003715 */
3716static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02003717xpath_boolean(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003718{
3719 LY_ERR rc;
3720
3721 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02003722 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003723 return LY_SUCCESS;
3724 }
3725
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003726 rc = lyxp_set_cast(args[0], LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003727 LY_CHECK_RET(rc);
3728 set_fill_set(set, args[0]);
3729
3730 return LY_SUCCESS;
3731}
3732
3733/**
3734 * @brief Execute the XPath ceiling(number) function. Returns LYXP_SET_NUMBER
3735 * with the first argument rounded up to the nearest integer.
3736 *
3737 * @param[in] args Array of arguments.
3738 * @param[in] arg_count Count of elements in @p args.
3739 * @param[in,out] set Context and result set at the same time.
3740 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003741 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003742 */
3743static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02003744xpath_ceiling(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003745{
3746 struct lysc_node_leaf *sleaf;
3747 LY_ERR rc = LY_SUCCESS;
3748
3749 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003750 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003751 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko5676f4e2021-04-06 17:14:45 +02003752 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3753 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3754 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3755 sleaf->name);
3756 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_DEC64)) {
3757 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"decimal64\".", __func__, sleaf->name);
3758 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003759 }
Michal Vasko1a09b212021-05-06 13:00:10 +02003760 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003761 return rc;
3762 }
3763
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003764 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003765 LY_CHECK_RET(rc);
3766 if ((long long)args[0]->val.num != args[0]->val.num) {
3767 set_fill_number(set, ((long long)args[0]->val.num) + 1);
3768 } else {
3769 set_fill_number(set, args[0]->val.num);
3770 }
3771
3772 return LY_SUCCESS;
3773}
3774
3775/**
3776 * @brief Execute the XPath concat(string, string, string*) function.
3777 * Returns LYXP_SET_STRING with the concatenation of all the arguments.
3778 *
3779 * @param[in] args Array of arguments.
3780 * @param[in] arg_count Count of elements in @p args.
3781 * @param[in,out] set Context and result set at the same time.
3782 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003783 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003784 */
3785static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02003786xpath_concat(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003787{
Michal Vaskodd528af2022-08-08 14:35:07 +02003788 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003789 char *str = NULL;
3790 size_t used = 1;
3791 LY_ERR rc = LY_SUCCESS;
3792 struct lysc_node_leaf *sleaf;
3793
3794 if (options & LYXP_SCNODE_ALL) {
3795 for (i = 0; i < arg_count; ++i) {
3796 if ((args[i]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[i]))) {
3797 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3798 LOGWRN(set->ctx, "Argument #%u of %s is a %s node \"%s\".",
Michal Vasko69730152020-10-09 16:30:07 +02003799 i + 1, __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003800 } else if (!warn_is_string_type(sleaf->type)) {
Radek Krejci70124c82020-08-14 22:17:03 +02003801 LOGWRN(set->ctx, "Argument #%u of %s is node \"%s\", not of string-type.", i + 1, __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003802 }
3803 }
3804 }
Michal Vasko1a09b212021-05-06 13:00:10 +02003805 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003806 return rc;
3807 }
3808
3809 for (i = 0; i < arg_count; ++i) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003810 rc = lyxp_set_cast(args[i], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003811 if (rc != LY_SUCCESS) {
3812 free(str);
3813 return rc;
3814 }
3815
3816 str = ly_realloc(str, (used + strlen(args[i]->val.str)) * sizeof(char));
3817 LY_CHECK_ERR_RET(!str, LOGMEM(set->ctx), LY_EMEM);
3818 strcpy(str + used - 1, args[i]->val.str);
3819 used += strlen(args[i]->val.str);
3820 }
3821
3822 /* free, kind of */
Michal Vaskod3678892020-05-21 10:06:58 +02003823 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003824 set->type = LYXP_SET_STRING;
3825 set->val.str = str;
3826
3827 return LY_SUCCESS;
3828}
3829
3830/**
3831 * @brief Execute the XPath contains(string, string) function.
3832 * Returns LYXP_SET_BOOLEAN whether the second argument can
3833 * be found in the first or not.
3834 *
3835 * @param[in] args Array of arguments.
3836 * @param[in] arg_count Count of elements in @p args.
3837 * @param[in,out] set Context and result set at the same time.
3838 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003839 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003840 */
3841static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02003842xpath_contains(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003843{
3844 struct lysc_node_leaf *sleaf;
3845 LY_ERR rc = LY_SUCCESS;
3846
3847 if (options & LYXP_SCNODE_ALL) {
3848 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3849 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003850 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3851 sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003852 } else if (!warn_is_string_type(sleaf->type)) {
3853 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003854 }
3855 }
3856
3857 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
3858 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003859 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3860 sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003861 } else if (!warn_is_string_type(sleaf->type)) {
3862 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003863 }
3864 }
Michal Vasko1a09b212021-05-06 13:00:10 +02003865 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003866 return rc;
3867 }
3868
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003869 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003870 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003871 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003872 LY_CHECK_RET(rc);
3873
3874 if (strstr(args[0]->val.str, args[1]->val.str)) {
3875 set_fill_boolean(set, 1);
3876 } else {
3877 set_fill_boolean(set, 0);
3878 }
3879
3880 return LY_SUCCESS;
3881}
3882
3883/**
3884 * @brief Execute the XPath count(node-set) function. Returns LYXP_SET_NUMBER
3885 * with the size of the node-set from the argument.
3886 *
3887 * @param[in] args Array of arguments.
3888 * @param[in] arg_count Count of elements in @p args.
3889 * @param[in,out] set Context and result set at the same time.
3890 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003891 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003892 */
3893static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02003894xpath_count(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003895{
Michal Vasko03ff5a72019-09-11 13:49:33 +02003896 LY_ERR rc = LY_SUCCESS;
3897
3898 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003899 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003900 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003901 }
Michal Vasko1a09b212021-05-06 13:00:10 +02003902 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003903 return rc;
3904 }
3905
Michal Vasko03ff5a72019-09-11 13:49:33 +02003906 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003907 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "count(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02003908 return LY_EVALID;
3909 }
3910
3911 set_fill_number(set, args[0]->used);
3912 return LY_SUCCESS;
3913}
3914
3915/**
3916 * @brief Execute the XPath current() function. Returns LYXP_SET_NODE_SET
3917 * with the context with the intial node.
3918 *
3919 * @param[in] args Array of arguments.
3920 * @param[in] arg_count Count of elements in @p args.
3921 * @param[in,out] set Context and result set at the same time.
3922 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003923 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003924 */
3925static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02003926xpath_current(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003927{
3928 if (arg_count || args) {
Radek Krejcie87c7dc2021-06-02 21:25:42 +02003929 LOGVAL(set->ctx, LY_VCODE_XP_INARGCOUNT, arg_count, LY_PRI_LENSTR("current()"));
Michal Vasko03ff5a72019-09-11 13:49:33 +02003930 return LY_EVALID;
3931 }
3932
3933 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02003934 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003935
Michal Vasko296dfaf2021-12-13 16:57:42 +01003936 if (set->cur_scnode) {
Michal Vasko7333cb32022-07-29 16:30:29 +02003937 LY_CHECK_RET(set_scnode_insert_node(set, set->cur_scnode, LYXP_NODE_ELEM, LYXP_AXIS_SELF, NULL));
Michal Vasko296dfaf2021-12-13 16:57:42 +01003938 } else {
3939 /* root node */
Michal Vasko7333cb32022-07-29 16:30:29 +02003940 LY_CHECK_RET(set_scnode_insert_node(set, NULL, set->root_type, LYXP_AXIS_SELF, NULL));
Michal Vasko296dfaf2021-12-13 16:57:42 +01003941 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003942 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02003943 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003944
Michal Vasko296dfaf2021-12-13 16:57:42 +01003945 if (set->cur_node) {
3946 /* position is filled later */
3947 set_insert_node(set, set->cur_node, 0, LYXP_NODE_ELEM, 0);
3948 } else {
3949 /* root node */
3950 set_insert_node(set, NULL, 0, set->root_type, 0);
3951 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003952 }
3953
3954 return LY_SUCCESS;
3955}
3956
3957/**
3958 * @brief Execute the YANG 1.1 deref(node-set) function. Returns LYXP_SET_NODE_SET with either
3959 * leafref or instance-identifier target node(s).
3960 *
3961 * @param[in] args Array of arguments.
3962 * @param[in] arg_count Count of elements in @p args.
3963 * @param[in,out] set Context and result set at the same time.
3964 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003965 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003966 */
3967static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02003968xpath_deref(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003969{
3970 struct lyd_node_term *leaf;
Michal Vasko42e497c2020-01-06 08:38:25 +01003971 struct lysc_node_leaf *sleaf = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02003972 struct lysc_type_leafref *lref;
Michal Vaskoae9e4cb2019-09-25 08:43:05 +02003973 const struct lysc_node *target;
Michal Vasko004d3152020-06-11 19:59:22 +02003974 struct ly_path *p;
3975 struct lyd_node *node;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003976 char *errmsg = NULL;
Michal Vasko00cbf532020-06-15 13:58:47 +02003977 uint8_t oper;
Michal Vasko741bb562021-06-24 11:59:50 +02003978 LY_ERR r;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003979
3980 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003981 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003982 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko5676f4e2021-04-06 17:14:45 +02003983 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
Michal Vasko423ba3f2021-07-19 13:08:50 +02003984 if (!(sleaf->nodetype & LYD_NODE_TERM)) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003985 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3986 sleaf->name);
Michal Vaskoed725d72021-06-23 12:03:45 +02003987 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_LEAFREF) &&
3988 !warn_is_specific_type(sleaf->type, LY_TYPE_INST)) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003989 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"leafref\" nor \"instance-identifier\".",
3990 __func__, sleaf->name);
3991 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003992 }
Michal Vasko1a09b212021-05-06 13:00:10 +02003993 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko423ba3f2021-07-19 13:08:50 +02003994 if (sleaf && (sleaf->nodetype & LYD_NODE_TERM) && (sleaf->type->basetype == LY_TYPE_LEAFREF)) {
Michal Vasko004d3152020-06-11 19:59:22 +02003995 lref = (struct lysc_type_leafref *)sleaf->type;
Michal Vaskod1e53b92021-01-28 13:11:06 +01003996 oper = (sleaf->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Michal Vasko004d3152020-06-11 19:59:22 +02003997
3998 /* it was already evaluated on schema, it must succeed */
Michal Vasko741bb562021-06-24 11:59:50 +02003999 r = ly_path_compile_leafref(set->ctx, &sleaf->node, NULL, lref->path, oper, LY_PATH_TARGET_MANY,
Michal Vasko24fc4d12021-07-12 14:41:20 +02004000 LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &p);
Michal Vasko741bb562021-06-24 11:59:50 +02004001 if (!r) {
4002 /* get the target node */
4003 target = p[LY_ARRAY_COUNT(p) - 1].node;
4004 ly_path_free(set->ctx, p);
Michal Vasko004d3152020-06-11 19:59:22 +02004005
Michal Vasko7333cb32022-07-29 16:30:29 +02004006 LY_CHECK_RET(set_scnode_insert_node(set, target, LYXP_NODE_ELEM, LYXP_AXIS_SELF, NULL));
Michal Vasko741bb562021-06-24 11:59:50 +02004007 } /* else the target was found before but is disabled so it was removed */
Michal Vaskoae9e4cb2019-09-25 08:43:05 +02004008 }
4009
Michal Vasko741bb562021-06-24 11:59:50 +02004010 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004011 }
4012
Michal Vaskod3678892020-05-21 10:06:58 +02004013 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004014 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "deref(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004015 return LY_EVALID;
4016 }
4017
Michal Vaskod3678892020-05-21 10:06:58 +02004018 lyxp_set_free_content(set);
4019 if (args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004020 leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
4021 sleaf = (struct lysc_node_leaf *)leaf->schema;
4022 if (sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
4023 if (sleaf->type->basetype == LY_TYPE_LEAFREF) {
4024 /* find leafref target */
Radek Krejci0b013302021-03-29 15:22:32 +02004025 if (lyplg_type_resolve_leafref((struct lysc_type_leafref *)sleaf->type, &leaf->node, &leaf->value, set->tree,
Michal Vasko9e685082021-01-29 14:49:09 +01004026 &node, &errmsg)) {
Michal Vasko004d3152020-06-11 19:59:22 +02004027 LOGERR(set->ctx, LY_EVALID, errmsg);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004028 free(errmsg);
Michal Vasko004d3152020-06-11 19:59:22 +02004029 return LY_EVALID;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004030 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004031 } else {
4032 assert(sleaf->type->basetype == LY_TYPE_INST);
Michal Vasko004d3152020-06-11 19:59:22 +02004033 if (ly_path_eval(leaf->value.target, set->tree, &node)) {
Michal Vaskoba99a3e2020-08-18 15:50:05 +02004034 LOGERR(set->ctx, LY_EVALID, "Invalid instance-identifier \"%s\" value - required instance not found.",
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02004035 lyd_get_value(&leaf->node));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004036 return LY_EVALID;
4037 }
4038 }
Michal Vasko004d3152020-06-11 19:59:22 +02004039
4040 /* insert it */
4041 set_insert_node(set, node, 0, LYXP_NODE_ELEM, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004042 }
4043 }
4044
4045 return LY_SUCCESS;
4046}
4047
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004048static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02004049xpath_derived_(struct lyxp_set **args, struct lyxp_set *set, uint32_t options, ly_bool self_match, const char *func)
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004050{
Michal Vaskofe1af042022-07-29 14:58:59 +02004051 uint32_t i, id_len;
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004052 LY_ARRAY_COUNT_TYPE u;
4053 struct lyd_node_term *leaf;
4054 struct lysc_node_leaf *sleaf;
4055 struct lyd_meta *meta;
Michal Vasko93923692021-05-07 15:28:02 +02004056 struct lyd_value *val;
4057 const struct lys_module *mod;
4058 const char *id_name;
Michal Vasko93923692021-05-07 15:28:02 +02004059 struct lysc_ident *id;
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004060 LY_ERR rc = LY_SUCCESS;
Radek Krejci857189e2020-09-01 13:26:36 +02004061 ly_bool found;
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004062
4063 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02004064 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004065 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", func);
Michal Vasko5676f4e2021-04-06 17:14:45 +02004066 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4067 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4068 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", func, lys_nodetype2str(sleaf->nodetype),
4069 sleaf->name);
4070 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_IDENT)) {
4071 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"identityref\".", func, sleaf->name);
4072 }
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004073 }
4074
4075 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4076 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4077 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", func, lys_nodetype2str(sleaf->nodetype),
Michal Vasko69730152020-10-09 16:30:07 +02004078 sleaf->name);
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004079 } else if (!warn_is_string_type(sleaf->type)) {
4080 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", func, sleaf->name);
4081 }
4082 }
Michal Vasko1a09b212021-05-06 13:00:10 +02004083 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004084 return rc;
4085 }
4086
4087 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004088 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "derived-from(-or-self)(node-set, string)");
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004089 return LY_EVALID;
4090 }
4091 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
4092 LY_CHECK_RET(rc);
4093
Michal Vasko93923692021-05-07 15:28:02 +02004094 /* parse the identity */
4095 id_name = args[1]->val.str;
4096 id_len = strlen(id_name);
4097 rc = moveto_resolve_model(&id_name, &id_len, set, set->cur_node ? set->cur_node->schema : NULL, &mod);
4098 LY_CHECK_RET(rc);
4099 if (!mod) {
4100 LOGVAL(set->ctx, LYVE_XPATH, "Identity \"%.*s\" without a prefix.", (int)id_len, id_name);
4101 return LY_EVALID;
4102 }
4103
4104 /* find the identity */
4105 found = 0;
4106 LY_ARRAY_FOR(mod->identities, u) {
4107 if (!ly_strncmp(mod->identities[u].name, id_name, id_len)) {
4108 /* we have match */
4109 found = 1;
4110 break;
4111 }
4112 }
4113 if (!found) {
4114 LOGVAL(set->ctx, LYVE_XPATH, "Identity \"%.*s\" not found in module \"%s\".", (int)id_len, id_name, mod->name);
4115 return LY_EVALID;
4116 }
4117 id = &mod->identities[u];
4118
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004119 set_fill_boolean(set, 0);
4120 found = 0;
4121 for (i = 0; i < args[0]->used; ++i) {
4122 if ((args[0]->val.nodes[i].type != LYXP_NODE_ELEM) && (args[0]->val.nodes[i].type != LYXP_NODE_META)) {
4123 continue;
4124 }
4125
4126 if (args[0]->val.nodes[i].type == LYXP_NODE_ELEM) {
4127 leaf = (struct lyd_node_term *)args[0]->val.nodes[i].node;
4128 sleaf = (struct lysc_node_leaf *)leaf->schema;
4129 val = &leaf->value;
4130 if (!(sleaf->nodetype & LYD_NODE_TERM) || (leaf->value.realtype->basetype != LY_TYPE_IDENT)) {
4131 /* uninteresting */
4132 continue;
4133 }
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004134 } else {
4135 meta = args[0]->val.meta[i].meta;
4136 val = &meta->value;
4137 if (val->realtype->basetype != LY_TYPE_IDENT) {
4138 /* uninteresting */
4139 continue;
4140 }
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004141 }
4142
Michal Vasko93923692021-05-07 15:28:02 +02004143 /* check the identity itself */
4144 if (self_match && (id == val->ident)) {
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004145 set_fill_boolean(set, 1);
4146 found = 1;
4147 }
Michal Vasko93923692021-05-07 15:28:02 +02004148 if (!found && !lyplg_type_identity_isderived(id, val->ident)) {
4149 set_fill_boolean(set, 1);
4150 found = 1;
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004151 }
4152
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004153 if (found) {
4154 break;
4155 }
4156 }
4157
4158 return LY_SUCCESS;
4159}
4160
Michal Vasko03ff5a72019-09-11 13:49:33 +02004161/**
4162 * @brief Execute the YANG 1.1 derived-from(node-set, string) function. Returns LYXP_SET_BOOLEAN depending
4163 * on whether the first argument nodes contain a node of an identity derived from the second
4164 * argument identity.
4165 *
4166 * @param[in] args Array of arguments.
4167 * @param[in] arg_count Count of elements in @p args.
4168 * @param[in,out] set Context and result set at the same time.
4169 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004170 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004171 */
4172static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004173xpath_derived_from(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004174{
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004175 return xpath_derived_(args, set, options, 0, __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004176}
4177
4178/**
4179 * @brief Execute the YANG 1.1 derived-from-or-self(node-set, string) function. Returns LYXP_SET_BOOLEAN depending
4180 * on whether the first argument nodes contain a node of an identity that either is or is derived from
4181 * the second argument identity.
4182 *
4183 * @param[in] args Array of arguments.
4184 * @param[in] arg_count Count of elements in @p args.
4185 * @param[in,out] set Context and result set at the same time.
4186 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004187 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004188 */
4189static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004190xpath_derived_from_or_self(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004191{
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02004192 return xpath_derived_(args, set, options, 1, __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004193}
4194
4195/**
4196 * @brief Execute the YANG 1.1 enum-value(node-set) function. Returns LYXP_SET_NUMBER
4197 * with the integer value of the first node's enum value, otherwise NaN.
4198 *
4199 * @param[in] args Array of arguments.
4200 * @param[in] arg_count Count of elements in @p args.
4201 * @param[in,out] set Context and result set at the same time.
4202 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004203 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004204 */
4205static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004206xpath_enum_value(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004207{
4208 struct lyd_node_term *leaf;
4209 struct lysc_node_leaf *sleaf;
4210 LY_ERR rc = LY_SUCCESS;
4211
4212 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02004213 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004214 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko5676f4e2021-04-06 17:14:45 +02004215 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4216 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4217 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
4218 sleaf->name);
4219 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_ENUM)) {
4220 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"enumeration\".", __func__, sleaf->name);
4221 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004222 }
Michal Vasko1a09b212021-05-06 13:00:10 +02004223 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004224 return rc;
4225 }
4226
Michal Vaskod3678892020-05-21 10:06:58 +02004227 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004228 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "enum-value(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004229 return LY_EVALID;
4230 }
4231
4232 set_fill_number(set, NAN);
Michal Vaskod3678892020-05-21 10:06:58 +02004233 if (args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004234 leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
4235 sleaf = (struct lysc_node_leaf *)leaf->schema;
4236 if ((sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST)) && (sleaf->type->basetype == LY_TYPE_ENUM)) {
4237 set_fill_number(set, leaf->value.enum_item->value);
4238 }
4239 }
4240
4241 return LY_SUCCESS;
4242}
4243
4244/**
4245 * @brief Execute the XPath false() function. Returns LYXP_SET_BOOLEAN
4246 * with false value.
4247 *
4248 * @param[in] args Array of arguments.
4249 * @param[in] arg_count Count of elements in @p args.
4250 * @param[in,out] set Context and result set at the same time.
4251 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004252 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004253 */
4254static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004255xpath_false(struct lyxp_set **UNUSED(args), uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004256{
4257 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004258 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004259 return LY_SUCCESS;
4260 }
4261
4262 set_fill_boolean(set, 0);
4263 return LY_SUCCESS;
4264}
4265
4266/**
4267 * @brief Execute the XPath floor(number) function. Returns LYXP_SET_NUMBER
4268 * with the first argument floored (truncated).
4269 *
4270 * @param[in] args Array of arguments.
4271 * @param[in] arg_count Count of elements in @p args.
4272 * @param[in,out] set Context and result set at the same time.
4273 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004274 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004275 */
4276static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004277xpath_floor(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t UNUSED(options))
Michal Vasko03ff5a72019-09-11 13:49:33 +02004278{
4279 LY_ERR rc;
4280
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004281 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004282 LY_CHECK_RET(rc);
4283 if (isfinite(args[0]->val.num)) {
4284 set_fill_number(set, (long long)args[0]->val.num);
4285 }
4286
4287 return LY_SUCCESS;
4288}
4289
4290/**
4291 * @brief Execute the XPath lang(string) function. Returns LYXP_SET_BOOLEAN
4292 * whether the language of the text matches the one from the argument.
4293 *
4294 * @param[in] args Array of arguments.
4295 * @param[in] arg_count Count of elements in @p args.
4296 * @param[in,out] set Context and result set at the same time.
4297 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004298 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004299 */
4300static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004301xpath_lang(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004302{
4303 const struct lyd_node *node;
4304 struct lysc_node_leaf *sleaf;
Michal Vasko9f96a052020-03-10 09:41:45 +01004305 struct lyd_meta *meta = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004306 const char *val;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004307 LY_ERR rc = LY_SUCCESS;
4308
4309 if (options & LYXP_SCNODE_ALL) {
4310 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4311 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004312 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
4313 sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004314 } else if (!warn_is_string_type(sleaf->type)) {
4315 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004316 }
4317 }
Michal Vasko1a09b212021-05-06 13:00:10 +02004318 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004319 return rc;
4320 }
4321
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004322 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004323 LY_CHECK_RET(rc);
4324
Michal Vasko03ff5a72019-09-11 13:49:33 +02004325 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004326 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "lang(string)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004327 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004328 } else if (!set->used) {
4329 set_fill_boolean(set, 0);
4330 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004331 }
4332
4333 switch (set->val.nodes[0].type) {
4334 case LYXP_NODE_ELEM:
4335 case LYXP_NODE_TEXT:
4336 node = set->val.nodes[0].node;
4337 break;
Michal Vasko9f96a052020-03-10 09:41:45 +01004338 case LYXP_NODE_META:
4339 node = set->val.meta[0].meta->parent;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004340 break;
4341 default:
4342 /* nothing to do with roots */
4343 set_fill_boolean(set, 0);
4344 return LY_SUCCESS;
4345 }
4346
Michal Vasko9f96a052020-03-10 09:41:45 +01004347 /* find lang metadata */
Michal Vasko9e685082021-01-29 14:49:09 +01004348 for ( ; node; node = lyd_parent(node)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01004349 for (meta = node->meta; meta; meta = meta->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004350 /* annotations */
Michal Vasko9f96a052020-03-10 09:41:45 +01004351 if (meta->name && !strcmp(meta->name, "lang") && !strcmp(meta->annotation->module->name, "xml")) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004352 break;
4353 }
4354 }
4355
Michal Vasko9f96a052020-03-10 09:41:45 +01004356 if (meta) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004357 break;
4358 }
4359 }
4360
4361 /* compare languages */
Michal Vasko9f96a052020-03-10 09:41:45 +01004362 if (!meta) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004363 set_fill_boolean(set, 0);
4364 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004365 uint64_t i;
4366
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02004367 val = lyd_get_meta_value(meta);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004368 for (i = 0; args[0]->val.str[i]; ++i) {
4369 if (tolower(args[0]->val.str[i]) != tolower(val[i])) {
4370 set_fill_boolean(set, 0);
4371 break;
4372 }
4373 }
4374 if (!args[0]->val.str[i]) {
4375 if (!val[i] || (val[i] == '-')) {
4376 set_fill_boolean(set, 1);
4377 } else {
4378 set_fill_boolean(set, 0);
4379 }
4380 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004381 }
4382
4383 return LY_SUCCESS;
4384}
4385
4386/**
4387 * @brief Execute the XPath last() function. Returns LYXP_SET_NUMBER
4388 * with the context size.
4389 *
4390 * @param[in] args Array of arguments.
4391 * @param[in] arg_count Count of elements in @p args.
4392 * @param[in,out] set Context and result set at the same time.
4393 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004394 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004395 */
4396static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004397xpath_last(struct lyxp_set **UNUSED(args), uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004398{
4399 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004400 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004401 return LY_SUCCESS;
4402 }
4403
Michal Vasko03ff5a72019-09-11 13:49:33 +02004404 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004405 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "last()");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004406 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004407 } else if (!set->used) {
4408 set_fill_number(set, 0);
4409 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004410 }
4411
4412 set_fill_number(set, set->ctx_size);
4413 return LY_SUCCESS;
4414}
4415
4416/**
4417 * @brief Execute the XPath local-name(node-set?) function. Returns LYXP_SET_STRING
4418 * with the node name without namespace from the argument or the context.
4419 *
4420 * @param[in] args Array of arguments.
4421 * @param[in] arg_count Count of elements in @p args.
4422 * @param[in,out] set Context and result set at the same time.
4423 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004424 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004425 */
4426static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004427xpath_local_name(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004428{
4429 struct lyxp_set_node *item;
Michal Vasko69730152020-10-09 16:30:07 +02004430
Michal Vasko03ff5a72019-09-11 13:49:33 +02004431 /* suppress unused variable warning */
4432 (void)options;
4433
4434 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004435 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004436 return LY_SUCCESS;
4437 }
4438
4439 if (arg_count) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004440 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004441 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]),
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004442 "local-name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004443 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004444 } else if (!args[0]->used) {
4445 set_fill_string(set, "", 0);
4446 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004447 }
4448
4449 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004450 assert(!set_sort(args[0]));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004451
4452 item = &args[0]->val.nodes[0];
4453 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004454 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004455 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "local-name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004456 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004457 } else if (!set->used) {
4458 set_fill_string(set, "", 0);
4459 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004460 }
4461
4462 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004463 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004464
4465 item = &set->val.nodes[0];
4466 }
4467
4468 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01004469 case LYXP_NODE_NONE:
4470 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004471 case LYXP_NODE_ROOT:
4472 case LYXP_NODE_ROOT_CONFIG:
4473 case LYXP_NODE_TEXT:
4474 set_fill_string(set, "", 0);
4475 break;
4476 case LYXP_NODE_ELEM:
4477 set_fill_string(set, item->node->schema->name, strlen(item->node->schema->name));
4478 break;
Michal Vasko9f96a052020-03-10 09:41:45 +01004479 case LYXP_NODE_META:
4480 set_fill_string(set, ((struct lyd_meta *)item->node)->name, strlen(((struct lyd_meta *)item->node)->name));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004481 break;
4482 }
4483
4484 return LY_SUCCESS;
4485}
4486
4487/**
4488 * @brief Execute the XPath name(node-set?) function. Returns LYXP_SET_STRING
4489 * with the node name fully qualified (with namespace) from the argument or the context.
4490 *
4491 * @param[in] args Array of arguments.
4492 * @param[in] arg_count Count of elements in @p args.
4493 * @param[in,out] set Context and result set at the same time.
4494 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004495 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004496 */
4497static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004498xpath_name(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004499{
4500 struct lyxp_set_node *item;
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02004501 struct lys_module *mod = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004502 char *str;
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02004503 const char *name = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004504
4505 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004506 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004507 return LY_SUCCESS;
4508 }
4509
4510 if (arg_count) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004511 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004512 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004513 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004514 } else if (!args[0]->used) {
4515 set_fill_string(set, "", 0);
4516 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004517 }
4518
4519 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004520 assert(!set_sort(args[0]));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004521
4522 item = &args[0]->val.nodes[0];
4523 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004524 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004525 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004526 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004527 } else if (!set->used) {
4528 set_fill_string(set, "", 0);
4529 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004530 }
4531
4532 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004533 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004534
4535 item = &set->val.nodes[0];
4536 }
4537
4538 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01004539 case LYXP_NODE_NONE:
4540 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004541 case LYXP_NODE_ROOT:
4542 case LYXP_NODE_ROOT_CONFIG:
4543 case LYXP_NODE_TEXT:
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02004544 /* keep NULL */
Michal Vasko03ff5a72019-09-11 13:49:33 +02004545 break;
4546 case LYXP_NODE_ELEM:
4547 mod = item->node->schema->module;
4548 name = item->node->schema->name;
4549 break;
Michal Vasko9f96a052020-03-10 09:41:45 +01004550 case LYXP_NODE_META:
4551 mod = ((struct lyd_meta *)item->node)->annotation->module;
4552 name = ((struct lyd_meta *)item->node)->name;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004553 break;
4554 }
4555
4556 if (mod && name) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004557 int rc = asprintf(&str, "%s:%s", ly_get_prefix(mod, set->format, set->prefix_data), name);
Michal Vasko26bbb272022-08-02 14:54:33 +02004558
Michal Vasko03ff5a72019-09-11 13:49:33 +02004559 LY_CHECK_ERR_RET(rc == -1, LOGMEM(set->ctx), LY_EMEM);
4560 set_fill_string(set, str, strlen(str));
4561 free(str);
4562 } else {
4563 set_fill_string(set, "", 0);
4564 }
4565
4566 return LY_SUCCESS;
4567}
4568
4569/**
4570 * @brief Execute the XPath namespace-uri(node-set?) function. Returns LYXP_SET_STRING
4571 * with the namespace of the node from the argument or the context.
4572 *
4573 * @param[in] args Array of arguments.
4574 * @param[in] arg_count Count of elements in @p args.
4575 * @param[in,out] set Context and result set at the same time.
4576 * @param[in] options XPath options.
4577 * @return LY_ERR (LY_EINVAL for wrong arguments on schema)
4578 */
4579static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004580xpath_namespace_uri(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004581{
4582 struct lyxp_set_node *item;
4583 struct lys_module *mod;
Michal Vasko69730152020-10-09 16:30:07 +02004584
Michal Vasko03ff5a72019-09-11 13:49:33 +02004585 /* suppress unused variable warning */
4586 (void)options;
4587
4588 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004589 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004590 return LY_SUCCESS;
4591 }
4592
4593 if (arg_count) {
Michal Vaskod3678892020-05-21 10:06:58 +02004594 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004595 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]),
Michal Vasko69730152020-10-09 16:30:07 +02004596 "namespace-uri(node-set?)");
Michal Vaskod3678892020-05-21 10:06:58 +02004597 return LY_EVALID;
4598 } else if (!args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004599 set_fill_string(set, "", 0);
4600 return LY_SUCCESS;
4601 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004602
4603 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004604 assert(!set_sort(args[0]));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004605
4606 item = &args[0]->val.nodes[0];
4607 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004608 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004609 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "namespace-uri(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004610 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004611 } else if (!set->used) {
4612 set_fill_string(set, "", 0);
4613 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004614 }
4615
4616 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004617 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004618
4619 item = &set->val.nodes[0];
4620 }
4621
4622 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01004623 case LYXP_NODE_NONE:
4624 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004625 case LYXP_NODE_ROOT:
4626 case LYXP_NODE_ROOT_CONFIG:
4627 case LYXP_NODE_TEXT:
4628 set_fill_string(set, "", 0);
4629 break;
4630 case LYXP_NODE_ELEM:
Michal Vasko9f96a052020-03-10 09:41:45 +01004631 case LYXP_NODE_META:
Michal Vasko03ff5a72019-09-11 13:49:33 +02004632 if (item->type == LYXP_NODE_ELEM) {
4633 mod = item->node->schema->module;
Michal Vasko9f96a052020-03-10 09:41:45 +01004634 } else { /* LYXP_NODE_META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02004635 /* annotations */
Michal Vasko9f96a052020-03-10 09:41:45 +01004636 mod = ((struct lyd_meta *)item->node)->annotation->module;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004637 }
4638
4639 set_fill_string(set, mod->ns, strlen(mod->ns));
4640 break;
4641 }
4642
4643 return LY_SUCCESS;
4644}
4645
4646/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02004647 * @brief Execute the XPath normalize-space(string?) function. Returns LYXP_SET_STRING
4648 * with normalized value (no leading, trailing, double white spaces) of the node
4649 * from the argument or the context.
4650 *
4651 * @param[in] args Array of arguments.
4652 * @param[in] arg_count Count of elements in @p args.
4653 * @param[in,out] set Context and result set at the same time.
4654 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004655 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004656 */
4657static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004658xpath_normalize_space(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004659{
Michal Vaskodd528af2022-08-08 14:35:07 +02004660 uint32_t i, new_used;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004661 char *new;
Radek Krejci857189e2020-09-01 13:26:36 +02004662 ly_bool have_spaces = 0, space_before = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004663 struct lysc_node_leaf *sleaf;
4664 LY_ERR rc = LY_SUCCESS;
4665
4666 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004667 if (arg_count && (args[0]->type == LYXP_SET_SCNODE_SET) &&
4668 (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004669 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004670 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
4671 sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004672 } else if (!warn_is_string_type(sleaf->type)) {
4673 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004674 }
4675 }
Michal Vasko1a09b212021-05-06 13:00:10 +02004676 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004677 return rc;
4678 }
4679
4680 if (arg_count) {
4681 set_fill_set(set, args[0]);
4682 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004683 rc = lyxp_set_cast(set, LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004684 LY_CHECK_RET(rc);
4685
4686 /* is there any normalization necessary? */
4687 for (i = 0; set->val.str[i]; ++i) {
4688 if (is_xmlws(set->val.str[i])) {
4689 if ((i == 0) || space_before || (!set->val.str[i + 1])) {
4690 have_spaces = 1;
4691 break;
4692 }
4693 space_before = 1;
4694 } else {
4695 space_before = 0;
4696 }
4697 }
4698
4699 /* yep, there is */
4700 if (have_spaces) {
4701 /* it's enough, at least one character will go, makes space for ending '\0' */
4702 new = malloc(strlen(set->val.str) * sizeof(char));
4703 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
4704 new_used = 0;
4705
4706 space_before = 0;
4707 for (i = 0; set->val.str[i]; ++i) {
4708 if (is_xmlws(set->val.str[i])) {
4709 if ((i == 0) || space_before) {
4710 space_before = 1;
4711 continue;
4712 } else {
4713 space_before = 1;
4714 }
4715 } else {
4716 space_before = 0;
4717 }
4718
4719 new[new_used] = (space_before ? ' ' : set->val.str[i]);
4720 ++new_used;
4721 }
4722
4723 /* at worst there is one trailing space now */
4724 if (new_used && is_xmlws(new[new_used - 1])) {
4725 --new_used;
4726 }
4727
4728 new = ly_realloc(new, (new_used + 1) * sizeof(char));
4729 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
4730 new[new_used] = '\0';
4731
4732 free(set->val.str);
4733 set->val.str = new;
4734 }
4735
4736 return LY_SUCCESS;
4737}
4738
4739/**
4740 * @brief Execute the XPath not(boolean) function. Returns LYXP_SET_BOOLEAN
4741 * with the argument converted to boolean and logically inverted.
4742 *
4743 * @param[in] args Array of arguments.
4744 * @param[in] arg_count Count of elements in @p args.
4745 * @param[in,out] set Context and result set at the same time.
4746 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004747 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004748 */
4749static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004750xpath_not(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004751{
4752 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004753 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004754 return LY_SUCCESS;
4755 }
4756
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004757 lyxp_set_cast(args[0], LYXP_SET_BOOLEAN);
Michal Vasko004d3152020-06-11 19:59:22 +02004758 if (args[0]->val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004759 set_fill_boolean(set, 0);
4760 } else {
4761 set_fill_boolean(set, 1);
4762 }
4763
4764 return LY_SUCCESS;
4765}
4766
4767/**
4768 * @brief Execute the XPath number(object?) function. Returns LYXP_SET_NUMBER
4769 * with the number representation of either the argument or the context.
4770 *
4771 * @param[in] args Array of arguments.
4772 * @param[in] arg_count Count of elements in @p args.
4773 * @param[in,out] set Context and result set at the same time.
4774 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004775 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004776 */
4777static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004778xpath_number(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004779{
4780 LY_ERR rc;
4781
4782 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004783 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004784 return LY_SUCCESS;
4785 }
4786
4787 if (arg_count) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004788 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004789 LY_CHECK_RET(rc);
4790 set_fill_set(set, args[0]);
4791 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004792 rc = lyxp_set_cast(set, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004793 LY_CHECK_RET(rc);
4794 }
4795
4796 return LY_SUCCESS;
4797}
4798
4799/**
4800 * @brief Execute the XPath position() function. Returns LYXP_SET_NUMBER
4801 * with the context position.
4802 *
4803 * @param[in] args Array of arguments.
4804 * @param[in] arg_count Count of elements in @p args.
4805 * @param[in,out] set Context and result set at the same time.
4806 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004807 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004808 */
4809static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004810xpath_position(struct lyxp_set **UNUSED(args), uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004811{
4812 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004813 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004814 return LY_SUCCESS;
4815 }
4816
Michal Vasko03ff5a72019-09-11 13:49:33 +02004817 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004818 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "position()");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004819 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004820 } else if (!set->used) {
4821 set_fill_number(set, 0);
4822 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004823 }
4824
4825 set_fill_number(set, set->ctx_pos);
4826
4827 /* UNUSED in 'Release' build type */
4828 (void)options;
4829 return LY_SUCCESS;
4830}
4831
4832/**
4833 * @brief Execute the YANG 1.1 re-match(string, string) function. Returns LYXP_SET_BOOLEAN
4834 * depending on whether the second argument regex matches the first argument string. For details refer to
4835 * YANG 1.1 RFC section 10.2.1.
4836 *
4837 * @param[in] args Array of arguments.
4838 * @param[in] arg_count Count of elements in @p args.
4839 * @param[in,out] set Context and result set at the same time.
4840 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004841 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004842 */
4843static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004844xpath_re_match(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004845{
4846 struct lysc_pattern **patterns = NULL, **pattern;
4847 struct lysc_node_leaf *sleaf;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004848 LY_ERR rc = LY_SUCCESS;
4849 struct ly_err_item *err;
4850
4851 if (options & LYXP_SCNODE_ALL) {
4852 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4853 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4854 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004855 } else if (!warn_is_string_type(sleaf->type)) {
4856 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004857 }
4858 }
4859
4860 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4861 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4862 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004863 } else if (!warn_is_string_type(sleaf->type)) {
4864 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004865 }
4866 }
Michal Vasko1a09b212021-05-06 13:00:10 +02004867 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004868 return rc;
4869 }
4870
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004871 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004872 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004873 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004874 LY_CHECK_RET(rc);
4875
4876 LY_ARRAY_NEW_RET(set->ctx, patterns, pattern, LY_EMEM);
Radek Iša45802b52021-02-09 09:21:58 +01004877 *pattern = calloc(1, sizeof **pattern);
Radek Krejciddace2c2021-01-08 11:30:56 +01004878 LOG_LOCSET(NULL, set->cur_node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01004879 rc = lys_compile_type_pattern_check(set->ctx, args[1]->val.str, &(*pattern)->code);
Michal Vasko4a7d4d62021-12-13 17:05:06 +01004880 if (set->cur_node) {
4881 LOG_LOCBACK(0, 1, 0, 0);
4882 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004883 if (rc != LY_SUCCESS) {
4884 LY_ARRAY_FREE(patterns);
4885 return rc;
4886 }
4887
Radek Krejci0b013302021-03-29 15:22:32 +02004888 rc = lyplg_type_validate_patterns(patterns, args[0]->val.str, strlen(args[0]->val.str), &err);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004889 pcre2_code_free((*pattern)->code);
4890 free(*pattern);
4891 LY_ARRAY_FREE(patterns);
4892 if (rc && (rc != LY_EVALID)) {
Michal Vasko177d0ed2020-11-23 16:43:03 +01004893 ly_err_print(set->ctx, err);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004894 ly_err_free(err);
4895 return rc;
4896 }
4897
4898 if (rc == LY_EVALID) {
4899 ly_err_free(err);
4900 set_fill_boolean(set, 0);
4901 } else {
4902 set_fill_boolean(set, 1);
4903 }
4904
4905 return LY_SUCCESS;
4906}
4907
4908/**
4909 * @brief Execute the XPath round(number) function. Returns LYXP_SET_NUMBER
4910 * with the rounded first argument. For details refer to
4911 * http://www.w3.org/TR/1999/REC-xpath-19991116/#function-round.
4912 *
4913 * @param[in] args Array of arguments.
4914 * @param[in] arg_count Count of elements in @p args.
4915 * @param[in,out] set Context and result set at the same time.
4916 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004917 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004918 */
4919static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004920xpath_round(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004921{
4922 struct lysc_node_leaf *sleaf;
4923 LY_ERR rc = LY_SUCCESS;
4924
4925 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02004926 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004927 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko5676f4e2021-04-06 17:14:45 +02004928 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4929 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4930 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
4931 sleaf->name);
4932 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_DEC64)) {
4933 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"decimal64\".", __func__, sleaf->name);
4934 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004935 }
Michal Vasko1a09b212021-05-06 13:00:10 +02004936 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004937 return rc;
4938 }
4939
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004940 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004941 LY_CHECK_RET(rc);
4942
4943 /* cover only the cases where floor can't be used */
4944 if ((args[0]->val.num == -0.0f) || ((args[0]->val.num < 0) && (args[0]->val.num >= -0.5))) {
4945 set_fill_number(set, -0.0f);
4946 } else {
4947 args[0]->val.num += 0.5;
4948 rc = xpath_floor(args, 1, args[0], options);
4949 LY_CHECK_RET(rc);
4950 set_fill_number(set, args[0]->val.num);
4951 }
4952
4953 return LY_SUCCESS;
4954}
4955
4956/**
4957 * @brief Execute the XPath starts-with(string, string) function.
4958 * Returns LYXP_SET_BOOLEAN whether the second argument is
4959 * the prefix of the first or not.
4960 *
4961 * @param[in] args Array of arguments.
4962 * @param[in] arg_count Count of elements in @p args.
4963 * @param[in,out] set Context and result set at the same time.
4964 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004965 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004966 */
4967static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02004968xpath_starts_with(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004969{
4970 struct lysc_node_leaf *sleaf;
4971 LY_ERR rc = LY_SUCCESS;
4972
4973 if (options & LYXP_SCNODE_ALL) {
4974 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4975 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4976 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004977 } else if (!warn_is_string_type(sleaf->type)) {
4978 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004979 }
4980 }
4981
4982 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4983 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4984 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004985 } else if (!warn_is_string_type(sleaf->type)) {
4986 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004987 }
4988 }
Michal Vasko1a09b212021-05-06 13:00:10 +02004989 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004990 return rc;
4991 }
4992
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004993 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004994 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004995 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004996 LY_CHECK_RET(rc);
4997
4998 if (strncmp(args[0]->val.str, args[1]->val.str, strlen(args[1]->val.str))) {
4999 set_fill_boolean(set, 0);
5000 } else {
5001 set_fill_boolean(set, 1);
5002 }
5003
5004 return LY_SUCCESS;
5005}
5006
5007/**
5008 * @brief Execute the XPath string(object?) function. Returns LYXP_SET_STRING
5009 * with the string representation of either the argument or the context.
5010 *
5011 * @param[in] args Array of arguments.
5012 * @param[in] arg_count Count of elements in @p args.
5013 * @param[in,out] set Context and result set at the same time.
5014 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005015 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005016 */
5017static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02005018xpath_string(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005019{
5020 LY_ERR rc;
5021
5022 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02005023 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005024 return LY_SUCCESS;
5025 }
5026
5027 if (arg_count) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005028 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005029 LY_CHECK_RET(rc);
5030 set_fill_set(set, args[0]);
5031 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005032 rc = lyxp_set_cast(set, LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005033 LY_CHECK_RET(rc);
5034 }
5035
5036 return LY_SUCCESS;
5037}
5038
5039/**
5040 * @brief Execute the XPath string-length(string?) function. Returns LYXP_SET_NUMBER
5041 * with the length of the string in either the argument or the context.
5042 *
5043 * @param[in] args Array of arguments.
5044 * @param[in] arg_count Count of elements in @p args.
5045 * @param[in,out] set Context and result set at the same time.
5046 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005047 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005048 */
5049static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02005050xpath_string_length(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005051{
5052 struct lysc_node_leaf *sleaf;
5053 LY_ERR rc = LY_SUCCESS;
5054
5055 if (options & LYXP_SCNODE_ALL) {
5056 if (arg_count && (args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
5057 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5058 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005059 } else if (!warn_is_string_type(sleaf->type)) {
5060 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005061 }
5062 }
5063 if (!arg_count && (set->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set))) {
5064 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5065 LOGWRN(set->ctx, "Argument #0 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005066 } else if (!warn_is_string_type(sleaf->type)) {
5067 LOGWRN(set->ctx, "Argument #0 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005068 }
5069 }
Michal Vasko1a09b212021-05-06 13:00:10 +02005070 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005071 return rc;
5072 }
5073
5074 if (arg_count) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005075 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005076 LY_CHECK_RET(rc);
5077 set_fill_number(set, strlen(args[0]->val.str));
5078 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005079 rc = lyxp_set_cast(set, LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005080 LY_CHECK_RET(rc);
5081 set_fill_number(set, strlen(set->val.str));
5082 }
5083
5084 return LY_SUCCESS;
5085}
5086
5087/**
5088 * @brief Execute the XPath substring(string, number, number?) function.
5089 * Returns LYXP_SET_STRING substring of the first argument starting
5090 * on the second argument index ending on the third argument index,
5091 * indexed from 1. For exact definition refer to
5092 * http://www.w3.org/TR/1999/REC-xpath-19991116/#function-substring.
5093 *
5094 * @param[in] args Array of arguments.
5095 * @param[in] arg_count Count of elements in @p args.
5096 * @param[in,out] set Context and result set at the same time.
5097 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005098 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005099 */
5100static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02005101xpath_substring(struct lyxp_set **args, uint32_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005102{
Michal Vasko6db996e2022-07-28 10:28:04 +02005103 int64_t start;
5104 int32_t len;
Michal Vaskodd528af2022-08-08 14:35:07 +02005105 uint32_t str_start, str_len, pos;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005106 struct lysc_node_leaf *sleaf;
5107 LY_ERR rc = LY_SUCCESS;
5108
5109 if (options & LYXP_SCNODE_ALL) {
5110 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
5111 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5112 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005113 } else if (!warn_is_string_type(sleaf->type)) {
5114 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005115 }
5116 }
5117
5118 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
5119 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5120 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005121 } else if (!warn_is_numeric_type(sleaf->type)) {
5122 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005123 }
5124 }
5125
Michal Vasko69730152020-10-09 16:30:07 +02005126 if ((arg_count == 3) && (args[2]->type == LYXP_SET_SCNODE_SET) &&
5127 (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[2]))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005128 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5129 LOGWRN(set->ctx, "Argument #3 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005130 } else if (!warn_is_numeric_type(sleaf->type)) {
5131 LOGWRN(set->ctx, "Argument #3 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005132 }
5133 }
Michal Vasko1a09b212021-05-06 13:00:10 +02005134 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005135 return rc;
5136 }
5137
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005138 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005139 LY_CHECK_RET(rc);
5140
5141 /* start */
5142 if (xpath_round(&args[1], 1, args[1], options)) {
5143 return -1;
5144 }
5145 if (isfinite(args[1]->val.num)) {
5146 start = args[1]->val.num - 1;
5147 } else if (isinf(args[1]->val.num) && signbit(args[1]->val.num)) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02005148 start = INT32_MIN;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005149 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02005150 start = INT32_MAX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005151 }
5152
5153 /* len */
5154 if (arg_count == 3) {
5155 rc = xpath_round(&args[2], 1, args[2], options);
5156 LY_CHECK_RET(rc);
Radek Krejci1deb5be2020-08-26 16:43:36 +02005157 if (isnan(args[2]->val.num) || signbit(args[2]->val.num)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005158 len = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02005159 } else if (isfinite(args[2]->val.num)) {
5160 len = args[2]->val.num;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005161 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02005162 len = INT32_MAX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005163 }
5164 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02005165 len = INT32_MAX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005166 }
5167
5168 /* find matching character positions */
5169 str_start = 0;
5170 str_len = 0;
5171 for (pos = 0; args[0]->val.str[pos]; ++pos) {
5172 if (pos < start) {
5173 ++str_start;
5174 } else if (pos < start + len) {
5175 ++str_len;
5176 } else {
5177 break;
5178 }
5179 }
5180
5181 set_fill_string(set, args[0]->val.str + str_start, str_len);
5182 return LY_SUCCESS;
5183}
5184
5185/**
5186 * @brief Execute the XPath substring-after(string, string) function.
5187 * Returns LYXP_SET_STRING with the string succeeding the occurance
5188 * of the second argument in the first or an empty string.
5189 *
5190 * @param[in] args Array of arguments.
5191 * @param[in] arg_count Count of elements in @p args.
5192 * @param[in,out] set Context and result set at the same time.
5193 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005194 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005195 */
5196static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02005197xpath_substring_after(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005198{
5199 char *ptr;
5200 struct lysc_node_leaf *sleaf;
5201 LY_ERR rc = LY_SUCCESS;
5202
5203 if (options & LYXP_SCNODE_ALL) {
5204 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
5205 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5206 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005207 } else if (!warn_is_string_type(sleaf->type)) {
5208 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005209 }
5210 }
5211
5212 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
5213 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5214 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005215 } else if (!warn_is_string_type(sleaf->type)) {
5216 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005217 }
5218 }
Michal Vasko1a09b212021-05-06 13:00:10 +02005219 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005220 return rc;
5221 }
5222
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005223 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005224 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005225 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005226 LY_CHECK_RET(rc);
5227
5228 ptr = strstr(args[0]->val.str, args[1]->val.str);
5229 if (ptr) {
5230 set_fill_string(set, ptr + strlen(args[1]->val.str), strlen(ptr + strlen(args[1]->val.str)));
5231 } else {
5232 set_fill_string(set, "", 0);
5233 }
5234
5235 return LY_SUCCESS;
5236}
5237
5238/**
5239 * @brief Execute the XPath substring-before(string, string) function.
5240 * Returns LYXP_SET_STRING with the string preceding the occurance
5241 * of the second argument in the first or an empty string.
5242 *
5243 * @param[in] args Array of arguments.
5244 * @param[in] arg_count Count of elements in @p args.
5245 * @param[in,out] set Context and result set at the same time.
5246 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005247 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005248 */
5249static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02005250xpath_substring_before(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005251{
5252 char *ptr;
5253 struct lysc_node_leaf *sleaf;
5254 LY_ERR rc = LY_SUCCESS;
5255
5256 if (options & LYXP_SCNODE_ALL) {
5257 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
5258 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5259 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005260 } else if (!warn_is_string_type(sleaf->type)) {
5261 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005262 }
5263 }
5264
5265 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
5266 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5267 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005268 } else if (!warn_is_string_type(sleaf->type)) {
5269 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005270 }
5271 }
Michal Vasko1a09b212021-05-06 13:00:10 +02005272 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005273 return rc;
5274 }
5275
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005276 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005277 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005278 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005279 LY_CHECK_RET(rc);
5280
5281 ptr = strstr(args[0]->val.str, args[1]->val.str);
5282 if (ptr) {
5283 set_fill_string(set, args[0]->val.str, ptr - args[0]->val.str);
5284 } else {
5285 set_fill_string(set, "", 0);
5286 }
5287
5288 return LY_SUCCESS;
5289}
5290
5291/**
5292 * @brief Execute the XPath sum(node-set) function. Returns LYXP_SET_NUMBER
5293 * with the sum of all the nodes in the context.
5294 *
5295 * @param[in] args Array of arguments.
5296 * @param[in] arg_count Count of elements in @p args.
5297 * @param[in,out] set Context and result set at the same time.
5298 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005299 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005300 */
5301static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02005302xpath_sum(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005303{
5304 long double num;
5305 char *str;
Michal Vasko1fdd8fa2021-01-08 09:21:45 +01005306 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005307 struct lyxp_set set_item;
5308 struct lysc_node_leaf *sleaf;
5309 LY_ERR rc = LY_SUCCESS;
5310
5311 if (options & LYXP_SCNODE_ALL) {
5312 if (args[0]->type == LYXP_SET_SCNODE_SET) {
5313 for (i = 0; i < args[0]->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005314 if (args[0]->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005315 sleaf = (struct lysc_node_leaf *)args[0]->val.scnodes[i].scnode;
5316 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5317 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__,
Michal Vasko69730152020-10-09 16:30:07 +02005318 lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005319 } else if (!warn_is_numeric_type(sleaf->type)) {
5320 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005321 }
5322 }
5323 }
5324 }
Michal Vasko1a09b212021-05-06 13:00:10 +02005325 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005326 return rc;
5327 }
5328
5329 set_fill_number(set, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005330
5331 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005332 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "sum(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02005333 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02005334 } else if (!args[0]->used) {
5335 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005336 }
5337
Michal Vasko5c4e5892019-11-14 12:31:38 +01005338 set_init(&set_item, set);
5339
Michal Vasko03ff5a72019-09-11 13:49:33 +02005340 set_item.type = LYXP_SET_NODE_SET;
Michal Vasko41decbf2021-11-02 11:50:21 +01005341 set_item.val.nodes = calloc(1, sizeof *set_item.val.nodes);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005342 LY_CHECK_ERR_RET(!set_item.val.nodes, LOGMEM(set->ctx), LY_EMEM);
5343
5344 set_item.used = 1;
5345 set_item.size = 1;
5346
5347 for (i = 0; i < args[0]->used; ++i) {
5348 set_item.val.nodes[0] = args[0]->val.nodes[i];
5349
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005350 rc = cast_node_set_to_string(&set_item, &str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005351 LY_CHECK_RET(rc);
5352 num = cast_string_to_number(str);
5353 free(str);
5354 set->val.num += num;
5355 }
5356
5357 free(set_item.val.nodes);
5358
5359 return LY_SUCCESS;
5360}
5361
5362/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02005363 * @brief Execute the XPath translate(string, string, string) function.
5364 * Returns LYXP_SET_STRING with the first argument with the characters
5365 * from the second argument replaced by those on the corresponding
5366 * positions in the third argument.
5367 *
5368 * @param[in] args Array of arguments.
5369 * @param[in] arg_count Count of elements in @p args.
5370 * @param[in,out] set Context and result set at the same time.
5371 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005372 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005373 */
5374static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02005375xpath_translate(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005376{
Michal Vaskodd528af2022-08-08 14:35:07 +02005377 uint32_t i, j, new_used;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005378 char *new;
Radek Krejci857189e2020-09-01 13:26:36 +02005379 ly_bool have_removed;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005380 struct lysc_node_leaf *sleaf;
5381 LY_ERR rc = LY_SUCCESS;
5382
5383 if (options & LYXP_SCNODE_ALL) {
5384 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
5385 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5386 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005387 } else if (!warn_is_string_type(sleaf->type)) {
5388 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005389 }
5390 }
5391
5392 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
5393 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5394 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005395 } else if (!warn_is_string_type(sleaf->type)) {
5396 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005397 }
5398 }
5399
5400 if ((args[2]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[2]))) {
5401 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5402 LOGWRN(set->ctx, "Argument #3 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005403 } else if (!warn_is_string_type(sleaf->type)) {
5404 LOGWRN(set->ctx, "Argument #3 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005405 }
5406 }
Michal Vasko1a09b212021-05-06 13:00:10 +02005407 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005408 return rc;
5409 }
5410
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005411 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005412 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005413 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005414 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005415 rc = lyxp_set_cast(args[2], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005416 LY_CHECK_RET(rc);
5417
5418 new = malloc((strlen(args[0]->val.str) + 1) * sizeof(char));
5419 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
5420 new_used = 0;
5421
5422 have_removed = 0;
5423 for (i = 0; args[0]->val.str[i]; ++i) {
Radek Krejci857189e2020-09-01 13:26:36 +02005424 ly_bool found = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005425
5426 for (j = 0; args[1]->val.str[j]; ++j) {
5427 if (args[0]->val.str[i] == args[1]->val.str[j]) {
5428 /* removing this char */
5429 if (j >= strlen(args[2]->val.str)) {
5430 have_removed = 1;
5431 found = 1;
5432 break;
5433 }
5434 /* replacing this char */
5435 new[new_used] = args[2]->val.str[j];
5436 ++new_used;
5437 found = 1;
5438 break;
5439 }
5440 }
5441
5442 /* copying this char */
5443 if (!found) {
5444 new[new_used] = args[0]->val.str[i];
5445 ++new_used;
5446 }
5447 }
5448
5449 if (have_removed) {
5450 new = ly_realloc(new, (new_used + 1) * sizeof(char));
5451 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
5452 }
5453 new[new_used] = '\0';
5454
Michal Vaskod3678892020-05-21 10:06:58 +02005455 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005456 set->type = LYXP_SET_STRING;
5457 set->val.str = new;
5458
5459 return LY_SUCCESS;
5460}
5461
5462/**
5463 * @brief Execute the XPath true() function. Returns LYXP_SET_BOOLEAN
5464 * with true value.
5465 *
5466 * @param[in] args Array of arguments.
5467 * @param[in] arg_count Count of elements in @p args.
5468 * @param[in,out] set Context and result set at the same time.
5469 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005470 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005471 */
5472static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02005473xpath_true(struct lyxp_set **UNUSED(args), uint32_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005474{
5475 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02005476 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005477 return LY_SUCCESS;
5478 }
5479
5480 set_fill_boolean(set, 1);
5481 return LY_SUCCESS;
5482}
5483
Michal Vasko03ff5a72019-09-11 13:49:33 +02005484/**
Michal Vasko49fec8e2022-05-24 10:28:33 +02005485 * @brief Execute the XPath node() processing instruction (node type). Returns LYXP_SET_NODE_SET
5486 * with only nodes from the context.
5487 *
5488 * @param[in,out] set Context and result set at the same time.
5489 * @param[in] axis Axis to search on.
5490 * @param[in] options XPath options.
5491 * @return LY_ERR
5492 */
5493static LY_ERR
5494xpath_pi_node(struct lyxp_set *set, enum lyxp_axis axis, uint32_t options)
5495{
5496 if (options & LYXP_SCNODE_ALL) {
5497 return moveto_scnode(set, NULL, NULL, axis, options);
5498 }
5499
5500 if (set->type != LYXP_SET_NODE_SET) {
5501 lyxp_set_free_content(set);
5502 return LY_SUCCESS;
5503 }
5504
5505 /* just like moving to a node with no restrictions */
5506 return moveto_node(set, NULL, NULL, axis, options);
5507}
5508
5509/**
5510 * @brief Execute the XPath text() processing instruction (node type). Returns LYXP_SET_NODE_SET
5511 * with the text content of the nodes in the context.
5512 *
5513 * @param[in,out] set Context and result set at the same time.
5514 * @param[in] axis Axis to search on.
5515 * @param[in] options XPath options.
5516 * @return LY_ERR
5517 */
5518static LY_ERR
5519xpath_pi_text(struct lyxp_set *set, enum lyxp_axis axis, uint32_t options)
5520{
5521 uint32_t i;
5522
5523 if (options & LYXP_SCNODE_ALL) {
5524 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
5525 return LY_SUCCESS;
5526 }
5527
5528 if (set->type != LYXP_SET_NODE_SET) {
5529 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "text()");
5530 return LY_EVALID;
5531 }
5532
5533 if (axis != LYXP_AXIS_CHILD) {
5534 /* even following and preceding axescan return text nodes, but whatever */
5535 lyxp_set_free_content(set);
5536 return LY_SUCCESS;
5537 }
5538
5539 for (i = 0; i < set->used; ++i) {
5540 switch (set->val.nodes[i].type) {
5541 case LYXP_NODE_NONE:
5542 LOGINT_RET(set->ctx);
5543 case LYXP_NODE_ELEM:
5544 if (set->val.nodes[i].node->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
5545 set->val.nodes[i].type = LYXP_NODE_TEXT;
5546 break;
5547 }
5548 /* fall through */
5549 case LYXP_NODE_ROOT:
5550 case LYXP_NODE_ROOT_CONFIG:
5551 case LYXP_NODE_TEXT:
5552 case LYXP_NODE_META:
5553 set_remove_node_none(set, i);
5554 break;
5555 }
5556 }
5557 set_remove_nodes_none(set);
5558
5559 return LY_SUCCESS;
5560}
5561
5562/**
Michal Vasko6346ece2019-09-24 13:12:53 +02005563 * @brief Skip prefix and return corresponding model if there is a prefix. Logs directly.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005564 *
Michal Vasko2104e9f2020-03-06 08:23:25 +01005565 * XPath @p set is expected to be a (sc)node set!
5566 *
Michal Vasko6346ece2019-09-24 13:12:53 +02005567 * @param[in,out] qname Qualified node name. If includes prefix, it is skipped.
5568 * @param[in,out] qname_len Length of @p qname, is updated accordingly.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005569 * @param[in] set Set with general XPath context.
5570 * @param[in] ctx_scnode Context node to inherit module for unprefixed node for ::LY_PREF_JSON.
Michal Vasko6346ece2019-09-24 13:12:53 +02005571 * @param[out] moveto_mod Expected module of a matching node.
5572 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005573 */
Michal Vasko6346ece2019-09-24 13:12:53 +02005574static LY_ERR
Michal Vaskofe1af042022-07-29 14:58:59 +02005575moveto_resolve_model(const char **qname, uint32_t *qname_len, const struct lyxp_set *set,
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005576 const struct lysc_node *ctx_scnode, const struct lys_module **moveto_mod)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005577{
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02005578 const struct lys_module *mod = NULL;
Michal Vasko6346ece2019-09-24 13:12:53 +02005579 const char *ptr;
Radek Krejci1deb5be2020-08-26 16:43:36 +02005580 size_t pref_len;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005581
Michal Vasko2104e9f2020-03-06 08:23:25 +01005582 assert((set->type == LYXP_SET_NODE_SET) || (set->type == LYXP_SET_SCNODE_SET));
5583
Michal Vasko6346ece2019-09-24 13:12:53 +02005584 if ((ptr = ly_strnchr(*qname, ':', *qname_len))) {
5585 /* specific module */
5586 pref_len = ptr - *qname;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005587 mod = ly_resolve_prefix(set->ctx, *qname, pref_len, set->format, set->prefix_data);
Michal Vasko6346ece2019-09-24 13:12:53 +02005588
Michal Vasko004d3152020-06-11 19:59:22 +02005589 /* check for errors and non-implemented modules, as they are not valid */
Juraj Vijtiukd75faa62019-11-26 14:10:10 +01005590 if (!mod || !mod->implemented) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005591 LOGVAL(set->ctx, LY_VCODE_XP_INMOD, pref_len, *qname);
Michal Vasko6346ece2019-09-24 13:12:53 +02005592 return LY_EVALID;
5593 }
Juraj Vijtiukd75faa62019-11-26 14:10:10 +01005594
Michal Vasko6346ece2019-09-24 13:12:53 +02005595 *qname += pref_len + 1;
5596 *qname_len -= pref_len + 1;
5597 } else if (((*qname)[0] == '*') && (*qname_len == 1)) {
5598 /* all modules - special case */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005599 mod = NULL;
Michal Vasko6346ece2019-09-24 13:12:53 +02005600 } else {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005601 switch (set->format) {
Radek Krejci8df109d2021-04-23 12:19:08 +02005602 case LY_VALUE_SCHEMA:
5603 case LY_VALUE_SCHEMA_RESOLVED:
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005604 /* current module */
5605 mod = set->cur_mod;
5606 break;
Radek Krejci224d4b42021-04-23 13:54:59 +02005607 case LY_VALUE_CANON:
Radek Krejci8df109d2021-04-23 12:19:08 +02005608 case LY_VALUE_JSON:
Radek Krejcif9943642021-04-26 10:18:21 +02005609 case LY_VALUE_LYB:
Michal Vaskoddd76592022-01-17 13:34:48 +01005610 case LY_VALUE_STR_NS:
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005611 /* inherit parent (context node) module */
5612 if (ctx_scnode) {
5613 mod = ctx_scnode->module;
5614 } else {
5615 mod = NULL;
5616 }
5617 break;
Radek Krejci8df109d2021-04-23 12:19:08 +02005618 case LY_VALUE_XML:
Michal Vasko52143d12021-04-14 15:36:39 +02005619 /* all nodes need to be prefixed */
5620 LOGVAL(set->ctx, LYVE_DATA, "Non-prefixed node \"%.*s\" in XML xpath found.", *qname_len, *qname);
5621 return LY_EVALID;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005622 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005623 }
5624
Michal Vasko6346ece2019-09-24 13:12:53 +02005625 *moveto_mod = mod;
5626 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005627}
5628
5629/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02005630 * @brief Move context @p set to the root. Handles absolute path.
5631 * Result is LYXP_SET_NODE_SET.
5632 *
5633 * @param[in,out] set Set to use.
5634 * @param[in] options Xpath options.
Michal Vaskob0099a92020-08-31 14:55:23 +02005635 * @return LY_ERR value.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005636 */
Michal Vaskob0099a92020-08-31 14:55:23 +02005637static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005638moveto_root(struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005639{
aPiecek8b0cc152021-05-31 16:40:31 +02005640 assert(!(options & LYXP_SKIP_EXPR));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005641
5642 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02005643 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko7333cb32022-07-29 16:30:29 +02005644 LY_CHECK_RET(set_scnode_insert_node(set, NULL, set->root_type, LYXP_AXIS_SELF, NULL));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005645 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02005646 set->type = LYXP_SET_NODE_SET;
5647 set->used = 0;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005648 set_insert_node(set, NULL, 0, set->root_type, 0);
Michal Vasko306e2832022-07-25 09:15:17 +02005649 set->non_child_axis = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005650 }
Michal Vaskob0099a92020-08-31 14:55:23 +02005651
5652 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005653}
5654
5655/**
5656 * @brief Check @p node as a part of NameTest processing.
5657 *
5658 * @param[in] node Node to check.
Michal Vasko49fec8e2022-05-24 10:28:33 +02005659 * @param[in] node_type Node type of @p node.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005660 * @param[in] set Set to read general context from.
Michal Vaskod3678892020-05-21 10:06:58 +02005661 * @param[in] node_name Node name in the dictionary to move to, NULL for any node.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005662 * @param[in] moveto_mod Expected module of the node, NULL for no prefix.
Michal Vaskocdad7122020-11-09 21:04:44 +01005663 * @param[in] options XPath options.
Michal Vasko6346ece2019-09-24 13:12:53 +02005664 * @return LY_ERR (LY_ENOT if node does not match, LY_EINCOMPLETE on unresolved when,
Michal Vaskocd2c88a2022-06-07 10:54:34 +02005665 * LY_EINVAL if neither node nor any children match)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005666 */
5667static LY_ERR
Michal Vasko49fec8e2022-05-24 10:28:33 +02005668moveto_node_check(const struct lyd_node *node, enum lyxp_node_type node_type, const struct lyxp_set *set,
5669 const char *node_name, const struct lys_module *moveto_mod, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005670{
Michal Vasko49fec8e2022-05-24 10:28:33 +02005671 if ((node_type == LYXP_NODE_ROOT_CONFIG) || (node_type == LYXP_NODE_ROOT)) {
5672 assert(node_type == set->root_type);
5673
5674 if (node_name || moveto_mod) {
5675 /* root will not match a specific node */
5676 return LY_ENOT;
5677 }
5678 return LY_SUCCESS;
5679 } else if (node_type != LYXP_NODE_ELEM) {
5680 /* other types will not match */
5681 return LY_ENOT;
5682 }
5683
Michal Vaskodca9f122021-07-16 13:56:22 +02005684 if (!node->schema) {
5685 /* opaque node never matches */
5686 return LY_ENOT;
5687 }
5688
Michal Vasko03ff5a72019-09-11 13:49:33 +02005689 /* module check */
Michal Vasko19089f02022-06-07 11:02:11 +02005690 if (moveto_mod) {
Michal Vasko0a1eb752022-09-29 11:00:34 +02005691 if ((set->ctx == LYD_CTX(node)) && (node->schema->module != moveto_mod)) {
Michal Vasko19089f02022-06-07 11:02:11 +02005692 return LY_ENOT;
Michal Vasko0a1eb752022-09-29 11:00:34 +02005693 } else if ((set->ctx != LYD_CTX(node)) && strcmp(node->schema->module->name, moveto_mod->name)) {
Michal Vasko19089f02022-06-07 11:02:11 +02005694 return LY_ENOT;
5695 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005696 }
5697
Michal Vasko5c4e5892019-11-14 12:31:38 +01005698 /* context check */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005699 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (node->schema->flags & LYS_CONFIG_R)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005700 return LY_EINVAL;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005701 } else if (set->context_op && (node->schema->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) &&
5702 (node->schema != set->context_op)) {
Michal Vasko6b26e742020-07-17 15:02:10 +02005703 return LY_EINVAL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005704 }
5705
5706 /* name check */
Michal Vasko19089f02022-06-07 11:02:11 +02005707 if (node_name) {
Michal Vasko0a1eb752022-09-29 11:00:34 +02005708 if ((set->ctx == LYD_CTX(node)) && (node->schema->name != node_name)) {
Michal Vasko19089f02022-06-07 11:02:11 +02005709 return LY_ENOT;
Michal Vasko0a1eb752022-09-29 11:00:34 +02005710 } else if ((set->ctx != LYD_CTX(node)) && strcmp(node->schema->name, node_name)) {
Michal Vasko19089f02022-06-07 11:02:11 +02005711 return LY_ENOT;
5712 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005713 }
5714
Michal Vaskoa1424542019-11-14 16:08:52 +01005715 /* when check */
Michal Vaskod5cfa6e2020-11-23 16:56:08 +01005716 if (!(options & LYXP_IGNORE_WHEN) && lysc_has_when(node->schema) && !(node->flags & LYD_WHEN_TRUE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005717 return LY_EINCOMPLETE;
Michal Vaskoa1424542019-11-14 16:08:52 +01005718 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005719
5720 /* match */
5721 return LY_SUCCESS;
5722}
5723
5724/**
Michal Vasko49fec8e2022-05-24 10:28:33 +02005725 * @brief Get the next node in a forward DFS.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005726 *
Michal Vasko49fec8e2022-05-24 10:28:33 +02005727 * @param[in] iter Last returned node.
5728 * @param[in] stop Node to stop the search on and not return.
5729 * @return Next node, NULL if there are no more.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005730 */
Michal Vasko49fec8e2022-05-24 10:28:33 +02005731static const struct lyd_node *
5732moveto_axis_node_next_dfs_forward(const struct lyd_node *iter, const struct lyd_node *stop)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005733{
Michal Vasko49fec8e2022-05-24 10:28:33 +02005734 const struct lyd_node *next = NULL;
5735
5736 /* 1) child */
5737 next = lyd_child(iter);
5738 if (!next) {
5739 if (iter == stop) {
5740 /* reached stop, no more descendants */
5741 return NULL;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005742 }
Michal Vasko49fec8e2022-05-24 10:28:33 +02005743 /* 2) child next sibling */
5744 next = iter->next;
5745 }
5746 while (!next) {
5747 iter = lyd_parent(iter);
5748 if ((!stop && !iter) || (stop && (lyd_parent(iter) == lyd_parent(stop)))) {
5749 return NULL;
5750 }
5751 next = iter->next;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005752 }
5753
Michal Vasko49fec8e2022-05-24 10:28:33 +02005754 return next;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005755}
5756
5757/**
Michal Vasko49fec8e2022-05-24 10:28:33 +02005758 * @brief Get the next node in a backward DFS.
5759 *
5760 * @param[in] iter Last returned node.
5761 * @param[in] stop Node to stop the search on and not return.
5762 * @return Next node, NULL if there are no more.
5763 */
5764static const struct lyd_node *
5765moveto_axis_node_next_dfs_backward(const struct lyd_node *iter, const struct lyd_node *stop)
5766{
5767 const struct lyd_node *next = NULL;
5768
5769 /* 1) previous sibling innermost last child */
5770 next = iter->prev->next ? iter->prev : NULL;
5771 while (next && lyd_child(next)) {
5772 next = lyd_child(next);
5773 next = next->prev;
5774 }
5775
5776 if (!next) {
5777 /* 2) parent */
5778 iter = lyd_parent(iter);
5779 if ((!stop && !iter) || (stop && (lyd_parent(iter) == lyd_parent(stop)))) {
5780 return NULL;
5781 }
5782 next = iter;
5783 }
5784
5785 return next;
5786}
5787
5788/**
5789 * @brief Get the first node on an axis for a context node.
5790 *
5791 * @param[in,out] iter NULL, updated to the next node.
5792 * @param[in,out] iter_type Node type 0 of @p iter, updated to the node type of the next node.
5793 * @param[in] node Context node.
5794 * @param[in] node_type Type of @p node.
5795 * @param[in] axis Axis to use.
5796 * @param[in] set XPath set with the general context.
5797 * @return LY_SUCCESS on success.
5798 * @return LY_ENOTFOUND if no next node found.
5799 */
5800static LY_ERR
5801moveto_axis_node_next_first(const struct lyd_node **iter, enum lyxp_node_type *iter_type, const struct lyd_node *node,
5802 enum lyxp_node_type node_type, enum lyxp_axis axis, struct lyxp_set *set)
5803{
5804 const struct lyd_node *next = NULL;
5805 enum lyxp_node_type next_type = 0;
5806
5807 assert(!*iter);
5808 assert(!*iter_type);
5809
5810 switch (axis) {
5811 case LYXP_AXIS_ANCESTOR_OR_SELF:
5812 case LYXP_AXIS_DESCENDANT_OR_SELF:
5813 case LYXP_AXIS_SELF:
5814 /* return the context node */
5815 next = node;
5816 next_type = node_type;
5817 break;
5818
5819 case LYXP_AXIS_ANCESTOR:
5820 case LYXP_AXIS_PARENT:
5821 if (node_type == LYXP_NODE_ELEM) {
5822 next = lyd_parent(node);
5823 next_type = next ? LYXP_NODE_ELEM : set->root_type;
5824 } else if (node_type == LYXP_NODE_TEXT) {
5825 next = node;
5826 next_type = LYXP_NODE_ELEM;
5827 } else if (node_type == LYXP_NODE_META) {
5828 next = ((struct lyd_meta *)node)->parent;
5829 next_type = LYXP_NODE_ELEM;
5830 } /* else root does not have a parent */
5831 break;
5832
5833 case LYXP_AXIS_CHILD:
5834 if ((node_type == LYXP_NODE_ROOT_CONFIG) || (node_type == LYXP_NODE_ROOT)) {
5835 assert(!node);
5836
5837 /* search in all the trees */
5838 next = set->tree;
5839 next_type = next ? LYXP_NODE_ELEM : 0;
5840 } else {
5841 /* search in children */
5842 next = lyd_child(node);
5843 next_type = next ? LYXP_NODE_ELEM : 0;
5844 }
5845 break;
5846
5847 case LYXP_AXIS_DESCENDANT:
5848 if ((node_type == LYXP_NODE_ROOT_CONFIG) || (node_type == LYXP_NODE_ROOT)) {
5849 /* top-level nodes */
5850 next = set->tree;
5851 next_type = LYXP_NODE_ELEM;
5852 } else if (node_type == LYXP_NODE_ELEM) {
5853 /* start from the context node */
5854 next = moveto_axis_node_next_dfs_forward(node, node);
5855 next_type = next ? LYXP_NODE_ELEM : 0;
5856 } /* else no children */
5857 break;
5858
5859 case LYXP_AXIS_FOLLOWING:
5860 case LYXP_AXIS_FOLLOWING_SIBLING:
5861 if (node_type == LYXP_NODE_ELEM) {
5862 /* first next sibling */
5863 next = node->next;
5864 next_type = next ? LYXP_NODE_ELEM : 0;
5865 } /* else no sibling */
5866 break;
5867
5868 case LYXP_AXIS_PRECEDING:
5869 if ((node_type == LYXP_NODE_ELEM) && node->prev->next) {
5870 /* skip ancestors */
5871 next = moveto_axis_node_next_dfs_backward(node, NULL);
5872 assert(next);
5873 next_type = LYXP_NODE_ELEM;
5874 } /* else no sibling */
5875 break;
5876
5877 case LYXP_AXIS_PRECEDING_SIBLING:
5878 if (node_type == LYXP_NODE_ELEM) {
5879 /* first previous sibling */
5880 next = node->prev->next ? node->prev : NULL;
5881 next_type = next ? LYXP_NODE_ELEM : 0;
5882 } /* else no sibling */
5883 break;
5884
5885 case LYXP_AXIS_ATTRIBUTE:
5886 /* handled specially */
5887 assert(0);
5888 LOGINT(set->ctx);
5889 break;
5890 }
5891
5892 *iter = next;
5893 *iter_type = next_type;
5894 return next_type ? LY_SUCCESS : LY_ENOTFOUND;
5895}
5896
5897/**
5898 * @brief Iterate over all nodes on an axis for a context node.
5899 *
5900 * @param[in,out] iter Last returned node, start with NULL, updated to the next node.
5901 * @param[in,out] iter_type Node type of @p iter, start with 0, updated to the node type of the next node.
5902 * @param[in] node Context node.
5903 * @param[in] node_type Type of @p node.
5904 * @param[in] axis Axis to use.
5905 * @param[in] set XPath set with the general context.
5906 * @return LY_SUCCESS on success.
5907 * @return LY_ENOTFOUND if no next node found.
5908 */
5909static LY_ERR
5910moveto_axis_node_next(const struct lyd_node **iter, enum lyxp_node_type *iter_type, const struct lyd_node *node,
5911 enum lyxp_node_type node_type, enum lyxp_axis axis, struct lyxp_set *set)
5912{
5913 const struct lyd_node *next = NULL;
5914 enum lyxp_node_type next_type = 0;
5915
5916 if (!*iter_type) {
5917 /* first returned node */
5918 return moveto_axis_node_next_first(iter, iter_type, node, node_type, axis, set);
5919 }
5920
5921 switch (axis) {
5922 case LYXP_AXIS_ANCESTOR_OR_SELF:
5923 if ((*iter == node) && (*iter_type == node_type)) {
5924 /* fake first ancestor, we returned self before */
5925 *iter = NULL;
5926 *iter_type = 0;
5927 return moveto_axis_node_next_first(iter, iter_type, node, node_type, LYXP_AXIS_ANCESTOR, set);
5928 } /* else continue ancestor */
5929
5930 /* fallthrough */
5931 case LYXP_AXIS_ANCESTOR:
5932 if (*iter_type == LYXP_NODE_ELEM) {
5933 /* iter parent */
5934 next = lyd_parent(*iter);
5935 next_type = next ? LYXP_NODE_ELEM : set->root_type;
5936 } /* else root, no ancestors */
5937 break;
5938
5939 case LYXP_AXIS_CHILD:
5940 assert(*iter_type == LYXP_NODE_ELEM);
5941
5942 /* next sibling (child) */
5943 next = (*iter)->next;
5944 next_type = next ? LYXP_NODE_ELEM : 0;
5945 break;
5946
5947 case LYXP_AXIS_DESCENDANT_OR_SELF:
5948 if ((*iter == node) && (*iter_type == node_type)) {
5949 /* fake first descendant, we returned self before */
5950 *iter = NULL;
5951 *iter_type = 0;
5952 return moveto_axis_node_next_first(iter, iter_type, node, node_type, LYXP_AXIS_DESCENDANT, set);
5953 } /* else continue descendant */
5954
5955 /* fallthrough */
5956 case LYXP_AXIS_DESCENDANT:
5957 assert(*iter_type == LYXP_NODE_ELEM);
5958 next = moveto_axis_node_next_dfs_forward(*iter, node);
5959 next_type = next ? LYXP_NODE_ELEM : 0;
5960 break;
5961
5962 case LYXP_AXIS_FOLLOWING:
5963 assert(*iter_type == LYXP_NODE_ELEM);
5964 next = moveto_axis_node_next_dfs_forward(*iter, NULL);
5965 next_type = next ? LYXP_NODE_ELEM : 0;
5966 break;
5967
5968 case LYXP_AXIS_FOLLOWING_SIBLING:
5969 assert(*iter_type == LYXP_NODE_ELEM);
5970
5971 /* next sibling */
5972 next = (*iter)->next;
5973 next_type = next ? LYXP_NODE_ELEM : 0;
5974 break;
5975
5976 case LYXP_AXIS_PARENT:
5977 case LYXP_AXIS_SELF:
5978 /* parent/self was returned before */
5979 break;
5980
5981 case LYXP_AXIS_PRECEDING:
5982 assert(*iter_type == LYXP_NODE_ELEM);
5983 next = moveto_axis_node_next_dfs_backward(*iter, NULL);
5984 next_type = next ? LYXP_NODE_ELEM : 0;
5985 break;
5986
5987 case LYXP_AXIS_PRECEDING_SIBLING:
5988 assert(*iter_type == LYXP_NODE_ELEM);
5989
5990 /* previous sibling */
5991 next = (*iter)->prev->next ? (*iter)->prev : NULL;
5992 next_type = next ? LYXP_NODE_ELEM : 0;
5993 break;
5994
5995 case LYXP_AXIS_ATTRIBUTE:
5996 /* handled specially */
5997 assert(0);
5998 LOGINT(set->ctx);
5999 break;
6000 }
6001
6002 *iter = next;
6003 *iter_type = next_type;
6004 return next_type ? LY_SUCCESS : LY_ENOTFOUND;
6005}
6006
6007/**
6008 * @brief Move context @p set to a node. Result is LYXP_SET_NODE_SET. Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006009 *
6010 * @param[in,out] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006011 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02006012 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vasko49fec8e2022-05-24 10:28:33 +02006013 * @param[in] axis Axis to search on.
Michal Vaskocdad7122020-11-09 21:04:44 +01006014 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006015 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6016 */
6017static LY_ERR
Michal Vasko49fec8e2022-05-24 10:28:33 +02006018moveto_node(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, enum lyxp_axis axis,
6019 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006020{
Michal Vasko230cf972021-12-02 12:31:00 +01006021 LY_ERR r, rc = LY_SUCCESS;
Michal Vasko49fec8e2022-05-24 10:28:33 +02006022 const struct lyd_node *iter;
6023 enum lyxp_node_type iter_type;
Michal Vasko230cf972021-12-02 12:31:00 +01006024 struct lyxp_set result;
Michal Vasko49fec8e2022-05-24 10:28:33 +02006025 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006026
aPiecek8b0cc152021-05-31 16:40:31 +02006027 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006028 return LY_SUCCESS;
6029 }
6030
6031 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006032 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006033 return LY_EVALID;
6034 }
6035
Michal Vasko230cf972021-12-02 12:31:00 +01006036 /* init result set */
6037 set_init(&result, set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006038
Michal Vasko49fec8e2022-05-24 10:28:33 +02006039 for (i = 0; i < set->used; ++i) {
6040 /* iterate over all the nodes on the axis of the node */
6041 iter = NULL;
6042 iter_type = 0;
6043 while (!moveto_axis_node_next(&iter, &iter_type, set->val.nodes[i].node, set->val.nodes[i].type, axis, set)) {
6044 r = moveto_node_check(iter, iter_type, set, ncname, moveto_mod, options);
6045 if (r == LY_EINCOMPLETE) {
Michal Vasko230cf972021-12-02 12:31:00 +01006046 rc = r;
6047 goto cleanup;
Michal Vasko49fec8e2022-05-24 10:28:33 +02006048 } else if (r) {
6049 continue;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006050 }
Michal Vasko49fec8e2022-05-24 10:28:33 +02006051
6052 /* check for duplicates if they are possible */
6053 switch (axis) {
6054 case LYXP_AXIS_ANCESTOR:
6055 case LYXP_AXIS_ANCESTOR_OR_SELF:
6056 case LYXP_AXIS_DESCENDANT:
6057 case LYXP_AXIS_DESCENDANT_OR_SELF:
6058 case LYXP_AXIS_FOLLOWING:
6059 case LYXP_AXIS_FOLLOWING_SIBLING:
6060 case LYXP_AXIS_PARENT:
6061 case LYXP_AXIS_PRECEDING:
6062 case LYXP_AXIS_PRECEDING_SIBLING:
Michal Vasko306e2832022-07-25 09:15:17 +02006063 result.non_child_axis = 1;
Michal Vasko49fec8e2022-05-24 10:28:33 +02006064 if (set_dup_node_check(&result, iter, iter_type, -1)) {
6065 continue;
6066 }
6067 break;
6068 case LYXP_AXIS_CHILD:
6069 case LYXP_AXIS_SELF:
6070 break;
6071 case LYXP_AXIS_ATTRIBUTE:
6072 /* handled specially */
6073 assert(0);
6074 LOGINT(set->ctx);
6075 break;
6076 }
6077
6078 /* matching node */
6079 set_insert_node(&result, iter, 0, iter_type, result.used);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006080 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006081 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006082
Michal Vasko230cf972021-12-02 12:31:00 +01006083 /* move result to the set */
6084 lyxp_set_free_content(set);
6085 *set = result;
6086 result.type = LYXP_SET_NUMBER;
Michal Vasko49fec8e2022-05-24 10:28:33 +02006087
Michal Vasko306e2832022-07-25 09:15:17 +02006088 /* sort the final set if the document order could have been broken */
6089 if (set->non_child_axis) {
6090 set_sort(set);
6091 } else {
6092 assert(!set_sort(set));
6093 }
Michal Vasko230cf972021-12-02 12:31:00 +01006094
6095cleanup:
6096 lyxp_set_free_content(&result);
6097 return rc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006098}
6099
6100/**
Michal Vasko49fec8e2022-05-24 10:28:33 +02006101 * @brief Move context @p set to child nodes using hashes. Result is LYXP_SET_NODE_SET. Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006102 *
6103 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02006104 * @param[in] scnode Matching node schema.
Michal Vasko004d3152020-06-11 19:59:22 +02006105 * @param[in] predicates If @p scnode is ::LYS_LIST or ::LYS_LEAFLIST, the predicates specifying a single instance.
Michal Vaskocdad7122020-11-09 21:04:44 +01006106 * @param[in] options XPath options.
Michal Vaskod3678892020-05-21 10:06:58 +02006107 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6108 */
6109static LY_ERR
Michal Vasko49fec8e2022-05-24 10:28:33 +02006110moveto_node_hash_child(struct lyxp_set *set, const struct lysc_node *scnode, const struct ly_path_predicate *predicates,
Michal Vaskocdad7122020-11-09 21:04:44 +01006111 uint32_t options)
Michal Vaskod3678892020-05-21 10:06:58 +02006112{
Michal Vaskoddd76592022-01-17 13:34:48 +01006113 LY_ERR ret = LY_SUCCESS, r;
Michal Vaskod3678892020-05-21 10:06:58 +02006114 uint32_t i;
Michal Vaskod3678892020-05-21 10:06:58 +02006115 const struct lyd_node *siblings;
Michal Vasko230cf972021-12-02 12:31:00 +01006116 struct lyxp_set result;
Michal Vasko004d3152020-06-11 19:59:22 +02006117 struct lyd_node *sub, *inst = NULL;
Michal Vaskod3678892020-05-21 10:06:58 +02006118
Michal Vasko004d3152020-06-11 19:59:22 +02006119 assert(scnode && (!(scnode->nodetype & (LYS_LIST | LYS_LEAFLIST)) || predicates));
Michal Vaskod3678892020-05-21 10:06:58 +02006120
Michal Vasko50aaa072021-12-02 13:11:56 +01006121 /* init result set */
6122 set_init(&result, set);
6123
aPiecek8b0cc152021-05-31 16:40:31 +02006124 if (options & LYXP_SKIP_EXPR) {
Michal Vasko004d3152020-06-11 19:59:22 +02006125 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02006126 }
6127
6128 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006129 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko004d3152020-06-11 19:59:22 +02006130 ret = LY_EVALID;
6131 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02006132 }
6133
6134 /* context check for all the nodes since we have the schema node */
6135 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (scnode->flags & LYS_CONFIG_R)) {
6136 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02006137 goto cleanup;
Michal Vasko69730152020-10-09 16:30:07 +02006138 } else if (set->context_op && (scnode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) &&
6139 (scnode != set->context_op)) {
Michal Vasko6b26e742020-07-17 15:02:10 +02006140 lyxp_set_free_content(set);
6141 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +02006142 }
6143
6144 /* create specific data instance if needed */
6145 if (scnode->nodetype == LYS_LIST) {
6146 LY_CHECK_GOTO(ret = lyd_create_list(scnode, predicates, &inst), cleanup);
6147 } else if (scnode->nodetype == LYS_LEAFLIST) {
6148 LY_CHECK_GOTO(ret = lyd_create_term2(scnode, &predicates[0].value, &inst), cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02006149 }
6150
Michal Vasko230cf972021-12-02 12:31:00 +01006151 for (i = 0; i < set->used; ++i) {
Michal Vaskod3678892020-05-21 10:06:58 +02006152 siblings = NULL;
6153
6154 if ((set->val.nodes[i].type == LYXP_NODE_ROOT_CONFIG) || (set->val.nodes[i].type == LYXP_NODE_ROOT)) {
6155 assert(!set->val.nodes[i].node);
6156
6157 /* search in all the trees */
6158 siblings = set->tree;
6159 } else if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
6160 /* search in children */
Radek Krejcia1c1e542020-09-29 16:06:52 +02006161 siblings = lyd_child(set->val.nodes[i].node);
Michal Vaskod3678892020-05-21 10:06:58 +02006162 }
6163
6164 /* find the node using hashes */
Michal Vasko004d3152020-06-11 19:59:22 +02006165 if (inst) {
Michal Vaskoddd76592022-01-17 13:34:48 +01006166 r = lyd_find_sibling_first(siblings, inst, &sub);
Michal Vaskod3678892020-05-21 10:06:58 +02006167 } else {
Michal Vaskoddd76592022-01-17 13:34:48 +01006168 r = lyd_find_sibling_val(siblings, scnode, NULL, 0, &sub);
Michal Vaskod3678892020-05-21 10:06:58 +02006169 }
Michal Vaskoddd76592022-01-17 13:34:48 +01006170 LY_CHECK_ERR_GOTO(r && (r != LY_ENOTFOUND), ret = r, cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02006171
6172 /* when check */
Michal Vaskod5cfa6e2020-11-23 16:56:08 +01006173 if (!(options & LYXP_IGNORE_WHEN) && sub && lysc_has_when(sub->schema) && !(sub->flags & LYD_WHEN_TRUE)) {
Michal Vasko004d3152020-06-11 19:59:22 +02006174 ret = LY_EINCOMPLETE;
6175 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02006176 }
6177
6178 if (sub) {
6179 /* pos filled later */
Michal Vasko230cf972021-12-02 12:31:00 +01006180 set_insert_node(&result, sub, 0, LYXP_NODE_ELEM, result.used);
Michal Vaskod3678892020-05-21 10:06:58 +02006181 }
6182 }
6183
Michal Vasko230cf972021-12-02 12:31:00 +01006184 /* move result to the set */
6185 lyxp_set_free_content(set);
6186 *set = result;
6187 result.type = LYXP_SET_NUMBER;
6188 assert(!set_sort(set));
6189
Michal Vasko004d3152020-06-11 19:59:22 +02006190cleanup:
Michal Vasko230cf972021-12-02 12:31:00 +01006191 lyxp_set_free_content(&result);
Michal Vasko004d3152020-06-11 19:59:22 +02006192 lyd_free_tree(inst);
6193 return ret;
Michal Vaskod3678892020-05-21 10:06:58 +02006194}
6195
6196/**
Michal Vasko49fec8e2022-05-24 10:28:33 +02006197 * @brief Check @p node as a part of schema NameTest processing.
6198 *
6199 * @param[in] node Schema node to check.
6200 * @param[in] ctx_scnode Context node.
6201 * @param[in] set Set to read general context from.
6202 * @param[in] node_name Node name in the dictionary to move to, NULL for any nodes.
6203 * @param[in] moveto_mod Expected module of the node, NULL for no prefix.
6204 * @return LY_ERR (LY_ENOT if node does not match, LY_EINVAL if neither node nor any children match)
6205 */
6206static LY_ERR
6207moveto_scnode_check(const struct lysc_node *node, const struct lysc_node *ctx_scnode, const struct lyxp_set *set,
6208 const char *node_name, const struct lys_module *moveto_mod)
6209{
6210 if (!moveto_mod && node_name) {
6211 switch (set->format) {
6212 case LY_VALUE_SCHEMA:
6213 case LY_VALUE_SCHEMA_RESOLVED:
6214 /* use current module */
6215 moveto_mod = set->cur_mod;
6216 break;
6217 case LY_VALUE_JSON:
6218 case LY_VALUE_LYB:
6219 case LY_VALUE_STR_NS:
6220 /* inherit module of the context node, if any */
6221 if (ctx_scnode) {
6222 moveto_mod = ctx_scnode->module;
6223 }
6224 break;
6225 case LY_VALUE_CANON:
6226 case LY_VALUE_XML:
6227 /* not defined */
6228 LOGINT(set->ctx);
6229 return LY_EINVAL;
6230 }
6231 }
6232
6233 if (!node) {
6234 /* root will not match a specific node */
6235 if (node_name || moveto_mod) {
6236 return LY_ENOT;
6237 }
6238 return LY_SUCCESS;
6239 }
6240
6241 /* module check */
6242 if (moveto_mod && (node->module != moveto_mod)) {
6243 return LY_ENOT;
6244 }
6245
6246 /* context check */
6247 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (node->flags & LYS_CONFIG_R)) {
6248 return LY_EINVAL;
6249 } else if (set->context_op && (node->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) && (node != set->context_op)) {
6250 return LY_EINVAL;
6251 }
6252
6253 /* name check */
6254 if (node_name && (node->name != node_name)) {
6255 return LY_ENOT;
6256 }
6257
6258 /* match */
6259 return LY_SUCCESS;
6260}
6261
6262/**
6263 * @brief Get the next node in a forward schema node DFS.
6264 *
6265 * @param[in] iter Last returned node.
6266 * @param[in] stop Node to stop the search on and not return.
6267 * @param[in] getnext_opts Options for ::lys_getnext().
6268 * @return Next node, NULL if there are no more.
6269 */
6270static const struct lysc_node *
6271moveto_axis_scnode_next_dfs_forward(const struct lysc_node *iter, const struct lysc_node *stop, uint32_t getnext_opts)
6272{
6273 const struct lysc_node *next = NULL;
6274
6275 next = lysc_node_child(iter);
6276 if (!next) {
6277 /* no children, try siblings */
Michal Vasko34a22fe2022-06-15 07:58:55 +02006278 if ((iter == stop) || !lysc_data_parent(iter)) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02006279 /* we are done, no next element to process */
6280 return NULL;
6281 }
6282
6283 next = lys_getnext(iter, lysc_data_parent(iter), NULL, getnext_opts);
6284 }
6285 while (!next && iter) {
6286 /* parent is already processed, go to its sibling */
6287 iter = iter->parent;
Michal Vasko34a22fe2022-06-15 07:58:55 +02006288 if ((iter == stop) || !lysc_data_parent(iter)) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02006289 /* we are done, no next element to process */
6290 return NULL;
6291 }
6292 next = lys_getnext(iter, lysc_data_parent(iter), NULL, getnext_opts);
6293 }
6294
6295 return next;
6296}
6297
6298/**
6299 * @brief Consider schema node based on its in_ctx enum value.
6300 *
6301 * @param[in,out] in_ctx In_ctx enum of the schema node, may be updated.
6302 * @param[in] axis Axis to use.
6303 * @return LY_SUCCESS on success.
6304 * @return LY_ENOT if the node should not be returned.
6305 */
6306static LY_ERR
6307moveto_axis_scnode_next_in_ctx(int32_t *in_ctx, enum lyxp_axis axis)
6308{
6309 switch (axis) {
6310 case LYXP_AXIS_SELF:
6311 if ((*in_ctx == LYXP_SET_SCNODE_START) || (*in_ctx == LYXP_SET_SCNODE_ATOM_CTX)) {
6312 /* additionally put the start node into context */
6313 *in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
6314 return LY_SUCCESS;
6315 }
6316 break;
6317 case LYXP_AXIS_PARENT:
6318 case LYXP_AXIS_ANCESTOR_OR_SELF:
6319 case LYXP_AXIS_ANCESTOR:
6320 case LYXP_AXIS_DESCENDANT_OR_SELF:
6321 case LYXP_AXIS_DESCENDANT:
6322 case LYXP_AXIS_FOLLOWING:
6323 case LYXP_AXIS_FOLLOWING_SIBLING:
6324 case LYXP_AXIS_PRECEDING:
6325 case LYXP_AXIS_PRECEDING_SIBLING:
6326 case LYXP_AXIS_CHILD:
6327 if (*in_ctx == LYXP_SET_SCNODE_START) {
6328 /* remember that context node was used */
6329 *in_ctx = LYXP_SET_SCNODE_START_USED;
6330 return LY_SUCCESS;
6331 } else if (*in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
6332 /* traversed */
6333 *in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
6334 return LY_SUCCESS;
6335 }
6336 break;
6337 case LYXP_AXIS_ATTRIBUTE:
6338 /* unreachable */
6339 assert(0);
6340 LOGINT(NULL);
6341 break;
6342 }
6343
6344 return LY_ENOT;
6345}
6346
6347/**
6348 * @brief Get previous sibling for a schema node.
6349 *
6350 * @param[in] scnode Schema node.
6351 * @param[in] getnext_opts Options for ::lys_getnext().
6352 * @return Previous sibling, NULL if none.
6353 */
6354static const struct lysc_node *
6355moveto_axis_scnode_preceding_sibling(const struct lysc_node *scnode, uint32_t getnext_opts)
6356{
6357 const struct lysc_node *next = NULL, *prev = NULL;
6358
6359 while ((next = lys_getnext(next, lysc_data_parent(scnode), scnode->module->compiled, getnext_opts))) {
6360 if (next == scnode) {
6361 break;
6362 }
6363
6364 prev = next;
6365 }
6366
6367 return prev;
6368}
6369
6370/**
6371 * @brief Get the first schema node on an axis for a context node.
6372 *
6373 * @param[in,out] iter Last returned node, start with NULL, updated to the next node.
6374 * @param[in,out] iter_type Node type of @p iter, start with 0, updated to the node type of the next node.
6375 * @param[in,out] iter_mod Internal module iterator, do not change.
6376 * @param[in,out] iter_mod_idx Internal module index iterator, do not change.
6377 * @param[in] scnode Context node.
6378 * @param[in] node_type Type of @p scnode.
6379 * @param[in] in_ctx In_ctx enum of @p scnode.
6380 * @param[in] axis Axis to use.
6381 * @param[in] set XPath set with the general context.
6382 * @param[in] getnext_opts Options for ::lys_getnext().
6383 * @return LY_SUCCESS on success.
6384 * @return LY_ENOTFOUND if no next node found.
6385 */
6386static LY_ERR
6387moveto_axis_scnode_next_first(const struct lysc_node **iter, enum lyxp_node_type *iter_type, const struct lys_module **iter_mod,
6388 uint32_t *iter_mod_idx, const struct lysc_node *scnode, enum lyxp_node_type node_type, enum lyxp_axis axis,
6389 struct lyxp_set *set, uint32_t getnext_opts)
6390{
6391 const struct lysc_node *next = NULL;
6392 enum lyxp_node_type next_type = 0;
6393
6394 assert(!*iter);
6395 assert(!*iter_type);
6396
6397 *iter_mod = NULL;
6398 *iter_mod_idx = 0;
6399
6400 switch (axis) {
6401 case LYXP_AXIS_ANCESTOR_OR_SELF:
6402 case LYXP_AXIS_DESCENDANT_OR_SELF:
6403 case LYXP_AXIS_SELF:
6404 if ((node_type == LYXP_NODE_ROOT_CONFIG) || (node_type == LYXP_NODE_ROOT) || (node_type == LYXP_NODE_ELEM)) {
6405 /* just return the node */
6406 next = scnode;
6407 next_type = node_type;
6408 }
6409 break;
6410
6411 case LYXP_AXIS_ANCESTOR:
6412 case LYXP_AXIS_PARENT:
6413 if (node_type == LYXP_NODE_ELEM) {
6414 next = lysc_data_parent(scnode);
6415 next_type = next ? LYXP_NODE_ELEM : set->root_type;
6416 } /* else no parent */
6417 break;
6418
6419 case LYXP_AXIS_DESCENDANT:
6420 case LYXP_AXIS_CHILD:
6421 if ((node_type == LYXP_NODE_ROOT_CONFIG) || (node_type == LYXP_NODE_ROOT)) {
6422 /* it can actually be in any module, it's all <running>, and even if it's moveto_mod (if set),
6423 * it can be in a top-level augment */
6424 while ((*iter_mod = ly_ctx_get_module_iter(set->ctx, iter_mod_idx))) {
6425 /* module may not be implemented or not compiled yet */
6426 if (!(*iter_mod)->compiled) {
6427 continue;
6428 }
6429
6430 /* get next node */
6431 if ((next = lys_getnext(NULL, NULL, (*iter_mod)->compiled, getnext_opts))) {
6432 next_type = LYXP_NODE_ELEM;
6433 break;
6434 }
6435 }
6436 } else if (node_type == LYXP_NODE_ELEM) {
6437 /* get next node */
6438 next = lys_getnext(NULL, scnode, NULL, getnext_opts);
6439 next_type = next ? LYXP_NODE_ELEM : 0;
6440 }
6441 break;
6442
6443 case LYXP_AXIS_FOLLOWING:
6444 case LYXP_AXIS_FOLLOWING_SIBLING:
6445 if (node_type == LYXP_NODE_ELEM) {
6446 /* first next sibling */
6447 next = lys_getnext(scnode, lysc_data_parent(scnode), scnode->module->compiled, getnext_opts);
6448 next_type = next ? LYXP_NODE_ELEM : 0;
6449 } /* else no sibling */
6450 break;
6451
6452 case LYXP_AXIS_PRECEDING:
6453 case LYXP_AXIS_PRECEDING_SIBLING:
6454 if (node_type == LYXP_NODE_ELEM) {
6455 /* first parent sibling */
6456 next = lys_getnext(NULL, lysc_data_parent(scnode), scnode->module->compiled, getnext_opts);
6457 if (next == scnode) {
6458 /* no preceding sibling */
6459 next = NULL;
6460 }
6461 next_type = next ? LYXP_NODE_ELEM : 0;
6462 } /* else no sibling */
6463 break;
6464
6465 case LYXP_AXIS_ATTRIBUTE:
6466 /* unreachable */
6467 assert(0);
6468 LOGINT(set->ctx);
6469 break;
6470 }
6471
6472 *iter = next;
6473 *iter_type = next_type;
6474 return next_type ? LY_SUCCESS : LY_ENOTFOUND;
6475}
6476
6477/**
6478 * @brief Iterate over all schema nodes on an axis for a context node.
6479 *
6480 * @param[in,out] iter Last returned node, start with NULL, updated to the next node.
6481 * @param[in,out] iter_type Node type of @p iter, start with 0, updated to the node type of the next node.
6482 * @param[in,out] iter_mod Internal module iterator, do not change.
6483 * @param[in,out] iter_mod_idx Internal module index iterator, do not change.
6484 * @param[in] scnode Context node.
6485 * @param[in] node_type Type of @p scnode.
6486 * @param[in] axis Axis to use.
6487 * @param[in] set XPath set with the general context.
6488 * @param[in] getnext_opts Options for ::lys_getnext().
6489 * @return LY_SUCCESS on success.
6490 * @return LY_ENOTFOUND if no next node found.
6491 */
6492static LY_ERR
6493moveto_axis_scnode_next(const struct lysc_node **iter, enum lyxp_node_type *iter_type, const struct lys_module **iter_mod,
6494 uint32_t *iter_mod_idx, const struct lysc_node *scnode, enum lyxp_node_type node_type, enum lyxp_axis axis,
6495 struct lyxp_set *set, uint32_t getnext_opts)
6496{
6497 const struct lysc_node *next = NULL, *dfs_stop;
6498 enum lyxp_node_type next_type = 0;
6499
6500 if (!*iter_type) {
6501 /* first returned node */
6502 return moveto_axis_scnode_next_first(iter, iter_type, iter_mod, iter_mod_idx, scnode, node_type, axis, set,
6503 getnext_opts);
6504 }
6505
6506 switch (axis) {
6507 case LYXP_AXIS_PARENT:
6508 case LYXP_AXIS_SELF:
6509 /* parent/self was returned before */
6510 break;
6511
6512 case LYXP_AXIS_ANCESTOR_OR_SELF:
6513 if ((*iter == scnode) && (*iter_type == node_type)) {
6514 /* fake first ancestor, we returned self before */
6515 *iter = NULL;
6516 *iter_type = 0;
6517 return moveto_axis_scnode_next_first(iter, iter_type, iter_mod, iter_mod_idx, scnode, node_type,
6518 LYXP_AXIS_ANCESTOR, set, getnext_opts);
6519 } /* else continue ancestor */
6520
6521 /* fallthrough */
6522 case LYXP_AXIS_ANCESTOR:
6523 if (*iter_type == LYXP_NODE_ELEM) {
6524 next = lysc_data_parent(*iter);
6525 next_type = next ? LYXP_NODE_ELEM : set->root_type;
6526 } /* else no ancestor */
6527 break;
6528
6529 case LYXP_AXIS_DESCENDANT_OR_SELF:
6530 if ((*iter == scnode) && (*iter_type == node_type)) {
6531 /* fake first descendant, we returned self before */
6532 *iter = NULL;
6533 *iter_type = 0;
6534 return moveto_axis_scnode_next_first(iter, iter_type, iter_mod, iter_mod_idx, scnode, node_type,
6535 LYXP_AXIS_DESCENDANT, set, getnext_opts);
6536 } /* else DFS until context node */
6537 dfs_stop = scnode;
6538
6539 /* fallthrough */
6540 case LYXP_AXIS_DESCENDANT:
6541 if (axis == LYXP_AXIS_DESCENDANT) {
6542 /* DFS until the context node */
6543 dfs_stop = scnode;
6544 }
6545
6546 /* fallthrough */
6547 case LYXP_AXIS_PRECEDING:
6548 if (axis == LYXP_AXIS_PRECEDING) {
6549 /* DFS until the previous sibling */
6550 dfs_stop = moveto_axis_scnode_preceding_sibling(scnode, getnext_opts);
6551 assert(dfs_stop);
6552
6553 if (*iter == dfs_stop) {
6554 /* we are done */
6555 break;
6556 }
6557 }
6558
6559 /* fallthrough */
6560 case LYXP_AXIS_FOLLOWING:
6561 if (axis == LYXP_AXIS_FOLLOWING) {
6562 /* DFS through the whole module */
6563 dfs_stop = NULL;
6564 }
6565
6566 /* nested nodes */
6567 assert(*iter);
6568 next = moveto_axis_scnode_next_dfs_forward(*iter, dfs_stop, getnext_opts);
6569 if (next) {
6570 next_type = LYXP_NODE_ELEM;
6571 break;
6572 } /* else get next top-level node just like a child */
6573
6574 /* fallthrough */
6575 case LYXP_AXIS_CHILD:
6576 case LYXP_AXIS_FOLLOWING_SIBLING:
6577 if (!*iter_mod) {
6578 /* nodes from a single module */
6579 if ((next = lys_getnext(*iter, lysc_data_parent(*iter), (*iter)->module->compiled, getnext_opts))) {
6580 next_type = LYXP_NODE_ELEM;
6581 break;
6582 }
6583
6584 assert(scnode);
6585 if (!lysc_data_parent(scnode)) {
6586 /* iterating over top-level nodes, find next */
6587 while (lysc_data_parent(*iter)) {
6588 *iter = lysc_data_parent(*iter);
6589 }
6590 if ((next = lys_getnext(*iter, NULL, (*iter)->module->compiled, getnext_opts))) {
6591 next_type = LYXP_NODE_ELEM;
6592 break;
6593 }
6594 }
6595 }
6596
6597 while (*iter_mod) {
6598 /* module top-level nodes */
6599 if ((next = lys_getnext(*iter, NULL, (*iter_mod)->compiled, getnext_opts))) {
6600 next_type = LYXP_NODE_ELEM;
6601 break;
6602 }
6603
6604 /* get next module */
6605 while ((*iter_mod = ly_ctx_get_module_iter(set->ctx, iter_mod_idx))) {
6606 /* module may not be implemented or not compiled yet */
6607 if ((*iter_mod)->compiled) {
6608 break;
6609 }
6610 }
6611
6612 /* new module, start over */
6613 *iter = NULL;
6614 }
6615 break;
6616
6617 case LYXP_AXIS_PRECEDING_SIBLING:
6618 assert(*iter);
6619
6620 /* next parent sibling until scnode */
6621 next = lys_getnext(*iter, lysc_data_parent(*iter), (*iter)->module->compiled, getnext_opts);
6622 if (next == scnode) {
6623 /* no previous sibling */
6624 next = NULL;
6625 }
6626 next_type = next ? LYXP_NODE_ELEM : 0;
6627 break;
6628
6629 case LYXP_AXIS_ATTRIBUTE:
6630 /* unreachable */
6631 assert(0);
6632 LOGINT(set->ctx);
6633 break;
6634 }
6635
6636 *iter = next;
6637 *iter_type = next_type;
6638 return next_type ? LY_SUCCESS : LY_ENOTFOUND;
6639}
6640
6641/**
Michal Vaskod3678892020-05-21 10:06:58 +02006642 * @brief Move context @p set to a schema node. Result is LYXP_SET_SCNODE_SET (or LYXP_SET_EMPTY).
6643 *
6644 * @param[in,out] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006645 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02006646 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vasko49fec8e2022-05-24 10:28:33 +02006647 * @param[in] axis Axis to search on.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006648 * @param[in] options XPath options.
6649 * @return LY_ERR
6650 */
6651static LY_ERR
Michal Vasko49fec8e2022-05-24 10:28:33 +02006652moveto_scnode(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, enum lyxp_axis axis,
6653 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006654{
Radek Krejci857189e2020-09-01 13:26:36 +02006655 ly_bool temp_ctx = 0;
Michal Vasko49fec8e2022-05-24 10:28:33 +02006656 uint32_t getnext_opts, orig_used, i, mod_idx, idx;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006657 const struct lys_module *mod;
Michal Vasko49fec8e2022-05-24 10:28:33 +02006658 const struct lysc_node *iter;
6659 enum lyxp_node_type iter_type;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006660
aPiecek8b0cc152021-05-31 16:40:31 +02006661 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006662 return LY_SUCCESS;
6663 }
6664
6665 if (set->type != LYXP_SET_SCNODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006666 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006667 return LY_EVALID;
6668 }
6669
Michal Vaskocafad9d2019-11-07 15:20:03 +01006670 /* getnext opts */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01006671 getnext_opts = 0;
Michal Vaskocafad9d2019-11-07 15:20:03 +01006672 if (options & LYXP_SCNODE_OUTPUT) {
6673 getnext_opts |= LYS_GETNEXT_OUTPUT;
6674 }
6675
Michal Vasko03ff5a72019-09-11 13:49:33 +02006676 orig_used = set->used;
6677 for (i = 0; i < orig_used; ++i) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02006678 /* update in_ctx first */
6679 if (moveto_axis_scnode_next_in_ctx(&set->val.scnodes[i].in_ctx, axis)) {
6680 /* not usable, skip */
6681 continue;
6682 }
Radek Krejciaa6b53f2020-08-27 15:19:03 +02006683
Michal Vasko49fec8e2022-05-24 10:28:33 +02006684 iter = NULL;
6685 iter_type = 0;
6686 while (!moveto_axis_scnode_next(&iter, &iter_type, &mod, &mod_idx, set->val.scnodes[i].scnode,
6687 set->val.scnodes[i].type, axis, set, getnext_opts)) {
6688 if (moveto_scnode_check(iter, NULL, set, ncname, moveto_mod)) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01006689 continue;
6690 }
6691
Michal Vasko49fec8e2022-05-24 10:28:33 +02006692 /* insert */
Michal Vasko7333cb32022-07-29 16:30:29 +02006693 LY_CHECK_RET(set_scnode_insert_node(set, iter, iter_type, axis, &idx));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006694
Michal Vasko49fec8e2022-05-24 10:28:33 +02006695 /* we need to prevent these nodes from being considered in this moveto */
6696 if ((idx < orig_used) && (idx > i)) {
6697 set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_NEW_CTX;
6698 temp_ctx = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006699 }
6700 }
6701 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006702
6703 /* correct temporary in_ctx values */
6704 if (temp_ctx) {
6705 for (i = 0; i < orig_used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006706 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_NEW_CTX) {
6707 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006708 }
6709 }
6710 }
6711
6712 return LY_SUCCESS;
6713}
6714
6715/**
Michal Vasko49fec8e2022-05-24 10:28:33 +02006716 * @brief Move context @p set to a child node and all its descendants. Result is LYXP_SET_NODE_SET.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006717 * Context position aware.
6718 *
6719 * @param[in] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006720 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02006721 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vaskocdad7122020-11-09 21:04:44 +01006722 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006723 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6724 */
6725static LY_ERR
Michal Vasko49fec8e2022-05-24 10:28:33 +02006726moveto_node_alldesc_child(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006727{
6728 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006729 const struct lyd_node *next, *elem, *start;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006730 struct lyxp_set ret_set;
6731 LY_ERR rc;
6732
aPiecek8b0cc152021-05-31 16:40:31 +02006733 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006734 return LY_SUCCESS;
6735 }
6736
6737 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006738 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006739 return LY_EVALID;
6740 }
6741
Michal Vasko9f96a052020-03-10 09:41:45 +01006742 /* replace the original nodes (and throws away all text and meta nodes, root is replaced by a child) */
Michal Vasko49fec8e2022-05-24 10:28:33 +02006743 rc = xpath_pi_node(set, LYXP_AXIS_CHILD, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006744 LY_CHECK_RET(rc);
6745
Michal Vasko6346ece2019-09-24 13:12:53 +02006746 /* this loop traverses all the nodes in the set and adds/keeps only those that match qname */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006747 set_init(&ret_set, set);
6748 for (i = 0; i < set->used; ++i) {
6749
6750 /* TREE DFS */
6751 start = set->val.nodes[i].node;
6752 for (elem = next = start; elem; elem = next) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02006753 rc = moveto_node_check(elem, LYXP_NODE_ELEM, set, ncname, moveto_mod, options);
Michal Vasko6346ece2019-09-24 13:12:53 +02006754 if (!rc) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006755 /* add matching node into result set */
6756 set_insert_node(&ret_set, elem, 0, LYXP_NODE_ELEM, ret_set.used);
6757 if (set_dup_node_check(set, elem, LYXP_NODE_ELEM, i)) {
6758 /* the node is a duplicate, we'll process it later in the set */
6759 goto skip_children;
6760 }
Michal Vasko6346ece2019-09-24 13:12:53 +02006761 } else if (rc == LY_EINCOMPLETE) {
Michal Vasko6346ece2019-09-24 13:12:53 +02006762 return rc;
6763 } else if (rc == LY_EINVAL) {
6764 goto skip_children;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006765 }
6766
6767 /* TREE DFS NEXT ELEM */
6768 /* select element for the next run - children first */
Radek Krejcia1c1e542020-09-29 16:06:52 +02006769 next = lyd_child(elem);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006770 if (!next) {
6771skip_children:
6772 /* no children, so try siblings, but only if it's not the start,
6773 * that is considered to be the root and it's siblings are not traversed */
6774 if (elem != start) {
6775 next = elem->next;
6776 } else {
6777 break;
6778 }
6779 }
6780 while (!next) {
6781 /* no siblings, go back through the parents */
Michal Vasko9e685082021-01-29 14:49:09 +01006782 if (lyd_parent(elem) == start) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006783 /* we are done, no next element to process */
6784 break;
6785 }
6786 /* parent is already processed, go to its sibling */
Michal Vasko9e685082021-01-29 14:49:09 +01006787 elem = lyd_parent(elem);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006788 next = elem->next;
6789 }
6790 }
6791 }
6792
6793 /* make the temporary set the current one */
6794 ret_set.ctx_pos = set->ctx_pos;
6795 ret_set.ctx_size = set->ctx_size;
Michal Vaskod3678892020-05-21 10:06:58 +02006796 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006797 memcpy(set, &ret_set, sizeof *set);
Michal Vasko306e2832022-07-25 09:15:17 +02006798 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006799
6800 return LY_SUCCESS;
6801}
6802
6803/**
Michal Vasko49fec8e2022-05-24 10:28:33 +02006804 * @brief Move context @p set to a child schema node and all its descendants starting from a node.
6805 * Result is LYXP_SET_NODE_SET.
6806 *
6807 * @param[in] set Set to use.
6808 * @param[in] start Start node whose subtree to add.
6809 * @param[in] start_idx Index of @p start in @p set.
6810 * @param[in] moveto_mod Matching node module, NULL for no prefix.
6811 * @param[in] ncname Matching node name in the dictionary, NULL for any.
6812 * @param[in] options XPath options.
6813 * @return LY_ERR value.
6814 */
6815static LY_ERR
6816moveto_scnode_dfs(struct lyxp_set *set, const struct lysc_node *start, uint32_t start_idx,
6817 const struct lys_module *moveto_mod, const char *ncname, uint32_t options)
6818{
6819 const struct lysc_node *next, *elem;
6820 uint32_t idx;
6821 LY_ERR rc;
6822
6823 /* TREE DFS */
6824 for (elem = next = start; elem; elem = next) {
6825 if ((elem == start) || (elem->nodetype & (LYS_CHOICE | LYS_CASE))) {
6826 /* schema-only nodes, skip root */
6827 goto next_iter;
6828 }
6829
6830 rc = moveto_scnode_check(elem, start, set, ncname, moveto_mod);
6831 if (!rc) {
6832 if (lyxp_set_scnode_contains(set, elem, LYXP_NODE_ELEM, start_idx, &idx)) {
6833 set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
6834 if (idx > start_idx) {
6835 /* we will process it later in the set */
6836 goto skip_children;
6837 }
6838 } else {
Michal Vasko7333cb32022-07-29 16:30:29 +02006839 LY_CHECK_RET(set_scnode_insert_node(set, elem, LYXP_NODE_ELEM, LYXP_AXIS_DESCENDANT, NULL));
Michal Vasko49fec8e2022-05-24 10:28:33 +02006840 }
6841 } else if (rc == LY_EINVAL) {
6842 goto skip_children;
6843 }
6844
6845next_iter:
6846 /* TREE DFS NEXT ELEM */
6847 /* select element for the next run - children first */
6848 next = lysc_node_child(elem);
6849 if (next && (next->nodetype == LYS_INPUT) && (options & LYXP_SCNODE_OUTPUT)) {
6850 next = next->next;
6851 } else if (next && (next->nodetype == LYS_OUTPUT) && !(options & LYXP_SCNODE_OUTPUT)) {
6852 next = next->next;
6853 }
6854 if (!next) {
6855skip_children:
6856 /* no children, so try siblings, but only if it's not the start,
6857 * that is considered to be the root and it's siblings are not traversed */
6858 if (elem != start) {
6859 next = elem->next;
6860 } else {
6861 break;
6862 }
6863 }
6864 while (!next) {
6865 /* no siblings, go back through the parents */
6866 if (elem->parent == start) {
6867 /* we are done, no next element to process */
6868 break;
6869 }
6870 /* parent is already processed, go to its sibling */
6871 elem = elem->parent;
6872 next = elem->next;
6873 }
6874 }
6875
6876 return LY_SUCCESS;
6877}
6878
6879/**
6880 * @brief Move context @p set to a child schema node and all its descendants. Result is LYXP_SET_NODE_SET.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006881 *
6882 * @param[in] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006883 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02006884 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006885 * @param[in] options XPath options.
Michal Vasko49fec8e2022-05-24 10:28:33 +02006886 * @return LY_ERR value.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006887 */
6888static LY_ERR
Michal Vasko49fec8e2022-05-24 10:28:33 +02006889moveto_scnode_alldesc_child(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006890{
Michal Vasko49fec8e2022-05-24 10:28:33 +02006891 uint32_t i, orig_used, mod_idx;
6892 const struct lys_module *mod;
6893 const struct lysc_node *root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006894
aPiecek8b0cc152021-05-31 16:40:31 +02006895 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006896 return LY_SUCCESS;
6897 }
6898
6899 if (set->type != LYXP_SET_SCNODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006900 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006901 return LY_EVALID;
6902 }
6903
Michal Vasko03ff5a72019-09-11 13:49:33 +02006904 orig_used = set->used;
6905 for (i = 0; i < orig_used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006906 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
6907 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01006908 continue;
6909 }
6910
6911 /* remember context node */
Radek Krejcif13b87b2020-12-01 22:02:17 +01006912 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vaskoec4df482019-12-16 10:02:18 +01006913 } else {
Michal Vasko1a09b212021-05-06 13:00:10 +02006914 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006915 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006916
Michal Vasko49fec8e2022-05-24 10:28:33 +02006917 if ((set->val.scnodes[i].type == LYXP_NODE_ROOT_CONFIG) || (set->val.scnodes[i].type == LYXP_NODE_ROOT)) {
6918 /* traverse all top-level nodes in all the modules */
6919 mod_idx = 0;
6920 while ((mod = ly_ctx_get_module_iter(set->ctx, &mod_idx))) {
6921 /* module may not be implemented or not compiled yet */
6922 if (!mod->compiled) {
6923 continue;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006924 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006925
Michal Vasko49fec8e2022-05-24 10:28:33 +02006926 root = NULL;
6927 /* no getnext opts needed */
6928 while ((root = lys_getnext(root, NULL, mod->compiled, 0))) {
6929 LY_CHECK_RET(moveto_scnode_dfs(set, root, i, moveto_mod, ncname, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006930 }
6931 }
Michal Vasko49fec8e2022-05-24 10:28:33 +02006932
6933 } else if (set->val.scnodes[i].type == LYXP_NODE_ELEM) {
6934 /* add all the descendants recursively */
6935 LY_CHECK_RET(moveto_scnode_dfs(set, set->val.scnodes[i].scnode, i, moveto_mod, ncname, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006936 }
6937 }
6938
6939 return LY_SUCCESS;
6940}
6941
6942/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02006943 * @brief Move context @p set to an attribute. Result is LYXP_SET_NODE_SET.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006944 * Indirectly context position aware.
6945 *
6946 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02006947 * @param[in] mod Matching metadata module, NULL for any.
6948 * @param[in] ncname Matching metadata name in the dictionary, NULL for any.
aPiecek8b0cc152021-05-31 16:40:31 +02006949 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006950 * @return LY_ERR
6951 */
6952static LY_ERR
aPiecek8b0cc152021-05-31 16:40:31 +02006953moveto_attr(struct lyxp_set *set, const struct lys_module *mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006954{
Michal Vasko9f96a052020-03-10 09:41:45 +01006955 struct lyd_meta *sub;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006956
aPiecek8b0cc152021-05-31 16:40:31 +02006957 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006958 return LY_SUCCESS;
6959 }
6960
6961 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006962 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006963 return LY_EVALID;
6964 }
6965
Radek Krejci1deb5be2020-08-26 16:43:36 +02006966 for (uint32_t i = 0; i < set->used; ) {
Radek Krejci857189e2020-09-01 13:26:36 +02006967 ly_bool replaced = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006968
6969 /* only attributes of an elem (not dummy) can be in the result, skip all the rest;
6970 * our attributes are always qualified */
Michal Vasko5c4e5892019-11-14 12:31:38 +01006971 if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko9f96a052020-03-10 09:41:45 +01006972 for (sub = set->val.nodes[i].node->meta; sub; sub = sub->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006973
6974 /* check "namespace" */
Michal Vaskod3678892020-05-21 10:06:58 +02006975 if (mod && (sub->annotation->module != mod)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006976 continue;
6977 }
6978
Michal Vaskod3678892020-05-21 10:06:58 +02006979 if (!ncname || (sub->name == ncname)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006980 /* match */
6981 if (!replaced) {
Michal Vasko9f96a052020-03-10 09:41:45 +01006982 set->val.meta[i].meta = sub;
6983 set->val.meta[i].type = LYXP_NODE_META;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006984 /* pos does not change */
6985 replaced = 1;
6986 } else {
Michal Vasko9f96a052020-03-10 09:41:45 +01006987 set_insert_node(set, (struct lyd_node *)sub, set->val.nodes[i].pos, LYXP_NODE_META, i + 1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006988 }
6989 ++i;
6990 }
6991 }
6992 }
6993
6994 if (!replaced) {
6995 /* no match */
6996 set_remove_node(set, i);
6997 }
6998 }
6999
7000 return LY_SUCCESS;
7001}
7002
7003/**
7004 * @brief Move context @p set1 to union with @p set2. @p set2 is emptied afterwards.
Michal Vasko61ac2f62020-05-25 12:39:51 +02007005 * Result is LYXP_SET_NODE_SET. Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007006 *
7007 * @param[in,out] set1 Set to use for the result.
7008 * @param[in] set2 Set that is copied to @p set1.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007009 * @return LY_ERR
7010 */
7011static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007012moveto_union(struct lyxp_set *set1, struct lyxp_set *set2)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007013{
7014 LY_ERR rc;
7015
Michal Vaskod3678892020-05-21 10:06:58 +02007016 if ((set1->type != LYXP_SET_NODE_SET) || (set2->type != LYXP_SET_NODE_SET)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01007017 LOGVAL(set1->ctx, LY_VCODE_XP_INOP_2, "union", print_set_type(set1), print_set_type(set2));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007018 return LY_EVALID;
7019 }
7020
7021 /* set2 is empty or both set1 and set2 */
Michal Vaskod3678892020-05-21 10:06:58 +02007022 if (!set2->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007023 return LY_SUCCESS;
7024 }
7025
Michal Vaskod3678892020-05-21 10:06:58 +02007026 if (!set1->used) {
aPiecekadc1e4f2021-10-07 11:15:12 +02007027 /* release hidden allocated data (lyxp_set.size) */
7028 lyxp_set_free_content(set1);
7029 /* direct copying of the entire structure */
Michal Vasko03ff5a72019-09-11 13:49:33 +02007030 memcpy(set1, set2, sizeof *set1);
7031 /* dynamic memory belongs to set1 now, do not free */
Michal Vaskod3678892020-05-21 10:06:58 +02007032 memset(set2, 0, sizeof *set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007033 return LY_SUCCESS;
7034 }
7035
7036 /* we assume sets are sorted */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007037 assert(!set_sort(set1) && !set_sort(set2));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007038
7039 /* sort, remove duplicates */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007040 rc = set_sorted_merge(set1, set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007041 LY_CHECK_RET(rc);
7042
7043 /* final set must be sorted */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007044 assert(!set_sort(set1));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007045
7046 return LY_SUCCESS;
7047}
7048
7049/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02007050 * @brief Move context @p set to an attribute in any of the descendants. Result is LYXP_SET_NODE_SET.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007051 * Context position aware.
7052 *
7053 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02007054 * @param[in] mod Matching metadata module, NULL for any.
7055 * @param[in] ncname Matching metadata name in the dictionary, NULL for any.
Michal Vaskocdad7122020-11-09 21:04:44 +01007056 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007057 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7058 */
7059static int
Michal Vaskocdad7122020-11-09 21:04:44 +01007060moveto_attr_alldesc(struct lyxp_set *set, const struct lys_module *mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007061{
Michal Vasko9f96a052020-03-10 09:41:45 +01007062 struct lyd_meta *sub;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007063 struct lyxp_set *set_all_desc = NULL;
7064 LY_ERR rc;
7065
aPiecek8b0cc152021-05-31 16:40:31 +02007066 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007067 return LY_SUCCESS;
7068 }
7069
7070 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01007071 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007072 return LY_EVALID;
7073 }
7074
Michal Vasko03ff5a72019-09-11 13:49:33 +02007075 /* can be optimized similarly to moveto_node_alldesc() and save considerable amount of memory,
7076 * but it likely won't be used much, so it's a waste of time */
7077 /* copy the context */
7078 set_all_desc = set_copy(set);
7079 /* get all descendant nodes (the original context nodes are removed) */
Michal Vasko49fec8e2022-05-24 10:28:33 +02007080 rc = moveto_node_alldesc_child(set_all_desc, NULL, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007081 if (rc != LY_SUCCESS) {
7082 lyxp_set_free(set_all_desc);
7083 return rc;
7084 }
7085 /* prepend the original context nodes */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007086 rc = moveto_union(set, set_all_desc);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007087 if (rc != LY_SUCCESS) {
7088 lyxp_set_free(set_all_desc);
7089 return rc;
7090 }
7091 lyxp_set_free(set_all_desc);
7092
Radek Krejci1deb5be2020-08-26 16:43:36 +02007093 for (uint32_t i = 0; i < set->used; ) {
Radek Krejci857189e2020-09-01 13:26:36 +02007094 ly_bool replaced = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007095
7096 /* only attributes of an elem can be in the result, skip all the rest,
7097 * we have all attributes qualified in lyd tree */
7098 if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko9f96a052020-03-10 09:41:45 +01007099 for (sub = set->val.nodes[i].node->meta; sub; sub = sub->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007100 /* check "namespace" */
Michal Vaskod3678892020-05-21 10:06:58 +02007101 if (mod && (sub->annotation->module != mod)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007102 continue;
7103 }
7104
Michal Vaskod3678892020-05-21 10:06:58 +02007105 if (!ncname || (sub->name == ncname)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007106 /* match */
7107 if (!replaced) {
Michal Vasko9f96a052020-03-10 09:41:45 +01007108 set->val.meta[i].meta = sub;
7109 set->val.meta[i].type = LYXP_NODE_META;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007110 /* pos does not change */
7111 replaced = 1;
7112 } else {
Michal Vasko9f96a052020-03-10 09:41:45 +01007113 set_insert_node(set, (struct lyd_node *)sub, set->val.meta[i].pos, LYXP_NODE_META, i + 1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007114 }
7115 ++i;
7116 }
7117 }
7118 }
7119
7120 if (!replaced) {
7121 /* no match */
7122 set_remove_node(set, i);
7123 }
7124 }
7125
7126 return LY_SUCCESS;
7127}
7128
7129/**
Michal Vasko8abcecc2022-07-28 09:55:01 +02007130 * @brief Move context @p set1 single item to the result of a comparison.
7131 *
7132 * @param[in] set1 First set with the item to compare.
7133 * @param[in] idx1 Index of the item in @p set1.
7134 * @param[in] set2 Second set.
7135 * @param[in] op Comparison operator to process.
7136 * @param[in] switch_operands Whether to switch sets as operands; whether it is `set1 op set2` or `set2 op set1`.
7137 * @param[out] result Result of the comparison.
7138 * @return LY_ERR value.
7139 */
7140static LY_ERR
7141moveto_op_comp_item(const struct lyxp_set *set1, uint32_t idx1, struct lyxp_set *set2, const char *op,
7142 ly_bool switch_operands, ly_bool *result)
7143{
7144 struct lyxp_set tmp1 = {0};
7145 LY_ERR rc = LY_SUCCESS;
7146
7147 assert(set1->type == LYXP_SET_NODE_SET);
7148
7149 /* cast set1 */
7150 switch (set2->type) {
7151 case LYXP_SET_NUMBER:
7152 rc = set_comp_cast(&tmp1, set1, LYXP_SET_NUMBER, idx1);
7153 break;
7154 case LYXP_SET_BOOLEAN:
7155 rc = set_comp_cast(&tmp1, set1, LYXP_SET_BOOLEAN, idx1);
7156 break;
7157 default:
7158 rc = set_comp_cast(&tmp1, set1, LYXP_SET_STRING, idx1);
7159 break;
7160 }
7161 LY_CHECK_GOTO(rc, cleanup);
7162
7163 /* canonize set2 */
7164 LY_CHECK_GOTO(rc = set_comp_canonize(set2, &set1->val.nodes[idx1]), cleanup);
7165
7166 /* compare recursively and store the result */
7167 if (switch_operands) {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007168 LY_CHECK_GOTO(rc = moveto_op_comp(set2, &tmp1, op, result), cleanup);
Michal Vasko8abcecc2022-07-28 09:55:01 +02007169 } else {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007170 LY_CHECK_GOTO(rc = moveto_op_comp(&tmp1, set2, op, result), cleanup);
Michal Vasko8abcecc2022-07-28 09:55:01 +02007171 }
7172
7173cleanup:
7174 lyxp_set_free_content(&tmp1);
7175 return rc;
7176}
7177
7178/**
7179 * @brief Move context @p set1 to the result of a comparison. Handles '=', '!=', '<=', '<', '>=', or '>'.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007180 * Result is LYXP_SET_BOOLEAN. Indirectly context position aware.
7181 *
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007182 * @param[in] set1 Set acting as the first operand for @p op.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007183 * @param[in] set2 Set acting as the second operand for @p op.
7184 * @param[in] op Comparison operator to process.
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007185 * @param[out] result Result of the comparison.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007186 * @return LY_ERR
7187 */
7188static LY_ERR
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007189moveto_op_comp(struct lyxp_set *set1, struct lyxp_set *set2, const char *op, ly_bool *result)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007190{
7191 /*
7192 * NODE SET + NODE SET = NODE SET + STRING /(1 NODE SET) 2 STRING
7193 * NODE SET + STRING = STRING + STRING /1 STRING (2 STRING)
7194 * NODE SET + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
7195 * NODE SET + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
7196 * STRING + NODE SET = STRING + STRING /(1 STRING) 2 STRING
7197 * NUMBER + NODE SET = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
7198 * BOOLEAN + NODE SET = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
7199 *
7200 * '=' or '!='
7201 * BOOLEAN + BOOLEAN
7202 * BOOLEAN + STRING = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
7203 * BOOLEAN + NUMBER = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
7204 * STRING + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
7205 * NUMBER + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
7206 * NUMBER + NUMBER
7207 * NUMBER + STRING = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
7208 * STRING + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
7209 * STRING + STRING
7210 *
7211 * '<=', '<', '>=', '>'
7212 * NUMBER + NUMBER
7213 * BOOLEAN + BOOLEAN = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
7214 * BOOLEAN + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
7215 * BOOLEAN + STRING = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
7216 * NUMBER + STRING = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
7217 * STRING + STRING = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
7218 * STRING + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
7219 * NUMBER + BOOLEAN = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
7220 * STRING + BOOLEAN = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
7221 */
Michal Vasko8abcecc2022-07-28 09:55:01 +02007222 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007223 LY_ERR rc;
7224
Michal Vasko03ff5a72019-09-11 13:49:33 +02007225 /* iterative evaluation with node-sets */
7226 if ((set1->type == LYXP_SET_NODE_SET) || (set2->type == LYXP_SET_NODE_SET)) {
7227 if (set1->type == LYXP_SET_NODE_SET) {
7228 for (i = 0; i < set1->used; ++i) {
Michal Vasko8abcecc2022-07-28 09:55:01 +02007229 /* evaluate for the single item */
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007230 LY_CHECK_RET(moveto_op_comp_item(set1, i, set2, op, 0, result));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007231
7232 /* lazy evaluation until true */
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007233 if (*result) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007234 return LY_SUCCESS;
7235 }
7236 }
7237 } else {
7238 for (i = 0; i < set2->used; ++i) {
Michal Vasko8abcecc2022-07-28 09:55:01 +02007239 /* evaluate for the single item */
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007240 LY_CHECK_RET(moveto_op_comp_item(set2, i, set1, op, 1, result));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007241
7242 /* lazy evaluation until true */
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007243 if (*result) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007244 return LY_SUCCESS;
7245 }
7246 }
7247 }
7248
Michal Vasko8abcecc2022-07-28 09:55:01 +02007249 /* false for all the nodes */
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007250 *result = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007251 return LY_SUCCESS;
7252 }
7253
7254 /* first convert properly */
7255 if ((op[0] == '=') || (op[0] == '!')) {
7256 if ((set1->type == LYXP_SET_BOOLEAN) || (set2->type == LYXP_SET_BOOLEAN)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007257 lyxp_set_cast(set1, LYXP_SET_BOOLEAN);
7258 lyxp_set_cast(set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007259 } else if ((set1->type == LYXP_SET_NUMBER) || (set2->type == LYXP_SET_NUMBER)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007260 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007261 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007262 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007263 LY_CHECK_RET(rc);
7264 } /* else we have 2 strings */
7265 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007266 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007267 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007268 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007269 LY_CHECK_RET(rc);
7270 }
7271
7272 assert(set1->type == set2->type);
7273
7274 /* compute result */
7275 if (op[0] == '=') {
7276 if (set1->type == LYXP_SET_BOOLEAN) {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007277 *result = (set1->val.bln == set2->val.bln);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007278 } else if (set1->type == LYXP_SET_NUMBER) {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007279 *result = (set1->val.num == set2->val.num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007280 } else {
7281 assert(set1->type == LYXP_SET_STRING);
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007282 *result = strcmp(set1->val.str, set2->val.str) ? 0 : 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007283 }
7284 } else if (op[0] == '!') {
7285 if (set1->type == LYXP_SET_BOOLEAN) {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007286 *result = (set1->val.bln != set2->val.bln);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007287 } else if (set1->type == LYXP_SET_NUMBER) {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007288 *result = (set1->val.num != set2->val.num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007289 } else {
7290 assert(set1->type == LYXP_SET_STRING);
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007291 *result = strcmp(set1->val.str, set2->val.str) ? 1 : 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007292 }
7293 } else {
7294 assert(set1->type == LYXP_SET_NUMBER);
7295 if (op[0] == '<') {
7296 if (op[1] == '=') {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007297 *result = (set1->val.num <= set2->val.num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007298 } else {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007299 *result = (set1->val.num < set2->val.num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007300 }
7301 } else {
7302 if (op[1] == '=') {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007303 *result = (set1->val.num >= set2->val.num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007304 } else {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007305 *result = (set1->val.num > set2->val.num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007306 }
7307 }
7308 }
7309
Michal Vasko03ff5a72019-09-11 13:49:33 +02007310 return LY_SUCCESS;
7311}
7312
7313/**
7314 * @brief Move context @p set to the result of a basic operation. Handles '+', '-', unary '-', '*', 'div',
7315 * or 'mod'. Result is LYXP_SET_NUMBER. Indirectly context position aware.
7316 *
7317 * @param[in,out] set1 Set to use for the result.
7318 * @param[in] set2 Set acting as the second operand for @p op.
7319 * @param[in] op Operator to process.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007320 * @return LY_ERR
7321 */
7322static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007323moveto_op_math(struct lyxp_set *set1, struct lyxp_set *set2, const char *op)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007324{
7325 LY_ERR rc;
7326
7327 /* unary '-' */
7328 if (!set2 && (op[0] == '-')) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007329 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007330 LY_CHECK_RET(rc);
7331 set1->val.num *= -1;
7332 lyxp_set_free(set2);
7333 return LY_SUCCESS;
7334 }
7335
7336 assert(set1 && set2);
7337
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007338 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007339 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007340 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007341 LY_CHECK_RET(rc);
7342
7343 switch (op[0]) {
7344 /* '+' */
7345 case '+':
7346 set1->val.num += set2->val.num;
7347 break;
7348
7349 /* '-' */
7350 case '-':
7351 set1->val.num -= set2->val.num;
7352 break;
7353
7354 /* '*' */
7355 case '*':
7356 set1->val.num *= set2->val.num;
7357 break;
7358
7359 /* 'div' */
7360 case 'd':
7361 set1->val.num /= set2->val.num;
7362 break;
7363
7364 /* 'mod' */
7365 case 'm':
7366 set1->val.num = ((long long)set1->val.num) % ((long long)set2->val.num);
7367 break;
7368
7369 default:
7370 LOGINT_RET(set1->ctx);
7371 }
7372
7373 return LY_SUCCESS;
7374}
7375
Michal Vasko03ff5a72019-09-11 13:49:33 +02007376/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02007377 * @brief Evaluate Predicate. Logs directly on error.
7378 *
Michal Vaskod3678892020-05-21 10:06:58 +02007379 * [9] Predicate ::= '[' Expr ']'
Michal Vasko03ff5a72019-09-11 13:49:33 +02007380 *
7381 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007382 * @param[in] tok_idx Position in the expression @p exp.
aPiecek8b0cc152021-05-31 16:40:31 +02007383 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007384 * @param[in] options XPath options.
Michal Vasko49fec8e2022-05-24 10:28:33 +02007385 * @param[in] axis Axis to search on.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007386 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7387 */
7388static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02007389eval_predicate(const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set, uint32_t options, enum lyxp_axis axis)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007390{
7391 LY_ERR rc;
Michal Vaskodd528af2022-08-08 14:35:07 +02007392 uint32_t i, orig_exp, orig_pos, orig_size;
Michal Vasko5c4e5892019-11-14 12:31:38 +01007393 int32_t pred_in_ctx;
Michal Vasko88a9e802022-05-24 10:50:28 +02007394 ly_bool reverse_axis = 0;
aPiecekfff4dca2021-10-07 10:59:53 +02007395 struct lyxp_set set2 = {0};
Michal Vasko03ff5a72019-09-11 13:49:33 +02007396
7397 /* '[' */
aPiecek8b0cc152021-05-31 16:40:31 +02007398 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02007399 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007400 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007401
aPiecek8b0cc152021-05-31 16:40:31 +02007402 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007403only_parse:
aPiecek8b0cc152021-05-31 16:40:31 +02007404 rc = eval_expr_select(exp, tok_idx, 0, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007405 LY_CHECK_RET(rc);
7406 } else if (set->type == LYXP_SET_NODE_SET) {
7407 /* we (possibly) need the set sorted, it can affect the result (if the predicate result is a number) */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007408 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007409
7410 /* empty set, nothing to evaluate */
7411 if (!set->used) {
7412 goto only_parse;
7413 }
7414
Michal Vasko49fec8e2022-05-24 10:28:33 +02007415 /* decide forward or reverse axis */
7416 switch (axis) {
7417 case LYXP_AXIS_ANCESTOR:
7418 case LYXP_AXIS_ANCESTOR_OR_SELF:
7419 case LYXP_AXIS_PRECEDING:
7420 case LYXP_AXIS_PRECEDING_SIBLING:
7421 reverse_axis = 1;
7422 break;
7423 case LYXP_AXIS_DESCENDANT:
7424 case LYXP_AXIS_DESCENDANT_OR_SELF:
7425 case LYXP_AXIS_FOLLOWING:
7426 case LYXP_AXIS_FOLLOWING_SIBLING:
7427 case LYXP_AXIS_PARENT:
7428 case LYXP_AXIS_CHILD:
7429 case LYXP_AXIS_SELF:
7430 case LYXP_AXIS_ATTRIBUTE:
7431 reverse_axis = 0;
7432 break;
7433 }
7434
Michal Vasko004d3152020-06-11 19:59:22 +02007435 orig_exp = *tok_idx;
Michal Vasko49fec8e2022-05-24 10:28:33 +02007436 orig_pos = reverse_axis ? set->used + 1 : 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007437 orig_size = set->used;
Michal Vasko39dbf352020-05-21 10:08:59 +02007438 for (i = 0; i < set->used; ++i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007439 set_init(&set2, set);
7440 set_insert_node(&set2, set->val.nodes[i].node, set->val.nodes[i].pos, set->val.nodes[i].type, 0);
Michal Vasko49fec8e2022-05-24 10:28:33 +02007441
7442 /* remember the node context position for position() and context size for last() */
7443 orig_pos += reverse_axis ? -1 : 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007444
7445 set2.ctx_pos = orig_pos;
7446 set2.ctx_size = orig_size;
Michal Vasko004d3152020-06-11 19:59:22 +02007447 *tok_idx = orig_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007448
Michal Vasko004d3152020-06-11 19:59:22 +02007449 rc = eval_expr_select(exp, tok_idx, 0, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007450 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02007451 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007452 return rc;
7453 }
7454
Michal Vasko49fec8e2022-05-24 10:28:33 +02007455 /* number is a proximity position */
Michal Vasko03ff5a72019-09-11 13:49:33 +02007456 if (set2.type == LYXP_SET_NUMBER) {
7457 if ((long long)set2.val.num == orig_pos) {
7458 set2.val.num = 1;
7459 } else {
7460 set2.val.num = 0;
7461 }
7462 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007463 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007464
7465 /* predicate satisfied or not? */
Michal Vasko004d3152020-06-11 19:59:22 +02007466 if (!set2.val.bln) {
Michal Vasko2caefc12019-11-14 16:07:56 +01007467 set_remove_node_none(set, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007468 }
7469 }
Michal Vasko2caefc12019-11-14 16:07:56 +01007470 set_remove_nodes_none(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007471
7472 } else if (set->type == LYXP_SET_SCNODE_SET) {
7473 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01007474 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007475 /* there is a currently-valid node */
7476 break;
7477 }
7478 }
7479 /* empty set, nothing to evaluate */
7480 if (i == set->used) {
7481 goto only_parse;
7482 }
7483
Michal Vasko004d3152020-06-11 19:59:22 +02007484 orig_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007485
Michal Vasko03ff5a72019-09-11 13:49:33 +02007486 /* set special in_ctx to all the valid snodes */
7487 pred_in_ctx = set_scnode_new_in_ctx(set);
7488
7489 /* use the valid snodes one-by-one */
7490 for (i = 0; i < set->used; ++i) {
7491 if (set->val.scnodes[i].in_ctx != pred_in_ctx) {
7492 continue;
7493 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01007494 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007495
Michal Vasko004d3152020-06-11 19:59:22 +02007496 *tok_idx = orig_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007497
Michal Vasko004d3152020-06-11 19:59:22 +02007498 rc = eval_expr_select(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007499 LY_CHECK_RET(rc);
7500
7501 set->val.scnodes[i].in_ctx = pred_in_ctx;
7502 }
7503
7504 /* restore the state as it was before the predicate */
7505 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01007506 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko1a09b212021-05-06 13:00:10 +02007507 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007508 } else if (set->val.scnodes[i].in_ctx == pred_in_ctx) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01007509 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007510 }
7511 }
7512
7513 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02007514 set2.type = LYXP_SET_NODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007515 set_fill_set(&set2, set);
7516
Michal Vasko004d3152020-06-11 19:59:22 +02007517 rc = eval_expr_select(exp, tok_idx, 0, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007518 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02007519 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007520 return rc;
7521 }
7522
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007523 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko004d3152020-06-11 19:59:22 +02007524 if (!set2.val.bln) {
Michal Vaskod3678892020-05-21 10:06:58 +02007525 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007526 }
Michal Vaskod3678892020-05-21 10:06:58 +02007527 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007528 }
7529
7530 /* ']' */
Michal Vasko004d3152020-06-11 19:59:22 +02007531 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
aPiecek8b0cc152021-05-31 16:40:31 +02007532 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02007533 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007534 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007535
7536 return LY_SUCCESS;
7537}
7538
7539/**
Michal Vaskod3678892020-05-21 10:06:58 +02007540 * @brief Evaluate Literal. Logs directly on error.
7541 *
7542 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007543 * @param[in] tok_idx Position in the expression @p exp.
Michal Vaskod3678892020-05-21 10:06:58 +02007544 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7545 */
7546static void
Michal Vaskodd528af2022-08-08 14:35:07 +02007547eval_literal(const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set)
Michal Vaskod3678892020-05-21 10:06:58 +02007548{
7549 if (set) {
Michal Vasko004d3152020-06-11 19:59:22 +02007550 if (exp->tok_len[*tok_idx] == 2) {
Michal Vaskod3678892020-05-21 10:06:58 +02007551 set_fill_string(set, "", 0);
7552 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007553 set_fill_string(set, &exp->expr[exp->tok_pos[*tok_idx] + 1], exp->tok_len[*tok_idx] - 2);
Michal Vaskod3678892020-05-21 10:06:58 +02007554 }
7555 }
7556 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02007557 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007558 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007559}
7560
7561/**
Michal Vasko3d969ff2022-07-29 15:02:08 +02007562 * @brief Check that a nametest in a predicate matches a key node.
7563 *
7564 * @param[in] nametest Nametest to check.
7565 * @param[in] len Length of @p nametest.
7566 * @param[in] ctx_scnode Found schema node as the context for the predicate.
7567 * @param[in] set Context set.
7568 * @param[in] key Expected key node.
7569 * @return LY_SUCCESS on success,
7570 * @return LY_ENOT if a predicate could not be compiled.
7571 * @return LY_ERR on any error.
7572 */
7573static LY_ERR
7574eval_name_test_try_compile_predicate_key(const char *nametest, uint32_t len, const struct lysc_node *ctx_scnode,
7575 const struct lyxp_set *set, const struct lysc_node *key)
7576{
7577 const struct lys_module *mod;
7578
7579 /* prefix (module) */
7580 LY_CHECK_RET(moveto_resolve_model(&nametest, &len, set, ctx_scnode, &mod));
7581 if (mod != key->module) {
7582 return LY_ENOT;
7583 }
7584
7585 /* node name */
7586 if (ly_strncmp(key->name, nametest, len)) {
7587 return LY_ENOT;
7588 }
7589
7590 return LY_SUCCESS;
7591}
7592
7593/**
7594 * @brief Append a simple predicate for the node.
7595 *
7596 * @param[in] exp Full parsed XPath expression.
7597 * @param[in] tok_idx Predicate start index in @p exp.
7598 * @param[in] end_tok_idx Predicate end index in @p exp.
7599 * @param[in] ctx_scnode Found schema node as the context for the predicate.
7600 * @param[in] set Context set.
7601 * @param[in] pred_node Node with the value referenced in the predicate.
7602 * @param[in,out] pred Predicate to append to.
7603 * @param[in,out] pred_len Length of @p pred, is updated.
7604 * @return LY_SUCCESS on success,
7605 * @return LY_ENOT if a predicate could not be compiled.
7606 * @return LY_ERR on any error.
7607 */
7608static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02007609eval_name_test_try_compile_predicate_append(const struct lyxp_expr *exp, uint32_t tok_idx, uint32_t end_tok_idx,
Michal Vasko3d969ff2022-07-29 15:02:08 +02007610 const struct lysc_node *ctx_scnode, const struct lyxp_set *set, const struct lysc_node *pred_node, char **pred,
7611 uint32_t *pred_len)
7612{
7613 LY_ERR rc = LY_SUCCESS;
7614 uint32_t i;
7615 const struct lyd_node *siblings;
7616 struct lyd_node *ctx_node;
Michal Vasko5fb92a22022-08-02 09:21:37 +02007617 const struct lysc_node *sparent, *cur_scnode;
Michal Vasko3d969ff2022-07-29 15:02:08 +02007618 struct lyxp_expr *val_exp = NULL;
7619 struct lyxp_set set2 = {0};
7620 char quot;
7621
7622 /* duplicate the value expression */
7623 LY_CHECK_GOTO(rc = lyxp_expr_dup(set->ctx, exp, tok_idx, end_tok_idx, &val_exp), cleanup);
7624
7625 /* get its atoms */
Michal Vasko5fb92a22022-08-02 09:21:37 +02007626 cur_scnode = set->cur_node ? set->cur_node->schema : NULL;
7627 LY_CHECK_GOTO(rc = lyxp_atomize(set->ctx, val_exp, set->cur_mod, set->format, set->prefix_data, cur_scnode,
7628 ctx_scnode, &set2, LYXP_SCNODE), cleanup);
Michal Vasko3d969ff2022-07-29 15:02:08 +02007629
7630 /* check whether we can compile a single predicate (evaluation result value is always the same) */
7631 for (i = 0; i < set2.used; ++i) {
7632 if ((set2.val.scnodes[i].type != LYXP_NODE_ELEM) || (set2.val.scnodes[i].in_ctx < LYXP_SET_SCNODE_ATOM_NODE)) {
7633 /* skip root and context node */
7634 continue;
7635 }
7636
Michal Vasko5fb92a22022-08-02 09:21:37 +02007637 /* 1) context node descendants are traversed - do best-effort detection of the value dependency on the
7638 * context node instance */
7639 if ((set2.val.scnodes[i].axis == LYXP_AXIS_CHILD) && (set2.val.scnodes[i].scnode->parent == ctx_scnode)) {
7640 /* 1.1) context node child was accessed on the child axis, certain dependency */
Michal Vasko3d969ff2022-07-29 15:02:08 +02007641 rc = LY_ENOT;
7642 goto cleanup;
7643 }
Michal Vasko5fb92a22022-08-02 09:21:37 +02007644 if ((set2.val.scnodes[i].axis == LYXP_AXIS_DESCENDANT) || (set2.val.scnodes[i].axis == LYXP_AXIS_DESCENDANT_OR_SELF)) {
7645 for (sparent = set2.val.scnodes[i].scnode->parent; sparent && (sparent != ctx_scnode); sparent = sparent->parent) {}
7646 if (sparent) {
7647 /* 1.2) context node descendant was accessed on the descendant axis, probable dependency */
7648 rc = LY_ENOT;
7649 goto cleanup;
7650 }
7651 }
Michal Vasko3d969ff2022-07-29 15:02:08 +02007652
Michal Vasko5fb92a22022-08-02 09:21:37 +02007653 /* 2) multi-instance nodes (list or leaf-list) are traversed - all the instances need to be considered,
7654 * but the current node can be safely ignored, it is always the same data instance */
7655 if ((set2.val.scnodes[i].scnode->nodetype & (LYS_LIST | LYS_LEAFLIST)) && (cur_scnode != set2.val.scnodes[i].scnode)) {
Michal Vasko3d969ff2022-07-29 15:02:08 +02007656 rc = LY_ENOT;
7657 goto cleanup;
7658 }
Michal Vasko3d969ff2022-07-29 15:02:08 +02007659 }
7660
7661 /* get any data instance of the context node, we checked it makes no difference */
7662 siblings = set->val.nodes[0].node ? lyd_child(set->val.nodes[0].node) : set->tree;
7663 LY_CHECK_GOTO(rc = lyd_find_sibling_schema(siblings, ctx_scnode, &ctx_node), cleanup);
7664
7665 /* evaluate the value subexpression with the root context node */
7666 lyxp_set_free_content(&set2);
7667 LY_CHECK_GOTO(rc = lyxp_eval(set->ctx, val_exp, set->cur_mod, set->format, set->prefix_data, set->cur_node,
7668 ctx_node, set->tree, NULL, &set2, 0), cleanup);
7669
7670 /* cast it into a string */
7671 LY_CHECK_GOTO(rc = lyxp_set_cast(&set2, LYXP_SET_STRING), cleanup);
7672
7673 /* append the JSON predicate */
7674 *pred = ly_realloc(*pred, *pred_len + 1 + strlen(pred_node->name) + 2 + strlen(set2.val.str) + 3);
7675 LY_CHECK_ERR_GOTO(!*pred, LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
7676 quot = strchr(set2.val.str, '\'') ? '\"' : '\'';
7677 *pred_len += sprintf(*pred + *pred_len, "[%s=%c%s%c]", pred_node->name, quot, set2.val.str, quot);
7678
7679cleanup:
7680 lyxp_expr_free(set->ctx, val_exp);
7681 lyxp_set_free_content(&set2);
7682 return rc;
7683}
7684
7685/**
Michal Vasko004d3152020-06-11 19:59:22 +02007686 * @brief Try to compile list or leaf-list predicate in the known format to be used for hash-based instance search.
Michal Vaskod3678892020-05-21 10:06:58 +02007687 *
Michal Vasko004d3152020-06-11 19:59:22 +02007688 * @param[in] exp Full parsed XPath expression.
7689 * @param[in,out] tok_idx Index in @p exp at the beginning of the predicate, is updated on success.
Michal Vasko3d969ff2022-07-29 15:02:08 +02007690 * @param[in] ctx_scnode Found schema node as the context for the predicate.
7691 * @param[in] set Context set.
Michal Vasko004d3152020-06-11 19:59:22 +02007692 * @param[out] predicates Parsed predicates.
7693 * @param[out] pred_type Type of @p predicates.
7694 * @return LY_SUCCESS on success,
Michal Vasko3d969ff2022-07-29 15:02:08 +02007695 * @return LY_ENOT if a predicate could not be compiled.
Michal Vasko004d3152020-06-11 19:59:22 +02007696 * @return LY_ERR on any error.
Michal Vaskod3678892020-05-21 10:06:58 +02007697 */
7698static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02007699eval_name_test_try_compile_predicates(const struct lyxp_expr *exp, uint32_t *tok_idx, const struct lysc_node *ctx_scnode,
Michal Vasko3d969ff2022-07-29 15:02:08 +02007700 const struct lyxp_set *set, struct ly_path_predicate **predicates, enum ly_path_pred_type *pred_type)
Michal Vaskod3678892020-05-21 10:06:58 +02007701{
Michal Vasko3d969ff2022-07-29 15:02:08 +02007702 LY_ERR rc = LY_SUCCESS;
Michal Vaskodd528af2022-08-08 14:35:07 +02007703 uint32_t e_idx, val_start_idx, pred_idx = 0, prev_lo, pred_len = 0;
Michal Vaskod3678892020-05-21 10:06:58 +02007704 const struct lysc_node *key;
Michal Vasko3d969ff2022-07-29 15:02:08 +02007705 char *pred = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02007706 struct lyxp_expr *exp2 = NULL;
Michal Vaskod3678892020-05-21 10:06:58 +02007707
Michal Vasko3d969ff2022-07-29 15:02:08 +02007708 assert(ctx_scnode->nodetype & (LYS_LIST | LYS_LEAFLIST));
Michal Vaskod3678892020-05-21 10:06:58 +02007709
Michal Vasko3d969ff2022-07-29 15:02:08 +02007710 /* turn logging off */
7711 prev_lo = ly_log_options(0);
7712
7713 if (ctx_scnode->nodetype == LYS_LIST) {
7714 /* check for predicates "[key1=...][key2=...]..." */
7715
Michal Vasko004d3152020-06-11 19:59:22 +02007716 /* get key count */
Michal Vasko3d969ff2022-07-29 15:02:08 +02007717 if (ctx_scnode->flags & LYS_KEYLESS) {
7718 rc = LY_ENOT;
7719 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +02007720 }
Michal Vaskod3678892020-05-21 10:06:58 +02007721
Michal Vasko004d3152020-06-11 19:59:22 +02007722 /* learn where the predicates end */
7723 e_idx = *tok_idx;
Michal Vasko3d969ff2022-07-29 15:02:08 +02007724 for (key = lysc_node_child(ctx_scnode); key && (key->flags & LYS_KEY); key = key->next) {
Michal Vasko004d3152020-06-11 19:59:22 +02007725 /* '[' */
7726 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
Michal Vasko3d969ff2022-07-29 15:02:08 +02007727 rc = LY_ENOT;
7728 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +02007729 }
7730 ++e_idx;
7731
Michal Vasko3354d272021-04-06 09:40:06 +02007732 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_NAMETEST)) {
Michal Vasko3d969ff2022-07-29 15:02:08 +02007733 /* not a key */
7734 rc = LY_ENOT;
7735 goto cleanup;
Michal Vasko3354d272021-04-06 09:40:06 +02007736 }
7737
Michal Vasko3d969ff2022-07-29 15:02:08 +02007738 /* check key */
7739 LY_CHECK_GOTO(rc = eval_name_test_try_compile_predicate_key(exp->expr + exp->tok_pos[e_idx],
7740 exp->tok_len[e_idx], ctx_scnode, set, key), cleanup);
7741
7742 ++e_idx;
7743
7744 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_OPER_EQUAL)) {
7745 /* not '=' */
7746 rc = LY_ENOT;
7747 goto cleanup;
7748 }
7749 ++e_idx;
7750
7751 /* value start */
7752 val_start_idx = e_idx;
7753
Michal Vasko004d3152020-06-11 19:59:22 +02007754 /* ']' */
7755 while (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK2)) {
Michal Vaskob8ee3562022-08-02 10:43:17 +02007756 if (!lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_OPER_LOG)) {
7757 /* higher priority than '=' */
7758 rc = LY_ENOT;
7759 goto cleanup;
7760 }
Michal Vasko004d3152020-06-11 19:59:22 +02007761 ++e_idx;
7762 }
Michal Vasko004d3152020-06-11 19:59:22 +02007763
Michal Vasko3d969ff2022-07-29 15:02:08 +02007764 /* try to evaluate the value */
7765 LY_CHECK_GOTO(rc = eval_name_test_try_compile_predicate_append(exp, val_start_idx, e_idx - 1, ctx_scnode,
7766 set, key, &pred, &pred_len), cleanup);
7767
7768 ++e_idx;
Michal Vasko004d3152020-06-11 19:59:22 +02007769 }
Michal Vasko004d3152020-06-11 19:59:22 +02007770 } else {
Michal Vasko3d969ff2022-07-29 15:02:08 +02007771 /* check for predicate "[.=...]" */
7772
Michal Vasko004d3152020-06-11 19:59:22 +02007773 /* learn just where this single predicate ends */
7774 e_idx = *tok_idx;
7775
Michal Vaskod3678892020-05-21 10:06:58 +02007776 /* '[' */
Michal Vasko004d3152020-06-11 19:59:22 +02007777 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
Michal Vasko3d969ff2022-07-29 15:02:08 +02007778 rc = LY_ENOT;
7779 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +02007780 }
7781 ++e_idx;
Michal Vaskod3678892020-05-21 10:06:58 +02007782
Michal Vasko3354d272021-04-06 09:40:06 +02007783 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_DOT)) {
Michal Vasko3d969ff2022-07-29 15:02:08 +02007784 /* not the node value */
7785 rc = LY_ENOT;
7786 goto cleanup;
Michal Vasko3354d272021-04-06 09:40:06 +02007787 }
Michal Vasko3d969ff2022-07-29 15:02:08 +02007788 ++e_idx;
7789
7790 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_OPER_EQUAL)) {
7791 /* not '=' */
7792 rc = LY_ENOT;
7793 goto cleanup;
7794 }
7795 ++e_idx;
7796
7797 /* value start */
7798 val_start_idx = e_idx;
Michal Vasko3354d272021-04-06 09:40:06 +02007799
Michal Vaskod3678892020-05-21 10:06:58 +02007800 /* ']' */
Michal Vasko004d3152020-06-11 19:59:22 +02007801 while (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK2)) {
Michal Vaskob8ee3562022-08-02 10:43:17 +02007802 if (!lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_OPER_LOG)) {
7803 /* higher priority than '=' */
7804 rc = LY_ENOT;
7805 goto cleanup;
7806 }
Michal Vasko004d3152020-06-11 19:59:22 +02007807 ++e_idx;
7808 }
Michal Vasko3d969ff2022-07-29 15:02:08 +02007809
7810 /* try to evaluate the value */
7811 LY_CHECK_GOTO(rc = eval_name_test_try_compile_predicate_append(exp, val_start_idx, e_idx - 1, ctx_scnode, set,
7812 ctx_scnode, &pred, &pred_len), cleanup);
7813
Michal Vasko004d3152020-06-11 19:59:22 +02007814 ++e_idx;
Michal Vaskod3678892020-05-21 10:06:58 +02007815 }
7816
Michal Vasko004d3152020-06-11 19:59:22 +02007817 /* parse the predicate(s) */
Michal Vasko3d969ff2022-07-29 15:02:08 +02007818 LY_CHECK_GOTO(rc = ly_path_parse_predicate(set->ctx, ctx_scnode, pred, pred_len, LY_PATH_PREFIX_OPTIONAL,
7819 LY_PATH_PRED_SIMPLE, &exp2), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02007820
7821 /* compile */
Michal Vasko3d969ff2022-07-29 15:02:08 +02007822 rc = ly_path_compile_predicate(set->ctx, set->cur_node ? set->cur_node->schema : NULL, set->cur_mod, ctx_scnode, exp2,
7823 &pred_idx, LY_VALUE_JSON, NULL, predicates, pred_type);
7824 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02007825
7826 /* success, the predicate must include all the needed information for hash-based search */
7827 *tok_idx = e_idx;
7828
7829cleanup:
7830 ly_log_options(prev_lo);
Michal Vasko3d969ff2022-07-29 15:02:08 +02007831 lyxp_expr_free(set->ctx, exp2);
7832 free(pred);
7833 return rc;
Michal Vaskod3678892020-05-21 10:06:58 +02007834}
7835
7836/**
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007837 * @brief Search for/check the next schema node that could be the only matching schema node meaning the
7838 * data node(s) could be found using a single hash-based search.
7839 *
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007840 * @param[in] ctx libyang context.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007841 * @param[in] node Next context node to check.
7842 * @param[in] name Expected node name.
7843 * @param[in] name_len Length of @p name.
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007844 * @param[in] moveto_mod Expected node module, can be NULL for JSON format with no prefix.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007845 * @param[in] root_type XPath root type.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007846 * @param[in] format Prefix format.
7847 * @param[in,out] found Previously found node, is updated.
7848 * @return LY_SUCCESS on success,
7849 * @return LY_ENOT if the whole check failed and hashes cannot be used.
7850 */
7851static LY_ERR
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007852eval_name_test_with_predicate_get_scnode(const struct ly_ctx *ctx, const struct lyd_node *node, const char *name,
Michal Vaskodd528af2022-08-08 14:35:07 +02007853 uint32_t name_len, const struct lys_module *moveto_mod, enum lyxp_node_type root_type, LY_VALUE_FORMAT format,
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007854 const struct lysc_node **found)
7855{
7856 const struct lysc_node *scnode;
7857 const struct lys_module *mod;
7858 uint32_t idx = 0;
7859
Radek Krejci8df109d2021-04-23 12:19:08 +02007860 assert((format == LY_VALUE_JSON) || moveto_mod);
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007861
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007862continue_search:
Michal Vasko7d1d0912020-10-16 08:38:30 +02007863 scnode = NULL;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007864 if (!node) {
Radek Krejci8df109d2021-04-23 12:19:08 +02007865 if ((format == LY_VALUE_JSON) && !moveto_mod) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007866 /* search all modules for a single match */
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007867 while ((mod = ly_ctx_get_module_iter(ctx, &idx))) {
Michal Vasko35a3b1d2021-07-14 09:34:16 +02007868 if (!mod->implemented) {
7869 continue;
7870 }
7871
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007872 scnode = lys_find_child(NULL, mod, name, name_len, 0, 0);
7873 if (scnode) {
7874 /* we have found a match */
7875 break;
7876 }
7877 }
7878
Michal Vasko7d1d0912020-10-16 08:38:30 +02007879 if (!scnode) {
7880 /* all modules searched */
7881 idx = 0;
7882 }
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007883 } else {
7884 /* search in top-level */
7885 scnode = lys_find_child(NULL, moveto_mod, name, name_len, 0, 0);
7886 }
7887 } else if (!*found || (lysc_data_parent(*found) != node->schema)) {
Radek Krejci8df109d2021-04-23 12:19:08 +02007888 if ((format == LY_VALUE_JSON) && !moveto_mod) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007889 /* we must adjust the module to inherit the one from the context node */
7890 moveto_mod = node->schema->module;
7891 }
7892
7893 /* search in children, do not repeat the same search */
7894 scnode = lys_find_child(node->schema, moveto_mod, name, name_len, 0, 0);
Michal Vasko7d1d0912020-10-16 08:38:30 +02007895 } /* else skip redundant search */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007896
7897 /* additional context check */
7898 if (scnode && (root_type == LYXP_NODE_ROOT_CONFIG) && (scnode->flags & LYS_CONFIG_R)) {
7899 scnode = NULL;
7900 }
7901
7902 if (scnode) {
7903 if (*found) {
7904 /* we found a schema node with the same name but at different level, give up, too complicated
7905 * (more hash-based searches would be required, not supported) */
7906 return LY_ENOT;
7907 } else {
7908 /* remember the found schema node and continue to make sure it can be used */
7909 *found = scnode;
7910 }
7911 }
7912
7913 if (idx) {
7914 /* continue searching all the following models */
7915 goto continue_search;
7916 }
7917
7918 return LY_SUCCESS;
7919}
7920
7921/**
Michal Vasko4ad69e72021-10-26 16:25:55 +02007922 * @brief Generate message when no matching schema nodes were found for a path segment.
7923 *
7924 * @param[in] set XPath set.
7925 * @param[in] scparent Previous schema parent in the context, if only one.
7926 * @param[in] ncname XPath NCName being evaluated.
7927 * @param[in] ncname_len Length of @p ncname.
7928 * @param[in] expr Whole XPath expression.
7929 * @param[in] options XPath options.
7930 */
7931static void
7932eval_name_test_scnode_no_match_msg(struct lyxp_set *set, const struct lyxp_set_scnode *scparent, const char *ncname,
Michal Vaskodd528af2022-08-08 14:35:07 +02007933 uint32_t ncname_len, const char *expr, uint32_t options)
Michal Vasko4ad69e72021-10-26 16:25:55 +02007934{
7935 const char *format;
7936 char *path = NULL, *ppath = NULL;
7937
7938 path = lysc_path(set->cur_scnode, LYSC_PATH_LOG, NULL, 0);
7939 if (scparent) {
7940 /* generate path for the parent */
7941 if (scparent->type == LYXP_NODE_ELEM) {
7942 ppath = lysc_path(scparent->scnode, LYSC_PATH_LOG, NULL, 0);
7943 } else if (scparent->type == LYXP_NODE_ROOT) {
7944 ppath = strdup("<root>");
7945 } else if (scparent->type == LYXP_NODE_ROOT_CONFIG) {
7946 ppath = strdup("<config-root>");
7947 }
7948 }
7949 if (ppath) {
7950 format = "Schema node \"%.*s\" for parent \"%s\" not found; in expr \"%.*s\" with context node \"%s\".";
7951 if (options & LYXP_SCNODE_ERROR) {
7952 LOGERR(set->ctx, LY_EVALID, format, ncname_len, ncname, ppath, (ncname - expr) + ncname_len, expr, path);
7953 } else {
7954 LOGWRN(set->ctx, format, ncname_len, ncname, ppath, (ncname - expr) + ncname_len, expr, path);
7955 }
7956 } else {
7957 format = "Schema node \"%.*s\" not found; in expr \"%.*s\" with context node \"%s\".";
7958 if (options & LYXP_SCNODE_ERROR) {
7959 LOGERR(set->ctx, LY_EVALID, format, ncname_len, ncname, (ncname - expr) + ncname_len, expr, path);
7960 } else {
7961 LOGWRN(set->ctx, format, ncname_len, ncname, (ncname - expr) + ncname_len, expr, path);
7962 }
7963 }
7964 free(path);
7965 free(ppath);
7966}
7967
7968/**
Michal Vaskod3678892020-05-21 10:06:58 +02007969 * @brief Evaluate NameTest and any following Predicates. Logs directly on error.
7970 *
7971 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
7972 * [6] NodeTest ::= NameTest | NodeType '(' ')'
7973 * [7] NameTest ::= '*' | NCName ':' '*' | QName
7974 *
7975 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007976 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko49fec8e2022-05-24 10:28:33 +02007977 * @param[in] axis What axis to search on.
Michal Vaskod3678892020-05-21 10:06:58 +02007978 * @param[in] all_desc Whether to search all the descendants or children only.
aPiecek8b0cc152021-05-31 16:40:31 +02007979 * @param[in,out] set Context and result set.
Michal Vaskod3678892020-05-21 10:06:58 +02007980 * @param[in] options XPath options.
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007981 * @return LY_ERR (LY_EINCOMPLETE on unresolved when, LY_ENOT for not found schema node)
Michal Vaskod3678892020-05-21 10:06:58 +02007982 */
7983static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02007984eval_name_test_with_predicate(const struct lyxp_expr *exp, uint32_t *tok_idx, enum lyxp_axis axis, ly_bool all_desc,
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007985 struct lyxp_set *set, uint32_t options)
Michal Vaskod3678892020-05-21 10:06:58 +02007986{
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007987 LY_ERR rc = LY_SUCCESS, r;
Michal Vasko004d3152020-06-11 19:59:22 +02007988 const char *ncname, *ncname_dict = NULL;
Michal Vasko56c008c2022-07-29 14:57:47 +02007989 uint32_t i, ncname_len;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007990 const struct lys_module *moveto_mod = NULL;
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007991 const struct lysc_node *scnode = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02007992 struct ly_path_predicate *predicates = NULL;
7993 enum ly_path_pred_type pred_type = 0;
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007994 int scnode_skip_pred = 0;
Michal Vaskod3678892020-05-21 10:06:58 +02007995
aPiecek8b0cc152021-05-31 16:40:31 +02007996 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02007997 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007998 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007999
aPiecek8b0cc152021-05-31 16:40:31 +02008000 if (options & LYXP_SKIP_EXPR) {
Michal Vaskod3678892020-05-21 10:06:58 +02008001 goto moveto;
8002 }
8003
Michal Vasko004d3152020-06-11 19:59:22 +02008004 ncname = &exp->expr[exp->tok_pos[*tok_idx - 1]];
8005 ncname_len = exp->tok_len[*tok_idx - 1];
Michal Vaskod3678892020-05-21 10:06:58 +02008006
Michal Vaskoc71c37b2021-01-11 13:40:02 +01008007 if ((ncname[0] == '*') && (ncname_len == 1)) {
8008 /* all nodes will match */
8009 goto moveto;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008010 }
8011
Michal Vaskoc71c37b2021-01-11 13:40:02 +01008012 /* parse (and skip) module name */
8013 rc = moveto_resolve_model(&ncname, &ncname_len, set, NULL, &moveto_mod);
Michal Vaskod3678892020-05-21 10:06:58 +02008014 LY_CHECK_GOTO(rc, cleanup);
8015
Michal Vasko49fec8e2022-05-24 10:28:33 +02008016 if ((ncname[0] == '*') && (ncname_len == 1)) {
8017 /* all nodes from the module will match */
8018 goto moveto;
8019 }
8020
8021 if (((set->format == LY_VALUE_JSON) || moveto_mod) && (axis == LYXP_AXIS_CHILD) && !all_desc &&
8022 (set->type == LYXP_SET_NODE_SET)) {
Michal Vaskod3678892020-05-21 10:06:58 +02008023 /* find the matching schema node in some parent in the context */
Michal Vasko56c008c2022-07-29 14:57:47 +02008024 for (i = 0; i < set->used; ++i) {
Michal Vaskoc71c37b2021-01-11 13:40:02 +01008025 if (eval_name_test_with_predicate_get_scnode(set->ctx, set->val.nodes[i].node, ncname, ncname_len,
8026 moveto_mod, set->root_type, set->format, &scnode)) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008027 /* check failed */
8028 scnode = NULL;
8029 break;
Michal Vaskod3678892020-05-21 10:06:58 +02008030 }
8031 }
8032
Michal Vasko004d3152020-06-11 19:59:22 +02008033 if (scnode && (scnode->nodetype & (LYS_LIST | LYS_LEAFLIST))) {
8034 /* try to create the predicates */
Michal Vasko3d969ff2022-07-29 15:02:08 +02008035 if (eval_name_test_try_compile_predicates(exp, tok_idx, scnode, set, &predicates, &pred_type)) {
Michal Vasko004d3152020-06-11 19:59:22 +02008036 /* hashes cannot be used */
Michal Vaskod3678892020-05-21 10:06:58 +02008037 scnode = NULL;
8038 }
8039 }
8040 }
8041
Michal Vaskoc71c37b2021-01-11 13:40:02 +01008042 if (!scnode) {
8043 /* we are not able to match based on a schema node and not all the modules match ("*"),
Michal Vasko004d3152020-06-11 19:59:22 +02008044 * use dictionary for efficient comparison */
Radek Krejci011e4aa2020-09-04 15:22:31 +02008045 LY_CHECK_GOTO(rc = lydict_insert(set->ctx, ncname, ncname_len, &ncname_dict), cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02008046 }
8047
8048moveto:
8049 /* move to the attribute(s), data node(s), or schema node(s) */
Michal Vasko49fec8e2022-05-24 10:28:33 +02008050 if (axis == LYXP_AXIS_ATTRIBUTE) {
aPiecek8b0cc152021-05-31 16:40:31 +02008051 if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02008052 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vaskod3678892020-05-21 10:06:58 +02008053 } else {
8054 if (all_desc) {
Michal Vaskocdad7122020-11-09 21:04:44 +01008055 rc = moveto_attr_alldesc(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008056 } else {
aPiecek8b0cc152021-05-31 16:40:31 +02008057 rc = moveto_attr(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008058 }
8059 LY_CHECK_GOTO(rc, cleanup);
8060 }
8061 } else {
aPiecek8b0cc152021-05-31 16:40:31 +02008062 if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008063 const struct lyxp_set_scnode *scparent = NULL;
Michal Vasko56c008c2022-07-29 14:57:47 +02008064 ly_bool found = 0;
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008065
8066 /* remember parent if there is only one, to print in the warning */
8067 for (i = 0; i < set->used; ++i) {
8068 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
8069 if (!scparent) {
8070 /* remember the context node */
8071 scparent = &set->val.scnodes[i];
8072 } else {
8073 /* several context nodes, no reasonable error possible */
8074 scparent = NULL;
8075 break;
8076 }
8077 }
8078 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02008079
Michal Vasko49fec8e2022-05-24 10:28:33 +02008080 if (all_desc && (axis == LYXP_AXIS_CHILD)) {
8081 /* efficient evaluation that does not add all the descendants into the set */
8082 rc = moveto_scnode_alldesc_child(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008083 } else {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008084 if (all_desc) {
8085 /* "//" == "/descendant-or-self::node()/" */
8086 rc = xpath_pi_node(set, LYXP_AXIS_DESCENDANT_OR_SELF, options);
8087 LY_CHECK_GOTO(rc, cleanup);
8088 }
8089 rc = moveto_scnode(set, moveto_mod, ncname_dict, axis, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008090 }
8091 LY_CHECK_GOTO(rc, cleanup);
8092
Michal Vasko56c008c2022-07-29 14:57:47 +02008093 i = set->used;
8094 do {
8095 --i;
Michal Vasko1a09b212021-05-06 13:00:10 +02008096 if (set->val.scnodes[i].in_ctx > LYXP_SET_SCNODE_ATOM_NODE) {
Michal Vasko56c008c2022-07-29 14:57:47 +02008097 found = 1;
Michal Vaskod3678892020-05-21 10:06:58 +02008098 break;
8099 }
Michal Vasko56c008c2022-07-29 14:57:47 +02008100 } while (i);
8101 if (!found) {
Michal Vasko4ad69e72021-10-26 16:25:55 +02008102 /* generate message */
8103 eval_name_test_scnode_no_match_msg(set, scparent, ncname, ncname_len, exp->expr, options);
8104
8105 if (options & LYXP_SCNODE_ERROR) {
8106 /* error */
8107 rc = LY_EVALID;
8108 goto cleanup;
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008109 }
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008110
8111 /* skip the predicates and the rest of this path to not generate invalid warnings */
8112 rc = LY_ENOT;
8113 scnode_skip_pred = 1;
Michal Vaskod3678892020-05-21 10:06:58 +02008114 }
8115 } else {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008116 if (all_desc && (axis == LYXP_AXIS_CHILD)) {
8117 /* efficient evaluation */
8118 rc = moveto_node_alldesc_child(set, moveto_mod, ncname_dict, options);
8119 } else if (scnode && (axis == LYXP_AXIS_CHILD)) {
8120 /* we can find the child nodes using hashes */
8121 rc = moveto_node_hash_child(set, scnode, predicates, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008122 } else {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008123 if (all_desc) {
8124 /* "//" == "/descendant-or-self::node()/" */
8125 rc = xpath_pi_node(set, LYXP_AXIS_DESCENDANT_OR_SELF, options);
8126 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02008127 }
Michal Vasko49fec8e2022-05-24 10:28:33 +02008128 rc = moveto_node(set, moveto_mod, ncname_dict, axis, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008129 }
8130 LY_CHECK_GOTO(rc, cleanup);
8131 }
8132 }
8133
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008134 if (scnode_skip_pred) {
8135 /* skip predicates */
8136 options |= LYXP_SKIP_EXPR;
8137 }
8138
Michal Vaskod3678892020-05-21 10:06:58 +02008139 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02008140 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008141 r = eval_predicate(exp, tok_idx, set, options, axis);
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008142 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02008143 }
8144
8145cleanup:
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008146 if (scnode_skip_pred) {
8147 /* restore options */
8148 options &= ~LYXP_SKIP_EXPR;
8149 }
aPiecek8b0cc152021-05-31 16:40:31 +02008150 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko004d3152020-06-11 19:59:22 +02008151 lydict_remove(set->ctx, ncname_dict);
Michal Vaskof7e16e22020-10-21 09:24:39 +02008152 ly_path_predicates_free(set->ctx, pred_type, predicates);
Michal Vaskodb51a8d2020-05-27 15:22:29 +02008153 }
Michal Vaskod3678892020-05-21 10:06:58 +02008154 return rc;
8155}
8156
8157/**
8158 * @brief Evaluate NodeType and any following Predicates. Logs directly on error.
8159 *
8160 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
8161 * [6] NodeTest ::= NameTest | NodeType '(' ')'
8162 * [8] NodeType ::= 'text' | 'node'
8163 *
8164 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008165 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko49fec8e2022-05-24 10:28:33 +02008166 * @param[in] axis Axis to search on.
8167 * @param[in] all_desc Whether to search all the descendants or axis only.
aPiecek8b0cc152021-05-31 16:40:31 +02008168 * @param[in,out] set Context and result set.
Michal Vaskod3678892020-05-21 10:06:58 +02008169 * @param[in] options XPath options.
8170 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8171 */
8172static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008173eval_node_type_with_predicate(const struct lyxp_expr *exp, uint32_t *tok_idx, enum lyxp_axis axis, ly_bool all_desc,
Radek Krejci1deb5be2020-08-26 16:43:36 +02008174 struct lyxp_set *set, uint32_t options)
Michal Vaskod3678892020-05-21 10:06:58 +02008175{
8176 LY_ERR rc;
8177
Michal Vaskod3678892020-05-21 10:06:58 +02008178 (void)all_desc;
8179
aPiecek8b0cc152021-05-31 16:40:31 +02008180 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko004d3152020-06-11 19:59:22 +02008181 assert(exp->tok_len[*tok_idx] == 4);
Michal Vasko49fec8e2022-05-24 10:28:33 +02008182 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "node", 4)) {
8183 rc = xpath_pi_node(set, axis, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008184 } else {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008185 assert(!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "text", 4));
8186 rc = xpath_pi_text(set, axis, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008187 }
Michal Vasko49fec8e2022-05-24 10:28:33 +02008188 LY_CHECK_RET(rc);
Michal Vaskod3678892020-05-21 10:06:58 +02008189 }
aPiecek8b0cc152021-05-31 16:40:31 +02008190 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008191 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008192 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02008193
8194 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02008195 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
aPiecek8b0cc152021-05-31 16:40:31 +02008196 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008197 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008198 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02008199
8200 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02008201 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
aPiecek8b0cc152021-05-31 16:40:31 +02008202 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008203 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008204 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02008205
8206 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02008207 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008208 rc = eval_predicate(exp, tok_idx, set, options, axis);
Michal Vaskod3678892020-05-21 10:06:58 +02008209 LY_CHECK_RET(rc);
8210 }
8211
8212 return LY_SUCCESS;
8213}
8214
8215/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02008216 * @brief Evaluate RelativeLocationPath. Logs directly on error.
8217 *
8218 * [4] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
8219 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
Michal Vaskod3678892020-05-21 10:06:58 +02008220 * [6] NodeTest ::= NameTest | NodeType '(' ')'
Michal Vasko03ff5a72019-09-11 13:49:33 +02008221 *
8222 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008223 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008224 * @param[in] all_desc Whether to search all the descendants or children only.
aPiecek8b0cc152021-05-31 16:40:31 +02008225 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008226 * @param[in] options XPath options.
8227 * @return LY_ERR (YL_EINCOMPLETE on unresolved when)
8228 */
8229static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008230eval_relative_location_path(const struct lyxp_expr *exp, uint32_t *tok_idx, ly_bool all_desc, struct lyxp_set *set,
Michal Vasko40308e72020-10-20 16:38:40 +02008231 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008232{
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008233 LY_ERR rc = LY_SUCCESS;
Michal Vasko49fec8e2022-05-24 10:28:33 +02008234 enum lyxp_axis axis;
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008235 int scnode_skip_path = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008236
8237 goto step;
8238 do {
8239 /* evaluate '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02008240 if (exp->tok_len[*tok_idx] == 1) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008241 all_desc = 0;
8242 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02008243 assert(exp->tok_len[*tok_idx] == 2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008244 all_desc = 1;
8245 }
aPiecek8b0cc152021-05-31 16:40:31 +02008246 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008247 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008248 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008249
8250step:
Michal Vasko49fec8e2022-05-24 10:28:33 +02008251 /* AxisSpecifier */
8252 if (exp->tokens[*tok_idx] == LYXP_TOKEN_AXISNAME) {
8253 axis = str2axis(exp->expr + exp->tok_pos[*tok_idx], exp->tok_len[*tok_idx]);
Michal Vaskod3678892020-05-21 10:06:58 +02008254
aPiecek8b0cc152021-05-31 16:40:31 +02008255 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008256 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
8257 ++(*tok_idx);
8258
8259 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_DCOLON);
8260 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
8261 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
8262 ++(*tok_idx);
8263 } else if (exp->tokens[*tok_idx] == LYXP_TOKEN_AT) {
8264 axis = LYXP_AXIS_ATTRIBUTE;
8265
8266 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
8267 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008268 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02008269 } else {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008270 /* default */
8271 axis = LYXP_AXIS_CHILD;
Michal Vaskod3678892020-05-21 10:06:58 +02008272 }
8273
Michal Vasko49fec8e2022-05-24 10:28:33 +02008274 /* NodeTest Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02008275 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008276 case LYXP_TOKEN_DOT:
8277 /* evaluate '.' */
Michal Vasko49fec8e2022-05-24 10:28:33 +02008278 if (!(options & LYXP_SKIP_EXPR)) {
8279 if (((options & LYXP_SCNODE_ALL) && (set->type != LYXP_SET_SCNODE_SET)) ||
8280 (!(options & LYXP_SCNODE_ALL) && (set->type != LYXP_SET_NODE_SET))) {
8281 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
8282 rc = LY_EVALID;
8283 goto cleanup;
8284 }
8285
8286 if (all_desc) {
8287 rc = xpath_pi_node(set, LYXP_AXIS_DESCENDANT_OR_SELF, options);
8288 LY_CHECK_GOTO(rc, cleanup);
8289 }
8290 rc = xpath_pi_node(set, LYXP_AXIS_SELF, options);
8291 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008292 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02008293 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008294 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008295 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008296 break;
8297
8298 case LYXP_TOKEN_DDOT:
8299 /* evaluate '..' */
Michal Vasko49fec8e2022-05-24 10:28:33 +02008300 if (!(options & LYXP_SKIP_EXPR)) {
8301 if (((options & LYXP_SCNODE_ALL) && (set->type != LYXP_SET_SCNODE_SET)) ||
8302 (!(options & LYXP_SCNODE_ALL) && (set->type != LYXP_SET_NODE_SET))) {
8303 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
8304 rc = LY_EVALID;
8305 goto cleanup;
8306 }
8307
8308 if (all_desc) {
8309 rc = xpath_pi_node(set, LYXP_AXIS_DESCENDANT_OR_SELF, options);
8310 LY_CHECK_GOTO(rc, cleanup);
8311 }
8312 rc = xpath_pi_node(set, LYXP_AXIS_PARENT, options);
8313 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008314 }
aPiecek8b0cc152021-05-31 16:40:31 +02008315 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008316 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008317 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008318 break;
8319
Michal Vasko03ff5a72019-09-11 13:49:33 +02008320 case LYXP_TOKEN_NAMETEST:
Michal Vaskod3678892020-05-21 10:06:58 +02008321 /* evaluate NameTest Predicate* */
Michal Vasko49fec8e2022-05-24 10:28:33 +02008322 rc = eval_name_test_with_predicate(exp, tok_idx, axis, all_desc, set, options);
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008323 if (rc == LY_ENOT) {
8324 assert(options & LYXP_SCNODE_ALL);
8325 /* skip the rest of this path */
8326 rc = LY_SUCCESS;
8327 scnode_skip_path = 1;
8328 options |= LYXP_SKIP_EXPR;
8329 }
8330 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02008331 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008332
Michal Vaskod3678892020-05-21 10:06:58 +02008333 case LYXP_TOKEN_NODETYPE:
8334 /* evaluate NodeType Predicate* */
Michal Vasko49fec8e2022-05-24 10:28:33 +02008335 rc = eval_node_type_with_predicate(exp, tok_idx, axis, all_desc, set, options);
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008336 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008337 break;
8338
8339 default:
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008340 LOGINT(set->ctx);
8341 rc = LY_EINT;
8342 goto cleanup;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008343 }
Michal Vasko004d3152020-06-11 19:59:22 +02008344 } while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008345
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008346cleanup:
8347 if (scnode_skip_path) {
8348 options &= ~LYXP_SKIP_EXPR;
8349 }
8350 return rc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008351}
8352
8353/**
8354 * @brief Evaluate AbsoluteLocationPath. Logs directly on error.
8355 *
8356 * [3] AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
8357 *
8358 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008359 * @param[in] tok_idx Position in the expression @p exp.
aPiecek8b0cc152021-05-31 16:40:31 +02008360 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008361 * @param[in] options XPath options.
8362 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8363 */
8364static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008365eval_absolute_location_path(const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008366{
Radek Krejci857189e2020-09-01 13:26:36 +02008367 ly_bool all_desc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008368
aPiecek8b0cc152021-05-31 16:40:31 +02008369 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008370 /* no matter what tokens follow, we need to be at the root */
Michal Vaskob0099a92020-08-31 14:55:23 +02008371 LY_CHECK_RET(moveto_root(set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008372 }
8373
8374 /* '/' RelativeLocationPath? */
Michal Vasko004d3152020-06-11 19:59:22 +02008375 if (exp->tok_len[*tok_idx] == 1) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008376 /* evaluate '/' - deferred */
8377 all_desc = 0;
aPiecek8b0cc152021-05-31 16:40:31 +02008378 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008379 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008380 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008381
Michal Vasko004d3152020-06-11 19:59:22 +02008382 if (lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008383 return LY_SUCCESS;
8384 }
Michal Vasko004d3152020-06-11 19:59:22 +02008385 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008386 case LYXP_TOKEN_DOT:
8387 case LYXP_TOKEN_DDOT:
Michal Vasko49fec8e2022-05-24 10:28:33 +02008388 case LYXP_TOKEN_AXISNAME:
Michal Vasko03ff5a72019-09-11 13:49:33 +02008389 case LYXP_TOKEN_AT:
8390 case LYXP_TOKEN_NAMETEST:
8391 case LYXP_TOKEN_NODETYPE:
Michal Vaskob0099a92020-08-31 14:55:23 +02008392 LY_CHECK_RET(eval_relative_location_path(exp, tok_idx, all_desc, set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008393 break;
8394 default:
8395 break;
8396 }
8397
Michal Vasko03ff5a72019-09-11 13:49:33 +02008398 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02008399 /* '//' RelativeLocationPath */
Michal Vasko03ff5a72019-09-11 13:49:33 +02008400 /* evaluate '//' - deferred so as not to waste memory by remembering all the nodes */
8401 all_desc = 1;
aPiecek8b0cc152021-05-31 16:40:31 +02008402 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008403 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008404 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008405
Michal Vaskob0099a92020-08-31 14:55:23 +02008406 LY_CHECK_RET(eval_relative_location_path(exp, tok_idx, all_desc, set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008407 }
8408
8409 return LY_SUCCESS;
8410}
8411
8412/**
8413 * @brief Evaluate FunctionCall. Logs directly on error.
8414 *
Michal Vaskod3678892020-05-21 10:06:58 +02008415 * [11] FunctionCall ::= FunctionName '(' ( Expr ( ',' Expr )* )? ')'
Michal Vasko03ff5a72019-09-11 13:49:33 +02008416 *
8417 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008418 * @param[in] tok_idx Position in the expression @p exp.
aPiecek8b0cc152021-05-31 16:40:31 +02008419 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008420 * @param[in] options XPath options.
8421 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8422 */
8423static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008424eval_function_call(const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008425{
8426 LY_ERR rc;
Michal Vasko69730152020-10-09 16:30:07 +02008427
Michal Vaskodd528af2022-08-08 14:35:07 +02008428 LY_ERR (*xpath_func)(struct lyxp_set **, uint32_t, struct lyxp_set *, uint32_t) = NULL;
8429 uint32_t arg_count = 0, i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008430 struct lyxp_set **args = NULL, **args_aux;
8431
aPiecek8b0cc152021-05-31 16:40:31 +02008432 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008433 /* FunctionName */
Michal Vasko004d3152020-06-11 19:59:22 +02008434 switch (exp->tok_len[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008435 case 3:
Michal Vasko004d3152020-06-11 19:59:22 +02008436 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "not", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008437 xpath_func = &xpath_not;
Michal Vasko004d3152020-06-11 19:59:22 +02008438 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "sum", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008439 xpath_func = &xpath_sum;
8440 }
8441 break;
8442 case 4:
Michal Vasko004d3152020-06-11 19:59:22 +02008443 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "lang", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008444 xpath_func = &xpath_lang;
Michal Vasko004d3152020-06-11 19:59:22 +02008445 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "last", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008446 xpath_func = &xpath_last;
Michal Vasko004d3152020-06-11 19:59:22 +02008447 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "name", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008448 xpath_func = &xpath_name;
Michal Vasko004d3152020-06-11 19:59:22 +02008449 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "true", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008450 xpath_func = &xpath_true;
8451 }
8452 break;
8453 case 5:
Michal Vasko004d3152020-06-11 19:59:22 +02008454 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "count", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008455 xpath_func = &xpath_count;
Michal Vasko004d3152020-06-11 19:59:22 +02008456 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "false", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008457 xpath_func = &xpath_false;
Michal Vasko004d3152020-06-11 19:59:22 +02008458 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "floor", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008459 xpath_func = &xpath_floor;
Michal Vasko004d3152020-06-11 19:59:22 +02008460 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "round", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008461 xpath_func = &xpath_round;
Michal Vasko004d3152020-06-11 19:59:22 +02008462 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "deref", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008463 xpath_func = &xpath_deref;
8464 }
8465 break;
8466 case 6:
Michal Vasko004d3152020-06-11 19:59:22 +02008467 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "concat", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008468 xpath_func = &xpath_concat;
Michal Vasko004d3152020-06-11 19:59:22 +02008469 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "number", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008470 xpath_func = &xpath_number;
Michal Vasko004d3152020-06-11 19:59:22 +02008471 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008472 xpath_func = &xpath_string;
8473 }
8474 break;
8475 case 7:
Michal Vasko004d3152020-06-11 19:59:22 +02008476 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "boolean", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008477 xpath_func = &xpath_boolean;
Michal Vasko004d3152020-06-11 19:59:22 +02008478 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "ceiling", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008479 xpath_func = &xpath_ceiling;
Michal Vasko004d3152020-06-11 19:59:22 +02008480 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "current", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008481 xpath_func = &xpath_current;
8482 }
8483 break;
8484 case 8:
Michal Vasko004d3152020-06-11 19:59:22 +02008485 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "contains", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008486 xpath_func = &xpath_contains;
Michal Vasko004d3152020-06-11 19:59:22 +02008487 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "position", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008488 xpath_func = &xpath_position;
Michal Vasko004d3152020-06-11 19:59:22 +02008489 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "re-match", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008490 xpath_func = &xpath_re_match;
8491 }
8492 break;
8493 case 9:
Michal Vasko004d3152020-06-11 19:59:22 +02008494 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008495 xpath_func = &xpath_substring;
Michal Vasko004d3152020-06-11 19:59:22 +02008496 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "translate", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008497 xpath_func = &xpath_translate;
8498 }
8499 break;
8500 case 10:
Michal Vasko004d3152020-06-11 19:59:22 +02008501 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "local-name", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008502 xpath_func = &xpath_local_name;
Michal Vasko004d3152020-06-11 19:59:22 +02008503 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "enum-value", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008504 xpath_func = &xpath_enum_value;
Michal Vasko004d3152020-06-11 19:59:22 +02008505 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "bit-is-set", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008506 xpath_func = &xpath_bit_is_set;
8507 }
8508 break;
8509 case 11:
Michal Vasko004d3152020-06-11 19:59:22 +02008510 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "starts-with", 11)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008511 xpath_func = &xpath_starts_with;
8512 }
8513 break;
8514 case 12:
Michal Vasko004d3152020-06-11 19:59:22 +02008515 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from", 12)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008516 xpath_func = &xpath_derived_from;
8517 }
8518 break;
8519 case 13:
Michal Vasko004d3152020-06-11 19:59:22 +02008520 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "namespace-uri", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008521 xpath_func = &xpath_namespace_uri;
Michal Vasko004d3152020-06-11 19:59:22 +02008522 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string-length", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008523 xpath_func = &xpath_string_length;
8524 }
8525 break;
8526 case 15:
Michal Vasko004d3152020-06-11 19:59:22 +02008527 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "normalize-space", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008528 xpath_func = &xpath_normalize_space;
Michal Vasko004d3152020-06-11 19:59:22 +02008529 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-after", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008530 xpath_func = &xpath_substring_after;
8531 }
8532 break;
8533 case 16:
Michal Vasko004d3152020-06-11 19:59:22 +02008534 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-before", 16)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008535 xpath_func = &xpath_substring_before;
8536 }
8537 break;
8538 case 20:
Michal Vasko004d3152020-06-11 19:59:22 +02008539 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from-or-self", 20)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008540 xpath_func = &xpath_derived_from_or_self;
8541 }
8542 break;
8543 }
8544
8545 if (!xpath_func) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01008546 LOGVAL(set->ctx, LY_VCODE_XP_INFUNC, exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008547 return LY_EVALID;
8548 }
8549 }
8550
aPiecek8b0cc152021-05-31 16:40:31 +02008551 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008552 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008553 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008554
8555 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02008556 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
aPiecek8b0cc152021-05-31 16:40:31 +02008557 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008558 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008559 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008560
8561 /* ( Expr ( ',' Expr )* )? */
Michal Vasko004d3152020-06-11 19:59:22 +02008562 if (exp->tokens[*tok_idx] != LYXP_TOKEN_PAR2) {
aPiecek8b0cc152021-05-31 16:40:31 +02008563 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008564 args = malloc(sizeof *args);
8565 LY_CHECK_ERR_GOTO(!args, LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
8566 arg_count = 1;
8567 args[0] = set_copy(set);
8568 if (!args[0]) {
8569 rc = LY_EMEM;
8570 goto cleanup;
8571 }
8572
Michal Vasko004d3152020-06-11 19:59:22 +02008573 rc = eval_expr_select(exp, tok_idx, 0, args[0], options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008574 LY_CHECK_GOTO(rc, cleanup);
8575 } else {
aPiecek8b0cc152021-05-31 16:40:31 +02008576 rc = eval_expr_select(exp, tok_idx, 0, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008577 LY_CHECK_GOTO(rc, cleanup);
8578 }
8579 }
Michal Vasko004d3152020-06-11 19:59:22 +02008580 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_COMMA)) {
aPiecek8b0cc152021-05-31 16:40:31 +02008581 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008582 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008583 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008584
aPiecek8b0cc152021-05-31 16:40:31 +02008585 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008586 ++arg_count;
8587 args_aux = realloc(args, arg_count * sizeof *args);
8588 LY_CHECK_ERR_GOTO(!args_aux, arg_count--; LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
8589 args = args_aux;
8590 args[arg_count - 1] = set_copy(set);
8591 if (!args[arg_count - 1]) {
8592 rc = LY_EMEM;
8593 goto cleanup;
8594 }
8595
Michal Vasko004d3152020-06-11 19:59:22 +02008596 rc = eval_expr_select(exp, tok_idx, 0, args[arg_count - 1], options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008597 LY_CHECK_GOTO(rc, cleanup);
8598 } else {
aPiecek8b0cc152021-05-31 16:40:31 +02008599 rc = eval_expr_select(exp, tok_idx, 0, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008600 LY_CHECK_GOTO(rc, cleanup);
8601 }
8602 }
8603
8604 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02008605 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
aPiecek8b0cc152021-05-31 16:40:31 +02008606 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008607 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008608 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008609
aPiecek8b0cc152021-05-31 16:40:31 +02008610 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008611 /* evaluate function */
8612 rc = xpath_func(args, arg_count, set, options);
8613
8614 if (options & LYXP_SCNODE_ALL) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008615 /* merge all nodes from arg evaluations */
8616 for (i = 0; i < arg_count; ++i) {
Michal Vasko1a09b212021-05-06 13:00:10 +02008617 set_scnode_clear_ctx(args[i], LYXP_SET_SCNODE_ATOM_NODE);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008618 lyxp_set_scnode_merge(set, args[i]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008619 }
8620 }
8621 } else {
8622 rc = LY_SUCCESS;
8623 }
8624
8625cleanup:
8626 for (i = 0; i < arg_count; ++i) {
8627 lyxp_set_free(args[i]);
8628 }
8629 free(args);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008630 return rc;
8631}
8632
8633/**
8634 * @brief Evaluate Number. Logs directly on error.
8635 *
8636 * @param[in] ctx Context for errors.
8637 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008638 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008639 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
8640 * @return LY_ERR
8641 */
8642static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008643eval_number(struct ly_ctx *ctx, const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008644{
8645 long double num;
8646 char *endptr;
8647
8648 if (set) {
8649 errno = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02008650 num = strtold(&exp->expr[exp->tok_pos[*tok_idx]], &endptr);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008651 if (errno) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01008652 LOGVAL(ctx, LY_VCODE_XP_INTOK, "Unknown", &exp->expr[exp->tok_pos[*tok_idx]]);
8653 LOGVAL(ctx, LYVE_XPATH, "Failed to convert \"%.*s\" into a long double (%s).",
Michal Vasko69730152020-10-09 16:30:07 +02008654 exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]], strerror(errno));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008655 return LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +02008656 } else if (endptr - &exp->expr[exp->tok_pos[*tok_idx]] != exp->tok_len[*tok_idx]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01008657 LOGVAL(ctx, LY_VCODE_XP_INTOK, "Unknown", &exp->expr[exp->tok_pos[*tok_idx]]);
8658 LOGVAL(ctx, LYVE_XPATH, "Failed to convert \"%.*s\" into a long double.",
Michal Vasko69730152020-10-09 16:30:07 +02008659 exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008660 return LY_EVALID;
8661 }
8662
8663 set_fill_number(set, num);
8664 }
8665
8666 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008667 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008668 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008669 return LY_SUCCESS;
8670}
8671
aPiecekdf23eee2021-10-07 12:21:50 +02008672LY_ERR
8673lyxp_vars_find(struct lyxp_var *vars, const char *name, size_t name_len, struct lyxp_var **var)
8674{
8675 LY_ERR ret = LY_ENOTFOUND;
8676 LY_ARRAY_COUNT_TYPE u;
8677
8678 assert(vars && name);
8679
8680 name_len = name_len ? name_len : strlen(name);
8681
8682 LY_ARRAY_FOR(vars, u) {
8683 if (!strncmp(vars[u].name, name, name_len)) {
8684 ret = LY_SUCCESS;
8685 break;
8686 }
8687 }
8688
8689 if (var && !ret) {
8690 *var = &vars[u];
8691 }
8692
8693 return ret;
8694}
8695
Michal Vasko03ff5a72019-09-11 13:49:33 +02008696/**
aPiecekfba75362021-10-07 12:39:48 +02008697 * @brief Evaluate VariableReference.
8698 *
8699 * @param[in] exp Parsed XPath expression.
8700 * @param[in] tok_idx Position in the expression @p exp.
8701 * @param[in] vars [Sized array](@ref sizedarrays) of XPath variables.
8702 * @param[in,out] set Context and result set.
8703 * @param[in] options XPath options.
8704 * @return LY_ERR value.
8705 */
8706static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008707eval_variable_reference(const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set, uint32_t options)
aPiecekfba75362021-10-07 12:39:48 +02008708{
8709 LY_ERR ret;
8710 const char *name;
8711 struct lyxp_var *var;
8712 const struct lyxp_var *vars;
8713 struct lyxp_expr *tokens = NULL;
Michal Vaskodd528af2022-08-08 14:35:07 +02008714 uint32_t token_index, name_len;
aPiecekfba75362021-10-07 12:39:48 +02008715
8716 vars = set->vars;
8717
Michal Vasko49fec8e2022-05-24 10:28:33 +02008718 /* find out the name and value of the variable */
aPiecekfba75362021-10-07 12:39:48 +02008719 name = &exp->expr[exp->tok_pos[*tok_idx]];
Michal Vaskoe68b5402022-07-29 14:58:15 +02008720 name_len = exp->tok_len[*tok_idx];
8721 ret = lyxp_vars_find((struct lyxp_var *)vars, name, name_len, &var);
8722 LY_CHECK_ERR_RET(ret, LOGERR(set->ctx, ret, "XPath variable \"%.*s\" not defined.", (int)name_len, name), ret);
aPiecekfba75362021-10-07 12:39:48 +02008723
Michal Vasko49fec8e2022-05-24 10:28:33 +02008724 /* parse value */
aPiecekfba75362021-10-07 12:39:48 +02008725 ret = lyxp_expr_parse(set->ctx, var->value, 0, 1, &tokens);
8726 LY_CHECK_GOTO(ret, cleanup);
8727
Michal Vasko49fec8e2022-05-24 10:28:33 +02008728 /* evaluate value */
aPiecekfba75362021-10-07 12:39:48 +02008729 token_index = 0;
8730 ret = eval_expr_select(tokens, &token_index, 0, set, options);
8731 LY_CHECK_GOTO(ret, cleanup);
8732
8733cleanup:
8734 lyxp_expr_free(set->ctx, tokens);
8735
8736 return ret;
8737}
8738
8739/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02008740 * @brief Evaluate PathExpr. Logs directly on error.
8741 *
Michal Vaskod3678892020-05-21 10:06:58 +02008742 * [12] PathExpr ::= LocationPath | PrimaryExpr Predicate*
Michal Vasko03ff5a72019-09-11 13:49:33 +02008743 * | PrimaryExpr Predicate* '/' RelativeLocationPath
8744 * | PrimaryExpr Predicate* '//' RelativeLocationPath
8745 * [2] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
aPiecekfba75362021-10-07 12:39:48 +02008746 * [10] PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
Michal Vasko03ff5a72019-09-11 13:49:33 +02008747 *
8748 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008749 * @param[in] tok_idx Position in the expression @p exp.
aPiecek8b0cc152021-05-31 16:40:31 +02008750 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008751 * @param[in] options XPath options.
8752 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8753 */
8754static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008755eval_path_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008756{
Michal Vasko49fec8e2022-05-24 10:28:33 +02008757 ly_bool all_desc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008758 LY_ERR rc;
8759
Michal Vasko004d3152020-06-11 19:59:22 +02008760 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008761 case LYXP_TOKEN_PAR1:
8762 /* '(' Expr ')' */
8763
8764 /* '(' */
aPiecek8b0cc152021-05-31 16:40:31 +02008765 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008766 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008767 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008768
8769 /* Expr */
Michal Vasko004d3152020-06-11 19:59:22 +02008770 rc = eval_expr_select(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008771 LY_CHECK_RET(rc);
8772
8773 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02008774 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
aPiecek8b0cc152021-05-31 16:40:31 +02008775 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008776 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008777 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008778
Michal Vasko03ff5a72019-09-11 13:49:33 +02008779 goto predicate;
8780
8781 case LYXP_TOKEN_DOT:
8782 case LYXP_TOKEN_DDOT:
Michal Vasko49fec8e2022-05-24 10:28:33 +02008783 case LYXP_TOKEN_AXISNAME:
Michal Vasko03ff5a72019-09-11 13:49:33 +02008784 case LYXP_TOKEN_AT:
8785 case LYXP_TOKEN_NAMETEST:
8786 case LYXP_TOKEN_NODETYPE:
8787 /* RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02008788 rc = eval_relative_location_path(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008789 LY_CHECK_RET(rc);
8790 break;
8791
aPiecekfba75362021-10-07 12:39:48 +02008792 case LYXP_TOKEN_VARREF:
8793 /* VariableReference */
8794 rc = eval_variable_reference(exp, tok_idx, set, options);
8795 LY_CHECK_RET(rc);
8796 ++(*tok_idx);
8797
aPiecekfba75362021-10-07 12:39:48 +02008798 goto predicate;
8799
Michal Vasko03ff5a72019-09-11 13:49:33 +02008800 case LYXP_TOKEN_FUNCNAME:
8801 /* FunctionCall */
aPiecek8b0cc152021-05-31 16:40:31 +02008802 rc = eval_function_call(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008803 LY_CHECK_RET(rc);
8804
Michal Vasko03ff5a72019-09-11 13:49:33 +02008805 goto predicate;
8806
Michal Vasko3e48bf32020-06-01 08:39:07 +02008807 case LYXP_TOKEN_OPER_PATH:
8808 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +02008809 /* AbsoluteLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02008810 rc = eval_absolute_location_path(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008811 LY_CHECK_RET(rc);
8812 break;
8813
8814 case LYXP_TOKEN_LITERAL:
8815 /* Literal */
aPiecek8b0cc152021-05-31 16:40:31 +02008816 if ((options & LYXP_SKIP_EXPR) || (options & LYXP_SCNODE_ALL)) {
8817 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02008818 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008819 }
Michal Vasko004d3152020-06-11 19:59:22 +02008820 eval_literal(exp, tok_idx, NULL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008821 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02008822 eval_literal(exp, tok_idx, set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008823 }
8824
Michal Vasko03ff5a72019-09-11 13:49:33 +02008825 goto predicate;
8826
8827 case LYXP_TOKEN_NUMBER:
8828 /* Number */
aPiecek8b0cc152021-05-31 16:40:31 +02008829 if ((options & LYXP_SKIP_EXPR) || (options & LYXP_SCNODE_ALL)) {
8830 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02008831 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008832 }
Michal Vasko004d3152020-06-11 19:59:22 +02008833 rc = eval_number(NULL, exp, tok_idx, NULL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008834 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02008835 rc = eval_number(set->ctx, exp, tok_idx, set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008836 }
8837 LY_CHECK_RET(rc);
8838
Michal Vasko03ff5a72019-09-11 13:49:33 +02008839 goto predicate;
8840
8841 default:
Michal Vasko49fec8e2022-05-24 10:28:33 +02008842 LOGVAL(set->ctx, LY_VCODE_XP_INTOK, lyxp_token2str(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008843 return LY_EVALID;
8844 }
8845
8846 return LY_SUCCESS;
8847
8848predicate:
8849 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02008850 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008851 rc = eval_predicate(exp, tok_idx, set, options, LYXP_AXIS_CHILD);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008852 LY_CHECK_RET(rc);
8853 }
8854
8855 /* ('/' or '//') RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02008856 if (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008857
8858 /* evaluate '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02008859 if (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008860 all_desc = 0;
8861 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008862 all_desc = 1;
8863 }
8864
aPiecek8b0cc152021-05-31 16:40:31 +02008865 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008866 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008867 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008868
Michal Vasko004d3152020-06-11 19:59:22 +02008869 rc = eval_relative_location_path(exp, tok_idx, all_desc, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008870 LY_CHECK_RET(rc);
8871 }
8872
8873 return LY_SUCCESS;
8874}
8875
8876/**
8877 * @brief Evaluate UnionExpr. Logs directly on error.
8878 *
Michal Vaskod3678892020-05-21 10:06:58 +02008879 * [20] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008880 *
8881 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008882 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008883 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02008884 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008885 * @param[in] options XPath options.
8886 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8887 */
8888static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008889eval_union_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008890{
8891 LY_ERR rc = LY_SUCCESS;
8892 struct lyxp_set orig_set, set2;
Michal Vaskodd528af2022-08-08 14:35:07 +02008893 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008894
8895 assert(repeat);
8896
8897 set_init(&orig_set, set);
8898 set_init(&set2, set);
8899
8900 set_fill_set(&orig_set, set);
8901
Michal Vasko004d3152020-06-11 19:59:22 +02008902 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008903 LY_CHECK_GOTO(rc, cleanup);
8904
8905 /* ('|' PathExpr)* */
8906 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008907 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_UNI);
aPiecek8b0cc152021-05-31 16:40:31 +02008908 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008909 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008910 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008911
aPiecek8b0cc152021-05-31 16:40:31 +02008912 if (options & LYXP_SKIP_EXPR) {
8913 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008914 LY_CHECK_GOTO(rc, cleanup);
8915 continue;
8916 }
8917
8918 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008919 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008920 LY_CHECK_GOTO(rc, cleanup);
8921
8922 /* eval */
8923 if (options & LYXP_SCNODE_ALL) {
Michal Vaskoecd62de2019-11-13 12:35:11 +01008924 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008925 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008926 rc = moveto_union(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008927 LY_CHECK_GOTO(rc, cleanup);
8928 }
8929 }
8930
8931cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008932 lyxp_set_free_content(&orig_set);
8933 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008934 return rc;
8935}
8936
8937/**
8938 * @brief Evaluate UnaryExpr. Logs directly on error.
8939 *
Michal Vaskod3678892020-05-21 10:06:58 +02008940 * [19] UnaryExpr ::= UnionExpr | '-' UnaryExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008941 *
8942 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008943 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008944 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02008945 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008946 * @param[in] options XPath options.
8947 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8948 */
8949static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008950eval_unary_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008951{
8952 LY_ERR rc;
Michal Vaskodd528af2022-08-08 14:35:07 +02008953 uint32_t this_op, i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008954
8955 assert(repeat);
8956
8957 /* ('-')+ */
Michal Vasko004d3152020-06-11 19:59:22 +02008958 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008959 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008960 assert(!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) && (exp->expr[exp->tok_pos[*tok_idx]] == '-'));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008961
aPiecek8b0cc152021-05-31 16:40:31 +02008962 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008963 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008964 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008965 }
8966
Michal Vasko004d3152020-06-11 19:59:22 +02008967 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNARY, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008968 LY_CHECK_RET(rc);
8969
aPiecek8b0cc152021-05-31 16:40:31 +02008970 if (!(options & LYXP_SKIP_EXPR) && (repeat % 2)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008971 if (options & LYXP_SCNODE_ALL) {
8972 warn_operands(set->ctx, set, NULL, 1, exp->expr, exp->tok_pos[this_op]);
8973 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008974 rc = moveto_op_math(set, NULL, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008975 LY_CHECK_RET(rc);
8976 }
8977 }
8978
8979 return LY_SUCCESS;
8980}
8981
8982/**
8983 * @brief Evaluate MultiplicativeExpr. Logs directly on error.
8984 *
Michal Vaskod3678892020-05-21 10:06:58 +02008985 * [18] MultiplicativeExpr ::= UnaryExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008986 * | MultiplicativeExpr '*' UnaryExpr
8987 * | MultiplicativeExpr 'div' UnaryExpr
8988 * | MultiplicativeExpr 'mod' UnaryExpr
8989 *
8990 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008991 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008992 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02008993 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008994 * @param[in] options XPath options.
8995 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8996 */
8997static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008998eval_multiplicative_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set,
Michal Vasko40308e72020-10-20 16:38:40 +02008999 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009000{
9001 LY_ERR rc;
Michal Vaskodd528af2022-08-08 14:35:07 +02009002 uint32_t i, this_op;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009003 struct lyxp_set orig_set, set2;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009004
9005 assert(repeat);
9006
9007 set_init(&orig_set, set);
9008 set_init(&set2, set);
9009
9010 set_fill_set(&orig_set, set);
9011
Michal Vasko004d3152020-06-11 19:59:22 +02009012 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009013 LY_CHECK_GOTO(rc, cleanup);
9014
9015 /* ('*' / 'div' / 'mod' UnaryExpr)* */
9016 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02009017 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009018
Michal Vasko004d3152020-06-11 19:59:22 +02009019 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_MATH);
aPiecek8b0cc152021-05-31 16:40:31 +02009020 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02009021 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02009022 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009023
aPiecek8b0cc152021-05-31 16:40:31 +02009024 if (options & LYXP_SKIP_EXPR) {
9025 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009026 LY_CHECK_GOTO(rc, cleanup);
9027 continue;
9028 }
9029
9030 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02009031 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009032 LY_CHECK_GOTO(rc, cleanup);
9033
9034 /* eval */
9035 if (options & LYXP_SCNODE_ALL) {
9036 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01009037 lyxp_set_scnode_merge(set, &set2);
Michal Vasko1a09b212021-05-06 13:00:10 +02009038 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009039 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009040 rc = moveto_op_math(set, &set2, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009041 LY_CHECK_GOTO(rc, cleanup);
9042 }
9043 }
9044
9045cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02009046 lyxp_set_free_content(&orig_set);
9047 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009048 return rc;
9049}
9050
9051/**
9052 * @brief Evaluate AdditiveExpr. Logs directly on error.
9053 *
Michal Vaskod3678892020-05-21 10:06:58 +02009054 * [17] AdditiveExpr ::= MultiplicativeExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02009055 * | AdditiveExpr '+' MultiplicativeExpr
9056 * | AdditiveExpr '-' MultiplicativeExpr
9057 *
9058 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02009059 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009060 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02009061 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009062 * @param[in] options XPath options.
9063 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
9064 */
9065static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02009066eval_additive_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009067{
9068 LY_ERR rc;
Michal Vaskodd528af2022-08-08 14:35:07 +02009069 uint32_t i, this_op;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009070 struct lyxp_set orig_set, set2;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009071
9072 assert(repeat);
9073
9074 set_init(&orig_set, set);
9075 set_init(&set2, set);
9076
9077 set_fill_set(&orig_set, set);
9078
Michal Vasko004d3152020-06-11 19:59:22 +02009079 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009080 LY_CHECK_GOTO(rc, cleanup);
9081
9082 /* ('+' / '-' MultiplicativeExpr)* */
9083 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02009084 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009085
Michal Vasko004d3152020-06-11 19:59:22 +02009086 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_MATH);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009087 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02009088 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02009089 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009090
aPiecek8b0cc152021-05-31 16:40:31 +02009091 if (options & LYXP_SKIP_EXPR) {
9092 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009093 LY_CHECK_GOTO(rc, cleanup);
9094 continue;
9095 }
9096
9097 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02009098 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009099 LY_CHECK_GOTO(rc, cleanup);
9100
9101 /* eval */
9102 if (options & LYXP_SCNODE_ALL) {
9103 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01009104 lyxp_set_scnode_merge(set, &set2);
Michal Vasko1a09b212021-05-06 13:00:10 +02009105 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009106 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009107 rc = moveto_op_math(set, &set2, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009108 LY_CHECK_GOTO(rc, cleanup);
9109 }
9110 }
9111
9112cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02009113 lyxp_set_free_content(&orig_set);
9114 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009115 return rc;
9116}
9117
9118/**
9119 * @brief Evaluate RelationalExpr. Logs directly on error.
9120 *
Michal Vaskod3678892020-05-21 10:06:58 +02009121 * [16] RelationalExpr ::= AdditiveExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02009122 * | RelationalExpr '<' AdditiveExpr
9123 * | RelationalExpr '>' AdditiveExpr
9124 * | RelationalExpr '<=' AdditiveExpr
9125 * | RelationalExpr '>=' AdditiveExpr
9126 *
9127 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02009128 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009129 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02009130 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009131 * @param[in] options XPath options.
9132 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
9133 */
9134static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02009135eval_relational_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009136{
9137 LY_ERR rc;
Michal Vaskodd528af2022-08-08 14:35:07 +02009138 uint32_t i, this_op;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009139 struct lyxp_set orig_set, set2;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009140
9141 assert(repeat);
9142
9143 set_init(&orig_set, set);
9144 set_init(&set2, set);
9145
9146 set_fill_set(&orig_set, set);
9147
Michal Vasko004d3152020-06-11 19:59:22 +02009148 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009149 LY_CHECK_GOTO(rc, cleanup);
9150
9151 /* ('<' / '>' / '<=' / '>=' AdditiveExpr)* */
9152 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02009153 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009154
Michal Vasko004d3152020-06-11 19:59:22 +02009155 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_COMP);
aPiecek8b0cc152021-05-31 16:40:31 +02009156 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02009157 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02009158 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009159
aPiecek8b0cc152021-05-31 16:40:31 +02009160 if (options & LYXP_SKIP_EXPR) {
9161 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009162 LY_CHECK_GOTO(rc, cleanup);
9163 continue;
9164 }
9165
9166 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02009167 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009168 LY_CHECK_GOTO(rc, cleanup);
9169
9170 /* eval */
9171 if (options & LYXP_SCNODE_ALL) {
9172 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01009173 lyxp_set_scnode_merge(set, &set2);
Michal Vasko1a09b212021-05-06 13:00:10 +02009174 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009175 } else {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02009176 ly_bool result;
9177
9178 rc = moveto_op_comp(set, &set2, &exp->expr[exp->tok_pos[this_op]], &result);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009179 LY_CHECK_GOTO(rc, cleanup);
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02009180 set_fill_boolean(set, result);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009181 }
9182 }
9183
9184cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02009185 lyxp_set_free_content(&orig_set);
9186 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009187 return rc;
9188}
9189
9190/**
9191 * @brief Evaluate EqualityExpr. Logs directly on error.
9192 *
Michal Vaskod3678892020-05-21 10:06:58 +02009193 * [15] EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02009194 * | EqualityExpr '!=' RelationalExpr
9195 *
9196 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02009197 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009198 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02009199 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009200 * @param[in] options XPath options.
9201 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
9202 */
9203static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02009204eval_equality_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009205{
9206 LY_ERR rc;
Michal Vaskodd528af2022-08-08 14:35:07 +02009207 uint32_t i, this_op;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009208 struct lyxp_set orig_set, set2;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009209
9210 assert(repeat);
9211
9212 set_init(&orig_set, set);
9213 set_init(&set2, set);
9214
9215 set_fill_set(&orig_set, set);
9216
Michal Vasko004d3152020-06-11 19:59:22 +02009217 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009218 LY_CHECK_GOTO(rc, cleanup);
9219
9220 /* ('=' / '!=' RelationalExpr)* */
9221 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02009222 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009223
Michal Vasko004d3152020-06-11 19:59:22 +02009224 assert((exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL) || (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_NEQUAL));
aPiecek8b0cc152021-05-31 16:40:31 +02009225 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02009226 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02009227 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009228
aPiecek8b0cc152021-05-31 16:40:31 +02009229 if (options & LYXP_SKIP_EXPR) {
9230 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009231 LY_CHECK_GOTO(rc, cleanup);
9232 continue;
9233 }
9234
9235 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02009236 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009237 LY_CHECK_GOTO(rc, cleanup);
9238
9239 /* eval */
9240 if (options & LYXP_SCNODE_ALL) {
9241 warn_operands(set->ctx, set, &set2, 0, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vasko004d3152020-06-11 19:59:22 +02009242 warn_equality_value(exp, set, *tok_idx - 1, this_op - 1, *tok_idx - 1);
9243 warn_equality_value(exp, &set2, this_op - 1, this_op - 1, *tok_idx - 1);
Michal Vaskoecd62de2019-11-13 12:35:11 +01009244 lyxp_set_scnode_merge(set, &set2);
Michal Vasko1a09b212021-05-06 13:00:10 +02009245 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009246 } else {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02009247 ly_bool result;
9248
9249 rc = moveto_op_comp(set, &set2, &exp->expr[exp->tok_pos[this_op]], &result);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009250 LY_CHECK_GOTO(rc, cleanup);
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02009251 set_fill_boolean(set, result);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009252 }
9253 }
9254
9255cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02009256 lyxp_set_free_content(&orig_set);
9257 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009258 return rc;
9259}
9260
9261/**
9262 * @brief Evaluate AndExpr. Logs directly on error.
9263 *
Michal Vaskod3678892020-05-21 10:06:58 +02009264 * [14] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02009265 *
9266 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02009267 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009268 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02009269 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009270 * @param[in] options XPath options.
9271 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
9272 */
9273static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02009274eval_and_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009275{
9276 LY_ERR rc;
9277 struct lyxp_set orig_set, set2;
Michal Vaskodd528af2022-08-08 14:35:07 +02009278 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009279
9280 assert(repeat);
9281
9282 set_init(&orig_set, set);
9283 set_init(&set2, set);
9284
9285 set_fill_set(&orig_set, set);
9286
Michal Vasko004d3152020-06-11 19:59:22 +02009287 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009288 LY_CHECK_GOTO(rc, cleanup);
9289
9290 /* cast to boolean, we know that will be the final result */
aPiecek8b0cc152021-05-31 16:40:31 +02009291 if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02009292 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009293 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009294 lyxp_set_cast(set, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009295 }
9296
9297 /* ('and' EqualityExpr)* */
9298 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02009299 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_LOG);
aPiecek8b0cc152021-05-31 16:40:31 +02009300 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, ((options & LYXP_SKIP_EXPR) || !set->val.bln ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02009301 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02009302 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009303
9304 /* lazy evaluation */
aPiecek8b0cc152021-05-31 16:40:31 +02009305 if ((options & LYXP_SKIP_EXPR) || ((set->type == LYXP_SET_BOOLEAN) && !set->val.bln)) {
9306 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009307 LY_CHECK_GOTO(rc, cleanup);
9308 continue;
9309 }
9310
9311 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02009312 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009313 LY_CHECK_GOTO(rc, cleanup);
9314
9315 /* eval - just get boolean value actually */
9316 if (set->type == LYXP_SET_SCNODE_SET) {
Michal Vasko1a09b212021-05-06 13:00:10 +02009317 set_scnode_clear_ctx(&set2, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vaskoecd62de2019-11-13 12:35:11 +01009318 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009319 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009320 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009321 set_fill_set(set, &set2);
9322 }
9323 }
9324
9325cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02009326 lyxp_set_free_content(&orig_set);
9327 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009328 return rc;
9329}
9330
9331/**
9332 * @brief Evaluate OrExpr. Logs directly on error.
9333 *
Michal Vaskod3678892020-05-21 10:06:58 +02009334 * [13] OrExpr ::= AndExpr | OrExpr 'or' AndExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02009335 *
9336 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02009337 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009338 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02009339 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009340 * @param[in] options XPath options.
9341 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
9342 */
9343static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02009344eval_or_expr(const struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t repeat, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009345{
9346 LY_ERR rc;
9347 struct lyxp_set orig_set, set2;
Michal Vaskodd528af2022-08-08 14:35:07 +02009348 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009349
9350 assert(repeat);
9351
9352 set_init(&orig_set, set);
9353 set_init(&set2, set);
9354
9355 set_fill_set(&orig_set, set);
9356
Michal Vasko004d3152020-06-11 19:59:22 +02009357 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009358 LY_CHECK_GOTO(rc, cleanup);
9359
9360 /* cast to boolean, we know that will be the final result */
aPiecek8b0cc152021-05-31 16:40:31 +02009361 if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02009362 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009363 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009364 lyxp_set_cast(set, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009365 }
9366
9367 /* ('or' AndExpr)* */
9368 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02009369 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_LOG);
aPiecek8b0cc152021-05-31 16:40:31 +02009370 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, ((options & LYXP_SKIP_EXPR) || set->val.bln ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02009371 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02009372 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009373
9374 /* lazy evaluation */
aPiecek8b0cc152021-05-31 16:40:31 +02009375 if ((options & LYXP_SKIP_EXPR) || ((set->type == LYXP_SET_BOOLEAN) && set->val.bln)) {
9376 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009377 LY_CHECK_GOTO(rc, cleanup);
9378 continue;
9379 }
9380
9381 set_fill_set(&set2, &orig_set);
9382 /* expr_type cound have been LYXP_EXPR_NONE in all these later calls (except for the first one),
9383 * but it does not matter */
Michal Vasko004d3152020-06-11 19:59:22 +02009384 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009385 LY_CHECK_GOTO(rc, cleanup);
9386
9387 /* eval - just get boolean value actually */
9388 if (set->type == LYXP_SET_SCNODE_SET) {
Michal Vasko1a09b212021-05-06 13:00:10 +02009389 set_scnode_clear_ctx(&set2, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vaskoecd62de2019-11-13 12:35:11 +01009390 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009391 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009392 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009393 set_fill_set(set, &set2);
9394 }
9395 }
9396
9397cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02009398 lyxp_set_free_content(&orig_set);
9399 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009400 return rc;
9401}
9402
9403/**
Michal Vasko004d3152020-06-11 19:59:22 +02009404 * @brief Decide what expression is at the pointer @p tok_idx and evaluate it accordingly.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009405 *
9406 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02009407 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009408 * @param[in] etype Expression type to evaluate.
aPiecek8b0cc152021-05-31 16:40:31 +02009409 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009410 * @param[in] options XPath options.
9411 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
9412 */
9413static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02009414eval_expr_select(const struct lyxp_expr *exp, uint32_t *tok_idx, enum lyxp_expr_type etype, struct lyxp_set *set,
Michal Vasko40308e72020-10-20 16:38:40 +02009415 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009416{
Michal Vaskodd528af2022-08-08 14:35:07 +02009417 uint32_t i, count;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009418 enum lyxp_expr_type next_etype;
9419 LY_ERR rc;
9420
9421 /* process operator repeats */
Michal Vasko004d3152020-06-11 19:59:22 +02009422 if (!exp->repeat[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02009423 next_etype = LYXP_EXPR_NONE;
9424 } else {
9425 /* find etype repeat */
Radek Krejci1e008d22020-08-17 11:37:37 +02009426 for (i = 0; exp->repeat[*tok_idx][i] > etype; ++i) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02009427
9428 /* select one-priority lower because etype expression called us */
9429 if (i) {
Michal Vasko004d3152020-06-11 19:59:22 +02009430 next_etype = exp->repeat[*tok_idx][i - 1];
Michal Vasko03ff5a72019-09-11 13:49:33 +02009431 /* count repeats for that expression */
Radek Krejci1e008d22020-08-17 11:37:37 +02009432 for (count = 0; i && exp->repeat[*tok_idx][i - 1] == next_etype; ++count, --i) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02009433 } else {
9434 next_etype = LYXP_EXPR_NONE;
9435 }
9436 }
9437
9438 /* decide what expression are we parsing based on the repeat */
9439 switch (next_etype) {
9440 case LYXP_EXPR_OR:
Michal Vasko004d3152020-06-11 19:59:22 +02009441 rc = eval_or_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009442 break;
9443 case LYXP_EXPR_AND:
Michal Vasko004d3152020-06-11 19:59:22 +02009444 rc = eval_and_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009445 break;
9446 case LYXP_EXPR_EQUALITY:
Michal Vasko004d3152020-06-11 19:59:22 +02009447 rc = eval_equality_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009448 break;
9449 case LYXP_EXPR_RELATIONAL:
Michal Vasko004d3152020-06-11 19:59:22 +02009450 rc = eval_relational_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009451 break;
9452 case LYXP_EXPR_ADDITIVE:
Michal Vasko004d3152020-06-11 19:59:22 +02009453 rc = eval_additive_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009454 break;
9455 case LYXP_EXPR_MULTIPLICATIVE:
Michal Vasko004d3152020-06-11 19:59:22 +02009456 rc = eval_multiplicative_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009457 break;
9458 case LYXP_EXPR_UNARY:
Michal Vasko004d3152020-06-11 19:59:22 +02009459 rc = eval_unary_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009460 break;
9461 case LYXP_EXPR_UNION:
Michal Vasko004d3152020-06-11 19:59:22 +02009462 rc = eval_union_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009463 break;
9464 case LYXP_EXPR_NONE:
Michal Vasko004d3152020-06-11 19:59:22 +02009465 rc = eval_path_expr(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009466 break;
9467 default:
9468 LOGINT_RET(set->ctx);
9469 }
9470
9471 return rc;
9472}
9473
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009474/**
9475 * @brief Get root type.
9476 *
9477 * @param[in] ctx_node Context node.
9478 * @param[in] ctx_scnode Schema context node.
9479 * @param[in] options XPath options.
9480 * @return Root type.
9481 */
9482static enum lyxp_node_type
Radek Krejci1deb5be2020-08-26 16:43:36 +02009483lyxp_get_root_type(const struct lyd_node *ctx_node, const struct lysc_node *ctx_scnode, uint32_t options)
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009484{
Michal Vasko6b26e742020-07-17 15:02:10 +02009485 const struct lysc_node *op;
9486
Michal Vaskoa27245c2022-05-02 09:01:35 +02009487 /* explicit */
9488 if (options & LYXP_ACCESS_TREE_ALL) {
9489 return LYXP_NODE_ROOT;
9490 } else if (options & LYXP_ACCESS_TREE_CONFIG) {
9491 return LYXP_NODE_ROOT_CONFIG;
9492 }
9493
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009494 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009495 /* schema */
Radek Krejci1e008d22020-08-17 11:37:37 +02009496 for (op = ctx_scnode; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
Michal Vasko6b26e742020-07-17 15:02:10 +02009497
9498 if (op || (options & LYXP_SCNODE)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009499 /* general root that can access everything */
9500 return LYXP_NODE_ROOT;
9501 } else if (!ctx_scnode || (ctx_scnode->flags & LYS_CONFIG_W)) {
9502 /* root context node can access only config data (because we said so, it is unspecified) */
9503 return LYXP_NODE_ROOT_CONFIG;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009504 }
Michal Vasko6b26e742020-07-17 15:02:10 +02009505 return LYXP_NODE_ROOT;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009506 }
9507
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009508 /* data */
Michal Vasko6b26e742020-07-17 15:02:10 +02009509 op = ctx_node ? ctx_node->schema : NULL;
Michal Vaskod989ba02020-08-24 10:59:24 +02009510 for ( ; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
Michal Vasko6b26e742020-07-17 15:02:10 +02009511
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009512 if (op || !(options & LYXP_SCHEMA)) {
9513 /* general root that can access everything */
9514 return LYXP_NODE_ROOT;
Christian Hoppsb6ecaea2021-02-06 09:45:38 -05009515 } else if (!ctx_node || !ctx_node->schema || (ctx_node->schema->flags & LYS_CONFIG_W)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009516 /* root context node can access only config data (because we said so, it is unspecified) */
9517 return LYXP_NODE_ROOT_CONFIG;
9518 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009519 return LYXP_NODE_ROOT;
9520}
9521
Michal Vasko03ff5a72019-09-11 13:49:33 +02009522LY_ERR
Michal Vasko400e9672021-01-11 13:39:17 +01009523lyxp_eval(const struct ly_ctx *ctx, const struct lyxp_expr *exp, const struct lys_module *cur_mod,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +02009524 LY_VALUE_FORMAT format, void *prefix_data, const struct lyd_node *cur_node, const struct lyd_node *ctx_node,
9525 const struct lyd_node *tree, const struct lyxp_var *vars, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009526{
Michal Vaskodd528af2022-08-08 14:35:07 +02009527 uint32_t tok_idx = 0;
Michal Vaskoddd76592022-01-17 13:34:48 +01009528 const struct lysc_node *snode;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009529 LY_ERR rc;
9530
Michal Vasko400e9672021-01-11 13:39:17 +01009531 LY_CHECK_ARG_RET(ctx, ctx, exp, set, LY_EINVAL);
Radek Krejci8df109d2021-04-23 12:19:08 +02009532 if (!cur_mod && ((format == LY_VALUE_SCHEMA) || (format == LY_VALUE_SCHEMA_RESOLVED))) {
Michal Vaskoddd76592022-01-17 13:34:48 +01009533 LOGERR(ctx, LY_EINVAL, "Current module must be set if schema format is used.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009534 return LY_EINVAL;
Michal Vasko004d3152020-06-11 19:59:22 +02009535 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02009536
Michal Vaskod3bb12f2020-12-04 14:33:09 +01009537 if (tree) {
9538 /* adjust the pointer to be the first top-level sibling */
9539 while (tree->parent) {
9540 tree = lyd_parent(tree);
9541 }
9542 tree = lyd_first_sibling(tree);
Michal Vaskoddd76592022-01-17 13:34:48 +01009543
9544 for (snode = tree->schema->parent; snode && (snode->nodetype & (LYS_CASE | LYS_CHOICE)); snode = snode->parent) {}
9545 if (snode) {
9546 /* unable to evaluate absolute paths */
9547 LOGERR(ctx, LY_EINVAL, "Data node \"%s\" has no parent but is not instance of a top-level schema node.",
9548 LYD_NAME(tree));
9549 return LY_EINVAL;
9550 }
Michal Vaskod3bb12f2020-12-04 14:33:09 +01009551 }
9552
Michal Vasko03ff5a72019-09-11 13:49:33 +02009553 /* prepare set for evaluation */
Michal Vasko03ff5a72019-09-11 13:49:33 +02009554 memset(set, 0, sizeof *set);
Michal Vaskod3678892020-05-21 10:06:58 +02009555 set->type = LYXP_SET_NODE_SET;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009556 set->root_type = lyxp_get_root_type(ctx_node, NULL, options);
9557 set_insert_node(set, (struct lyd_node *)ctx_node, 0, ctx_node ? LYXP_NODE_ELEM : set->root_type, 0);
9558
Michal Vasko400e9672021-01-11 13:39:17 +01009559 set->ctx = (struct ly_ctx *)ctx;
Michal Vaskoa3e92bc2022-07-29 14:56:23 +02009560 set->cur_node = cur_node;
9561 for (set->context_op = cur_node ? cur_node->schema : NULL;
Radek Krejci0f969882020-08-21 16:56:47 +02009562 set->context_op && !(set->context_op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF));
9563 set->context_op = set->context_op->parent) {}
Michal Vaskof03ed032020-03-04 13:31:44 +01009564 set->tree = tree;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009565 set->cur_mod = cur_mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009566 set->format = format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009567 set->prefix_data = prefix_data;
aPiecekfba75362021-10-07 12:39:48 +02009568 set->vars = vars;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009569
Radek Krejciddace2c2021-01-08 11:30:56 +01009570 LOG_LOCSET(NULL, set->cur_node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01009571
Michal Vasko03ff5a72019-09-11 13:49:33 +02009572 /* evaluate */
Michal Vasko004d3152020-06-11 19:59:22 +02009573 rc = eval_expr_select(exp, &tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009574 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02009575 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009576 }
9577
Michal Vasko4a7d4d62021-12-13 17:05:06 +01009578 if (set->cur_node) {
9579 LOG_LOCBACK(0, 1, 0, 0);
9580 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02009581 return rc;
9582}
9583
9584#if 0
9585
9586/* full xml printing of set elements, not used currently */
9587
9588void
9589lyxp_set_print_xml(FILE *f, struct lyxp_set *set)
9590{
9591 uint32_t i;
9592 char *str_num;
9593 struct lyout out;
9594
9595 memset(&out, 0, sizeof out);
9596
9597 out.type = LYOUT_STREAM;
9598 out.method.f = f;
9599
9600 switch (set->type) {
9601 case LYXP_SET_EMPTY:
Michal Vasko5233e962020-08-14 14:26:20 +02009602 ly_print_(&out, "Empty XPath set\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009603 break;
9604 case LYXP_SET_BOOLEAN:
Michal Vasko5233e962020-08-14 14:26:20 +02009605 ly_print_(&out, "Boolean XPath set:\n");
9606 ly_print_(&out, "%s\n\n", set->value.bool ? "true" : "false");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009607 break;
9608 case LYXP_SET_STRING:
Michal Vasko5233e962020-08-14 14:26:20 +02009609 ly_print_(&out, "String XPath set:\n");
9610 ly_print_(&out, "\"%s\"\n\n", set->value.str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009611 break;
9612 case LYXP_SET_NUMBER:
Michal Vasko5233e962020-08-14 14:26:20 +02009613 ly_print_(&out, "Number XPath set:\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009614
9615 if (isnan(set->value.num)) {
9616 str_num = strdup("NaN");
9617 } else if ((set->value.num == 0) || (set->value.num == -0.0f)) {
9618 str_num = strdup("0");
9619 } else if (isinf(set->value.num) && !signbit(set->value.num)) {
9620 str_num = strdup("Infinity");
9621 } else if (isinf(set->value.num) && signbit(set->value.num)) {
9622 str_num = strdup("-Infinity");
9623 } else if ((long long)set->value.num == set->value.num) {
9624 if (asprintf(&str_num, "%lld", (long long)set->value.num) == -1) {
9625 str_num = NULL;
9626 }
9627 } else {
9628 if (asprintf(&str_num, "%03.1Lf", set->value.num) == -1) {
9629 str_num = NULL;
9630 }
9631 }
9632 if (!str_num) {
9633 LOGMEM;
9634 return;
9635 }
Michal Vasko5233e962020-08-14 14:26:20 +02009636 ly_print_(&out, "%s\n\n", str_num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009637 free(str_num);
9638 break;
9639 case LYXP_SET_NODE_SET:
Michal Vasko5233e962020-08-14 14:26:20 +02009640 ly_print_(&out, "Node XPath set:\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009641
9642 for (i = 0; i < set->used; ++i) {
Michal Vasko5233e962020-08-14 14:26:20 +02009643 ly_print_(&out, "%d. ", i + 1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009644 switch (set->node_type[i]) {
9645 case LYXP_NODE_ROOT_ALL:
Michal Vasko5233e962020-08-14 14:26:20 +02009646 ly_print_(&out, "ROOT all\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009647 break;
9648 case LYXP_NODE_ROOT_CONFIG:
Michal Vasko5233e962020-08-14 14:26:20 +02009649 ly_print_(&out, "ROOT config\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009650 break;
9651 case LYXP_NODE_ROOT_STATE:
Michal Vasko5233e962020-08-14 14:26:20 +02009652 ly_print_(&out, "ROOT state\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009653 break;
9654 case LYXP_NODE_ROOT_NOTIF:
Michal Vasko5233e962020-08-14 14:26:20 +02009655 ly_print_(&out, "ROOT notification \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009656 break;
9657 case LYXP_NODE_ROOT_RPC:
Michal Vasko5233e962020-08-14 14:26:20 +02009658 ly_print_(&out, "ROOT rpc \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009659 break;
9660 case LYXP_NODE_ROOT_OUTPUT:
Michal Vasko5233e962020-08-14 14:26:20 +02009661 ly_print_(&out, "ROOT output \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009662 break;
9663 case LYXP_NODE_ELEM:
Michal Vasko5233e962020-08-14 14:26:20 +02009664 ly_print_(&out, "ELEM \"%s\"\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009665 xml_print_node(&out, 1, set->value.nodes[i], 1, LYP_FORMAT);
Michal Vasko5233e962020-08-14 14:26:20 +02009666 ly_print_(&out, "\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009667 break;
9668 case LYXP_NODE_TEXT:
Michal Vasko5233e962020-08-14 14:26:20 +02009669 ly_print_(&out, "TEXT \"%s\"\n\n", ((struct lyd_node_leaf_list *)set->value.nodes[i])->value_str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009670 break;
9671 case LYXP_NODE_ATTR:
Michal Vasko5233e962020-08-14 14:26:20 +02009672 ly_print_(&out, "ATTR \"%s\" = \"%s\"\n\n", set->value.attrs[i]->name, set->value.attrs[i]->value);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009673 break;
9674 }
9675 }
9676 break;
9677 }
9678}
9679
9680#endif
9681
9682LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009683lyxp_set_cast(struct lyxp_set *set, enum lyxp_set_type target)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009684{
9685 long double num;
9686 char *str;
9687 LY_ERR rc;
9688
9689 if (!set || (set->type == target)) {
9690 return LY_SUCCESS;
9691 }
9692
9693 /* it's not possible to convert anything into a node set */
Michal Vaskod3678892020-05-21 10:06:58 +02009694 assert(target != LYXP_SET_NODE_SET);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009695
9696 if (set->type == LYXP_SET_SCNODE_SET) {
Michal Vaskod3678892020-05-21 10:06:58 +02009697 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009698 return LY_EINVAL;
9699 }
9700
9701 /* to STRING */
Michal Vaskod3678892020-05-21 10:06:58 +02009702 if ((target == LYXP_SET_STRING) || ((target == LYXP_SET_NUMBER) && (set->type == LYXP_SET_NODE_SET))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02009703 switch (set->type) {
9704 case LYXP_SET_NUMBER:
9705 if (isnan(set->val.num)) {
9706 set->val.str = strdup("NaN");
9707 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
9708 } else if ((set->val.num == 0) || (set->val.num == -0.0f)) {
9709 set->val.str = strdup("0");
9710 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
9711 } else if (isinf(set->val.num) && !signbit(set->val.num)) {
9712 set->val.str = strdup("Infinity");
9713 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
9714 } else if (isinf(set->val.num) && signbit(set->val.num)) {
9715 set->val.str = strdup("-Infinity");
9716 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
9717 } else if ((long long)set->val.num == set->val.num) {
9718 if (asprintf(&str, "%lld", (long long)set->val.num) == -1) {
9719 LOGMEM_RET(set->ctx);
9720 }
9721 set->val.str = str;
9722 } else {
9723 if (asprintf(&str, "%03.1Lf", set->val.num) == -1) {
9724 LOGMEM_RET(set->ctx);
9725 }
9726 set->val.str = str;
9727 }
9728 break;
9729 case LYXP_SET_BOOLEAN:
Michal Vasko004d3152020-06-11 19:59:22 +02009730 if (set->val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02009731 set->val.str = strdup("true");
9732 } else {
9733 set->val.str = strdup("false");
9734 }
9735 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), LY_EMEM);
9736 break;
9737 case LYXP_SET_NODE_SET:
Michal Vasko03ff5a72019-09-11 13:49:33 +02009738 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009739 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02009740
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009741 rc = cast_node_set_to_string(set, &str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009742 LY_CHECK_RET(rc);
Michal Vaskod3678892020-05-21 10:06:58 +02009743 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009744 set->val.str = str;
9745 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009746 default:
9747 LOGINT_RET(set->ctx);
9748 }
9749 set->type = LYXP_SET_STRING;
9750 }
9751
9752 /* to NUMBER */
9753 if (target == LYXP_SET_NUMBER) {
9754 switch (set->type) {
9755 case LYXP_SET_STRING:
9756 num = cast_string_to_number(set->val.str);
Michal Vaskod3678892020-05-21 10:06:58 +02009757 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009758 set->val.num = num;
9759 break;
9760 case LYXP_SET_BOOLEAN:
Michal Vasko004d3152020-06-11 19:59:22 +02009761 if (set->val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02009762 set->val.num = 1;
9763 } else {
9764 set->val.num = 0;
9765 }
9766 break;
9767 default:
9768 LOGINT_RET(set->ctx);
9769 }
9770 set->type = LYXP_SET_NUMBER;
9771 }
9772
9773 /* to BOOLEAN */
9774 if (target == LYXP_SET_BOOLEAN) {
9775 switch (set->type) {
9776 case LYXP_SET_NUMBER:
9777 if ((set->val.num == 0) || (set->val.num == -0.0f) || isnan(set->val.num)) {
Michal Vasko004d3152020-06-11 19:59:22 +02009778 set->val.bln = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009779 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02009780 set->val.bln = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009781 }
9782 break;
9783 case LYXP_SET_STRING:
9784 if (set->val.str[0]) {
Michal Vaskod3678892020-05-21 10:06:58 +02009785 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02009786 set->val.bln = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009787 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02009788 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02009789 set->val.bln = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009790 }
9791 break;
9792 case LYXP_SET_NODE_SET:
Michal Vaskod3678892020-05-21 10:06:58 +02009793 if (set->used) {
9794 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02009795 set->val.bln = 1;
Michal Vaskod3678892020-05-21 10:06:58 +02009796 } else {
9797 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02009798 set->val.bln = 0;
Michal Vaskod3678892020-05-21 10:06:58 +02009799 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02009800 break;
9801 default:
9802 LOGINT_RET(set->ctx);
9803 }
9804 set->type = LYXP_SET_BOOLEAN;
9805 }
9806
Michal Vasko03ff5a72019-09-11 13:49:33 +02009807 return LY_SUCCESS;
9808}
9809
9810LY_ERR
Michal Vasko400e9672021-01-11 13:39:17 +01009811lyxp_atomize(const struct ly_ctx *ctx, const struct lyxp_expr *exp, const struct lys_module *cur_mod,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +02009812 LY_VALUE_FORMAT format, void *prefix_data, const struct lysc_node *cur_scnode,
9813 const struct lysc_node *ctx_scnode, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009814{
Radek Krejci2efc45b2020-12-22 16:25:44 +01009815 LY_ERR ret;
Michal Vaskodd528af2022-08-08 14:35:07 +02009816 uint32_t tok_idx = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009817
Michal Vasko400e9672021-01-11 13:39:17 +01009818 LY_CHECK_ARG_RET(ctx, ctx, exp, set, LY_EINVAL);
Radek Krejci8df109d2021-04-23 12:19:08 +02009819 if (!cur_mod && ((format == LY_VALUE_SCHEMA) || (format == LY_VALUE_SCHEMA_RESOLVED))) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009820 LOGARG(NULL, "Current module must be set if schema format is used.");
9821 return LY_EINVAL;
Michal Vasko004d3152020-06-11 19:59:22 +02009822 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02009823
9824 /* prepare set for evaluation */
Michal Vasko03ff5a72019-09-11 13:49:33 +02009825 memset(set, 0, sizeof *set);
9826 set->type = LYXP_SET_SCNODE_SET;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009827 set->root_type = lyxp_get_root_type(NULL, ctx_scnode, options);
Michal Vasko7333cb32022-07-29 16:30:29 +02009828 LY_CHECK_RET(set_scnode_insert_node(set, ctx_scnode, ctx_scnode ? LYXP_NODE_ELEM : set->root_type, LYXP_AXIS_SELF, NULL));
Radek Krejcif13b87b2020-12-01 22:02:17 +01009829 set->val.scnodes[0].in_ctx = LYXP_SET_SCNODE_START;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009830
Michal Vasko400e9672021-01-11 13:39:17 +01009831 set->ctx = (struct ly_ctx *)ctx;
Michal Vaskoa3e92bc2022-07-29 14:56:23 +02009832 set->cur_scnode = cur_scnode;
9833 for (set->context_op = cur_scnode;
Radek Krejci0f969882020-08-21 16:56:47 +02009834 set->context_op && !(set->context_op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF));
9835 set->context_op = set->context_op->parent) {}
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009836 set->cur_mod = cur_mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009837 set->format = format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009838 set->prefix_data = prefix_data;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009839
Radek Krejciddace2c2021-01-08 11:30:56 +01009840 LOG_LOCSET(set->cur_scnode, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01009841
Michal Vasko03ff5a72019-09-11 13:49:33 +02009842 /* evaluate */
Radek Krejci2efc45b2020-12-22 16:25:44 +01009843 ret = eval_expr_select(exp, &tok_idx, 0, set, options);
9844
Radek Krejciddace2c2021-01-08 11:30:56 +01009845 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01009846 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009847}
Michal Vaskod43d71a2020-08-07 14:54:58 +02009848
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01009849LIBYANG_API_DEF const char *
Michal Vaskod43d71a2020-08-07 14:54:58 +02009850lyxp_get_expr(const struct lyxp_expr *path)
9851{
9852 if (!path) {
9853 return NULL;
9854 }
9855
9856 return path->expr;
9857}