blob: ab7921e676cfe06230f040a0e2340e2db0447d8d [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 Vaskob4750962022-10-06 15:33:35 +020035#include "plugins_exts/metadata.h"
Michal Vasko03ff5a72019-09-11 13:49:33 +020036#include "plugins_types.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020037#include "printer_data.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020038#include "schema_compile_node.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020039#include "tree.h"
Radek Krejci77114102021-03-10 15:21:57 +010040#include "tree_data.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020041#include "tree_data_internal.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010042#include "tree_edit.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020043#include "tree_schema_internal.h"
44#include "xml.h"
Michal Vasko03ff5a72019-09-11 13:49:33 +020045
Michal Vasko7333cb32022-07-29 16:30:29 +020046static LY_ERR set_scnode_insert_node(struct lyxp_set *set, const struct lysc_node *node, enum lyxp_node_type node_type,
47 enum lyxp_axis axis, uint32_t *index_p);
Michal Vaskodd528af2022-08-08 14:35:07 +020048static LY_ERR reparse_or_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth);
49static 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 +020050 struct lyxp_set *set, uint32_t options);
Michal Vaskofe1af042022-07-29 14:58:59 +020051static LY_ERR moveto_resolve_model(const char **qname, uint32_t *qname_len, const struct lyxp_set *set,
Michal Vasko93923692021-05-07 15:28:02 +020052 const struct lysc_node *ctx_scnode, const struct lys_module **moveto_mod);
Michal Vasko47da6562022-07-14 15:43:15 +020053static LY_ERR moveto_axis_node_next(const struct lyd_node **iter, enum lyxp_node_type *iter_type,
54 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 +020055static LY_ERR moveto_node(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname,
56 enum lyxp_axis axis, uint32_t options);
57static LY_ERR moveto_scnode(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname,
58 enum lyxp_axis axis, uint32_t options);
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +020059static 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 +020060
aPiecek96dc1e32021-10-08 15:45:59 +020061/* Functions are divided into the following basic classes:
62 *
63 * (re)parse functions:
64 * Parse functions parse the expression into
65 * tokens (syntactic analysis).
66 * Reparse functions perform semantic analysis
67 * (do not save the result, just a check) of
68 * the expression and fill repeat indices.
69 *
70 * warn functions:
71 * Warn functions check specific reasonable conditions for schema XPath
72 * and print a warning if they are not satisfied.
73 *
74 * moveto functions:
75 * They and only they actually change the context (set).
76 *
77 * eval functions:
78 * They execute a parsed XPath expression on some data subtree.
79 */
80
Michal Vasko03ff5a72019-09-11 13:49:33 +020081/**
82 * @brief Print the type of an XPath \p set.
83 *
84 * @param[in] set Set to use.
85 * @return Set type string.
86 */
87static const char *
88print_set_type(struct lyxp_set *set)
89{
90 switch (set->type) {
Michal Vasko03ff5a72019-09-11 13:49:33 +020091 case LYXP_SET_NODE_SET:
92 return "node set";
93 case LYXP_SET_SCNODE_SET:
94 return "schema node set";
95 case LYXP_SET_BOOLEAN:
96 return "boolean";
97 case LYXP_SET_NUMBER:
98 return "number";
99 case LYXP_SET_STRING:
100 return "string";
101 }
102
103 return NULL;
104}
105
Michal Vasko24cddf82020-06-01 08:17:01 +0200106const char *
Michal Vasko49fec8e2022-05-24 10:28:33 +0200107lyxp_token2str(enum lyxp_token tok)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200108{
109 switch (tok) {
110 case LYXP_TOKEN_PAR1:
111 return "(";
112 case LYXP_TOKEN_PAR2:
113 return ")";
114 case LYXP_TOKEN_BRACK1:
115 return "[";
116 case LYXP_TOKEN_BRACK2:
117 return "]";
118 case LYXP_TOKEN_DOT:
119 return ".";
120 case LYXP_TOKEN_DDOT:
121 return "..";
122 case LYXP_TOKEN_AT:
123 return "@";
124 case LYXP_TOKEN_COMMA:
125 return ",";
126 case LYXP_TOKEN_NAMETEST:
127 return "NameTest";
128 case LYXP_TOKEN_NODETYPE:
129 return "NodeType";
aPiecekfba75362021-10-07 12:39:48 +0200130 case LYXP_TOKEN_VARREF:
131 return "VariableReference";
Michal Vasko03ff5a72019-09-11 13:49:33 +0200132 case LYXP_TOKEN_FUNCNAME:
133 return "FunctionName";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200134 case LYXP_TOKEN_OPER_LOG:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200135 return "Operator(Logic)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200136 case LYXP_TOKEN_OPER_EQUAL:
137 return "Operator(Equal)";
138 case LYXP_TOKEN_OPER_NEQUAL:
139 return "Operator(Non-equal)";
140 case LYXP_TOKEN_OPER_COMP:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200141 return "Operator(Comparison)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200142 case LYXP_TOKEN_OPER_MATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200143 return "Operator(Math)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200144 case LYXP_TOKEN_OPER_UNI:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200145 return "Operator(Union)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200146 case LYXP_TOKEN_OPER_PATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200147 return "Operator(Path)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200148 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko14676352020-05-29 11:35:55 +0200149 return "Operator(Recursive Path)";
Michal Vasko03ff5a72019-09-11 13:49:33 +0200150 case LYXP_TOKEN_LITERAL:
151 return "Literal";
152 case LYXP_TOKEN_NUMBER:
153 return "Number";
154 default:
155 LOGINT(NULL);
156 return "";
157 }
158}
159
160/**
Michal Vasko49fec8e2022-05-24 10:28:33 +0200161 * @brief Transform string into an axis.
162 *
163 * @param[in] str String to transform.
164 * @param[in] str_len Length of @p str.
165 * @return Transformed axis.
166 */
167static enum lyxp_axis
Michal Vaskodd528af2022-08-08 14:35:07 +0200168str2axis(const char *str, uint32_t str_len)
Michal Vasko49fec8e2022-05-24 10:28:33 +0200169{
170 switch (str_len) {
171 case 4:
172 assert(!strncmp("self", str, str_len));
173 return LYXP_AXIS_SELF;
174 case 5:
175 assert(!strncmp("child", str, str_len));
176 return LYXP_AXIS_CHILD;
177 case 6:
178 assert(!strncmp("parent", str, str_len));
179 return LYXP_AXIS_PARENT;
180 case 8:
181 assert(!strncmp("ancestor", str, str_len));
182 return LYXP_AXIS_ANCESTOR;
183 case 9:
184 if (str[0] == 'a') {
185 assert(!strncmp("attribute", str, str_len));
186 return LYXP_AXIS_ATTRIBUTE;
187 } else if (str[0] == 'f') {
188 assert(!strncmp("following", str, str_len));
189 return LYXP_AXIS_FOLLOWING;
190 } else {
191 assert(!strncmp("preceding", str, str_len));
192 return LYXP_AXIS_PRECEDING;
193 }
194 break;
195 case 10:
196 assert(!strncmp("descendant", str, str_len));
197 return LYXP_AXIS_DESCENDANT;
198 case 16:
199 assert(!strncmp("ancestor-or-self", str, str_len));
200 return LYXP_AXIS_ANCESTOR_OR_SELF;
201 case 17:
202 if (str[0] == 'f') {
203 assert(!strncmp("following-sibling", str, str_len));
204 return LYXP_AXIS_FOLLOWING_SIBLING;
205 } else {
206 assert(!strncmp("preceding-sibling", str, str_len));
207 return LYXP_AXIS_PRECEDING_SIBLING;
208 }
209 break;
210 case 18:
211 assert(!strncmp("descendant-or-self", str, str_len));
212 return LYXP_AXIS_DESCENDANT_OR_SELF;
213 }
214
215 LOGINT(NULL);
216 return 0;
217}
218
219/**
Michal Vasko03ff5a72019-09-11 13:49:33 +0200220 * @brief Print the whole expression \p exp to debug output.
221 *
222 * @param[in] exp Expression to use.
223 */
224static void
Michal Vasko40308e72020-10-20 16:38:40 +0200225print_expr_struct_debug(const struct lyxp_expr *exp)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200226{
Radek Krejcif13b87b2020-12-01 22:02:17 +0100227#define MSG_BUFFER_SIZE 128
228 char tmp[MSG_BUFFER_SIZE];
Michal Vasko1fdd8fa2021-01-08 09:21:45 +0100229 uint32_t i, j;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200230
Radek Krejci52b6d512020-10-12 12:33:17 +0200231 if (!exp || (ly_ll < LY_LLDBG)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200232 return;
233 }
234
235 LOGDBG(LY_LDGXPATH, "expression \"%s\":", exp->expr);
236 for (i = 0; i < exp->used; ++i) {
Michal Vasko49fec8e2022-05-24 10:28:33 +0200237 sprintf(tmp, "\ttoken %s, in expression \"%.*s\"", lyxp_token2str(exp->tokens[i]), exp->tok_len[i],
Michal Vasko69730152020-10-09 16:30:07 +0200238 &exp->expr[exp->tok_pos[i]]);
Michal Vasko23049552021-03-04 15:57:44 +0100239 if (exp->repeat && exp->repeat[i]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200240 sprintf(tmp + strlen(tmp), " (repeat %d", exp->repeat[i][0]);
241 for (j = 1; exp->repeat[i][j]; ++j) {
242 sprintf(tmp + strlen(tmp), ", %d", exp->repeat[i][j]);
243 }
244 strcat(tmp, ")");
245 }
246 LOGDBG(LY_LDGXPATH, tmp);
247 }
Radek Krejcif13b87b2020-12-01 22:02:17 +0100248#undef MSG_BUFFER_SIZE
Michal Vasko03ff5a72019-09-11 13:49:33 +0200249}
250
251#ifndef NDEBUG
252
253/**
254 * @brief Print XPath set content to debug output.
255 *
256 * @param[in] set Set to print.
257 */
258static void
259print_set_debug(struct lyxp_set *set)
260{
261 uint32_t i;
262 char *str;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200263 struct lyxp_set_node *item;
264 struct lyxp_set_scnode *sitem;
265
Radek Krejci52b6d512020-10-12 12:33:17 +0200266 if (ly_ll < LY_LLDBG) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200267 return;
268 }
269
270 switch (set->type) {
271 case LYXP_SET_NODE_SET:
272 LOGDBG(LY_LDGXPATH, "set NODE SET:");
273 for (i = 0; i < set->used; ++i) {
274 item = &set->val.nodes[i];
275
276 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +0100277 case LYXP_NODE_NONE:
278 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): NONE", i + 1, item->pos);
279 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200280 case LYXP_NODE_ROOT:
281 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ROOT", i + 1, item->pos);
282 break;
283 case LYXP_NODE_ROOT_CONFIG:
284 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ROOT CONFIG", i + 1, item->pos);
285 break;
286 case LYXP_NODE_ELEM:
Michal Vasko9e685082021-01-29 14:49:09 +0100287 if ((item->node->schema->nodetype == LYS_LIST) && (lyd_child(item->node)->schema->nodetype == LYS_LEAF)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200288 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s (1st child val: %s)", i + 1, item->pos,
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200289 item->node->schema->name, lyd_get_value(lyd_child(item->node)));
Michal Vasko9e685082021-01-29 14:49:09 +0100290 } else if (item->node->schema->nodetype == LYS_LEAFLIST) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200291 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s (val: %s)", i + 1, item->pos,
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200292 item->node->schema->name, lyd_get_value(item->node));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200293 } else {
294 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s", i + 1, item->pos, item->node->schema->name);
295 }
296 break;
297 case LYXP_NODE_TEXT:
298 if (item->node->schema->nodetype & LYS_ANYDATA) {
299 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): TEXT <%s>", i + 1, item->pos,
Michal Vasko69730152020-10-09 16:30:07 +0200300 item->node->schema->nodetype == LYS_ANYXML ? "anyxml" : "anydata");
Michal Vasko03ff5a72019-09-11 13:49:33 +0200301 } else {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200302 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 +0200303 }
304 break;
Michal Vasko9f96a052020-03-10 09:41:45 +0100305 case LYXP_NODE_META:
306 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 +0200307 set->val.meta[i].meta->value);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200308 break;
309 }
310 }
311 break;
312
313 case LYXP_SET_SCNODE_SET:
314 LOGDBG(LY_LDGXPATH, "set SCNODE SET:");
315 for (i = 0; i < set->used; ++i) {
316 sitem = &set->val.scnodes[i];
317
318 switch (sitem->type) {
319 case LYXP_NODE_ROOT:
320 LOGDBG(LY_LDGXPATH, "\t%d (%u): ROOT", i + 1, sitem->in_ctx);
321 break;
322 case LYXP_NODE_ROOT_CONFIG:
323 LOGDBG(LY_LDGXPATH, "\t%d (%u): ROOT CONFIG", i + 1, sitem->in_ctx);
324 break;
325 case LYXP_NODE_ELEM:
326 LOGDBG(LY_LDGXPATH, "\t%d (%u): ELEM %s", i + 1, sitem->in_ctx, sitem->scnode->name);
327 break;
328 default:
329 LOGINT(NULL);
330 break;
331 }
332 }
333 break;
334
Michal Vasko03ff5a72019-09-11 13:49:33 +0200335 case LYXP_SET_BOOLEAN:
336 LOGDBG(LY_LDGXPATH, "set BOOLEAN");
Michal Vasko004d3152020-06-11 19:59:22 +0200337 LOGDBG(LY_LDGXPATH, "\t%s", (set->val.bln ? "true" : "false"));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200338 break;
339
340 case LYXP_SET_STRING:
341 LOGDBG(LY_LDGXPATH, "set STRING");
342 LOGDBG(LY_LDGXPATH, "\t%s", set->val.str);
343 break;
344
345 case LYXP_SET_NUMBER:
346 LOGDBG(LY_LDGXPATH, "set NUMBER");
347
348 if (isnan(set->val.num)) {
349 str = strdup("NaN");
350 } else if ((set->val.num == 0) || (set->val.num == -0.0f)) {
351 str = strdup("0");
352 } else if (isinf(set->val.num) && !signbit(set->val.num)) {
353 str = strdup("Infinity");
354 } else if (isinf(set->val.num) && signbit(set->val.num)) {
355 str = strdup("-Infinity");
356 } else if ((long long)set->val.num == set->val.num) {
357 if (asprintf(&str, "%lld", (long long)set->val.num) == -1) {
358 str = NULL;
359 }
360 } else {
361 if (asprintf(&str, "%03.1Lf", set->val.num) == -1) {
362 str = NULL;
363 }
364 }
365 LY_CHECK_ERR_RET(!str, LOGMEM(NULL), );
366
367 LOGDBG(LY_LDGXPATH, "\t%s", str);
368 free(str);
369 }
370}
371
372#endif
373
374/**
375 * @brief Realloc the string \p str.
376 *
377 * @param[in] ctx libyang context for logging.
378 * @param[in] needed How much free space is required.
379 * @param[in,out] str Pointer to the string to use.
380 * @param[in,out] used Used bytes in \p str.
381 * @param[in,out] size Allocated bytes in \p str.
382 * @return LY_ERR
383 */
384static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +0200385cast_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 +0200386{
Michal Vasko2291ab92022-08-08 08:53:12 +0200387 if (*size - (unsigned)*used < needed) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200388 do {
Michal Vaskodd528af2022-08-08 14:35:07 +0200389 if ((UINT32_MAX - *size) < LYXP_STRING_CAST_SIZE_STEP) {
390 LOGERR(ctx, LY_EINVAL, "XPath string length limit (%" PRIu32 ") reached.", UINT32_MAX);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200391 return LY_EINVAL;
392 }
393 *size += LYXP_STRING_CAST_SIZE_STEP;
Michal Vasko2291ab92022-08-08 08:53:12 +0200394 } while (*size - (unsigned)*used < needed);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200395 *str = ly_realloc(*str, *size * sizeof(char));
396 LY_CHECK_ERR_RET(!(*str), LOGMEM(ctx), LY_EMEM);
397 }
398
399 return LY_SUCCESS;
400}
401
402/**
403 * @brief Cast nodes recursively to one string @p str.
404 *
Michal Vasko47da6562022-07-14 15:43:15 +0200405 * @param[in] node Node to cast, NULL if root.
406 * @param[in] set XPath set.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200407 * @param[in] indent Current indent.
408 * @param[in,out] str Resulting string.
409 * @param[in,out] used Used bytes in @p str.
410 * @param[in,out] size Allocated bytes in @p str.
Michal Vasko47da6562022-07-14 15:43:15 +0200411 * @return LY_ERR value.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200412 */
413static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +0200414cast_string_recursive(const struct lyd_node *node, struct lyxp_set *set, uint32_t indent, char **str, uint32_t *used,
415 uint32_t *size)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200416{
Radek Krejci7f769d72020-07-11 23:13:56 +0200417 char *buf, *line, *ptr = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200418 const char *value_str;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200419 const struct lyd_node *child;
Michal Vasko47da6562022-07-14 15:43:15 +0200420 enum lyxp_node_type child_type;
Michal Vasko60ea6352020-06-29 13:39:39 +0200421 struct lyd_node *tree;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200422 struct lyd_node_any *any;
423 LY_ERR rc;
424
Michal Vasko47da6562022-07-14 15:43:15 +0200425 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && node && (node->schema->flags & LYS_CONFIG_R)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200426 return LY_SUCCESS;
427 }
428
Michal Vasko47da6562022-07-14 15:43:15 +0200429 if (!node) {
430 /* fake container */
431 LY_CHECK_RET(cast_string_realloc(set->ctx, 1, str, used, size));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200432 strcpy(*str + (*used - 1), "\n");
433 ++(*used);
434
435 ++indent;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200436
Michal Vasko47da6562022-07-14 15:43:15 +0200437 /* print all the top-level nodes */
438 child = NULL;
439 child_type = 0;
440 while (!moveto_axis_node_next(&child, &child_type, NULL, set->root_type, LYXP_AXIS_CHILD, set)) {
441 LY_CHECK_RET(cast_string_recursive(child, set, indent, str, used, size));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200442 }
443
Michal Vasko47da6562022-07-14 15:43:15 +0200444 /* end fake container */
445 LY_CHECK_RET(cast_string_realloc(set->ctx, 1, str, used, size));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200446 strcpy(*str + (*used - 1), "\n");
447 ++(*used);
448
449 --indent;
Michal Vasko47da6562022-07-14 15:43:15 +0200450 } else {
451 switch (node->schema->nodetype) {
452 case LYS_CONTAINER:
453 case LYS_LIST:
454 case LYS_RPC:
455 case LYS_NOTIF:
456 LY_CHECK_RET(cast_string_realloc(set->ctx, 1, str, used, size));
457 strcpy(*str + (*used - 1), "\n");
458 ++(*used);
459
460 for (child = lyd_child(node); child; child = child->next) {
461 LY_CHECK_RET(cast_string_recursive(child, set, indent + 1, str, used, size));
462 }
463
464 break;
465
466 case LYS_LEAF:
467 case LYS_LEAFLIST:
468 value_str = lyd_get_value(node);
469
470 /* print indent */
471 LY_CHECK_RET(cast_string_realloc(set->ctx, indent * 2 + strlen(value_str) + 1, str, used, size));
472 memset(*str + (*used - 1), ' ', indent * 2);
473 *used += indent * 2;
474
475 /* print value */
476 if (*used == 1) {
477 sprintf(*str + (*used - 1), "%s", value_str);
478 *used += strlen(value_str);
479 } else {
480 sprintf(*str + (*used - 1), "%s\n", value_str);
481 *used += strlen(value_str) + 1;
482 }
483
484 break;
485
486 case LYS_ANYXML:
487 case LYS_ANYDATA:
488 any = (struct lyd_node_any *)node;
489 if (!(void *)any->value.tree) {
490 /* no content */
491 buf = strdup("");
492 LY_CHECK_ERR_RET(!buf, LOGMEM(set->ctx), LY_EMEM);
493 } else {
494 struct ly_out *out;
495
496 if (any->value_type == LYD_ANYDATA_LYB) {
497 /* try to parse it into a data tree */
498 if (lyd_parse_data_mem((struct ly_ctx *)set->ctx, any->value.mem, LYD_LYB,
499 LYD_PARSE_ONLY | LYD_PARSE_STRICT, 0, &tree) == LY_SUCCESS) {
500 /* successfully parsed */
501 free(any->value.mem);
502 any->value.tree = tree;
503 any->value_type = LYD_ANYDATA_DATATREE;
504 }
505 /* error is covered by the following switch where LYD_ANYDATA_LYB causes failure */
506 }
507
508 switch (any->value_type) {
509 case LYD_ANYDATA_STRING:
510 case LYD_ANYDATA_XML:
511 case LYD_ANYDATA_JSON:
512 buf = strdup(any->value.json);
513 LY_CHECK_ERR_RET(!buf, LOGMEM(set->ctx), LY_EMEM);
514 break;
515 case LYD_ANYDATA_DATATREE:
516 LY_CHECK_RET(ly_out_new_memory(&buf, 0, &out));
517 rc = lyd_print_all(out, any->value.tree, LYD_XML, 0);
518 ly_out_free(out, NULL, 0);
519 LY_CHECK_RET(rc < 0, -rc);
520 break;
521 case LYD_ANYDATA_LYB:
522 LOGERR(set->ctx, LY_EINVAL, "Cannot convert LYB anydata into string.");
523 return LY_EINVAL;
524 }
525 }
526
527 line = strtok_r(buf, "\n", &ptr);
528 do {
529 rc = cast_string_realloc(set->ctx, indent * 2 + strlen(line) + 1, str, used, size);
530 if (rc != LY_SUCCESS) {
531 free(buf);
532 return rc;
533 }
534 memset(*str + (*used - 1), ' ', indent * 2);
535 *used += indent * 2;
536
537 strcpy(*str + (*used - 1), line);
538 *used += strlen(line);
539
540 strcpy(*str + (*used - 1), "\n");
541 *used += 1;
542 } while ((line = strtok_r(NULL, "\n", &ptr)));
543
544 free(buf);
545 break;
546
547 default:
548 LOGINT_RET(set->ctx);
549 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200550 }
551
552 return LY_SUCCESS;
553}
554
555/**
556 * @brief Cast an element into a string.
557 *
Michal Vasko47da6562022-07-14 15:43:15 +0200558 * @param[in] node Node to cast, NULL if root.
559 * @param[in] set XPath set.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200560 * @param[out] str Element cast to dynamically-allocated string.
561 * @return LY_ERR
562 */
563static LY_ERR
Michal Vasko47da6562022-07-14 15:43:15 +0200564cast_string_elem(const struct lyd_node *node, struct lyxp_set *set, char **str)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200565{
Michal Vaskodd528af2022-08-08 14:35:07 +0200566 uint32_t used, size;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200567 LY_ERR rc;
568
569 *str = malloc(LYXP_STRING_CAST_SIZE_START * sizeof(char));
Michal Vasko47da6562022-07-14 15:43:15 +0200570 LY_CHECK_ERR_RET(!*str, LOGMEM(set->ctx), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200571 (*str)[0] = '\0';
572 used = 1;
573 size = LYXP_STRING_CAST_SIZE_START;
574
Michal Vasko47da6562022-07-14 15:43:15 +0200575 rc = cast_string_recursive(node, set, 0, str, &used, &size);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200576 if (rc != LY_SUCCESS) {
577 free(*str);
578 return rc;
579 }
580
581 if (size > used) {
582 *str = ly_realloc(*str, used * sizeof(char));
Michal Vasko47da6562022-07-14 15:43:15 +0200583 LY_CHECK_ERR_RET(!*str, LOGMEM(set->ctx), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200584 }
585 return LY_SUCCESS;
586}
587
588/**
589 * @brief Cast a LYXP_SET_NODE_SET set into a string.
590 * Context position aware.
591 *
592 * @param[in] set Set to cast.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200593 * @param[out] str Cast dynamically-allocated string.
594 * @return LY_ERR
595 */
596static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100597cast_node_set_to_string(struct lyxp_set *set, char **str)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200598{
Michal Vaskoaa677062021-03-09 13:52:53 +0100599 if (!set->used) {
600 *str = strdup("");
601 if (!*str) {
602 LOGMEM_RET(set->ctx);
603 }
604 return LY_SUCCESS;
605 }
606
Michal Vasko03ff5a72019-09-11 13:49:33 +0200607 switch (set->val.nodes[0].type) {
Michal Vasko2caefc12019-11-14 16:07:56 +0100608 case LYXP_NODE_NONE:
609 /* invalid */
610 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200611 case LYXP_NODE_ROOT:
612 case LYXP_NODE_ROOT_CONFIG:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200613 case LYXP_NODE_ELEM:
614 case LYXP_NODE_TEXT:
Michal Vasko47da6562022-07-14 15:43:15 +0200615 return cast_string_elem(set->val.nodes[0].node, set, str);
Michal Vasko9f96a052020-03-10 09:41:45 +0100616 case LYXP_NODE_META:
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200617 *str = strdup(lyd_get_meta_value(set->val.meta[0].meta));
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200618 if (!*str) {
619 LOGMEM_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200620 }
621 return LY_SUCCESS;
622 }
623
624 LOGINT_RET(set->ctx);
625}
626
627/**
628 * @brief Cast a string into an XPath number.
629 *
630 * @param[in] str String to use.
631 * @return Cast number.
632 */
633static long double
634cast_string_to_number(const char *str)
635{
636 long double num;
637 char *ptr;
638
639 errno = 0;
640 num = strtold(str, &ptr);
641 if (errno || *ptr) {
642 num = NAN;
643 }
644 return num;
645}
646
647/**
648 * @brief Callback for checking value equality.
649 *
Michal Vasko62524a92021-02-26 10:08:50 +0100650 * Implementation of ::lyht_value_equal_cb.
Radek Krejci857189e2020-09-01 13:26:36 +0200651 *
Michal Vasko03ff5a72019-09-11 13:49:33 +0200652 * @param[in] val1_p First value.
653 * @param[in] val2_p Second value.
654 * @param[in] mod Whether hash table is being modified.
655 * @param[in] cb_data Callback data.
Radek Krejci857189e2020-09-01 13:26:36 +0200656 * @return Boolean value whether values are equal or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200657 */
Radek Krejci857189e2020-09-01 13:26:36 +0200658static ly_bool
659set_values_equal_cb(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *UNUSED(cb_data))
Michal Vasko03ff5a72019-09-11 13:49:33 +0200660{
661 struct lyxp_set_hash_node *val1, *val2;
662
663 val1 = (struct lyxp_set_hash_node *)val1_p;
664 val2 = (struct lyxp_set_hash_node *)val2_p;
665
666 if ((val1->node == val2->node) && (val1->type == val2->type)) {
667 return 1;
668 }
669
670 return 0;
671}
672
673/**
674 * @brief Insert node and its hash into set.
675 *
676 * @param[in] set et to insert to.
677 * @param[in] node Node with hash.
678 * @param[in] type Node type.
679 */
680static void
681set_insert_node_hash(struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type)
682{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200683 LY_ERR r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200684 uint32_t i, hash;
685 struct lyxp_set_hash_node hnode;
686
687 if (!set->ht && (set->used >= LYD_HT_MIN_ITEMS)) {
688 /* create hash table and add all the nodes */
689 set->ht = lyht_new(1, sizeof(struct lyxp_set_hash_node), set_values_equal_cb, NULL, 1);
690 for (i = 0; i < set->used; ++i) {
691 hnode.node = set->val.nodes[i].node;
692 hnode.type = set->val.nodes[i].type;
693
694 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
695 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
696 hash = dict_hash_multi(hash, NULL, 0);
697
698 r = lyht_insert(set->ht, &hnode, hash, NULL);
699 assert(!r);
700 (void)r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200701
Michal Vasko9d6befd2019-12-11 14:56:56 +0100702 if (hnode.node == node) {
703 /* it was just added, do not add it twice */
704 node = NULL;
705 }
706 }
707 }
708
709 if (set->ht && node) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200710 /* add the new node into hash table */
711 hnode.node = node;
712 hnode.type = type;
713
714 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
715 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
716 hash = dict_hash_multi(hash, NULL, 0);
717
718 r = lyht_insert(set->ht, &hnode, hash, NULL);
719 assert(!r);
720 (void)r;
721 }
722}
723
724/**
725 * @brief Remove node and its hash from set.
726 *
727 * @param[in] set Set to remove from.
728 * @param[in] node Node to remove.
729 * @param[in] type Node type.
730 */
731static void
732set_remove_node_hash(struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type)
733{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200734 LY_ERR r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200735 struct lyxp_set_hash_node hnode;
736 uint32_t hash;
737
738 if (set->ht) {
739 hnode.node = node;
740 hnode.type = type;
741
742 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
743 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
744 hash = dict_hash_multi(hash, NULL, 0);
745
746 r = lyht_remove(set->ht, &hnode, hash);
747 assert(!r);
748 (void)r;
749
750 if (!set->ht->used) {
751 lyht_free(set->ht);
752 set->ht = NULL;
753 }
754 }
755}
756
757/**
758 * @brief Check whether node is in set based on its hash.
759 *
760 * @param[in] set Set to search in.
761 * @param[in] node Node to search for.
762 * @param[in] type Node type.
763 * @param[in] skip_idx Index in @p set to skip.
764 * @return LY_ERR
765 */
766static LY_ERR
767set_dup_node_hash_check(const struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type, int skip_idx)
768{
769 struct lyxp_set_hash_node hnode, *match_p;
770 uint32_t hash;
771
772 hnode.node = node;
773 hnode.type = type;
774
775 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
776 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
777 hash = dict_hash_multi(hash, NULL, 0);
778
779 if (!lyht_find(set->ht, &hnode, hash, (void **)&match_p)) {
780 if ((skip_idx > -1) && (set->val.nodes[skip_idx].node == match_p->node) && (set->val.nodes[skip_idx].type == match_p->type)) {
781 /* we found it on the index that should be skipped, find another */
782 hnode = *match_p;
783 if (lyht_find_next(set->ht, &hnode, hash, (void **)&match_p)) {
784 /* none other found */
785 return LY_SUCCESS;
786 }
787 }
788
789 return LY_EEXIST;
790 }
791
792 /* not found */
793 return LY_SUCCESS;
794}
795
Michal Vaskod3678892020-05-21 10:06:58 +0200796void
797lyxp_set_free_content(struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200798{
799 if (!set) {
800 return;
801 }
802
803 if (set->type == LYXP_SET_NODE_SET) {
804 free(set->val.nodes);
805 lyht_free(set->ht);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200806 } else if (set->type == LYXP_SET_SCNODE_SET) {
807 free(set->val.scnodes);
Michal Vaskod3678892020-05-21 10:06:58 +0200808 lyht_free(set->ht);
809 } else {
810 if (set->type == LYXP_SET_STRING) {
811 free(set->val.str);
812 }
813 set->type = LYXP_SET_NODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200814 }
Michal Vaskod3678892020-05-21 10:06:58 +0200815
816 set->val.nodes = NULL;
817 set->used = 0;
818 set->size = 0;
819 set->ht = NULL;
820 set->ctx_pos = 0;
aPiecek748da732021-06-01 09:56:43 +0200821 set->ctx_size = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200822}
823
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100824/**
825 * @brief Free dynamically-allocated set.
826 *
827 * @param[in] set Set to free.
828 */
829static void
Michal Vasko03ff5a72019-09-11 13:49:33 +0200830lyxp_set_free(struct lyxp_set *set)
831{
832 if (!set) {
833 return;
834 }
835
Michal Vaskod3678892020-05-21 10:06:58 +0200836 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200837 free(set);
838}
839
840/**
841 * @brief Initialize set context.
842 *
843 * @param[in] new Set to initialize.
844 * @param[in] set Arbitrary initialized set.
845 */
846static void
Michal Vasko4c7763f2020-07-27 17:40:37 +0200847set_init(struct lyxp_set *new, const struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200848{
849 memset(new, 0, sizeof *new);
Michal Vasko02a77382019-09-12 11:47:35 +0200850 if (set) {
Michal Vasko306e2832022-07-25 09:15:17 +0200851 new->non_child_axis = set->non_child_axis;
Michal Vasko02a77382019-09-12 11:47:35 +0200852 new->ctx = set->ctx;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200853 new->cur_node = set->cur_node;
Michal Vasko588112f2019-12-10 14:51:53 +0100854 new->root_type = set->root_type;
Michal Vasko6b26e742020-07-17 15:02:10 +0200855 new->context_op = set->context_op;
Michal Vaskof03ed032020-03-04 13:31:44 +0100856 new->tree = set->tree;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200857 new->cur_mod = set->cur_mod;
Michal Vasko02a77382019-09-12 11:47:35 +0200858 new->format = set->format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200859 new->prefix_data = set->prefix_data;
aPiecekfba75362021-10-07 12:39:48 +0200860 new->vars = set->vars;
Michal Vasko02a77382019-09-12 11:47:35 +0200861 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200862}
863
864/**
865 * @brief Create a deep copy of a set.
866 *
867 * @param[in] set Set to copy.
868 * @return Copy of @p set.
869 */
870static struct lyxp_set *
871set_copy(struct lyxp_set *set)
872{
873 struct lyxp_set *ret;
Michal Vasko1fdd8fa2021-01-08 09:21:45 +0100874 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200875
876 if (!set) {
877 return NULL;
878 }
879
880 ret = malloc(sizeof *ret);
881 LY_CHECK_ERR_RET(!ret, LOGMEM(set->ctx), NULL);
882 set_init(ret, set);
883
884 if (set->type == LYXP_SET_SCNODE_SET) {
885 ret->type = set->type;
886
887 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100888 if ((set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) ||
889 (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_START)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +0200890 uint32_t idx;
Michal Vasko26bbb272022-08-02 14:54:33 +0200891
Michal Vasko7333cb32022-07-29 16:30:29 +0200892 LY_CHECK_ERR_RET(set_scnode_insert_node(ret, set->val.scnodes[i].scnode, set->val.scnodes[i].type,
893 set->val.scnodes[i].axis, &idx), lyxp_set_free(ret), NULL);
Michal Vasko3f27c522020-01-06 08:37:49 +0100894 /* coverity seems to think scnodes can be NULL */
Radek Krejciaa6b53f2020-08-27 15:19:03 +0200895 if (!ret->val.scnodes) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200896 lyxp_set_free(ret);
897 return NULL;
898 }
Michal Vaskoba716542019-12-16 10:01:58 +0100899 ret->val.scnodes[idx].in_ctx = set->val.scnodes[i].in_ctx;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200900 }
901 }
902 } else if (set->type == LYXP_SET_NODE_SET) {
903 ret->type = set->type;
Michal Vasko08e9b112021-06-11 15:41:17 +0200904 if (set->used) {
905 ret->val.nodes = malloc(set->used * sizeof *ret->val.nodes);
906 LY_CHECK_ERR_RET(!ret->val.nodes, LOGMEM(set->ctx); free(ret), NULL);
907 memcpy(ret->val.nodes, set->val.nodes, set->used * sizeof *ret->val.nodes);
908 } else {
909 ret->val.nodes = NULL;
910 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200911
912 ret->used = ret->size = set->used;
913 ret->ctx_pos = set->ctx_pos;
914 ret->ctx_size = set->ctx_size;
Michal Vasko4a04e542021-02-01 08:58:30 +0100915 if (set->ht) {
916 ret->ht = lyht_dup(set->ht);
917 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200918 } else {
Radek Krejci0f969882020-08-21 16:56:47 +0200919 memcpy(ret, set, sizeof *ret);
920 if (set->type == LYXP_SET_STRING) {
921 ret->val.str = strdup(set->val.str);
922 LY_CHECK_ERR_RET(!ret->val.str, LOGMEM(set->ctx); free(ret), NULL);
923 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200924 }
925
926 return ret;
927}
928
929/**
930 * @brief Fill XPath set with a string. Any current data are disposed of.
931 *
932 * @param[in] set Set to fill.
933 * @param[in] string String to fill into \p set.
934 * @param[in] str_len Length of \p string. 0 is a valid value!
935 */
936static void
Michal Vaskodd528af2022-08-08 14:35:07 +0200937set_fill_string(struct lyxp_set *set, const char *string, uint32_t str_len)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200938{
Michal Vaskod3678892020-05-21 10:06:58 +0200939 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200940
941 set->type = LYXP_SET_STRING;
942 if ((str_len == 0) && (string[0] != '\0')) {
943 string = "";
944 }
945 set->val.str = strndup(string, str_len);
946}
947
948/**
949 * @brief Fill XPath set with a number. Any current data are disposed of.
950 *
951 * @param[in] set Set to fill.
952 * @param[in] number Number to fill into \p set.
953 */
954static void
955set_fill_number(struct lyxp_set *set, long double number)
956{
Michal Vaskod3678892020-05-21 10:06:58 +0200957 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200958
959 set->type = LYXP_SET_NUMBER;
960 set->val.num = number;
961}
962
963/**
964 * @brief Fill XPath set with a boolean. Any current data are disposed of.
965 *
966 * @param[in] set Set to fill.
967 * @param[in] boolean Boolean to fill into \p set.
968 */
969static void
Radek Krejci857189e2020-09-01 13:26:36 +0200970set_fill_boolean(struct lyxp_set *set, ly_bool boolean)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200971{
Michal Vaskod3678892020-05-21 10:06:58 +0200972 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200973
974 set->type = LYXP_SET_BOOLEAN;
Michal Vasko004d3152020-06-11 19:59:22 +0200975 set->val.bln = boolean;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200976}
977
978/**
979 * @brief Fill XPath set with the value from another set (deep assign).
980 * Any current data are disposed of.
981 *
982 * @param[in] trg Set to fill.
983 * @param[in] src Source set to copy into \p trg.
984 */
985static void
Michal Vasko4c7763f2020-07-27 17:40:37 +0200986set_fill_set(struct lyxp_set *trg, const struct lyxp_set *src)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200987{
988 if (!trg || !src) {
989 return;
990 }
991
992 if (trg->type == LYXP_SET_NODE_SET) {
993 free(trg->val.nodes);
994 } else if (trg->type == LYXP_SET_STRING) {
995 free(trg->val.str);
996 }
997 set_init(trg, src);
998
999 if (src->type == LYXP_SET_SCNODE_SET) {
1000 trg->type = LYXP_SET_SCNODE_SET;
1001 trg->used = src->used;
1002 trg->size = src->used;
1003
Michal Vasko08e9b112021-06-11 15:41:17 +02001004 if (trg->size) {
1005 trg->val.scnodes = ly_realloc(trg->val.scnodes, trg->size * sizeof *trg->val.scnodes);
1006 LY_CHECK_ERR_RET(!trg->val.scnodes, LOGMEM(src->ctx); memset(trg, 0, sizeof *trg), );
1007 memcpy(trg->val.scnodes, src->val.scnodes, src->used * sizeof *src->val.scnodes);
1008 } else {
1009 trg->val.scnodes = NULL;
1010 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02001011 } else if (src->type == LYXP_SET_BOOLEAN) {
Michal Vasko004d3152020-06-11 19:59:22 +02001012 set_fill_boolean(trg, src->val.bln);
Michal Vasko44f3d2c2020-08-24 09:49:38 +02001013 } else if (src->type == LYXP_SET_NUMBER) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001014 set_fill_number(trg, src->val.num);
1015 } else if (src->type == LYXP_SET_STRING) {
1016 set_fill_string(trg, src->val.str, strlen(src->val.str));
1017 } else {
1018 if (trg->type == LYXP_SET_NODE_SET) {
1019 free(trg->val.nodes);
1020 } else if (trg->type == LYXP_SET_STRING) {
1021 free(trg->val.str);
1022 }
1023
Michal Vaskod3678892020-05-21 10:06:58 +02001024 assert(src->type == LYXP_SET_NODE_SET);
1025
1026 trg->type = LYXP_SET_NODE_SET;
1027 trg->used = src->used;
1028 trg->size = src->used;
1029 trg->ctx_pos = src->ctx_pos;
1030 trg->ctx_size = src->ctx_size;
1031
Michal Vasko08e9b112021-06-11 15:41:17 +02001032 if (trg->size) {
1033 trg->val.nodes = malloc(trg->size * sizeof *trg->val.nodes);
1034 LY_CHECK_ERR_RET(!trg->val.nodes, LOGMEM(src->ctx); memset(trg, 0, sizeof *trg), );
1035 memcpy(trg->val.nodes, src->val.nodes, src->used * sizeof *src->val.nodes);
1036 } else {
1037 trg->val.nodes = NULL;
1038 }
Michal Vaskod3678892020-05-21 10:06:58 +02001039 if (src->ht) {
1040 trg->ht = lyht_dup(src->ht);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001041 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02001042 trg->ht = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001043 }
1044 }
1045}
1046
1047/**
1048 * @brief Clear context of all schema nodes.
1049 *
1050 * @param[in] set Set to clear.
Michal Vasko1a09b212021-05-06 13:00:10 +02001051 * @param[in] new_ctx New context state for all the nodes currently in the context.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001052 */
1053static void
Michal Vasko1a09b212021-05-06 13:00:10 +02001054set_scnode_clear_ctx(struct lyxp_set *set, int32_t new_ctx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001055{
1056 uint32_t i;
1057
1058 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01001059 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko1a09b212021-05-06 13:00:10 +02001060 set->val.scnodes[i].in_ctx = new_ctx;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001061 } else if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_START) {
1062 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001063 }
1064 }
1065}
1066
1067/**
1068 * @brief Remove a node from a set. Removing last node changes
1069 * set into LYXP_SET_EMPTY. Context position aware.
1070 *
1071 * @param[in] set Set to use.
1072 * @param[in] idx Index from @p set of the node to be removed.
1073 */
1074static void
1075set_remove_node(struct lyxp_set *set, uint32_t idx)
1076{
1077 assert(set && (set->type == LYXP_SET_NODE_SET));
1078 assert(idx < set->used);
1079
1080 set_remove_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
1081
1082 --set->used;
Michal Vasko08e9b112021-06-11 15:41:17 +02001083 if (idx < set->used) {
1084 memmove(&set->val.nodes[idx], &set->val.nodes[idx + 1], (set->used - idx) * sizeof *set->val.nodes);
1085 } else if (!set->used) {
Michal Vaskod3678892020-05-21 10:06:58 +02001086 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001087 }
1088}
1089
1090/**
Michal Vasko2caefc12019-11-14 16:07:56 +01001091 * @brief Remove a node from a set by setting its type to LYXP_NODE_NONE.
Michal Vasko57eab132019-09-24 11:46:26 +02001092 *
1093 * @param[in] set Set to use.
1094 * @param[in] idx Index from @p set of the node to be removed.
1095 */
1096static void
Michal Vasko2caefc12019-11-14 16:07:56 +01001097set_remove_node_none(struct lyxp_set *set, uint32_t idx)
Michal Vasko57eab132019-09-24 11:46:26 +02001098{
1099 assert(set && (set->type == LYXP_SET_NODE_SET));
1100 assert(idx < set->used);
1101
Michal Vasko2caefc12019-11-14 16:07:56 +01001102 if (set->val.nodes[idx].type == LYXP_NODE_ELEM) {
1103 set_remove_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
1104 }
1105 set->val.nodes[idx].type = LYXP_NODE_NONE;
Michal Vasko57eab132019-09-24 11:46:26 +02001106}
1107
1108/**
Michal Vasko2caefc12019-11-14 16:07:56 +01001109 * @brief Remove all LYXP_NODE_NONE nodes from a set. Removing last node changes
Michal Vasko57eab132019-09-24 11:46:26 +02001110 * set into LYXP_SET_EMPTY. Context position aware.
1111 *
1112 * @param[in] set Set to consolidate.
1113 */
1114static void
Michal Vasko2caefc12019-11-14 16:07:56 +01001115set_remove_nodes_none(struct lyxp_set *set)
Michal Vasko57eab132019-09-24 11:46:26 +02001116{
Michal Vasko1fdd8fa2021-01-08 09:21:45 +01001117 uint32_t i, orig_used, end = 0;
1118 int64_t start;
Michal Vasko57eab132019-09-24 11:46:26 +02001119
Michal Vaskod3678892020-05-21 10:06:58 +02001120 assert(set);
Michal Vasko57eab132019-09-24 11:46:26 +02001121
1122 orig_used = set->used;
1123 set->used = 0;
Michal Vaskod989ba02020-08-24 10:59:24 +02001124 for (i = 0; i < orig_used; ) {
Michal Vasko57eab132019-09-24 11:46:26 +02001125 start = -1;
1126 do {
Michal Vasko2caefc12019-11-14 16:07:56 +01001127 if ((set->val.nodes[i].type != LYXP_NODE_NONE) && (start == -1)) {
Michal Vasko57eab132019-09-24 11:46:26 +02001128 start = i;
Michal Vasko2caefc12019-11-14 16:07:56 +01001129 } else if ((start > -1) && (set->val.nodes[i].type == LYXP_NODE_NONE)) {
Michal Vasko57eab132019-09-24 11:46:26 +02001130 end = i;
1131 ++i;
1132 break;
1133 }
1134
1135 ++i;
1136 if (i == orig_used) {
1137 end = i;
1138 }
1139 } while (i < orig_used);
1140
1141 if (start > -1) {
1142 /* move the whole chunk of valid nodes together */
1143 if (set->used != (unsigned)start) {
1144 memmove(&set->val.nodes[set->used], &set->val.nodes[start], (end - start) * sizeof *set->val.nodes);
1145 }
1146 set->used += end - start;
1147 }
1148 }
Michal Vasko57eab132019-09-24 11:46:26 +02001149}
1150
1151/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02001152 * @brief Check for duplicates in a node set.
1153 *
1154 * @param[in] set Set to check.
1155 * @param[in] node Node to look for in @p set.
1156 * @param[in] node_type Type of @p node.
1157 * @param[in] skip_idx Index from @p set to skip.
1158 * @return LY_ERR
1159 */
1160static LY_ERR
1161set_dup_node_check(const struct lyxp_set *set, const struct lyd_node *node, enum lyxp_node_type node_type, int skip_idx)
1162{
1163 uint32_t i;
1164
Michal Vasko2caefc12019-11-14 16:07:56 +01001165 if (set->ht && node) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001166 return set_dup_node_hash_check(set, (struct lyd_node *)node, node_type, skip_idx);
1167 }
1168
1169 for (i = 0; i < set->used; ++i) {
1170 if ((skip_idx > -1) && (i == (unsigned)skip_idx)) {
1171 continue;
1172 }
1173
1174 if ((set->val.nodes[i].node == node) && (set->val.nodes[i].type == node_type)) {
1175 return LY_EEXIST;
1176 }
1177 }
1178
1179 return LY_SUCCESS;
1180}
1181
Radek Krejci857189e2020-09-01 13:26:36 +02001182ly_bool
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001183lyxp_set_scnode_contains(struct lyxp_set *set, const struct lysc_node *node, enum lyxp_node_type node_type, int skip_idx,
1184 uint32_t *index_p)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001185{
1186 uint32_t i;
1187
1188 for (i = 0; i < set->used; ++i) {
1189 if ((skip_idx > -1) && (i == (unsigned)skip_idx)) {
1190 continue;
1191 }
1192
1193 if ((set->val.scnodes[i].scnode == node) && (set->val.scnodes[i].type == node_type)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001194 if (index_p) {
1195 *index_p = i;
1196 }
1197 return 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001198 }
1199 }
1200
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001201 return 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001202}
1203
Michal Vaskoecd62de2019-11-13 12:35:11 +01001204void
1205lyxp_set_scnode_merge(struct lyxp_set *set1, struct lyxp_set *set2)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001206{
1207 uint32_t orig_used, i, j;
1208
Michal Vaskod3678892020-05-21 10:06:58 +02001209 assert((set1->type == LYXP_SET_SCNODE_SET) && (set2->type == LYXP_SET_SCNODE_SET));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001210
Michal Vaskod3678892020-05-21 10:06:58 +02001211 if (!set2->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001212 return;
1213 }
1214
Michal Vaskod3678892020-05-21 10:06:58 +02001215 if (!set1->used) {
aPiecekadc1e4f2021-10-07 11:15:12 +02001216 /* release hidden allocated data (lyxp_set.size) */
1217 lyxp_set_free_content(set1);
1218 /* direct copying of the entire structure */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001219 memcpy(set1, set2, sizeof *set1);
1220 return;
1221 }
1222
1223 if (set1->used + set2->used > set1->size) {
1224 set1->size = set1->used + set2->used;
1225 set1->val.scnodes = ly_realloc(set1->val.scnodes, set1->size * sizeof *set1->val.scnodes);
1226 LY_CHECK_ERR_RET(!set1->val.scnodes, LOGMEM(set1->ctx), );
1227 }
1228
1229 orig_used = set1->used;
1230
1231 for (i = 0; i < set2->used; ++i) {
1232 for (j = 0; j < orig_used; ++j) {
1233 /* detect duplicities */
1234 if (set1->val.scnodes[j].scnode == set2->val.scnodes[i].scnode) {
1235 break;
1236 }
1237 }
1238
Michal Vasko0587bce2020-12-10 12:19:21 +01001239 if (j < orig_used) {
1240 /* node is there, but update its status if needed */
1241 if (set1->val.scnodes[j].in_ctx == LYXP_SET_SCNODE_START_USED) {
1242 set1->val.scnodes[j].in_ctx = set2->val.scnodes[i].in_ctx;
Michal Vasko1a09b212021-05-06 13:00:10 +02001243 } else if ((set1->val.scnodes[j].in_ctx == LYXP_SET_SCNODE_ATOM_NODE) &&
1244 (set2->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL)) {
1245 set1->val.scnodes[j].in_ctx = set2->val.scnodes[i].in_ctx;
Michal Vasko0587bce2020-12-10 12:19:21 +01001246 }
1247 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001248 memcpy(&set1->val.scnodes[set1->used], &set2->val.scnodes[i], sizeof *set2->val.scnodes);
1249 ++set1->used;
1250 }
1251 }
1252
Michal Vaskod3678892020-05-21 10:06:58 +02001253 lyxp_set_free_content(set2);
1254 set2->type = LYXP_SET_SCNODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001255}
1256
1257/**
1258 * @brief Insert a node into a set. Context position aware.
1259 *
1260 * @param[in] set Set to use.
1261 * @param[in] node Node to insert to @p set.
1262 * @param[in] pos Sort position of @p node. If left 0, it is filled just before sorting.
1263 * @param[in] node_type Node type of @p node.
1264 * @param[in] idx Index in @p set to insert into.
1265 */
1266static void
1267set_insert_node(struct lyxp_set *set, const struct lyd_node *node, uint32_t pos, enum lyxp_node_type node_type, uint32_t idx)
1268{
Michal Vaskod3678892020-05-21 10:06:58 +02001269 assert(set && (set->type == LYXP_SET_NODE_SET));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001270
Michal Vaskod3678892020-05-21 10:06:58 +02001271 if (!set->size) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001272 /* first item */
1273 if (idx) {
1274 /* no real harm done, but it is a bug */
1275 LOGINT(set->ctx);
1276 idx = 0;
1277 }
1278 set->val.nodes = malloc(LYXP_SET_SIZE_START * sizeof *set->val.nodes);
1279 LY_CHECK_ERR_RET(!set->val.nodes, LOGMEM(set->ctx), );
1280 set->type = LYXP_SET_NODE_SET;
1281 set->used = 0;
1282 set->size = LYXP_SET_SIZE_START;
1283 set->ctx_pos = 1;
1284 set->ctx_size = 1;
1285 set->ht = NULL;
1286 } else {
1287 /* not an empty set */
1288 if (set->used == set->size) {
1289
1290 /* set is full */
Michal Vasko871df522022-04-06 12:14:41 +02001291 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 +02001292 LY_CHECK_ERR_RET(!set->val.nodes, LOGMEM(set->ctx), );
Michal Vasko871df522022-04-06 12:14:41 +02001293 set->size *= LYXP_SET_SIZE_MUL_STEP;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001294 }
1295
1296 if (idx > set->used) {
1297 LOGINT(set->ctx);
1298 idx = set->used;
1299 }
1300
1301 /* make space for the new node */
1302 if (idx < set->used) {
1303 memmove(&set->val.nodes[idx + 1], &set->val.nodes[idx], (set->used - idx) * sizeof *set->val.nodes);
1304 }
1305 }
1306
1307 /* finally assign the value */
1308 set->val.nodes[idx].node = (struct lyd_node *)node;
1309 set->val.nodes[idx].type = node_type;
1310 set->val.nodes[idx].pos = pos;
1311 ++set->used;
1312
Michal Vasko2416fdd2021-10-01 11:07:10 +02001313 /* add into hash table */
1314 set_insert_node_hash(set, (struct lyd_node *)node, node_type);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001315}
1316
Michal Vasko7333cb32022-07-29 16:30:29 +02001317/**
1318 * @brief Insert schema node into set.
1319 *
1320 * @param[in] set Set to insert into.
1321 * @param[in] node Node to insert.
1322 * @param[in] node_type Node type of @p node.
1323 * @param[in] axis Axis that @p node was reached on.
1324 * @param[out] index_p Optional pointer to store index if the inserted @p node.
1325 * @return LY_SUCCESS on success.
1326 * @return LY_EMEM on memory allocation failure.
1327 */
1328static LY_ERR
1329set_scnode_insert_node(struct lyxp_set *set, const struct lysc_node *node, enum lyxp_node_type node_type,
1330 enum lyxp_axis axis, uint32_t *index_p)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001331{
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001332 uint32_t index;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001333
1334 assert(set->type == LYXP_SET_SCNODE_SET);
1335
Michal Vasko871df522022-04-06 12:14:41 +02001336 if (!set->size) {
1337 /* first item */
1338 set->val.scnodes = malloc(LYXP_SET_SIZE_START * sizeof *set->val.scnodes);
1339 LY_CHECK_ERR_RET(!set->val.scnodes, LOGMEM(set->ctx), LY_EMEM);
1340 set->type = LYXP_SET_SCNODE_SET;
1341 set->used = 0;
1342 set->size = LYXP_SET_SIZE_START;
1343 set->ctx_pos = 1;
1344 set->ctx_size = 1;
1345 set->ht = NULL;
1346 }
1347
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001348 if (lyxp_set_scnode_contains(set, node, node_type, -1, &index)) {
Michal Vasko7333cb32022-07-29 16:30:29 +02001349 /* BUG if axes differs, this new one is thrown away */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001350 set->val.scnodes[index].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001351 } else {
1352 if (set->used == set->size) {
Michal Vasko871df522022-04-06 12:14:41 +02001353 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 +02001354 LY_CHECK_ERR_RET(!set->val.scnodes, LOGMEM(set->ctx), LY_EMEM);
Michal Vasko871df522022-04-06 12:14:41 +02001355 set->size *= LYXP_SET_SIZE_MUL_STEP;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001356 }
1357
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001358 index = set->used;
1359 set->val.scnodes[index].scnode = (struct lysc_node *)node;
1360 set->val.scnodes[index].type = node_type;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001361 set->val.scnodes[index].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko7333cb32022-07-29 16:30:29 +02001362 set->val.scnodes[index].axis = axis;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001363 ++set->used;
1364 }
1365
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001366 if (index_p) {
1367 *index_p = index;
1368 }
1369
1370 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001371}
1372
1373/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02001374 * @brief Set all nodes with ctx 1 to a new unique context value.
1375 *
1376 * @param[in] set Set to modify.
1377 * @return New context value.
1378 */
Michal Vasko5c4e5892019-11-14 12:31:38 +01001379static int32_t
Michal Vasko03ff5a72019-09-11 13:49:33 +02001380set_scnode_new_in_ctx(struct lyxp_set *set)
1381{
Michal Vasko5c4e5892019-11-14 12:31:38 +01001382 uint32_t i;
1383 int32_t ret_ctx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001384
1385 assert(set->type == LYXP_SET_SCNODE_SET);
1386
Radek Krejcif13b87b2020-12-01 22:02:17 +01001387 ret_ctx = LYXP_SET_SCNODE_ATOM_PRED_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001388retry:
1389 for (i = 0; i < set->used; ++i) {
1390 if (set->val.scnodes[i].in_ctx >= ret_ctx) {
1391 ret_ctx = set->val.scnodes[i].in_ctx + 1;
1392 goto retry;
1393 }
1394 }
1395 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01001396 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001397 set->val.scnodes[i].in_ctx = ret_ctx;
1398 }
1399 }
1400
1401 return ret_ctx;
1402}
1403
1404/**
1405 * @brief Get unique @p node position in the data.
1406 *
1407 * @param[in] node Node to find.
1408 * @param[in] node_type Node type of @p node.
1409 * @param[in] root Root node.
1410 * @param[in] root_type Type of the XPath @p root node.
1411 * @param[in] prev Node that we think is before @p node in DFS from @p root. Can optionally
1412 * be used to increase efficiency and start the DFS from this node.
1413 * @param[in] prev_pos Node @p prev position. Optional, but must be set if @p prev is set.
1414 * @return Node position.
1415 */
1416static uint32_t
1417get_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 +02001418 enum lyxp_node_type root_type, const struct lyd_node **prev, uint32_t *prev_pos)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001419{
Michal Vasko56daf732020-08-10 10:57:18 +02001420 const struct lyd_node *elem = NULL, *top_sibling;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001421 uint32_t pos = 1;
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001422 ly_bool found = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001423
1424 assert(prev && prev_pos && !root->prev->next);
1425
1426 if ((node_type == LYXP_NODE_ROOT) || (node_type == LYXP_NODE_ROOT_CONFIG)) {
1427 return 0;
1428 }
1429
1430 if (*prev) {
1431 /* start from the previous element instead from the root */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001432 pos = *prev_pos;
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001433 for (top_sibling = *prev; top_sibling->parent; top_sibling = lyd_parent(top_sibling)) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001434 goto dfs_search;
1435 }
1436
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001437 LY_LIST_FOR(root, top_sibling) {
Michal Vasko56daf732020-08-10 10:57:18 +02001438 LYD_TREE_DFS_BEGIN(top_sibling, elem) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001439dfs_search:
Michal Vaskoa9309bb2021-07-09 09:31:55 +02001440 LYD_TREE_DFS_continue = 0;
1441
Michal Vasko56daf732020-08-10 10:57:18 +02001442 if (*prev && !elem) {
1443 /* resume previous DFS */
1444 elem = LYD_TREE_DFS_next = (struct lyd_node *)*prev;
1445 LYD_TREE_DFS_continue = 0;
1446 }
1447
Michal Vasko482a6822022-05-06 08:56:12 +02001448 if (!elem->schema || ((root_type == LYXP_NODE_ROOT_CONFIG) && (elem->schema->flags & LYS_CONFIG_R))) {
Michal Vasko56daf732020-08-10 10:57:18 +02001449 /* skip */
1450 LYD_TREE_DFS_continue = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001451 } else {
Michal Vasko56daf732020-08-10 10:57:18 +02001452 if (elem == node) {
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001453 found = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001454 break;
1455 }
Michal Vasko56daf732020-08-10 10:57:18 +02001456 ++pos;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001457 }
Michal Vasko56daf732020-08-10 10:57:18 +02001458
1459 LYD_TREE_DFS_END(top_sibling, elem);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001460 }
1461
1462 /* node found */
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001463 if (found) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001464 break;
1465 }
1466 }
1467
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001468 if (!found) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001469 if (!(*prev)) {
1470 /* we went from root and failed to find it, cannot be */
Michal Vaskob7be7a82020-08-20 09:09:04 +02001471 LOGINT(LYD_CTX(node));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001472 return 0;
1473 } else {
Michal Vasko56daf732020-08-10 10:57:18 +02001474 /* start the search again from the beginning */
1475 *prev = root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001476
Michal Vasko56daf732020-08-10 10:57:18 +02001477 top_sibling = root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001478 pos = 1;
1479 goto dfs_search;
1480 }
1481 }
1482
1483 /* remember the last found node for next time */
1484 *prev = node;
1485 *prev_pos = pos;
1486
1487 return pos;
1488}
1489
1490/**
1491 * @brief Assign (fill) missing node positions.
1492 *
1493 * @param[in] set Set to fill positions in.
1494 * @param[in] root Context root node.
1495 * @param[in] root_type Context root type.
1496 * @return LY_ERR
1497 */
1498static LY_ERR
1499set_assign_pos(struct lyxp_set *set, const struct lyd_node *root, enum lyxp_node_type root_type)
1500{
1501 const struct lyd_node *prev = NULL, *tmp_node;
1502 uint32_t i, tmp_pos = 0;
1503
1504 for (i = 0; i < set->used; ++i) {
1505 if (!set->val.nodes[i].pos) {
1506 tmp_node = NULL;
1507 switch (set->val.nodes[i].type) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001508 case LYXP_NODE_META:
1509 tmp_node = set->val.meta[i].meta->parent;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001510 if (!tmp_node) {
1511 LOGINT_RET(root->schema->module->ctx);
1512 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01001513 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001514 case LYXP_NODE_ELEM:
1515 case LYXP_NODE_TEXT:
1516 if (!tmp_node) {
1517 tmp_node = set->val.nodes[i].node;
1518 }
1519 set->val.nodes[i].pos = get_node_pos(tmp_node, set->val.nodes[i].type, root, root_type, &prev, &tmp_pos);
1520 break;
1521 default:
1522 /* all roots have position 0 */
1523 break;
1524 }
1525 }
1526 }
1527
1528 return LY_SUCCESS;
1529}
1530
1531/**
Michal Vasko9f96a052020-03-10 09:41:45 +01001532 * @brief Get unique @p meta position in the parent metadata.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001533 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001534 * @param[in] meta Metadata to use.
1535 * @return Metadata position.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001536 */
Michal Vaskodd528af2022-08-08 14:35:07 +02001537static uint32_t
Michal Vasko9f96a052020-03-10 09:41:45 +01001538get_meta_pos(struct lyd_meta *meta)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001539{
Michal Vaskodd528af2022-08-08 14:35:07 +02001540 uint32_t pos = 0;
Michal Vasko9f96a052020-03-10 09:41:45 +01001541 struct lyd_meta *meta2;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001542
Michal Vasko9f96a052020-03-10 09:41:45 +01001543 for (meta2 = meta->parent->meta; meta2 && (meta2 != meta); meta2 = meta2->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001544 ++pos;
1545 }
1546
Michal Vasko9f96a052020-03-10 09:41:45 +01001547 assert(meta2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001548 return pos;
1549}
1550
1551/**
1552 * @brief Compare 2 nodes in respect to XPath document order.
1553 *
1554 * @param[in] item1 1st node.
1555 * @param[in] item2 2nd node.
1556 * @return If 1st > 2nd returns 1, 1st == 2nd returns 0, and 1st < 2nd returns -1.
1557 */
1558static int
1559set_sort_compare(struct lyxp_set_node *item1, struct lyxp_set_node *item2)
1560{
Michal Vasko9f96a052020-03-10 09:41:45 +01001561 uint32_t meta_pos1 = 0, meta_pos2 = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001562
1563 if (item1->pos < item2->pos) {
1564 return -1;
1565 }
1566
1567 if (item1->pos > item2->pos) {
1568 return 1;
1569 }
1570
1571 /* node positions are equal, the fun case */
1572
1573 /* 1st ELEM - == - 2nd TEXT, 1st TEXT - == - 2nd ELEM */
1574 /* special case since text nodes are actually saved as their parents */
1575 if ((item1->node == item2->node) && (item1->type != item2->type)) {
1576 if (item1->type == LYXP_NODE_ELEM) {
1577 assert(item2->type == LYXP_NODE_TEXT);
1578 return -1;
1579 } else {
1580 assert((item1->type == LYXP_NODE_TEXT) && (item2->type == LYXP_NODE_ELEM));
1581 return 1;
1582 }
1583 }
1584
Michal Vasko9f96a052020-03-10 09:41:45 +01001585 /* we need meta positions now */
1586 if (item1->type == LYXP_NODE_META) {
1587 meta_pos1 = get_meta_pos((struct lyd_meta *)item1->node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001588 }
Michal Vasko9f96a052020-03-10 09:41:45 +01001589 if (item2->type == LYXP_NODE_META) {
1590 meta_pos2 = get_meta_pos((struct lyd_meta *)item2->node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001591 }
1592
Michal Vasko9f96a052020-03-10 09:41:45 +01001593 /* 1st ROOT - 2nd ROOT, 1st ELEM - 2nd ELEM, 1st TEXT - 2nd TEXT, 1st META - =pos= - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001594 /* check for duplicates */
1595 if (item1->node == item2->node) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001596 assert((item1->type == item2->type) && ((item1->type != LYXP_NODE_META) || (meta_pos1 == meta_pos2)));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001597 return 0;
1598 }
1599
Michal Vasko9f96a052020-03-10 09:41:45 +01001600 /* 1st ELEM - 2nd TEXT, 1st ELEM - any pos - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001601 /* elem is always first, 2nd node is after it */
1602 if (item1->type == LYXP_NODE_ELEM) {
1603 assert(item2->type != LYXP_NODE_ELEM);
1604 return -1;
1605 }
1606
Michal Vasko9f96a052020-03-10 09:41:45 +01001607 /* 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 +02001608 /* 2nd is before 1st */
Michal Vasko69730152020-10-09 16:30:07 +02001609 if (((item1->type == LYXP_NODE_TEXT) &&
1610 ((item2->type == LYXP_NODE_ELEM) || (item2->type == LYXP_NODE_META))) ||
1611 ((item1->type == LYXP_NODE_META) && (item2->type == LYXP_NODE_ELEM)) ||
1612 (((item1->type == LYXP_NODE_META) && (item2->type == LYXP_NODE_META)) &&
1613 (meta_pos1 > meta_pos2))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001614 return 1;
1615 }
1616
Michal Vasko9f96a052020-03-10 09:41:45 +01001617 /* 1st META - any pos - 2nd TEXT, 1st META <pos< - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001618 /* 2nd is after 1st */
1619 return -1;
1620}
1621
1622/**
1623 * @brief Set cast for comparisons.
1624 *
Michal Vasko8abcecc2022-07-28 09:55:01 +02001625 * @param[in,out] trg Target set to cast source into.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001626 * @param[in] src Source set.
1627 * @param[in] type Target set type.
1628 * @param[in] src_idx Source set node index.
Michal Vasko8abcecc2022-07-28 09:55:01 +02001629 * @return LY_SUCCESS on success.
1630 * @return LY_ERR value on error.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001631 */
1632static LY_ERR
Michal Vasko8abcecc2022-07-28 09:55:01 +02001633set_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 +02001634{
1635 assert(src->type == LYXP_SET_NODE_SET);
1636
1637 set_init(trg, src);
1638
1639 /* insert node into target set */
1640 set_insert_node(trg, src->val.nodes[src_idx].node, src->val.nodes[src_idx].pos, src->val.nodes[src_idx].type, 0);
1641
1642 /* cast target set appropriately */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001643 return lyxp_set_cast(trg, type);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001644}
1645
Michal Vasko4c7763f2020-07-27 17:40:37 +02001646/**
1647 * @brief Set content canonization for comparisons.
1648 *
Michal Vasko8abcecc2022-07-28 09:55:01 +02001649 * @param[in,out] set Set to canonize.
Michal Vasko4c7763f2020-07-27 17:40:37 +02001650 * @param[in] xp_node Source XPath node/meta to use for canonization.
Michal Vasko8abcecc2022-07-28 09:55:01 +02001651 * @return LY_SUCCESS on success.
1652 * @return LY_ERR value on error.
Michal Vasko4c7763f2020-07-27 17:40:37 +02001653 */
1654static LY_ERR
Michal Vasko8abcecc2022-07-28 09:55:01 +02001655set_comp_canonize(struct lyxp_set *set, const struct lyxp_set_node *xp_node)
Michal Vasko4c7763f2020-07-27 17:40:37 +02001656{
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001657 const struct lysc_type *type = NULL;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001658 struct lyd_value val;
1659 struct ly_err_item *err = NULL;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001660 LY_ERR rc;
1661
1662 /* is there anything to canonize even? */
Michal Vasko8abcecc2022-07-28 09:55:01 +02001663 if (set->type == LYXP_SET_STRING) {
Michal Vasko4c7763f2020-07-27 17:40:37 +02001664 /* do we have a type to use for canonization? */
1665 if ((xp_node->type == LYXP_NODE_ELEM) && (xp_node->node->schema->nodetype & LYD_NODE_TERM)) {
1666 type = ((struct lyd_node_term *)xp_node->node)->value.realtype;
1667 } else if (xp_node->type == LYXP_NODE_META) {
1668 type = ((struct lyd_meta *)xp_node->node)->value.realtype;
1669 }
1670 }
1671 if (!type) {
Michal Vasko8abcecc2022-07-28 09:55:01 +02001672 /* no canonization needed/possible */
1673 return LY_SUCCESS;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001674 }
1675
Michal Vasko8abcecc2022-07-28 09:55:01 +02001676 /* check for built-in types without required canonization */
1677 if ((type->basetype == LY_TYPE_STRING) && (type->plugin->store == lyplg_type_store_string)) {
1678 /* string */
1679 return LY_SUCCESS;
1680 }
1681 if ((type->basetype == LY_TYPE_BOOL) && (type->plugin->store == lyplg_type_store_boolean)) {
1682 /* boolean */
1683 return LY_SUCCESS;
1684 }
1685 if ((type->basetype == LY_TYPE_ENUM) && (type->plugin->store == lyplg_type_store_enum)) {
1686 /* enumeration */
1687 return LY_SUCCESS;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001688 }
1689
Michal Vasko8abcecc2022-07-28 09:55:01 +02001690 /* print canonized string, ignore errors, the value may not satisfy schema constraints */
1691 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 +01001692 LYD_HINT_DATA, xp_node->node->schema, &val, NULL, &err);
Michal Vasko4c7763f2020-07-27 17:40:37 +02001693 ly_err_free(err);
1694 if (rc) {
Michal Vasko8abcecc2022-07-28 09:55:01 +02001695 /* invalid value, function store automaticaly dealloc value when fail */
1696 return LY_SUCCESS;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001697 }
1698
Michal Vasko8abcecc2022-07-28 09:55:01 +02001699 /* use the canonized string value */
1700 free(set->val.str);
1701 set->val.str = strdup(lyd_value_get_canonical(set->ctx, &val));
1702 type->plugin->free(set->ctx, &val);
1703 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), LY_EMEM);
Michal Vasko4c7763f2020-07-27 17:40:37 +02001704
Michal Vasko4c7763f2020-07-27 17:40:37 +02001705 return LY_SUCCESS;
1706}
1707
Michal Vasko03ff5a72019-09-11 13:49:33 +02001708/**
1709 * @brief Bubble sort @p set into XPath document order.
Michal Vasko49fec8e2022-05-24 10:28:33 +02001710 * Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001711 *
1712 * @param[in] set Set to sort.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001713 * @return How many times the whole set was traversed - 1 (if set was sorted, returns 0).
1714 */
1715static int
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001716set_sort(struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001717{
1718 uint32_t i, j;
Radek Krejci1deb5be2020-08-26 16:43:36 +02001719 int ret = 0, cmp;
Radek Krejci857189e2020-09-01 13:26:36 +02001720 ly_bool inverted, change;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001721 const struct lyd_node *root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001722 struct lyxp_set_node item;
1723 struct lyxp_set_hash_node hnode;
1724 uint64_t hash;
1725
Michal Vasko3cf8fbf2020-05-27 15:21:21 +02001726 if ((set->type != LYXP_SET_NODE_SET) || (set->used < 2)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001727 return 0;
1728 }
1729
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001730 /* find first top-level node to be used as anchor for positions */
Michal Vasko4a7d4d62021-12-13 17:05:06 +01001731 for (root = set->tree; root->parent; root = lyd_parent(root)) {}
Michal Vaskod989ba02020-08-24 10:59:24 +02001732 for ( ; root->prev->next; root = root->prev) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001733
1734 /* fill positions */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001735 if (set_assign_pos(set, root, set->root_type)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001736 return -1;
1737 }
1738
Michal Vasko88a9e802022-05-24 10:50:28 +02001739#ifndef NDEBUG
Michal Vasko03ff5a72019-09-11 13:49:33 +02001740 LOGDBG(LY_LDGXPATH, "SORT BEGIN");
1741 print_set_debug(set);
Michal Vasko88a9e802022-05-24 10:50:28 +02001742#endif
Michal Vasko03ff5a72019-09-11 13:49:33 +02001743
1744 for (i = 0; i < set->used; ++i) {
1745 inverted = 0;
1746 change = 0;
1747
1748 for (j = 1; j < set->used - i; ++j) {
1749 /* compare node positions */
1750 if (inverted) {
1751 cmp = set_sort_compare(&set->val.nodes[j], &set->val.nodes[j - 1]);
1752 } else {
1753 cmp = set_sort_compare(&set->val.nodes[j - 1], &set->val.nodes[j]);
1754 }
1755
1756 /* swap if needed */
1757 if ((inverted && (cmp < 0)) || (!inverted && (cmp > 0))) {
1758 change = 1;
1759
1760 item = set->val.nodes[j - 1];
1761 set->val.nodes[j - 1] = set->val.nodes[j];
1762 set->val.nodes[j] = item;
1763 } else {
1764 /* whether node_pos1 should be smaller than node_pos2 or the other way around */
1765 inverted = !inverted;
1766 }
1767 }
1768
1769 ++ret;
1770
1771 if (!change) {
1772 break;
1773 }
1774 }
1775
Michal Vasko88a9e802022-05-24 10:50:28 +02001776#ifndef NDEBUG
Michal Vasko03ff5a72019-09-11 13:49:33 +02001777 LOGDBG(LY_LDGXPATH, "SORT END %d", ret);
1778 print_set_debug(set);
Michal Vasko88a9e802022-05-24 10:50:28 +02001779#endif
Michal Vasko03ff5a72019-09-11 13:49:33 +02001780
1781 /* check node hashes */
1782 if (set->used >= LYD_HT_MIN_ITEMS) {
1783 assert(set->ht);
1784 for (i = 0; i < set->used; ++i) {
1785 hnode.node = set->val.nodes[i].node;
1786 hnode.type = set->val.nodes[i].type;
1787
1788 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
1789 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
1790 hash = dict_hash_multi(hash, NULL, 0);
1791
1792 assert(!lyht_find(set->ht, &hnode, hash, NULL));
1793 }
1794 }
1795
1796 return ret - 1;
1797}
1798
Michal Vasko03ff5a72019-09-11 13:49:33 +02001799/**
1800 * @brief Merge 2 sorted sets into one.
1801 *
1802 * @param[in,out] trg Set to merge into. Duplicates are removed.
1803 * @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 +02001804 * @return LY_ERR
1805 */
1806static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001807set_sorted_merge(struct lyxp_set *trg, struct lyxp_set *src)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001808{
1809 uint32_t i, j, k, count, dup_count;
1810 int cmp;
1811 const struct lyd_node *root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001812
Michal Vaskod3678892020-05-21 10:06:58 +02001813 if ((trg->type != LYXP_SET_NODE_SET) || (src->type != LYXP_SET_NODE_SET)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001814 return LY_EINVAL;
1815 }
1816
Michal Vaskod3678892020-05-21 10:06:58 +02001817 if (!src->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001818 return LY_SUCCESS;
Michal Vaskod3678892020-05-21 10:06:58 +02001819 } else if (!trg->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001820 set_fill_set(trg, src);
Michal Vaskod3678892020-05-21 10:06:58 +02001821 lyxp_set_free_content(src);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001822 return LY_SUCCESS;
1823 }
1824
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001825 /* find first top-level node to be used as anchor for positions */
Michal Vasko0143b682021-12-13 17:13:09 +01001826 for (root = trg->tree; root->parent; root = lyd_parent(root)) {}
Michal Vaskod989ba02020-08-24 10:59:24 +02001827 for ( ; root->prev->next; root = root->prev) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001828
1829 /* fill positions */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001830 if (set_assign_pos(trg, root, trg->root_type) || set_assign_pos(src, root, src->root_type)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001831 return LY_EINT;
1832 }
1833
1834#ifndef NDEBUG
1835 LOGDBG(LY_LDGXPATH, "MERGE target");
1836 print_set_debug(trg);
1837 LOGDBG(LY_LDGXPATH, "MERGE source");
1838 print_set_debug(src);
1839#endif
1840
1841 /* make memory for the merge (duplicates are not detected yet, so space
1842 * will likely be wasted on them, too bad) */
1843 if (trg->size - trg->used < src->used) {
1844 trg->size = trg->used + src->used;
1845
1846 trg->val.nodes = ly_realloc(trg->val.nodes, trg->size * sizeof *trg->val.nodes);
1847 LY_CHECK_ERR_RET(!trg->val.nodes, LOGMEM(src->ctx), LY_EMEM);
1848 }
1849
1850 i = 0;
1851 j = 0;
1852 count = 0;
1853 dup_count = 0;
1854 do {
1855 cmp = set_sort_compare(&src->val.nodes[i], &trg->val.nodes[j]);
1856 if (!cmp) {
1857 if (!count) {
1858 /* duplicate, just skip it */
1859 ++i;
1860 ++j;
1861 } else {
1862 /* we are copying something already, so let's copy the duplicate too,
1863 * we are hoping that afterwards there are some more nodes to
1864 * copy and this way we can copy them all together */
1865 ++count;
1866 ++dup_count;
1867 ++i;
1868 ++j;
1869 }
1870 } else if (cmp < 0) {
1871 /* inserting src node into trg, just remember it for now */
1872 ++count;
1873 ++i;
1874
1875 /* insert the hash now */
1876 set_insert_node_hash(trg, src->val.nodes[i - 1].node, src->val.nodes[i - 1].type);
1877 } else if (count) {
1878copy_nodes:
1879 /* time to actually copy the nodes, we have found the largest block of nodes */
1880 memmove(&trg->val.nodes[j + (count - dup_count)],
1881 &trg->val.nodes[j],
1882 (trg->used - j) * sizeof *trg->val.nodes);
1883 memcpy(&trg->val.nodes[j - dup_count], &src->val.nodes[i - count], count * sizeof *src->val.nodes);
1884
1885 trg->used += count - dup_count;
1886 /* do not change i, except the copying above, we are basically doing exactly what is in the else branch below */
1887 j += count - dup_count;
1888
1889 count = 0;
1890 dup_count = 0;
1891 } else {
1892 ++j;
1893 }
1894 } while ((i < src->used) && (j < trg->used));
1895
1896 if ((i < src->used) || count) {
1897 /* insert all the hashes first */
1898 for (k = i; k < src->used; ++k) {
1899 set_insert_node_hash(trg, src->val.nodes[k].node, src->val.nodes[k].type);
1900 }
1901
1902 /* loop ended, but we need to copy something at trg end */
1903 count += src->used - i;
1904 i = src->used;
1905 goto copy_nodes;
1906 }
1907
1908 /* we are inserting hashes before the actual node insert, which causes
1909 * situations when there were initially not enough items for a hash table,
1910 * but even after some were inserted, hash table was not created (during
1911 * insertion the number of items is not updated yet) */
1912 if (!trg->ht && (trg->used >= LYD_HT_MIN_ITEMS)) {
1913 set_insert_node_hash(trg, NULL, 0);
1914 }
1915
1916#ifndef NDEBUG
1917 LOGDBG(LY_LDGXPATH, "MERGE result");
1918 print_set_debug(trg);
1919#endif
1920
Michal Vaskod3678892020-05-21 10:06:58 +02001921 lyxp_set_free_content(src);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001922 return LY_SUCCESS;
1923}
1924
Michal Vasko14676352020-05-29 11:35:55 +02001925LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02001926lyxp_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 +02001927{
Michal Vasko004d3152020-06-11 19:59:22 +02001928 if (exp->used == tok_idx) {
Michal Vasko14676352020-05-29 11:35:55 +02001929 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001930 LOGVAL(ctx, LY_VCODE_XP_EOF);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001931 }
Michal Vasko14676352020-05-29 11:35:55 +02001932 return LY_EINCOMPLETE;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001933 }
1934
Michal Vasko004d3152020-06-11 19:59:22 +02001935 if (want_tok && (exp->tokens[tok_idx] != want_tok)) {
Michal Vasko14676352020-05-29 11:35:55 +02001936 if (ctx) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02001937 LOGVAL(ctx, LY_VCODE_XP_INTOK2, lyxp_token2str(exp->tokens[tok_idx]),
1938 &exp->expr[exp->tok_pos[tok_idx]], lyxp_token2str(want_tok));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001939 }
Michal Vasko14676352020-05-29 11:35:55 +02001940 return LY_ENOT;
1941 }
1942
1943 return LY_SUCCESS;
1944}
1945
Michal Vasko004d3152020-06-11 19:59:22 +02001946LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02001947lyxp_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 +02001948{
1949 LY_CHECK_RET(lyxp_check_token(ctx, exp, *tok_idx, want_tok));
1950
1951 /* skip the token */
1952 ++(*tok_idx);
1953
1954 return LY_SUCCESS;
1955}
1956
Michal Vasko14676352020-05-29 11:35:55 +02001957/* just like lyxp_check_token() but tests for 2 tokens */
1958static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02001959exp_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 +02001960 enum lyxp_token want_tok2)
Michal Vasko14676352020-05-29 11:35:55 +02001961{
Michal Vasko004d3152020-06-11 19:59:22 +02001962 if (exp->used == tok_idx) {
Michal Vasko14676352020-05-29 11:35:55 +02001963 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001964 LOGVAL(ctx, LY_VCODE_XP_EOF);
Michal Vasko14676352020-05-29 11:35:55 +02001965 }
1966 return LY_EINCOMPLETE;
1967 }
1968
Michal Vasko004d3152020-06-11 19:59:22 +02001969 if ((exp->tokens[tok_idx] != want_tok1) && (exp->tokens[tok_idx] != want_tok2)) {
Michal Vasko14676352020-05-29 11:35:55 +02001970 if (ctx) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02001971 LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_token2str(exp->tokens[tok_idx]),
Michal Vasko0b468e62020-10-19 09:33:04 +02001972 &exp->expr[exp->tok_pos[tok_idx]]);
Michal Vasko14676352020-05-29 11:35:55 +02001973 }
1974 return LY_ENOT;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001975 }
1976
1977 return LY_SUCCESS;
1978}
1979
Michal Vasko4911eeb2021-06-28 11:23:05 +02001980LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02001981lyxp_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 +02001982 enum lyxp_token want_tok2)
1983{
1984 LY_CHECK_RET(exp_check_token2(ctx, exp, *tok_idx, want_tok1, want_tok2));
1985
1986 /* skip the token */
1987 ++(*tok_idx);
1988
1989 return LY_SUCCESS;
1990}
1991
Michal Vasko03ff5a72019-09-11 13:49:33 +02001992/**
1993 * @brief Stack operation push on the repeat array.
1994 *
1995 * @param[in] exp Expression to use.
Michal Vasko004d3152020-06-11 19:59:22 +02001996 * @param[in] tok_idx Position in the expresion \p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001997 * @param[in] repeat_op_idx Index from \p exp of the operator token. This value is pushed.
1998 */
1999static void
Michal Vaskodd528af2022-08-08 14:35:07 +02002000exp_repeat_push(struct lyxp_expr *exp, uint32_t tok_idx, uint32_t repeat_op_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002001{
Michal Vaskodd528af2022-08-08 14:35:07 +02002002 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002003
Michal Vasko004d3152020-06-11 19:59:22 +02002004 if (exp->repeat[tok_idx]) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002005 for (i = 0; exp->repeat[tok_idx][i]; ++i) {}
Michal Vasko004d3152020-06-11 19:59:22 +02002006 exp->repeat[tok_idx] = realloc(exp->repeat[tok_idx], (i + 2) * sizeof *exp->repeat[tok_idx]);
2007 LY_CHECK_ERR_RET(!exp->repeat[tok_idx], LOGMEM(NULL), );
2008 exp->repeat[tok_idx][i] = repeat_op_idx;
2009 exp->repeat[tok_idx][i + 1] = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002010 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02002011 exp->repeat[tok_idx] = calloc(2, sizeof *exp->repeat[tok_idx]);
2012 LY_CHECK_ERR_RET(!exp->repeat[tok_idx], LOGMEM(NULL), );
2013 exp->repeat[tok_idx][0] = repeat_op_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002014 }
2015}
2016
2017/**
2018 * @brief Reparse Predicate. Logs directly on error.
2019 *
2020 * [7] Predicate ::= '[' Expr ']'
2021 *
2022 * @param[in] ctx Context for logging.
2023 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002024 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002025 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002026 * @return LY_ERR
2027 */
2028static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002029reparse_predicate(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint32_t *tok_idx, uint32_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002030{
2031 LY_ERR rc;
2032
Michal Vasko004d3152020-06-11 19:59:22 +02002033 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_BRACK1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002034 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002035 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002036
aPiecekbf968d92021-05-27 14:35:05 +02002037 rc = reparse_or_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002038 LY_CHECK_RET(rc);
2039
Michal Vasko004d3152020-06-11 19:59:22 +02002040 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_BRACK2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002041 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002042 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002043
2044 return LY_SUCCESS;
2045}
2046
2047/**
2048 * @brief Reparse RelativeLocationPath. Logs directly on error.
2049 *
2050 * [4] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
2051 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
2052 * [6] NodeTest ::= NameTest | NodeType '(' ')'
2053 *
2054 * @param[in] ctx Context for logging.
2055 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002056 * @param[in] tok_idx Position in the expression \p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002057 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002058 * @return LY_ERR (LY_EINCOMPLETE on forward reference)
2059 */
2060static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002061reparse_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 +02002062{
2063 LY_ERR rc;
2064
Michal Vasko004d3152020-06-11 19:59:22 +02002065 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002066 LY_CHECK_RET(rc);
2067
2068 goto step;
2069 do {
2070 /* '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02002071 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002072
Michal Vasko004d3152020-06-11 19:59:22 +02002073 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002074 LY_CHECK_RET(rc);
2075step:
2076 /* Step */
Michal Vasko004d3152020-06-11 19:59:22 +02002077 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002078 case LYXP_TOKEN_DOT:
Michal Vasko004d3152020-06-11 19:59:22 +02002079 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002080 break;
2081
2082 case LYXP_TOKEN_DDOT:
Michal Vasko004d3152020-06-11 19:59:22 +02002083 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002084 break;
2085
Michal Vasko49fec8e2022-05-24 10:28:33 +02002086 case LYXP_TOKEN_AXISNAME:
2087 ++(*tok_idx);
2088
2089 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_DCOLON);
2090 LY_CHECK_RET(rc);
2091
2092 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02002093 case LYXP_TOKEN_AT:
Michal Vasko004d3152020-06-11 19:59:22 +02002094 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002095
Michal Vasko004d3152020-06-11 19:59:22 +02002096 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002097 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002098 if ((exp->tokens[*tok_idx] != LYXP_TOKEN_NAMETEST) && (exp->tokens[*tok_idx] != LYXP_TOKEN_NODETYPE)) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02002099 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 +02002100 return LY_EVALID;
2101 }
Michal Vasko49fec8e2022-05-24 10:28:33 +02002102 if (exp->tokens[*tok_idx] == LYXP_TOKEN_NODETYPE) {
2103 goto reparse_nodetype;
2104 }
Radek Krejci0f969882020-08-21 16:56:47 +02002105 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02002106 case LYXP_TOKEN_NAMETEST:
Michal Vasko004d3152020-06-11 19:59:22 +02002107 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002108 goto reparse_predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002109
2110 case LYXP_TOKEN_NODETYPE:
Michal Vasko49fec8e2022-05-24 10:28:33 +02002111reparse_nodetype:
Michal Vasko004d3152020-06-11 19:59:22 +02002112 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002113
2114 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02002115 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002116 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002117 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002118
2119 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02002120 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002121 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002122 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002123
2124reparse_predicate:
2125 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002126 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
aPiecekbf968d92021-05-27 14:35:05 +02002127 rc = reparse_predicate(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002128 LY_CHECK_RET(rc);
2129 }
2130 break;
2131 default:
Michal Vasko49fec8e2022-05-24 10:28:33 +02002132 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 +02002133 return LY_EVALID;
2134 }
Michal Vasko004d3152020-06-11 19:59:22 +02002135 } while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH));
Michal Vasko03ff5a72019-09-11 13:49:33 +02002136
2137 return LY_SUCCESS;
2138}
2139
2140/**
2141 * @brief Reparse AbsoluteLocationPath. Logs directly on error.
2142 *
2143 * [3] AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
2144 *
2145 * @param[in] ctx Context for logging.
2146 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002147 * @param[in] tok_idx Position in the expression \p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002148 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002149 * @return LY_ERR
2150 */
2151static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002152reparse_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 +02002153{
2154 LY_ERR rc;
2155
Michal Vasko004d3152020-06-11 19:59:22 +02002156 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 +02002157
2158 /* '/' RelativeLocationPath? */
Michal Vasko004d3152020-06-11 19:59:22 +02002159 if (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002160 /* '/' */
Michal Vasko004d3152020-06-11 19:59:22 +02002161 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002162
Michal Vasko004d3152020-06-11 19:59:22 +02002163 if (lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002164 return LY_SUCCESS;
2165 }
Michal Vasko004d3152020-06-11 19:59:22 +02002166 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002167 case LYXP_TOKEN_DOT:
2168 case LYXP_TOKEN_DDOT:
Michal Vasko49fec8e2022-05-24 10:28:33 +02002169 case LYXP_TOKEN_AXISNAME:
Michal Vasko03ff5a72019-09-11 13:49:33 +02002170 case LYXP_TOKEN_AT:
2171 case LYXP_TOKEN_NAMETEST:
2172 case LYXP_TOKEN_NODETYPE:
aPiecekbf968d92021-05-27 14:35:05 +02002173 rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002174 LY_CHECK_RET(rc);
Radek Krejci0f969882020-08-21 16:56:47 +02002175 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02002176 default:
2177 break;
2178 }
2179
Michal Vasko03ff5a72019-09-11 13:49:33 +02002180 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02002181 /* '//' RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02002182 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002183
aPiecekbf968d92021-05-27 14:35:05 +02002184 rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002185 LY_CHECK_RET(rc);
2186 }
2187
2188 return LY_SUCCESS;
2189}
2190
2191/**
2192 * @brief Reparse FunctionCall. Logs directly on error.
2193 *
2194 * [9] FunctionCall ::= FunctionName '(' ( Expr ( ',' Expr )* )? ')'
2195 *
2196 * @param[in] ctx Context for logging.
2197 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002198 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002199 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002200 * @return LY_ERR
2201 */
2202static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002203reparse_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 +02002204{
Radek Krejci1deb5be2020-08-26 16:43:36 +02002205 int8_t min_arg_count = -1;
Michal Vaskodd528af2022-08-08 14:35:07 +02002206 uint32_t arg_count, max_arg_count = 0, func_tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002207 LY_ERR rc;
2208
Michal Vasko004d3152020-06-11 19:59:22 +02002209 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_FUNCNAME);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002210 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002211 func_tok_idx = *tok_idx;
2212 switch (exp->tok_len[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002213 case 3:
Michal Vasko004d3152020-06-11 19:59:22 +02002214 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "not", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002215 min_arg_count = 1;
2216 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002217 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "sum", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002218 min_arg_count = 1;
2219 max_arg_count = 1;
2220 }
2221 break;
2222 case 4:
Michal Vasko004d3152020-06-11 19:59:22 +02002223 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "lang", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002224 min_arg_count = 1;
2225 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002226 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "last", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002227 min_arg_count = 0;
2228 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002229 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "name", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002230 min_arg_count = 0;
2231 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002232 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "true", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002233 min_arg_count = 0;
2234 max_arg_count = 0;
2235 }
2236 break;
2237 case 5:
Michal Vasko004d3152020-06-11 19:59:22 +02002238 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "count", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002239 min_arg_count = 1;
2240 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002241 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "false", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002242 min_arg_count = 0;
2243 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002244 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "floor", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002245 min_arg_count = 1;
2246 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002247 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "round", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002248 min_arg_count = 1;
2249 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002250 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "deref", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002251 min_arg_count = 1;
2252 max_arg_count = 1;
2253 }
2254 break;
2255 case 6:
Michal Vasko004d3152020-06-11 19:59:22 +02002256 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "concat", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002257 min_arg_count = 2;
Radek Krejci1deb5be2020-08-26 16:43:36 +02002258 max_arg_count = UINT32_MAX;
Michal Vasko004d3152020-06-11 19:59:22 +02002259 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "number", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002260 min_arg_count = 0;
2261 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002262 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002263 min_arg_count = 0;
2264 max_arg_count = 1;
2265 }
2266 break;
2267 case 7:
Michal Vasko004d3152020-06-11 19:59:22 +02002268 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "boolean", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002269 min_arg_count = 1;
2270 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002271 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "ceiling", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002272 min_arg_count = 1;
2273 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002274 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "current", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002275 min_arg_count = 0;
2276 max_arg_count = 0;
2277 }
2278 break;
2279 case 8:
Michal Vasko004d3152020-06-11 19:59:22 +02002280 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "contains", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002281 min_arg_count = 2;
2282 max_arg_count = 2;
Michal Vasko004d3152020-06-11 19:59:22 +02002283 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "position", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002284 min_arg_count = 0;
2285 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002286 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "re-match", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002287 min_arg_count = 2;
2288 max_arg_count = 2;
2289 }
2290 break;
2291 case 9:
Michal Vasko004d3152020-06-11 19:59:22 +02002292 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002293 min_arg_count = 2;
2294 max_arg_count = 3;
Michal Vasko004d3152020-06-11 19:59:22 +02002295 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "translate", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002296 min_arg_count = 3;
2297 max_arg_count = 3;
2298 }
2299 break;
2300 case 10:
Michal Vasko004d3152020-06-11 19:59:22 +02002301 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "local-name", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002302 min_arg_count = 0;
2303 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002304 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "enum-value", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002305 min_arg_count = 1;
2306 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002307 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "bit-is-set", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002308 min_arg_count = 2;
2309 max_arg_count = 2;
2310 }
2311 break;
2312 case 11:
Michal Vasko004d3152020-06-11 19:59:22 +02002313 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "starts-with", 11)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002314 min_arg_count = 2;
2315 max_arg_count = 2;
2316 }
2317 break;
2318 case 12:
Michal Vasko004d3152020-06-11 19:59:22 +02002319 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from", 12)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002320 min_arg_count = 2;
2321 max_arg_count = 2;
2322 }
2323 break;
2324 case 13:
Michal Vasko004d3152020-06-11 19:59:22 +02002325 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "namespace-uri", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002326 min_arg_count = 0;
2327 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002328 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string-length", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002329 min_arg_count = 0;
2330 max_arg_count = 1;
2331 }
2332 break;
2333 case 15:
Michal Vasko004d3152020-06-11 19:59:22 +02002334 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "normalize-space", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002335 min_arg_count = 0;
2336 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002337 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-after", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002338 min_arg_count = 2;
2339 max_arg_count = 2;
2340 }
2341 break;
2342 case 16:
Michal Vasko004d3152020-06-11 19:59:22 +02002343 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-before", 16)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002344 min_arg_count = 2;
2345 max_arg_count = 2;
2346 }
2347 break;
2348 case 20:
Michal Vasko004d3152020-06-11 19:59:22 +02002349 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from-or-self", 20)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002350 min_arg_count = 2;
2351 max_arg_count = 2;
2352 }
2353 break;
2354 }
2355 if (min_arg_count == -1) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002356 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 +02002357 return LY_EINVAL;
2358 }
Michal Vasko004d3152020-06-11 19:59:22 +02002359 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002360
2361 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02002362 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002363 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002364 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002365
2366 /* ( Expr ( ',' Expr )* )? */
2367 arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002368 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002369 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002370 if (exp->tokens[*tok_idx] != LYXP_TOKEN_PAR2) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002371 ++arg_count;
aPiecekbf968d92021-05-27 14:35:05 +02002372 rc = reparse_or_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002373 LY_CHECK_RET(rc);
2374 }
Michal Vasko004d3152020-06-11 19:59:22 +02002375 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_COMMA)) {
2376 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002377
2378 ++arg_count;
aPiecekbf968d92021-05-27 14:35:05 +02002379 rc = reparse_or_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002380 LY_CHECK_RET(rc);
2381 }
2382
2383 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02002384 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002385 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002386 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002387
Radek Krejci857189e2020-09-01 13:26:36 +02002388 if ((arg_count < (uint32_t)min_arg_count) || (arg_count > max_arg_count)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002389 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 +02002390 return LY_EVALID;
2391 }
2392
2393 return LY_SUCCESS;
2394}
2395
2396/**
2397 * @brief Reparse PathExpr. Logs directly on error.
2398 *
2399 * [10] PathExpr ::= LocationPath | PrimaryExpr Predicate*
2400 * | PrimaryExpr Predicate* '/' RelativeLocationPath
2401 * | PrimaryExpr Predicate* '//' RelativeLocationPath
2402 * [2] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
aPiecekfba75362021-10-07 12:39:48 +02002403 * [8] PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
Michal Vasko03ff5a72019-09-11 13:49:33 +02002404 *
2405 * @param[in] ctx Context for logging.
2406 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002407 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002408 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002409 * @return LY_ERR
2410 */
2411static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002412reparse_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 +02002413{
2414 LY_ERR rc;
2415
Michal Vasko004d3152020-06-11 19:59:22 +02002416 if (lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko14676352020-05-29 11:35:55 +02002417 return LY_EVALID;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002418 }
2419
Michal Vasko004d3152020-06-11 19:59:22 +02002420 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002421 case LYXP_TOKEN_PAR1:
2422 /* '(' Expr ')' Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002423 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002424
aPiecekbf968d92021-05-27 14:35:05 +02002425 rc = reparse_or_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002426 LY_CHECK_RET(rc);
2427
Michal Vasko004d3152020-06-11 19:59:22 +02002428 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002429 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002430 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002431 goto predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002432 case LYXP_TOKEN_DOT:
2433 case LYXP_TOKEN_DDOT:
Michal Vasko49fec8e2022-05-24 10:28:33 +02002434 case LYXP_TOKEN_AXISNAME:
Michal Vasko03ff5a72019-09-11 13:49:33 +02002435 case LYXP_TOKEN_AT:
2436 case LYXP_TOKEN_NAMETEST:
2437 case LYXP_TOKEN_NODETYPE:
2438 /* RelativeLocationPath */
aPiecekbf968d92021-05-27 14:35:05 +02002439 rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002440 LY_CHECK_RET(rc);
2441 break;
aPiecekfba75362021-10-07 12:39:48 +02002442 case LYXP_TOKEN_VARREF:
2443 /* VariableReference */
2444 ++(*tok_idx);
2445 goto predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002446 case LYXP_TOKEN_FUNCNAME:
2447 /* FunctionCall */
aPiecekbf968d92021-05-27 14:35:05 +02002448 rc = reparse_function_call(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002449 LY_CHECK_RET(rc);
2450 goto predicate;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002451 case LYXP_TOKEN_OPER_PATH:
2452 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +02002453 /* AbsoluteLocationPath */
aPiecekbf968d92021-05-27 14:35:05 +02002454 rc = reparse_absolute_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002455 LY_CHECK_RET(rc);
2456 break;
2457 case LYXP_TOKEN_LITERAL:
2458 /* Literal */
Michal Vasko004d3152020-06-11 19:59:22 +02002459 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002460 goto predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002461 case LYXP_TOKEN_NUMBER:
2462 /* Number */
Michal Vasko004d3152020-06-11 19:59:22 +02002463 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002464 goto predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002465 default:
Michal Vasko49fec8e2022-05-24 10:28:33 +02002466 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 +02002467 return LY_EVALID;
2468 }
2469
2470 return LY_SUCCESS;
2471
2472predicate:
2473 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002474 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
aPiecekbf968d92021-05-27 14:35:05 +02002475 rc = reparse_predicate(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002476 LY_CHECK_RET(rc);
2477 }
2478
2479 /* ('/' or '//') RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02002480 if (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002481
2482 /* '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02002483 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002484
aPiecekbf968d92021-05-27 14:35:05 +02002485 rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002486 LY_CHECK_RET(rc);
2487 }
2488
2489 return LY_SUCCESS;
2490}
2491
2492/**
2493 * @brief Reparse UnaryExpr. Logs directly on error.
2494 *
2495 * [17] UnaryExpr ::= UnionExpr | '-' UnaryExpr
2496 * [18] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
2497 *
2498 * @param[in] ctx Context for logging.
2499 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002500 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002501 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002502 * @return LY_ERR
2503 */
2504static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002505reparse_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 +02002506{
Michal Vaskodd528af2022-08-08 14:35:07 +02002507 uint32_t prev_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002508 LY_ERR rc;
2509
2510 /* ('-')* */
Michal Vasko004d3152020-06-11 19:59:22 +02002511 prev_exp = *tok_idx;
Michal Vasko69730152020-10-09 16:30:07 +02002512 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2513 (exp->expr[exp->tok_pos[*tok_idx]] == '-')) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002514 exp_repeat_push(exp, prev_exp, LYXP_EXPR_UNARY);
Michal Vasko004d3152020-06-11 19:59:22 +02002515 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002516 }
2517
2518 /* PathExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002519 prev_exp = *tok_idx;
aPiecekbf968d92021-05-27 14:35:05 +02002520 rc = reparse_path_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002521 LY_CHECK_RET(rc);
2522
2523 /* ('|' PathExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002524 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_UNI)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002525 exp_repeat_push(exp, prev_exp, LYXP_EXPR_UNION);
Michal Vasko004d3152020-06-11 19:59:22 +02002526 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002527
aPiecekbf968d92021-05-27 14:35:05 +02002528 rc = reparse_path_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002529 LY_CHECK_RET(rc);
2530 }
2531
2532 return LY_SUCCESS;
2533}
2534
2535/**
2536 * @brief Reparse AdditiveExpr. Logs directly on error.
2537 *
2538 * [15] AdditiveExpr ::= MultiplicativeExpr
2539 * | AdditiveExpr '+' MultiplicativeExpr
2540 * | AdditiveExpr '-' MultiplicativeExpr
2541 * [16] MultiplicativeExpr ::= UnaryExpr
2542 * | MultiplicativeExpr '*' UnaryExpr
2543 * | MultiplicativeExpr 'div' UnaryExpr
2544 * | MultiplicativeExpr 'mod' UnaryExpr
2545 *
2546 * @param[in] ctx Context for logging.
2547 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002548 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002549 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002550 * @return LY_ERR
2551 */
2552static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002553reparse_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 +02002554{
Michal Vaskodd528af2022-08-08 14:35:07 +02002555 uint32_t prev_add_exp, prev_mul_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002556 LY_ERR rc;
2557
Michal Vasko004d3152020-06-11 19:59:22 +02002558 prev_add_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002559 goto reparse_multiplicative_expr;
2560
2561 /* ('+' / '-' MultiplicativeExpr)* */
Michal Vasko69730152020-10-09 16:30:07 +02002562 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2563 ((exp->expr[exp->tok_pos[*tok_idx]] == '+') || (exp->expr[exp->tok_pos[*tok_idx]] == '-'))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002564 exp_repeat_push(exp, prev_add_exp, LYXP_EXPR_ADDITIVE);
Michal Vasko004d3152020-06-11 19:59:22 +02002565 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002566
2567reparse_multiplicative_expr:
2568 /* UnaryExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002569 prev_mul_exp = *tok_idx;
aPiecekbf968d92021-05-27 14:35:05 +02002570 rc = reparse_unary_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002571 LY_CHECK_RET(rc);
2572
2573 /* ('*' / 'div' / 'mod' UnaryExpr)* */
Michal Vasko69730152020-10-09 16:30:07 +02002574 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2575 ((exp->expr[exp->tok_pos[*tok_idx]] == '*') || (exp->tok_len[*tok_idx] == 3))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002576 exp_repeat_push(exp, prev_mul_exp, LYXP_EXPR_MULTIPLICATIVE);
Michal Vasko004d3152020-06-11 19:59:22 +02002577 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002578
aPiecekbf968d92021-05-27 14:35:05 +02002579 rc = reparse_unary_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002580 LY_CHECK_RET(rc);
2581 }
2582 }
2583
2584 return LY_SUCCESS;
2585}
2586
2587/**
2588 * @brief Reparse EqualityExpr. Logs directly on error.
2589 *
2590 * [13] EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr
2591 * | EqualityExpr '!=' RelationalExpr
2592 * [14] RelationalExpr ::= AdditiveExpr
2593 * | RelationalExpr '<' AdditiveExpr
2594 * | RelationalExpr '>' AdditiveExpr
2595 * | RelationalExpr '<=' AdditiveExpr
2596 * | RelationalExpr '>=' AdditiveExpr
2597 *
2598 * @param[in] ctx Context for logging.
2599 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002600 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002601 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002602 * @return LY_ERR
2603 */
2604static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002605reparse_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 +02002606{
Michal Vaskodd528af2022-08-08 14:35:07 +02002607 uint32_t prev_eq_exp, prev_rel_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002608 LY_ERR rc;
2609
Michal Vasko004d3152020-06-11 19:59:22 +02002610 prev_eq_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002611 goto reparse_additive_expr;
2612
2613 /* ('=' / '!=' RelationalExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002614 while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_EQUAL, LYXP_TOKEN_OPER_NEQUAL)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002615 exp_repeat_push(exp, prev_eq_exp, LYXP_EXPR_EQUALITY);
Michal Vasko004d3152020-06-11 19:59:22 +02002616 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002617
2618reparse_additive_expr:
2619 /* AdditiveExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002620 prev_rel_exp = *tok_idx;
aPiecekbf968d92021-05-27 14:35:05 +02002621 rc = reparse_additive_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002622 LY_CHECK_RET(rc);
2623
2624 /* ('<' / '>' / '<=' / '>=' AdditiveExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002625 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_COMP)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002626 exp_repeat_push(exp, prev_rel_exp, LYXP_EXPR_RELATIONAL);
Michal Vasko004d3152020-06-11 19:59:22 +02002627 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002628
aPiecekbf968d92021-05-27 14:35:05 +02002629 rc = reparse_additive_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002630 LY_CHECK_RET(rc);
2631 }
2632 }
2633
2634 return LY_SUCCESS;
2635}
2636
2637/**
2638 * @brief Reparse OrExpr. Logs directly on error.
2639 *
2640 * [11] OrExpr ::= AndExpr | OrExpr 'or' AndExpr
2641 * [12] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
2642 *
2643 * @param[in] ctx Context for logging.
2644 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002645 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002646 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002647 * @return LY_ERR
2648 */
2649static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002650reparse_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 +02002651{
Michal Vaskodd528af2022-08-08 14:35:07 +02002652 uint32_t prev_or_exp, prev_and_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002653 LY_ERR rc;
2654
aPiecekbf968d92021-05-27 14:35:05 +02002655 ++depth;
2656 LY_CHECK_ERR_RET(depth > LYXP_MAX_BLOCK_DEPTH, LOGVAL(ctx, LY_VCODE_XP_DEPTH), LY_EINVAL);
2657
Michal Vasko004d3152020-06-11 19:59:22 +02002658 prev_or_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002659 goto reparse_equality_expr;
2660
2661 /* ('or' AndExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002662 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 +02002663 exp_repeat_push(exp, prev_or_exp, LYXP_EXPR_OR);
Michal Vasko004d3152020-06-11 19:59:22 +02002664 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002665
2666reparse_equality_expr:
2667 /* EqualityExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002668 prev_and_exp = *tok_idx;
aPiecekbf968d92021-05-27 14:35:05 +02002669 rc = reparse_equality_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002670 LY_CHECK_RET(rc);
2671
2672 /* ('and' EqualityExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002673 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 +02002674 exp_repeat_push(exp, prev_and_exp, LYXP_EXPR_AND);
Michal Vasko004d3152020-06-11 19:59:22 +02002675 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002676
aPiecekbf968d92021-05-27 14:35:05 +02002677 rc = reparse_equality_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002678 LY_CHECK_RET(rc);
2679 }
2680 }
2681
2682 return LY_SUCCESS;
2683}
Radek Krejcib1646a92018-11-02 16:08:26 +01002684
2685/**
2686 * @brief Parse NCName.
2687 *
2688 * @param[in] ncname Name to parse.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002689 * @return Length of @p ncname valid bytes.
Radek Krejcib1646a92018-11-02 16:08:26 +01002690 */
Michal Vasko49fec8e2022-05-24 10:28:33 +02002691static ssize_t
Radek Krejcib1646a92018-11-02 16:08:26 +01002692parse_ncname(const char *ncname)
2693{
Radek Krejci1deb5be2020-08-26 16:43:36 +02002694 uint32_t uc;
Radek Krejcid4270262019-01-07 15:07:25 +01002695 size_t size;
Michal Vasko49fec8e2022-05-24 10:28:33 +02002696 ssize_t len = 0;
Radek Krejcib1646a92018-11-02 16:08:26 +01002697
2698 LY_CHECK_RET(ly_getutf8(&ncname, &uc, &size), 0);
2699 if (!is_xmlqnamestartchar(uc) || (uc == ':')) {
2700 return len;
2701 }
2702
2703 do {
2704 len += size;
Radek Krejci9a564c92019-01-07 14:53:57 +01002705 if (!*ncname) {
2706 break;
2707 }
Radek Krejcid4270262019-01-07 15:07:25 +01002708 LY_CHECK_RET(ly_getutf8(&ncname, &uc, &size), -len);
Radek Krejcib1646a92018-11-02 16:08:26 +01002709 } while (is_xmlqnamechar(uc) && (uc != ':'));
2710
2711 return len;
2712}
2713
2714/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02002715 * @brief Add @p token into the expression @p exp.
Radek Krejcib1646a92018-11-02 16:08:26 +01002716 *
Michal Vasko03ff5a72019-09-11 13:49:33 +02002717 * @param[in] ctx Context for logging.
Radek Krejcib1646a92018-11-02 16:08:26 +01002718 * @param[in] exp Expression to use.
2719 * @param[in] token Token to add.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002720 * @param[in] tok_pos Token position in the XPath expression.
Radek Krejcib1646a92018-11-02 16:08:26 +01002721 * @param[in] tok_len Token length in the XPath expression.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002722 * @return LY_ERR
Radek Krejcib1646a92018-11-02 16:08:26 +01002723 */
2724static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02002725exp_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 +01002726{
2727 uint32_t prev;
2728
2729 if (exp->used == exp->size) {
2730 prev = exp->size;
2731 exp->size += LYXP_EXPR_SIZE_STEP;
2732 if (prev > exp->size) {
2733 LOGINT(ctx);
2734 return LY_EINT;
2735 }
2736
2737 exp->tokens = ly_realloc(exp->tokens, exp->size * sizeof *exp->tokens);
2738 LY_CHECK_ERR_RET(!exp->tokens, LOGMEM(ctx), LY_EMEM);
2739 exp->tok_pos = ly_realloc(exp->tok_pos, exp->size * sizeof *exp->tok_pos);
2740 LY_CHECK_ERR_RET(!exp->tok_pos, LOGMEM(ctx), LY_EMEM);
2741 exp->tok_len = ly_realloc(exp->tok_len, exp->size * sizeof *exp->tok_len);
2742 LY_CHECK_ERR_RET(!exp->tok_len, LOGMEM(ctx), LY_EMEM);
2743 }
2744
2745 exp->tokens[exp->used] = token;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002746 exp->tok_pos[exp->used] = tok_pos;
Radek Krejcib1646a92018-11-02 16:08:26 +01002747 exp->tok_len[exp->used] = tok_len;
2748 ++exp->used;
2749 return LY_SUCCESS;
2750}
2751
2752void
Michal Vasko14676352020-05-29 11:35:55 +02002753lyxp_expr_free(const struct ly_ctx *ctx, struct lyxp_expr *expr)
Radek Krejcib1646a92018-11-02 16:08:26 +01002754{
Michal Vaskodd528af2022-08-08 14:35:07 +02002755 uint32_t i;
Radek Krejcib1646a92018-11-02 16:08:26 +01002756
2757 if (!expr) {
2758 return;
2759 }
2760
2761 lydict_remove(ctx, expr->expr);
2762 free(expr->tokens);
2763 free(expr->tok_pos);
2764 free(expr->tok_len);
2765 if (expr->repeat) {
2766 for (i = 0; i < expr->used; ++i) {
2767 free(expr->repeat[i]);
2768 }
2769 }
2770 free(expr->repeat);
2771 free(expr);
2772}
2773
Michal Vasko49fec8e2022-05-24 10:28:33 +02002774/**
2775 * @brief Parse Axis name.
2776 *
2777 * @param[in] str String to parse.
2778 * @param[in] str_len Length of @p str.
2779 * @return LY_SUCCESS if an axis.
2780 * @return LY_ENOT otherwise.
2781 */
2782static LY_ERR
2783expr_parse_axis(const char *str, size_t str_len)
2784{
2785 switch (str_len) {
2786 case 4:
2787 if (!strncmp("self", str, str_len)) {
2788 return LY_SUCCESS;
2789 }
2790 break;
2791 case 5:
2792 if (!strncmp("child", str, str_len)) {
2793 return LY_SUCCESS;
2794 }
2795 break;
2796 case 6:
2797 if (!strncmp("parent", str, str_len)) {
2798 return LY_SUCCESS;
2799 }
2800 break;
2801 case 8:
2802 if (!strncmp("ancestor", str, str_len)) {
2803 return LY_SUCCESS;
2804 }
2805 break;
2806 case 9:
2807 if (!strncmp("attribute", str, str_len)) {
2808 return LY_SUCCESS;
2809 } else if (!strncmp("following", str, str_len)) {
2810 return LY_SUCCESS;
2811 } else if (!strncmp("namespace", str, str_len)) {
2812 LOGERR(NULL, LY_EINVAL, "Axis \"namespace\" not supported.");
2813 return LY_ENOT;
2814 } else if (!strncmp("preceding", str, str_len)) {
2815 return LY_SUCCESS;
2816 }
2817 break;
2818 case 10:
2819 if (!strncmp("descendant", str, str_len)) {
2820 return LY_SUCCESS;
2821 }
2822 break;
2823 case 16:
2824 if (!strncmp("ancestor-or-self", str, str_len)) {
2825 return LY_SUCCESS;
2826 }
2827 break;
2828 case 17:
2829 if (!strncmp("following-sibling", str, str_len)) {
2830 return LY_SUCCESS;
2831 } else if (!strncmp("preceding-sibling", str, str_len)) {
2832 return LY_SUCCESS;
2833 }
2834 break;
2835 case 18:
2836 if (!strncmp("descendant-or-self", str, str_len)) {
2837 return LY_SUCCESS;
2838 }
2839 break;
2840 }
2841
2842 return LY_ENOT;
2843}
2844
Radek Krejcif03a9e22020-09-18 20:09:31 +02002845LY_ERR
2846lyxp_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 +01002847{
Radek Krejcif03a9e22020-09-18 20:09:31 +02002848 LY_ERR ret = LY_SUCCESS;
2849 struct lyxp_expr *expr;
Radek Krejcid4270262019-01-07 15:07:25 +01002850 size_t parsed = 0, tok_len;
Radek Krejcib1646a92018-11-02 16:08:26 +01002851 enum lyxp_token tok_type;
Michal Vasko49fec8e2022-05-24 10:28:33 +02002852 ly_bool prev_func_check = 0, prev_ntype_check = 0, has_axis;
Michal Vaskodd528af2022-08-08 14:35:07 +02002853 uint32_t tok_idx = 0;
Michal Vasko49fec8e2022-05-24 10:28:33 +02002854 ssize_t ncname_len;
Radek Krejcib1646a92018-11-02 16:08:26 +01002855
Radek Krejcif03a9e22020-09-18 20:09:31 +02002856 assert(expr_p);
2857
2858 if (!expr_str[0]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002859 LOGVAL(ctx, LY_VCODE_XP_EOF);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002860 return LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +02002861 }
2862
2863 if (!expr_len) {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002864 expr_len = strlen(expr_str);
Michal Vasko004d3152020-06-11 19:59:22 +02002865 }
Michal Vaskodd528af2022-08-08 14:35:07 +02002866 if (expr_len > UINT32_MAX) {
2867 LOGVAL(ctx, LYVE_XPATH, "XPath expression cannot be longer than %" PRIu32 " characters.", UINT32_MAX);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002868 return LY_EVALID;
Radek Krejcib1646a92018-11-02 16:08:26 +01002869 }
2870
2871 /* init lyxp_expr structure */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002872 expr = calloc(1, sizeof *expr);
2873 LY_CHECK_ERR_GOTO(!expr, LOGMEM(ctx); ret = LY_EMEM, error);
2874 LY_CHECK_GOTO(ret = lydict_insert(ctx, expr_str, expr_len, &expr->expr), error);
2875 expr->used = 0;
2876 expr->size = LYXP_EXPR_SIZE_START;
2877 expr->tokens = malloc(expr->size * sizeof *expr->tokens);
2878 LY_CHECK_ERR_GOTO(!expr->tokens, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002879
Radek Krejcif03a9e22020-09-18 20:09:31 +02002880 expr->tok_pos = malloc(expr->size * sizeof *expr->tok_pos);
2881 LY_CHECK_ERR_GOTO(!expr->tok_pos, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002882
Radek Krejcif03a9e22020-09-18 20:09:31 +02002883 expr->tok_len = malloc(expr->size * sizeof *expr->tok_len);
2884 LY_CHECK_ERR_GOTO(!expr->tok_len, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002885
Michal Vasko004d3152020-06-11 19:59:22 +02002886 /* make expr 0-terminated */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002887 expr_str = expr->expr;
Michal Vasko004d3152020-06-11 19:59:22 +02002888
Radek Krejcif03a9e22020-09-18 20:09:31 +02002889 while (is_xmlws(expr_str[parsed])) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002890 ++parsed;
2891 }
2892
2893 do {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002894 if (expr_str[parsed] == '(') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002895
2896 /* '(' */
2897 tok_len = 1;
2898 tok_type = LYXP_TOKEN_PAR1;
2899
Michal Vasko49fec8e2022-05-24 10:28:33 +02002900 if (prev_ntype_check && expr->used && (expr->tokens[expr->used - 1] == LYXP_TOKEN_NAMETEST) &&
2901 (((expr->tok_len[expr->used - 1] == 4) &&
2902 (!strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "node", 4) ||
2903 !strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "text", 4))) ||
2904 ((expr->tok_len[expr->used - 1] == 7) &&
2905 !strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "comment", 7)))) {
2906 /* it is NodeType after all */
2907 expr->tokens[expr->used - 1] = LYXP_TOKEN_NODETYPE;
2908
2909 prev_ntype_check = 0;
2910 prev_func_check = 0;
2911 } else if (prev_func_check && expr->used && (expr->tokens[expr->used - 1] == LYXP_TOKEN_NAMETEST)) {
2912 /* it is FunctionName after all */
2913 expr->tokens[expr->used - 1] = LYXP_TOKEN_FUNCNAME;
2914
2915 prev_ntype_check = 0;
2916 prev_func_check = 0;
Radek Krejcib1646a92018-11-02 16:08:26 +01002917 }
2918
Radek Krejcif03a9e22020-09-18 20:09:31 +02002919 } else if (expr_str[parsed] == ')') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002920
2921 /* ')' */
2922 tok_len = 1;
2923 tok_type = LYXP_TOKEN_PAR2;
2924
Radek Krejcif03a9e22020-09-18 20:09:31 +02002925 } else if (expr_str[parsed] == '[') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002926
2927 /* '[' */
2928 tok_len = 1;
2929 tok_type = LYXP_TOKEN_BRACK1;
2930
Radek Krejcif03a9e22020-09-18 20:09:31 +02002931 } else if (expr_str[parsed] == ']') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002932
2933 /* ']' */
2934 tok_len = 1;
2935 tok_type = LYXP_TOKEN_BRACK2;
2936
Radek Krejcif03a9e22020-09-18 20:09:31 +02002937 } else if (!strncmp(&expr_str[parsed], "..", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002938
2939 /* '..' */
2940 tok_len = 2;
2941 tok_type = LYXP_TOKEN_DDOT;
2942
Radek Krejcif03a9e22020-09-18 20:09:31 +02002943 } else if ((expr_str[parsed] == '.') && (!isdigit(expr_str[parsed + 1]))) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002944
2945 /* '.' */
2946 tok_len = 1;
2947 tok_type = LYXP_TOKEN_DOT;
2948
Radek Krejcif03a9e22020-09-18 20:09:31 +02002949 } else if (expr_str[parsed] == '@') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002950
2951 /* '@' */
2952 tok_len = 1;
2953 tok_type = LYXP_TOKEN_AT;
2954
Radek Krejcif03a9e22020-09-18 20:09:31 +02002955 } else if (expr_str[parsed] == ',') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002956
2957 /* ',' */
2958 tok_len = 1;
2959 tok_type = LYXP_TOKEN_COMMA;
2960
Radek Krejcif03a9e22020-09-18 20:09:31 +02002961 } else if (expr_str[parsed] == '\'') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002962
2963 /* Literal with ' */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002964 for (tok_len = 1; (expr_str[parsed + tok_len] != '\0') && (expr_str[parsed + tok_len] != '\''); ++tok_len) {}
2965 LY_CHECK_ERR_GOTO(expr_str[parsed + tok_len] == '\0',
Radek Krejci2efc45b2020-12-22 16:25:44 +01002966 LOGVAL(ctx, LY_VCODE_XP_EOE, expr_str[parsed], &expr_str[parsed]); ret = LY_EVALID,
Michal Vasko69730152020-10-09 16:30:07 +02002967 error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002968 ++tok_len;
2969 tok_type = LYXP_TOKEN_LITERAL;
2970
Radek Krejcif03a9e22020-09-18 20:09:31 +02002971 } else if (expr_str[parsed] == '\"') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002972
2973 /* Literal with " */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002974 for (tok_len = 1; (expr_str[parsed + tok_len] != '\0') && (expr_str[parsed + tok_len] != '\"'); ++tok_len) {}
2975 LY_CHECK_ERR_GOTO(expr_str[parsed + tok_len] == '\0',
Radek Krejci2efc45b2020-12-22 16:25:44 +01002976 LOGVAL(ctx, LY_VCODE_XP_EOE, expr_str[parsed], &expr_str[parsed]); ret = LY_EVALID,
Michal Vasko69730152020-10-09 16:30:07 +02002977 error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002978 ++tok_len;
2979 tok_type = LYXP_TOKEN_LITERAL;
2980
Radek Krejcif03a9e22020-09-18 20:09:31 +02002981 } else if ((expr_str[parsed] == '.') || (isdigit(expr_str[parsed]))) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002982
2983 /* Number */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002984 for (tok_len = 0; isdigit(expr_str[parsed + tok_len]); ++tok_len) {}
2985 if (expr_str[parsed + tok_len] == '.') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002986 ++tok_len;
Radek Krejcif03a9e22020-09-18 20:09:31 +02002987 for ( ; isdigit(expr_str[parsed + tok_len]); ++tok_len) {}
Radek Krejcib1646a92018-11-02 16:08:26 +01002988 }
2989 tok_type = LYXP_TOKEN_NUMBER;
2990
aPiecekfba75362021-10-07 12:39:48 +02002991 } else if (expr_str[parsed] == '$') {
2992
2993 /* VariableReference */
2994 parsed++;
Michal Vasko49fec8e2022-05-24 10:28:33 +02002995 ncname_len = parse_ncname(&expr_str[parsed]);
aPiecekfba75362021-10-07 12:39:48 +02002996 LY_CHECK_ERR_GOTO(ncname_len < 1, LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed - ncname_len],
2997 parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
2998 tok_len = ncname_len;
2999 LY_CHECK_ERR_GOTO(expr_str[parsed + tok_len] == ':',
3000 LOGVAL(ctx, LYVE_XPATH, "Variable with prefix is not supported."); ret = LY_EVALID,
3001 error);
3002 tok_type = LYXP_TOKEN_VARREF;
3003
Radek Krejcif03a9e22020-09-18 20:09:31 +02003004 } else if (expr_str[parsed] == '/') {
Radek Krejcib1646a92018-11-02 16:08:26 +01003005
3006 /* Operator '/', '//' */
Radek Krejcif03a9e22020-09-18 20:09:31 +02003007 if (!strncmp(&expr_str[parsed], "//", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003008 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003009 tok_type = LYXP_TOKEN_OPER_RPATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01003010 } else {
3011 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003012 tok_type = LYXP_TOKEN_OPER_PATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01003013 }
Radek Krejcib1646a92018-11-02 16:08:26 +01003014
Radek Krejcif03a9e22020-09-18 20:09:31 +02003015 } else if (!strncmp(&expr_str[parsed], "!=", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003016
Michal Vasko3e48bf32020-06-01 08:39:07 +02003017 /* Operator '!=' */
Radek Krejcib1646a92018-11-02 16:08:26 +01003018 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003019 tok_type = LYXP_TOKEN_OPER_NEQUAL;
3020
Radek Krejcif03a9e22020-09-18 20:09:31 +02003021 } else if (!strncmp(&expr_str[parsed], "<=", 2) || !strncmp(&expr_str[parsed], ">=", 2)) {
Michal Vasko3e48bf32020-06-01 08:39:07 +02003022
3023 /* Operator '<=', '>=' */
3024 tok_len = 2;
3025 tok_type = LYXP_TOKEN_OPER_COMP;
Radek Krejcib1646a92018-11-02 16:08:26 +01003026
Radek Krejcif03a9e22020-09-18 20:09:31 +02003027 } else if (expr_str[parsed] == '|') {
Radek Krejcib1646a92018-11-02 16:08:26 +01003028
3029 /* Operator '|' */
3030 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003031 tok_type = LYXP_TOKEN_OPER_UNI;
Radek Krejcib1646a92018-11-02 16:08:26 +01003032
Radek Krejcif03a9e22020-09-18 20:09:31 +02003033 } else if ((expr_str[parsed] == '+') || (expr_str[parsed] == '-')) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003034
3035 /* Operator '+', '-' */
3036 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003037 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01003038
Radek Krejcif03a9e22020-09-18 20:09:31 +02003039 } else if (expr_str[parsed] == '=') {
Radek Krejcib1646a92018-11-02 16:08:26 +01003040
Michal Vasko3e48bf32020-06-01 08:39:07 +02003041 /* Operator '=' */
Radek Krejcib1646a92018-11-02 16:08:26 +01003042 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003043 tok_type = LYXP_TOKEN_OPER_EQUAL;
3044
Radek Krejcif03a9e22020-09-18 20:09:31 +02003045 } else if ((expr_str[parsed] == '<') || (expr_str[parsed] == '>')) {
Michal Vasko3e48bf32020-06-01 08:39:07 +02003046
3047 /* Operator '<', '>' */
3048 tok_len = 1;
3049 tok_type = LYXP_TOKEN_OPER_COMP;
Radek Krejcib1646a92018-11-02 16:08:26 +01003050
Michal Vasko69730152020-10-09 16:30:07 +02003051 } else if (expr->used && (expr->tokens[expr->used - 1] != LYXP_TOKEN_AT) &&
3052 (expr->tokens[expr->used - 1] != LYXP_TOKEN_PAR1) &&
3053 (expr->tokens[expr->used - 1] != LYXP_TOKEN_BRACK1) &&
3054 (expr->tokens[expr->used - 1] != LYXP_TOKEN_COMMA) &&
3055 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_LOG) &&
3056 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_EQUAL) &&
3057 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_NEQUAL) &&
3058 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_COMP) &&
3059 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_MATH) &&
3060 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_UNI) &&
3061 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_PATH) &&
3062 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_RPATH)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003063
3064 /* Operator '*', 'or', 'and', 'mod', or 'div' */
Radek Krejcif03a9e22020-09-18 20:09:31 +02003065 if (expr_str[parsed] == '*') {
Radek Krejcib1646a92018-11-02 16:08:26 +01003066 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003067 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01003068
Radek Krejcif03a9e22020-09-18 20:09:31 +02003069 } else if (!strncmp(&expr_str[parsed], "or", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003070 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003071 tok_type = LYXP_TOKEN_OPER_LOG;
Radek Krejcib1646a92018-11-02 16:08:26 +01003072
Radek Krejcif03a9e22020-09-18 20:09:31 +02003073 } else if (!strncmp(&expr_str[parsed], "and", 3)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003074 tok_len = 3;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003075 tok_type = LYXP_TOKEN_OPER_LOG;
Radek Krejcib1646a92018-11-02 16:08:26 +01003076
Radek Krejcif03a9e22020-09-18 20:09:31 +02003077 } else if (!strncmp(&expr_str[parsed], "mod", 3) || !strncmp(&expr_str[parsed], "div", 3)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003078 tok_len = 3;
Michal Vasko3e48bf32020-06-01 08:39:07 +02003079 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01003080
Michal Vasko49fec8e2022-05-24 10:28:33 +02003081 } else if (prev_ntype_check || prev_func_check) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003082 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 +02003083 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 +02003084 ret = LY_EVALID;
Radek Krejcib1646a92018-11-02 16:08:26 +01003085 goto error;
3086 } else {
Michal Vasko774ce402021-04-14 15:35:06 +02003087 LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed], parsed + 1, expr_str);
Radek Krejcif03a9e22020-09-18 20:09:31 +02003088 ret = LY_EVALID;
Radek Krejcib1646a92018-11-02 16:08:26 +01003089 goto error;
3090 }
Radek Krejcib1646a92018-11-02 16:08:26 +01003091 } else {
3092
Michal Vasko49fec8e2022-05-24 10:28:33 +02003093 /* (AxisName '::')? ((NCName ':')? '*' | QName) or NodeType/FunctionName */
3094 if (expr_str[parsed] == '*') {
3095 ncname_len = 1;
3096 } else {
3097 ncname_len = parse_ncname(&expr_str[parsed]);
3098 LY_CHECK_ERR_GOTO(ncname_len < 1, LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed - ncname_len],
3099 parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
3100 }
Radek Krejcib1646a92018-11-02 16:08:26 +01003101 tok_len = ncname_len;
3102
Michal Vasko49fec8e2022-05-24 10:28:33 +02003103 has_axis = 0;
3104 if (!strncmp(&expr_str[parsed + tok_len], "::", 2)) {
3105 /* axis */
3106 LY_CHECK_ERR_GOTO(expr_parse_axis(&expr_str[parsed], ncname_len),
3107 LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed], parsed + 1, expr_str); ret = LY_EVALID, error);
3108 tok_type = LYXP_TOKEN_AXISNAME;
3109
3110 LY_CHECK_GOTO(ret = exp_add_token(ctx, expr, tok_type, parsed, tok_len), error);
3111 parsed += tok_len;
3112
3113 /* '::' */
3114 tok_len = 2;
3115 tok_type = LYXP_TOKEN_DCOLON;
3116
3117 LY_CHECK_GOTO(ret = exp_add_token(ctx, expr, tok_type, parsed, tok_len), error);
3118 parsed += tok_len;
3119
3120 if (expr_str[parsed] == '*') {
3121 ncname_len = 1;
3122 } else {
3123 ncname_len = parse_ncname(&expr_str[parsed]);
3124 LY_CHECK_ERR_GOTO(ncname_len < 1, LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed - ncname_len],
3125 parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
3126 }
3127 tok_len = ncname_len;
3128
3129 has_axis = 1;
3130 }
3131
Radek Krejcif03a9e22020-09-18 20:09:31 +02003132 if (expr_str[parsed + tok_len] == ':') {
Radek Krejcib1646a92018-11-02 16:08:26 +01003133 ++tok_len;
Radek Krejcif03a9e22020-09-18 20:09:31 +02003134 if (expr_str[parsed + tok_len] == '*') {
Radek Krejcib1646a92018-11-02 16:08:26 +01003135 ++tok_len;
3136 } else {
Radek Krejcif03a9e22020-09-18 20:09:31 +02003137 ncname_len = parse_ncname(&expr_str[parsed + tok_len]);
Michal Vaskoe2be5462021-08-04 10:49:42 +02003138 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 +02003139 parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01003140 tok_len += ncname_len;
3141 }
Michal Vasko49fec8e2022-05-24 10:28:33 +02003142 /* remove old flags to prevent ambiguities */
3143 prev_ntype_check = 0;
3144 prev_func_check = 0;
Radek Krejcib1646a92018-11-02 16:08:26 +01003145 tok_type = LYXP_TOKEN_NAMETEST;
3146 } else {
Michal Vasko49fec8e2022-05-24 10:28:33 +02003147 /* if not '*', there is no prefix so it can still be NodeType/FunctionName, we can't finally decide now */
3148 prev_ntype_check = (expr_str[parsed] == '*') ? 0 : 1;
3149 prev_func_check = (prev_ntype_check && !has_axis) ? 1 : 0;
Radek Krejcib1646a92018-11-02 16:08:26 +01003150 tok_type = LYXP_TOKEN_NAMETEST;
3151 }
3152 }
3153
3154 /* store the token, move on to the next one */
Radek Krejcif03a9e22020-09-18 20:09:31 +02003155 LY_CHECK_GOTO(ret = exp_add_token(ctx, expr, tok_type, parsed, tok_len), error);
Radek Krejcib1646a92018-11-02 16:08:26 +01003156 parsed += tok_len;
Radek Krejcif03a9e22020-09-18 20:09:31 +02003157 while (is_xmlws(expr_str[parsed])) {
Radek Krejcib1646a92018-11-02 16:08:26 +01003158 ++parsed;
3159 }
3160
Radek Krejcif03a9e22020-09-18 20:09:31 +02003161 } while (expr_str[parsed]);
Radek Krejcib1646a92018-11-02 16:08:26 +01003162
Michal Vasko004d3152020-06-11 19:59:22 +02003163 if (reparse) {
3164 /* prealloc repeat */
Radek Krejcif03a9e22020-09-18 20:09:31 +02003165 expr->repeat = calloc(expr->size, sizeof *expr->repeat);
3166 LY_CHECK_ERR_GOTO(!expr->repeat, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01003167
Michal Vasko004d3152020-06-11 19:59:22 +02003168 /* fill repeat */
aPiecekbf968d92021-05-27 14:35:05 +02003169 LY_CHECK_ERR_GOTO(reparse_or_expr(ctx, expr, &tok_idx, 0), ret = LY_EVALID, error);
Radek Krejcif03a9e22020-09-18 20:09:31 +02003170 if (expr->used > tok_idx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003171 LOGVAL(ctx, LYVE_XPATH, "Unparsed characters \"%s\" left at the end of an XPath expression.",
Michal Vasko69730152020-10-09 16:30:07 +02003172 &expr->expr[expr->tok_pos[tok_idx]]);
Radek Krejcif03a9e22020-09-18 20:09:31 +02003173 ret = LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +02003174 goto error;
3175 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003176 }
3177
Radek Krejcif03a9e22020-09-18 20:09:31 +02003178 print_expr_struct_debug(expr);
3179 *expr_p = expr;
3180 return LY_SUCCESS;
Radek Krejcib1646a92018-11-02 16:08:26 +01003181
3182error:
Radek Krejcif03a9e22020-09-18 20:09:31 +02003183 lyxp_expr_free(ctx, expr);
3184 return ret;
Radek Krejcib1646a92018-11-02 16:08:26 +01003185}
3186
Michal Vasko1734be92020-09-22 08:55:10 +02003187LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02003188lyxp_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 +02003189 struct lyxp_expr **dup_p)
Michal Vasko004d3152020-06-11 19:59:22 +02003190{
Michal Vasko1734be92020-09-22 08:55:10 +02003191 LY_ERR ret = LY_SUCCESS;
3192 struct lyxp_expr *dup = NULL;
Michal Vaskod59039d2022-09-09 09:07:30 +02003193 uint32_t used = 0, i, j, expr_len;
Michal Vaskoe33134a2022-07-29 14:54:40 +02003194 const char *expr_start;
3195
3196 assert((!start_idx && !end_idx) || ((start_idx < exp->used) && (end_idx < exp->used) && (start_idx <= end_idx)));
Michal Vasko004d3152020-06-11 19:59:22 +02003197
Michal Vasko7f45cf22020-10-01 12:49:44 +02003198 if (!exp) {
3199 goto cleanup;
3200 }
3201
Michal Vaskoe33134a2022-07-29 14:54:40 +02003202 if (!start_idx && !end_idx) {
3203 end_idx = exp->used - 1;
3204 }
3205
3206 expr_start = exp->expr + exp->tok_pos[start_idx];
3207 expr_len = (exp->tok_pos[end_idx] + exp->tok_len[end_idx]) - exp->tok_pos[start_idx];
3208
Michal Vasko004d3152020-06-11 19:59:22 +02003209 dup = calloc(1, sizeof *dup);
Michal Vasko1734be92020-09-22 08:55:10 +02003210 LY_CHECK_ERR_GOTO(!dup, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02003211
Michal Vasko08e9b112021-06-11 15:41:17 +02003212 if (exp->used) {
Michal Vaskoe33134a2022-07-29 14:54:40 +02003213 used = (end_idx - start_idx) + 1;
3214
3215 dup->tokens = malloc(used * sizeof *dup->tokens);
Michal Vasko08e9b112021-06-11 15:41:17 +02003216 LY_CHECK_ERR_GOTO(!dup->tokens, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vaskoe33134a2022-07-29 14:54:40 +02003217 memcpy(dup->tokens, exp->tokens + start_idx, used * sizeof *dup->tokens);
Michal Vasko004d3152020-06-11 19:59:22 +02003218
Michal Vaskoe33134a2022-07-29 14:54:40 +02003219 dup->tok_pos = malloc(used * sizeof *dup->tok_pos);
Michal Vasko08e9b112021-06-11 15:41:17 +02003220 LY_CHECK_ERR_GOTO(!dup->tok_pos, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vaskoe33134a2022-07-29 14:54:40 +02003221 memcpy(dup->tok_pos, exp->tok_pos + start_idx, used * sizeof *dup->tok_pos);
Michal Vasko004d3152020-06-11 19:59:22 +02003222
Michal Vaskoe33134a2022-07-29 14:54:40 +02003223 if (start_idx) {
3224 /* fix the indices in the expression */
3225 for (i = 0; i < used; ++i) {
3226 dup->tok_pos[i] -= expr_start - exp->expr;
3227 }
3228 }
3229
3230 dup->tok_len = malloc(used * sizeof *dup->tok_len);
Michal Vasko08e9b112021-06-11 15:41:17 +02003231 LY_CHECK_ERR_GOTO(!dup->tok_len, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vaskoe33134a2022-07-29 14:54:40 +02003232 memcpy(dup->tok_len, exp->tok_len + start_idx, used * sizeof *dup->tok_len);
Michal Vasko004d3152020-06-11 19:59:22 +02003233
Michal Vasko79a7a872022-06-17 09:00:48 +02003234 if (exp->repeat) {
Michal Vaskoe33134a2022-07-29 14:54:40 +02003235 dup->repeat = malloc(used * sizeof *dup->repeat);
Michal Vasko79a7a872022-06-17 09:00:48 +02003236 LY_CHECK_ERR_GOTO(!dup->repeat, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vaskoe33134a2022-07-29 14:54:40 +02003237 for (i = start_idx; i <= end_idx; ++i) {
Michal Vasko79a7a872022-06-17 09:00:48 +02003238 if (!exp->repeat[i]) {
Michal Vaskoe33134a2022-07-29 14:54:40 +02003239 dup->repeat[i - start_idx] = NULL;
Michal Vasko79a7a872022-06-17 09:00:48 +02003240 } else {
3241 for (j = 0; exp->repeat[i][j]; ++j) {}
3242 /* the ending 0 as well */
3243 ++j;
Michal Vasko004d3152020-06-11 19:59:22 +02003244
Michal Vaskoe33134a2022-07-29 14:54:40 +02003245 dup->repeat[i - start_idx] = malloc(j * sizeof **dup->repeat);
3246 LY_CHECK_ERR_GOTO(!dup->repeat[i - start_idx], LOGMEM(ctx); ret = LY_EMEM, cleanup);
3247 memcpy(dup->repeat[i - start_idx], exp->repeat[i], j * sizeof **dup->repeat);
Michal Vasko79a7a872022-06-17 09:00:48 +02003248 }
Michal Vasko08e9b112021-06-11 15:41:17 +02003249 }
Michal Vasko004d3152020-06-11 19:59:22 +02003250 }
3251 }
3252
Michal Vaskoe33134a2022-07-29 14:54:40 +02003253 dup->used = used;
3254 dup->size = used;
3255
3256 /* copy only subexpression */
3257 LY_CHECK_GOTO(ret = lydict_insert(ctx, expr_start, expr_len, &dup->expr), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02003258
Michal Vasko1734be92020-09-22 08:55:10 +02003259cleanup:
3260 if (ret) {
3261 lyxp_expr_free(ctx, dup);
3262 } else {
3263 *dup_p = dup;
3264 }
3265 return ret;
Michal Vasko004d3152020-06-11 19:59:22 +02003266}
3267
Michal Vasko03ff5a72019-09-11 13:49:33 +02003268/**
3269 * @brief Get the last-added schema node that is currently in the context.
3270 *
3271 * @param[in] set Set to search in.
3272 * @return Last-added schema context node, NULL if no node is in context.
3273 */
3274static struct lysc_node *
3275warn_get_scnode_in_ctx(struct lyxp_set *set)
3276{
3277 uint32_t i;
3278
3279 if (!set || (set->type != LYXP_SET_SCNODE_SET)) {
3280 return NULL;
3281 }
3282
3283 i = set->used;
3284 do {
3285 --i;
Radek Krejcif13b87b2020-12-01 22:02:17 +01003286 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003287 /* if there are more, simply return the first found (last added) */
3288 return set->val.scnodes[i].scnode;
3289 }
3290 } while (i);
3291
3292 return NULL;
3293}
3294
3295/**
3296 * @brief Test whether a type is numeric - integer type or decimal64.
3297 *
3298 * @param[in] type Type to test.
Radek Krejci857189e2020-09-01 13:26:36 +02003299 * @return Boolean value whether @p type is numeric type or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003300 */
Radek Krejci857189e2020-09-01 13:26:36 +02003301static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003302warn_is_numeric_type(struct lysc_type *type)
3303{
3304 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003305 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003306 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003307
3308 switch (type->basetype) {
3309 case LY_TYPE_DEC64:
3310 case LY_TYPE_INT8:
3311 case LY_TYPE_UINT8:
3312 case LY_TYPE_INT16:
3313 case LY_TYPE_UINT16:
3314 case LY_TYPE_INT32:
3315 case LY_TYPE_UINT32:
3316 case LY_TYPE_INT64:
3317 case LY_TYPE_UINT64:
3318 return 1;
3319 case LY_TYPE_UNION:
3320 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003321 LY_ARRAY_FOR(uni->types, u) {
3322 ret = warn_is_numeric_type(uni->types[u]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003323 if (ret) {
3324 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003325 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003326 }
3327 }
3328 /* did not find any suitable type */
3329 return 0;
3330 case LY_TYPE_LEAFREF:
3331 return warn_is_numeric_type(((struct lysc_type_leafref *)type)->realtype);
3332 default:
3333 return 0;
3334 }
3335}
3336
3337/**
3338 * @brief Test whether a type is string-like - no integers, decimal64 or binary.
3339 *
3340 * @param[in] type Type to test.
Radek Krejci857189e2020-09-01 13:26:36 +02003341 * @return Boolean value whether @p type's basetype is string type or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003342 */
Radek Krejci857189e2020-09-01 13:26:36 +02003343static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003344warn_is_string_type(struct lysc_type *type)
3345{
3346 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003347 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003348 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003349
3350 switch (type->basetype) {
3351 case LY_TYPE_BITS:
3352 case LY_TYPE_ENUM:
3353 case LY_TYPE_IDENT:
3354 case LY_TYPE_INST:
3355 case LY_TYPE_STRING:
3356 return 1;
3357 case LY_TYPE_UNION:
3358 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003359 LY_ARRAY_FOR(uni->types, u) {
3360 ret = warn_is_string_type(uni->types[u]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003361 if (ret) {
3362 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003363 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003364 }
3365 }
3366 /* did not find any suitable type */
3367 return 0;
3368 case LY_TYPE_LEAFREF:
3369 return warn_is_string_type(((struct lysc_type_leafref *)type)->realtype);
3370 default:
3371 return 0;
3372 }
3373}
3374
3375/**
3376 * @brief Test whether a type is one specific type.
3377 *
3378 * @param[in] type Type to test.
3379 * @param[in] base Expected type.
Radek Krejci857189e2020-09-01 13:26:36 +02003380 * @return Boolean value whether the given @p type is of the specific basetype @p base.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003381 */
Radek Krejci857189e2020-09-01 13:26:36 +02003382static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003383warn_is_specific_type(struct lysc_type *type, LY_DATA_TYPE base)
3384{
3385 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003386 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003387 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003388
3389 if (type->basetype == base) {
3390 return 1;
3391 } else if (type->basetype == LY_TYPE_UNION) {
3392 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003393 LY_ARRAY_FOR(uni->types, u) {
3394 ret = warn_is_specific_type(uni->types[u], base);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003395 if (ret) {
3396 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003397 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003398 }
3399 }
3400 /* did not find any suitable type */
3401 return 0;
3402 } else if (type->basetype == LY_TYPE_LEAFREF) {
3403 return warn_is_specific_type(((struct lysc_type_leafref *)type)->realtype, base);
3404 }
3405
3406 return 0;
3407}
3408
3409/**
3410 * @brief Get next type of a (union) type.
3411 *
3412 * @param[in] type Base type.
3413 * @param[in] prev_type Previously returned type.
3414 * @return Next type or NULL.
3415 */
3416static struct lysc_type *
3417warn_is_equal_type_next_type(struct lysc_type *type, struct lysc_type *prev_type)
3418{
3419 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003420 ly_bool found = 0;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003421 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003422
Michal Vasko4e55f5a2022-12-14 12:15:00 +01003423 if (type->basetype == LY_TYPE_UNION) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003424 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;
Michal Vasko4e55f5a2022-12-14 12:15:00 +01003437 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003438 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 Vasko1a2b8ee2022-12-05 10:41:55 +01004027 LOGERR(set->ctx, LY_EVALID, "%s", 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 Vasko6d657122022-10-19 14:38:35 +02005715 /* when check, accept the context node because it should only be the path ".", we have checked the when is valid before */
5716 if (!(options & LYXP_IGNORE_WHEN) && lysc_has_when(node->schema) && !(node->flags & LYD_WHEN_TRUE) &&
5717 (node != set->cur_node)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005718 return LY_EINCOMPLETE;
Michal Vaskoa1424542019-11-14 16:08:52 +01005719 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005720
5721 /* match */
5722 return LY_SUCCESS;
5723}
5724
5725/**
Michal Vasko49fec8e2022-05-24 10:28:33 +02005726 * @brief Get the next node in a forward DFS.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005727 *
Michal Vasko49fec8e2022-05-24 10:28:33 +02005728 * @param[in] iter Last returned node.
5729 * @param[in] stop Node to stop the search on and not return.
5730 * @return Next node, NULL if there are no more.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005731 */
Michal Vasko49fec8e2022-05-24 10:28:33 +02005732static const struct lyd_node *
5733moveto_axis_node_next_dfs_forward(const struct lyd_node *iter, const struct lyd_node *stop)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005734{
Michal Vasko49fec8e2022-05-24 10:28:33 +02005735 const struct lyd_node *next = NULL;
5736
5737 /* 1) child */
5738 next = lyd_child(iter);
5739 if (!next) {
5740 if (iter == stop) {
5741 /* reached stop, no more descendants */
5742 return NULL;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005743 }
Michal Vasko49fec8e2022-05-24 10:28:33 +02005744 /* 2) child next sibling */
5745 next = iter->next;
5746 }
5747 while (!next) {
5748 iter = lyd_parent(iter);
5749 if ((!stop && !iter) || (stop && (lyd_parent(iter) == lyd_parent(stop)))) {
5750 return NULL;
5751 }
5752 next = iter->next;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005753 }
5754
Michal Vasko49fec8e2022-05-24 10:28:33 +02005755 return next;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005756}
5757
5758/**
Michal Vasko49fec8e2022-05-24 10:28:33 +02005759 * @brief Get the next node in a backward DFS.
5760 *
5761 * @param[in] iter Last returned node.
5762 * @param[in] stop Node to stop the search on and not return.
5763 * @return Next node, NULL if there are no more.
5764 */
5765static const struct lyd_node *
5766moveto_axis_node_next_dfs_backward(const struct lyd_node *iter, const struct lyd_node *stop)
5767{
5768 const struct lyd_node *next = NULL;
5769
5770 /* 1) previous sibling innermost last child */
5771 next = iter->prev->next ? iter->prev : NULL;
5772 while (next && lyd_child(next)) {
5773 next = lyd_child(next);
5774 next = next->prev;
5775 }
5776
5777 if (!next) {
5778 /* 2) parent */
5779 iter = lyd_parent(iter);
5780 if ((!stop && !iter) || (stop && (lyd_parent(iter) == lyd_parent(stop)))) {
5781 return NULL;
5782 }
5783 next = iter;
5784 }
5785
5786 return next;
5787}
5788
5789/**
5790 * @brief Get the first node on an axis for a context node.
5791 *
5792 * @param[in,out] iter NULL, updated to the next node.
5793 * @param[in,out] iter_type Node type 0 of @p iter, updated to the node type of the next node.
5794 * @param[in] node Context node.
5795 * @param[in] node_type Type of @p node.
5796 * @param[in] axis Axis to use.
5797 * @param[in] set XPath set with the general context.
5798 * @return LY_SUCCESS on success.
5799 * @return LY_ENOTFOUND if no next node found.
5800 */
5801static LY_ERR
5802moveto_axis_node_next_first(const struct lyd_node **iter, enum lyxp_node_type *iter_type, const struct lyd_node *node,
5803 enum lyxp_node_type node_type, enum lyxp_axis axis, struct lyxp_set *set)
5804{
5805 const struct lyd_node *next = NULL;
5806 enum lyxp_node_type next_type = 0;
5807
5808 assert(!*iter);
5809 assert(!*iter_type);
5810
5811 switch (axis) {
5812 case LYXP_AXIS_ANCESTOR_OR_SELF:
5813 case LYXP_AXIS_DESCENDANT_OR_SELF:
5814 case LYXP_AXIS_SELF:
5815 /* return the context node */
5816 next = node;
5817 next_type = node_type;
5818 break;
5819
5820 case LYXP_AXIS_ANCESTOR:
5821 case LYXP_AXIS_PARENT:
5822 if (node_type == LYXP_NODE_ELEM) {
5823 next = lyd_parent(node);
5824 next_type = next ? LYXP_NODE_ELEM : set->root_type;
5825 } else if (node_type == LYXP_NODE_TEXT) {
5826 next = node;
5827 next_type = LYXP_NODE_ELEM;
5828 } else if (node_type == LYXP_NODE_META) {
5829 next = ((struct lyd_meta *)node)->parent;
5830 next_type = LYXP_NODE_ELEM;
5831 } /* else root does not have a parent */
5832 break;
5833
5834 case LYXP_AXIS_CHILD:
5835 if ((node_type == LYXP_NODE_ROOT_CONFIG) || (node_type == LYXP_NODE_ROOT)) {
5836 assert(!node);
5837
5838 /* search in all the trees */
5839 next = set->tree;
5840 next_type = next ? LYXP_NODE_ELEM : 0;
5841 } else {
5842 /* search in children */
5843 next = lyd_child(node);
5844 next_type = next ? LYXP_NODE_ELEM : 0;
5845 }
5846 break;
5847
5848 case LYXP_AXIS_DESCENDANT:
5849 if ((node_type == LYXP_NODE_ROOT_CONFIG) || (node_type == LYXP_NODE_ROOT)) {
5850 /* top-level nodes */
5851 next = set->tree;
5852 next_type = LYXP_NODE_ELEM;
5853 } else if (node_type == LYXP_NODE_ELEM) {
5854 /* start from the context node */
5855 next = moveto_axis_node_next_dfs_forward(node, node);
5856 next_type = next ? LYXP_NODE_ELEM : 0;
5857 } /* else no children */
5858 break;
5859
5860 case LYXP_AXIS_FOLLOWING:
5861 case LYXP_AXIS_FOLLOWING_SIBLING:
5862 if (node_type == LYXP_NODE_ELEM) {
5863 /* first next sibling */
5864 next = node->next;
5865 next_type = next ? LYXP_NODE_ELEM : 0;
5866 } /* else no sibling */
5867 break;
5868
5869 case LYXP_AXIS_PRECEDING:
5870 if ((node_type == LYXP_NODE_ELEM) && node->prev->next) {
5871 /* skip ancestors */
5872 next = moveto_axis_node_next_dfs_backward(node, NULL);
5873 assert(next);
5874 next_type = LYXP_NODE_ELEM;
5875 } /* else no sibling */
5876 break;
5877
5878 case LYXP_AXIS_PRECEDING_SIBLING:
5879 if (node_type == LYXP_NODE_ELEM) {
5880 /* first previous sibling */
5881 next = node->prev->next ? node->prev : NULL;
5882 next_type = next ? LYXP_NODE_ELEM : 0;
5883 } /* else no sibling */
5884 break;
5885
5886 case LYXP_AXIS_ATTRIBUTE:
5887 /* handled specially */
5888 assert(0);
5889 LOGINT(set->ctx);
5890 break;
5891 }
5892
5893 *iter = next;
5894 *iter_type = next_type;
5895 return next_type ? LY_SUCCESS : LY_ENOTFOUND;
5896}
5897
5898/**
5899 * @brief Iterate over all nodes on an axis for a context node.
5900 *
5901 * @param[in,out] iter Last returned node, start with NULL, updated to the next node.
5902 * @param[in,out] iter_type Node type of @p iter, start with 0, updated to the node type of the next node.
5903 * @param[in] node Context node.
5904 * @param[in] node_type Type of @p node.
5905 * @param[in] axis Axis to use.
5906 * @param[in] set XPath set with the general context.
5907 * @return LY_SUCCESS on success.
5908 * @return LY_ENOTFOUND if no next node found.
5909 */
5910static LY_ERR
5911moveto_axis_node_next(const struct lyd_node **iter, enum lyxp_node_type *iter_type, const struct lyd_node *node,
5912 enum lyxp_node_type node_type, enum lyxp_axis axis, struct lyxp_set *set)
5913{
5914 const struct lyd_node *next = NULL;
5915 enum lyxp_node_type next_type = 0;
5916
5917 if (!*iter_type) {
5918 /* first returned node */
5919 return moveto_axis_node_next_first(iter, iter_type, node, node_type, axis, set);
5920 }
5921
5922 switch (axis) {
5923 case LYXP_AXIS_ANCESTOR_OR_SELF:
5924 if ((*iter == node) && (*iter_type == node_type)) {
5925 /* fake first ancestor, we returned self before */
5926 *iter = NULL;
5927 *iter_type = 0;
5928 return moveto_axis_node_next_first(iter, iter_type, node, node_type, LYXP_AXIS_ANCESTOR, set);
5929 } /* else continue ancestor */
5930
5931 /* fallthrough */
5932 case LYXP_AXIS_ANCESTOR:
5933 if (*iter_type == LYXP_NODE_ELEM) {
5934 /* iter parent */
5935 next = lyd_parent(*iter);
5936 next_type = next ? LYXP_NODE_ELEM : set->root_type;
5937 } /* else root, no ancestors */
5938 break;
5939
5940 case LYXP_AXIS_CHILD:
5941 assert(*iter_type == LYXP_NODE_ELEM);
5942
5943 /* next sibling (child) */
5944 next = (*iter)->next;
5945 next_type = next ? LYXP_NODE_ELEM : 0;
5946 break;
5947
5948 case LYXP_AXIS_DESCENDANT_OR_SELF:
5949 if ((*iter == node) && (*iter_type == node_type)) {
5950 /* fake first descendant, we returned self before */
5951 *iter = NULL;
5952 *iter_type = 0;
5953 return moveto_axis_node_next_first(iter, iter_type, node, node_type, LYXP_AXIS_DESCENDANT, set);
5954 } /* else continue descendant */
5955
5956 /* fallthrough */
5957 case LYXP_AXIS_DESCENDANT:
5958 assert(*iter_type == LYXP_NODE_ELEM);
5959 next = moveto_axis_node_next_dfs_forward(*iter, node);
5960 next_type = next ? LYXP_NODE_ELEM : 0;
5961 break;
5962
5963 case LYXP_AXIS_FOLLOWING:
5964 assert(*iter_type == LYXP_NODE_ELEM);
5965 next = moveto_axis_node_next_dfs_forward(*iter, NULL);
5966 next_type = next ? LYXP_NODE_ELEM : 0;
5967 break;
5968
5969 case LYXP_AXIS_FOLLOWING_SIBLING:
5970 assert(*iter_type == LYXP_NODE_ELEM);
5971
5972 /* next sibling */
5973 next = (*iter)->next;
5974 next_type = next ? LYXP_NODE_ELEM : 0;
5975 break;
5976
5977 case LYXP_AXIS_PARENT:
5978 case LYXP_AXIS_SELF:
5979 /* parent/self was returned before */
5980 break;
5981
5982 case LYXP_AXIS_PRECEDING:
5983 assert(*iter_type == LYXP_NODE_ELEM);
5984 next = moveto_axis_node_next_dfs_backward(*iter, NULL);
5985 next_type = next ? LYXP_NODE_ELEM : 0;
5986 break;
5987
5988 case LYXP_AXIS_PRECEDING_SIBLING:
5989 assert(*iter_type == LYXP_NODE_ELEM);
5990
5991 /* previous sibling */
5992 next = (*iter)->prev->next ? (*iter)->prev : NULL;
5993 next_type = next ? LYXP_NODE_ELEM : 0;
5994 break;
5995
5996 case LYXP_AXIS_ATTRIBUTE:
5997 /* handled specially */
5998 assert(0);
5999 LOGINT(set->ctx);
6000 break;
6001 }
6002
6003 *iter = next;
6004 *iter_type = next_type;
6005 return next_type ? LY_SUCCESS : LY_ENOTFOUND;
6006}
6007
6008/**
6009 * @brief Move context @p set to a node. Result is LYXP_SET_NODE_SET. Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006010 *
6011 * @param[in,out] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006012 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02006013 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vasko49fec8e2022-05-24 10:28:33 +02006014 * @param[in] axis Axis to search on.
Michal Vaskocdad7122020-11-09 21:04:44 +01006015 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006016 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6017 */
6018static LY_ERR
Michal Vasko49fec8e2022-05-24 10:28:33 +02006019moveto_node(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, enum lyxp_axis axis,
6020 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006021{
Michal Vasko230cf972021-12-02 12:31:00 +01006022 LY_ERR r, rc = LY_SUCCESS;
Michal Vasko49fec8e2022-05-24 10:28:33 +02006023 const struct lyd_node *iter;
6024 enum lyxp_node_type iter_type;
Michal Vasko230cf972021-12-02 12:31:00 +01006025 struct lyxp_set result;
Michal Vasko49fec8e2022-05-24 10:28:33 +02006026 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006027
aPiecek8b0cc152021-05-31 16:40:31 +02006028 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006029 return LY_SUCCESS;
6030 }
6031
6032 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006033 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006034 return LY_EVALID;
6035 }
6036
Michal Vasko230cf972021-12-02 12:31:00 +01006037 /* init result set */
6038 set_init(&result, set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006039
Michal Vasko49fec8e2022-05-24 10:28:33 +02006040 for (i = 0; i < set->used; ++i) {
6041 /* iterate over all the nodes on the axis of the node */
6042 iter = NULL;
6043 iter_type = 0;
6044 while (!moveto_axis_node_next(&iter, &iter_type, set->val.nodes[i].node, set->val.nodes[i].type, axis, set)) {
6045 r = moveto_node_check(iter, iter_type, set, ncname, moveto_mod, options);
6046 if (r == LY_EINCOMPLETE) {
Michal Vasko230cf972021-12-02 12:31:00 +01006047 rc = r;
6048 goto cleanup;
Michal Vasko49fec8e2022-05-24 10:28:33 +02006049 } else if (r) {
6050 continue;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006051 }
Michal Vasko49fec8e2022-05-24 10:28:33 +02006052
6053 /* check for duplicates if they are possible */
6054 switch (axis) {
6055 case LYXP_AXIS_ANCESTOR:
6056 case LYXP_AXIS_ANCESTOR_OR_SELF:
6057 case LYXP_AXIS_DESCENDANT:
6058 case LYXP_AXIS_DESCENDANT_OR_SELF:
6059 case LYXP_AXIS_FOLLOWING:
6060 case LYXP_AXIS_FOLLOWING_SIBLING:
6061 case LYXP_AXIS_PARENT:
6062 case LYXP_AXIS_PRECEDING:
6063 case LYXP_AXIS_PRECEDING_SIBLING:
Michal Vasko306e2832022-07-25 09:15:17 +02006064 result.non_child_axis = 1;
Michal Vasko49fec8e2022-05-24 10:28:33 +02006065 if (set_dup_node_check(&result, iter, iter_type, -1)) {
6066 continue;
6067 }
6068 break;
6069 case LYXP_AXIS_CHILD:
6070 case LYXP_AXIS_SELF:
6071 break;
6072 case LYXP_AXIS_ATTRIBUTE:
6073 /* handled specially */
6074 assert(0);
6075 LOGINT(set->ctx);
6076 break;
6077 }
6078
6079 /* matching node */
6080 set_insert_node(&result, iter, 0, iter_type, result.used);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006081 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006082 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006083
Michal Vasko230cf972021-12-02 12:31:00 +01006084 /* move result to the set */
6085 lyxp_set_free_content(set);
6086 *set = result;
6087 result.type = LYXP_SET_NUMBER;
Michal Vasko49fec8e2022-05-24 10:28:33 +02006088
Michal Vasko306e2832022-07-25 09:15:17 +02006089 /* sort the final set if the document order could have been broken */
6090 if (set->non_child_axis) {
6091 set_sort(set);
6092 } else {
6093 assert(!set_sort(set));
6094 }
Michal Vasko230cf972021-12-02 12:31:00 +01006095
6096cleanup:
6097 lyxp_set_free_content(&result);
6098 return rc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006099}
6100
6101/**
Michal Vasko49fec8e2022-05-24 10:28:33 +02006102 * @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 +02006103 *
6104 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02006105 * @param[in] scnode Matching node schema.
Michal Vasko004d3152020-06-11 19:59:22 +02006106 * @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 +01006107 * @param[in] options XPath options.
Michal Vaskod3678892020-05-21 10:06:58 +02006108 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6109 */
6110static LY_ERR
Michal Vasko49fec8e2022-05-24 10:28:33 +02006111moveto_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 +01006112 uint32_t options)
Michal Vaskod3678892020-05-21 10:06:58 +02006113{
Michal Vaskoddd76592022-01-17 13:34:48 +01006114 LY_ERR ret = LY_SUCCESS, r;
Michal Vaskod3678892020-05-21 10:06:58 +02006115 uint32_t i;
Michal Vaskod3678892020-05-21 10:06:58 +02006116 const struct lyd_node *siblings;
Michal Vasko230cf972021-12-02 12:31:00 +01006117 struct lyxp_set result;
Michal Vasko004d3152020-06-11 19:59:22 +02006118 struct lyd_node *sub, *inst = NULL;
Michal Vaskod3678892020-05-21 10:06:58 +02006119
Michal Vasko004d3152020-06-11 19:59:22 +02006120 assert(scnode && (!(scnode->nodetype & (LYS_LIST | LYS_LEAFLIST)) || predicates));
Michal Vaskod3678892020-05-21 10:06:58 +02006121
Michal Vasko50aaa072021-12-02 13:11:56 +01006122 /* init result set */
6123 set_init(&result, set);
6124
aPiecek8b0cc152021-05-31 16:40:31 +02006125 if (options & LYXP_SKIP_EXPR) {
Michal Vasko004d3152020-06-11 19:59:22 +02006126 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02006127 }
6128
6129 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006130 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko004d3152020-06-11 19:59:22 +02006131 ret = LY_EVALID;
6132 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02006133 }
6134
6135 /* context check for all the nodes since we have the schema node */
6136 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (scnode->flags & LYS_CONFIG_R)) {
6137 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02006138 goto cleanup;
Michal Vasko69730152020-10-09 16:30:07 +02006139 } else if (set->context_op && (scnode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) &&
6140 (scnode != set->context_op)) {
Michal Vasko6b26e742020-07-17 15:02:10 +02006141 lyxp_set_free_content(set);
6142 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +02006143 }
6144
6145 /* create specific data instance if needed */
6146 if (scnode->nodetype == LYS_LIST) {
6147 LY_CHECK_GOTO(ret = lyd_create_list(scnode, predicates, &inst), cleanup);
6148 } else if (scnode->nodetype == LYS_LEAFLIST) {
6149 LY_CHECK_GOTO(ret = lyd_create_term2(scnode, &predicates[0].value, &inst), cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02006150 }
6151
Michal Vasko230cf972021-12-02 12:31:00 +01006152 for (i = 0; i < set->used; ++i) {
Michal Vaskod3678892020-05-21 10:06:58 +02006153 siblings = NULL;
6154
6155 if ((set->val.nodes[i].type == LYXP_NODE_ROOT_CONFIG) || (set->val.nodes[i].type == LYXP_NODE_ROOT)) {
6156 assert(!set->val.nodes[i].node);
6157
6158 /* search in all the trees */
6159 siblings = set->tree;
6160 } else if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
6161 /* search in children */
Radek Krejcia1c1e542020-09-29 16:06:52 +02006162 siblings = lyd_child(set->val.nodes[i].node);
Michal Vaskod3678892020-05-21 10:06:58 +02006163 }
6164
6165 /* find the node using hashes */
Michal Vasko004d3152020-06-11 19:59:22 +02006166 if (inst) {
Michal Vaskoddd76592022-01-17 13:34:48 +01006167 r = lyd_find_sibling_first(siblings, inst, &sub);
Michal Vaskod3678892020-05-21 10:06:58 +02006168 } else {
Michal Vaskoddd76592022-01-17 13:34:48 +01006169 r = lyd_find_sibling_val(siblings, scnode, NULL, 0, &sub);
Michal Vaskod3678892020-05-21 10:06:58 +02006170 }
Michal Vaskoddd76592022-01-17 13:34:48 +01006171 LY_CHECK_ERR_GOTO(r && (r != LY_ENOTFOUND), ret = r, cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02006172
6173 /* when check */
Michal Vaskod5cfa6e2020-11-23 16:56:08 +01006174 if (!(options & LYXP_IGNORE_WHEN) && sub && lysc_has_when(sub->schema) && !(sub->flags & LYD_WHEN_TRUE)) {
Michal Vasko004d3152020-06-11 19:59:22 +02006175 ret = LY_EINCOMPLETE;
6176 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02006177 }
6178
6179 if (sub) {
6180 /* pos filled later */
Michal Vasko230cf972021-12-02 12:31:00 +01006181 set_insert_node(&result, sub, 0, LYXP_NODE_ELEM, result.used);
Michal Vaskod3678892020-05-21 10:06:58 +02006182 }
6183 }
6184
Michal Vasko230cf972021-12-02 12:31:00 +01006185 /* move result to the set */
6186 lyxp_set_free_content(set);
6187 *set = result;
6188 result.type = LYXP_SET_NUMBER;
6189 assert(!set_sort(set));
6190
Michal Vasko004d3152020-06-11 19:59:22 +02006191cleanup:
Michal Vasko230cf972021-12-02 12:31:00 +01006192 lyxp_set_free_content(&result);
Michal Vasko004d3152020-06-11 19:59:22 +02006193 lyd_free_tree(inst);
6194 return ret;
Michal Vaskod3678892020-05-21 10:06:58 +02006195}
6196
6197/**
Michal Vasko49fec8e2022-05-24 10:28:33 +02006198 * @brief Check @p node as a part of schema NameTest processing.
6199 *
6200 * @param[in] node Schema node to check.
6201 * @param[in] ctx_scnode Context node.
6202 * @param[in] set Set to read general context from.
6203 * @param[in] node_name Node name in the dictionary to move to, NULL for any nodes.
6204 * @param[in] moveto_mod Expected module of the node, NULL for no prefix.
6205 * @return LY_ERR (LY_ENOT if node does not match, LY_EINVAL if neither node nor any children match)
6206 */
6207static LY_ERR
6208moveto_scnode_check(const struct lysc_node *node, const struct lysc_node *ctx_scnode, const struct lyxp_set *set,
6209 const char *node_name, const struct lys_module *moveto_mod)
6210{
6211 if (!moveto_mod && node_name) {
6212 switch (set->format) {
6213 case LY_VALUE_SCHEMA:
6214 case LY_VALUE_SCHEMA_RESOLVED:
6215 /* use current module */
6216 moveto_mod = set->cur_mod;
6217 break;
6218 case LY_VALUE_JSON:
6219 case LY_VALUE_LYB:
6220 case LY_VALUE_STR_NS:
6221 /* inherit module of the context node, if any */
6222 if (ctx_scnode) {
6223 moveto_mod = ctx_scnode->module;
6224 }
6225 break;
6226 case LY_VALUE_CANON:
6227 case LY_VALUE_XML:
6228 /* not defined */
6229 LOGINT(set->ctx);
6230 return LY_EINVAL;
6231 }
6232 }
6233
6234 if (!node) {
6235 /* root will not match a specific node */
6236 if (node_name || moveto_mod) {
6237 return LY_ENOT;
6238 }
6239 return LY_SUCCESS;
6240 }
6241
6242 /* module check */
6243 if (moveto_mod && (node->module != moveto_mod)) {
6244 return LY_ENOT;
6245 }
6246
6247 /* context check */
6248 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (node->flags & LYS_CONFIG_R)) {
6249 return LY_EINVAL;
6250 } else if (set->context_op && (node->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) && (node != set->context_op)) {
6251 return LY_EINVAL;
6252 }
6253
6254 /* name check */
6255 if (node_name && (node->name != node_name)) {
6256 return LY_ENOT;
6257 }
6258
6259 /* match */
6260 return LY_SUCCESS;
6261}
6262
6263/**
6264 * @brief Get the next node in a forward schema node DFS.
6265 *
6266 * @param[in] iter Last returned node.
6267 * @param[in] stop Node to stop the search on and not return.
6268 * @param[in] getnext_opts Options for ::lys_getnext().
6269 * @return Next node, NULL if there are no more.
6270 */
6271static const struct lysc_node *
6272moveto_axis_scnode_next_dfs_forward(const struct lysc_node *iter, const struct lysc_node *stop, uint32_t getnext_opts)
6273{
6274 const struct lysc_node *next = NULL;
6275
6276 next = lysc_node_child(iter);
6277 if (!next) {
6278 /* no children, try siblings */
Michal Vasko34a22fe2022-06-15 07:58:55 +02006279 if ((iter == stop) || !lysc_data_parent(iter)) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02006280 /* we are done, no next element to process */
6281 return NULL;
6282 }
6283
6284 next = lys_getnext(iter, lysc_data_parent(iter), NULL, getnext_opts);
6285 }
6286 while (!next && iter) {
6287 /* parent is already processed, go to its sibling */
6288 iter = iter->parent;
Michal Vasko34a22fe2022-06-15 07:58:55 +02006289 if ((iter == stop) || !lysc_data_parent(iter)) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02006290 /* we are done, no next element to process */
6291 return NULL;
6292 }
6293 next = lys_getnext(iter, lysc_data_parent(iter), NULL, getnext_opts);
6294 }
6295
6296 return next;
6297}
6298
6299/**
6300 * @brief Consider schema node based on its in_ctx enum value.
6301 *
6302 * @param[in,out] in_ctx In_ctx enum of the schema node, may be updated.
6303 * @param[in] axis Axis to use.
6304 * @return LY_SUCCESS on success.
6305 * @return LY_ENOT if the node should not be returned.
6306 */
6307static LY_ERR
6308moveto_axis_scnode_next_in_ctx(int32_t *in_ctx, enum lyxp_axis axis)
6309{
6310 switch (axis) {
6311 case LYXP_AXIS_SELF:
6312 if ((*in_ctx == LYXP_SET_SCNODE_START) || (*in_ctx == LYXP_SET_SCNODE_ATOM_CTX)) {
6313 /* additionally put the start node into context */
6314 *in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
6315 return LY_SUCCESS;
6316 }
6317 break;
6318 case LYXP_AXIS_PARENT:
6319 case LYXP_AXIS_ANCESTOR_OR_SELF:
6320 case LYXP_AXIS_ANCESTOR:
6321 case LYXP_AXIS_DESCENDANT_OR_SELF:
6322 case LYXP_AXIS_DESCENDANT:
6323 case LYXP_AXIS_FOLLOWING:
6324 case LYXP_AXIS_FOLLOWING_SIBLING:
6325 case LYXP_AXIS_PRECEDING:
6326 case LYXP_AXIS_PRECEDING_SIBLING:
6327 case LYXP_AXIS_CHILD:
6328 if (*in_ctx == LYXP_SET_SCNODE_START) {
6329 /* remember that context node was used */
6330 *in_ctx = LYXP_SET_SCNODE_START_USED;
6331 return LY_SUCCESS;
6332 } else if (*in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
6333 /* traversed */
6334 *in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
6335 return LY_SUCCESS;
6336 }
6337 break;
6338 case LYXP_AXIS_ATTRIBUTE:
6339 /* unreachable */
6340 assert(0);
6341 LOGINT(NULL);
6342 break;
6343 }
6344
6345 return LY_ENOT;
6346}
6347
6348/**
6349 * @brief Get previous sibling for a schema node.
6350 *
6351 * @param[in] scnode Schema node.
6352 * @param[in] getnext_opts Options for ::lys_getnext().
6353 * @return Previous sibling, NULL if none.
6354 */
6355static const struct lysc_node *
6356moveto_axis_scnode_preceding_sibling(const struct lysc_node *scnode, uint32_t getnext_opts)
6357{
6358 const struct lysc_node *next = NULL, *prev = NULL;
6359
6360 while ((next = lys_getnext(next, lysc_data_parent(scnode), scnode->module->compiled, getnext_opts))) {
6361 if (next == scnode) {
6362 break;
6363 }
6364
6365 prev = next;
6366 }
6367
6368 return prev;
6369}
6370
6371/**
6372 * @brief Get the first schema node on an axis for a context node.
6373 *
6374 * @param[in,out] iter Last returned node, start with NULL, updated to the next node.
6375 * @param[in,out] iter_type Node type of @p iter, start with 0, updated to the node type of the next node.
6376 * @param[in,out] iter_mod Internal module iterator, do not change.
6377 * @param[in,out] iter_mod_idx Internal module index iterator, do not change.
6378 * @param[in] scnode Context node.
6379 * @param[in] node_type Type of @p scnode.
6380 * @param[in] in_ctx In_ctx enum of @p scnode.
6381 * @param[in] axis Axis to use.
6382 * @param[in] set XPath set with the general context.
6383 * @param[in] getnext_opts Options for ::lys_getnext().
6384 * @return LY_SUCCESS on success.
6385 * @return LY_ENOTFOUND if no next node found.
6386 */
6387static LY_ERR
6388moveto_axis_scnode_next_first(const struct lysc_node **iter, enum lyxp_node_type *iter_type, const struct lys_module **iter_mod,
6389 uint32_t *iter_mod_idx, const struct lysc_node *scnode, enum lyxp_node_type node_type, enum lyxp_axis axis,
6390 struct lyxp_set *set, uint32_t getnext_opts)
6391{
6392 const struct lysc_node *next = NULL;
6393 enum lyxp_node_type next_type = 0;
6394
6395 assert(!*iter);
6396 assert(!*iter_type);
6397
6398 *iter_mod = NULL;
6399 *iter_mod_idx = 0;
6400
6401 switch (axis) {
6402 case LYXP_AXIS_ANCESTOR_OR_SELF:
6403 case LYXP_AXIS_DESCENDANT_OR_SELF:
6404 case LYXP_AXIS_SELF:
6405 if ((node_type == LYXP_NODE_ROOT_CONFIG) || (node_type == LYXP_NODE_ROOT) || (node_type == LYXP_NODE_ELEM)) {
6406 /* just return the node */
6407 next = scnode;
6408 next_type = node_type;
6409 }
6410 break;
6411
6412 case LYXP_AXIS_ANCESTOR:
6413 case LYXP_AXIS_PARENT:
6414 if (node_type == LYXP_NODE_ELEM) {
6415 next = lysc_data_parent(scnode);
6416 next_type = next ? LYXP_NODE_ELEM : set->root_type;
6417 } /* else no parent */
6418 break;
6419
6420 case LYXP_AXIS_DESCENDANT:
6421 case LYXP_AXIS_CHILD:
6422 if ((node_type == LYXP_NODE_ROOT_CONFIG) || (node_type == LYXP_NODE_ROOT)) {
6423 /* it can actually be in any module, it's all <running>, and even if it's moveto_mod (if set),
6424 * it can be in a top-level augment */
6425 while ((*iter_mod = ly_ctx_get_module_iter(set->ctx, iter_mod_idx))) {
6426 /* module may not be implemented or not compiled yet */
6427 if (!(*iter_mod)->compiled) {
6428 continue;
6429 }
6430
6431 /* get next node */
6432 if ((next = lys_getnext(NULL, NULL, (*iter_mod)->compiled, getnext_opts))) {
6433 next_type = LYXP_NODE_ELEM;
6434 break;
6435 }
6436 }
6437 } else if (node_type == LYXP_NODE_ELEM) {
6438 /* get next node */
6439 next = lys_getnext(NULL, scnode, NULL, getnext_opts);
6440 next_type = next ? LYXP_NODE_ELEM : 0;
6441 }
6442 break;
6443
6444 case LYXP_AXIS_FOLLOWING:
6445 case LYXP_AXIS_FOLLOWING_SIBLING:
6446 if (node_type == LYXP_NODE_ELEM) {
6447 /* first next sibling */
6448 next = lys_getnext(scnode, lysc_data_parent(scnode), scnode->module->compiled, getnext_opts);
6449 next_type = next ? LYXP_NODE_ELEM : 0;
6450 } /* else no sibling */
6451 break;
6452
6453 case LYXP_AXIS_PRECEDING:
6454 case LYXP_AXIS_PRECEDING_SIBLING:
6455 if (node_type == LYXP_NODE_ELEM) {
6456 /* first parent sibling */
6457 next = lys_getnext(NULL, lysc_data_parent(scnode), scnode->module->compiled, getnext_opts);
6458 if (next == scnode) {
6459 /* no preceding sibling */
6460 next = NULL;
6461 }
6462 next_type = next ? LYXP_NODE_ELEM : 0;
6463 } /* else no sibling */
6464 break;
6465
6466 case LYXP_AXIS_ATTRIBUTE:
6467 /* unreachable */
6468 assert(0);
6469 LOGINT(set->ctx);
6470 break;
6471 }
6472
6473 *iter = next;
6474 *iter_type = next_type;
6475 return next_type ? LY_SUCCESS : LY_ENOTFOUND;
6476}
6477
6478/**
6479 * @brief Iterate over all schema nodes on an axis for a context node.
6480 *
6481 * @param[in,out] iter Last returned node, start with NULL, updated to the next node.
6482 * @param[in,out] iter_type Node type of @p iter, start with 0, updated to the node type of the next node.
6483 * @param[in,out] iter_mod Internal module iterator, do not change.
6484 * @param[in,out] iter_mod_idx Internal module index iterator, do not change.
6485 * @param[in] scnode Context node.
6486 * @param[in] node_type Type of @p scnode.
6487 * @param[in] axis Axis to use.
6488 * @param[in] set XPath set with the general context.
6489 * @param[in] getnext_opts Options for ::lys_getnext().
6490 * @return LY_SUCCESS on success.
6491 * @return LY_ENOTFOUND if no next node found.
6492 */
6493static LY_ERR
6494moveto_axis_scnode_next(const struct lysc_node **iter, enum lyxp_node_type *iter_type, const struct lys_module **iter_mod,
6495 uint32_t *iter_mod_idx, const struct lysc_node *scnode, enum lyxp_node_type node_type, enum lyxp_axis axis,
6496 struct lyxp_set *set, uint32_t getnext_opts)
6497{
6498 const struct lysc_node *next = NULL, *dfs_stop;
6499 enum lyxp_node_type next_type = 0;
6500
6501 if (!*iter_type) {
6502 /* first returned node */
6503 return moveto_axis_scnode_next_first(iter, iter_type, iter_mod, iter_mod_idx, scnode, node_type, axis, set,
6504 getnext_opts);
6505 }
6506
6507 switch (axis) {
6508 case LYXP_AXIS_PARENT:
6509 case LYXP_AXIS_SELF:
6510 /* parent/self was returned before */
6511 break;
6512
6513 case LYXP_AXIS_ANCESTOR_OR_SELF:
6514 if ((*iter == scnode) && (*iter_type == node_type)) {
6515 /* fake first ancestor, we returned self before */
6516 *iter = NULL;
6517 *iter_type = 0;
6518 return moveto_axis_scnode_next_first(iter, iter_type, iter_mod, iter_mod_idx, scnode, node_type,
6519 LYXP_AXIS_ANCESTOR, set, getnext_opts);
6520 } /* else continue ancestor */
6521
6522 /* fallthrough */
6523 case LYXP_AXIS_ANCESTOR:
6524 if (*iter_type == LYXP_NODE_ELEM) {
6525 next = lysc_data_parent(*iter);
6526 next_type = next ? LYXP_NODE_ELEM : set->root_type;
6527 } /* else no ancestor */
6528 break;
6529
6530 case LYXP_AXIS_DESCENDANT_OR_SELF:
6531 if ((*iter == scnode) && (*iter_type == node_type)) {
6532 /* fake first descendant, we returned self before */
6533 *iter = NULL;
6534 *iter_type = 0;
6535 return moveto_axis_scnode_next_first(iter, iter_type, iter_mod, iter_mod_idx, scnode, node_type,
6536 LYXP_AXIS_DESCENDANT, set, getnext_opts);
6537 } /* else DFS until context node */
6538 dfs_stop = scnode;
6539
6540 /* fallthrough */
6541 case LYXP_AXIS_DESCENDANT:
6542 if (axis == LYXP_AXIS_DESCENDANT) {
6543 /* DFS until the context node */
6544 dfs_stop = scnode;
6545 }
6546
6547 /* fallthrough */
6548 case LYXP_AXIS_PRECEDING:
6549 if (axis == LYXP_AXIS_PRECEDING) {
6550 /* DFS until the previous sibling */
6551 dfs_stop = moveto_axis_scnode_preceding_sibling(scnode, getnext_opts);
6552 assert(dfs_stop);
6553
6554 if (*iter == dfs_stop) {
6555 /* we are done */
6556 break;
6557 }
6558 }
6559
6560 /* fallthrough */
6561 case LYXP_AXIS_FOLLOWING:
6562 if (axis == LYXP_AXIS_FOLLOWING) {
6563 /* DFS through the whole module */
6564 dfs_stop = NULL;
6565 }
6566
6567 /* nested nodes */
6568 assert(*iter);
6569 next = moveto_axis_scnode_next_dfs_forward(*iter, dfs_stop, getnext_opts);
6570 if (next) {
6571 next_type = LYXP_NODE_ELEM;
6572 break;
6573 } /* else get next top-level node just like a child */
6574
6575 /* fallthrough */
6576 case LYXP_AXIS_CHILD:
6577 case LYXP_AXIS_FOLLOWING_SIBLING:
6578 if (!*iter_mod) {
6579 /* nodes from a single module */
6580 if ((next = lys_getnext(*iter, lysc_data_parent(*iter), (*iter)->module->compiled, getnext_opts))) {
6581 next_type = LYXP_NODE_ELEM;
6582 break;
6583 }
6584
6585 assert(scnode);
Michal Vaskoa353cce2022-11-14 10:09:55 +01006586 if ((axis != LYXP_AXIS_CHILD) && !lysc_data_parent(scnode)) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02006587 /* iterating over top-level nodes, find next */
6588 while (lysc_data_parent(*iter)) {
6589 *iter = lysc_data_parent(*iter);
6590 }
6591 if ((next = lys_getnext(*iter, NULL, (*iter)->module->compiled, getnext_opts))) {
6592 next_type = LYXP_NODE_ELEM;
6593 break;
6594 }
6595 }
6596 }
6597
6598 while (*iter_mod) {
6599 /* module top-level nodes */
6600 if ((next = lys_getnext(*iter, NULL, (*iter_mod)->compiled, getnext_opts))) {
6601 next_type = LYXP_NODE_ELEM;
6602 break;
6603 }
6604
6605 /* get next module */
6606 while ((*iter_mod = ly_ctx_get_module_iter(set->ctx, iter_mod_idx))) {
6607 /* module may not be implemented or not compiled yet */
6608 if ((*iter_mod)->compiled) {
6609 break;
6610 }
6611 }
6612
6613 /* new module, start over */
6614 *iter = NULL;
6615 }
6616 break;
6617
6618 case LYXP_AXIS_PRECEDING_SIBLING:
6619 assert(*iter);
6620
6621 /* next parent sibling until scnode */
6622 next = lys_getnext(*iter, lysc_data_parent(*iter), (*iter)->module->compiled, getnext_opts);
6623 if (next == scnode) {
6624 /* no previous sibling */
6625 next = NULL;
6626 }
6627 next_type = next ? LYXP_NODE_ELEM : 0;
6628 break;
6629
6630 case LYXP_AXIS_ATTRIBUTE:
6631 /* unreachable */
6632 assert(0);
6633 LOGINT(set->ctx);
6634 break;
6635 }
6636
6637 *iter = next;
6638 *iter_type = next_type;
6639 return next_type ? LY_SUCCESS : LY_ENOTFOUND;
6640}
6641
6642/**
Michal Vaskod3678892020-05-21 10:06:58 +02006643 * @brief Move context @p set to a schema node. Result is LYXP_SET_SCNODE_SET (or LYXP_SET_EMPTY).
6644 *
6645 * @param[in,out] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006646 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02006647 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vasko49fec8e2022-05-24 10:28:33 +02006648 * @param[in] axis Axis to search on.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006649 * @param[in] options XPath options.
6650 * @return LY_ERR
6651 */
6652static LY_ERR
Michal Vasko49fec8e2022-05-24 10:28:33 +02006653moveto_scnode(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, enum lyxp_axis axis,
6654 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006655{
Radek Krejci857189e2020-09-01 13:26:36 +02006656 ly_bool temp_ctx = 0;
Michal Vasko49fec8e2022-05-24 10:28:33 +02006657 uint32_t getnext_opts, orig_used, i, mod_idx, idx;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006658 const struct lys_module *mod;
Michal Vasko49fec8e2022-05-24 10:28:33 +02006659 const struct lysc_node *iter;
6660 enum lyxp_node_type iter_type;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006661
aPiecek8b0cc152021-05-31 16:40:31 +02006662 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006663 return LY_SUCCESS;
6664 }
6665
6666 if (set->type != LYXP_SET_SCNODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006667 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006668 return LY_EVALID;
6669 }
6670
Michal Vaskocafad9d2019-11-07 15:20:03 +01006671 /* getnext opts */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01006672 getnext_opts = 0;
Michal Vaskocafad9d2019-11-07 15:20:03 +01006673 if (options & LYXP_SCNODE_OUTPUT) {
6674 getnext_opts |= LYS_GETNEXT_OUTPUT;
6675 }
6676
Michal Vasko03ff5a72019-09-11 13:49:33 +02006677 orig_used = set->used;
6678 for (i = 0; i < orig_used; ++i) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02006679 /* update in_ctx first */
6680 if (moveto_axis_scnode_next_in_ctx(&set->val.scnodes[i].in_ctx, axis)) {
6681 /* not usable, skip */
6682 continue;
6683 }
Radek Krejciaa6b53f2020-08-27 15:19:03 +02006684
Michal Vasko49fec8e2022-05-24 10:28:33 +02006685 iter = NULL;
6686 iter_type = 0;
6687 while (!moveto_axis_scnode_next(&iter, &iter_type, &mod, &mod_idx, set->val.scnodes[i].scnode,
6688 set->val.scnodes[i].type, axis, set, getnext_opts)) {
6689 if (moveto_scnode_check(iter, NULL, set, ncname, moveto_mod)) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01006690 continue;
6691 }
6692
Michal Vasko49fec8e2022-05-24 10:28:33 +02006693 /* insert */
Michal Vasko7333cb32022-07-29 16:30:29 +02006694 LY_CHECK_RET(set_scnode_insert_node(set, iter, iter_type, axis, &idx));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006695
Michal Vasko49fec8e2022-05-24 10:28:33 +02006696 /* we need to prevent these nodes from being considered in this moveto */
6697 if ((idx < orig_used) && (idx > i)) {
6698 set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_NEW_CTX;
6699 temp_ctx = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006700 }
6701 }
Michal Vasko66330fc2022-11-21 15:52:24 +01006702
6703 if (moveto_mod && ncname && ((axis == LYXP_AXIS_DESCENDANT) || (axis == LYXP_AXIS_CHILD)) &&
6704 (set->val.scnodes[i].type == LYXP_NODE_ELEM) && !ly_nested_ext_schema(NULL, set->val.scnodes[i].scnode,
6705 moveto_mod->name, strlen(moveto_mod->name), LY_VALUE_JSON, NULL, ncname, strlen(ncname), &iter, NULL)) {
6706 /* there is a matching node from an extension, use it */
6707 LY_CHECK_RET(set_scnode_insert_node(set, iter, LYXP_NODE_ELEM, axis, &idx));
6708 if ((idx < orig_used) && (idx > i)) {
6709 set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_NEW_CTX;
6710 temp_ctx = 1;
6711 }
6712 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006713 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006714
6715 /* correct temporary in_ctx values */
6716 if (temp_ctx) {
6717 for (i = 0; i < orig_used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006718 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_NEW_CTX) {
6719 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006720 }
6721 }
6722 }
6723
6724 return LY_SUCCESS;
6725}
6726
6727/**
Michal Vasko49fec8e2022-05-24 10:28:33 +02006728 * @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 +02006729 * Context position aware.
6730 *
6731 * @param[in] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006732 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02006733 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vaskocdad7122020-11-09 21:04:44 +01006734 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006735 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6736 */
6737static LY_ERR
Michal Vasko49fec8e2022-05-24 10:28:33 +02006738moveto_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 +02006739{
6740 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006741 const struct lyd_node *next, *elem, *start;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006742 struct lyxp_set ret_set;
6743 LY_ERR rc;
6744
aPiecek8b0cc152021-05-31 16:40:31 +02006745 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006746 return LY_SUCCESS;
6747 }
6748
6749 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006750 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006751 return LY_EVALID;
6752 }
6753
Michal Vasko9f96a052020-03-10 09:41:45 +01006754 /* 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 +02006755 rc = xpath_pi_node(set, LYXP_AXIS_CHILD, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006756 LY_CHECK_RET(rc);
6757
Michal Vasko6346ece2019-09-24 13:12:53 +02006758 /* this loop traverses all the nodes in the set and adds/keeps only those that match qname */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006759 set_init(&ret_set, set);
6760 for (i = 0; i < set->used; ++i) {
6761
6762 /* TREE DFS */
6763 start = set->val.nodes[i].node;
6764 for (elem = next = start; elem; elem = next) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02006765 rc = moveto_node_check(elem, LYXP_NODE_ELEM, set, ncname, moveto_mod, options);
Michal Vasko6346ece2019-09-24 13:12:53 +02006766 if (!rc) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006767 /* add matching node into result set */
6768 set_insert_node(&ret_set, elem, 0, LYXP_NODE_ELEM, ret_set.used);
6769 if (set_dup_node_check(set, elem, LYXP_NODE_ELEM, i)) {
6770 /* the node is a duplicate, we'll process it later in the set */
6771 goto skip_children;
6772 }
Michal Vasko6346ece2019-09-24 13:12:53 +02006773 } else if (rc == LY_EINCOMPLETE) {
Michal Vasko6346ece2019-09-24 13:12:53 +02006774 return rc;
6775 } else if (rc == LY_EINVAL) {
6776 goto skip_children;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006777 }
6778
6779 /* TREE DFS NEXT ELEM */
6780 /* select element for the next run - children first */
Radek Krejcia1c1e542020-09-29 16:06:52 +02006781 next = lyd_child(elem);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006782 if (!next) {
6783skip_children:
6784 /* no children, so try siblings, but only if it's not the start,
6785 * that is considered to be the root and it's siblings are not traversed */
6786 if (elem != start) {
6787 next = elem->next;
6788 } else {
6789 break;
6790 }
6791 }
6792 while (!next) {
6793 /* no siblings, go back through the parents */
Michal Vasko9e685082021-01-29 14:49:09 +01006794 if (lyd_parent(elem) == start) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006795 /* we are done, no next element to process */
6796 break;
6797 }
6798 /* parent is already processed, go to its sibling */
Michal Vasko9e685082021-01-29 14:49:09 +01006799 elem = lyd_parent(elem);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006800 next = elem->next;
6801 }
6802 }
6803 }
6804
6805 /* make the temporary set the current one */
6806 ret_set.ctx_pos = set->ctx_pos;
6807 ret_set.ctx_size = set->ctx_size;
Michal Vaskod3678892020-05-21 10:06:58 +02006808 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006809 memcpy(set, &ret_set, sizeof *set);
Michal Vasko306e2832022-07-25 09:15:17 +02006810 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006811
6812 return LY_SUCCESS;
6813}
6814
6815/**
Michal Vasko49fec8e2022-05-24 10:28:33 +02006816 * @brief Move context @p set to a child schema node and all its descendants starting from a node.
6817 * Result is LYXP_SET_NODE_SET.
6818 *
6819 * @param[in] set Set to use.
6820 * @param[in] start Start node whose subtree to add.
6821 * @param[in] start_idx Index of @p start in @p set.
6822 * @param[in] moveto_mod Matching node module, NULL for no prefix.
6823 * @param[in] ncname Matching node name in the dictionary, NULL for any.
6824 * @param[in] options XPath options.
6825 * @return LY_ERR value.
6826 */
6827static LY_ERR
6828moveto_scnode_dfs(struct lyxp_set *set, const struct lysc_node *start, uint32_t start_idx,
6829 const struct lys_module *moveto_mod, const char *ncname, uint32_t options)
6830{
6831 const struct lysc_node *next, *elem;
6832 uint32_t idx;
6833 LY_ERR rc;
6834
6835 /* TREE DFS */
6836 for (elem = next = start; elem; elem = next) {
6837 if ((elem == start) || (elem->nodetype & (LYS_CHOICE | LYS_CASE))) {
6838 /* schema-only nodes, skip root */
6839 goto next_iter;
6840 }
6841
6842 rc = moveto_scnode_check(elem, start, set, ncname, moveto_mod);
6843 if (!rc) {
6844 if (lyxp_set_scnode_contains(set, elem, LYXP_NODE_ELEM, start_idx, &idx)) {
6845 set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
6846 if (idx > start_idx) {
6847 /* we will process it later in the set */
6848 goto skip_children;
6849 }
6850 } else {
Michal Vasko7333cb32022-07-29 16:30:29 +02006851 LY_CHECK_RET(set_scnode_insert_node(set, elem, LYXP_NODE_ELEM, LYXP_AXIS_DESCENDANT, NULL));
Michal Vasko49fec8e2022-05-24 10:28:33 +02006852 }
6853 } else if (rc == LY_EINVAL) {
6854 goto skip_children;
6855 }
6856
6857next_iter:
6858 /* TREE DFS NEXT ELEM */
6859 /* select element for the next run - children first */
6860 next = lysc_node_child(elem);
6861 if (next && (next->nodetype == LYS_INPUT) && (options & LYXP_SCNODE_OUTPUT)) {
6862 next = next->next;
6863 } else if (next && (next->nodetype == LYS_OUTPUT) && !(options & LYXP_SCNODE_OUTPUT)) {
6864 next = next->next;
6865 }
6866 if (!next) {
6867skip_children:
6868 /* no children, so try siblings, but only if it's not the start,
6869 * that is considered to be the root and it's siblings are not traversed */
6870 if (elem != start) {
6871 next = elem->next;
6872 } else {
6873 break;
6874 }
6875 }
6876 while (!next) {
6877 /* no siblings, go back through the parents */
6878 if (elem->parent == start) {
6879 /* we are done, no next element to process */
6880 break;
6881 }
6882 /* parent is already processed, go to its sibling */
6883 elem = elem->parent;
6884 next = elem->next;
6885 }
6886 }
6887
6888 return LY_SUCCESS;
6889}
6890
6891/**
6892 * @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 +02006893 *
6894 * @param[in] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006895 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02006896 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006897 * @param[in] options XPath options.
Michal Vasko49fec8e2022-05-24 10:28:33 +02006898 * @return LY_ERR value.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006899 */
6900static LY_ERR
Michal Vasko49fec8e2022-05-24 10:28:33 +02006901moveto_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 +02006902{
Michal Vasko49fec8e2022-05-24 10:28:33 +02006903 uint32_t i, orig_used, mod_idx;
6904 const struct lys_module *mod;
6905 const struct lysc_node *root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006906
aPiecek8b0cc152021-05-31 16:40:31 +02006907 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006908 return LY_SUCCESS;
6909 }
6910
6911 if (set->type != LYXP_SET_SCNODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006912 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006913 return LY_EVALID;
6914 }
6915
Michal Vasko03ff5a72019-09-11 13:49:33 +02006916 orig_used = set->used;
6917 for (i = 0; i < orig_used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006918 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
6919 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01006920 continue;
6921 }
6922
6923 /* remember context node */
Radek Krejcif13b87b2020-12-01 22:02:17 +01006924 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vaskoec4df482019-12-16 10:02:18 +01006925 } else {
Michal Vasko1a09b212021-05-06 13:00:10 +02006926 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006927 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006928
Michal Vasko49fec8e2022-05-24 10:28:33 +02006929 if ((set->val.scnodes[i].type == LYXP_NODE_ROOT_CONFIG) || (set->val.scnodes[i].type == LYXP_NODE_ROOT)) {
6930 /* traverse all top-level nodes in all the modules */
6931 mod_idx = 0;
6932 while ((mod = ly_ctx_get_module_iter(set->ctx, &mod_idx))) {
6933 /* module may not be implemented or not compiled yet */
6934 if (!mod->compiled) {
6935 continue;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006936 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006937
Michal Vasko49fec8e2022-05-24 10:28:33 +02006938 root = NULL;
6939 /* no getnext opts needed */
6940 while ((root = lys_getnext(root, NULL, mod->compiled, 0))) {
6941 LY_CHECK_RET(moveto_scnode_dfs(set, root, i, moveto_mod, ncname, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006942 }
6943 }
Michal Vasko49fec8e2022-05-24 10:28:33 +02006944
6945 } else if (set->val.scnodes[i].type == LYXP_NODE_ELEM) {
6946 /* add all the descendants recursively */
6947 LY_CHECK_RET(moveto_scnode_dfs(set, set->val.scnodes[i].scnode, i, moveto_mod, ncname, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006948 }
6949 }
6950
6951 return LY_SUCCESS;
6952}
6953
6954/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02006955 * @brief Move context @p set to an attribute. Result is LYXP_SET_NODE_SET.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006956 * Indirectly context position aware.
6957 *
6958 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02006959 * @param[in] mod Matching metadata module, NULL for any.
6960 * @param[in] ncname Matching metadata name in the dictionary, NULL for any.
aPiecek8b0cc152021-05-31 16:40:31 +02006961 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006962 * @return LY_ERR
6963 */
6964static LY_ERR
aPiecek8b0cc152021-05-31 16:40:31 +02006965moveto_attr(struct lyxp_set *set, const struct lys_module *mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006966{
Michal Vasko9f96a052020-03-10 09:41:45 +01006967 struct lyd_meta *sub;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006968
aPiecek8b0cc152021-05-31 16:40:31 +02006969 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006970 return LY_SUCCESS;
6971 }
6972
6973 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006974 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006975 return LY_EVALID;
6976 }
6977
Radek Krejci1deb5be2020-08-26 16:43:36 +02006978 for (uint32_t i = 0; i < set->used; ) {
Radek Krejci857189e2020-09-01 13:26:36 +02006979 ly_bool replaced = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006980
6981 /* only attributes of an elem (not dummy) can be in the result, skip all the rest;
6982 * our attributes are always qualified */
Michal Vasko5c4e5892019-11-14 12:31:38 +01006983 if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko9f96a052020-03-10 09:41:45 +01006984 for (sub = set->val.nodes[i].node->meta; sub; sub = sub->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006985
6986 /* check "namespace" */
Michal Vaskod3678892020-05-21 10:06:58 +02006987 if (mod && (sub->annotation->module != mod)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006988 continue;
6989 }
6990
Michal Vaskod3678892020-05-21 10:06:58 +02006991 if (!ncname || (sub->name == ncname)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006992 /* match */
6993 if (!replaced) {
Michal Vasko9f96a052020-03-10 09:41:45 +01006994 set->val.meta[i].meta = sub;
6995 set->val.meta[i].type = LYXP_NODE_META;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006996 /* pos does not change */
6997 replaced = 1;
6998 } else {
Michal Vasko9f96a052020-03-10 09:41:45 +01006999 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 +02007000 }
7001 ++i;
7002 }
7003 }
7004 }
7005
7006 if (!replaced) {
7007 /* no match */
7008 set_remove_node(set, i);
7009 }
7010 }
7011
7012 return LY_SUCCESS;
7013}
7014
7015/**
7016 * @brief Move context @p set1 to union with @p set2. @p set2 is emptied afterwards.
Michal Vasko61ac2f62020-05-25 12:39:51 +02007017 * Result is LYXP_SET_NODE_SET. Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007018 *
7019 * @param[in,out] set1 Set to use for the result.
7020 * @param[in] set2 Set that is copied to @p set1.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007021 * @return LY_ERR
7022 */
7023static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007024moveto_union(struct lyxp_set *set1, struct lyxp_set *set2)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007025{
7026 LY_ERR rc;
7027
Michal Vaskod3678892020-05-21 10:06:58 +02007028 if ((set1->type != LYXP_SET_NODE_SET) || (set2->type != LYXP_SET_NODE_SET)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01007029 LOGVAL(set1->ctx, LY_VCODE_XP_INOP_2, "union", print_set_type(set1), print_set_type(set2));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007030 return LY_EVALID;
7031 }
7032
7033 /* set2 is empty or both set1 and set2 */
Michal Vaskod3678892020-05-21 10:06:58 +02007034 if (!set2->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007035 return LY_SUCCESS;
7036 }
7037
Michal Vaskod3678892020-05-21 10:06:58 +02007038 if (!set1->used) {
aPiecekadc1e4f2021-10-07 11:15:12 +02007039 /* release hidden allocated data (lyxp_set.size) */
7040 lyxp_set_free_content(set1);
7041 /* direct copying of the entire structure */
Michal Vasko03ff5a72019-09-11 13:49:33 +02007042 memcpy(set1, set2, sizeof *set1);
7043 /* dynamic memory belongs to set1 now, do not free */
Michal Vaskod3678892020-05-21 10:06:58 +02007044 memset(set2, 0, sizeof *set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007045 return LY_SUCCESS;
7046 }
7047
7048 /* we assume sets are sorted */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007049 assert(!set_sort(set1) && !set_sort(set2));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007050
7051 /* sort, remove duplicates */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007052 rc = set_sorted_merge(set1, set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007053 LY_CHECK_RET(rc);
7054
7055 /* final set must be sorted */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007056 assert(!set_sort(set1));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007057
7058 return LY_SUCCESS;
7059}
7060
7061/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02007062 * @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 +02007063 * Context position aware.
7064 *
7065 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02007066 * @param[in] mod Matching metadata module, NULL for any.
7067 * @param[in] ncname Matching metadata name in the dictionary, NULL for any.
Michal Vaskocdad7122020-11-09 21:04:44 +01007068 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007069 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7070 */
7071static int
Michal Vaskocdad7122020-11-09 21:04:44 +01007072moveto_attr_alldesc(struct lyxp_set *set, const struct lys_module *mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007073{
Michal Vasko9f96a052020-03-10 09:41:45 +01007074 struct lyd_meta *sub;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007075 struct lyxp_set *set_all_desc = NULL;
7076 LY_ERR rc;
7077
aPiecek8b0cc152021-05-31 16:40:31 +02007078 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007079 return LY_SUCCESS;
7080 }
7081
7082 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01007083 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007084 return LY_EVALID;
7085 }
7086
Michal Vasko03ff5a72019-09-11 13:49:33 +02007087 /* can be optimized similarly to moveto_node_alldesc() and save considerable amount of memory,
7088 * but it likely won't be used much, so it's a waste of time */
7089 /* copy the context */
7090 set_all_desc = set_copy(set);
7091 /* get all descendant nodes (the original context nodes are removed) */
Michal Vasko49fec8e2022-05-24 10:28:33 +02007092 rc = moveto_node_alldesc_child(set_all_desc, NULL, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007093 if (rc != LY_SUCCESS) {
7094 lyxp_set_free(set_all_desc);
7095 return rc;
7096 }
7097 /* prepend the original context nodes */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007098 rc = moveto_union(set, set_all_desc);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007099 if (rc != LY_SUCCESS) {
7100 lyxp_set_free(set_all_desc);
7101 return rc;
7102 }
7103 lyxp_set_free(set_all_desc);
7104
Radek Krejci1deb5be2020-08-26 16:43:36 +02007105 for (uint32_t i = 0; i < set->used; ) {
Radek Krejci857189e2020-09-01 13:26:36 +02007106 ly_bool replaced = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007107
7108 /* only attributes of an elem can be in the result, skip all the rest,
7109 * we have all attributes qualified in lyd tree */
7110 if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko9f96a052020-03-10 09:41:45 +01007111 for (sub = set->val.nodes[i].node->meta; sub; sub = sub->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007112 /* check "namespace" */
Michal Vaskod3678892020-05-21 10:06:58 +02007113 if (mod && (sub->annotation->module != mod)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007114 continue;
7115 }
7116
Michal Vaskod3678892020-05-21 10:06:58 +02007117 if (!ncname || (sub->name == ncname)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007118 /* match */
7119 if (!replaced) {
Michal Vasko9f96a052020-03-10 09:41:45 +01007120 set->val.meta[i].meta = sub;
7121 set->val.meta[i].type = LYXP_NODE_META;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007122 /* pos does not change */
7123 replaced = 1;
7124 } else {
Michal Vasko9f96a052020-03-10 09:41:45 +01007125 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 +02007126 }
7127 ++i;
7128 }
7129 }
7130 }
7131
7132 if (!replaced) {
7133 /* no match */
7134 set_remove_node(set, i);
7135 }
7136 }
7137
7138 return LY_SUCCESS;
7139}
7140
7141/**
Michal Vasko8abcecc2022-07-28 09:55:01 +02007142 * @brief Move context @p set1 single item to the result of a comparison.
7143 *
7144 * @param[in] set1 First set with the item to compare.
7145 * @param[in] idx1 Index of the item in @p set1.
7146 * @param[in] set2 Second set.
7147 * @param[in] op Comparison operator to process.
7148 * @param[in] switch_operands Whether to switch sets as operands; whether it is `set1 op set2` or `set2 op set1`.
7149 * @param[out] result Result of the comparison.
7150 * @return LY_ERR value.
7151 */
7152static LY_ERR
7153moveto_op_comp_item(const struct lyxp_set *set1, uint32_t idx1, struct lyxp_set *set2, const char *op,
7154 ly_bool switch_operands, ly_bool *result)
7155{
7156 struct lyxp_set tmp1 = {0};
7157 LY_ERR rc = LY_SUCCESS;
7158
7159 assert(set1->type == LYXP_SET_NODE_SET);
7160
7161 /* cast set1 */
7162 switch (set2->type) {
7163 case LYXP_SET_NUMBER:
7164 rc = set_comp_cast(&tmp1, set1, LYXP_SET_NUMBER, idx1);
7165 break;
7166 case LYXP_SET_BOOLEAN:
7167 rc = set_comp_cast(&tmp1, set1, LYXP_SET_BOOLEAN, idx1);
7168 break;
7169 default:
7170 rc = set_comp_cast(&tmp1, set1, LYXP_SET_STRING, idx1);
7171 break;
7172 }
7173 LY_CHECK_GOTO(rc, cleanup);
7174
7175 /* canonize set2 */
7176 LY_CHECK_GOTO(rc = set_comp_canonize(set2, &set1->val.nodes[idx1]), cleanup);
7177
7178 /* compare recursively and store the result */
7179 if (switch_operands) {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007180 LY_CHECK_GOTO(rc = moveto_op_comp(set2, &tmp1, op, result), cleanup);
Michal Vasko8abcecc2022-07-28 09:55:01 +02007181 } else {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007182 LY_CHECK_GOTO(rc = moveto_op_comp(&tmp1, set2, op, result), cleanup);
Michal Vasko8abcecc2022-07-28 09:55:01 +02007183 }
7184
7185cleanup:
7186 lyxp_set_free_content(&tmp1);
7187 return rc;
7188}
7189
7190/**
7191 * @brief Move context @p set1 to the result of a comparison. Handles '=', '!=', '<=', '<', '>=', or '>'.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007192 * Result is LYXP_SET_BOOLEAN. Indirectly context position aware.
7193 *
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007194 * @param[in] set1 Set acting as the first operand for @p op.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007195 * @param[in] set2 Set acting as the second operand for @p op.
7196 * @param[in] op Comparison operator to process.
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007197 * @param[out] result Result of the comparison.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007198 * @return LY_ERR
7199 */
7200static LY_ERR
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007201moveto_op_comp(struct lyxp_set *set1, struct lyxp_set *set2, const char *op, ly_bool *result)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007202{
7203 /*
7204 * NODE SET + NODE SET = NODE SET + STRING /(1 NODE SET) 2 STRING
7205 * NODE SET + STRING = STRING + STRING /1 STRING (2 STRING)
7206 * NODE SET + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
7207 * NODE SET + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
7208 * STRING + NODE SET = STRING + STRING /(1 STRING) 2 STRING
7209 * NUMBER + NODE SET = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
7210 * BOOLEAN + NODE SET = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
7211 *
7212 * '=' or '!='
7213 * BOOLEAN + BOOLEAN
7214 * BOOLEAN + STRING = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
7215 * BOOLEAN + NUMBER = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
7216 * STRING + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
7217 * NUMBER + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
7218 * NUMBER + NUMBER
7219 * NUMBER + STRING = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
7220 * STRING + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
7221 * STRING + STRING
7222 *
7223 * '<=', '<', '>=', '>'
7224 * NUMBER + NUMBER
7225 * BOOLEAN + BOOLEAN = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
7226 * BOOLEAN + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
7227 * BOOLEAN + STRING = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
7228 * NUMBER + STRING = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
7229 * STRING + STRING = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
7230 * STRING + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
7231 * NUMBER + BOOLEAN = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
7232 * STRING + BOOLEAN = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
7233 */
Michal Vasko8abcecc2022-07-28 09:55:01 +02007234 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007235 LY_ERR rc;
7236
Michal Vasko03ff5a72019-09-11 13:49:33 +02007237 /* iterative evaluation with node-sets */
7238 if ((set1->type == LYXP_SET_NODE_SET) || (set2->type == LYXP_SET_NODE_SET)) {
7239 if (set1->type == LYXP_SET_NODE_SET) {
7240 for (i = 0; i < set1->used; ++i) {
Michal Vasko8abcecc2022-07-28 09:55:01 +02007241 /* evaluate for the single item */
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007242 LY_CHECK_RET(moveto_op_comp_item(set1, i, set2, op, 0, result));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007243
7244 /* lazy evaluation until true */
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007245 if (*result) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007246 return LY_SUCCESS;
7247 }
7248 }
7249 } else {
7250 for (i = 0; i < set2->used; ++i) {
Michal Vasko8abcecc2022-07-28 09:55:01 +02007251 /* evaluate for the single item */
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007252 LY_CHECK_RET(moveto_op_comp_item(set2, i, set1, op, 1, result));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007253
7254 /* lazy evaluation until true */
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007255 if (*result) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007256 return LY_SUCCESS;
7257 }
7258 }
7259 }
7260
Michal Vasko8abcecc2022-07-28 09:55:01 +02007261 /* false for all the nodes */
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007262 *result = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007263 return LY_SUCCESS;
7264 }
7265
7266 /* first convert properly */
7267 if ((op[0] == '=') || (op[0] == '!')) {
7268 if ((set1->type == LYXP_SET_BOOLEAN) || (set2->type == LYXP_SET_BOOLEAN)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007269 lyxp_set_cast(set1, LYXP_SET_BOOLEAN);
7270 lyxp_set_cast(set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007271 } else if ((set1->type == LYXP_SET_NUMBER) || (set2->type == LYXP_SET_NUMBER)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007272 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007273 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007274 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007275 LY_CHECK_RET(rc);
7276 } /* else we have 2 strings */
7277 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007278 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007279 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007280 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007281 LY_CHECK_RET(rc);
7282 }
7283
7284 assert(set1->type == set2->type);
7285
7286 /* compute result */
7287 if (op[0] == '=') {
7288 if (set1->type == LYXP_SET_BOOLEAN) {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007289 *result = (set1->val.bln == set2->val.bln);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007290 } else if (set1->type == LYXP_SET_NUMBER) {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007291 *result = (set1->val.num == set2->val.num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007292 } else {
7293 assert(set1->type == LYXP_SET_STRING);
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007294 *result = strcmp(set1->val.str, set2->val.str) ? 0 : 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007295 }
7296 } else if (op[0] == '!') {
7297 if (set1->type == LYXP_SET_BOOLEAN) {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007298 *result = (set1->val.bln != set2->val.bln);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007299 } else if (set1->type == LYXP_SET_NUMBER) {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007300 *result = (set1->val.num != set2->val.num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007301 } else {
7302 assert(set1->type == LYXP_SET_STRING);
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007303 *result = strcmp(set1->val.str, set2->val.str) ? 1 : 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007304 }
7305 } else {
7306 assert(set1->type == LYXP_SET_NUMBER);
7307 if (op[0] == '<') {
7308 if (op[1] == '=') {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007309 *result = (set1->val.num <= set2->val.num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007310 } else {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007311 *result = (set1->val.num < set2->val.num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007312 }
7313 } else {
7314 if (op[1] == '=') {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007315 *result = (set1->val.num >= set2->val.num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007316 } else {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02007317 *result = (set1->val.num > set2->val.num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007318 }
7319 }
7320 }
7321
Michal Vasko03ff5a72019-09-11 13:49:33 +02007322 return LY_SUCCESS;
7323}
7324
7325/**
7326 * @brief Move context @p set to the result of a basic operation. Handles '+', '-', unary '-', '*', 'div',
7327 * or 'mod'. Result is LYXP_SET_NUMBER. Indirectly context position aware.
7328 *
7329 * @param[in,out] set1 Set to use for the result.
7330 * @param[in] set2 Set acting as the second operand for @p op.
7331 * @param[in] op Operator to process.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007332 * @return LY_ERR
7333 */
7334static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007335moveto_op_math(struct lyxp_set *set1, struct lyxp_set *set2, const char *op)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007336{
7337 LY_ERR rc;
7338
7339 /* unary '-' */
7340 if (!set2 && (op[0] == '-')) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007341 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007342 LY_CHECK_RET(rc);
7343 set1->val.num *= -1;
7344 lyxp_set_free(set2);
7345 return LY_SUCCESS;
7346 }
7347
7348 assert(set1 && set2);
7349
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007350 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007351 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007352 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007353 LY_CHECK_RET(rc);
7354
7355 switch (op[0]) {
7356 /* '+' */
7357 case '+':
7358 set1->val.num += set2->val.num;
7359 break;
7360
7361 /* '-' */
7362 case '-':
7363 set1->val.num -= set2->val.num;
7364 break;
7365
7366 /* '*' */
7367 case '*':
7368 set1->val.num *= set2->val.num;
7369 break;
7370
7371 /* 'div' */
7372 case 'd':
7373 set1->val.num /= set2->val.num;
7374 break;
7375
7376 /* 'mod' */
7377 case 'm':
7378 set1->val.num = ((long long)set1->val.num) % ((long long)set2->val.num);
7379 break;
7380
7381 default:
7382 LOGINT_RET(set1->ctx);
7383 }
7384
7385 return LY_SUCCESS;
7386}
7387
Michal Vasko03ff5a72019-09-11 13:49:33 +02007388/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02007389 * @brief Evaluate Predicate. Logs directly on error.
7390 *
Michal Vaskod3678892020-05-21 10:06:58 +02007391 * [9] Predicate ::= '[' Expr ']'
Michal Vasko03ff5a72019-09-11 13:49:33 +02007392 *
7393 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007394 * @param[in] tok_idx Position in the expression @p exp.
aPiecek8b0cc152021-05-31 16:40:31 +02007395 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007396 * @param[in] options XPath options.
Michal Vasko49fec8e2022-05-24 10:28:33 +02007397 * @param[in] axis Axis to search on.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007398 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7399 */
7400static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02007401eval_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 +02007402{
7403 LY_ERR rc;
Michal Vaskodd528af2022-08-08 14:35:07 +02007404 uint32_t i, orig_exp, orig_pos, orig_size;
Michal Vasko5c4e5892019-11-14 12:31:38 +01007405 int32_t pred_in_ctx;
Michal Vasko88a9e802022-05-24 10:50:28 +02007406 ly_bool reverse_axis = 0;
aPiecekfff4dca2021-10-07 10:59:53 +02007407 struct lyxp_set set2 = {0};
Michal Vasko03ff5a72019-09-11 13:49:33 +02007408
7409 /* '[' */
aPiecek8b0cc152021-05-31 16:40:31 +02007410 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02007411 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007412 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007413
aPiecek8b0cc152021-05-31 16:40:31 +02007414 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007415only_parse:
aPiecek8b0cc152021-05-31 16:40:31 +02007416 rc = eval_expr_select(exp, tok_idx, 0, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007417 LY_CHECK_RET(rc);
7418 } else if (set->type == LYXP_SET_NODE_SET) {
7419 /* 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 +01007420 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007421
7422 /* empty set, nothing to evaluate */
7423 if (!set->used) {
7424 goto only_parse;
7425 }
7426
Michal Vasko49fec8e2022-05-24 10:28:33 +02007427 /* decide forward or reverse axis */
7428 switch (axis) {
7429 case LYXP_AXIS_ANCESTOR:
7430 case LYXP_AXIS_ANCESTOR_OR_SELF:
7431 case LYXP_AXIS_PRECEDING:
7432 case LYXP_AXIS_PRECEDING_SIBLING:
7433 reverse_axis = 1;
7434 break;
7435 case LYXP_AXIS_DESCENDANT:
7436 case LYXP_AXIS_DESCENDANT_OR_SELF:
7437 case LYXP_AXIS_FOLLOWING:
7438 case LYXP_AXIS_FOLLOWING_SIBLING:
7439 case LYXP_AXIS_PARENT:
7440 case LYXP_AXIS_CHILD:
7441 case LYXP_AXIS_SELF:
7442 case LYXP_AXIS_ATTRIBUTE:
7443 reverse_axis = 0;
7444 break;
7445 }
7446
Michal Vasko004d3152020-06-11 19:59:22 +02007447 orig_exp = *tok_idx;
Michal Vasko49fec8e2022-05-24 10:28:33 +02007448 orig_pos = reverse_axis ? set->used + 1 : 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007449 orig_size = set->used;
Michal Vasko39dbf352020-05-21 10:08:59 +02007450 for (i = 0; i < set->used; ++i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007451 set_init(&set2, set);
7452 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 +02007453
7454 /* remember the node context position for position() and context size for last() */
7455 orig_pos += reverse_axis ? -1 : 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007456
7457 set2.ctx_pos = orig_pos;
7458 set2.ctx_size = orig_size;
Michal Vasko004d3152020-06-11 19:59:22 +02007459 *tok_idx = orig_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007460
Michal Vasko004d3152020-06-11 19:59:22 +02007461 rc = eval_expr_select(exp, tok_idx, 0, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007462 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02007463 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007464 return rc;
7465 }
7466
Michal Vasko49fec8e2022-05-24 10:28:33 +02007467 /* number is a proximity position */
Michal Vasko03ff5a72019-09-11 13:49:33 +02007468 if (set2.type == LYXP_SET_NUMBER) {
7469 if ((long long)set2.val.num == orig_pos) {
7470 set2.val.num = 1;
7471 } else {
7472 set2.val.num = 0;
7473 }
7474 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007475 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007476
7477 /* predicate satisfied or not? */
Michal Vasko004d3152020-06-11 19:59:22 +02007478 if (!set2.val.bln) {
Michal Vasko2caefc12019-11-14 16:07:56 +01007479 set_remove_node_none(set, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007480 }
7481 }
Michal Vasko2caefc12019-11-14 16:07:56 +01007482 set_remove_nodes_none(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007483
7484 } else if (set->type == LYXP_SET_SCNODE_SET) {
7485 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01007486 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007487 /* there is a currently-valid node */
7488 break;
7489 }
7490 }
7491 /* empty set, nothing to evaluate */
7492 if (i == set->used) {
7493 goto only_parse;
7494 }
7495
Michal Vasko004d3152020-06-11 19:59:22 +02007496 orig_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007497
Michal Vasko03ff5a72019-09-11 13:49:33 +02007498 /* set special in_ctx to all the valid snodes */
7499 pred_in_ctx = set_scnode_new_in_ctx(set);
7500
7501 /* use the valid snodes one-by-one */
7502 for (i = 0; i < set->used; ++i) {
7503 if (set->val.scnodes[i].in_ctx != pred_in_ctx) {
7504 continue;
7505 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01007506 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007507
Michal Vasko004d3152020-06-11 19:59:22 +02007508 *tok_idx = orig_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007509
Michal Vasko004d3152020-06-11 19:59:22 +02007510 rc = eval_expr_select(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007511 LY_CHECK_RET(rc);
7512
7513 set->val.scnodes[i].in_ctx = pred_in_ctx;
7514 }
7515
7516 /* restore the state as it was before the predicate */
7517 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01007518 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko1a09b212021-05-06 13:00:10 +02007519 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007520 } else if (set->val.scnodes[i].in_ctx == pred_in_ctx) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01007521 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007522 }
7523 }
7524
7525 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02007526 set2.type = LYXP_SET_NODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007527 set_fill_set(&set2, set);
7528
Michal Vasko004d3152020-06-11 19:59:22 +02007529 rc = eval_expr_select(exp, tok_idx, 0, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007530 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02007531 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007532 return rc;
7533 }
7534
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007535 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko004d3152020-06-11 19:59:22 +02007536 if (!set2.val.bln) {
Michal Vaskod3678892020-05-21 10:06:58 +02007537 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007538 }
Michal Vaskod3678892020-05-21 10:06:58 +02007539 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007540 }
7541
7542 /* ']' */
Michal Vasko004d3152020-06-11 19:59:22 +02007543 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
aPiecek8b0cc152021-05-31 16:40:31 +02007544 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02007545 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007546 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007547
7548 return LY_SUCCESS;
7549}
7550
7551/**
Michal Vaskod3678892020-05-21 10:06:58 +02007552 * @brief Evaluate Literal. Logs directly on error.
7553 *
7554 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007555 * @param[in] tok_idx Position in the expression @p exp.
Michal Vaskod3678892020-05-21 10:06:58 +02007556 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7557 */
7558static void
Michal Vaskodd528af2022-08-08 14:35:07 +02007559eval_literal(const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set)
Michal Vaskod3678892020-05-21 10:06:58 +02007560{
7561 if (set) {
Michal Vasko004d3152020-06-11 19:59:22 +02007562 if (exp->tok_len[*tok_idx] == 2) {
Michal Vaskod3678892020-05-21 10:06:58 +02007563 set_fill_string(set, "", 0);
7564 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007565 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 +02007566 }
7567 }
7568 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02007569 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007570 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007571}
7572
7573/**
Michal Vasko3d969ff2022-07-29 15:02:08 +02007574 * @brief Check that a nametest in a predicate matches a key node.
7575 *
7576 * @param[in] nametest Nametest to check.
7577 * @param[in] len Length of @p nametest.
7578 * @param[in] ctx_scnode Found schema node as the context for the predicate.
7579 * @param[in] set Context set.
7580 * @param[in] key Expected key node.
7581 * @return LY_SUCCESS on success,
7582 * @return LY_ENOT if a predicate could not be compiled.
7583 * @return LY_ERR on any error.
7584 */
7585static LY_ERR
7586eval_name_test_try_compile_predicate_key(const char *nametest, uint32_t len, const struct lysc_node *ctx_scnode,
7587 const struct lyxp_set *set, const struct lysc_node *key)
7588{
7589 const struct lys_module *mod;
7590
7591 /* prefix (module) */
7592 LY_CHECK_RET(moveto_resolve_model(&nametest, &len, set, ctx_scnode, &mod));
7593 if (mod != key->module) {
7594 return LY_ENOT;
7595 }
7596
7597 /* node name */
7598 if (ly_strncmp(key->name, nametest, len)) {
7599 return LY_ENOT;
7600 }
7601
7602 return LY_SUCCESS;
7603}
7604
7605/**
7606 * @brief Append a simple predicate for the node.
7607 *
7608 * @param[in] exp Full parsed XPath expression.
7609 * @param[in] tok_idx Predicate start index in @p exp.
7610 * @param[in] end_tok_idx Predicate end index in @p exp.
7611 * @param[in] ctx_scnode Found schema node as the context for the predicate.
7612 * @param[in] set Context set.
7613 * @param[in] pred_node Node with the value referenced in the predicate.
7614 * @param[in,out] pred Predicate to append to.
7615 * @param[in,out] pred_len Length of @p pred, is updated.
7616 * @return LY_SUCCESS on success,
7617 * @return LY_ENOT if a predicate could not be compiled.
7618 * @return LY_ERR on any error.
7619 */
7620static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02007621eval_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 +02007622 const struct lysc_node *ctx_scnode, const struct lyxp_set *set, const struct lysc_node *pred_node, char **pred,
7623 uint32_t *pred_len)
7624{
7625 LY_ERR rc = LY_SUCCESS;
7626 uint32_t i;
7627 const struct lyd_node *siblings;
7628 struct lyd_node *ctx_node;
Michal Vasko5fb92a22022-08-02 09:21:37 +02007629 const struct lysc_node *sparent, *cur_scnode;
Michal Vasko3d969ff2022-07-29 15:02:08 +02007630 struct lyxp_expr *val_exp = NULL;
7631 struct lyxp_set set2 = {0};
7632 char quot;
7633
7634 /* duplicate the value expression */
7635 LY_CHECK_GOTO(rc = lyxp_expr_dup(set->ctx, exp, tok_idx, end_tok_idx, &val_exp), cleanup);
7636
7637 /* get its atoms */
Michal Vasko5fb92a22022-08-02 09:21:37 +02007638 cur_scnode = set->cur_node ? set->cur_node->schema : NULL;
7639 LY_CHECK_GOTO(rc = lyxp_atomize(set->ctx, val_exp, set->cur_mod, set->format, set->prefix_data, cur_scnode,
7640 ctx_scnode, &set2, LYXP_SCNODE), cleanup);
Michal Vasko3d969ff2022-07-29 15:02:08 +02007641
7642 /* check whether we can compile a single predicate (evaluation result value is always the same) */
7643 for (i = 0; i < set2.used; ++i) {
7644 if ((set2.val.scnodes[i].type != LYXP_NODE_ELEM) || (set2.val.scnodes[i].in_ctx < LYXP_SET_SCNODE_ATOM_NODE)) {
7645 /* skip root and context node */
7646 continue;
7647 }
7648
Michal Vasko5fb92a22022-08-02 09:21:37 +02007649 /* 1) context node descendants are traversed - do best-effort detection of the value dependency on the
7650 * context node instance */
7651 if ((set2.val.scnodes[i].axis == LYXP_AXIS_CHILD) && (set2.val.scnodes[i].scnode->parent == ctx_scnode)) {
7652 /* 1.1) context node child was accessed on the child axis, certain dependency */
Michal Vasko3d969ff2022-07-29 15:02:08 +02007653 rc = LY_ENOT;
7654 goto cleanup;
7655 }
Michal Vasko5fb92a22022-08-02 09:21:37 +02007656 if ((set2.val.scnodes[i].axis == LYXP_AXIS_DESCENDANT) || (set2.val.scnodes[i].axis == LYXP_AXIS_DESCENDANT_OR_SELF)) {
7657 for (sparent = set2.val.scnodes[i].scnode->parent; sparent && (sparent != ctx_scnode); sparent = sparent->parent) {}
7658 if (sparent) {
7659 /* 1.2) context node descendant was accessed on the descendant axis, probable dependency */
7660 rc = LY_ENOT;
7661 goto cleanup;
7662 }
7663 }
Michal Vasko3d969ff2022-07-29 15:02:08 +02007664
Michal Vasko5fb92a22022-08-02 09:21:37 +02007665 /* 2) multi-instance nodes (list or leaf-list) are traversed - all the instances need to be considered,
7666 * but the current node can be safely ignored, it is always the same data instance */
7667 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 +02007668 rc = LY_ENOT;
7669 goto cleanup;
7670 }
Michal Vasko3d969ff2022-07-29 15:02:08 +02007671 }
7672
7673 /* get any data instance of the context node, we checked it makes no difference */
7674 siblings = set->val.nodes[0].node ? lyd_child(set->val.nodes[0].node) : set->tree;
7675 LY_CHECK_GOTO(rc = lyd_find_sibling_schema(siblings, ctx_scnode, &ctx_node), cleanup);
7676
7677 /* evaluate the value subexpression with the root context node */
7678 lyxp_set_free_content(&set2);
7679 LY_CHECK_GOTO(rc = lyxp_eval(set->ctx, val_exp, set->cur_mod, set->format, set->prefix_data, set->cur_node,
7680 ctx_node, set->tree, NULL, &set2, 0), cleanup);
7681
7682 /* cast it into a string */
7683 LY_CHECK_GOTO(rc = lyxp_set_cast(&set2, LYXP_SET_STRING), cleanup);
7684
7685 /* append the JSON predicate */
7686 *pred = ly_realloc(*pred, *pred_len + 1 + strlen(pred_node->name) + 2 + strlen(set2.val.str) + 3);
7687 LY_CHECK_ERR_GOTO(!*pred, LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
7688 quot = strchr(set2.val.str, '\'') ? '\"' : '\'';
7689 *pred_len += sprintf(*pred + *pred_len, "[%s=%c%s%c]", pred_node->name, quot, set2.val.str, quot);
7690
7691cleanup:
7692 lyxp_expr_free(set->ctx, val_exp);
7693 lyxp_set_free_content(&set2);
7694 return rc;
7695}
7696
7697/**
Michal Vasko004d3152020-06-11 19:59:22 +02007698 * @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 +02007699 *
Michal Vasko004d3152020-06-11 19:59:22 +02007700 * @param[in] exp Full parsed XPath expression.
7701 * @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 +02007702 * @param[in] ctx_scnode Found schema node as the context for the predicate.
7703 * @param[in] set Context set.
Michal Vasko004d3152020-06-11 19:59:22 +02007704 * @param[out] predicates Parsed predicates.
7705 * @param[out] pred_type Type of @p predicates.
7706 * @return LY_SUCCESS on success,
Michal Vasko3d969ff2022-07-29 15:02:08 +02007707 * @return LY_ENOT if a predicate could not be compiled.
Michal Vasko004d3152020-06-11 19:59:22 +02007708 * @return LY_ERR on any error.
Michal Vaskod3678892020-05-21 10:06:58 +02007709 */
7710static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02007711eval_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 +02007712 const struct lyxp_set *set, struct ly_path_predicate **predicates, enum ly_path_pred_type *pred_type)
Michal Vaskod3678892020-05-21 10:06:58 +02007713{
Michal Vasko3d969ff2022-07-29 15:02:08 +02007714 LY_ERR rc = LY_SUCCESS;
Michal Vaskod4a6d042022-12-08 08:34:29 +01007715 uint32_t e_idx, val_start_idx, pred_idx = 0, temp_lo = 0, pred_len = 0, nested_pred;
Michal Vaskod3678892020-05-21 10:06:58 +02007716 const struct lysc_node *key;
Michal Vasko3d969ff2022-07-29 15:02:08 +02007717 char *pred = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02007718 struct lyxp_expr *exp2 = NULL;
Michal Vaskod3678892020-05-21 10:06:58 +02007719
Michal Vasko3d969ff2022-07-29 15:02:08 +02007720 assert(ctx_scnode->nodetype & (LYS_LIST | LYS_LEAFLIST));
Michal Vaskod3678892020-05-21 10:06:58 +02007721
Michal Vasko3d969ff2022-07-29 15:02:08 +02007722 /* turn logging off */
Michal Vaskod4a6d042022-12-08 08:34:29 +01007723 ly_temp_log_options(&temp_lo);
Michal Vasko3d969ff2022-07-29 15:02:08 +02007724
7725 if (ctx_scnode->nodetype == LYS_LIST) {
7726 /* check for predicates "[key1=...][key2=...]..." */
7727
Michal Vasko004d3152020-06-11 19:59:22 +02007728 /* get key count */
Michal Vasko3d969ff2022-07-29 15:02:08 +02007729 if (ctx_scnode->flags & LYS_KEYLESS) {
7730 rc = LY_ENOT;
7731 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +02007732 }
Michal Vaskod3678892020-05-21 10:06:58 +02007733
Michal Vasko004d3152020-06-11 19:59:22 +02007734 /* learn where the predicates end */
7735 e_idx = *tok_idx;
Michal Vasko3d969ff2022-07-29 15:02:08 +02007736 for (key = lysc_node_child(ctx_scnode); key && (key->flags & LYS_KEY); key = key->next) {
Michal Vasko004d3152020-06-11 19:59:22 +02007737 /* '[' */
7738 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
Michal Vasko3d969ff2022-07-29 15:02:08 +02007739 rc = LY_ENOT;
7740 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +02007741 }
7742 ++e_idx;
7743
Michal Vasko3354d272021-04-06 09:40:06 +02007744 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_NAMETEST)) {
Michal Vasko3d969ff2022-07-29 15:02:08 +02007745 /* not a key */
7746 rc = LY_ENOT;
7747 goto cleanup;
Michal Vasko3354d272021-04-06 09:40:06 +02007748 }
7749
Michal Vasko3d969ff2022-07-29 15:02:08 +02007750 /* check key */
7751 LY_CHECK_GOTO(rc = eval_name_test_try_compile_predicate_key(exp->expr + exp->tok_pos[e_idx],
7752 exp->tok_len[e_idx], ctx_scnode, set, key), cleanup);
7753
7754 ++e_idx;
7755
7756 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_OPER_EQUAL)) {
7757 /* not '=' */
7758 rc = LY_ENOT;
7759 goto cleanup;
7760 }
7761 ++e_idx;
7762
7763 /* value start */
7764 val_start_idx = e_idx;
7765
Michal Vasko004d3152020-06-11 19:59:22 +02007766 /* ']' */
Michal Vasko3ef7e252022-11-16 08:29:49 +01007767 nested_pred = 1;
7768 do {
7769 ++e_idx;
7770
7771 if ((nested_pred == 1) && !lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_OPER_LOG)) {
Michal Vaskob8ee3562022-08-02 10:43:17 +02007772 /* higher priority than '=' */
7773 rc = LY_ENOT;
7774 goto cleanup;
Michal Vasko3ef7e252022-11-16 08:29:49 +01007775 } else if (!lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
7776 /* nested predicate */
7777 ++nested_pred;
7778 } else if (!lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK2)) {
7779 /* predicate end */
7780 --nested_pred;
Michal Vaskob8ee3562022-08-02 10:43:17 +02007781 }
Michal Vasko3ef7e252022-11-16 08:29:49 +01007782 } while (nested_pred);
Michal Vasko004d3152020-06-11 19:59:22 +02007783
Michal Vasko3d969ff2022-07-29 15:02:08 +02007784 /* try to evaluate the value */
7785 LY_CHECK_GOTO(rc = eval_name_test_try_compile_predicate_append(exp, val_start_idx, e_idx - 1, ctx_scnode,
7786 set, key, &pred, &pred_len), cleanup);
7787
7788 ++e_idx;
Michal Vasko004d3152020-06-11 19:59:22 +02007789 }
Michal Vasko004d3152020-06-11 19:59:22 +02007790 } else {
Michal Vasko3d969ff2022-07-29 15:02:08 +02007791 /* check for predicate "[.=...]" */
7792
Michal Vasko004d3152020-06-11 19:59:22 +02007793 /* learn just where this single predicate ends */
7794 e_idx = *tok_idx;
7795
Michal Vaskod3678892020-05-21 10:06:58 +02007796 /* '[' */
Michal Vasko004d3152020-06-11 19:59:22 +02007797 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
Michal Vasko3d969ff2022-07-29 15:02:08 +02007798 rc = LY_ENOT;
7799 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +02007800 }
7801 ++e_idx;
Michal Vaskod3678892020-05-21 10:06:58 +02007802
Michal Vasko3354d272021-04-06 09:40:06 +02007803 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_DOT)) {
Michal Vasko3d969ff2022-07-29 15:02:08 +02007804 /* not the node value */
7805 rc = LY_ENOT;
7806 goto cleanup;
Michal Vasko3354d272021-04-06 09:40:06 +02007807 }
Michal Vasko3d969ff2022-07-29 15:02:08 +02007808 ++e_idx;
7809
7810 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_OPER_EQUAL)) {
7811 /* not '=' */
7812 rc = LY_ENOT;
7813 goto cleanup;
7814 }
7815 ++e_idx;
7816
7817 /* value start */
7818 val_start_idx = e_idx;
Michal Vasko3354d272021-04-06 09:40:06 +02007819
Michal Vaskod3678892020-05-21 10:06:58 +02007820 /* ']' */
Michal Vasko31f19632022-11-16 09:38:40 +01007821 nested_pred = 1;
7822 do {
7823 ++e_idx;
7824
7825 if ((nested_pred == 1) && !lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_OPER_LOG)) {
Michal Vaskob8ee3562022-08-02 10:43:17 +02007826 /* higher priority than '=' */
7827 rc = LY_ENOT;
7828 goto cleanup;
Michal Vasko31f19632022-11-16 09:38:40 +01007829 } else if (!lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
7830 /* nested predicate */
7831 ++nested_pred;
7832 } else if (!lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK2)) {
7833 /* predicate end */
7834 --nested_pred;
Michal Vaskob8ee3562022-08-02 10:43:17 +02007835 }
Michal Vasko31f19632022-11-16 09:38:40 +01007836 } while (nested_pred);
Michal Vasko3d969ff2022-07-29 15:02:08 +02007837
7838 /* try to evaluate the value */
7839 LY_CHECK_GOTO(rc = eval_name_test_try_compile_predicate_append(exp, val_start_idx, e_idx - 1, ctx_scnode, set,
7840 ctx_scnode, &pred, &pred_len), cleanup);
7841
Michal Vasko004d3152020-06-11 19:59:22 +02007842 ++e_idx;
Michal Vaskod3678892020-05-21 10:06:58 +02007843 }
7844
Michal Vasko004d3152020-06-11 19:59:22 +02007845 /* parse the predicate(s) */
Michal Vasko3d969ff2022-07-29 15:02:08 +02007846 LY_CHECK_GOTO(rc = ly_path_parse_predicate(set->ctx, ctx_scnode, pred, pred_len, LY_PATH_PREFIX_OPTIONAL,
7847 LY_PATH_PRED_SIMPLE, &exp2), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02007848
7849 /* compile */
Michal Vasko3d969ff2022-07-29 15:02:08 +02007850 rc = ly_path_compile_predicate(set->ctx, set->cur_node ? set->cur_node->schema : NULL, set->cur_mod, ctx_scnode, exp2,
7851 &pred_idx, LY_VALUE_JSON, NULL, predicates, pred_type);
7852 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02007853
7854 /* success, the predicate must include all the needed information for hash-based search */
7855 *tok_idx = e_idx;
7856
7857cleanup:
Michal Vaskod4a6d042022-12-08 08:34:29 +01007858 ly_temp_log_options(NULL);
Michal Vasko3d969ff2022-07-29 15:02:08 +02007859 lyxp_expr_free(set->ctx, exp2);
7860 free(pred);
7861 return rc;
Michal Vaskod3678892020-05-21 10:06:58 +02007862}
7863
7864/**
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007865 * @brief Search for/check the next schema node that could be the only matching schema node meaning the
7866 * data node(s) could be found using a single hash-based search.
7867 *
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007868 * @param[in] ctx libyang context.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007869 * @param[in] node Next context node to check.
7870 * @param[in] name Expected node name.
7871 * @param[in] name_len Length of @p name.
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007872 * @param[in] moveto_mod Expected node module, can be NULL for JSON format with no prefix.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007873 * @param[in] root_type XPath root type.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007874 * @param[in] format Prefix format.
7875 * @param[in,out] found Previously found node, is updated.
7876 * @return LY_SUCCESS on success,
7877 * @return LY_ENOT if the whole check failed and hashes cannot be used.
7878 */
7879static LY_ERR
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007880eval_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 +02007881 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 +02007882 const struct lysc_node **found)
7883{
7884 const struct lysc_node *scnode;
7885 const struct lys_module *mod;
7886 uint32_t idx = 0;
7887
Radek Krejci8df109d2021-04-23 12:19:08 +02007888 assert((format == LY_VALUE_JSON) || moveto_mod);
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007889
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007890continue_search:
Michal Vasko7d1d0912020-10-16 08:38:30 +02007891 scnode = NULL;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007892 if (!node) {
Radek Krejci8df109d2021-04-23 12:19:08 +02007893 if ((format == LY_VALUE_JSON) && !moveto_mod) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007894 /* search all modules for a single match */
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007895 while ((mod = ly_ctx_get_module_iter(ctx, &idx))) {
Michal Vasko35a3b1d2021-07-14 09:34:16 +02007896 if (!mod->implemented) {
7897 continue;
7898 }
7899
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007900 scnode = lys_find_child(NULL, mod, name, name_len, 0, 0);
7901 if (scnode) {
7902 /* we have found a match */
7903 break;
7904 }
7905 }
7906
Michal Vasko7d1d0912020-10-16 08:38:30 +02007907 if (!scnode) {
7908 /* all modules searched */
7909 idx = 0;
7910 }
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007911 } else {
7912 /* search in top-level */
7913 scnode = lys_find_child(NULL, moveto_mod, name, name_len, 0, 0);
7914 }
7915 } else if (!*found || (lysc_data_parent(*found) != node->schema)) {
Radek Krejci8df109d2021-04-23 12:19:08 +02007916 if ((format == LY_VALUE_JSON) && !moveto_mod) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007917 /* we must adjust the module to inherit the one from the context node */
7918 moveto_mod = node->schema->module;
7919 }
7920
7921 /* search in children, do not repeat the same search */
7922 scnode = lys_find_child(node->schema, moveto_mod, name, name_len, 0, 0);
Michal Vasko7d1d0912020-10-16 08:38:30 +02007923 } /* else skip redundant search */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007924
7925 /* additional context check */
7926 if (scnode && (root_type == LYXP_NODE_ROOT_CONFIG) && (scnode->flags & LYS_CONFIG_R)) {
7927 scnode = NULL;
7928 }
7929
7930 if (scnode) {
7931 if (*found) {
7932 /* we found a schema node with the same name but at different level, give up, too complicated
7933 * (more hash-based searches would be required, not supported) */
7934 return LY_ENOT;
7935 } else {
7936 /* remember the found schema node and continue to make sure it can be used */
7937 *found = scnode;
7938 }
7939 }
7940
7941 if (idx) {
7942 /* continue searching all the following models */
7943 goto continue_search;
7944 }
7945
7946 return LY_SUCCESS;
7947}
7948
7949/**
Michal Vasko4ad69e72021-10-26 16:25:55 +02007950 * @brief Generate message when no matching schema nodes were found for a path segment.
7951 *
7952 * @param[in] set XPath set.
7953 * @param[in] scparent Previous schema parent in the context, if only one.
7954 * @param[in] ncname XPath NCName being evaluated.
7955 * @param[in] ncname_len Length of @p ncname.
7956 * @param[in] expr Whole XPath expression.
7957 * @param[in] options XPath options.
7958 */
7959static void
7960eval_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 +02007961 uint32_t ncname_len, const char *expr, uint32_t options)
Michal Vasko4ad69e72021-10-26 16:25:55 +02007962{
7963 const char *format;
7964 char *path = NULL, *ppath = NULL;
7965
7966 path = lysc_path(set->cur_scnode, LYSC_PATH_LOG, NULL, 0);
7967 if (scparent) {
7968 /* generate path for the parent */
7969 if (scparent->type == LYXP_NODE_ELEM) {
7970 ppath = lysc_path(scparent->scnode, LYSC_PATH_LOG, NULL, 0);
7971 } else if (scparent->type == LYXP_NODE_ROOT) {
7972 ppath = strdup("<root>");
7973 } else if (scparent->type == LYXP_NODE_ROOT_CONFIG) {
7974 ppath = strdup("<config-root>");
7975 }
7976 }
7977 if (ppath) {
7978 format = "Schema node \"%.*s\" for parent \"%s\" not found; in expr \"%.*s\" with context node \"%s\".";
7979 if (options & LYXP_SCNODE_ERROR) {
7980 LOGERR(set->ctx, LY_EVALID, format, ncname_len, ncname, ppath, (ncname - expr) + ncname_len, expr, path);
7981 } else {
7982 LOGWRN(set->ctx, format, ncname_len, ncname, ppath, (ncname - expr) + ncname_len, expr, path);
7983 }
7984 } else {
7985 format = "Schema node \"%.*s\" not found; in expr \"%.*s\" with context node \"%s\".";
7986 if (options & LYXP_SCNODE_ERROR) {
7987 LOGERR(set->ctx, LY_EVALID, format, ncname_len, ncname, (ncname - expr) + ncname_len, expr, path);
7988 } else {
7989 LOGWRN(set->ctx, format, ncname_len, ncname, (ncname - expr) + ncname_len, expr, path);
7990 }
7991 }
7992 free(path);
7993 free(ppath);
7994}
7995
7996/**
Michal Vaskod3678892020-05-21 10:06:58 +02007997 * @brief Evaluate NameTest and any following Predicates. Logs directly on error.
7998 *
7999 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
8000 * [6] NodeTest ::= NameTest | NodeType '(' ')'
8001 * [7] NameTest ::= '*' | NCName ':' '*' | QName
8002 *
8003 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008004 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko49fec8e2022-05-24 10:28:33 +02008005 * @param[in] axis What axis to search on.
Michal Vaskod3678892020-05-21 10:06:58 +02008006 * @param[in] all_desc Whether to search all the descendants or children only.
aPiecek8b0cc152021-05-31 16:40:31 +02008007 * @param[in,out] set Context and result set.
Michal Vaskod3678892020-05-21 10:06:58 +02008008 * @param[in] options XPath options.
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008009 * @return LY_ERR (LY_EINCOMPLETE on unresolved when, LY_ENOT for not found schema node)
Michal Vaskod3678892020-05-21 10:06:58 +02008010 */
8011static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008012eval_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 +02008013 struct lyxp_set *set, uint32_t options)
Michal Vaskod3678892020-05-21 10:06:58 +02008014{
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008015 LY_ERR rc = LY_SUCCESS, r;
Michal Vasko004d3152020-06-11 19:59:22 +02008016 const char *ncname, *ncname_dict = NULL;
Michal Vasko56c008c2022-07-29 14:57:47 +02008017 uint32_t i, ncname_len;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008018 const struct lys_module *moveto_mod = NULL;
Michal Vaskoc71c37b2021-01-11 13:40:02 +01008019 const struct lysc_node *scnode = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02008020 struct ly_path_predicate *predicates = NULL;
8021 enum ly_path_pred_type pred_type = 0;
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008022 int scnode_skip_pred = 0;
Michal Vaskod3678892020-05-21 10:06:58 +02008023
aPiecek8b0cc152021-05-31 16:40:31 +02008024 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008025 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008026 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02008027
aPiecek8b0cc152021-05-31 16:40:31 +02008028 if (options & LYXP_SKIP_EXPR) {
Michal Vaskod3678892020-05-21 10:06:58 +02008029 goto moveto;
8030 }
8031
Michal Vasko004d3152020-06-11 19:59:22 +02008032 ncname = &exp->expr[exp->tok_pos[*tok_idx - 1]];
8033 ncname_len = exp->tok_len[*tok_idx - 1];
Michal Vaskod3678892020-05-21 10:06:58 +02008034
Michal Vaskoc71c37b2021-01-11 13:40:02 +01008035 if ((ncname[0] == '*') && (ncname_len == 1)) {
8036 /* all nodes will match */
8037 goto moveto;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008038 }
8039
Michal Vaskoc71c37b2021-01-11 13:40:02 +01008040 /* parse (and skip) module name */
8041 rc = moveto_resolve_model(&ncname, &ncname_len, set, NULL, &moveto_mod);
Michal Vaskod3678892020-05-21 10:06:58 +02008042 LY_CHECK_GOTO(rc, cleanup);
8043
Michal Vasko49fec8e2022-05-24 10:28:33 +02008044 if ((ncname[0] == '*') && (ncname_len == 1)) {
8045 /* all nodes from the module will match */
8046 goto moveto;
8047 }
8048
8049 if (((set->format == LY_VALUE_JSON) || moveto_mod) && (axis == LYXP_AXIS_CHILD) && !all_desc &&
8050 (set->type == LYXP_SET_NODE_SET)) {
Michal Vaskod3678892020-05-21 10:06:58 +02008051 /* find the matching schema node in some parent in the context */
Michal Vasko56c008c2022-07-29 14:57:47 +02008052 for (i = 0; i < set->used; ++i) {
Michal Vaskoc71c37b2021-01-11 13:40:02 +01008053 if (eval_name_test_with_predicate_get_scnode(set->ctx, set->val.nodes[i].node, ncname, ncname_len,
8054 moveto_mod, set->root_type, set->format, &scnode)) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008055 /* check failed */
8056 scnode = NULL;
8057 break;
Michal Vaskod3678892020-05-21 10:06:58 +02008058 }
8059 }
8060
Michal Vasko004d3152020-06-11 19:59:22 +02008061 if (scnode && (scnode->nodetype & (LYS_LIST | LYS_LEAFLIST))) {
8062 /* try to create the predicates */
Michal Vasko3d969ff2022-07-29 15:02:08 +02008063 if (eval_name_test_try_compile_predicates(exp, tok_idx, scnode, set, &predicates, &pred_type)) {
Michal Vasko004d3152020-06-11 19:59:22 +02008064 /* hashes cannot be used */
Michal Vaskod3678892020-05-21 10:06:58 +02008065 scnode = NULL;
8066 }
8067 }
8068 }
8069
Michal Vaskoc71c37b2021-01-11 13:40:02 +01008070 if (!scnode) {
8071 /* we are not able to match based on a schema node and not all the modules match ("*"),
Michal Vasko004d3152020-06-11 19:59:22 +02008072 * use dictionary for efficient comparison */
Radek Krejci011e4aa2020-09-04 15:22:31 +02008073 LY_CHECK_GOTO(rc = lydict_insert(set->ctx, ncname, ncname_len, &ncname_dict), cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02008074 }
8075
8076moveto:
8077 /* move to the attribute(s), data node(s), or schema node(s) */
Michal Vasko49fec8e2022-05-24 10:28:33 +02008078 if (axis == LYXP_AXIS_ATTRIBUTE) {
aPiecek8b0cc152021-05-31 16:40:31 +02008079 if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02008080 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vaskod3678892020-05-21 10:06:58 +02008081 } else {
8082 if (all_desc) {
Michal Vaskocdad7122020-11-09 21:04:44 +01008083 rc = moveto_attr_alldesc(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008084 } else {
aPiecek8b0cc152021-05-31 16:40:31 +02008085 rc = moveto_attr(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008086 }
8087 LY_CHECK_GOTO(rc, cleanup);
8088 }
8089 } else {
aPiecek8b0cc152021-05-31 16:40:31 +02008090 if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008091 const struct lyxp_set_scnode *scparent = NULL;
Michal Vasko56c008c2022-07-29 14:57:47 +02008092 ly_bool found = 0;
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008093
8094 /* remember parent if there is only one, to print in the warning */
8095 for (i = 0; i < set->used; ++i) {
8096 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
8097 if (!scparent) {
8098 /* remember the context node */
8099 scparent = &set->val.scnodes[i];
8100 } else {
8101 /* several context nodes, no reasonable error possible */
8102 scparent = NULL;
8103 break;
8104 }
8105 }
8106 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02008107
Michal Vasko49fec8e2022-05-24 10:28:33 +02008108 if (all_desc && (axis == LYXP_AXIS_CHILD)) {
8109 /* efficient evaluation that does not add all the descendants into the set */
8110 rc = moveto_scnode_alldesc_child(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008111 } else {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008112 if (all_desc) {
8113 /* "//" == "/descendant-or-self::node()/" */
8114 rc = xpath_pi_node(set, LYXP_AXIS_DESCENDANT_OR_SELF, options);
8115 LY_CHECK_GOTO(rc, cleanup);
8116 }
8117 rc = moveto_scnode(set, moveto_mod, ncname_dict, axis, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008118 }
8119 LY_CHECK_GOTO(rc, cleanup);
8120
Michal Vasko56c008c2022-07-29 14:57:47 +02008121 i = set->used;
8122 do {
8123 --i;
Michal Vasko1a09b212021-05-06 13:00:10 +02008124 if (set->val.scnodes[i].in_ctx > LYXP_SET_SCNODE_ATOM_NODE) {
Michal Vasko56c008c2022-07-29 14:57:47 +02008125 found = 1;
Michal Vaskod3678892020-05-21 10:06:58 +02008126 break;
8127 }
Michal Vasko56c008c2022-07-29 14:57:47 +02008128 } while (i);
8129 if (!found) {
Michal Vasko4ad69e72021-10-26 16:25:55 +02008130 /* generate message */
8131 eval_name_test_scnode_no_match_msg(set, scparent, ncname, ncname_len, exp->expr, options);
8132
8133 if (options & LYXP_SCNODE_ERROR) {
8134 /* error */
8135 rc = LY_EVALID;
8136 goto cleanup;
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008137 }
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008138
8139 /* skip the predicates and the rest of this path to not generate invalid warnings */
8140 rc = LY_ENOT;
8141 scnode_skip_pred = 1;
Michal Vaskod3678892020-05-21 10:06:58 +02008142 }
8143 } else {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008144 if (all_desc && (axis == LYXP_AXIS_CHILD)) {
8145 /* efficient evaluation */
8146 rc = moveto_node_alldesc_child(set, moveto_mod, ncname_dict, options);
8147 } else if (scnode && (axis == LYXP_AXIS_CHILD)) {
8148 /* we can find the child nodes using hashes */
8149 rc = moveto_node_hash_child(set, scnode, predicates, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008150 } else {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008151 if (all_desc) {
8152 /* "//" == "/descendant-or-self::node()/" */
8153 rc = xpath_pi_node(set, LYXP_AXIS_DESCENDANT_OR_SELF, options);
8154 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02008155 }
Michal Vasko49fec8e2022-05-24 10:28:33 +02008156 rc = moveto_node(set, moveto_mod, ncname_dict, axis, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008157 }
8158 LY_CHECK_GOTO(rc, cleanup);
8159 }
8160 }
8161
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008162 if (scnode_skip_pred) {
8163 /* skip predicates */
8164 options |= LYXP_SKIP_EXPR;
8165 }
8166
Michal Vaskod3678892020-05-21 10:06:58 +02008167 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02008168 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008169 r = eval_predicate(exp, tok_idx, set, options, axis);
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008170 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02008171 }
8172
8173cleanup:
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008174 if (scnode_skip_pred) {
8175 /* restore options */
8176 options &= ~LYXP_SKIP_EXPR;
8177 }
aPiecek8b0cc152021-05-31 16:40:31 +02008178 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko004d3152020-06-11 19:59:22 +02008179 lydict_remove(set->ctx, ncname_dict);
Michal Vaskof7e16e22020-10-21 09:24:39 +02008180 ly_path_predicates_free(set->ctx, pred_type, predicates);
Michal Vaskodb51a8d2020-05-27 15:22:29 +02008181 }
Michal Vaskod3678892020-05-21 10:06:58 +02008182 return rc;
8183}
8184
8185/**
8186 * @brief Evaluate NodeType and any following Predicates. Logs directly on error.
8187 *
8188 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
8189 * [6] NodeTest ::= NameTest | NodeType '(' ')'
8190 * [8] NodeType ::= 'text' | 'node'
8191 *
8192 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008193 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko49fec8e2022-05-24 10:28:33 +02008194 * @param[in] axis Axis to search on.
8195 * @param[in] all_desc Whether to search all the descendants or axis only.
aPiecek8b0cc152021-05-31 16:40:31 +02008196 * @param[in,out] set Context and result set.
Michal Vaskod3678892020-05-21 10:06:58 +02008197 * @param[in] options XPath options.
8198 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8199 */
8200static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008201eval_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 +02008202 struct lyxp_set *set, uint32_t options)
Michal Vaskod3678892020-05-21 10:06:58 +02008203{
8204 LY_ERR rc;
8205
Michal Vaskod3678892020-05-21 10:06:58 +02008206 (void)all_desc;
8207
aPiecek8b0cc152021-05-31 16:40:31 +02008208 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko004d3152020-06-11 19:59:22 +02008209 assert(exp->tok_len[*tok_idx] == 4);
Michal Vasko49fec8e2022-05-24 10:28:33 +02008210 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "node", 4)) {
8211 rc = xpath_pi_node(set, axis, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008212 } else {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008213 assert(!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "text", 4));
8214 rc = xpath_pi_text(set, axis, options);
Michal Vaskod3678892020-05-21 10:06:58 +02008215 }
Michal Vasko49fec8e2022-05-24 10:28:33 +02008216 LY_CHECK_RET(rc);
Michal Vaskod3678892020-05-21 10:06:58 +02008217 }
aPiecek8b0cc152021-05-31 16:40:31 +02008218 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008219 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008220 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02008221
8222 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02008223 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
aPiecek8b0cc152021-05-31 16:40:31 +02008224 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008225 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008226 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02008227
8228 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02008229 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
aPiecek8b0cc152021-05-31 16:40:31 +02008230 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008231 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008232 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02008233
8234 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02008235 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008236 rc = eval_predicate(exp, tok_idx, set, options, axis);
Michal Vaskod3678892020-05-21 10:06:58 +02008237 LY_CHECK_RET(rc);
8238 }
8239
8240 return LY_SUCCESS;
8241}
8242
8243/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02008244 * @brief Evaluate RelativeLocationPath. Logs directly on error.
8245 *
8246 * [4] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
8247 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
Michal Vaskod3678892020-05-21 10:06:58 +02008248 * [6] NodeTest ::= NameTest | NodeType '(' ')'
Michal Vasko03ff5a72019-09-11 13:49:33 +02008249 *
8250 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008251 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008252 * @param[in] all_desc Whether to search all the descendants or children only.
aPiecek8b0cc152021-05-31 16:40:31 +02008253 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008254 * @param[in] options XPath options.
8255 * @return LY_ERR (YL_EINCOMPLETE on unresolved when)
8256 */
8257static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008258eval_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 +02008259 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008260{
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008261 LY_ERR rc = LY_SUCCESS;
Michal Vasko49fec8e2022-05-24 10:28:33 +02008262 enum lyxp_axis axis;
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008263 int scnode_skip_path = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008264
8265 goto step;
8266 do {
8267 /* evaluate '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02008268 if (exp->tok_len[*tok_idx] == 1) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008269 all_desc = 0;
8270 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02008271 assert(exp->tok_len[*tok_idx] == 2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008272 all_desc = 1;
8273 }
aPiecek8b0cc152021-05-31 16:40:31 +02008274 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008275 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008276 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008277
8278step:
Michal Vasko49fec8e2022-05-24 10:28:33 +02008279 /* AxisSpecifier */
8280 if (exp->tokens[*tok_idx] == LYXP_TOKEN_AXISNAME) {
8281 axis = str2axis(exp->expr + exp->tok_pos[*tok_idx], exp->tok_len[*tok_idx]);
Michal Vaskod3678892020-05-21 10:06:58 +02008282
aPiecek8b0cc152021-05-31 16:40:31 +02008283 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008284 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
8285 ++(*tok_idx);
8286
8287 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_DCOLON);
8288 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
8289 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
8290 ++(*tok_idx);
8291 } else if (exp->tokens[*tok_idx] == LYXP_TOKEN_AT) {
8292 axis = LYXP_AXIS_ATTRIBUTE;
8293
8294 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
8295 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008296 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02008297 } else {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008298 /* default */
8299 axis = LYXP_AXIS_CHILD;
Michal Vaskod3678892020-05-21 10:06:58 +02008300 }
8301
Michal Vasko49fec8e2022-05-24 10:28:33 +02008302 /* NodeTest Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02008303 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008304 case LYXP_TOKEN_DOT:
8305 /* evaluate '.' */
Michal Vasko49fec8e2022-05-24 10:28:33 +02008306 if (!(options & LYXP_SKIP_EXPR)) {
8307 if (((options & LYXP_SCNODE_ALL) && (set->type != LYXP_SET_SCNODE_SET)) ||
8308 (!(options & LYXP_SCNODE_ALL) && (set->type != LYXP_SET_NODE_SET))) {
8309 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
8310 rc = LY_EVALID;
8311 goto cleanup;
8312 }
8313
8314 if (all_desc) {
8315 rc = xpath_pi_node(set, LYXP_AXIS_DESCENDANT_OR_SELF, options);
8316 LY_CHECK_GOTO(rc, cleanup);
8317 }
8318 rc = xpath_pi_node(set, LYXP_AXIS_SELF, options);
8319 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008320 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02008321 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008322 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008323 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008324 break;
8325
8326 case LYXP_TOKEN_DDOT:
8327 /* evaluate '..' */
Michal Vasko49fec8e2022-05-24 10:28:33 +02008328 if (!(options & LYXP_SKIP_EXPR)) {
8329 if (((options & LYXP_SCNODE_ALL) && (set->type != LYXP_SET_SCNODE_SET)) ||
8330 (!(options & LYXP_SCNODE_ALL) && (set->type != LYXP_SET_NODE_SET))) {
8331 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
8332 rc = LY_EVALID;
8333 goto cleanup;
8334 }
8335
8336 if (all_desc) {
8337 rc = xpath_pi_node(set, LYXP_AXIS_DESCENDANT_OR_SELF, options);
8338 LY_CHECK_GOTO(rc, cleanup);
8339 }
8340 rc = xpath_pi_node(set, LYXP_AXIS_PARENT, options);
8341 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008342 }
aPiecek8b0cc152021-05-31 16:40:31 +02008343 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008344 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008345 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008346 break;
8347
Michal Vasko03ff5a72019-09-11 13:49:33 +02008348 case LYXP_TOKEN_NAMETEST:
Michal Vaskod3678892020-05-21 10:06:58 +02008349 /* evaluate NameTest Predicate* */
Michal Vasko49fec8e2022-05-24 10:28:33 +02008350 rc = eval_name_test_with_predicate(exp, tok_idx, axis, all_desc, set, options);
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008351 if (rc == LY_ENOT) {
8352 assert(options & LYXP_SCNODE_ALL);
8353 /* skip the rest of this path */
8354 rc = LY_SUCCESS;
8355 scnode_skip_path = 1;
8356 options |= LYXP_SKIP_EXPR;
8357 }
8358 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02008359 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008360
Michal Vaskod3678892020-05-21 10:06:58 +02008361 case LYXP_TOKEN_NODETYPE:
8362 /* evaluate NodeType Predicate* */
Michal Vasko49fec8e2022-05-24 10:28:33 +02008363 rc = eval_node_type_with_predicate(exp, tok_idx, axis, all_desc, set, options);
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008364 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008365 break;
8366
8367 default:
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008368 LOGINT(set->ctx);
8369 rc = LY_EINT;
8370 goto cleanup;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008371 }
Michal Vasko004d3152020-06-11 19:59:22 +02008372 } while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008373
Michal Vaskoa036a6b2021-10-12 16:05:23 +02008374cleanup:
8375 if (scnode_skip_path) {
8376 options &= ~LYXP_SKIP_EXPR;
8377 }
8378 return rc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008379}
8380
8381/**
8382 * @brief Evaluate AbsoluteLocationPath. Logs directly on error.
8383 *
8384 * [3] AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
8385 *
8386 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008387 * @param[in] tok_idx Position in the expression @p exp.
aPiecek8b0cc152021-05-31 16:40:31 +02008388 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008389 * @param[in] options XPath options.
8390 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8391 */
8392static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008393eval_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 +02008394{
Radek Krejci857189e2020-09-01 13:26:36 +02008395 ly_bool all_desc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008396
aPiecek8b0cc152021-05-31 16:40:31 +02008397 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008398 /* no matter what tokens follow, we need to be at the root */
Michal Vaskob0099a92020-08-31 14:55:23 +02008399 LY_CHECK_RET(moveto_root(set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008400 }
8401
8402 /* '/' RelativeLocationPath? */
Michal Vasko004d3152020-06-11 19:59:22 +02008403 if (exp->tok_len[*tok_idx] == 1) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008404 /* evaluate '/' - deferred */
8405 all_desc = 0;
aPiecek8b0cc152021-05-31 16:40:31 +02008406 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008407 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008408 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008409
Michal Vasko004d3152020-06-11 19:59:22 +02008410 if (lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008411 return LY_SUCCESS;
8412 }
Michal Vasko004d3152020-06-11 19:59:22 +02008413 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008414 case LYXP_TOKEN_DOT:
8415 case LYXP_TOKEN_DDOT:
Michal Vasko49fec8e2022-05-24 10:28:33 +02008416 case LYXP_TOKEN_AXISNAME:
Michal Vasko03ff5a72019-09-11 13:49:33 +02008417 case LYXP_TOKEN_AT:
8418 case LYXP_TOKEN_NAMETEST:
8419 case LYXP_TOKEN_NODETYPE:
Michal Vaskob0099a92020-08-31 14:55:23 +02008420 LY_CHECK_RET(eval_relative_location_path(exp, tok_idx, all_desc, set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008421 break;
8422 default:
8423 break;
8424 }
8425
Michal Vasko03ff5a72019-09-11 13:49:33 +02008426 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02008427 /* '//' RelativeLocationPath */
Michal Vasko03ff5a72019-09-11 13:49:33 +02008428 /* evaluate '//' - deferred so as not to waste memory by remembering all the nodes */
8429 all_desc = 1;
aPiecek8b0cc152021-05-31 16:40:31 +02008430 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008431 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008432 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008433
Michal Vaskob0099a92020-08-31 14:55:23 +02008434 LY_CHECK_RET(eval_relative_location_path(exp, tok_idx, all_desc, set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008435 }
8436
8437 return LY_SUCCESS;
8438}
8439
8440/**
8441 * @brief Evaluate FunctionCall. Logs directly on error.
8442 *
Michal Vaskod3678892020-05-21 10:06:58 +02008443 * [11] FunctionCall ::= FunctionName '(' ( Expr ( ',' Expr )* )? ')'
Michal Vasko03ff5a72019-09-11 13:49:33 +02008444 *
8445 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008446 * @param[in] tok_idx Position in the expression @p exp.
aPiecek8b0cc152021-05-31 16:40:31 +02008447 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008448 * @param[in] options XPath options.
8449 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8450 */
8451static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008452eval_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 +02008453{
8454 LY_ERR rc;
Michal Vasko69730152020-10-09 16:30:07 +02008455
Michal Vaskodd528af2022-08-08 14:35:07 +02008456 LY_ERR (*xpath_func)(struct lyxp_set **, uint32_t, struct lyxp_set *, uint32_t) = NULL;
8457 uint32_t arg_count = 0, i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008458 struct lyxp_set **args = NULL, **args_aux;
8459
aPiecek8b0cc152021-05-31 16:40:31 +02008460 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008461 /* FunctionName */
Michal Vasko004d3152020-06-11 19:59:22 +02008462 switch (exp->tok_len[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008463 case 3:
Michal Vasko004d3152020-06-11 19:59:22 +02008464 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "not", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008465 xpath_func = &xpath_not;
Michal Vasko004d3152020-06-11 19:59:22 +02008466 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "sum", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008467 xpath_func = &xpath_sum;
8468 }
8469 break;
8470 case 4:
Michal Vasko004d3152020-06-11 19:59:22 +02008471 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "lang", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008472 xpath_func = &xpath_lang;
Michal Vasko004d3152020-06-11 19:59:22 +02008473 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "last", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008474 xpath_func = &xpath_last;
Michal Vasko004d3152020-06-11 19:59:22 +02008475 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "name", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008476 xpath_func = &xpath_name;
Michal Vasko004d3152020-06-11 19:59:22 +02008477 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "true", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008478 xpath_func = &xpath_true;
8479 }
8480 break;
8481 case 5:
Michal Vasko004d3152020-06-11 19:59:22 +02008482 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "count", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008483 xpath_func = &xpath_count;
Michal Vasko004d3152020-06-11 19:59:22 +02008484 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "false", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008485 xpath_func = &xpath_false;
Michal Vasko004d3152020-06-11 19:59:22 +02008486 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "floor", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008487 xpath_func = &xpath_floor;
Michal Vasko004d3152020-06-11 19:59:22 +02008488 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "round", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008489 xpath_func = &xpath_round;
Michal Vasko004d3152020-06-11 19:59:22 +02008490 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "deref", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008491 xpath_func = &xpath_deref;
8492 }
8493 break;
8494 case 6:
Michal Vasko004d3152020-06-11 19:59:22 +02008495 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "concat", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008496 xpath_func = &xpath_concat;
Michal Vasko004d3152020-06-11 19:59:22 +02008497 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "number", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008498 xpath_func = &xpath_number;
Michal Vasko004d3152020-06-11 19:59:22 +02008499 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008500 xpath_func = &xpath_string;
8501 }
8502 break;
8503 case 7:
Michal Vasko004d3152020-06-11 19:59:22 +02008504 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "boolean", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008505 xpath_func = &xpath_boolean;
Michal Vasko004d3152020-06-11 19:59:22 +02008506 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "ceiling", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008507 xpath_func = &xpath_ceiling;
Michal Vasko004d3152020-06-11 19:59:22 +02008508 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "current", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008509 xpath_func = &xpath_current;
8510 }
8511 break;
8512 case 8:
Michal Vasko004d3152020-06-11 19:59:22 +02008513 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "contains", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008514 xpath_func = &xpath_contains;
Michal Vasko004d3152020-06-11 19:59:22 +02008515 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "position", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008516 xpath_func = &xpath_position;
Michal Vasko004d3152020-06-11 19:59:22 +02008517 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "re-match", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008518 xpath_func = &xpath_re_match;
8519 }
8520 break;
8521 case 9:
Michal Vasko004d3152020-06-11 19:59:22 +02008522 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008523 xpath_func = &xpath_substring;
Michal Vasko004d3152020-06-11 19:59:22 +02008524 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "translate", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008525 xpath_func = &xpath_translate;
8526 }
8527 break;
8528 case 10:
Michal Vasko004d3152020-06-11 19:59:22 +02008529 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "local-name", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008530 xpath_func = &xpath_local_name;
Michal Vasko004d3152020-06-11 19:59:22 +02008531 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "enum-value", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008532 xpath_func = &xpath_enum_value;
Michal Vasko004d3152020-06-11 19:59:22 +02008533 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "bit-is-set", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008534 xpath_func = &xpath_bit_is_set;
8535 }
8536 break;
8537 case 11:
Michal Vasko004d3152020-06-11 19:59:22 +02008538 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "starts-with", 11)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008539 xpath_func = &xpath_starts_with;
8540 }
8541 break;
8542 case 12:
Michal Vasko004d3152020-06-11 19:59:22 +02008543 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from", 12)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008544 xpath_func = &xpath_derived_from;
8545 }
8546 break;
8547 case 13:
Michal Vasko004d3152020-06-11 19:59:22 +02008548 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "namespace-uri", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008549 xpath_func = &xpath_namespace_uri;
Michal Vasko004d3152020-06-11 19:59:22 +02008550 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string-length", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008551 xpath_func = &xpath_string_length;
8552 }
8553 break;
8554 case 15:
Michal Vasko004d3152020-06-11 19:59:22 +02008555 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "normalize-space", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008556 xpath_func = &xpath_normalize_space;
Michal Vasko004d3152020-06-11 19:59:22 +02008557 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-after", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008558 xpath_func = &xpath_substring_after;
8559 }
8560 break;
8561 case 16:
Michal Vasko004d3152020-06-11 19:59:22 +02008562 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-before", 16)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008563 xpath_func = &xpath_substring_before;
8564 }
8565 break;
8566 case 20:
Michal Vasko004d3152020-06-11 19:59:22 +02008567 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from-or-self", 20)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008568 xpath_func = &xpath_derived_from_or_self;
8569 }
8570 break;
8571 }
8572
8573 if (!xpath_func) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01008574 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 +02008575 return LY_EVALID;
8576 }
8577 }
8578
aPiecek8b0cc152021-05-31 16:40:31 +02008579 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008580 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008581 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008582
8583 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02008584 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
aPiecek8b0cc152021-05-31 16:40:31 +02008585 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008586 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008587 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008588
8589 /* ( Expr ( ',' Expr )* )? */
Michal Vasko004d3152020-06-11 19:59:22 +02008590 if (exp->tokens[*tok_idx] != LYXP_TOKEN_PAR2) {
aPiecek8b0cc152021-05-31 16:40:31 +02008591 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008592 args = malloc(sizeof *args);
8593 LY_CHECK_ERR_GOTO(!args, LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
8594 arg_count = 1;
8595 args[0] = set_copy(set);
8596 if (!args[0]) {
8597 rc = LY_EMEM;
8598 goto cleanup;
8599 }
8600
Michal Vasko004d3152020-06-11 19:59:22 +02008601 rc = eval_expr_select(exp, tok_idx, 0, args[0], options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008602 LY_CHECK_GOTO(rc, cleanup);
8603 } else {
aPiecek8b0cc152021-05-31 16:40:31 +02008604 rc = eval_expr_select(exp, tok_idx, 0, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008605 LY_CHECK_GOTO(rc, cleanup);
8606 }
8607 }
Michal Vasko004d3152020-06-11 19:59:22 +02008608 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_COMMA)) {
aPiecek8b0cc152021-05-31 16:40:31 +02008609 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008610 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008611 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008612
aPiecek8b0cc152021-05-31 16:40:31 +02008613 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008614 ++arg_count;
8615 args_aux = realloc(args, arg_count * sizeof *args);
8616 LY_CHECK_ERR_GOTO(!args_aux, arg_count--; LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
8617 args = args_aux;
8618 args[arg_count - 1] = set_copy(set);
8619 if (!args[arg_count - 1]) {
8620 rc = LY_EMEM;
8621 goto cleanup;
8622 }
8623
Michal Vasko004d3152020-06-11 19:59:22 +02008624 rc = eval_expr_select(exp, tok_idx, 0, args[arg_count - 1], options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008625 LY_CHECK_GOTO(rc, cleanup);
8626 } else {
aPiecek8b0cc152021-05-31 16:40:31 +02008627 rc = eval_expr_select(exp, tok_idx, 0, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008628 LY_CHECK_GOTO(rc, cleanup);
8629 }
8630 }
8631
8632 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02008633 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
aPiecek8b0cc152021-05-31 16:40:31 +02008634 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008635 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008636 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008637
aPiecek8b0cc152021-05-31 16:40:31 +02008638 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008639 /* evaluate function */
8640 rc = xpath_func(args, arg_count, set, options);
8641
8642 if (options & LYXP_SCNODE_ALL) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008643 /* merge all nodes from arg evaluations */
8644 for (i = 0; i < arg_count; ++i) {
Michal Vasko1a09b212021-05-06 13:00:10 +02008645 set_scnode_clear_ctx(args[i], LYXP_SET_SCNODE_ATOM_NODE);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008646 lyxp_set_scnode_merge(set, args[i]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008647 }
8648 }
8649 } else {
8650 rc = LY_SUCCESS;
8651 }
8652
8653cleanup:
8654 for (i = 0; i < arg_count; ++i) {
8655 lyxp_set_free(args[i]);
8656 }
8657 free(args);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008658 return rc;
8659}
8660
8661/**
8662 * @brief Evaluate Number. Logs directly on error.
8663 *
8664 * @param[in] ctx Context for errors.
8665 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008666 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008667 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
8668 * @return LY_ERR
8669 */
8670static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008671eval_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 +02008672{
8673 long double num;
8674 char *endptr;
8675
8676 if (set) {
8677 errno = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02008678 num = strtold(&exp->expr[exp->tok_pos[*tok_idx]], &endptr);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008679 if (errno) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01008680 LOGVAL(ctx, LY_VCODE_XP_INTOK, "Unknown", &exp->expr[exp->tok_pos[*tok_idx]]);
8681 LOGVAL(ctx, LYVE_XPATH, "Failed to convert \"%.*s\" into a long double (%s).",
Michal Vasko69730152020-10-09 16:30:07 +02008682 exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]], strerror(errno));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008683 return LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +02008684 } else if (endptr - &exp->expr[exp->tok_pos[*tok_idx]] != exp->tok_len[*tok_idx]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01008685 LOGVAL(ctx, LY_VCODE_XP_INTOK, "Unknown", &exp->expr[exp->tok_pos[*tok_idx]]);
8686 LOGVAL(ctx, LYVE_XPATH, "Failed to convert \"%.*s\" into a long double.",
Michal Vasko69730152020-10-09 16:30:07 +02008687 exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008688 return LY_EVALID;
8689 }
8690
8691 set_fill_number(set, num);
8692 }
8693
8694 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008695 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008696 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008697 return LY_SUCCESS;
8698}
8699
aPiecekdf23eee2021-10-07 12:21:50 +02008700LY_ERR
8701lyxp_vars_find(struct lyxp_var *vars, const char *name, size_t name_len, struct lyxp_var **var)
8702{
8703 LY_ERR ret = LY_ENOTFOUND;
8704 LY_ARRAY_COUNT_TYPE u;
8705
8706 assert(vars && name);
8707
8708 name_len = name_len ? name_len : strlen(name);
8709
8710 LY_ARRAY_FOR(vars, u) {
8711 if (!strncmp(vars[u].name, name, name_len)) {
8712 ret = LY_SUCCESS;
8713 break;
8714 }
8715 }
8716
8717 if (var && !ret) {
8718 *var = &vars[u];
8719 }
8720
8721 return ret;
8722}
8723
Michal Vasko03ff5a72019-09-11 13:49:33 +02008724/**
aPiecekfba75362021-10-07 12:39:48 +02008725 * @brief Evaluate VariableReference.
8726 *
8727 * @param[in] exp Parsed XPath expression.
8728 * @param[in] tok_idx Position in the expression @p exp.
8729 * @param[in] vars [Sized array](@ref sizedarrays) of XPath variables.
8730 * @param[in,out] set Context and result set.
8731 * @param[in] options XPath options.
8732 * @return LY_ERR value.
8733 */
8734static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008735eval_variable_reference(const struct lyxp_expr *exp, uint32_t *tok_idx, struct lyxp_set *set, uint32_t options)
aPiecekfba75362021-10-07 12:39:48 +02008736{
8737 LY_ERR ret;
8738 const char *name;
8739 struct lyxp_var *var;
8740 const struct lyxp_var *vars;
8741 struct lyxp_expr *tokens = NULL;
Michal Vaskodd528af2022-08-08 14:35:07 +02008742 uint32_t token_index, name_len;
aPiecekfba75362021-10-07 12:39:48 +02008743
8744 vars = set->vars;
8745
Michal Vasko49fec8e2022-05-24 10:28:33 +02008746 /* find out the name and value of the variable */
aPiecekfba75362021-10-07 12:39:48 +02008747 name = &exp->expr[exp->tok_pos[*tok_idx]];
Michal Vaskoe68b5402022-07-29 14:58:15 +02008748 name_len = exp->tok_len[*tok_idx];
8749 ret = lyxp_vars_find((struct lyxp_var *)vars, name, name_len, &var);
8750 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 +02008751
Michal Vasko49fec8e2022-05-24 10:28:33 +02008752 /* parse value */
aPiecekfba75362021-10-07 12:39:48 +02008753 ret = lyxp_expr_parse(set->ctx, var->value, 0, 1, &tokens);
8754 LY_CHECK_GOTO(ret, cleanup);
8755
Michal Vasko49fec8e2022-05-24 10:28:33 +02008756 /* evaluate value */
aPiecekfba75362021-10-07 12:39:48 +02008757 token_index = 0;
8758 ret = eval_expr_select(tokens, &token_index, 0, set, options);
8759 LY_CHECK_GOTO(ret, cleanup);
8760
8761cleanup:
8762 lyxp_expr_free(set->ctx, tokens);
8763
8764 return ret;
8765}
8766
8767/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02008768 * @brief Evaluate PathExpr. Logs directly on error.
8769 *
Michal Vaskod3678892020-05-21 10:06:58 +02008770 * [12] PathExpr ::= LocationPath | PrimaryExpr Predicate*
Michal Vasko03ff5a72019-09-11 13:49:33 +02008771 * | PrimaryExpr Predicate* '/' RelativeLocationPath
8772 * | PrimaryExpr Predicate* '//' RelativeLocationPath
8773 * [2] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
aPiecekfba75362021-10-07 12:39:48 +02008774 * [10] PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
Michal Vasko03ff5a72019-09-11 13:49:33 +02008775 *
8776 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008777 * @param[in] tok_idx Position in the expression @p exp.
aPiecek8b0cc152021-05-31 16:40:31 +02008778 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008779 * @param[in] options XPath options.
8780 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8781 */
8782static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008783eval_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 +02008784{
Michal Vasko49fec8e2022-05-24 10:28:33 +02008785 ly_bool all_desc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008786 LY_ERR rc;
8787
Michal Vasko004d3152020-06-11 19:59:22 +02008788 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008789 case LYXP_TOKEN_PAR1:
8790 /* '(' Expr ')' */
8791
8792 /* '(' */
aPiecek8b0cc152021-05-31 16:40:31 +02008793 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008794 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008795 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008796
8797 /* Expr */
Michal Vasko004d3152020-06-11 19:59:22 +02008798 rc = eval_expr_select(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008799 LY_CHECK_RET(rc);
8800
8801 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02008802 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
aPiecek8b0cc152021-05-31 16:40:31 +02008803 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008804 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008805 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008806
Michal Vasko03ff5a72019-09-11 13:49:33 +02008807 goto predicate;
8808
8809 case LYXP_TOKEN_DOT:
8810 case LYXP_TOKEN_DDOT:
Michal Vasko49fec8e2022-05-24 10:28:33 +02008811 case LYXP_TOKEN_AXISNAME:
Michal Vasko03ff5a72019-09-11 13:49:33 +02008812 case LYXP_TOKEN_AT:
8813 case LYXP_TOKEN_NAMETEST:
8814 case LYXP_TOKEN_NODETYPE:
8815 /* RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02008816 rc = eval_relative_location_path(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008817 LY_CHECK_RET(rc);
8818 break;
8819
aPiecekfba75362021-10-07 12:39:48 +02008820 case LYXP_TOKEN_VARREF:
8821 /* VariableReference */
8822 rc = eval_variable_reference(exp, tok_idx, set, options);
8823 LY_CHECK_RET(rc);
8824 ++(*tok_idx);
8825
aPiecekfba75362021-10-07 12:39:48 +02008826 goto predicate;
8827
Michal Vasko03ff5a72019-09-11 13:49:33 +02008828 case LYXP_TOKEN_FUNCNAME:
8829 /* FunctionCall */
aPiecek8b0cc152021-05-31 16:40:31 +02008830 rc = eval_function_call(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008831 LY_CHECK_RET(rc);
8832
Michal Vasko03ff5a72019-09-11 13:49:33 +02008833 goto predicate;
8834
Michal Vasko3e48bf32020-06-01 08:39:07 +02008835 case LYXP_TOKEN_OPER_PATH:
8836 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +02008837 /* AbsoluteLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02008838 rc = eval_absolute_location_path(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008839 LY_CHECK_RET(rc);
8840 break;
8841
8842 case LYXP_TOKEN_LITERAL:
8843 /* Literal */
aPiecek8b0cc152021-05-31 16:40:31 +02008844 if ((options & LYXP_SKIP_EXPR) || (options & LYXP_SCNODE_ALL)) {
8845 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02008846 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008847 }
Michal Vasko004d3152020-06-11 19:59:22 +02008848 eval_literal(exp, tok_idx, NULL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008849 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02008850 eval_literal(exp, tok_idx, set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008851 }
8852
Michal Vasko03ff5a72019-09-11 13:49:33 +02008853 goto predicate;
8854
8855 case LYXP_TOKEN_NUMBER:
8856 /* Number */
aPiecek8b0cc152021-05-31 16:40:31 +02008857 if ((options & LYXP_SKIP_EXPR) || (options & LYXP_SCNODE_ALL)) {
8858 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02008859 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008860 }
Michal Vasko004d3152020-06-11 19:59:22 +02008861 rc = eval_number(NULL, exp, tok_idx, NULL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008862 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02008863 rc = eval_number(set->ctx, exp, tok_idx, set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008864 }
8865 LY_CHECK_RET(rc);
8866
Michal Vasko03ff5a72019-09-11 13:49:33 +02008867 goto predicate;
8868
8869 default:
Michal Vasko49fec8e2022-05-24 10:28:33 +02008870 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 +02008871 return LY_EVALID;
8872 }
8873
8874 return LY_SUCCESS;
8875
8876predicate:
8877 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02008878 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
Michal Vasko49fec8e2022-05-24 10:28:33 +02008879 rc = eval_predicate(exp, tok_idx, set, options, LYXP_AXIS_CHILD);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008880 LY_CHECK_RET(rc);
8881 }
8882
8883 /* ('/' or '//') RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02008884 if (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008885
8886 /* evaluate '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02008887 if (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008888 all_desc = 0;
8889 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008890 all_desc = 1;
8891 }
8892
aPiecek8b0cc152021-05-31 16:40:31 +02008893 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008894 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008895 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008896
Michal Vasko004d3152020-06-11 19:59:22 +02008897 rc = eval_relative_location_path(exp, tok_idx, all_desc, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008898 LY_CHECK_RET(rc);
8899 }
8900
8901 return LY_SUCCESS;
8902}
8903
8904/**
8905 * @brief Evaluate UnionExpr. Logs directly on error.
8906 *
Michal Vaskod3678892020-05-21 10:06:58 +02008907 * [20] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008908 *
8909 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008910 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008911 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02008912 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008913 * @param[in] options XPath options.
8914 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8915 */
8916static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008917eval_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 +02008918{
8919 LY_ERR rc = LY_SUCCESS;
8920 struct lyxp_set orig_set, set2;
Michal Vaskodd528af2022-08-08 14:35:07 +02008921 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008922
8923 assert(repeat);
8924
8925 set_init(&orig_set, set);
8926 set_init(&set2, set);
8927
8928 set_fill_set(&orig_set, set);
8929
Michal Vasko004d3152020-06-11 19:59:22 +02008930 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008931 LY_CHECK_GOTO(rc, cleanup);
8932
8933 /* ('|' PathExpr)* */
8934 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008935 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_UNI);
aPiecek8b0cc152021-05-31 16:40:31 +02008936 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008937 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008938 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008939
aPiecek8b0cc152021-05-31 16:40:31 +02008940 if (options & LYXP_SKIP_EXPR) {
8941 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008942 LY_CHECK_GOTO(rc, cleanup);
8943 continue;
8944 }
8945
8946 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008947 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008948 LY_CHECK_GOTO(rc, cleanup);
8949
8950 /* eval */
8951 if (options & LYXP_SCNODE_ALL) {
Michal Vaskoecd62de2019-11-13 12:35:11 +01008952 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008953 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008954 rc = moveto_union(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008955 LY_CHECK_GOTO(rc, cleanup);
8956 }
8957 }
8958
8959cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008960 lyxp_set_free_content(&orig_set);
8961 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008962 return rc;
8963}
8964
8965/**
8966 * @brief Evaluate UnaryExpr. Logs directly on error.
8967 *
Michal Vaskod3678892020-05-21 10:06:58 +02008968 * [19] UnaryExpr ::= UnionExpr | '-' UnaryExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008969 *
8970 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008971 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008972 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02008973 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008974 * @param[in] options XPath options.
8975 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8976 */
8977static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02008978eval_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 +02008979{
8980 LY_ERR rc;
Michal Vaskodd528af2022-08-08 14:35:07 +02008981 uint32_t this_op, i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008982
8983 assert(repeat);
8984
8985 /* ('-')+ */
Michal Vasko004d3152020-06-11 19:59:22 +02008986 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008987 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008988 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 +02008989
aPiecek8b0cc152021-05-31 16:40:31 +02008990 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02008991 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008992 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008993 }
8994
Michal Vasko004d3152020-06-11 19:59:22 +02008995 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNARY, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008996 LY_CHECK_RET(rc);
8997
aPiecek8b0cc152021-05-31 16:40:31 +02008998 if (!(options & LYXP_SKIP_EXPR) && (repeat % 2)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008999 if (options & LYXP_SCNODE_ALL) {
9000 warn_operands(set->ctx, set, NULL, 1, exp->expr, exp->tok_pos[this_op]);
9001 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009002 rc = moveto_op_math(set, NULL, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009003 LY_CHECK_RET(rc);
9004 }
9005 }
9006
9007 return LY_SUCCESS;
9008}
9009
9010/**
9011 * @brief Evaluate MultiplicativeExpr. Logs directly on error.
9012 *
Michal Vaskod3678892020-05-21 10:06:58 +02009013 * [18] MultiplicativeExpr ::= UnaryExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02009014 * | MultiplicativeExpr '*' UnaryExpr
9015 * | MultiplicativeExpr 'div' UnaryExpr
9016 * | MultiplicativeExpr 'mod' UnaryExpr
9017 *
9018 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02009019 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009020 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02009021 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009022 * @param[in] options XPath options.
9023 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
9024 */
9025static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02009026eval_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 +02009027 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009028{
9029 LY_ERR rc;
Michal Vaskodd528af2022-08-08 14:35:07 +02009030 uint32_t i, this_op;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009031 struct lyxp_set orig_set, set2;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009032
9033 assert(repeat);
9034
9035 set_init(&orig_set, set);
9036 set_init(&set2, set);
9037
9038 set_fill_set(&orig_set, set);
9039
Michal Vasko004d3152020-06-11 19:59:22 +02009040 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009041 LY_CHECK_GOTO(rc, cleanup);
9042
9043 /* ('*' / 'div' / 'mod' UnaryExpr)* */
9044 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02009045 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009046
Michal Vasko004d3152020-06-11 19:59:22 +02009047 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_MATH);
aPiecek8b0cc152021-05-31 16:40:31 +02009048 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02009049 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02009050 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009051
aPiecek8b0cc152021-05-31 16:40:31 +02009052 if (options & LYXP_SKIP_EXPR) {
9053 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009054 LY_CHECK_GOTO(rc, cleanup);
9055 continue;
9056 }
9057
9058 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02009059 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009060 LY_CHECK_GOTO(rc, cleanup);
9061
9062 /* eval */
9063 if (options & LYXP_SCNODE_ALL) {
9064 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01009065 lyxp_set_scnode_merge(set, &set2);
Michal Vasko1a09b212021-05-06 13:00:10 +02009066 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009067 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009068 rc = moveto_op_math(set, &set2, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009069 LY_CHECK_GOTO(rc, cleanup);
9070 }
9071 }
9072
9073cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02009074 lyxp_set_free_content(&orig_set);
9075 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009076 return rc;
9077}
9078
9079/**
9080 * @brief Evaluate AdditiveExpr. Logs directly on error.
9081 *
Michal Vaskod3678892020-05-21 10:06:58 +02009082 * [17] AdditiveExpr ::= MultiplicativeExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02009083 * | AdditiveExpr '+' MultiplicativeExpr
9084 * | AdditiveExpr '-' MultiplicativeExpr
9085 *
9086 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02009087 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009088 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02009089 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009090 * @param[in] options XPath options.
9091 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
9092 */
9093static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02009094eval_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 +02009095{
9096 LY_ERR rc;
Michal Vaskodd528af2022-08-08 14:35:07 +02009097 uint32_t i, this_op;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009098 struct lyxp_set orig_set, set2;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009099
9100 assert(repeat);
9101
9102 set_init(&orig_set, set);
9103 set_init(&set2, set);
9104
9105 set_fill_set(&orig_set, set);
9106
Michal Vasko004d3152020-06-11 19:59:22 +02009107 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009108 LY_CHECK_GOTO(rc, cleanup);
9109
9110 /* ('+' / '-' MultiplicativeExpr)* */
9111 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02009112 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009113
Michal Vasko004d3152020-06-11 19:59:22 +02009114 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_MATH);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009115 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02009116 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02009117 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009118
aPiecek8b0cc152021-05-31 16:40:31 +02009119 if (options & LYXP_SKIP_EXPR) {
9120 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009121 LY_CHECK_GOTO(rc, cleanup);
9122 continue;
9123 }
9124
9125 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02009126 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009127 LY_CHECK_GOTO(rc, cleanup);
9128
9129 /* eval */
9130 if (options & LYXP_SCNODE_ALL) {
9131 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01009132 lyxp_set_scnode_merge(set, &set2);
Michal Vasko1a09b212021-05-06 13:00:10 +02009133 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009134 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009135 rc = moveto_op_math(set, &set2, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009136 LY_CHECK_GOTO(rc, cleanup);
9137 }
9138 }
9139
9140cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02009141 lyxp_set_free_content(&orig_set);
9142 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009143 return rc;
9144}
9145
9146/**
9147 * @brief Evaluate RelationalExpr. Logs directly on error.
9148 *
Michal Vaskod3678892020-05-21 10:06:58 +02009149 * [16] RelationalExpr ::= AdditiveExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02009150 * | RelationalExpr '<' AdditiveExpr
9151 * | RelationalExpr '>' AdditiveExpr
9152 * | RelationalExpr '<=' AdditiveExpr
9153 * | RelationalExpr '>=' AdditiveExpr
9154 *
9155 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02009156 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009157 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02009158 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009159 * @param[in] options XPath options.
9160 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
9161 */
9162static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02009163eval_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 +02009164{
9165 LY_ERR rc;
Michal Vaskodd528af2022-08-08 14:35:07 +02009166 uint32_t i, this_op;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009167 struct lyxp_set orig_set, set2;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009168
9169 assert(repeat);
9170
9171 set_init(&orig_set, set);
9172 set_init(&set2, set);
9173
9174 set_fill_set(&orig_set, set);
9175
Michal Vasko004d3152020-06-11 19:59:22 +02009176 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009177 LY_CHECK_GOTO(rc, cleanup);
9178
9179 /* ('<' / '>' / '<=' / '>=' AdditiveExpr)* */
9180 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02009181 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009182
Michal Vasko004d3152020-06-11 19:59:22 +02009183 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_COMP);
aPiecek8b0cc152021-05-31 16:40:31 +02009184 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02009185 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02009186 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009187
aPiecek8b0cc152021-05-31 16:40:31 +02009188 if (options & LYXP_SKIP_EXPR) {
9189 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009190 LY_CHECK_GOTO(rc, cleanup);
9191 continue;
9192 }
9193
9194 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02009195 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009196 LY_CHECK_GOTO(rc, cleanup);
9197
9198 /* eval */
9199 if (options & LYXP_SCNODE_ALL) {
9200 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01009201 lyxp_set_scnode_merge(set, &set2);
Michal Vasko1a09b212021-05-06 13:00:10 +02009202 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009203 } else {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02009204 ly_bool result;
9205
9206 rc = moveto_op_comp(set, &set2, &exp->expr[exp->tok_pos[this_op]], &result);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009207 LY_CHECK_GOTO(rc, cleanup);
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02009208 set_fill_boolean(set, result);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009209 }
9210 }
9211
9212cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02009213 lyxp_set_free_content(&orig_set);
9214 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009215 return rc;
9216}
9217
9218/**
9219 * @brief Evaluate EqualityExpr. Logs directly on error.
9220 *
Michal Vaskod3678892020-05-21 10:06:58 +02009221 * [15] EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02009222 * | EqualityExpr '!=' RelationalExpr
9223 *
9224 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02009225 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009226 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02009227 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009228 * @param[in] options XPath options.
9229 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
9230 */
9231static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02009232eval_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 +02009233{
9234 LY_ERR rc;
Michal Vaskodd528af2022-08-08 14:35:07 +02009235 uint32_t i, this_op;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009236 struct lyxp_set orig_set, set2;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009237
9238 assert(repeat);
9239
9240 set_init(&orig_set, set);
9241 set_init(&set2, set);
9242
9243 set_fill_set(&orig_set, set);
9244
Michal Vasko004d3152020-06-11 19:59:22 +02009245 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009246 LY_CHECK_GOTO(rc, cleanup);
9247
9248 /* ('=' / '!=' RelationalExpr)* */
9249 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02009250 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009251
Michal Vasko004d3152020-06-11 19:59:22 +02009252 assert((exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL) || (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_NEQUAL));
aPiecek8b0cc152021-05-31 16:40:31 +02009253 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02009254 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02009255 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009256
aPiecek8b0cc152021-05-31 16:40:31 +02009257 if (options & LYXP_SKIP_EXPR) {
9258 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009259 LY_CHECK_GOTO(rc, cleanup);
9260 continue;
9261 }
9262
9263 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02009264 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009265 LY_CHECK_GOTO(rc, cleanup);
9266
9267 /* eval */
9268 if (options & LYXP_SCNODE_ALL) {
9269 warn_operands(set->ctx, set, &set2, 0, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vasko004d3152020-06-11 19:59:22 +02009270 warn_equality_value(exp, set, *tok_idx - 1, this_op - 1, *tok_idx - 1);
9271 warn_equality_value(exp, &set2, this_op - 1, this_op - 1, *tok_idx - 1);
Michal Vaskoecd62de2019-11-13 12:35:11 +01009272 lyxp_set_scnode_merge(set, &set2);
Michal Vasko1a09b212021-05-06 13:00:10 +02009273 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009274 } else {
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02009275 ly_bool result;
9276
9277 rc = moveto_op_comp(set, &set2, &exp->expr[exp->tok_pos[this_op]], &result);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009278 LY_CHECK_GOTO(rc, cleanup);
Haithem Ben Ghorbal1ac219d2022-09-07 12:30:06 +02009279 set_fill_boolean(set, result);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009280 }
9281 }
9282
9283cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02009284 lyxp_set_free_content(&orig_set);
9285 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009286 return rc;
9287}
9288
9289/**
9290 * @brief Evaluate AndExpr. Logs directly on error.
9291 *
Michal Vaskod3678892020-05-21 10:06:58 +02009292 * [14] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02009293 *
9294 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02009295 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009296 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02009297 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009298 * @param[in] options XPath options.
9299 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
9300 */
9301static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02009302eval_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 +02009303{
9304 LY_ERR rc;
9305 struct lyxp_set orig_set, set2;
Michal Vaskodd528af2022-08-08 14:35:07 +02009306 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009307
9308 assert(repeat);
9309
9310 set_init(&orig_set, set);
9311 set_init(&set2, set);
9312
9313 set_fill_set(&orig_set, set);
9314
Michal Vasko004d3152020-06-11 19:59:22 +02009315 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009316 LY_CHECK_GOTO(rc, cleanup);
9317
9318 /* cast to boolean, we know that will be the final result */
aPiecek8b0cc152021-05-31 16:40:31 +02009319 if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02009320 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009321 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009322 lyxp_set_cast(set, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009323 }
9324
9325 /* ('and' EqualityExpr)* */
9326 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02009327 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_LOG);
aPiecek8b0cc152021-05-31 16:40:31 +02009328 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, ((options & LYXP_SKIP_EXPR) || !set->val.bln ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02009329 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02009330 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009331
9332 /* lazy evaluation */
aPiecek8b0cc152021-05-31 16:40:31 +02009333 if ((options & LYXP_SKIP_EXPR) || ((set->type == LYXP_SET_BOOLEAN) && !set->val.bln)) {
9334 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009335 LY_CHECK_GOTO(rc, cleanup);
9336 continue;
9337 }
9338
9339 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02009340 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009341 LY_CHECK_GOTO(rc, cleanup);
9342
9343 /* eval - just get boolean value actually */
9344 if (set->type == LYXP_SET_SCNODE_SET) {
Michal Vasko1a09b212021-05-06 13:00:10 +02009345 set_scnode_clear_ctx(&set2, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vaskoecd62de2019-11-13 12:35:11 +01009346 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009347 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009348 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009349 set_fill_set(set, &set2);
9350 }
9351 }
9352
9353cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02009354 lyxp_set_free_content(&orig_set);
9355 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009356 return rc;
9357}
9358
9359/**
9360 * @brief Evaluate OrExpr. Logs directly on error.
9361 *
Michal Vaskod3678892020-05-21 10:06:58 +02009362 * [13] OrExpr ::= AndExpr | OrExpr 'or' AndExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02009363 *
9364 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02009365 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009366 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02009367 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009368 * @param[in] options XPath options.
9369 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
9370 */
9371static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02009372eval_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 +02009373{
9374 LY_ERR rc;
9375 struct lyxp_set orig_set, set2;
Michal Vaskodd528af2022-08-08 14:35:07 +02009376 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009377
9378 assert(repeat);
9379
9380 set_init(&orig_set, set);
9381 set_init(&set2, set);
9382
9383 set_fill_set(&orig_set, set);
9384
Michal Vasko004d3152020-06-11 19:59:22 +02009385 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009386 LY_CHECK_GOTO(rc, cleanup);
9387
9388 /* cast to boolean, we know that will be the final result */
aPiecek8b0cc152021-05-31 16:40:31 +02009389 if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02009390 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009391 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009392 lyxp_set_cast(set, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009393 }
9394
9395 /* ('or' AndExpr)* */
9396 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02009397 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_LOG);
aPiecek8b0cc152021-05-31 16:40:31 +02009398 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, ((options & LYXP_SKIP_EXPR) || set->val.bln ? "skipped" : "parsed"),
Michal Vasko49fec8e2022-05-24 10:28:33 +02009399 lyxp_token2str(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02009400 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009401
9402 /* lazy evaluation */
aPiecek8b0cc152021-05-31 16:40:31 +02009403 if ((options & LYXP_SKIP_EXPR) || ((set->type == LYXP_SET_BOOLEAN) && set->val.bln)) {
9404 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009405 LY_CHECK_GOTO(rc, cleanup);
9406 continue;
9407 }
9408
9409 set_fill_set(&set2, &orig_set);
9410 /* expr_type cound have been LYXP_EXPR_NONE in all these later calls (except for the first one),
9411 * but it does not matter */
Michal Vasko004d3152020-06-11 19:59:22 +02009412 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009413 LY_CHECK_GOTO(rc, cleanup);
9414
9415 /* eval - just get boolean value actually */
9416 if (set->type == LYXP_SET_SCNODE_SET) {
Michal Vasko1a09b212021-05-06 13:00:10 +02009417 set_scnode_clear_ctx(&set2, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vaskoecd62de2019-11-13 12:35:11 +01009418 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009419 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009420 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009421 set_fill_set(set, &set2);
9422 }
9423 }
9424
9425cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02009426 lyxp_set_free_content(&orig_set);
9427 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009428 return rc;
9429}
9430
9431/**
Michal Vasko004d3152020-06-11 19:59:22 +02009432 * @brief Decide what expression is at the pointer @p tok_idx and evaluate it accordingly.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009433 *
9434 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02009435 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009436 * @param[in] etype Expression type to evaluate.
aPiecek8b0cc152021-05-31 16:40:31 +02009437 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02009438 * @param[in] options XPath options.
9439 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
9440 */
9441static LY_ERR
Michal Vaskodd528af2022-08-08 14:35:07 +02009442eval_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 +02009443 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009444{
Michal Vaskodd528af2022-08-08 14:35:07 +02009445 uint32_t i, count;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009446 enum lyxp_expr_type next_etype;
9447 LY_ERR rc;
9448
9449 /* process operator repeats */
Michal Vasko004d3152020-06-11 19:59:22 +02009450 if (!exp->repeat[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02009451 next_etype = LYXP_EXPR_NONE;
9452 } else {
9453 /* find etype repeat */
Radek Krejci1e008d22020-08-17 11:37:37 +02009454 for (i = 0; exp->repeat[*tok_idx][i] > etype; ++i) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02009455
9456 /* select one-priority lower because etype expression called us */
9457 if (i) {
Michal Vasko004d3152020-06-11 19:59:22 +02009458 next_etype = exp->repeat[*tok_idx][i - 1];
Michal Vasko03ff5a72019-09-11 13:49:33 +02009459 /* count repeats for that expression */
Radek Krejci1e008d22020-08-17 11:37:37 +02009460 for (count = 0; i && exp->repeat[*tok_idx][i - 1] == next_etype; ++count, --i) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02009461 } else {
9462 next_etype = LYXP_EXPR_NONE;
9463 }
9464 }
9465
9466 /* decide what expression are we parsing based on the repeat */
9467 switch (next_etype) {
9468 case LYXP_EXPR_OR:
Michal Vasko004d3152020-06-11 19:59:22 +02009469 rc = eval_or_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009470 break;
9471 case LYXP_EXPR_AND:
Michal Vasko004d3152020-06-11 19:59:22 +02009472 rc = eval_and_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009473 break;
9474 case LYXP_EXPR_EQUALITY:
Michal Vasko004d3152020-06-11 19:59:22 +02009475 rc = eval_equality_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009476 break;
9477 case LYXP_EXPR_RELATIONAL:
Michal Vasko004d3152020-06-11 19:59:22 +02009478 rc = eval_relational_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009479 break;
9480 case LYXP_EXPR_ADDITIVE:
Michal Vasko004d3152020-06-11 19:59:22 +02009481 rc = eval_additive_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009482 break;
9483 case LYXP_EXPR_MULTIPLICATIVE:
Michal Vasko004d3152020-06-11 19:59:22 +02009484 rc = eval_multiplicative_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009485 break;
9486 case LYXP_EXPR_UNARY:
Michal Vasko004d3152020-06-11 19:59:22 +02009487 rc = eval_unary_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009488 break;
9489 case LYXP_EXPR_UNION:
Michal Vasko004d3152020-06-11 19:59:22 +02009490 rc = eval_union_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009491 break;
9492 case LYXP_EXPR_NONE:
Michal Vasko004d3152020-06-11 19:59:22 +02009493 rc = eval_path_expr(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009494 break;
9495 default:
9496 LOGINT_RET(set->ctx);
9497 }
9498
9499 return rc;
9500}
9501
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009502/**
9503 * @brief Get root type.
9504 *
9505 * @param[in] ctx_node Context node.
9506 * @param[in] ctx_scnode Schema context node.
9507 * @param[in] options XPath options.
9508 * @return Root type.
9509 */
9510static enum lyxp_node_type
Radek Krejci1deb5be2020-08-26 16:43:36 +02009511lyxp_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 +01009512{
Michal Vasko6b26e742020-07-17 15:02:10 +02009513 const struct lysc_node *op;
9514
Michal Vaskoa27245c2022-05-02 09:01:35 +02009515 /* explicit */
9516 if (options & LYXP_ACCESS_TREE_ALL) {
9517 return LYXP_NODE_ROOT;
9518 } else if (options & LYXP_ACCESS_TREE_CONFIG) {
9519 return LYXP_NODE_ROOT_CONFIG;
9520 }
9521
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009522 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009523 /* schema */
Radek Krejci1e008d22020-08-17 11:37:37 +02009524 for (op = ctx_scnode; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
Michal Vasko6b26e742020-07-17 15:02:10 +02009525
9526 if (op || (options & LYXP_SCNODE)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009527 /* general root that can access everything */
9528 return LYXP_NODE_ROOT;
9529 } else if (!ctx_scnode || (ctx_scnode->flags & LYS_CONFIG_W)) {
9530 /* root context node can access only config data (because we said so, it is unspecified) */
9531 return LYXP_NODE_ROOT_CONFIG;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009532 }
Michal Vasko6b26e742020-07-17 15:02:10 +02009533 return LYXP_NODE_ROOT;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009534 }
9535
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009536 /* data */
Michal Vasko6b26e742020-07-17 15:02:10 +02009537 op = ctx_node ? ctx_node->schema : NULL;
Michal Vaskod989ba02020-08-24 10:59:24 +02009538 for ( ; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
Michal Vasko6b26e742020-07-17 15:02:10 +02009539
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009540 if (op || !(options & LYXP_SCHEMA)) {
9541 /* general root that can access everything */
9542 return LYXP_NODE_ROOT;
Christian Hoppsb6ecaea2021-02-06 09:45:38 -05009543 } else if (!ctx_node || !ctx_node->schema || (ctx_node->schema->flags & LYS_CONFIG_W)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009544 /* root context node can access only config data (because we said so, it is unspecified) */
9545 return LYXP_NODE_ROOT_CONFIG;
9546 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009547 return LYXP_NODE_ROOT;
9548}
9549
Michal Vasko03ff5a72019-09-11 13:49:33 +02009550LY_ERR
Michal Vasko400e9672021-01-11 13:39:17 +01009551lyxp_eval(const struct ly_ctx *ctx, const struct lyxp_expr *exp, const struct lys_module *cur_mod,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +02009552 LY_VALUE_FORMAT format, void *prefix_data, const struct lyd_node *cur_node, const struct lyd_node *ctx_node,
9553 const struct lyd_node *tree, const struct lyxp_var *vars, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009554{
Michal Vaskodd528af2022-08-08 14:35:07 +02009555 uint32_t tok_idx = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009556 LY_ERR rc;
9557
Michal Vasko400e9672021-01-11 13:39:17 +01009558 LY_CHECK_ARG_RET(ctx, ctx, exp, set, LY_EINVAL);
Radek Krejci8df109d2021-04-23 12:19:08 +02009559 if (!cur_mod && ((format == LY_VALUE_SCHEMA) || (format == LY_VALUE_SCHEMA_RESOLVED))) {
Michal Vaskoddd76592022-01-17 13:34:48 +01009560 LOGERR(ctx, LY_EINVAL, "Current module must be set if schema format is used.");
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009561 return LY_EINVAL;
Michal Vasko004d3152020-06-11 19:59:22 +02009562 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02009563
Michal Vaskod3bb12f2020-12-04 14:33:09 +01009564 if (tree) {
9565 /* adjust the pointer to be the first top-level sibling */
9566 while (tree->parent) {
9567 tree = lyd_parent(tree);
9568 }
9569 tree = lyd_first_sibling(tree);
Michal Vaskoddd76592022-01-17 13:34:48 +01009570
Michal Vasko6f78a772022-11-10 08:13:52 +01009571 if (lysc_data_parent(tree->schema)) {
Michal Vaskoddd76592022-01-17 13:34:48 +01009572 /* unable to evaluate absolute paths */
9573 LOGERR(ctx, LY_EINVAL, "Data node \"%s\" has no parent but is not instance of a top-level schema node.",
9574 LYD_NAME(tree));
9575 return LY_EINVAL;
9576 }
Michal Vaskod3bb12f2020-12-04 14:33:09 +01009577 }
9578
Michal Vasko03ff5a72019-09-11 13:49:33 +02009579 /* prepare set for evaluation */
Michal Vasko03ff5a72019-09-11 13:49:33 +02009580 memset(set, 0, sizeof *set);
Michal Vaskod3678892020-05-21 10:06:58 +02009581 set->type = LYXP_SET_NODE_SET;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009582 set->root_type = lyxp_get_root_type(ctx_node, NULL, options);
9583 set_insert_node(set, (struct lyd_node *)ctx_node, 0, ctx_node ? LYXP_NODE_ELEM : set->root_type, 0);
9584
Michal Vasko400e9672021-01-11 13:39:17 +01009585 set->ctx = (struct ly_ctx *)ctx;
Michal Vaskoa3e92bc2022-07-29 14:56:23 +02009586 set->cur_node = cur_node;
9587 for (set->context_op = cur_node ? cur_node->schema : NULL;
Radek Krejci0f969882020-08-21 16:56:47 +02009588 set->context_op && !(set->context_op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF));
9589 set->context_op = set->context_op->parent) {}
Michal Vaskof03ed032020-03-04 13:31:44 +01009590 set->tree = tree;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009591 set->cur_mod = cur_mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009592 set->format = format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009593 set->prefix_data = prefix_data;
aPiecekfba75362021-10-07 12:39:48 +02009594 set->vars = vars;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009595
Radek Krejciddace2c2021-01-08 11:30:56 +01009596 LOG_LOCSET(NULL, set->cur_node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01009597
Michal Vasko03ff5a72019-09-11 13:49:33 +02009598 /* evaluate */
Michal Vasko004d3152020-06-11 19:59:22 +02009599 rc = eval_expr_select(exp, &tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009600 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02009601 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009602 }
9603
Michal Vasko4a7d4d62021-12-13 17:05:06 +01009604 if (set->cur_node) {
9605 LOG_LOCBACK(0, 1, 0, 0);
9606 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02009607 return rc;
9608}
9609
9610#if 0
9611
9612/* full xml printing of set elements, not used currently */
9613
9614void
9615lyxp_set_print_xml(FILE *f, struct lyxp_set *set)
9616{
9617 uint32_t i;
9618 char *str_num;
9619 struct lyout out;
9620
9621 memset(&out, 0, sizeof out);
9622
9623 out.type = LYOUT_STREAM;
9624 out.method.f = f;
9625
9626 switch (set->type) {
9627 case LYXP_SET_EMPTY:
Michal Vasko5233e962020-08-14 14:26:20 +02009628 ly_print_(&out, "Empty XPath set\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009629 break;
9630 case LYXP_SET_BOOLEAN:
Michal Vasko5233e962020-08-14 14:26:20 +02009631 ly_print_(&out, "Boolean XPath set:\n");
9632 ly_print_(&out, "%s\n\n", set->value.bool ? "true" : "false");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009633 break;
9634 case LYXP_SET_STRING:
Michal Vasko5233e962020-08-14 14:26:20 +02009635 ly_print_(&out, "String XPath set:\n");
9636 ly_print_(&out, "\"%s\"\n\n", set->value.str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009637 break;
9638 case LYXP_SET_NUMBER:
Michal Vasko5233e962020-08-14 14:26:20 +02009639 ly_print_(&out, "Number XPath set:\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009640
9641 if (isnan(set->value.num)) {
9642 str_num = strdup("NaN");
9643 } else if ((set->value.num == 0) || (set->value.num == -0.0f)) {
9644 str_num = strdup("0");
9645 } else if (isinf(set->value.num) && !signbit(set->value.num)) {
9646 str_num = strdup("Infinity");
9647 } else if (isinf(set->value.num) && signbit(set->value.num)) {
9648 str_num = strdup("-Infinity");
9649 } else if ((long long)set->value.num == set->value.num) {
9650 if (asprintf(&str_num, "%lld", (long long)set->value.num) == -1) {
9651 str_num = NULL;
9652 }
9653 } else {
9654 if (asprintf(&str_num, "%03.1Lf", set->value.num) == -1) {
9655 str_num = NULL;
9656 }
9657 }
9658 if (!str_num) {
9659 LOGMEM;
9660 return;
9661 }
Michal Vasko5233e962020-08-14 14:26:20 +02009662 ly_print_(&out, "%s\n\n", str_num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009663 free(str_num);
9664 break;
9665 case LYXP_SET_NODE_SET:
Michal Vasko5233e962020-08-14 14:26:20 +02009666 ly_print_(&out, "Node XPath set:\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009667
9668 for (i = 0; i < set->used; ++i) {
Michal Vasko5233e962020-08-14 14:26:20 +02009669 ly_print_(&out, "%d. ", i + 1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009670 switch (set->node_type[i]) {
9671 case LYXP_NODE_ROOT_ALL:
Michal Vasko5233e962020-08-14 14:26:20 +02009672 ly_print_(&out, "ROOT all\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009673 break;
9674 case LYXP_NODE_ROOT_CONFIG:
Michal Vasko5233e962020-08-14 14:26:20 +02009675 ly_print_(&out, "ROOT config\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009676 break;
9677 case LYXP_NODE_ROOT_STATE:
Michal Vasko5233e962020-08-14 14:26:20 +02009678 ly_print_(&out, "ROOT state\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009679 break;
9680 case LYXP_NODE_ROOT_NOTIF:
Michal Vasko5233e962020-08-14 14:26:20 +02009681 ly_print_(&out, "ROOT notification \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009682 break;
9683 case LYXP_NODE_ROOT_RPC:
Michal Vasko5233e962020-08-14 14:26:20 +02009684 ly_print_(&out, "ROOT rpc \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009685 break;
9686 case LYXP_NODE_ROOT_OUTPUT:
Michal Vasko5233e962020-08-14 14:26:20 +02009687 ly_print_(&out, "ROOT output \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009688 break;
9689 case LYXP_NODE_ELEM:
Michal Vasko5233e962020-08-14 14:26:20 +02009690 ly_print_(&out, "ELEM \"%s\"\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009691 xml_print_node(&out, 1, set->value.nodes[i], 1, LYP_FORMAT);
Michal Vasko5233e962020-08-14 14:26:20 +02009692 ly_print_(&out, "\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02009693 break;
9694 case LYXP_NODE_TEXT:
Michal Vasko5233e962020-08-14 14:26:20 +02009695 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 +02009696 break;
9697 case LYXP_NODE_ATTR:
Michal Vasko5233e962020-08-14 14:26:20 +02009698 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 +02009699 break;
9700 }
9701 }
9702 break;
9703 }
9704}
9705
9706#endif
9707
9708LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009709lyxp_set_cast(struct lyxp_set *set, enum lyxp_set_type target)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009710{
9711 long double num;
9712 char *str;
9713 LY_ERR rc;
9714
9715 if (!set || (set->type == target)) {
9716 return LY_SUCCESS;
9717 }
9718
9719 /* it's not possible to convert anything into a node set */
Michal Vaskod3678892020-05-21 10:06:58 +02009720 assert(target != LYXP_SET_NODE_SET);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009721
9722 if (set->type == LYXP_SET_SCNODE_SET) {
Michal Vaskod3678892020-05-21 10:06:58 +02009723 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009724 return LY_EINVAL;
9725 }
9726
9727 /* to STRING */
Michal Vaskod3678892020-05-21 10:06:58 +02009728 if ((target == LYXP_SET_STRING) || ((target == LYXP_SET_NUMBER) && (set->type == LYXP_SET_NODE_SET))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02009729 switch (set->type) {
9730 case LYXP_SET_NUMBER:
9731 if (isnan(set->val.num)) {
9732 set->val.str = strdup("NaN");
9733 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
9734 } else if ((set->val.num == 0) || (set->val.num == -0.0f)) {
9735 set->val.str = strdup("0");
9736 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
9737 } else if (isinf(set->val.num) && !signbit(set->val.num)) {
9738 set->val.str = strdup("Infinity");
9739 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
9740 } else if (isinf(set->val.num) && signbit(set->val.num)) {
9741 set->val.str = strdup("-Infinity");
9742 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
9743 } else if ((long long)set->val.num == set->val.num) {
9744 if (asprintf(&str, "%lld", (long long)set->val.num) == -1) {
9745 LOGMEM_RET(set->ctx);
9746 }
9747 set->val.str = str;
9748 } else {
9749 if (asprintf(&str, "%03.1Lf", set->val.num) == -1) {
9750 LOGMEM_RET(set->ctx);
9751 }
9752 set->val.str = str;
9753 }
9754 break;
9755 case LYXP_SET_BOOLEAN:
Michal Vasko004d3152020-06-11 19:59:22 +02009756 if (set->val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02009757 set->val.str = strdup("true");
9758 } else {
9759 set->val.str = strdup("false");
9760 }
9761 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), LY_EMEM);
9762 break;
9763 case LYXP_SET_NODE_SET:
Michal Vasko03ff5a72019-09-11 13:49:33 +02009764 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009765 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02009766
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01009767 rc = cast_node_set_to_string(set, &str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009768 LY_CHECK_RET(rc);
Michal Vaskod3678892020-05-21 10:06:58 +02009769 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009770 set->val.str = str;
9771 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009772 default:
9773 LOGINT_RET(set->ctx);
9774 }
9775 set->type = LYXP_SET_STRING;
9776 }
9777
9778 /* to NUMBER */
9779 if (target == LYXP_SET_NUMBER) {
9780 switch (set->type) {
9781 case LYXP_SET_STRING:
9782 num = cast_string_to_number(set->val.str);
Michal Vaskod3678892020-05-21 10:06:58 +02009783 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02009784 set->val.num = num;
9785 break;
9786 case LYXP_SET_BOOLEAN:
Michal Vasko004d3152020-06-11 19:59:22 +02009787 if (set->val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02009788 set->val.num = 1;
9789 } else {
9790 set->val.num = 0;
9791 }
9792 break;
9793 default:
9794 LOGINT_RET(set->ctx);
9795 }
9796 set->type = LYXP_SET_NUMBER;
9797 }
9798
9799 /* to BOOLEAN */
9800 if (target == LYXP_SET_BOOLEAN) {
9801 switch (set->type) {
9802 case LYXP_SET_NUMBER:
9803 if ((set->val.num == 0) || (set->val.num == -0.0f) || isnan(set->val.num)) {
Michal Vasko004d3152020-06-11 19:59:22 +02009804 set->val.bln = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009805 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02009806 set->val.bln = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009807 }
9808 break;
9809 case LYXP_SET_STRING:
9810 if (set->val.str[0]) {
Michal Vaskod3678892020-05-21 10:06:58 +02009811 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02009812 set->val.bln = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009813 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02009814 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02009815 set->val.bln = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009816 }
9817 break;
9818 case LYXP_SET_NODE_SET:
Michal Vaskod3678892020-05-21 10:06:58 +02009819 if (set->used) {
9820 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02009821 set->val.bln = 1;
Michal Vaskod3678892020-05-21 10:06:58 +02009822 } else {
9823 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02009824 set->val.bln = 0;
Michal Vaskod3678892020-05-21 10:06:58 +02009825 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02009826 break;
9827 default:
9828 LOGINT_RET(set->ctx);
9829 }
9830 set->type = LYXP_SET_BOOLEAN;
9831 }
9832
Michal Vasko03ff5a72019-09-11 13:49:33 +02009833 return LY_SUCCESS;
9834}
9835
9836LY_ERR
Michal Vasko400e9672021-01-11 13:39:17 +01009837lyxp_atomize(const struct ly_ctx *ctx, const struct lyxp_expr *exp, const struct lys_module *cur_mod,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +02009838 LY_VALUE_FORMAT format, void *prefix_data, const struct lysc_node *cur_scnode,
9839 const struct lysc_node *ctx_scnode, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02009840{
Radek Krejci2efc45b2020-12-22 16:25:44 +01009841 LY_ERR ret;
Michal Vaskodd528af2022-08-08 14:35:07 +02009842 uint32_t tok_idx = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009843
Michal Vasko400e9672021-01-11 13:39:17 +01009844 LY_CHECK_ARG_RET(ctx, ctx, exp, set, LY_EINVAL);
Radek Krejci8df109d2021-04-23 12:19:08 +02009845 if (!cur_mod && ((format == LY_VALUE_SCHEMA) || (format == LY_VALUE_SCHEMA_RESOLVED))) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009846 LOGARG(NULL, "Current module must be set if schema format is used.");
9847 return LY_EINVAL;
Michal Vasko004d3152020-06-11 19:59:22 +02009848 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02009849
9850 /* prepare set for evaluation */
Michal Vasko03ff5a72019-09-11 13:49:33 +02009851 memset(set, 0, sizeof *set);
9852 set->type = LYXP_SET_SCNODE_SET;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009853 set->root_type = lyxp_get_root_type(NULL, ctx_scnode, options);
Michal Vasko7333cb32022-07-29 16:30:29 +02009854 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 +01009855 set->val.scnodes[0].in_ctx = LYXP_SET_SCNODE_START;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009856
Michal Vasko400e9672021-01-11 13:39:17 +01009857 set->ctx = (struct ly_ctx *)ctx;
Michal Vaskoa3e92bc2022-07-29 14:56:23 +02009858 set->cur_scnode = cur_scnode;
9859 for (set->context_op = cur_scnode;
Radek Krejci0f969882020-08-21 16:56:47 +02009860 set->context_op && !(set->context_op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF));
9861 set->context_op = set->context_op->parent) {}
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009862 set->cur_mod = cur_mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009863 set->format = format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009864 set->prefix_data = prefix_data;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009865
Radek Krejciddace2c2021-01-08 11:30:56 +01009866 LOG_LOCSET(set->cur_scnode, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01009867
Michal Vasko03ff5a72019-09-11 13:49:33 +02009868 /* evaluate */
Radek Krejci2efc45b2020-12-22 16:25:44 +01009869 ret = eval_expr_select(exp, &tok_idx, 0, set, options);
9870
Michal Vaskof69e4552022-12-02 10:27:42 +01009871 LOG_LOCBACK(set->cur_scnode ? 1 : 0, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01009872 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009873}
Michal Vaskod43d71a2020-08-07 14:54:58 +02009874
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01009875LIBYANG_API_DEF const char *
Michal Vaskod43d71a2020-08-07 14:54:58 +02009876lyxp_get_expr(const struct lyxp_expr *path)
9877{
9878 if (!path) {
9879 return NULL;
9880 }
9881
9882 return path->expr;
9883}