blob: ddfdc0605dec534f985bda26765dcbd18b555beb [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 Vasko61ac2f62020-05-25 12:39:51 +02006 * Copyright (c) 2015 - 2020 CESNET, z.s.p.o.
Radek Krejcib1646a92018-11-02 16:08:26 +01007 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
Christian Hopps32874e12021-05-01 09:43:54 -040014#define _GNU_SOURCE /* asprintf, strdup */
Radek Krejcib1646a92018-11-02 16:08:26 +010015
Radek Krejci535ea9f2020-05-29 16:01:05 +020016#include "xpath.h"
Radek Krejcib1646a92018-11-02 16:08:26 +010017
Radek Krejci535ea9f2020-05-29 16:01:05 +020018#include <assert.h>
Radek Krejcib1646a92018-11-02 16:08:26 +010019#include <ctype.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020020#include <errno.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020021#include <math.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020022#include <stdint.h>
Radek Krejcib1646a92018-11-02 16:08:26 +010023#include <stdio.h>
24#include <stdlib.h>
Radek Krejcib1646a92018-11-02 16:08:26 +010025#include <string.h>
Radek Krejcib1646a92018-11-02 16:08:26 +010026
Radek Krejci535ea9f2020-05-29 16:01:05 +020027#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020028#include "compat.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020029#include "context.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020030#include "dict.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020031#include "hash_table.h"
Radek Krejci47fab892020-11-05 17:02:41 +010032#include "out.h"
Radek Krejci7931b192020-06-25 17:05:03 +020033#include "parser_data.h"
Michal Vasko004d3152020-06-11 19:59:22 +020034#include "path.h"
Michal Vasko03ff5a72019-09-11 13:49:33 +020035#include "plugins_types.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020036#include "printer_data.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020037#include "schema_compile_node.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020038#include "tree.h"
Radek Krejci77114102021-03-10 15:21:57 +010039#include "tree_data.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020040#include "tree_data_internal.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010041#include "tree_edit.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020042#include "tree_schema_internal.h"
43#include "xml.h"
Michal Vasko03ff5a72019-09-11 13:49:33 +020044
aPiecekbf968d92021-05-27 14:35:05 +020045static LY_ERR reparse_or_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t depth);
Michal Vasko40308e72020-10-20 16:38:40 +020046static LY_ERR eval_expr_select(const struct lyxp_expr *exp, uint16_t *tok_idx, enum lyxp_expr_type etype,
47 struct lyxp_set *set, uint32_t options);
Michal Vasko93923692021-05-07 15:28:02 +020048static LY_ERR moveto_resolve_model(const char **qname, uint16_t *qname_len, const struct lyxp_set *set,
49 const struct lysc_node *ctx_scnode, const struct lys_module **moveto_mod);
Michal Vasko03ff5a72019-09-11 13:49:33 +020050
aPiecek96dc1e32021-10-08 15:45:59 +020051/* Functions are divided into the following basic classes:
52 *
53 * (re)parse functions:
54 * Parse functions parse the expression into
55 * tokens (syntactic analysis).
56 * Reparse functions perform semantic analysis
57 * (do not save the result, just a check) of
58 * the expression and fill repeat indices.
59 *
60 * warn functions:
61 * Warn functions check specific reasonable conditions for schema XPath
62 * and print a warning if they are not satisfied.
63 *
64 * moveto functions:
65 * They and only they actually change the context (set).
66 *
67 * eval functions:
68 * They execute a parsed XPath expression on some data subtree.
69 */
70
Michal Vasko03ff5a72019-09-11 13:49:33 +020071/**
72 * @brief Print the type of an XPath \p set.
73 *
74 * @param[in] set Set to use.
75 * @return Set type string.
76 */
77static const char *
78print_set_type(struct lyxp_set *set)
79{
80 switch (set->type) {
Michal Vasko03ff5a72019-09-11 13:49:33 +020081 case LYXP_SET_NODE_SET:
82 return "node set";
83 case LYXP_SET_SCNODE_SET:
84 return "schema node set";
85 case LYXP_SET_BOOLEAN:
86 return "boolean";
87 case LYXP_SET_NUMBER:
88 return "number";
89 case LYXP_SET_STRING:
90 return "string";
91 }
92
93 return NULL;
94}
95
Michal Vasko24cddf82020-06-01 08:17:01 +020096const char *
97lyxp_print_token(enum lyxp_token tok)
Michal Vasko03ff5a72019-09-11 13:49:33 +020098{
99 switch (tok) {
100 case LYXP_TOKEN_PAR1:
101 return "(";
102 case LYXP_TOKEN_PAR2:
103 return ")";
104 case LYXP_TOKEN_BRACK1:
105 return "[";
106 case LYXP_TOKEN_BRACK2:
107 return "]";
108 case LYXP_TOKEN_DOT:
109 return ".";
110 case LYXP_TOKEN_DDOT:
111 return "..";
112 case LYXP_TOKEN_AT:
113 return "@";
114 case LYXP_TOKEN_COMMA:
115 return ",";
116 case LYXP_TOKEN_NAMETEST:
117 return "NameTest";
118 case LYXP_TOKEN_NODETYPE:
119 return "NodeType";
aPiecekfba75362021-10-07 12:39:48 +0200120 case LYXP_TOKEN_VARREF:
121 return "VariableReference";
Michal Vasko03ff5a72019-09-11 13:49:33 +0200122 case LYXP_TOKEN_FUNCNAME:
123 return "FunctionName";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200124 case LYXP_TOKEN_OPER_LOG:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200125 return "Operator(Logic)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200126 case LYXP_TOKEN_OPER_EQUAL:
127 return "Operator(Equal)";
128 case LYXP_TOKEN_OPER_NEQUAL:
129 return "Operator(Non-equal)";
130 case LYXP_TOKEN_OPER_COMP:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200131 return "Operator(Comparison)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200132 case LYXP_TOKEN_OPER_MATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200133 return "Operator(Math)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200134 case LYXP_TOKEN_OPER_UNI:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200135 return "Operator(Union)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200136 case LYXP_TOKEN_OPER_PATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200137 return "Operator(Path)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200138 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko14676352020-05-29 11:35:55 +0200139 return "Operator(Recursive Path)";
Michal Vasko03ff5a72019-09-11 13:49:33 +0200140 case LYXP_TOKEN_LITERAL:
141 return "Literal";
142 case LYXP_TOKEN_NUMBER:
143 return "Number";
144 default:
145 LOGINT(NULL);
146 return "";
147 }
148}
149
150/**
151 * @brief Print the whole expression \p exp to debug output.
152 *
153 * @param[in] exp Expression to use.
154 */
155static void
Michal Vasko40308e72020-10-20 16:38:40 +0200156print_expr_struct_debug(const struct lyxp_expr *exp)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200157{
Radek Krejcif13b87b2020-12-01 22:02:17 +0100158#define MSG_BUFFER_SIZE 128
159 char tmp[MSG_BUFFER_SIZE];
Michal Vasko1fdd8fa2021-01-08 09:21:45 +0100160 uint32_t i, j;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200161
Radek Krejci52b6d512020-10-12 12:33:17 +0200162 if (!exp || (ly_ll < LY_LLDBG)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200163 return;
164 }
165
166 LOGDBG(LY_LDGXPATH, "expression \"%s\":", exp->expr);
167 for (i = 0; i < exp->used; ++i) {
Michal Vasko24cddf82020-06-01 08:17:01 +0200168 sprintf(tmp, "\ttoken %s, in expression \"%.*s\"", lyxp_print_token(exp->tokens[i]), exp->tok_len[i],
Michal Vasko69730152020-10-09 16:30:07 +0200169 &exp->expr[exp->tok_pos[i]]);
Michal Vasko23049552021-03-04 15:57:44 +0100170 if (exp->repeat && exp->repeat[i]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200171 sprintf(tmp + strlen(tmp), " (repeat %d", exp->repeat[i][0]);
172 for (j = 1; exp->repeat[i][j]; ++j) {
173 sprintf(tmp + strlen(tmp), ", %d", exp->repeat[i][j]);
174 }
175 strcat(tmp, ")");
176 }
177 LOGDBG(LY_LDGXPATH, tmp);
178 }
Radek Krejcif13b87b2020-12-01 22:02:17 +0100179#undef MSG_BUFFER_SIZE
Michal Vasko03ff5a72019-09-11 13:49:33 +0200180}
181
182#ifndef NDEBUG
183
184/**
185 * @brief Print XPath set content to debug output.
186 *
187 * @param[in] set Set to print.
188 */
189static void
190print_set_debug(struct lyxp_set *set)
191{
192 uint32_t i;
193 char *str;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200194 struct lyxp_set_node *item;
195 struct lyxp_set_scnode *sitem;
196
Radek Krejci52b6d512020-10-12 12:33:17 +0200197 if (ly_ll < LY_LLDBG) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200198 return;
199 }
200
201 switch (set->type) {
202 case LYXP_SET_NODE_SET:
203 LOGDBG(LY_LDGXPATH, "set NODE SET:");
204 for (i = 0; i < set->used; ++i) {
205 item = &set->val.nodes[i];
206
207 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +0100208 case LYXP_NODE_NONE:
209 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): NONE", i + 1, item->pos);
210 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200211 case LYXP_NODE_ROOT:
212 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ROOT", i + 1, item->pos);
213 break;
214 case LYXP_NODE_ROOT_CONFIG:
215 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ROOT CONFIG", i + 1, item->pos);
216 break;
217 case LYXP_NODE_ELEM:
Michal Vasko9e685082021-01-29 14:49:09 +0100218 if ((item->node->schema->nodetype == LYS_LIST) && (lyd_child(item->node)->schema->nodetype == LYS_LEAF)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200219 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s (1st child val: %s)", i + 1, item->pos,
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200220 item->node->schema->name, lyd_get_value(lyd_child(item->node)));
Michal Vasko9e685082021-01-29 14:49:09 +0100221 } else if (item->node->schema->nodetype == LYS_LEAFLIST) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200222 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s (val: %s)", i + 1, item->pos,
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200223 item->node->schema->name, lyd_get_value(item->node));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200224 } else {
225 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s", i + 1, item->pos, item->node->schema->name);
226 }
227 break;
228 case LYXP_NODE_TEXT:
229 if (item->node->schema->nodetype & LYS_ANYDATA) {
230 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): TEXT <%s>", i + 1, item->pos,
Michal Vasko69730152020-10-09 16:30:07 +0200231 item->node->schema->nodetype == LYS_ANYXML ? "anyxml" : "anydata");
Michal Vasko03ff5a72019-09-11 13:49:33 +0200232 } else {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200233 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 +0200234 }
235 break;
Michal Vasko9f96a052020-03-10 09:41:45 +0100236 case LYXP_NODE_META:
237 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 +0200238 set->val.meta[i].meta->value);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200239 break;
240 }
241 }
242 break;
243
244 case LYXP_SET_SCNODE_SET:
245 LOGDBG(LY_LDGXPATH, "set SCNODE SET:");
246 for (i = 0; i < set->used; ++i) {
247 sitem = &set->val.scnodes[i];
248
249 switch (sitem->type) {
250 case LYXP_NODE_ROOT:
251 LOGDBG(LY_LDGXPATH, "\t%d (%u): ROOT", i + 1, sitem->in_ctx);
252 break;
253 case LYXP_NODE_ROOT_CONFIG:
254 LOGDBG(LY_LDGXPATH, "\t%d (%u): ROOT CONFIG", i + 1, sitem->in_ctx);
255 break;
256 case LYXP_NODE_ELEM:
257 LOGDBG(LY_LDGXPATH, "\t%d (%u): ELEM %s", i + 1, sitem->in_ctx, sitem->scnode->name);
258 break;
259 default:
260 LOGINT(NULL);
261 break;
262 }
263 }
264 break;
265
Michal Vasko03ff5a72019-09-11 13:49:33 +0200266 case LYXP_SET_BOOLEAN:
267 LOGDBG(LY_LDGXPATH, "set BOOLEAN");
Michal Vasko004d3152020-06-11 19:59:22 +0200268 LOGDBG(LY_LDGXPATH, "\t%s", (set->val.bln ? "true" : "false"));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200269 break;
270
271 case LYXP_SET_STRING:
272 LOGDBG(LY_LDGXPATH, "set STRING");
273 LOGDBG(LY_LDGXPATH, "\t%s", set->val.str);
274 break;
275
276 case LYXP_SET_NUMBER:
277 LOGDBG(LY_LDGXPATH, "set NUMBER");
278
279 if (isnan(set->val.num)) {
280 str = strdup("NaN");
281 } else if ((set->val.num == 0) || (set->val.num == -0.0f)) {
282 str = strdup("0");
283 } else if (isinf(set->val.num) && !signbit(set->val.num)) {
284 str = strdup("Infinity");
285 } else if (isinf(set->val.num) && signbit(set->val.num)) {
286 str = strdup("-Infinity");
287 } else if ((long long)set->val.num == set->val.num) {
288 if (asprintf(&str, "%lld", (long long)set->val.num) == -1) {
289 str = NULL;
290 }
291 } else {
292 if (asprintf(&str, "%03.1Lf", set->val.num) == -1) {
293 str = NULL;
294 }
295 }
296 LY_CHECK_ERR_RET(!str, LOGMEM(NULL), );
297
298 LOGDBG(LY_LDGXPATH, "\t%s", str);
299 free(str);
300 }
301}
302
303#endif
304
305/**
306 * @brief Realloc the string \p str.
307 *
308 * @param[in] ctx libyang context for logging.
309 * @param[in] needed How much free space is required.
310 * @param[in,out] str Pointer to the string to use.
311 * @param[in,out] used Used bytes in \p str.
312 * @param[in,out] size Allocated bytes in \p str.
313 * @return LY_ERR
314 */
315static LY_ERR
Michal Vasko52927e22020-03-16 17:26:14 +0100316cast_string_realloc(const struct ly_ctx *ctx, uint16_t needed, char **str, uint16_t *used, uint16_t *size)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200317{
318 if (*size - *used < needed) {
319 do {
320 if ((UINT16_MAX - *size) < LYXP_STRING_CAST_SIZE_STEP) {
321 LOGERR(ctx, LY_EINVAL, "XPath string length limit (%u) reached.", UINT16_MAX);
322 return LY_EINVAL;
323 }
324 *size += LYXP_STRING_CAST_SIZE_STEP;
325 } while (*size - *used < needed);
326 *str = ly_realloc(*str, *size * sizeof(char));
327 LY_CHECK_ERR_RET(!(*str), LOGMEM(ctx), LY_EMEM);
328 }
329
330 return LY_SUCCESS;
331}
332
333/**
334 * @brief Cast nodes recursively to one string @p str.
335 *
336 * @param[in] node Node to cast.
337 * @param[in] fake_cont Whether to put the data into a "fake" container.
338 * @param[in] root_type Type of the XPath root.
339 * @param[in] indent Current indent.
340 * @param[in,out] str Resulting string.
341 * @param[in,out] used Used bytes in @p str.
342 * @param[in,out] size Allocated bytes in @p str.
343 * @return LY_ERR
344 */
345static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200346cast_string_recursive(const struct lyd_node *node, ly_bool fake_cont, enum lyxp_node_type root_type, uint16_t indent, char **str,
Radek Krejci0f969882020-08-21 16:56:47 +0200347 uint16_t *used, uint16_t *size)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200348{
Radek Krejci7f769d72020-07-11 23:13:56 +0200349 char *buf, *line, *ptr = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200350 const char *value_str;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200351 const struct lyd_node *child;
Michal Vasko60ea6352020-06-29 13:39:39 +0200352 struct lyd_node *tree;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200353 struct lyd_node_any *any;
354 LY_ERR rc;
355
356 if ((root_type == LYXP_NODE_ROOT_CONFIG) && (node->schema->flags & LYS_CONFIG_R)) {
357 return LY_SUCCESS;
358 }
359
360 if (fake_cont) {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200361 rc = cast_string_realloc(LYD_CTX(node), 1, str, used, size);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200362 LY_CHECK_RET(rc);
363 strcpy(*str + (*used - 1), "\n");
364 ++(*used);
365
366 ++indent;
367 }
368
369 switch (node->schema->nodetype) {
370 case LYS_CONTAINER:
371 case LYS_LIST:
372 case LYS_RPC:
373 case LYS_NOTIF:
Michal Vaskob7be7a82020-08-20 09:09:04 +0200374 rc = cast_string_realloc(LYD_CTX(node), 1, str, used, size);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200375 LY_CHECK_RET(rc);
376 strcpy(*str + (*used - 1), "\n");
377 ++(*used);
378
Radek Krejcia1c1e542020-09-29 16:06:52 +0200379 for (child = lyd_child(node); child; child = child->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200380 rc = cast_string_recursive(child, 0, root_type, indent + 1, str, used, size);
381 LY_CHECK_RET(rc);
382 }
383
384 break;
385
386 case LYS_LEAF:
387 case LYS_LEAFLIST:
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200388 value_str = lyd_get_value(node);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200389
390 /* print indent */
Michal Vaskob7be7a82020-08-20 09:09:04 +0200391 LY_CHECK_RET(cast_string_realloc(LYD_CTX(node), indent * 2 + strlen(value_str) + 1, str, used, size));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200392 memset(*str + (*used - 1), ' ', indent * 2);
393 *used += indent * 2;
394
395 /* print value */
396 if (*used == 1) {
397 sprintf(*str + (*used - 1), "%s", value_str);
398 *used += strlen(value_str);
399 } else {
400 sprintf(*str + (*used - 1), "%s\n", value_str);
401 *used += strlen(value_str) + 1;
402 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200403
404 break;
405
406 case LYS_ANYXML:
407 case LYS_ANYDATA:
408 any = (struct lyd_node_any *)node;
409 if (!(void *)any->value.tree) {
410 /* no content */
411 buf = strdup("");
Michal Vaskob7be7a82020-08-20 09:09:04 +0200412 LY_CHECK_ERR_RET(!buf, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200413 } else {
Radek Krejci241f6b52020-05-21 18:13:49 +0200414 struct ly_out *out;
Radek Krejcia5bba312020-01-09 15:41:20 +0100415
Michal Vasko60ea6352020-06-29 13:39:39 +0200416 if (any->value_type == LYD_ANYDATA_LYB) {
417 /* try to parse it into a data tree */
Michal Vaskob7be7a82020-08-20 09:09:04 +0200418 if (lyd_parse_data_mem((struct ly_ctx *)LYD_CTX(node), any->value.mem, LYD_LYB, LYD_PARSE_ONLY | LYD_PARSE_STRICT, 0, &tree) == LY_SUCCESS) {
Michal Vasko60ea6352020-06-29 13:39:39 +0200419 /* successfully parsed */
420 free(any->value.mem);
421 any->value.tree = tree;
422 any->value_type = LYD_ANYDATA_DATATREE;
423 }
Radek Krejci7931b192020-06-25 17:05:03 +0200424 /* error is covered by the following switch where LYD_ANYDATA_LYB causes failure */
Michal Vasko60ea6352020-06-29 13:39:39 +0200425 }
426
Michal Vasko03ff5a72019-09-11 13:49:33 +0200427 switch (any->value_type) {
428 case LYD_ANYDATA_STRING:
429 case LYD_ANYDATA_XML:
430 case LYD_ANYDATA_JSON:
431 buf = strdup(any->value.json);
Michal Vaskob7be7a82020-08-20 09:09:04 +0200432 LY_CHECK_ERR_RET(!buf, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200433 break;
434 case LYD_ANYDATA_DATATREE:
Radek Krejci84ce7b12020-06-11 17:28:25 +0200435 LY_CHECK_RET(ly_out_new_memory(&buf, 0, &out));
Michal Vasko3a41dff2020-07-15 14:30:28 +0200436 rc = lyd_print_all(out, any->value.tree, LYD_XML, 0);
Radek Krejci241f6b52020-05-21 18:13:49 +0200437 ly_out_free(out, NULL, 0);
Radek Krejcia5bba312020-01-09 15:41:20 +0100438 LY_CHECK_RET(rc < 0, -rc);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200439 break;
Michal Vasko60ea6352020-06-29 13:39:39 +0200440 case LYD_ANYDATA_LYB:
Michal Vaskob7be7a82020-08-20 09:09:04 +0200441 LOGERR(LYD_CTX(node), LY_EINVAL, "Cannot convert LYB anydata into string.");
Michal Vasko60ea6352020-06-29 13:39:39 +0200442 return LY_EINVAL;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200443 }
444 }
445
446 line = strtok_r(buf, "\n", &ptr);
447 do {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200448 rc = cast_string_realloc(LYD_CTX(node), indent * 2 + strlen(line) + 1, str, used, size);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200449 if (rc != LY_SUCCESS) {
450 free(buf);
451 return rc;
452 }
453 memset(*str + (*used - 1), ' ', indent * 2);
454 *used += indent * 2;
455
456 strcpy(*str + (*used - 1), line);
457 *used += strlen(line);
458
459 strcpy(*str + (*used - 1), "\n");
460 *used += 1;
461 } while ((line = strtok_r(NULL, "\n", &ptr)));
462
463 free(buf);
464 break;
465
466 default:
Michal Vaskob7be7a82020-08-20 09:09:04 +0200467 LOGINT_RET(LYD_CTX(node));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200468 }
469
470 if (fake_cont) {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200471 rc = cast_string_realloc(LYD_CTX(node), 1, str, used, size);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200472 LY_CHECK_RET(rc);
473 strcpy(*str + (*used - 1), "\n");
474 ++(*used);
475
476 --indent;
477 }
478
479 return LY_SUCCESS;
480}
481
482/**
483 * @brief Cast an element into a string.
484 *
485 * @param[in] node Node to cast.
486 * @param[in] fake_cont Whether to put the data into a "fake" container.
487 * @param[in] root_type Type of the XPath root.
488 * @param[out] str Element cast to dynamically-allocated string.
489 * @return LY_ERR
490 */
491static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200492cast_string_elem(struct lyd_node *node, ly_bool fake_cont, enum lyxp_node_type root_type, char **str)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200493{
494 uint16_t used, size;
495 LY_ERR rc;
496
497 *str = malloc(LYXP_STRING_CAST_SIZE_START * sizeof(char));
Michal Vaskob7be7a82020-08-20 09:09:04 +0200498 LY_CHECK_ERR_RET(!*str, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200499 (*str)[0] = '\0';
500 used = 1;
501 size = LYXP_STRING_CAST_SIZE_START;
502
503 rc = cast_string_recursive(node, fake_cont, root_type, 0, str, &used, &size);
504 if (rc != LY_SUCCESS) {
505 free(*str);
506 return rc;
507 }
508
509 if (size > used) {
510 *str = ly_realloc(*str, used * sizeof(char));
Michal Vaskob7be7a82020-08-20 09:09:04 +0200511 LY_CHECK_ERR_RET(!*str, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200512 }
513 return LY_SUCCESS;
514}
515
516/**
517 * @brief Cast a LYXP_SET_NODE_SET set into a string.
518 * Context position aware.
519 *
520 * @param[in] set Set to cast.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200521 * @param[out] str Cast dynamically-allocated string.
522 * @return LY_ERR
523 */
524static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100525cast_node_set_to_string(struct lyxp_set *set, char **str)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200526{
Michal Vaskoaa677062021-03-09 13:52:53 +0100527 if (!set->used) {
528 *str = strdup("");
529 if (!*str) {
530 LOGMEM_RET(set->ctx);
531 }
532 return LY_SUCCESS;
533 }
534
Michal Vasko03ff5a72019-09-11 13:49:33 +0200535 switch (set->val.nodes[0].type) {
Michal Vasko2caefc12019-11-14 16:07:56 +0100536 case LYXP_NODE_NONE:
537 /* invalid */
538 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200539 case LYXP_NODE_ROOT:
540 case LYXP_NODE_ROOT_CONFIG:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100541 return cast_string_elem(set->val.nodes[0].node, 1, set->root_type, str);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200542 case LYXP_NODE_ELEM:
543 case LYXP_NODE_TEXT:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100544 return cast_string_elem(set->val.nodes[0].node, 0, set->root_type, str);
Michal Vasko9f96a052020-03-10 09:41:45 +0100545 case LYXP_NODE_META:
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200546 *str = strdup(lyd_get_meta_value(set->val.meta[0].meta));
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200547 if (!*str) {
548 LOGMEM_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200549 }
550 return LY_SUCCESS;
551 }
552
553 LOGINT_RET(set->ctx);
554}
555
556/**
557 * @brief Cast a string into an XPath number.
558 *
559 * @param[in] str String to use.
560 * @return Cast number.
561 */
562static long double
563cast_string_to_number(const char *str)
564{
565 long double num;
566 char *ptr;
567
568 errno = 0;
569 num = strtold(str, &ptr);
570 if (errno || *ptr) {
571 num = NAN;
572 }
573 return num;
574}
575
576/**
577 * @brief Callback for checking value equality.
578 *
Michal Vasko62524a92021-02-26 10:08:50 +0100579 * Implementation of ::lyht_value_equal_cb.
Radek Krejci857189e2020-09-01 13:26:36 +0200580 *
Michal Vasko03ff5a72019-09-11 13:49:33 +0200581 * @param[in] val1_p First value.
582 * @param[in] val2_p Second value.
583 * @param[in] mod Whether hash table is being modified.
584 * @param[in] cb_data Callback data.
Radek Krejci857189e2020-09-01 13:26:36 +0200585 * @return Boolean value whether values are equal or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200586 */
Radek Krejci857189e2020-09-01 13:26:36 +0200587static ly_bool
588set_values_equal_cb(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *UNUSED(cb_data))
Michal Vasko03ff5a72019-09-11 13:49:33 +0200589{
590 struct lyxp_set_hash_node *val1, *val2;
591
592 val1 = (struct lyxp_set_hash_node *)val1_p;
593 val2 = (struct lyxp_set_hash_node *)val2_p;
594
595 if ((val1->node == val2->node) && (val1->type == val2->type)) {
596 return 1;
597 }
598
599 return 0;
600}
601
602/**
603 * @brief Insert node and its hash into set.
604 *
605 * @param[in] set et to insert to.
606 * @param[in] node Node with hash.
607 * @param[in] type Node type.
608 */
609static void
610set_insert_node_hash(struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type)
611{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200612 LY_ERR r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200613 uint32_t i, hash;
614 struct lyxp_set_hash_node hnode;
615
616 if (!set->ht && (set->used >= LYD_HT_MIN_ITEMS)) {
617 /* create hash table and add all the nodes */
618 set->ht = lyht_new(1, sizeof(struct lyxp_set_hash_node), set_values_equal_cb, NULL, 1);
619 for (i = 0; i < set->used; ++i) {
620 hnode.node = set->val.nodes[i].node;
621 hnode.type = set->val.nodes[i].type;
622
623 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
624 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
625 hash = dict_hash_multi(hash, NULL, 0);
626
627 r = lyht_insert(set->ht, &hnode, hash, NULL);
628 assert(!r);
629 (void)r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200630
Michal Vasko9d6befd2019-12-11 14:56:56 +0100631 if (hnode.node == node) {
632 /* it was just added, do not add it twice */
633 node = NULL;
634 }
635 }
636 }
637
638 if (set->ht && node) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200639 /* add the new node into hash table */
640 hnode.node = node;
641 hnode.type = type;
642
643 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
644 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
645 hash = dict_hash_multi(hash, NULL, 0);
646
647 r = lyht_insert(set->ht, &hnode, hash, NULL);
648 assert(!r);
649 (void)r;
650 }
651}
652
653/**
654 * @brief Remove node and its hash from set.
655 *
656 * @param[in] set Set to remove from.
657 * @param[in] node Node to remove.
658 * @param[in] type Node type.
659 */
660static void
661set_remove_node_hash(struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type)
662{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200663 LY_ERR r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200664 struct lyxp_set_hash_node hnode;
665 uint32_t hash;
666
667 if (set->ht) {
668 hnode.node = node;
669 hnode.type = type;
670
671 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
672 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
673 hash = dict_hash_multi(hash, NULL, 0);
674
675 r = lyht_remove(set->ht, &hnode, hash);
676 assert(!r);
677 (void)r;
678
679 if (!set->ht->used) {
680 lyht_free(set->ht);
681 set->ht = NULL;
682 }
683 }
684}
685
686/**
687 * @brief Check whether node is in set based on its hash.
688 *
689 * @param[in] set Set to search in.
690 * @param[in] node Node to search for.
691 * @param[in] type Node type.
692 * @param[in] skip_idx Index in @p set to skip.
693 * @return LY_ERR
694 */
695static LY_ERR
696set_dup_node_hash_check(const struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type, int skip_idx)
697{
698 struct lyxp_set_hash_node hnode, *match_p;
699 uint32_t hash;
700
701 hnode.node = node;
702 hnode.type = type;
703
704 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
705 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
706 hash = dict_hash_multi(hash, NULL, 0);
707
708 if (!lyht_find(set->ht, &hnode, hash, (void **)&match_p)) {
709 if ((skip_idx > -1) && (set->val.nodes[skip_idx].node == match_p->node) && (set->val.nodes[skip_idx].type == match_p->type)) {
710 /* we found it on the index that should be skipped, find another */
711 hnode = *match_p;
712 if (lyht_find_next(set->ht, &hnode, hash, (void **)&match_p)) {
713 /* none other found */
714 return LY_SUCCESS;
715 }
716 }
717
718 return LY_EEXIST;
719 }
720
721 /* not found */
722 return LY_SUCCESS;
723}
724
Michal Vaskod3678892020-05-21 10:06:58 +0200725void
726lyxp_set_free_content(struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200727{
728 if (!set) {
729 return;
730 }
731
732 if (set->type == LYXP_SET_NODE_SET) {
733 free(set->val.nodes);
734 lyht_free(set->ht);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200735 } else if (set->type == LYXP_SET_SCNODE_SET) {
736 free(set->val.scnodes);
Michal Vaskod3678892020-05-21 10:06:58 +0200737 lyht_free(set->ht);
738 } else {
739 if (set->type == LYXP_SET_STRING) {
740 free(set->val.str);
741 }
742 set->type = LYXP_SET_NODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200743 }
Michal Vaskod3678892020-05-21 10:06:58 +0200744
745 set->val.nodes = NULL;
746 set->used = 0;
747 set->size = 0;
748 set->ht = NULL;
749 set->ctx_pos = 0;
aPiecek748da732021-06-01 09:56:43 +0200750 set->ctx_size = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200751}
752
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100753/**
754 * @brief Free dynamically-allocated set.
755 *
756 * @param[in] set Set to free.
757 */
758static void
Michal Vasko03ff5a72019-09-11 13:49:33 +0200759lyxp_set_free(struct lyxp_set *set)
760{
761 if (!set) {
762 return;
763 }
764
Michal Vaskod3678892020-05-21 10:06:58 +0200765 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200766 free(set);
767}
768
769/**
770 * @brief Initialize set context.
771 *
772 * @param[in] new Set to initialize.
773 * @param[in] set Arbitrary initialized set.
774 */
775static void
Michal Vasko4c7763f2020-07-27 17:40:37 +0200776set_init(struct lyxp_set *new, const struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200777{
778 memset(new, 0, sizeof *new);
Michal Vasko02a77382019-09-12 11:47:35 +0200779 if (set) {
780 new->ctx = set->ctx;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200781 new->cur_node = set->cur_node;
Michal Vasko588112f2019-12-10 14:51:53 +0100782 new->root_type = set->root_type;
Michal Vasko6b26e742020-07-17 15:02:10 +0200783 new->context_op = set->context_op;
Michal Vaskof03ed032020-03-04 13:31:44 +0100784 new->tree = set->tree;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200785 new->cur_mod = set->cur_mod;
Michal Vasko02a77382019-09-12 11:47:35 +0200786 new->format = set->format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200787 new->prefix_data = set->prefix_data;
aPiecekfba75362021-10-07 12:39:48 +0200788 new->vars = set->vars;
Michal Vasko02a77382019-09-12 11:47:35 +0200789 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200790}
791
792/**
793 * @brief Create a deep copy of a set.
794 *
795 * @param[in] set Set to copy.
796 * @return Copy of @p set.
797 */
798static struct lyxp_set *
799set_copy(struct lyxp_set *set)
800{
801 struct lyxp_set *ret;
Michal Vasko1fdd8fa2021-01-08 09:21:45 +0100802 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200803
804 if (!set) {
805 return NULL;
806 }
807
808 ret = malloc(sizeof *ret);
809 LY_CHECK_ERR_RET(!ret, LOGMEM(set->ctx), NULL);
810 set_init(ret, set);
811
812 if (set->type == LYXP_SET_SCNODE_SET) {
813 ret->type = set->type;
814
815 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100816 if ((set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) ||
817 (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_START)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +0200818 uint32_t idx;
819 LY_CHECK_ERR_RET(lyxp_set_scnode_insert_node(ret, set->val.scnodes[i].scnode, set->val.scnodes[i].type, &idx),
820 lyxp_set_free(ret), NULL);
Michal Vasko3f27c522020-01-06 08:37:49 +0100821 /* coverity seems to think scnodes can be NULL */
Radek Krejciaa6b53f2020-08-27 15:19:03 +0200822 if (!ret->val.scnodes) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200823 lyxp_set_free(ret);
824 return NULL;
825 }
Michal Vaskoba716542019-12-16 10:01:58 +0100826 ret->val.scnodes[idx].in_ctx = set->val.scnodes[i].in_ctx;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200827 }
828 }
829 } else if (set->type == LYXP_SET_NODE_SET) {
830 ret->type = set->type;
Michal Vasko08e9b112021-06-11 15:41:17 +0200831 if (set->used) {
832 ret->val.nodes = malloc(set->used * sizeof *ret->val.nodes);
833 LY_CHECK_ERR_RET(!ret->val.nodes, LOGMEM(set->ctx); free(ret), NULL);
834 memcpy(ret->val.nodes, set->val.nodes, set->used * sizeof *ret->val.nodes);
835 } else {
836 ret->val.nodes = NULL;
837 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200838
839 ret->used = ret->size = set->used;
840 ret->ctx_pos = set->ctx_pos;
841 ret->ctx_size = set->ctx_size;
Michal Vasko4a04e542021-02-01 08:58:30 +0100842 if (set->ht) {
843 ret->ht = lyht_dup(set->ht);
844 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200845 } else {
Radek Krejci0f969882020-08-21 16:56:47 +0200846 memcpy(ret, set, sizeof *ret);
847 if (set->type == LYXP_SET_STRING) {
848 ret->val.str = strdup(set->val.str);
849 LY_CHECK_ERR_RET(!ret->val.str, LOGMEM(set->ctx); free(ret), NULL);
850 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200851 }
852
853 return ret;
854}
855
856/**
857 * @brief Fill XPath set with a string. Any current data are disposed of.
858 *
859 * @param[in] set Set to fill.
860 * @param[in] string String to fill into \p set.
861 * @param[in] str_len Length of \p string. 0 is a valid value!
862 */
863static void
864set_fill_string(struct lyxp_set *set, const char *string, uint16_t str_len)
865{
Michal Vaskod3678892020-05-21 10:06:58 +0200866 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200867
868 set->type = LYXP_SET_STRING;
869 if ((str_len == 0) && (string[0] != '\0')) {
870 string = "";
871 }
872 set->val.str = strndup(string, str_len);
873}
874
875/**
876 * @brief Fill XPath set with a number. Any current data are disposed of.
877 *
878 * @param[in] set Set to fill.
879 * @param[in] number Number to fill into \p set.
880 */
881static void
882set_fill_number(struct lyxp_set *set, long double number)
883{
Michal Vaskod3678892020-05-21 10:06:58 +0200884 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200885
886 set->type = LYXP_SET_NUMBER;
887 set->val.num = number;
888}
889
890/**
891 * @brief Fill XPath set with a boolean. Any current data are disposed of.
892 *
893 * @param[in] set Set to fill.
894 * @param[in] boolean Boolean to fill into \p set.
895 */
896static void
Radek Krejci857189e2020-09-01 13:26:36 +0200897set_fill_boolean(struct lyxp_set *set, ly_bool boolean)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200898{
Michal Vaskod3678892020-05-21 10:06:58 +0200899 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200900
901 set->type = LYXP_SET_BOOLEAN;
Michal Vasko004d3152020-06-11 19:59:22 +0200902 set->val.bln = boolean;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200903}
904
905/**
906 * @brief Fill XPath set with the value from another set (deep assign).
907 * Any current data are disposed of.
908 *
909 * @param[in] trg Set to fill.
910 * @param[in] src Source set to copy into \p trg.
911 */
912static void
Michal Vasko4c7763f2020-07-27 17:40:37 +0200913set_fill_set(struct lyxp_set *trg, const struct lyxp_set *src)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200914{
915 if (!trg || !src) {
916 return;
917 }
918
919 if (trg->type == LYXP_SET_NODE_SET) {
920 free(trg->val.nodes);
921 } else if (trg->type == LYXP_SET_STRING) {
922 free(trg->val.str);
923 }
924 set_init(trg, src);
925
926 if (src->type == LYXP_SET_SCNODE_SET) {
927 trg->type = LYXP_SET_SCNODE_SET;
928 trg->used = src->used;
929 trg->size = src->used;
930
Michal Vasko08e9b112021-06-11 15:41:17 +0200931 if (trg->size) {
932 trg->val.scnodes = ly_realloc(trg->val.scnodes, trg->size * sizeof *trg->val.scnodes);
933 LY_CHECK_ERR_RET(!trg->val.scnodes, LOGMEM(src->ctx); memset(trg, 0, sizeof *trg), );
934 memcpy(trg->val.scnodes, src->val.scnodes, src->used * sizeof *src->val.scnodes);
935 } else {
936 trg->val.scnodes = NULL;
937 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200938 } else if (src->type == LYXP_SET_BOOLEAN) {
Michal Vasko004d3152020-06-11 19:59:22 +0200939 set_fill_boolean(trg, src->val.bln);
Michal Vasko44f3d2c2020-08-24 09:49:38 +0200940 } else if (src->type == LYXP_SET_NUMBER) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200941 set_fill_number(trg, src->val.num);
942 } else if (src->type == LYXP_SET_STRING) {
943 set_fill_string(trg, src->val.str, strlen(src->val.str));
944 } else {
945 if (trg->type == LYXP_SET_NODE_SET) {
946 free(trg->val.nodes);
947 } else if (trg->type == LYXP_SET_STRING) {
948 free(trg->val.str);
949 }
950
Michal Vaskod3678892020-05-21 10:06:58 +0200951 assert(src->type == LYXP_SET_NODE_SET);
952
953 trg->type = LYXP_SET_NODE_SET;
954 trg->used = src->used;
955 trg->size = src->used;
956 trg->ctx_pos = src->ctx_pos;
957 trg->ctx_size = src->ctx_size;
958
Michal Vasko08e9b112021-06-11 15:41:17 +0200959 if (trg->size) {
960 trg->val.nodes = malloc(trg->size * sizeof *trg->val.nodes);
961 LY_CHECK_ERR_RET(!trg->val.nodes, LOGMEM(src->ctx); memset(trg, 0, sizeof *trg), );
962 memcpy(trg->val.nodes, src->val.nodes, src->used * sizeof *src->val.nodes);
963 } else {
964 trg->val.nodes = NULL;
965 }
Michal Vaskod3678892020-05-21 10:06:58 +0200966 if (src->ht) {
967 trg->ht = lyht_dup(src->ht);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200968 } else {
Michal Vaskod3678892020-05-21 10:06:58 +0200969 trg->ht = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200970 }
971 }
972}
973
974/**
975 * @brief Clear context of all schema nodes.
976 *
977 * @param[in] set Set to clear.
Michal Vasko1a09b212021-05-06 13:00:10 +0200978 * @param[in] new_ctx New context state for all the nodes currently in the context.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200979 */
980static void
Michal Vasko1a09b212021-05-06 13:00:10 +0200981set_scnode_clear_ctx(struct lyxp_set *set, int32_t new_ctx)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200982{
983 uint32_t i;
984
985 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100986 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko1a09b212021-05-06 13:00:10 +0200987 set->val.scnodes[i].in_ctx = new_ctx;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100988 } else if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_START) {
989 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200990 }
991 }
992}
993
994/**
995 * @brief Remove a node from a set. Removing last node changes
996 * set into LYXP_SET_EMPTY. Context position aware.
997 *
998 * @param[in] set Set to use.
999 * @param[in] idx Index from @p set of the node to be removed.
1000 */
1001static void
1002set_remove_node(struct lyxp_set *set, uint32_t idx)
1003{
1004 assert(set && (set->type == LYXP_SET_NODE_SET));
1005 assert(idx < set->used);
1006
1007 set_remove_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
1008
1009 --set->used;
Michal Vasko08e9b112021-06-11 15:41:17 +02001010 if (idx < set->used) {
1011 memmove(&set->val.nodes[idx], &set->val.nodes[idx + 1], (set->used - idx) * sizeof *set->val.nodes);
1012 } else if (!set->used) {
Michal Vaskod3678892020-05-21 10:06:58 +02001013 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001014 }
1015}
1016
1017/**
Michal Vasko2caefc12019-11-14 16:07:56 +01001018 * @brief Remove a node from a set by setting its type to LYXP_NODE_NONE.
Michal Vasko57eab132019-09-24 11:46:26 +02001019 *
1020 * @param[in] set Set to use.
1021 * @param[in] idx Index from @p set of the node to be removed.
1022 */
1023static void
Michal Vasko2caefc12019-11-14 16:07:56 +01001024set_remove_node_none(struct lyxp_set *set, uint32_t idx)
Michal Vasko57eab132019-09-24 11:46:26 +02001025{
1026 assert(set && (set->type == LYXP_SET_NODE_SET));
1027 assert(idx < set->used);
1028
Michal Vasko2caefc12019-11-14 16:07:56 +01001029 if (set->val.nodes[idx].type == LYXP_NODE_ELEM) {
1030 set_remove_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
1031 }
1032 set->val.nodes[idx].type = LYXP_NODE_NONE;
Michal Vasko57eab132019-09-24 11:46:26 +02001033}
1034
1035/**
Michal Vasko2caefc12019-11-14 16:07:56 +01001036 * @brief Remove all LYXP_NODE_NONE nodes from a set. Removing last node changes
Michal Vasko57eab132019-09-24 11:46:26 +02001037 * set into LYXP_SET_EMPTY. Context position aware.
1038 *
1039 * @param[in] set Set to consolidate.
1040 */
1041static void
Michal Vasko2caefc12019-11-14 16:07:56 +01001042set_remove_nodes_none(struct lyxp_set *set)
Michal Vasko57eab132019-09-24 11:46:26 +02001043{
Michal Vasko1fdd8fa2021-01-08 09:21:45 +01001044 uint32_t i, orig_used, end = 0;
1045 int64_t start;
Michal Vasko57eab132019-09-24 11:46:26 +02001046
Michal Vaskod3678892020-05-21 10:06:58 +02001047 assert(set);
Michal Vasko57eab132019-09-24 11:46:26 +02001048
1049 orig_used = set->used;
1050 set->used = 0;
Michal Vaskod989ba02020-08-24 10:59:24 +02001051 for (i = 0; i < orig_used; ) {
Michal Vasko57eab132019-09-24 11:46:26 +02001052 start = -1;
1053 do {
Michal Vasko2caefc12019-11-14 16:07:56 +01001054 if ((set->val.nodes[i].type != LYXP_NODE_NONE) && (start == -1)) {
Michal Vasko57eab132019-09-24 11:46:26 +02001055 start = i;
Michal Vasko2caefc12019-11-14 16:07:56 +01001056 } else if ((start > -1) && (set->val.nodes[i].type == LYXP_NODE_NONE)) {
Michal Vasko57eab132019-09-24 11:46:26 +02001057 end = i;
1058 ++i;
1059 break;
1060 }
1061
1062 ++i;
1063 if (i == orig_used) {
1064 end = i;
1065 }
1066 } while (i < orig_used);
1067
1068 if (start > -1) {
1069 /* move the whole chunk of valid nodes together */
1070 if (set->used != (unsigned)start) {
1071 memmove(&set->val.nodes[set->used], &set->val.nodes[start], (end - start) * sizeof *set->val.nodes);
1072 }
1073 set->used += end - start;
1074 }
1075 }
Michal Vasko57eab132019-09-24 11:46:26 +02001076}
1077
1078/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02001079 * @brief Check for duplicates in a node set.
1080 *
1081 * @param[in] set Set to check.
1082 * @param[in] node Node to look for in @p set.
1083 * @param[in] node_type Type of @p node.
1084 * @param[in] skip_idx Index from @p set to skip.
1085 * @return LY_ERR
1086 */
1087static LY_ERR
1088set_dup_node_check(const struct lyxp_set *set, const struct lyd_node *node, enum lyxp_node_type node_type, int skip_idx)
1089{
1090 uint32_t i;
1091
Michal Vasko2caefc12019-11-14 16:07:56 +01001092 if (set->ht && node) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001093 return set_dup_node_hash_check(set, (struct lyd_node *)node, node_type, skip_idx);
1094 }
1095
1096 for (i = 0; i < set->used; ++i) {
1097 if ((skip_idx > -1) && (i == (unsigned)skip_idx)) {
1098 continue;
1099 }
1100
1101 if ((set->val.nodes[i].node == node) && (set->val.nodes[i].type == node_type)) {
1102 return LY_EEXIST;
1103 }
1104 }
1105
1106 return LY_SUCCESS;
1107}
1108
Radek Krejci857189e2020-09-01 13:26:36 +02001109ly_bool
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001110lyxp_set_scnode_contains(struct lyxp_set *set, const struct lysc_node *node, enum lyxp_node_type node_type, int skip_idx,
1111 uint32_t *index_p)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001112{
1113 uint32_t i;
1114
1115 for (i = 0; i < set->used; ++i) {
1116 if ((skip_idx > -1) && (i == (unsigned)skip_idx)) {
1117 continue;
1118 }
1119
1120 if ((set->val.scnodes[i].scnode == node) && (set->val.scnodes[i].type == node_type)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001121 if (index_p) {
1122 *index_p = i;
1123 }
1124 return 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001125 }
1126 }
1127
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001128 return 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001129}
1130
Michal Vaskoecd62de2019-11-13 12:35:11 +01001131void
1132lyxp_set_scnode_merge(struct lyxp_set *set1, struct lyxp_set *set2)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001133{
1134 uint32_t orig_used, i, j;
1135
Michal Vaskod3678892020-05-21 10:06:58 +02001136 assert((set1->type == LYXP_SET_SCNODE_SET) && (set2->type == LYXP_SET_SCNODE_SET));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001137
Michal Vaskod3678892020-05-21 10:06:58 +02001138 if (!set2->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001139 return;
1140 }
1141
Michal Vaskod3678892020-05-21 10:06:58 +02001142 if (!set1->used) {
aPiecekadc1e4f2021-10-07 11:15:12 +02001143 /* release hidden allocated data (lyxp_set.size) */
1144 lyxp_set_free_content(set1);
1145 /* direct copying of the entire structure */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001146 memcpy(set1, set2, sizeof *set1);
1147 return;
1148 }
1149
1150 if (set1->used + set2->used > set1->size) {
1151 set1->size = set1->used + set2->used;
1152 set1->val.scnodes = ly_realloc(set1->val.scnodes, set1->size * sizeof *set1->val.scnodes);
1153 LY_CHECK_ERR_RET(!set1->val.scnodes, LOGMEM(set1->ctx), );
1154 }
1155
1156 orig_used = set1->used;
1157
1158 for (i = 0; i < set2->used; ++i) {
1159 for (j = 0; j < orig_used; ++j) {
1160 /* detect duplicities */
1161 if (set1->val.scnodes[j].scnode == set2->val.scnodes[i].scnode) {
1162 break;
1163 }
1164 }
1165
Michal Vasko0587bce2020-12-10 12:19:21 +01001166 if (j < orig_used) {
1167 /* node is there, but update its status if needed */
1168 if (set1->val.scnodes[j].in_ctx == LYXP_SET_SCNODE_START_USED) {
1169 set1->val.scnodes[j].in_ctx = set2->val.scnodes[i].in_ctx;
Michal Vasko1a09b212021-05-06 13:00:10 +02001170 } else if ((set1->val.scnodes[j].in_ctx == LYXP_SET_SCNODE_ATOM_NODE) &&
1171 (set2->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL)) {
1172 set1->val.scnodes[j].in_ctx = set2->val.scnodes[i].in_ctx;
Michal Vasko0587bce2020-12-10 12:19:21 +01001173 }
1174 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001175 memcpy(&set1->val.scnodes[set1->used], &set2->val.scnodes[i], sizeof *set2->val.scnodes);
1176 ++set1->used;
1177 }
1178 }
1179
Michal Vaskod3678892020-05-21 10:06:58 +02001180 lyxp_set_free_content(set2);
1181 set2->type = LYXP_SET_SCNODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001182}
1183
1184/**
1185 * @brief Insert a node into a set. Context position aware.
1186 *
1187 * @param[in] set Set to use.
1188 * @param[in] node Node to insert to @p set.
1189 * @param[in] pos Sort position of @p node. If left 0, it is filled just before sorting.
1190 * @param[in] node_type Node type of @p node.
1191 * @param[in] idx Index in @p set to insert into.
1192 */
1193static void
1194set_insert_node(struct lyxp_set *set, const struct lyd_node *node, uint32_t pos, enum lyxp_node_type node_type, uint32_t idx)
1195{
Michal Vaskod3678892020-05-21 10:06:58 +02001196 assert(set && (set->type == LYXP_SET_NODE_SET));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001197
Michal Vaskod3678892020-05-21 10:06:58 +02001198 if (!set->size) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001199 /* first item */
1200 if (idx) {
1201 /* no real harm done, but it is a bug */
1202 LOGINT(set->ctx);
1203 idx = 0;
1204 }
1205 set->val.nodes = malloc(LYXP_SET_SIZE_START * sizeof *set->val.nodes);
1206 LY_CHECK_ERR_RET(!set->val.nodes, LOGMEM(set->ctx), );
1207 set->type = LYXP_SET_NODE_SET;
1208 set->used = 0;
1209 set->size = LYXP_SET_SIZE_START;
1210 set->ctx_pos = 1;
1211 set->ctx_size = 1;
1212 set->ht = NULL;
1213 } else {
1214 /* not an empty set */
1215 if (set->used == set->size) {
1216
1217 /* set is full */
1218 set->val.nodes = ly_realloc(set->val.nodes, (set->size + LYXP_SET_SIZE_STEP) * sizeof *set->val.nodes);
1219 LY_CHECK_ERR_RET(!set->val.nodes, LOGMEM(set->ctx), );
1220 set->size += LYXP_SET_SIZE_STEP;
1221 }
1222
1223 if (idx > set->used) {
1224 LOGINT(set->ctx);
1225 idx = set->used;
1226 }
1227
1228 /* make space for the new node */
1229 if (idx < set->used) {
1230 memmove(&set->val.nodes[idx + 1], &set->val.nodes[idx], (set->used - idx) * sizeof *set->val.nodes);
1231 }
1232 }
1233
1234 /* finally assign the value */
1235 set->val.nodes[idx].node = (struct lyd_node *)node;
1236 set->val.nodes[idx].type = node_type;
1237 set->val.nodes[idx].pos = pos;
1238 ++set->used;
1239
Michal Vasko2416fdd2021-10-01 11:07:10 +02001240 /* add into hash table */
1241 set_insert_node_hash(set, (struct lyd_node *)node, node_type);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001242}
1243
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001244LY_ERR
1245lyxp_set_scnode_insert_node(struct lyxp_set *set, const struct lysc_node *node, enum lyxp_node_type node_type, uint32_t *index_p)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001246{
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001247 uint32_t index;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001248
1249 assert(set->type == LYXP_SET_SCNODE_SET);
1250
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001251 if (lyxp_set_scnode_contains(set, node, node_type, -1, &index)) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01001252 set->val.scnodes[index].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001253 } else {
1254 if (set->used == set->size) {
1255 set->val.scnodes = ly_realloc(set->val.scnodes, (set->size + LYXP_SET_SIZE_STEP) * sizeof *set->val.scnodes);
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001256 LY_CHECK_ERR_RET(!set->val.scnodes, LOGMEM(set->ctx), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001257 set->size += LYXP_SET_SIZE_STEP;
1258 }
1259
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001260 index = set->used;
1261 set->val.scnodes[index].scnode = (struct lysc_node *)node;
1262 set->val.scnodes[index].type = node_type;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001263 set->val.scnodes[index].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001264 ++set->used;
1265 }
1266
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001267 if (index_p) {
1268 *index_p = index;
1269 }
1270
1271 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001272}
1273
1274/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02001275 * @brief Set all nodes with ctx 1 to a new unique context value.
1276 *
1277 * @param[in] set Set to modify.
1278 * @return New context value.
1279 */
Michal Vasko5c4e5892019-11-14 12:31:38 +01001280static int32_t
Michal Vasko03ff5a72019-09-11 13:49:33 +02001281set_scnode_new_in_ctx(struct lyxp_set *set)
1282{
Michal Vasko5c4e5892019-11-14 12:31:38 +01001283 uint32_t i;
1284 int32_t ret_ctx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001285
1286 assert(set->type == LYXP_SET_SCNODE_SET);
1287
Radek Krejcif13b87b2020-12-01 22:02:17 +01001288 ret_ctx = LYXP_SET_SCNODE_ATOM_PRED_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001289retry:
1290 for (i = 0; i < set->used; ++i) {
1291 if (set->val.scnodes[i].in_ctx >= ret_ctx) {
1292 ret_ctx = set->val.scnodes[i].in_ctx + 1;
1293 goto retry;
1294 }
1295 }
1296 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01001297 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001298 set->val.scnodes[i].in_ctx = ret_ctx;
1299 }
1300 }
1301
1302 return ret_ctx;
1303}
1304
1305/**
1306 * @brief Get unique @p node position in the data.
1307 *
1308 * @param[in] node Node to find.
1309 * @param[in] node_type Node type of @p node.
1310 * @param[in] root Root node.
1311 * @param[in] root_type Type of the XPath @p root node.
1312 * @param[in] prev Node that we think is before @p node in DFS from @p root. Can optionally
1313 * be used to increase efficiency and start the DFS from this node.
1314 * @param[in] prev_pos Node @p prev position. Optional, but must be set if @p prev is set.
1315 * @return Node position.
1316 */
1317static uint32_t
1318get_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 +02001319 enum lyxp_node_type root_type, const struct lyd_node **prev, uint32_t *prev_pos)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001320{
Michal Vasko56daf732020-08-10 10:57:18 +02001321 const struct lyd_node *elem = NULL, *top_sibling;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001322 uint32_t pos = 1;
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001323 ly_bool found = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001324
1325 assert(prev && prev_pos && !root->prev->next);
1326
1327 if ((node_type == LYXP_NODE_ROOT) || (node_type == LYXP_NODE_ROOT_CONFIG)) {
1328 return 0;
1329 }
1330
1331 if (*prev) {
1332 /* start from the previous element instead from the root */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001333 pos = *prev_pos;
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001334 for (top_sibling = *prev; top_sibling->parent; top_sibling = lyd_parent(top_sibling)) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001335 goto dfs_search;
1336 }
1337
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001338 LY_LIST_FOR(root, top_sibling) {
Michal Vasko56daf732020-08-10 10:57:18 +02001339 LYD_TREE_DFS_BEGIN(top_sibling, elem) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001340dfs_search:
Michal Vaskoa9309bb2021-07-09 09:31:55 +02001341 LYD_TREE_DFS_continue = 0;
1342
Michal Vasko56daf732020-08-10 10:57:18 +02001343 if (*prev && !elem) {
1344 /* resume previous DFS */
1345 elem = LYD_TREE_DFS_next = (struct lyd_node *)*prev;
1346 LYD_TREE_DFS_continue = 0;
1347 }
1348
Michal Vasko03ff5a72019-09-11 13:49:33 +02001349 if ((root_type == LYXP_NODE_ROOT_CONFIG) && (elem->schema->flags & LYS_CONFIG_R)) {
Michal Vasko56daf732020-08-10 10:57:18 +02001350 /* skip */
1351 LYD_TREE_DFS_continue = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001352 } else {
Michal Vasko56daf732020-08-10 10:57:18 +02001353 if (elem == node) {
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001354 found = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001355 break;
1356 }
Michal Vasko56daf732020-08-10 10:57:18 +02001357 ++pos;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001358 }
Michal Vasko56daf732020-08-10 10:57:18 +02001359
1360 LYD_TREE_DFS_END(top_sibling, elem);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001361 }
1362
1363 /* node found */
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001364 if (found) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001365 break;
1366 }
1367 }
1368
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001369 if (!found) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001370 if (!(*prev)) {
1371 /* we went from root and failed to find it, cannot be */
Michal Vaskob7be7a82020-08-20 09:09:04 +02001372 LOGINT(LYD_CTX(node));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001373 return 0;
1374 } else {
Michal Vasko56daf732020-08-10 10:57:18 +02001375 /* start the search again from the beginning */
1376 *prev = root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001377
Michal Vasko56daf732020-08-10 10:57:18 +02001378 top_sibling = root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001379 pos = 1;
1380 goto dfs_search;
1381 }
1382 }
1383
1384 /* remember the last found node for next time */
1385 *prev = node;
1386 *prev_pos = pos;
1387
1388 return pos;
1389}
1390
1391/**
1392 * @brief Assign (fill) missing node positions.
1393 *
1394 * @param[in] set Set to fill positions in.
1395 * @param[in] root Context root node.
1396 * @param[in] root_type Context root type.
1397 * @return LY_ERR
1398 */
1399static LY_ERR
1400set_assign_pos(struct lyxp_set *set, const struct lyd_node *root, enum lyxp_node_type root_type)
1401{
1402 const struct lyd_node *prev = NULL, *tmp_node;
1403 uint32_t i, tmp_pos = 0;
1404
1405 for (i = 0; i < set->used; ++i) {
1406 if (!set->val.nodes[i].pos) {
1407 tmp_node = NULL;
1408 switch (set->val.nodes[i].type) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001409 case LYXP_NODE_META:
1410 tmp_node = set->val.meta[i].meta->parent;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001411 if (!tmp_node) {
1412 LOGINT_RET(root->schema->module->ctx);
1413 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01001414 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001415 case LYXP_NODE_ELEM:
1416 case LYXP_NODE_TEXT:
1417 if (!tmp_node) {
1418 tmp_node = set->val.nodes[i].node;
1419 }
1420 set->val.nodes[i].pos = get_node_pos(tmp_node, set->val.nodes[i].type, root, root_type, &prev, &tmp_pos);
1421 break;
1422 default:
1423 /* all roots have position 0 */
1424 break;
1425 }
1426 }
1427 }
1428
1429 return LY_SUCCESS;
1430}
1431
1432/**
Michal Vasko9f96a052020-03-10 09:41:45 +01001433 * @brief Get unique @p meta position in the parent metadata.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001434 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001435 * @param[in] meta Metadata to use.
1436 * @return Metadata position.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001437 */
1438static uint16_t
Michal Vasko9f96a052020-03-10 09:41:45 +01001439get_meta_pos(struct lyd_meta *meta)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001440{
1441 uint16_t pos = 0;
Michal Vasko9f96a052020-03-10 09:41:45 +01001442 struct lyd_meta *meta2;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001443
Michal Vasko9f96a052020-03-10 09:41:45 +01001444 for (meta2 = meta->parent->meta; meta2 && (meta2 != meta); meta2 = meta2->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001445 ++pos;
1446 }
1447
Michal Vasko9f96a052020-03-10 09:41:45 +01001448 assert(meta2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001449 return pos;
1450}
1451
1452/**
1453 * @brief Compare 2 nodes in respect to XPath document order.
1454 *
1455 * @param[in] item1 1st node.
1456 * @param[in] item2 2nd node.
1457 * @return If 1st > 2nd returns 1, 1st == 2nd returns 0, and 1st < 2nd returns -1.
1458 */
1459static int
1460set_sort_compare(struct lyxp_set_node *item1, struct lyxp_set_node *item2)
1461{
Michal Vasko9f96a052020-03-10 09:41:45 +01001462 uint32_t meta_pos1 = 0, meta_pos2 = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001463
1464 if (item1->pos < item2->pos) {
1465 return -1;
1466 }
1467
1468 if (item1->pos > item2->pos) {
1469 return 1;
1470 }
1471
1472 /* node positions are equal, the fun case */
1473
1474 /* 1st ELEM - == - 2nd TEXT, 1st TEXT - == - 2nd ELEM */
1475 /* special case since text nodes are actually saved as their parents */
1476 if ((item1->node == item2->node) && (item1->type != item2->type)) {
1477 if (item1->type == LYXP_NODE_ELEM) {
1478 assert(item2->type == LYXP_NODE_TEXT);
1479 return -1;
1480 } else {
1481 assert((item1->type == LYXP_NODE_TEXT) && (item2->type == LYXP_NODE_ELEM));
1482 return 1;
1483 }
1484 }
1485
Michal Vasko9f96a052020-03-10 09:41:45 +01001486 /* we need meta positions now */
1487 if (item1->type == LYXP_NODE_META) {
1488 meta_pos1 = get_meta_pos((struct lyd_meta *)item1->node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001489 }
Michal Vasko9f96a052020-03-10 09:41:45 +01001490 if (item2->type == LYXP_NODE_META) {
1491 meta_pos2 = get_meta_pos((struct lyd_meta *)item2->node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001492 }
1493
Michal Vasko9f96a052020-03-10 09:41:45 +01001494 /* 1st ROOT - 2nd ROOT, 1st ELEM - 2nd ELEM, 1st TEXT - 2nd TEXT, 1st META - =pos= - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001495 /* check for duplicates */
1496 if (item1->node == item2->node) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001497 assert((item1->type == item2->type) && ((item1->type != LYXP_NODE_META) || (meta_pos1 == meta_pos2)));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001498 return 0;
1499 }
1500
Michal Vasko9f96a052020-03-10 09:41:45 +01001501 /* 1st ELEM - 2nd TEXT, 1st ELEM - any pos - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001502 /* elem is always first, 2nd node is after it */
1503 if (item1->type == LYXP_NODE_ELEM) {
1504 assert(item2->type != LYXP_NODE_ELEM);
1505 return -1;
1506 }
1507
Michal Vasko9f96a052020-03-10 09:41:45 +01001508 /* 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 +02001509 /* 2nd is before 1st */
Michal Vasko69730152020-10-09 16:30:07 +02001510 if (((item1->type == LYXP_NODE_TEXT) &&
1511 ((item2->type == LYXP_NODE_ELEM) || (item2->type == LYXP_NODE_META))) ||
1512 ((item1->type == LYXP_NODE_META) && (item2->type == LYXP_NODE_ELEM)) ||
1513 (((item1->type == LYXP_NODE_META) && (item2->type == LYXP_NODE_META)) &&
1514 (meta_pos1 > meta_pos2))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001515 return 1;
1516 }
1517
Michal Vasko9f96a052020-03-10 09:41:45 +01001518 /* 1st META - any pos - 2nd TEXT, 1st META <pos< - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001519 /* 2nd is after 1st */
1520 return -1;
1521}
1522
1523/**
1524 * @brief Set cast for comparisons.
1525 *
1526 * @param[in] trg Target set to cast source into.
1527 * @param[in] src Source set.
1528 * @param[in] type Target set type.
1529 * @param[in] src_idx Source set node index.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001530 * @return LY_ERR
1531 */
1532static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001533set_comp_cast(struct lyxp_set *trg, struct lyxp_set *src, enum lyxp_set_type type, uint32_t src_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001534{
1535 assert(src->type == LYXP_SET_NODE_SET);
1536
1537 set_init(trg, src);
1538
1539 /* insert node into target set */
1540 set_insert_node(trg, src->val.nodes[src_idx].node, src->val.nodes[src_idx].pos, src->val.nodes[src_idx].type, 0);
1541
1542 /* cast target set appropriately */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001543 return lyxp_set_cast(trg, type);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001544}
1545
Michal Vasko4c7763f2020-07-27 17:40:37 +02001546/**
1547 * @brief Set content canonization for comparisons.
1548 *
1549 * @param[in] trg Target set to put the canononized source into.
1550 * @param[in] src Source set.
1551 * @param[in] xp_node Source XPath node/meta to use for canonization.
1552 * @return LY_ERR
1553 */
1554static LY_ERR
1555set_comp_canonize(struct lyxp_set *trg, const struct lyxp_set *src, const struct lyxp_set_node *xp_node)
1556{
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001557 const struct lysc_type *type = NULL;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001558 struct lyd_value val;
1559 struct ly_err_item *err = NULL;
1560 char *str, *ptr;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001561 LY_ERR rc;
1562
1563 /* is there anything to canonize even? */
1564 if ((src->type == LYXP_SET_NUMBER) || (src->type == LYXP_SET_STRING)) {
1565 /* do we have a type to use for canonization? */
1566 if ((xp_node->type == LYXP_NODE_ELEM) && (xp_node->node->schema->nodetype & LYD_NODE_TERM)) {
1567 type = ((struct lyd_node_term *)xp_node->node)->value.realtype;
1568 } else if (xp_node->type == LYXP_NODE_META) {
1569 type = ((struct lyd_meta *)xp_node->node)->value.realtype;
1570 }
1571 }
1572 if (!type) {
1573 goto fill;
1574 }
1575
1576 if (src->type == LYXP_SET_NUMBER) {
1577 /* canonize number */
1578 if (asprintf(&str, "%Lf", src->val.num) == -1) {
1579 LOGMEM(src->ctx);
1580 return LY_EMEM;
1581 }
1582 } else {
1583 /* canonize string */
1584 str = strdup(src->val.str);
1585 }
1586
1587 /* ignore errors, the value may not satisfy schema constraints */
Radek Krejci0b013302021-03-29 15:22:32 +02001588 rc = type->plugin->store(src->ctx, type, str, strlen(str), LYPLG_TYPE_STORE_DYNAMIC, src->format, src->prefix_data,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001589 LYD_HINT_DATA, xp_node->node->schema, &val, NULL, &err);
Michal Vasko4c7763f2020-07-27 17:40:37 +02001590 ly_err_free(err);
1591 if (rc) {
1592 /* invalid value */
Radek IÅ¡a48460222021-03-02 15:18:32 +01001593 /* function store automaticaly dealloc value when fail */
Michal Vasko4c7763f2020-07-27 17:40:37 +02001594 goto fill;
1595 }
1596
Michal Vasko4c7763f2020-07-27 17:40:37 +02001597 /* use the canonized value */
1598 set_init(trg, src);
1599 trg->type = src->type;
1600 if (src->type == LYXP_SET_NUMBER) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001601 trg->val.num = strtold(type->plugin->print(src->ctx, &val, LY_VALUE_CANON, NULL, NULL, NULL), &ptr);
Michal Vasko4c7763f2020-07-27 17:40:37 +02001602 LY_CHECK_ERR_RET(ptr[0], LOGINT(src->ctx), LY_EINT);
1603 } else {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001604 trg->val.str = strdup(type->plugin->print(src->ctx, &val, LY_VALUE_CANON, NULL, NULL, NULL));
Michal Vasko4c7763f2020-07-27 17:40:37 +02001605 }
1606 type->plugin->free(src->ctx, &val);
1607 return LY_SUCCESS;
1608
1609fill:
1610 /* no canonization needed/possible */
1611 set_fill_set(trg, src);
1612 return LY_SUCCESS;
1613}
1614
Michal Vasko03ff5a72019-09-11 13:49:33 +02001615#ifndef NDEBUG
1616
1617/**
1618 * @brief Bubble sort @p set into XPath document order.
1619 * Context position aware. Unused in the 'Release' build target.
1620 *
1621 * @param[in] set Set to sort.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001622 * @return How many times the whole set was traversed - 1 (if set was sorted, returns 0).
1623 */
1624static int
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001625set_sort(struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001626{
1627 uint32_t i, j;
Radek Krejci1deb5be2020-08-26 16:43:36 +02001628 int ret = 0, cmp;
Radek Krejci857189e2020-09-01 13:26:36 +02001629 ly_bool inverted, change;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001630 const struct lyd_node *root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001631 struct lyxp_set_node item;
1632 struct lyxp_set_hash_node hnode;
1633 uint64_t hash;
1634
Michal Vasko3cf8fbf2020-05-27 15:21:21 +02001635 if ((set->type != LYXP_SET_NODE_SET) || (set->used < 2)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001636 return 0;
1637 }
1638
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001639 /* find first top-level node to be used as anchor for positions */
Michal Vasko0245d502021-12-13 17:05:06 +01001640 for (root = set->tree; root->parent; root = lyd_parent(root)) {}
Michal Vaskod989ba02020-08-24 10:59:24 +02001641 for ( ; root->prev->next; root = root->prev) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001642
1643 /* fill positions */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001644 if (set_assign_pos(set, root, set->root_type)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001645 return -1;
1646 }
1647
1648 LOGDBG(LY_LDGXPATH, "SORT BEGIN");
1649 print_set_debug(set);
1650
1651 for (i = 0; i < set->used; ++i) {
1652 inverted = 0;
1653 change = 0;
1654
1655 for (j = 1; j < set->used - i; ++j) {
1656 /* compare node positions */
1657 if (inverted) {
1658 cmp = set_sort_compare(&set->val.nodes[j], &set->val.nodes[j - 1]);
1659 } else {
1660 cmp = set_sort_compare(&set->val.nodes[j - 1], &set->val.nodes[j]);
1661 }
1662
1663 /* swap if needed */
1664 if ((inverted && (cmp < 0)) || (!inverted && (cmp > 0))) {
1665 change = 1;
1666
1667 item = set->val.nodes[j - 1];
1668 set->val.nodes[j - 1] = set->val.nodes[j];
1669 set->val.nodes[j] = item;
1670 } else {
1671 /* whether node_pos1 should be smaller than node_pos2 or the other way around */
1672 inverted = !inverted;
1673 }
1674 }
1675
1676 ++ret;
1677
1678 if (!change) {
1679 break;
1680 }
1681 }
1682
1683 LOGDBG(LY_LDGXPATH, "SORT END %d", ret);
1684 print_set_debug(set);
1685
1686 /* check node hashes */
1687 if (set->used >= LYD_HT_MIN_ITEMS) {
1688 assert(set->ht);
1689 for (i = 0; i < set->used; ++i) {
1690 hnode.node = set->val.nodes[i].node;
1691 hnode.type = set->val.nodes[i].type;
1692
1693 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
1694 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
1695 hash = dict_hash_multi(hash, NULL, 0);
1696
1697 assert(!lyht_find(set->ht, &hnode, hash, NULL));
1698 }
1699 }
1700
1701 return ret - 1;
1702}
1703
Michal Vasko03ff5a72019-09-11 13:49:33 +02001704#endif
1705
1706/**
1707 * @brief Merge 2 sorted sets into one.
1708 *
1709 * @param[in,out] trg Set to merge into. Duplicates are removed.
1710 * @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 +02001711 * @return LY_ERR
1712 */
1713static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001714set_sorted_merge(struct lyxp_set *trg, struct lyxp_set *src)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001715{
1716 uint32_t i, j, k, count, dup_count;
1717 int cmp;
1718 const struct lyd_node *root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001719
Michal Vaskod3678892020-05-21 10:06:58 +02001720 if ((trg->type != LYXP_SET_NODE_SET) || (src->type != LYXP_SET_NODE_SET)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001721 return LY_EINVAL;
1722 }
1723
Michal Vaskod3678892020-05-21 10:06:58 +02001724 if (!src->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001725 return LY_SUCCESS;
Michal Vaskod3678892020-05-21 10:06:58 +02001726 } else if (!trg->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001727 set_fill_set(trg, src);
Michal Vaskod3678892020-05-21 10:06:58 +02001728 lyxp_set_free_content(src);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001729 return LY_SUCCESS;
1730 }
1731
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001732 /* find first top-level node to be used as anchor for positions */
Michal Vasko9e685082021-01-29 14:49:09 +01001733 for (root = trg->cur_node; root->parent; root = lyd_parent(root)) {}
Michal Vaskod989ba02020-08-24 10:59:24 +02001734 for ( ; root->prev->next; root = root->prev) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001735
1736 /* fill positions */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001737 if (set_assign_pos(trg, root, trg->root_type) || set_assign_pos(src, root, src->root_type)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001738 return LY_EINT;
1739 }
1740
1741#ifndef NDEBUG
1742 LOGDBG(LY_LDGXPATH, "MERGE target");
1743 print_set_debug(trg);
1744 LOGDBG(LY_LDGXPATH, "MERGE source");
1745 print_set_debug(src);
1746#endif
1747
1748 /* make memory for the merge (duplicates are not detected yet, so space
1749 * will likely be wasted on them, too bad) */
1750 if (trg->size - trg->used < src->used) {
1751 trg->size = trg->used + src->used;
1752
1753 trg->val.nodes = ly_realloc(trg->val.nodes, trg->size * sizeof *trg->val.nodes);
1754 LY_CHECK_ERR_RET(!trg->val.nodes, LOGMEM(src->ctx), LY_EMEM);
1755 }
1756
1757 i = 0;
1758 j = 0;
1759 count = 0;
1760 dup_count = 0;
1761 do {
1762 cmp = set_sort_compare(&src->val.nodes[i], &trg->val.nodes[j]);
1763 if (!cmp) {
1764 if (!count) {
1765 /* duplicate, just skip it */
1766 ++i;
1767 ++j;
1768 } else {
1769 /* we are copying something already, so let's copy the duplicate too,
1770 * we are hoping that afterwards there are some more nodes to
1771 * copy and this way we can copy them all together */
1772 ++count;
1773 ++dup_count;
1774 ++i;
1775 ++j;
1776 }
1777 } else if (cmp < 0) {
1778 /* inserting src node into trg, just remember it for now */
1779 ++count;
1780 ++i;
1781
1782 /* insert the hash now */
1783 set_insert_node_hash(trg, src->val.nodes[i - 1].node, src->val.nodes[i - 1].type);
1784 } else if (count) {
1785copy_nodes:
1786 /* time to actually copy the nodes, we have found the largest block of nodes */
1787 memmove(&trg->val.nodes[j + (count - dup_count)],
1788 &trg->val.nodes[j],
1789 (trg->used - j) * sizeof *trg->val.nodes);
1790 memcpy(&trg->val.nodes[j - dup_count], &src->val.nodes[i - count], count * sizeof *src->val.nodes);
1791
1792 trg->used += count - dup_count;
1793 /* do not change i, except the copying above, we are basically doing exactly what is in the else branch below */
1794 j += count - dup_count;
1795
1796 count = 0;
1797 dup_count = 0;
1798 } else {
1799 ++j;
1800 }
1801 } while ((i < src->used) && (j < trg->used));
1802
1803 if ((i < src->used) || count) {
1804 /* insert all the hashes first */
1805 for (k = i; k < src->used; ++k) {
1806 set_insert_node_hash(trg, src->val.nodes[k].node, src->val.nodes[k].type);
1807 }
1808
1809 /* loop ended, but we need to copy something at trg end */
1810 count += src->used - i;
1811 i = src->used;
1812 goto copy_nodes;
1813 }
1814
1815 /* we are inserting hashes before the actual node insert, which causes
1816 * situations when there were initially not enough items for a hash table,
1817 * but even after some were inserted, hash table was not created (during
1818 * insertion the number of items is not updated yet) */
1819 if (!trg->ht && (trg->used >= LYD_HT_MIN_ITEMS)) {
1820 set_insert_node_hash(trg, NULL, 0);
1821 }
1822
1823#ifndef NDEBUG
1824 LOGDBG(LY_LDGXPATH, "MERGE result");
1825 print_set_debug(trg);
1826#endif
1827
Michal Vaskod3678892020-05-21 10:06:58 +02001828 lyxp_set_free_content(src);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001829 return LY_SUCCESS;
1830}
1831
Michal Vasko14676352020-05-29 11:35:55 +02001832LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02001833lyxp_check_token(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint16_t tok_idx, enum lyxp_token want_tok)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001834{
Michal Vasko004d3152020-06-11 19:59:22 +02001835 if (exp->used == tok_idx) {
Michal Vasko14676352020-05-29 11:35:55 +02001836 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001837 LOGVAL(ctx, LY_VCODE_XP_EOF);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001838 }
Michal Vasko14676352020-05-29 11:35:55 +02001839 return LY_EINCOMPLETE;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001840 }
1841
Michal Vasko004d3152020-06-11 19:59:22 +02001842 if (want_tok && (exp->tokens[tok_idx] != want_tok)) {
Michal Vasko14676352020-05-29 11:35:55 +02001843 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001844 LOGVAL(ctx, LY_VCODE_XP_INTOK2, lyxp_print_token(exp->tokens[tok_idx]),
Michal Vasko0b468e62020-10-19 09:33:04 +02001845 &exp->expr[exp->tok_pos[tok_idx]], lyxp_print_token(want_tok));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001846 }
Michal Vasko14676352020-05-29 11:35:55 +02001847 return LY_ENOT;
1848 }
1849
1850 return LY_SUCCESS;
1851}
1852
Michal Vasko004d3152020-06-11 19:59:22 +02001853LY_ERR
1854lyxp_next_token(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint16_t *tok_idx, enum lyxp_token want_tok)
1855{
1856 LY_CHECK_RET(lyxp_check_token(ctx, exp, *tok_idx, want_tok));
1857
1858 /* skip the token */
1859 ++(*tok_idx);
1860
1861 return LY_SUCCESS;
1862}
1863
Michal Vasko14676352020-05-29 11:35:55 +02001864/* just like lyxp_check_token() but tests for 2 tokens */
1865static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02001866exp_check_token2(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint16_t tok_idx, enum lyxp_token want_tok1,
Radek Krejci0f969882020-08-21 16:56:47 +02001867 enum lyxp_token want_tok2)
Michal Vasko14676352020-05-29 11:35:55 +02001868{
Michal Vasko004d3152020-06-11 19:59:22 +02001869 if (exp->used == tok_idx) {
Michal Vasko14676352020-05-29 11:35:55 +02001870 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001871 LOGVAL(ctx, LY_VCODE_XP_EOF);
Michal Vasko14676352020-05-29 11:35:55 +02001872 }
1873 return LY_EINCOMPLETE;
1874 }
1875
Michal Vasko004d3152020-06-11 19:59:22 +02001876 if ((exp->tokens[tok_idx] != want_tok1) && (exp->tokens[tok_idx] != want_tok2)) {
Michal Vasko14676352020-05-29 11:35:55 +02001877 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001878 LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_print_token(exp->tokens[tok_idx]),
Michal Vasko0b468e62020-10-19 09:33:04 +02001879 &exp->expr[exp->tok_pos[tok_idx]]);
Michal Vasko14676352020-05-29 11:35:55 +02001880 }
1881 return LY_ENOT;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001882 }
1883
1884 return LY_SUCCESS;
1885}
1886
Michal Vasko4911eeb2021-06-28 11:23:05 +02001887LY_ERR
1888lyxp_next_token2(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint16_t *tok_idx, enum lyxp_token want_tok1,
1889 enum lyxp_token want_tok2)
1890{
1891 LY_CHECK_RET(exp_check_token2(ctx, exp, *tok_idx, want_tok1, want_tok2));
1892
1893 /* skip the token */
1894 ++(*tok_idx);
1895
1896 return LY_SUCCESS;
1897}
1898
Michal Vasko03ff5a72019-09-11 13:49:33 +02001899/**
1900 * @brief Stack operation push on the repeat array.
1901 *
1902 * @param[in] exp Expression to use.
Michal Vasko004d3152020-06-11 19:59:22 +02001903 * @param[in] tok_idx Position in the expresion \p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001904 * @param[in] repeat_op_idx Index from \p exp of the operator token. This value is pushed.
1905 */
1906static void
Michal Vasko004d3152020-06-11 19:59:22 +02001907exp_repeat_push(struct lyxp_expr *exp, uint16_t tok_idx, uint16_t repeat_op_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001908{
1909 uint16_t i;
1910
Michal Vasko004d3152020-06-11 19:59:22 +02001911 if (exp->repeat[tok_idx]) {
Radek Krejci1e008d22020-08-17 11:37:37 +02001912 for (i = 0; exp->repeat[tok_idx][i]; ++i) {}
Michal Vasko004d3152020-06-11 19:59:22 +02001913 exp->repeat[tok_idx] = realloc(exp->repeat[tok_idx], (i + 2) * sizeof *exp->repeat[tok_idx]);
1914 LY_CHECK_ERR_RET(!exp->repeat[tok_idx], LOGMEM(NULL), );
1915 exp->repeat[tok_idx][i] = repeat_op_idx;
1916 exp->repeat[tok_idx][i + 1] = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001917 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02001918 exp->repeat[tok_idx] = calloc(2, sizeof *exp->repeat[tok_idx]);
1919 LY_CHECK_ERR_RET(!exp->repeat[tok_idx], LOGMEM(NULL), );
1920 exp->repeat[tok_idx][0] = repeat_op_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001921 }
1922}
1923
1924/**
1925 * @brief Reparse Predicate. Logs directly on error.
1926 *
1927 * [7] Predicate ::= '[' Expr ']'
1928 *
1929 * @param[in] ctx Context for logging.
1930 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02001931 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02001932 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001933 * @return LY_ERR
1934 */
1935static LY_ERR
aPiecekbf968d92021-05-27 14:35:05 +02001936reparse_predicate(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001937{
1938 LY_ERR rc;
1939
Michal Vasko004d3152020-06-11 19:59:22 +02001940 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_BRACK1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001941 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02001942 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001943
aPiecekbf968d92021-05-27 14:35:05 +02001944 rc = reparse_or_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001945 LY_CHECK_RET(rc);
1946
Michal Vasko004d3152020-06-11 19:59:22 +02001947 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_BRACK2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001948 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02001949 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001950
1951 return LY_SUCCESS;
1952}
1953
1954/**
1955 * @brief Reparse RelativeLocationPath. Logs directly on error.
1956 *
1957 * [4] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
1958 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
1959 * [6] NodeTest ::= NameTest | NodeType '(' ')'
1960 *
1961 * @param[in] ctx Context for logging.
1962 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02001963 * @param[in] tok_idx Position in the expression \p exp.
aPiecekbf968d92021-05-27 14:35:05 +02001964 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001965 * @return LY_ERR (LY_EINCOMPLETE on forward reference)
1966 */
1967static LY_ERR
aPiecekbf968d92021-05-27 14:35:05 +02001968reparse_relative_location_path(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001969{
1970 LY_ERR rc;
1971
Michal Vasko004d3152020-06-11 19:59:22 +02001972 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001973 LY_CHECK_RET(rc);
1974
1975 goto step;
1976 do {
1977 /* '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02001978 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001979
Michal Vasko004d3152020-06-11 19:59:22 +02001980 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001981 LY_CHECK_RET(rc);
1982step:
1983 /* Step */
Michal Vasko004d3152020-06-11 19:59:22 +02001984 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001985 case LYXP_TOKEN_DOT:
Michal Vasko004d3152020-06-11 19:59:22 +02001986 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001987 break;
1988
1989 case LYXP_TOKEN_DDOT:
Michal Vasko004d3152020-06-11 19:59:22 +02001990 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001991 break;
1992
1993 case LYXP_TOKEN_AT:
Michal Vasko004d3152020-06-11 19:59:22 +02001994 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001995
Michal Vasko004d3152020-06-11 19:59:22 +02001996 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001997 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02001998 if ((exp->tokens[*tok_idx] != LYXP_TOKEN_NAMETEST) && (exp->tokens[*tok_idx] != LYXP_TOKEN_NODETYPE)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001999 LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_print_token(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002000 return LY_EVALID;
2001 }
Radek Krejci0f969882020-08-21 16:56:47 +02002002 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02002003 case LYXP_TOKEN_NAMETEST:
Michal Vasko004d3152020-06-11 19:59:22 +02002004 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002005 goto reparse_predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002006
2007 case LYXP_TOKEN_NODETYPE:
Michal Vasko004d3152020-06-11 19:59:22 +02002008 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002009
2010 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02002011 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002012 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002013 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002014
2015 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02002016 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002017 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002018 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002019
2020reparse_predicate:
2021 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002022 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
aPiecekbf968d92021-05-27 14:35:05 +02002023 rc = reparse_predicate(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002024 LY_CHECK_RET(rc);
2025 }
2026 break;
2027 default:
Radek Krejci2efc45b2020-12-22 16:25:44 +01002028 LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_print_token(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002029 return LY_EVALID;
2030 }
Michal Vasko004d3152020-06-11 19:59:22 +02002031 } while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH));
Michal Vasko03ff5a72019-09-11 13:49:33 +02002032
2033 return LY_SUCCESS;
2034}
2035
2036/**
2037 * @brief Reparse AbsoluteLocationPath. Logs directly on error.
2038 *
2039 * [3] AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
2040 *
2041 * @param[in] ctx Context for logging.
2042 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002043 * @param[in] tok_idx Position in the expression \p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002044 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002045 * @return LY_ERR
2046 */
2047static LY_ERR
aPiecekbf968d92021-05-27 14:35:05 +02002048reparse_absolute_location_path(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002049{
2050 LY_ERR rc;
2051
Michal Vasko004d3152020-06-11 19:59:22 +02002052 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 +02002053
2054 /* '/' RelativeLocationPath? */
Michal Vasko004d3152020-06-11 19:59:22 +02002055 if (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002056 /* '/' */
Michal Vasko004d3152020-06-11 19:59:22 +02002057 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002058
Michal Vasko004d3152020-06-11 19:59:22 +02002059 if (lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002060 return LY_SUCCESS;
2061 }
Michal Vasko004d3152020-06-11 19:59:22 +02002062 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002063 case LYXP_TOKEN_DOT:
2064 case LYXP_TOKEN_DDOT:
2065 case LYXP_TOKEN_AT:
2066 case LYXP_TOKEN_NAMETEST:
2067 case LYXP_TOKEN_NODETYPE:
aPiecekbf968d92021-05-27 14:35:05 +02002068 rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002069 LY_CHECK_RET(rc);
Radek Krejci0f969882020-08-21 16:56:47 +02002070 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02002071 default:
2072 break;
2073 }
2074
Michal Vasko03ff5a72019-09-11 13:49:33 +02002075 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02002076 /* '//' RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02002077 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002078
aPiecekbf968d92021-05-27 14:35:05 +02002079 rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002080 LY_CHECK_RET(rc);
2081 }
2082
2083 return LY_SUCCESS;
2084}
2085
2086/**
2087 * @brief Reparse FunctionCall. Logs directly on error.
2088 *
2089 * [9] FunctionCall ::= FunctionName '(' ( Expr ( ',' Expr )* )? ')'
2090 *
2091 * @param[in] ctx Context for logging.
2092 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002093 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002094 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002095 * @return LY_ERR
2096 */
2097static LY_ERR
aPiecekbf968d92021-05-27 14:35:05 +02002098reparse_function_call(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002099{
Radek Krejci1deb5be2020-08-26 16:43:36 +02002100 int8_t min_arg_count = -1;
2101 uint32_t arg_count, max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002102 uint16_t func_tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002103 LY_ERR rc;
2104
Michal Vasko004d3152020-06-11 19:59:22 +02002105 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_FUNCNAME);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002106 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002107 func_tok_idx = *tok_idx;
2108 switch (exp->tok_len[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002109 case 3:
Michal Vasko004d3152020-06-11 19:59:22 +02002110 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "not", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002111 min_arg_count = 1;
2112 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002113 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "sum", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002114 min_arg_count = 1;
2115 max_arg_count = 1;
2116 }
2117 break;
2118 case 4:
Michal Vasko004d3152020-06-11 19:59:22 +02002119 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "lang", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002120 min_arg_count = 1;
2121 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002122 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "last", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002123 min_arg_count = 0;
2124 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002125 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "name", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002126 min_arg_count = 0;
2127 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002128 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "true", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002129 min_arg_count = 0;
2130 max_arg_count = 0;
2131 }
2132 break;
2133 case 5:
Michal Vasko004d3152020-06-11 19:59:22 +02002134 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "count", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002135 min_arg_count = 1;
2136 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002137 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "false", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002138 min_arg_count = 0;
2139 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002140 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "floor", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002141 min_arg_count = 1;
2142 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002143 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "round", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002144 min_arg_count = 1;
2145 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002146 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "deref", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002147 min_arg_count = 1;
2148 max_arg_count = 1;
2149 }
2150 break;
2151 case 6:
Michal Vasko004d3152020-06-11 19:59:22 +02002152 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "concat", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002153 min_arg_count = 2;
Radek Krejci1deb5be2020-08-26 16:43:36 +02002154 max_arg_count = UINT32_MAX;
Michal Vasko004d3152020-06-11 19:59:22 +02002155 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "number", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002156 min_arg_count = 0;
2157 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002158 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002159 min_arg_count = 0;
2160 max_arg_count = 1;
2161 }
2162 break;
2163 case 7:
Michal Vasko004d3152020-06-11 19:59:22 +02002164 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "boolean", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002165 min_arg_count = 1;
2166 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002167 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "ceiling", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002168 min_arg_count = 1;
2169 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002170 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "current", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002171 min_arg_count = 0;
2172 max_arg_count = 0;
2173 }
2174 break;
2175 case 8:
Michal Vasko004d3152020-06-11 19:59:22 +02002176 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "contains", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002177 min_arg_count = 2;
2178 max_arg_count = 2;
Michal Vasko004d3152020-06-11 19:59:22 +02002179 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "position", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002180 min_arg_count = 0;
2181 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002182 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "re-match", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002183 min_arg_count = 2;
2184 max_arg_count = 2;
2185 }
2186 break;
2187 case 9:
Michal Vasko004d3152020-06-11 19:59:22 +02002188 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002189 min_arg_count = 2;
2190 max_arg_count = 3;
Michal Vasko004d3152020-06-11 19:59:22 +02002191 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "translate", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002192 min_arg_count = 3;
2193 max_arg_count = 3;
2194 }
2195 break;
2196 case 10:
Michal Vasko004d3152020-06-11 19:59:22 +02002197 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "local-name", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002198 min_arg_count = 0;
2199 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002200 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "enum-value", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002201 min_arg_count = 1;
2202 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002203 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "bit-is-set", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002204 min_arg_count = 2;
2205 max_arg_count = 2;
2206 }
2207 break;
2208 case 11:
Michal Vasko004d3152020-06-11 19:59:22 +02002209 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "starts-with", 11)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002210 min_arg_count = 2;
2211 max_arg_count = 2;
2212 }
2213 break;
2214 case 12:
Michal Vasko004d3152020-06-11 19:59:22 +02002215 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from", 12)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002216 min_arg_count = 2;
2217 max_arg_count = 2;
2218 }
2219 break;
2220 case 13:
Michal Vasko004d3152020-06-11 19:59:22 +02002221 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "namespace-uri", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002222 min_arg_count = 0;
2223 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002224 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string-length", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002225 min_arg_count = 0;
2226 max_arg_count = 1;
2227 }
2228 break;
2229 case 15:
Michal Vasko004d3152020-06-11 19:59:22 +02002230 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "normalize-space", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002231 min_arg_count = 0;
2232 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002233 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-after", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002234 min_arg_count = 2;
2235 max_arg_count = 2;
2236 }
2237 break;
2238 case 16:
Michal Vasko004d3152020-06-11 19:59:22 +02002239 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-before", 16)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002240 min_arg_count = 2;
2241 max_arg_count = 2;
2242 }
2243 break;
2244 case 20:
Michal Vasko004d3152020-06-11 19:59:22 +02002245 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from-or-self", 20)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002246 min_arg_count = 2;
2247 max_arg_count = 2;
2248 }
2249 break;
2250 }
2251 if (min_arg_count == -1) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002252 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 +02002253 return LY_EINVAL;
2254 }
Michal Vasko004d3152020-06-11 19:59:22 +02002255 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002256
2257 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02002258 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002259 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002260 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002261
2262 /* ( Expr ( ',' Expr )* )? */
2263 arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002264 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002265 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002266 if (exp->tokens[*tok_idx] != LYXP_TOKEN_PAR2) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002267 ++arg_count;
aPiecekbf968d92021-05-27 14:35:05 +02002268 rc = reparse_or_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002269 LY_CHECK_RET(rc);
2270 }
Michal Vasko004d3152020-06-11 19:59:22 +02002271 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_COMMA)) {
2272 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002273
2274 ++arg_count;
aPiecekbf968d92021-05-27 14:35:05 +02002275 rc = reparse_or_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002276 LY_CHECK_RET(rc);
2277 }
2278
2279 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02002280 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002281 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002282 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002283
Radek Krejci857189e2020-09-01 13:26:36 +02002284 if ((arg_count < (uint32_t)min_arg_count) || (arg_count > max_arg_count)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002285 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 +02002286 return LY_EVALID;
2287 }
2288
2289 return LY_SUCCESS;
2290}
2291
2292/**
2293 * @brief Reparse PathExpr. Logs directly on error.
2294 *
2295 * [10] PathExpr ::= LocationPath | PrimaryExpr Predicate*
2296 * | PrimaryExpr Predicate* '/' RelativeLocationPath
2297 * | PrimaryExpr Predicate* '//' RelativeLocationPath
2298 * [2] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
aPiecekfba75362021-10-07 12:39:48 +02002299 * [8] PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
Michal Vasko03ff5a72019-09-11 13:49:33 +02002300 *
2301 * @param[in] ctx Context for logging.
2302 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002303 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002304 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002305 * @return LY_ERR
2306 */
2307static LY_ERR
aPiecekbf968d92021-05-27 14:35:05 +02002308reparse_path_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002309{
2310 LY_ERR rc;
2311
Michal Vasko004d3152020-06-11 19:59:22 +02002312 if (lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko14676352020-05-29 11:35:55 +02002313 return LY_EVALID;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002314 }
2315
Michal Vasko004d3152020-06-11 19:59:22 +02002316 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002317 case LYXP_TOKEN_PAR1:
2318 /* '(' Expr ')' Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002319 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002320
aPiecekbf968d92021-05-27 14:35:05 +02002321 rc = reparse_or_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002322 LY_CHECK_RET(rc);
2323
Michal Vasko004d3152020-06-11 19:59:22 +02002324 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002325 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002326 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002327 goto predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002328 case LYXP_TOKEN_DOT:
2329 case LYXP_TOKEN_DDOT:
2330 case LYXP_TOKEN_AT:
2331 case LYXP_TOKEN_NAMETEST:
2332 case LYXP_TOKEN_NODETYPE:
2333 /* RelativeLocationPath */
aPiecekbf968d92021-05-27 14:35:05 +02002334 rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002335 LY_CHECK_RET(rc);
2336 break;
aPiecekfba75362021-10-07 12:39:48 +02002337 case LYXP_TOKEN_VARREF:
2338 /* VariableReference */
2339 ++(*tok_idx);
2340 goto predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002341 case LYXP_TOKEN_FUNCNAME:
2342 /* FunctionCall */
aPiecekbf968d92021-05-27 14:35:05 +02002343 rc = reparse_function_call(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002344 LY_CHECK_RET(rc);
2345 goto predicate;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002346 case LYXP_TOKEN_OPER_PATH:
2347 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +02002348 /* AbsoluteLocationPath */
aPiecekbf968d92021-05-27 14:35:05 +02002349 rc = reparse_absolute_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002350 LY_CHECK_RET(rc);
2351 break;
2352 case LYXP_TOKEN_LITERAL:
2353 /* Literal */
Michal Vasko004d3152020-06-11 19:59:22 +02002354 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002355 goto predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002356 case LYXP_TOKEN_NUMBER:
2357 /* Number */
Michal Vasko004d3152020-06-11 19:59:22 +02002358 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002359 goto predicate;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002360 default:
Radek Krejci2efc45b2020-12-22 16:25:44 +01002361 LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_print_token(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002362 return LY_EVALID;
2363 }
2364
2365 return LY_SUCCESS;
2366
2367predicate:
2368 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002369 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
aPiecekbf968d92021-05-27 14:35:05 +02002370 rc = reparse_predicate(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002371 LY_CHECK_RET(rc);
2372 }
2373
2374 /* ('/' or '//') RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02002375 if (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002376
2377 /* '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02002378 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002379
aPiecekbf968d92021-05-27 14:35:05 +02002380 rc = reparse_relative_location_path(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002381 LY_CHECK_RET(rc);
2382 }
2383
2384 return LY_SUCCESS;
2385}
2386
2387/**
2388 * @brief Reparse UnaryExpr. Logs directly on error.
2389 *
2390 * [17] UnaryExpr ::= UnionExpr | '-' UnaryExpr
2391 * [18] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
2392 *
2393 * @param[in] ctx Context for logging.
2394 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002395 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002396 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002397 * @return LY_ERR
2398 */
2399static LY_ERR
aPiecekbf968d92021-05-27 14:35:05 +02002400reparse_unary_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002401{
2402 uint16_t prev_exp;
2403 LY_ERR rc;
2404
2405 /* ('-')* */
Michal Vasko004d3152020-06-11 19:59:22 +02002406 prev_exp = *tok_idx;
Michal Vasko69730152020-10-09 16:30:07 +02002407 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2408 (exp->expr[exp->tok_pos[*tok_idx]] == '-')) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002409 exp_repeat_push(exp, prev_exp, LYXP_EXPR_UNARY);
Michal Vasko004d3152020-06-11 19:59:22 +02002410 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002411 }
2412
2413 /* PathExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002414 prev_exp = *tok_idx;
aPiecekbf968d92021-05-27 14:35:05 +02002415 rc = reparse_path_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002416 LY_CHECK_RET(rc);
2417
2418 /* ('|' PathExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002419 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_UNI)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002420 exp_repeat_push(exp, prev_exp, LYXP_EXPR_UNION);
Michal Vasko004d3152020-06-11 19:59:22 +02002421 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002422
aPiecekbf968d92021-05-27 14:35:05 +02002423 rc = reparse_path_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002424 LY_CHECK_RET(rc);
2425 }
2426
2427 return LY_SUCCESS;
2428}
2429
2430/**
2431 * @brief Reparse AdditiveExpr. Logs directly on error.
2432 *
2433 * [15] AdditiveExpr ::= MultiplicativeExpr
2434 * | AdditiveExpr '+' MultiplicativeExpr
2435 * | AdditiveExpr '-' MultiplicativeExpr
2436 * [16] MultiplicativeExpr ::= UnaryExpr
2437 * | MultiplicativeExpr '*' UnaryExpr
2438 * | MultiplicativeExpr 'div' UnaryExpr
2439 * | MultiplicativeExpr 'mod' UnaryExpr
2440 *
2441 * @param[in] ctx Context for logging.
2442 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002443 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002444 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002445 * @return LY_ERR
2446 */
2447static LY_ERR
aPiecekbf968d92021-05-27 14:35:05 +02002448reparse_additive_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002449{
2450 uint16_t prev_add_exp, prev_mul_exp;
2451 LY_ERR rc;
2452
Michal Vasko004d3152020-06-11 19:59:22 +02002453 prev_add_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002454 goto reparse_multiplicative_expr;
2455
2456 /* ('+' / '-' MultiplicativeExpr)* */
Michal Vasko69730152020-10-09 16:30:07 +02002457 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2458 ((exp->expr[exp->tok_pos[*tok_idx]] == '+') || (exp->expr[exp->tok_pos[*tok_idx]] == '-'))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002459 exp_repeat_push(exp, prev_add_exp, LYXP_EXPR_ADDITIVE);
Michal Vasko004d3152020-06-11 19:59:22 +02002460 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002461
2462reparse_multiplicative_expr:
2463 /* UnaryExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002464 prev_mul_exp = *tok_idx;
aPiecekbf968d92021-05-27 14:35:05 +02002465 rc = reparse_unary_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002466 LY_CHECK_RET(rc);
2467
2468 /* ('*' / 'div' / 'mod' UnaryExpr)* */
Michal Vasko69730152020-10-09 16:30:07 +02002469 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2470 ((exp->expr[exp->tok_pos[*tok_idx]] == '*') || (exp->tok_len[*tok_idx] == 3))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002471 exp_repeat_push(exp, prev_mul_exp, LYXP_EXPR_MULTIPLICATIVE);
Michal Vasko004d3152020-06-11 19:59:22 +02002472 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002473
aPiecekbf968d92021-05-27 14:35:05 +02002474 rc = reparse_unary_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002475 LY_CHECK_RET(rc);
2476 }
2477 }
2478
2479 return LY_SUCCESS;
2480}
2481
2482/**
2483 * @brief Reparse EqualityExpr. Logs directly on error.
2484 *
2485 * [13] EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr
2486 * | EqualityExpr '!=' RelationalExpr
2487 * [14] RelationalExpr ::= AdditiveExpr
2488 * | RelationalExpr '<' AdditiveExpr
2489 * | RelationalExpr '>' AdditiveExpr
2490 * | RelationalExpr '<=' AdditiveExpr
2491 * | RelationalExpr '>=' AdditiveExpr
2492 *
2493 * @param[in] ctx Context for logging.
2494 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002495 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002496 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002497 * @return LY_ERR
2498 */
2499static LY_ERR
aPiecekbf968d92021-05-27 14:35:05 +02002500reparse_equality_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002501{
2502 uint16_t prev_eq_exp, prev_rel_exp;
2503 LY_ERR rc;
2504
Michal Vasko004d3152020-06-11 19:59:22 +02002505 prev_eq_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002506 goto reparse_additive_expr;
2507
2508 /* ('=' / '!=' RelationalExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002509 while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_EQUAL, LYXP_TOKEN_OPER_NEQUAL)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002510 exp_repeat_push(exp, prev_eq_exp, LYXP_EXPR_EQUALITY);
Michal Vasko004d3152020-06-11 19:59:22 +02002511 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002512
2513reparse_additive_expr:
2514 /* AdditiveExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002515 prev_rel_exp = *tok_idx;
aPiecekbf968d92021-05-27 14:35:05 +02002516 rc = reparse_additive_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002517 LY_CHECK_RET(rc);
2518
2519 /* ('<' / '>' / '<=' / '>=' AdditiveExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002520 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_COMP)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002521 exp_repeat_push(exp, prev_rel_exp, LYXP_EXPR_RELATIONAL);
Michal Vasko004d3152020-06-11 19:59:22 +02002522 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002523
aPiecekbf968d92021-05-27 14:35:05 +02002524 rc = reparse_additive_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002525 LY_CHECK_RET(rc);
2526 }
2527 }
2528
2529 return LY_SUCCESS;
2530}
2531
2532/**
2533 * @brief Reparse OrExpr. Logs directly on error.
2534 *
2535 * [11] OrExpr ::= AndExpr | OrExpr 'or' AndExpr
2536 * [12] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
2537 *
2538 * @param[in] ctx Context for logging.
2539 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002540 * @param[in] tok_idx Position in the expression @p exp.
aPiecekbf968d92021-05-27 14:35:05 +02002541 * @param[in] depth Current number of nested expressions.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002542 * @return LY_ERR
2543 */
2544static LY_ERR
aPiecekbf968d92021-05-27 14:35:05 +02002545reparse_or_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t depth)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002546{
2547 uint16_t prev_or_exp, prev_and_exp;
2548 LY_ERR rc;
2549
aPiecekbf968d92021-05-27 14:35:05 +02002550 ++depth;
2551 LY_CHECK_ERR_RET(depth > LYXP_MAX_BLOCK_DEPTH, LOGVAL(ctx, LY_VCODE_XP_DEPTH), LY_EINVAL);
2552
Michal Vasko004d3152020-06-11 19:59:22 +02002553 prev_or_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002554 goto reparse_equality_expr;
2555
2556 /* ('or' AndExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002557 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 +02002558 exp_repeat_push(exp, prev_or_exp, LYXP_EXPR_OR);
Michal Vasko004d3152020-06-11 19:59:22 +02002559 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002560
2561reparse_equality_expr:
2562 /* EqualityExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002563 prev_and_exp = *tok_idx;
aPiecekbf968d92021-05-27 14:35:05 +02002564 rc = reparse_equality_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002565 LY_CHECK_RET(rc);
2566
2567 /* ('and' EqualityExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002568 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 +02002569 exp_repeat_push(exp, prev_and_exp, LYXP_EXPR_AND);
Michal Vasko004d3152020-06-11 19:59:22 +02002570 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002571
aPiecekbf968d92021-05-27 14:35:05 +02002572 rc = reparse_equality_expr(ctx, exp, tok_idx, depth);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002573 LY_CHECK_RET(rc);
2574 }
2575 }
2576
2577 return LY_SUCCESS;
2578}
Radek Krejcib1646a92018-11-02 16:08:26 +01002579
2580/**
2581 * @brief Parse NCName.
2582 *
2583 * @param[in] ncname Name to parse.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002584 * @return Length of @p ncname valid bytes.
Radek Krejcib1646a92018-11-02 16:08:26 +01002585 */
Radek Krejcid4270262019-01-07 15:07:25 +01002586static long int
Radek Krejcib1646a92018-11-02 16:08:26 +01002587parse_ncname(const char *ncname)
2588{
Radek Krejci1deb5be2020-08-26 16:43:36 +02002589 uint32_t uc;
Radek Krejcid4270262019-01-07 15:07:25 +01002590 size_t size;
2591 long int len = 0;
Radek Krejcib1646a92018-11-02 16:08:26 +01002592
2593 LY_CHECK_RET(ly_getutf8(&ncname, &uc, &size), 0);
2594 if (!is_xmlqnamestartchar(uc) || (uc == ':')) {
2595 return len;
2596 }
2597
2598 do {
2599 len += size;
Radek Krejci9a564c92019-01-07 14:53:57 +01002600 if (!*ncname) {
2601 break;
2602 }
Radek Krejcid4270262019-01-07 15:07:25 +01002603 LY_CHECK_RET(ly_getutf8(&ncname, &uc, &size), -len);
Radek Krejcib1646a92018-11-02 16:08:26 +01002604 } while (is_xmlqnamechar(uc) && (uc != ':'));
2605
2606 return len;
2607}
2608
2609/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02002610 * @brief Add @p token into the expression @p exp.
Radek Krejcib1646a92018-11-02 16:08:26 +01002611 *
Michal Vasko03ff5a72019-09-11 13:49:33 +02002612 * @param[in] ctx Context for logging.
Radek Krejcib1646a92018-11-02 16:08:26 +01002613 * @param[in] exp Expression to use.
2614 * @param[in] token Token to add.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002615 * @param[in] tok_pos Token position in the XPath expression.
Radek Krejcib1646a92018-11-02 16:08:26 +01002616 * @param[in] tok_len Token length in the XPath expression.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002617 * @return LY_ERR
Radek Krejcib1646a92018-11-02 16:08:26 +01002618 */
2619static LY_ERR
Michal Vasko14676352020-05-29 11:35:55 +02002620exp_add_token(const struct ly_ctx *ctx, struct lyxp_expr *exp, enum lyxp_token token, uint16_t tok_pos, uint16_t tok_len)
Radek Krejcib1646a92018-11-02 16:08:26 +01002621{
2622 uint32_t prev;
2623
2624 if (exp->used == exp->size) {
2625 prev = exp->size;
2626 exp->size += LYXP_EXPR_SIZE_STEP;
2627 if (prev > exp->size) {
2628 LOGINT(ctx);
2629 return LY_EINT;
2630 }
2631
2632 exp->tokens = ly_realloc(exp->tokens, exp->size * sizeof *exp->tokens);
2633 LY_CHECK_ERR_RET(!exp->tokens, LOGMEM(ctx), LY_EMEM);
2634 exp->tok_pos = ly_realloc(exp->tok_pos, exp->size * sizeof *exp->tok_pos);
2635 LY_CHECK_ERR_RET(!exp->tok_pos, LOGMEM(ctx), LY_EMEM);
2636 exp->tok_len = ly_realloc(exp->tok_len, exp->size * sizeof *exp->tok_len);
2637 LY_CHECK_ERR_RET(!exp->tok_len, LOGMEM(ctx), LY_EMEM);
2638 }
2639
2640 exp->tokens[exp->used] = token;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002641 exp->tok_pos[exp->used] = tok_pos;
Radek Krejcib1646a92018-11-02 16:08:26 +01002642 exp->tok_len[exp->used] = tok_len;
2643 ++exp->used;
2644 return LY_SUCCESS;
2645}
2646
2647void
Michal Vasko14676352020-05-29 11:35:55 +02002648lyxp_expr_free(const struct ly_ctx *ctx, struct lyxp_expr *expr)
Radek Krejcib1646a92018-11-02 16:08:26 +01002649{
2650 uint16_t i;
2651
2652 if (!expr) {
2653 return;
2654 }
2655
2656 lydict_remove(ctx, expr->expr);
2657 free(expr->tokens);
2658 free(expr->tok_pos);
2659 free(expr->tok_len);
2660 if (expr->repeat) {
2661 for (i = 0; i < expr->used; ++i) {
2662 free(expr->repeat[i]);
2663 }
2664 }
2665 free(expr->repeat);
2666 free(expr);
2667}
2668
Radek Krejcif03a9e22020-09-18 20:09:31 +02002669LY_ERR
2670lyxp_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 +01002671{
Radek Krejcif03a9e22020-09-18 20:09:31 +02002672 LY_ERR ret = LY_SUCCESS;
2673 struct lyxp_expr *expr;
Radek Krejcid4270262019-01-07 15:07:25 +01002674 size_t parsed = 0, tok_len;
Radek Krejcib1646a92018-11-02 16:08:26 +01002675 enum lyxp_token tok_type;
Radek Krejci857189e2020-09-01 13:26:36 +02002676 ly_bool prev_function_check = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002677 uint16_t tok_idx = 0;
Radek Krejcib1646a92018-11-02 16:08:26 +01002678
Radek Krejcif03a9e22020-09-18 20:09:31 +02002679 assert(expr_p);
2680
2681 if (!expr_str[0]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002682 LOGVAL(ctx, LY_VCODE_XP_EOF);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002683 return LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +02002684 }
2685
2686 if (!expr_len) {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002687 expr_len = strlen(expr_str);
Michal Vasko004d3152020-06-11 19:59:22 +02002688 }
2689 if (expr_len > UINT16_MAX) {
Michal Vasko623ac7b2021-04-09 12:44:23 +02002690 LOGVAL(ctx, LYVE_XPATH, "XPath expression cannot be longer than %u characters.", UINT16_MAX);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002691 return LY_EVALID;
Radek Krejcib1646a92018-11-02 16:08:26 +01002692 }
2693
2694 /* init lyxp_expr structure */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002695 expr = calloc(1, sizeof *expr);
2696 LY_CHECK_ERR_GOTO(!expr, LOGMEM(ctx); ret = LY_EMEM, error);
2697 LY_CHECK_GOTO(ret = lydict_insert(ctx, expr_str, expr_len, &expr->expr), error);
2698 expr->used = 0;
2699 expr->size = LYXP_EXPR_SIZE_START;
2700 expr->tokens = malloc(expr->size * sizeof *expr->tokens);
2701 LY_CHECK_ERR_GOTO(!expr->tokens, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002702
Radek Krejcif03a9e22020-09-18 20:09:31 +02002703 expr->tok_pos = malloc(expr->size * sizeof *expr->tok_pos);
2704 LY_CHECK_ERR_GOTO(!expr->tok_pos, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002705
Radek Krejcif03a9e22020-09-18 20:09:31 +02002706 expr->tok_len = malloc(expr->size * sizeof *expr->tok_len);
2707 LY_CHECK_ERR_GOTO(!expr->tok_len, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002708
Michal Vasko004d3152020-06-11 19:59:22 +02002709 /* make expr 0-terminated */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002710 expr_str = expr->expr;
Michal Vasko004d3152020-06-11 19:59:22 +02002711
Radek Krejcif03a9e22020-09-18 20:09:31 +02002712 while (is_xmlws(expr_str[parsed])) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002713 ++parsed;
2714 }
2715
2716 do {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002717 if (expr_str[parsed] == '(') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002718
2719 /* '(' */
2720 tok_len = 1;
2721 tok_type = LYXP_TOKEN_PAR1;
2722
Radek Krejcif03a9e22020-09-18 20:09:31 +02002723 if (prev_function_check && expr->used && (expr->tokens[expr->used - 1] == LYXP_TOKEN_NAMETEST)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002724 /* it is a NodeType/FunctionName after all */
Michal Vasko69730152020-10-09 16:30:07 +02002725 if (((expr->tok_len[expr->used - 1] == 4) &&
2726 (!strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "node", 4) ||
2727 !strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "text", 4))) ||
2728 ((expr->tok_len[expr->used - 1] == 7) &&
2729 !strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "comment", 7))) {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002730 expr->tokens[expr->used - 1] = LYXP_TOKEN_NODETYPE;
Radek Krejcib1646a92018-11-02 16:08:26 +01002731 } else {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002732 expr->tokens[expr->used - 1] = LYXP_TOKEN_FUNCNAME;
Radek Krejcib1646a92018-11-02 16:08:26 +01002733 }
2734 prev_function_check = 0;
2735 }
2736
Radek Krejcif03a9e22020-09-18 20:09:31 +02002737 } else if (expr_str[parsed] == ')') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002738
2739 /* ')' */
2740 tok_len = 1;
2741 tok_type = LYXP_TOKEN_PAR2;
2742
Radek Krejcif03a9e22020-09-18 20:09:31 +02002743 } else if (expr_str[parsed] == '[') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002744
2745 /* '[' */
2746 tok_len = 1;
2747 tok_type = LYXP_TOKEN_BRACK1;
2748
Radek Krejcif03a9e22020-09-18 20:09:31 +02002749 } else if (expr_str[parsed] == ']') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002750
2751 /* ']' */
2752 tok_len = 1;
2753 tok_type = LYXP_TOKEN_BRACK2;
2754
Radek Krejcif03a9e22020-09-18 20:09:31 +02002755 } else if (!strncmp(&expr_str[parsed], "..", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002756
2757 /* '..' */
2758 tok_len = 2;
2759 tok_type = LYXP_TOKEN_DDOT;
2760
Radek Krejcif03a9e22020-09-18 20:09:31 +02002761 } else if ((expr_str[parsed] == '.') && (!isdigit(expr_str[parsed + 1]))) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002762
2763 /* '.' */
2764 tok_len = 1;
2765 tok_type = LYXP_TOKEN_DOT;
2766
Radek Krejcif03a9e22020-09-18 20:09:31 +02002767 } else if (expr_str[parsed] == '@') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002768
2769 /* '@' */
2770 tok_len = 1;
2771 tok_type = LYXP_TOKEN_AT;
2772
Radek Krejcif03a9e22020-09-18 20:09:31 +02002773 } else if (expr_str[parsed] == ',') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002774
2775 /* ',' */
2776 tok_len = 1;
2777 tok_type = LYXP_TOKEN_COMMA;
2778
Radek Krejcif03a9e22020-09-18 20:09:31 +02002779 } else if (expr_str[parsed] == '\'') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002780
2781 /* Literal with ' */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002782 for (tok_len = 1; (expr_str[parsed + tok_len] != '\0') && (expr_str[parsed + tok_len] != '\''); ++tok_len) {}
2783 LY_CHECK_ERR_GOTO(expr_str[parsed + tok_len] == '\0',
Radek Krejci2efc45b2020-12-22 16:25:44 +01002784 LOGVAL(ctx, LY_VCODE_XP_EOE, expr_str[parsed], &expr_str[parsed]); ret = LY_EVALID,
Michal Vasko69730152020-10-09 16:30:07 +02002785 error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002786 ++tok_len;
2787 tok_type = LYXP_TOKEN_LITERAL;
2788
Radek Krejcif03a9e22020-09-18 20:09:31 +02002789 } else if (expr_str[parsed] == '\"') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002790
2791 /* Literal with " */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002792 for (tok_len = 1; (expr_str[parsed + tok_len] != '\0') && (expr_str[parsed + tok_len] != '\"'); ++tok_len) {}
2793 LY_CHECK_ERR_GOTO(expr_str[parsed + tok_len] == '\0',
Radek Krejci2efc45b2020-12-22 16:25:44 +01002794 LOGVAL(ctx, LY_VCODE_XP_EOE, expr_str[parsed], &expr_str[parsed]); ret = LY_EVALID,
Michal Vasko69730152020-10-09 16:30:07 +02002795 error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002796 ++tok_len;
2797 tok_type = LYXP_TOKEN_LITERAL;
2798
Radek Krejcif03a9e22020-09-18 20:09:31 +02002799 } else if ((expr_str[parsed] == '.') || (isdigit(expr_str[parsed]))) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002800
2801 /* Number */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002802 for (tok_len = 0; isdigit(expr_str[parsed + tok_len]); ++tok_len) {}
2803 if (expr_str[parsed + tok_len] == '.') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002804 ++tok_len;
Radek Krejcif03a9e22020-09-18 20:09:31 +02002805 for ( ; isdigit(expr_str[parsed + tok_len]); ++tok_len) {}
Radek Krejcib1646a92018-11-02 16:08:26 +01002806 }
2807 tok_type = LYXP_TOKEN_NUMBER;
2808
aPiecekfba75362021-10-07 12:39:48 +02002809 } else if (expr_str[parsed] == '$') {
2810
2811 /* VariableReference */
2812 parsed++;
2813 long int ncname_len = parse_ncname(&expr_str[parsed]);
2814 LY_CHECK_ERR_GOTO(ncname_len < 1, LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed - ncname_len],
2815 parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
2816 tok_len = ncname_len;
2817 LY_CHECK_ERR_GOTO(expr_str[parsed + tok_len] == ':',
2818 LOGVAL(ctx, LYVE_XPATH, "Variable with prefix is not supported."); ret = LY_EVALID,
2819 error);
2820 tok_type = LYXP_TOKEN_VARREF;
2821
Radek Krejcif03a9e22020-09-18 20:09:31 +02002822 } else if (expr_str[parsed] == '/') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002823
2824 /* Operator '/', '//' */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002825 if (!strncmp(&expr_str[parsed], "//", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002826 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002827 tok_type = LYXP_TOKEN_OPER_RPATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002828 } else {
2829 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002830 tok_type = LYXP_TOKEN_OPER_PATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002831 }
Radek Krejcib1646a92018-11-02 16:08:26 +01002832
Radek Krejcif03a9e22020-09-18 20:09:31 +02002833 } else if (!strncmp(&expr_str[parsed], "!=", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002834
Michal Vasko3e48bf32020-06-01 08:39:07 +02002835 /* Operator '!=' */
Radek Krejcib1646a92018-11-02 16:08:26 +01002836 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002837 tok_type = LYXP_TOKEN_OPER_NEQUAL;
2838
Radek Krejcif03a9e22020-09-18 20:09:31 +02002839 } else if (!strncmp(&expr_str[parsed], "<=", 2) || !strncmp(&expr_str[parsed], ">=", 2)) {
Michal Vasko3e48bf32020-06-01 08:39:07 +02002840
2841 /* Operator '<=', '>=' */
2842 tok_len = 2;
2843 tok_type = LYXP_TOKEN_OPER_COMP;
Radek Krejcib1646a92018-11-02 16:08:26 +01002844
Radek Krejcif03a9e22020-09-18 20:09:31 +02002845 } else if (expr_str[parsed] == '|') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002846
2847 /* Operator '|' */
2848 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002849 tok_type = LYXP_TOKEN_OPER_UNI;
Radek Krejcib1646a92018-11-02 16:08:26 +01002850
Radek Krejcif03a9e22020-09-18 20:09:31 +02002851 } else if ((expr_str[parsed] == '+') || (expr_str[parsed] == '-')) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002852
2853 /* Operator '+', '-' */
2854 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002855 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002856
Radek Krejcif03a9e22020-09-18 20:09:31 +02002857 } else if (expr_str[parsed] == '=') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002858
Michal Vasko3e48bf32020-06-01 08:39:07 +02002859 /* Operator '=' */
Radek Krejcib1646a92018-11-02 16:08:26 +01002860 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002861 tok_type = LYXP_TOKEN_OPER_EQUAL;
2862
Radek Krejcif03a9e22020-09-18 20:09:31 +02002863 } else if ((expr_str[parsed] == '<') || (expr_str[parsed] == '>')) {
Michal Vasko3e48bf32020-06-01 08:39:07 +02002864
2865 /* Operator '<', '>' */
2866 tok_len = 1;
2867 tok_type = LYXP_TOKEN_OPER_COMP;
Radek Krejcib1646a92018-11-02 16:08:26 +01002868
Michal Vasko69730152020-10-09 16:30:07 +02002869 } else if (expr->used && (expr->tokens[expr->used - 1] != LYXP_TOKEN_AT) &&
2870 (expr->tokens[expr->used - 1] != LYXP_TOKEN_PAR1) &&
2871 (expr->tokens[expr->used - 1] != LYXP_TOKEN_BRACK1) &&
2872 (expr->tokens[expr->used - 1] != LYXP_TOKEN_COMMA) &&
2873 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_LOG) &&
2874 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_EQUAL) &&
2875 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_NEQUAL) &&
2876 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_COMP) &&
2877 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_MATH) &&
2878 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_UNI) &&
2879 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_PATH) &&
2880 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_RPATH)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002881
2882 /* Operator '*', 'or', 'and', 'mod', or 'div' */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002883 if (expr_str[parsed] == '*') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002884 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002885 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002886
Radek Krejcif03a9e22020-09-18 20:09:31 +02002887 } else if (!strncmp(&expr_str[parsed], "or", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002888 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002889 tok_type = LYXP_TOKEN_OPER_LOG;
Radek Krejcib1646a92018-11-02 16:08:26 +01002890
Radek Krejcif03a9e22020-09-18 20:09:31 +02002891 } else if (!strncmp(&expr_str[parsed], "and", 3)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002892 tok_len = 3;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002893 tok_type = LYXP_TOKEN_OPER_LOG;
Radek Krejcib1646a92018-11-02 16:08:26 +01002894
Radek Krejcif03a9e22020-09-18 20:09:31 +02002895 } else if (!strncmp(&expr_str[parsed], "mod", 3) || !strncmp(&expr_str[parsed], "div", 3)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002896 tok_len = 3;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002897 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002898
2899 } else if (prev_function_check) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002900 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 +02002901 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 +02002902 ret = LY_EVALID;
Radek Krejcib1646a92018-11-02 16:08:26 +01002903 goto error;
2904 } else {
Michal Vasko774ce402021-04-14 15:35:06 +02002905 LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed], parsed + 1, expr_str);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002906 ret = LY_EVALID;
Radek Krejcib1646a92018-11-02 16:08:26 +01002907 goto error;
2908 }
Radek Krejcif03a9e22020-09-18 20:09:31 +02002909 } else if (expr_str[parsed] == '*') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002910
2911 /* NameTest '*' */
2912 tok_len = 1;
2913 tok_type = LYXP_TOKEN_NAMETEST;
2914
2915 } else {
2916
2917 /* NameTest (NCName ':' '*' | QName) or NodeType/FunctionName */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002918 long int ncname_len = parse_ncname(&expr_str[parsed]);
Michal Vaskoe2be5462021-08-04 10:49:42 +02002919 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 +02002920 parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002921 tok_len = ncname_len;
2922
Radek Krejcif03a9e22020-09-18 20:09:31 +02002923 if (expr_str[parsed + tok_len] == ':') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002924 ++tok_len;
Radek Krejcif03a9e22020-09-18 20:09:31 +02002925 if (expr_str[parsed + tok_len] == '*') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002926 ++tok_len;
2927 } else {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002928 ncname_len = parse_ncname(&expr_str[parsed + tok_len]);
Michal Vaskoe2be5462021-08-04 10:49:42 +02002929 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 +02002930 parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002931 tok_len += ncname_len;
2932 }
2933 /* remove old flag to prevent ambiguities */
2934 prev_function_check = 0;
2935 tok_type = LYXP_TOKEN_NAMETEST;
2936 } else {
2937 /* there is no prefix so it can still be NodeType/FunctionName, we can't finally decide now */
2938 prev_function_check = 1;
2939 tok_type = LYXP_TOKEN_NAMETEST;
2940 }
2941 }
2942
2943 /* store the token, move on to the next one */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002944 LY_CHECK_GOTO(ret = exp_add_token(ctx, expr, tok_type, parsed, tok_len), error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002945 parsed += tok_len;
Radek Krejcif03a9e22020-09-18 20:09:31 +02002946 while (is_xmlws(expr_str[parsed])) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002947 ++parsed;
2948 }
2949
Radek Krejcif03a9e22020-09-18 20:09:31 +02002950 } while (expr_str[parsed]);
Radek Krejcib1646a92018-11-02 16:08:26 +01002951
Michal Vasko004d3152020-06-11 19:59:22 +02002952 if (reparse) {
2953 /* prealloc repeat */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002954 expr->repeat = calloc(expr->size, sizeof *expr->repeat);
2955 LY_CHECK_ERR_GOTO(!expr->repeat, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002956
Michal Vasko004d3152020-06-11 19:59:22 +02002957 /* fill repeat */
aPiecekbf968d92021-05-27 14:35:05 +02002958 LY_CHECK_ERR_GOTO(reparse_or_expr(ctx, expr, &tok_idx, 0), ret = LY_EVALID, error);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002959 if (expr->used > tok_idx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002960 LOGVAL(ctx, LYVE_XPATH, "Unparsed characters \"%s\" left at the end of an XPath expression.",
Michal Vasko69730152020-10-09 16:30:07 +02002961 &expr->expr[expr->tok_pos[tok_idx]]);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002962 ret = LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +02002963 goto error;
2964 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02002965 }
2966
Radek Krejcif03a9e22020-09-18 20:09:31 +02002967 print_expr_struct_debug(expr);
2968 *expr_p = expr;
2969 return LY_SUCCESS;
Radek Krejcib1646a92018-11-02 16:08:26 +01002970
2971error:
Radek Krejcif03a9e22020-09-18 20:09:31 +02002972 lyxp_expr_free(ctx, expr);
2973 return ret;
Radek Krejcib1646a92018-11-02 16:08:26 +01002974}
2975
Michal Vasko1734be92020-09-22 08:55:10 +02002976LY_ERR
2977lyxp_expr_dup(const struct ly_ctx *ctx, const struct lyxp_expr *exp, struct lyxp_expr **dup_p)
Michal Vasko004d3152020-06-11 19:59:22 +02002978{
Michal Vasko1734be92020-09-22 08:55:10 +02002979 LY_ERR ret = LY_SUCCESS;
2980 struct lyxp_expr *dup = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02002981 uint32_t i, j;
2982
Michal Vasko7f45cf22020-10-01 12:49:44 +02002983 if (!exp) {
2984 goto cleanup;
2985 }
2986
Michal Vasko004d3152020-06-11 19:59:22 +02002987 dup = calloc(1, sizeof *dup);
Michal Vasko1734be92020-09-22 08:55:10 +02002988 LY_CHECK_ERR_GOTO(!dup, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02002989
Michal Vasko08e9b112021-06-11 15:41:17 +02002990 if (exp->used) {
2991 dup->tokens = malloc(exp->used * sizeof *dup->tokens);
2992 LY_CHECK_ERR_GOTO(!dup->tokens, LOGMEM(ctx); ret = LY_EMEM, cleanup);
2993 memcpy(dup->tokens, exp->tokens, exp->used * sizeof *dup->tokens);
Michal Vasko004d3152020-06-11 19:59:22 +02002994
Michal Vasko08e9b112021-06-11 15:41:17 +02002995 dup->tok_pos = malloc(exp->used * sizeof *dup->tok_pos);
2996 LY_CHECK_ERR_GOTO(!dup->tok_pos, LOGMEM(ctx); ret = LY_EMEM, cleanup);
2997 memcpy(dup->tok_pos, exp->tok_pos, exp->used * sizeof *dup->tok_pos);
Michal Vasko004d3152020-06-11 19:59:22 +02002998
Michal Vasko08e9b112021-06-11 15:41:17 +02002999 dup->tok_len = malloc(exp->used * sizeof *dup->tok_len);
3000 LY_CHECK_ERR_GOTO(!dup->tok_len, LOGMEM(ctx); ret = LY_EMEM, cleanup);
3001 memcpy(dup->tok_len, exp->tok_len, exp->used * sizeof *dup->tok_len);
Michal Vasko004d3152020-06-11 19:59:22 +02003002
Michal Vasko08e9b112021-06-11 15:41:17 +02003003 dup->repeat = malloc(exp->used * sizeof *dup->repeat);
3004 LY_CHECK_ERR_GOTO(!dup->repeat, LOGMEM(ctx); ret = LY_EMEM, cleanup);
3005 for (i = 0; i < exp->used; ++i) {
3006 if (!exp->repeat[i]) {
3007 dup->repeat[i] = NULL;
3008 } else {
3009 for (j = 0; exp->repeat[i][j]; ++j) {}
3010 /* the ending 0 as well */
3011 ++j;
Michal Vasko004d3152020-06-11 19:59:22 +02003012
Michal Vasko08e9b112021-06-11 15:41:17 +02003013 dup->repeat[i] = malloc(j * sizeof **dup->repeat);
3014 LY_CHECK_ERR_GOTO(!dup->repeat[i], LOGMEM(ctx); ret = LY_EMEM, cleanup);
3015 memcpy(dup->repeat[i], exp->repeat[i], j * sizeof **dup->repeat);
3016 dup->repeat[i][j - 1] = 0;
3017 }
Michal Vasko004d3152020-06-11 19:59:22 +02003018 }
3019 }
3020
3021 dup->used = exp->used;
3022 dup->size = exp->used;
Michal Vasko1734be92020-09-22 08:55:10 +02003023 LY_CHECK_GOTO(ret = lydict_insert(ctx, exp->expr, 0, &dup->expr), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02003024
Michal Vasko1734be92020-09-22 08:55:10 +02003025cleanup:
3026 if (ret) {
3027 lyxp_expr_free(ctx, dup);
3028 } else {
3029 *dup_p = dup;
3030 }
3031 return ret;
Michal Vasko004d3152020-06-11 19:59:22 +02003032}
3033
Michal Vasko03ff5a72019-09-11 13:49:33 +02003034/**
3035 * @brief Get the last-added schema node that is currently in the context.
3036 *
3037 * @param[in] set Set to search in.
3038 * @return Last-added schema context node, NULL if no node is in context.
3039 */
3040static struct lysc_node *
3041warn_get_scnode_in_ctx(struct lyxp_set *set)
3042{
3043 uint32_t i;
3044
3045 if (!set || (set->type != LYXP_SET_SCNODE_SET)) {
3046 return NULL;
3047 }
3048
3049 i = set->used;
3050 do {
3051 --i;
Radek Krejcif13b87b2020-12-01 22:02:17 +01003052 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003053 /* if there are more, simply return the first found (last added) */
3054 return set->val.scnodes[i].scnode;
3055 }
3056 } while (i);
3057
3058 return NULL;
3059}
3060
3061/**
3062 * @brief Test whether a type is numeric - integer type or decimal64.
3063 *
3064 * @param[in] type Type to test.
Radek Krejci857189e2020-09-01 13:26:36 +02003065 * @return Boolean value whether @p type is numeric type or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003066 */
Radek Krejci857189e2020-09-01 13:26:36 +02003067static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003068warn_is_numeric_type(struct lysc_type *type)
3069{
3070 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003071 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003072 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003073
3074 switch (type->basetype) {
3075 case LY_TYPE_DEC64:
3076 case LY_TYPE_INT8:
3077 case LY_TYPE_UINT8:
3078 case LY_TYPE_INT16:
3079 case LY_TYPE_UINT16:
3080 case LY_TYPE_INT32:
3081 case LY_TYPE_UINT32:
3082 case LY_TYPE_INT64:
3083 case LY_TYPE_UINT64:
3084 return 1;
3085 case LY_TYPE_UNION:
3086 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003087 LY_ARRAY_FOR(uni->types, u) {
3088 ret = warn_is_numeric_type(uni->types[u]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003089 if (ret) {
3090 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003091 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003092 }
3093 }
3094 /* did not find any suitable type */
3095 return 0;
3096 case LY_TYPE_LEAFREF:
3097 return warn_is_numeric_type(((struct lysc_type_leafref *)type)->realtype);
3098 default:
3099 return 0;
3100 }
3101}
3102
3103/**
3104 * @brief Test whether a type is string-like - no integers, decimal64 or binary.
3105 *
3106 * @param[in] type Type to test.
Radek Krejci857189e2020-09-01 13:26:36 +02003107 * @return Boolean value whether @p type's basetype is string type or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003108 */
Radek Krejci857189e2020-09-01 13:26:36 +02003109static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003110warn_is_string_type(struct lysc_type *type)
3111{
3112 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003113 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003114 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003115
3116 switch (type->basetype) {
3117 case LY_TYPE_BITS:
3118 case LY_TYPE_ENUM:
3119 case LY_TYPE_IDENT:
3120 case LY_TYPE_INST:
3121 case LY_TYPE_STRING:
3122 return 1;
3123 case LY_TYPE_UNION:
3124 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003125 LY_ARRAY_FOR(uni->types, u) {
3126 ret = warn_is_string_type(uni->types[u]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003127 if (ret) {
3128 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003129 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003130 }
3131 }
3132 /* did not find any suitable type */
3133 return 0;
3134 case LY_TYPE_LEAFREF:
3135 return warn_is_string_type(((struct lysc_type_leafref *)type)->realtype);
3136 default:
3137 return 0;
3138 }
3139}
3140
3141/**
3142 * @brief Test whether a type is one specific type.
3143 *
3144 * @param[in] type Type to test.
3145 * @param[in] base Expected type.
Radek Krejci857189e2020-09-01 13:26:36 +02003146 * @return Boolean value whether the given @p type is of the specific basetype @p base.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003147 */
Radek Krejci857189e2020-09-01 13:26:36 +02003148static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003149warn_is_specific_type(struct lysc_type *type, LY_DATA_TYPE base)
3150{
3151 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003152 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003153 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003154
3155 if (type->basetype == base) {
3156 return 1;
3157 } else if (type->basetype == LY_TYPE_UNION) {
3158 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003159 LY_ARRAY_FOR(uni->types, u) {
3160 ret = warn_is_specific_type(uni->types[u], base);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003161 if (ret) {
3162 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003163 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003164 }
3165 }
3166 /* did not find any suitable type */
3167 return 0;
3168 } else if (type->basetype == LY_TYPE_LEAFREF) {
3169 return warn_is_specific_type(((struct lysc_type_leafref *)type)->realtype, base);
3170 }
3171
3172 return 0;
3173}
3174
3175/**
3176 * @brief Get next type of a (union) type.
3177 *
3178 * @param[in] type Base type.
3179 * @param[in] prev_type Previously returned type.
3180 * @return Next type or NULL.
3181 */
3182static struct lysc_type *
3183warn_is_equal_type_next_type(struct lysc_type *type, struct lysc_type *prev_type)
3184{
3185 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003186 ly_bool found = 0;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003187 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003188
3189 switch (type->basetype) {
3190 case LY_TYPE_UNION:
3191 uni = (struct lysc_type_union *)type;
3192 if (!prev_type) {
3193 return uni->types[0];
3194 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003195 LY_ARRAY_FOR(uni->types, u) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003196 if (found) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003197 return uni->types[u];
Michal Vasko03ff5a72019-09-11 13:49:33 +02003198 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003199 if (prev_type == uni->types[u]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003200 found = 1;
3201 }
3202 }
3203 return NULL;
3204 default:
3205 if (prev_type) {
3206 assert(type == prev_type);
3207 return NULL;
3208 } else {
3209 return type;
3210 }
3211 }
3212}
3213
3214/**
3215 * @brief Test whether 2 types have a common type.
3216 *
3217 * @param[in] type1 First type.
3218 * @param[in] type2 Second type.
3219 * @return 1 if they do, 0 otherwise.
3220 */
3221static int
3222warn_is_equal_type(struct lysc_type *type1, struct lysc_type *type2)
3223{
3224 struct lysc_type *t1, *rt1, *t2, *rt2;
3225
3226 t1 = NULL;
3227 while ((t1 = warn_is_equal_type_next_type(type1, t1))) {
3228 if (t1->basetype == LY_TYPE_LEAFREF) {
3229 rt1 = ((struct lysc_type_leafref *)t1)->realtype;
3230 } else {
3231 rt1 = t1;
3232 }
3233
3234 t2 = NULL;
3235 while ((t2 = warn_is_equal_type_next_type(type2, t2))) {
3236 if (t2->basetype == LY_TYPE_LEAFREF) {
3237 rt2 = ((struct lysc_type_leafref *)t2)->realtype;
3238 } else {
3239 rt2 = t2;
3240 }
3241
3242 if (rt2->basetype == rt1->basetype) {
3243 /* match found */
3244 return 1;
3245 }
3246 }
3247 }
3248
3249 return 0;
3250}
3251
3252/**
Michal Vaskoaa956522021-11-11 10:45:34 +01003253 * @brief Print warning with information about the XPath subexpression that caused previous warning.
3254 *
3255 * @param[in] ctx Context for logging.
3256 * @param[in] tok_pos Index of the subexpression in the whole expression.
3257 * @param[in] subexpr Subexpression start.
3258 * @param[in] subexpr_len Length of @p subexpr to print.
3259 * @param[in] cur_scnode Expression context node.
3260 */
3261static void
3262warn_subexpr_log(const struct ly_ctx *ctx, uint16_t tok_pos, const char *subexpr, int subexpr_len,
3263 const struct lysc_node *cur_scnode)
3264{
3265 char *path;
3266
3267 path = lysc_path(cur_scnode, LYSC_PATH_LOG, NULL, 0);
3268 LOGWRN(ctx, "Previous warning generated by XPath subexpression[%" PRIu16 "] \"%.*s\" with context node \"%s\".",
3269 tok_pos, subexpr_len, subexpr, path);
3270 free(path);
3271}
3272
3273/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02003274 * @brief Check both operands of comparison operators.
3275 *
3276 * @param[in] ctx Context for errors.
3277 * @param[in] set1 First operand set.
3278 * @param[in] set2 Second operand set.
3279 * @param[in] numbers_only Whether accept only numbers or other types are fine too (for '=' and '!=').
3280 * @param[in] expr Start of the expression to print with the warning.
3281 * @param[in] tok_pos Token position.
3282 */
3283static void
Michal Vaskoaa956522021-11-11 10:45:34 +01003284warn_operands(struct ly_ctx *ctx, struct lyxp_set *set1, struct lyxp_set *set2, ly_bool numbers_only, const char *expr,
3285 uint16_t tok_pos)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003286{
3287 struct lysc_node_leaf *node1, *node2;
Radek Krejci857189e2020-09-01 13:26:36 +02003288 ly_bool leaves = 1, warning = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003289
3290 node1 = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set1);
3291 node2 = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set2);
3292
3293 if (!node1 && !node2) {
3294 /* no node-sets involved, nothing to do */
3295 return;
3296 }
3297
3298 if (node1) {
3299 if (!(node1->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3300 LOGWRN(ctx, "Node type %s \"%s\" used as operand.", lys_nodetype2str(node1->nodetype), node1->name);
3301 warning = 1;
3302 leaves = 0;
3303 } else if (numbers_only && !warn_is_numeric_type(node1->type)) {
3304 LOGWRN(ctx, "Node \"%s\" is not of a numeric type, but used where it was expected.", node1->name);
3305 warning = 1;
3306 }
3307 }
3308
3309 if (node2) {
3310 if (!(node2->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3311 LOGWRN(ctx, "Node type %s \"%s\" used as operand.", lys_nodetype2str(node2->nodetype), node2->name);
3312 warning = 1;
3313 leaves = 0;
3314 } else if (numbers_only && !warn_is_numeric_type(node2->type)) {
3315 LOGWRN(ctx, "Node \"%s\" is not of a numeric type, but used where it was expected.", node2->name);
3316 warning = 1;
3317 }
3318 }
3319
3320 if (node1 && node2 && leaves && !numbers_only) {
Michal Vasko69730152020-10-09 16:30:07 +02003321 if ((warn_is_numeric_type(node1->type) && !warn_is_numeric_type(node2->type)) ||
3322 (!warn_is_numeric_type(node1->type) && warn_is_numeric_type(node2->type)) ||
3323 (!warn_is_numeric_type(node1->type) && !warn_is_numeric_type(node2->type) &&
3324 !warn_is_equal_type(node1->type, node2->type))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003325 LOGWRN(ctx, "Incompatible types of operands \"%s\" and \"%s\" for comparison.", node1->name, node2->name);
3326 warning = 1;
3327 }
3328 }
3329
3330 if (warning) {
Michal Vaskoaa956522021-11-11 10:45:34 +01003331 warn_subexpr_log(ctx, tok_pos, expr + tok_pos, 20, set1->cur_scnode);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003332 }
3333}
3334
3335/**
3336 * @brief Check that a value is valid for a leaf. If not applicable, does nothing.
3337 *
3338 * @param[in] exp Parsed XPath expression.
3339 * @param[in] set Set with the leaf/leaf-list.
3340 * @param[in] val_exp Index of the value (literal/number) in @p exp.
3341 * @param[in] equal_exp Index of the start of the equality expression in @p exp.
3342 * @param[in] last_equal_exp Index of the end of the equality expression in @p exp.
3343 */
3344static void
Michal Vasko40308e72020-10-20 16:38:40 +02003345warn_equality_value(const struct lyxp_expr *exp, struct lyxp_set *set, uint16_t val_exp, uint16_t equal_exp,
3346 uint16_t last_equal_exp)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003347{
3348 struct lysc_node *scnode;
3349 struct lysc_type *type;
3350 char *value;
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003351 struct lyd_value storage;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003352 LY_ERR rc;
3353 struct ly_err_item *err = NULL;
3354
Michal Vasko69730152020-10-09 16:30:07 +02003355 if ((scnode = warn_get_scnode_in_ctx(set)) && (scnode->nodetype & (LYS_LEAF | LYS_LEAFLIST)) &&
3356 ((exp->tokens[val_exp] == LYXP_TOKEN_LITERAL) || (exp->tokens[val_exp] == LYXP_TOKEN_NUMBER))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003357 /* check that the node can have the specified value */
3358 if (exp->tokens[val_exp] == LYXP_TOKEN_LITERAL) {
3359 value = strndup(exp->expr + exp->tok_pos[val_exp] + 1, exp->tok_len[val_exp] - 2);
3360 } else {
3361 value = strndup(exp->expr + exp->tok_pos[val_exp], exp->tok_len[val_exp]);
3362 }
3363 if (!value) {
3364 LOGMEM(set->ctx);
3365 return;
3366 }
3367
3368 if ((((struct lysc_node_leaf *)scnode)->type->basetype == LY_TYPE_IDENT) && !strchr(value, ':')) {
3369 LOGWRN(set->ctx, "Identityref \"%s\" comparison with identity \"%s\" without prefix, consider adding"
Michal Vasko69730152020-10-09 16:30:07 +02003370 " a prefix or best using \"derived-from(-or-self)()\" functions.", scnode->name, value);
Michal Vaskoaa956522021-11-11 10:45:34 +01003371 warn_subexpr_log(set->ctx, exp->tok_pos[equal_exp], exp->expr + exp->tok_pos[equal_exp],
Radek Krejci0f969882020-08-21 16:56:47 +02003372 (exp->tok_pos[last_equal_exp] - exp->tok_pos[equal_exp]) + exp->tok_len[last_equal_exp],
Michal Vaskoaa956522021-11-11 10:45:34 +01003373 set->cur_scnode);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003374 }
3375
3376 type = ((struct lysc_node_leaf *)scnode)->type;
3377 if (type->basetype != LY_TYPE_IDENT) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003378 rc = type->plugin->store(set->ctx, type, value, strlen(value), 0, set->format, set->prefix_data,
Michal Vasko405cc9e2020-12-01 12:01:27 +01003379 LYD_HINT_DATA, scnode, &storage, NULL, &err);
Michal Vaskobf42e832020-11-23 16:59:42 +01003380 if (rc == LY_EINCOMPLETE) {
3381 rc = LY_SUCCESS;
3382 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003383
3384 if (err) {
3385 LOGWRN(set->ctx, "Invalid value \"%s\" which does not fit the type (%s).", value, err->msg);
3386 ly_err_free(err);
3387 } else if (rc != LY_SUCCESS) {
3388 LOGWRN(set->ctx, "Invalid value \"%s\" which does not fit the type.", value);
3389 }
3390 if (rc != LY_SUCCESS) {
Michal Vaskoaa956522021-11-11 10:45:34 +01003391 warn_subexpr_log(set->ctx, exp->tok_pos[equal_exp], exp->expr + exp->tok_pos[equal_exp],
Radek Krejci0f969882020-08-21 16:56:47 +02003392 (exp->tok_pos[last_equal_exp] - exp->tok_pos[equal_exp]) + exp->tok_len[last_equal_exp],
Michal Vaskoaa956522021-11-11 10:45:34 +01003393 set->cur_scnode);
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003394 } else {
3395 type->plugin->free(set->ctx, &storage);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003396 }
3397 }
3398 free(value);
3399 }
3400}
3401
3402/*
3403 * XPath functions
3404 */
3405
3406/**
3407 * @brief Execute the YANG 1.1 bit-is-set(node-set, string) function. Returns LYXP_SET_BOOLEAN
3408 * depending on whether the first node bit value from the second argument is set.
3409 *
3410 * @param[in] args Array of arguments.
3411 * @param[in] arg_count Count of elements in @p args.
3412 * @param[in,out] set Context and result set at the same time.
3413 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003414 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003415 */
3416static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003417xpath_bit_is_set(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003418{
3419 struct lyd_node_term *leaf;
3420 struct lysc_node_leaf *sleaf;
Michal Vasko2588b952021-07-29 07:43:26 +02003421 struct lyd_value_bits *bits;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003422 LY_ERR rc = LY_SUCCESS;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003423 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003424
3425 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003426 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003427 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko5676f4e2021-04-06 17:14:45 +02003428 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3429 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3430 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3431 sleaf->name);
3432 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_BITS)) {
3433 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"bits\".", __func__, sleaf->name);
3434 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003435 }
3436
3437 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
3438 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003439 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3440 sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003441 } else if (!warn_is_string_type(sleaf->type)) {
3442 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003443 }
3444 }
Michal Vasko1a09b212021-05-06 13:00:10 +02003445 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003446 return rc;
3447 }
3448
Michal Vaskod3678892020-05-21 10:06:58 +02003449 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003450 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 +02003451 return LY_EVALID;
3452 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003453 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003454 LY_CHECK_RET(rc);
3455
3456 set_fill_boolean(set, 0);
Michal Vaskod3678892020-05-21 10:06:58 +02003457 if (args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003458 leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
Michal Vasko2588b952021-07-29 07:43:26 +02003459 if ((leaf->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST)) && (leaf->value.realtype->basetype == LY_TYPE_BITS)) {
3460 LYD_VALUE_GET(&leaf->value, bits);
3461 LY_ARRAY_FOR(bits->items, u) {
3462 if (!strcmp(bits->items[u]->name, args[1]->val.str)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003463 set_fill_boolean(set, 1);
3464 break;
3465 }
3466 }
3467 }
3468 }
3469
3470 return LY_SUCCESS;
3471}
3472
3473/**
3474 * @brief Execute the XPath boolean(object) function. Returns LYXP_SET_BOOLEAN
3475 * with the argument converted to boolean.
3476 *
3477 * @param[in] args Array of arguments.
3478 * @param[in] arg_count Count of elements in @p args.
3479 * @param[in,out] set Context and result set at the same time.
3480 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003481 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003482 */
3483static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003484xpath_boolean(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003485{
3486 LY_ERR rc;
3487
3488 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02003489 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003490 return LY_SUCCESS;
3491 }
3492
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003493 rc = lyxp_set_cast(args[0], LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003494 LY_CHECK_RET(rc);
3495 set_fill_set(set, args[0]);
3496
3497 return LY_SUCCESS;
3498}
3499
3500/**
3501 * @brief Execute the XPath ceiling(number) function. Returns LYXP_SET_NUMBER
3502 * with the first argument rounded up to the nearest integer.
3503 *
3504 * @param[in] args Array of arguments.
3505 * @param[in] arg_count Count of elements in @p args.
3506 * @param[in,out] set Context and result set at the same time.
3507 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003508 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003509 */
3510static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003511xpath_ceiling(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003512{
3513 struct lysc_node_leaf *sleaf;
3514 LY_ERR rc = LY_SUCCESS;
3515
3516 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003517 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003518 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko5676f4e2021-04-06 17:14:45 +02003519 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3520 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3521 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3522 sleaf->name);
3523 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_DEC64)) {
3524 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"decimal64\".", __func__, sleaf->name);
3525 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003526 }
Michal Vasko1a09b212021-05-06 13:00:10 +02003527 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003528 return rc;
3529 }
3530
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003531 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003532 LY_CHECK_RET(rc);
3533 if ((long long)args[0]->val.num != args[0]->val.num) {
3534 set_fill_number(set, ((long long)args[0]->val.num) + 1);
3535 } else {
3536 set_fill_number(set, args[0]->val.num);
3537 }
3538
3539 return LY_SUCCESS;
3540}
3541
3542/**
3543 * @brief Execute the XPath concat(string, string, string*) function.
3544 * Returns LYXP_SET_STRING with the concatenation of all the arguments.
3545 *
3546 * @param[in] args Array of arguments.
3547 * @param[in] arg_count Count of elements in @p args.
3548 * @param[in,out] set Context and result set at the same time.
3549 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003550 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003551 */
3552static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003553xpath_concat(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003554{
3555 uint16_t i;
3556 char *str = NULL;
3557 size_t used = 1;
3558 LY_ERR rc = LY_SUCCESS;
3559 struct lysc_node_leaf *sleaf;
3560
3561 if (options & LYXP_SCNODE_ALL) {
3562 for (i = 0; i < arg_count; ++i) {
3563 if ((args[i]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[i]))) {
3564 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3565 LOGWRN(set->ctx, "Argument #%u of %s is a %s node \"%s\".",
Michal Vasko69730152020-10-09 16:30:07 +02003566 i + 1, __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003567 } else if (!warn_is_string_type(sleaf->type)) {
Radek Krejci70124c82020-08-14 22:17:03 +02003568 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 +02003569 }
3570 }
3571 }
Michal Vasko1a09b212021-05-06 13:00:10 +02003572 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003573 return rc;
3574 }
3575
3576 for (i = 0; i < arg_count; ++i) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003577 rc = lyxp_set_cast(args[i], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003578 if (rc != LY_SUCCESS) {
3579 free(str);
3580 return rc;
3581 }
3582
3583 str = ly_realloc(str, (used + strlen(args[i]->val.str)) * sizeof(char));
3584 LY_CHECK_ERR_RET(!str, LOGMEM(set->ctx), LY_EMEM);
3585 strcpy(str + used - 1, args[i]->val.str);
3586 used += strlen(args[i]->val.str);
3587 }
3588
3589 /* free, kind of */
Michal Vaskod3678892020-05-21 10:06:58 +02003590 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003591 set->type = LYXP_SET_STRING;
3592 set->val.str = str;
3593
3594 return LY_SUCCESS;
3595}
3596
3597/**
3598 * @brief Execute the XPath contains(string, string) function.
3599 * Returns LYXP_SET_BOOLEAN whether the second argument can
3600 * be found in the first or not.
3601 *
3602 * @param[in] args Array of arguments.
3603 * @param[in] arg_count Count of elements in @p args.
3604 * @param[in,out] set Context and result set at the same time.
3605 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003606 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003607 */
3608static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003609xpath_contains(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003610{
3611 struct lysc_node_leaf *sleaf;
3612 LY_ERR rc = LY_SUCCESS;
3613
3614 if (options & LYXP_SCNODE_ALL) {
3615 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3616 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003617 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3618 sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003619 } else if (!warn_is_string_type(sleaf->type)) {
3620 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003621 }
3622 }
3623
3624 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
3625 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003626 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3627 sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003628 } else if (!warn_is_string_type(sleaf->type)) {
3629 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003630 }
3631 }
Michal Vasko1a09b212021-05-06 13:00:10 +02003632 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003633 return rc;
3634 }
3635
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003636 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003637 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003638 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003639 LY_CHECK_RET(rc);
3640
3641 if (strstr(args[0]->val.str, args[1]->val.str)) {
3642 set_fill_boolean(set, 1);
3643 } else {
3644 set_fill_boolean(set, 0);
3645 }
3646
3647 return LY_SUCCESS;
3648}
3649
3650/**
3651 * @brief Execute the XPath count(node-set) function. Returns LYXP_SET_NUMBER
3652 * with the size of the node-set from the argument.
3653 *
3654 * @param[in] args Array of arguments.
3655 * @param[in] arg_count Count of elements in @p args.
3656 * @param[in,out] set Context and result set at the same time.
3657 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003658 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003659 */
3660static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003661xpath_count(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003662{
Michal Vasko03ff5a72019-09-11 13:49:33 +02003663 LY_ERR rc = LY_SUCCESS;
3664
3665 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003666 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003667 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003668 }
Michal Vasko1a09b212021-05-06 13:00:10 +02003669 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003670 return rc;
3671 }
3672
Michal Vasko03ff5a72019-09-11 13:49:33 +02003673 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003674 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "count(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02003675 return LY_EVALID;
3676 }
3677
3678 set_fill_number(set, args[0]->used);
3679 return LY_SUCCESS;
3680}
3681
3682/**
3683 * @brief Execute the XPath current() function. Returns LYXP_SET_NODE_SET
3684 * with the context with the intial node.
3685 *
3686 * @param[in] args Array of arguments.
3687 * @param[in] arg_count Count of elements in @p args.
3688 * @param[in,out] set Context and result set at the same time.
3689 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003690 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003691 */
3692static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003693xpath_current(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003694{
3695 if (arg_count || args) {
Radek Krejcie87c7dc2021-06-02 21:25:42 +02003696 LOGVAL(set->ctx, LY_VCODE_XP_INARGCOUNT, arg_count, LY_PRI_LENSTR("current()"));
Michal Vasko03ff5a72019-09-11 13:49:33 +02003697 return LY_EVALID;
3698 }
3699
3700 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02003701 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003702
Michal Vasko62b7f762021-12-13 16:57:42 +01003703 if (set->cur_scnode) {
3704 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, set->cur_scnode, LYXP_NODE_ELEM, NULL));
3705 } else {
3706 /* root node */
3707 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, NULL, set->root_type, NULL));
3708 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003709 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02003710 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003711
Michal Vasko62b7f762021-12-13 16:57:42 +01003712 if (set->cur_node) {
3713 /* position is filled later */
3714 set_insert_node(set, set->cur_node, 0, LYXP_NODE_ELEM, 0);
3715 } else {
3716 /* root node */
3717 set_insert_node(set, NULL, 0, set->root_type, 0);
3718 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003719 }
3720
3721 return LY_SUCCESS;
3722}
3723
3724/**
3725 * @brief Execute the YANG 1.1 deref(node-set) function. Returns LYXP_SET_NODE_SET with either
3726 * leafref or instance-identifier target node(s).
3727 *
3728 * @param[in] args Array of arguments.
3729 * @param[in] arg_count Count of elements in @p args.
3730 * @param[in,out] set Context and result set at the same time.
3731 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003732 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003733 */
3734static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003735xpath_deref(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003736{
3737 struct lyd_node_term *leaf;
Michal Vasko42e497c2020-01-06 08:38:25 +01003738 struct lysc_node_leaf *sleaf = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02003739 struct lysc_type_leafref *lref;
Michal Vaskoae9e4cb2019-09-25 08:43:05 +02003740 const struct lysc_node *target;
Michal Vasko004d3152020-06-11 19:59:22 +02003741 struct ly_path *p;
3742 struct lyd_node *node;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003743 char *errmsg = NULL;
Michal Vasko00cbf532020-06-15 13:58:47 +02003744 uint8_t oper;
Michal Vasko741bb562021-06-24 11:59:50 +02003745 LY_ERR r;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003746
3747 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003748 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003749 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko5676f4e2021-04-06 17:14:45 +02003750 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
Michal Vasko423ba3f2021-07-19 13:08:50 +02003751 if (!(sleaf->nodetype & LYD_NODE_TERM)) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003752 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3753 sleaf->name);
Michal Vaskoed725d72021-06-23 12:03:45 +02003754 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_LEAFREF) &&
3755 !warn_is_specific_type(sleaf->type, LY_TYPE_INST)) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003756 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"leafref\" nor \"instance-identifier\".",
3757 __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 Vasko423ba3f2021-07-19 13:08:50 +02003761 if (sleaf && (sleaf->nodetype & LYD_NODE_TERM) && (sleaf->type->basetype == LY_TYPE_LEAFREF)) {
Michal Vasko004d3152020-06-11 19:59:22 +02003762 lref = (struct lysc_type_leafref *)sleaf->type;
Michal Vaskod1e53b92021-01-28 13:11:06 +01003763 oper = (sleaf->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Michal Vasko004d3152020-06-11 19:59:22 +02003764
3765 /* it was already evaluated on schema, it must succeed */
Michal Vasko741bb562021-06-24 11:59:50 +02003766 r = ly_path_compile_leafref(set->ctx, &sleaf->node, NULL, lref->path, oper, LY_PATH_TARGET_MANY,
Michal Vasko24fc4d12021-07-12 14:41:20 +02003767 LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &p);
Michal Vasko741bb562021-06-24 11:59:50 +02003768 if (!r) {
3769 /* get the target node */
3770 target = p[LY_ARRAY_COUNT(p) - 1].node;
3771 ly_path_free(set->ctx, p);
Michal Vasko004d3152020-06-11 19:59:22 +02003772
Michal Vasko741bb562021-06-24 11:59:50 +02003773 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, target, LYXP_NODE_ELEM, NULL));
3774 } /* else the target was found before but is disabled so it was removed */
Michal Vaskoae9e4cb2019-09-25 08:43:05 +02003775 }
3776
Michal Vasko741bb562021-06-24 11:59:50 +02003777 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003778 }
3779
Michal Vaskod3678892020-05-21 10:06:58 +02003780 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003781 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "deref(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02003782 return LY_EVALID;
3783 }
3784
Michal Vaskod3678892020-05-21 10:06:58 +02003785 lyxp_set_free_content(set);
3786 if (args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003787 leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
3788 sleaf = (struct lysc_node_leaf *)leaf->schema;
3789 if (sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
3790 if (sleaf->type->basetype == LY_TYPE_LEAFREF) {
3791 /* find leafref target */
Radek Krejci0b013302021-03-29 15:22:32 +02003792 if (lyplg_type_resolve_leafref((struct lysc_type_leafref *)sleaf->type, &leaf->node, &leaf->value, set->tree,
Michal Vasko9e685082021-01-29 14:49:09 +01003793 &node, &errmsg)) {
Michal Vasko004d3152020-06-11 19:59:22 +02003794 LOGERR(set->ctx, LY_EVALID, errmsg);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003795 free(errmsg);
Michal Vasko004d3152020-06-11 19:59:22 +02003796 return LY_EVALID;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003797 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003798 } else {
3799 assert(sleaf->type->basetype == LY_TYPE_INST);
Michal Vasko004d3152020-06-11 19:59:22 +02003800 if (ly_path_eval(leaf->value.target, set->tree, &node)) {
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003801 LOGERR(set->ctx, LY_EVALID, "Invalid instance-identifier \"%s\" value - required instance not found.",
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02003802 lyd_get_value(&leaf->node));
Michal Vasko03ff5a72019-09-11 13:49:33 +02003803 return LY_EVALID;
3804 }
3805 }
Michal Vasko004d3152020-06-11 19:59:22 +02003806
3807 /* insert it */
3808 set_insert_node(set, node, 0, LYXP_NODE_ELEM, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003809 }
3810 }
3811
3812 return LY_SUCCESS;
3813}
3814
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003815static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003816xpath_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 +02003817{
Michal Vasko1fdd8fa2021-01-08 09:21:45 +01003818 uint32_t i;
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003819 LY_ARRAY_COUNT_TYPE u;
3820 struct lyd_node_term *leaf;
3821 struct lysc_node_leaf *sleaf;
3822 struct lyd_meta *meta;
Michal Vasko93923692021-05-07 15:28:02 +02003823 struct lyd_value *val;
3824 const struct lys_module *mod;
3825 const char *id_name;
3826 uint16_t id_len;
3827 struct lysc_ident *id;
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003828 LY_ERR rc = LY_SUCCESS;
Radek Krejci857189e2020-09-01 13:26:36 +02003829 ly_bool found;
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003830
3831 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003832 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003833 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", func);
Michal Vasko5676f4e2021-04-06 17:14:45 +02003834 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3835 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3836 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", func, lys_nodetype2str(sleaf->nodetype),
3837 sleaf->name);
3838 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_IDENT)) {
3839 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"identityref\".", func, sleaf->name);
3840 }
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003841 }
3842
3843 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
3844 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3845 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", func, lys_nodetype2str(sleaf->nodetype),
Michal Vasko69730152020-10-09 16:30:07 +02003846 sleaf->name);
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003847 } else if (!warn_is_string_type(sleaf->type)) {
3848 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", func, sleaf->name);
3849 }
3850 }
Michal Vasko1a09b212021-05-06 13:00:10 +02003851 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003852 return rc;
3853 }
3854
3855 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003856 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 +02003857 return LY_EVALID;
3858 }
3859 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
3860 LY_CHECK_RET(rc);
3861
Michal Vasko93923692021-05-07 15:28:02 +02003862 /* parse the identity */
3863 id_name = args[1]->val.str;
3864 id_len = strlen(id_name);
3865 rc = moveto_resolve_model(&id_name, &id_len, set, set->cur_node ? set->cur_node->schema : NULL, &mod);
3866 LY_CHECK_RET(rc);
3867 if (!mod) {
3868 LOGVAL(set->ctx, LYVE_XPATH, "Identity \"%.*s\" without a prefix.", (int)id_len, id_name);
3869 return LY_EVALID;
3870 }
3871
3872 /* find the identity */
3873 found = 0;
3874 LY_ARRAY_FOR(mod->identities, u) {
3875 if (!ly_strncmp(mod->identities[u].name, id_name, id_len)) {
3876 /* we have match */
3877 found = 1;
3878 break;
3879 }
3880 }
3881 if (!found) {
3882 LOGVAL(set->ctx, LYVE_XPATH, "Identity \"%.*s\" not found in module \"%s\".", (int)id_len, id_name, mod->name);
3883 return LY_EVALID;
3884 }
3885 id = &mod->identities[u];
3886
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003887 set_fill_boolean(set, 0);
3888 found = 0;
3889 for (i = 0; i < args[0]->used; ++i) {
3890 if ((args[0]->val.nodes[i].type != LYXP_NODE_ELEM) && (args[0]->val.nodes[i].type != LYXP_NODE_META)) {
3891 continue;
3892 }
3893
3894 if (args[0]->val.nodes[i].type == LYXP_NODE_ELEM) {
3895 leaf = (struct lyd_node_term *)args[0]->val.nodes[i].node;
3896 sleaf = (struct lysc_node_leaf *)leaf->schema;
3897 val = &leaf->value;
3898 if (!(sleaf->nodetype & LYD_NODE_TERM) || (leaf->value.realtype->basetype != LY_TYPE_IDENT)) {
3899 /* uninteresting */
3900 continue;
3901 }
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003902 } else {
3903 meta = args[0]->val.meta[i].meta;
3904 val = &meta->value;
3905 if (val->realtype->basetype != LY_TYPE_IDENT) {
3906 /* uninteresting */
3907 continue;
3908 }
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003909 }
3910
Michal Vasko93923692021-05-07 15:28:02 +02003911 /* check the identity itself */
3912 if (self_match && (id == val->ident)) {
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003913 set_fill_boolean(set, 1);
3914 found = 1;
3915 }
Michal Vasko93923692021-05-07 15:28:02 +02003916 if (!found && !lyplg_type_identity_isderived(id, val->ident)) {
3917 set_fill_boolean(set, 1);
3918 found = 1;
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003919 }
3920
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003921 if (found) {
3922 break;
3923 }
3924 }
3925
3926 return LY_SUCCESS;
3927}
3928
Michal Vasko03ff5a72019-09-11 13:49:33 +02003929/**
3930 * @brief Execute the YANG 1.1 derived-from(node-set, string) function. Returns LYXP_SET_BOOLEAN depending
3931 * on whether the first argument nodes contain a node of an identity derived from the second
3932 * argument identity.
3933 *
3934 * @param[in] args Array of arguments.
3935 * @param[in] arg_count Count of elements in @p args.
3936 * @param[in,out] set Context and result set at the same time.
3937 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003938 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003939 */
3940static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003941xpath_derived_from(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003942{
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003943 return xpath_derived_(args, set, options, 0, __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003944}
3945
3946/**
3947 * @brief Execute the YANG 1.1 derived-from-or-self(node-set, string) function. Returns LYXP_SET_BOOLEAN depending
3948 * on whether the first argument nodes contain a node of an identity that either is or is derived from
3949 * the second argument identity.
3950 *
3951 * @param[in] args Array of arguments.
3952 * @param[in] arg_count Count of elements in @p args.
3953 * @param[in,out] set Context and result set at the same time.
3954 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003955 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003956 */
3957static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003958xpath_derived_from_or_self(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003959{
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003960 return xpath_derived_(args, set, options, 1, __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003961}
3962
3963/**
3964 * @brief Execute the YANG 1.1 enum-value(node-set) function. Returns LYXP_SET_NUMBER
3965 * with the integer value of the first node's enum value, otherwise NaN.
3966 *
3967 * @param[in] args Array of arguments.
3968 * @param[in] arg_count Count of elements in @p args.
3969 * @param[in,out] set Context and result set at the same time.
3970 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003971 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003972 */
3973static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003974xpath_enum_value(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003975{
3976 struct lyd_node_term *leaf;
3977 struct lysc_node_leaf *sleaf;
3978 LY_ERR rc = LY_SUCCESS;
3979
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]))) {
3984 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3985 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3986 sleaf->name);
3987 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_ENUM)) {
3988 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"enumeration\".", __func__, sleaf->name);
3989 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003990 }
Michal Vasko1a09b212021-05-06 13:00:10 +02003991 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003992 return rc;
3993 }
3994
Michal Vaskod3678892020-05-21 10:06:58 +02003995 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003996 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "enum-value(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02003997 return LY_EVALID;
3998 }
3999
4000 set_fill_number(set, NAN);
Michal Vaskod3678892020-05-21 10:06:58 +02004001 if (args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004002 leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
4003 sleaf = (struct lysc_node_leaf *)leaf->schema;
4004 if ((sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST)) && (sleaf->type->basetype == LY_TYPE_ENUM)) {
4005 set_fill_number(set, leaf->value.enum_item->value);
4006 }
4007 }
4008
4009 return LY_SUCCESS;
4010}
4011
4012/**
4013 * @brief Execute the XPath false() function. Returns LYXP_SET_BOOLEAN
4014 * with false value.
4015 *
4016 * @param[in] args Array of arguments.
4017 * @param[in] arg_count Count of elements in @p args.
4018 * @param[in,out] set Context and result set at the same time.
4019 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004020 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004021 */
4022static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004023xpath_false(struct lyxp_set **UNUSED(args), uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004024{
4025 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004026 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004027 return LY_SUCCESS;
4028 }
4029
4030 set_fill_boolean(set, 0);
4031 return LY_SUCCESS;
4032}
4033
4034/**
4035 * @brief Execute the XPath floor(number) function. Returns LYXP_SET_NUMBER
4036 * with the first argument floored (truncated).
4037 *
4038 * @param[in] args Array of arguments.
4039 * @param[in] arg_count Count of elements in @p args.
4040 * @param[in,out] set Context and result set at the same time.
4041 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004042 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004043 */
4044static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004045xpath_floor(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t UNUSED(options))
Michal Vasko03ff5a72019-09-11 13:49:33 +02004046{
4047 LY_ERR rc;
4048
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004049 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004050 LY_CHECK_RET(rc);
4051 if (isfinite(args[0]->val.num)) {
4052 set_fill_number(set, (long long)args[0]->val.num);
4053 }
4054
4055 return LY_SUCCESS;
4056}
4057
4058/**
4059 * @brief Execute the XPath lang(string) function. Returns LYXP_SET_BOOLEAN
4060 * whether the language of the text matches the one from the argument.
4061 *
4062 * @param[in] args Array of arguments.
4063 * @param[in] arg_count Count of elements in @p args.
4064 * @param[in,out] set Context and result set at the same time.
4065 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004066 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004067 */
4068static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004069xpath_lang(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004070{
4071 const struct lyd_node *node;
4072 struct lysc_node_leaf *sleaf;
Michal Vasko9f96a052020-03-10 09:41:45 +01004073 struct lyd_meta *meta = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004074 const char *val;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004075 LY_ERR rc = LY_SUCCESS;
4076
4077 if (options & LYXP_SCNODE_ALL) {
4078 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4079 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004080 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
4081 sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004082 } else if (!warn_is_string_type(sleaf->type)) {
4083 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004084 }
4085 }
Michal Vasko1a09b212021-05-06 13:00:10 +02004086 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004087 return rc;
4088 }
4089
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004090 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004091 LY_CHECK_RET(rc);
4092
Michal Vasko03ff5a72019-09-11 13:49:33 +02004093 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004094 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "lang(string)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004095 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004096 } else if (!set->used) {
4097 set_fill_boolean(set, 0);
4098 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004099 }
4100
4101 switch (set->val.nodes[0].type) {
4102 case LYXP_NODE_ELEM:
4103 case LYXP_NODE_TEXT:
4104 node = set->val.nodes[0].node;
4105 break;
Michal Vasko9f96a052020-03-10 09:41:45 +01004106 case LYXP_NODE_META:
4107 node = set->val.meta[0].meta->parent;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004108 break;
4109 default:
4110 /* nothing to do with roots */
4111 set_fill_boolean(set, 0);
4112 return LY_SUCCESS;
4113 }
4114
Michal Vasko9f96a052020-03-10 09:41:45 +01004115 /* find lang metadata */
Michal Vasko9e685082021-01-29 14:49:09 +01004116 for ( ; node; node = lyd_parent(node)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01004117 for (meta = node->meta; meta; meta = meta->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004118 /* annotations */
Michal Vasko9f96a052020-03-10 09:41:45 +01004119 if (meta->name && !strcmp(meta->name, "lang") && !strcmp(meta->annotation->module->name, "xml")) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004120 break;
4121 }
4122 }
4123
Michal Vasko9f96a052020-03-10 09:41:45 +01004124 if (meta) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004125 break;
4126 }
4127 }
4128
4129 /* compare languages */
Michal Vasko9f96a052020-03-10 09:41:45 +01004130 if (!meta) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004131 set_fill_boolean(set, 0);
4132 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004133 uint64_t i;
4134
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02004135 val = lyd_get_meta_value(meta);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004136 for (i = 0; args[0]->val.str[i]; ++i) {
4137 if (tolower(args[0]->val.str[i]) != tolower(val[i])) {
4138 set_fill_boolean(set, 0);
4139 break;
4140 }
4141 }
4142 if (!args[0]->val.str[i]) {
4143 if (!val[i] || (val[i] == '-')) {
4144 set_fill_boolean(set, 1);
4145 } else {
4146 set_fill_boolean(set, 0);
4147 }
4148 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004149 }
4150
4151 return LY_SUCCESS;
4152}
4153
4154/**
4155 * @brief Execute the XPath last() function. Returns LYXP_SET_NUMBER
4156 * with the context size.
4157 *
4158 * @param[in] args Array of arguments.
4159 * @param[in] arg_count Count of elements in @p args.
4160 * @param[in,out] set Context and result set at the same time.
4161 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004162 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004163 */
4164static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004165xpath_last(struct lyxp_set **UNUSED(args), uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004166{
4167 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004168 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004169 return LY_SUCCESS;
4170 }
4171
Michal Vasko03ff5a72019-09-11 13:49:33 +02004172 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004173 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "last()");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004174 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004175 } else if (!set->used) {
4176 set_fill_number(set, 0);
4177 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004178 }
4179
4180 set_fill_number(set, set->ctx_size);
4181 return LY_SUCCESS;
4182}
4183
4184/**
4185 * @brief Execute the XPath local-name(node-set?) function. Returns LYXP_SET_STRING
4186 * with the node name without namespace from the argument or the context.
4187 *
4188 * @param[in] args Array of arguments.
4189 * @param[in] arg_count Count of elements in @p args.
4190 * @param[in,out] set Context and result set at the same time.
4191 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004192 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004193 */
4194static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004195xpath_local_name(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004196{
4197 struct lyxp_set_node *item;
Michal Vasko69730152020-10-09 16:30:07 +02004198
Michal Vasko03ff5a72019-09-11 13:49:33 +02004199 /* suppress unused variable warning */
4200 (void)options;
4201
4202 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004203 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004204 return LY_SUCCESS;
4205 }
4206
4207 if (arg_count) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004208 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004209 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]),
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004210 "local-name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004211 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004212 } else if (!args[0]->used) {
4213 set_fill_string(set, "", 0);
4214 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004215 }
4216
4217 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004218 assert(!set_sort(args[0]));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004219
4220 item = &args[0]->val.nodes[0];
4221 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004222 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004223 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "local-name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004224 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004225 } else if (!set->used) {
4226 set_fill_string(set, "", 0);
4227 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004228 }
4229
4230 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004231 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004232
4233 item = &set->val.nodes[0];
4234 }
4235
4236 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01004237 case LYXP_NODE_NONE:
4238 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004239 case LYXP_NODE_ROOT:
4240 case LYXP_NODE_ROOT_CONFIG:
4241 case LYXP_NODE_TEXT:
4242 set_fill_string(set, "", 0);
4243 break;
4244 case LYXP_NODE_ELEM:
4245 set_fill_string(set, item->node->schema->name, strlen(item->node->schema->name));
4246 break;
Michal Vasko9f96a052020-03-10 09:41:45 +01004247 case LYXP_NODE_META:
4248 set_fill_string(set, ((struct lyd_meta *)item->node)->name, strlen(((struct lyd_meta *)item->node)->name));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004249 break;
4250 }
4251
4252 return LY_SUCCESS;
4253}
4254
4255/**
4256 * @brief Execute the XPath name(node-set?) function. Returns LYXP_SET_STRING
4257 * with the node name fully qualified (with namespace) from the argument or the context.
4258 *
4259 * @param[in] args Array of arguments.
4260 * @param[in] arg_count Count of elements in @p args.
4261 * @param[in,out] set Context and result set at the same time.
4262 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004263 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004264 */
4265static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004266xpath_name(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004267{
4268 struct lyxp_set_node *item;
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02004269 struct lys_module *mod = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004270 char *str;
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02004271 const char *name = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004272
4273 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004274 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004275 return LY_SUCCESS;
4276 }
4277
4278 if (arg_count) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004279 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004280 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004281 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004282 } else if (!args[0]->used) {
4283 set_fill_string(set, "", 0);
4284 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004285 }
4286
4287 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004288 assert(!set_sort(args[0]));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004289
4290 item = &args[0]->val.nodes[0];
4291 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004292 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004293 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004294 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004295 } else if (!set->used) {
4296 set_fill_string(set, "", 0);
4297 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004298 }
4299
4300 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004301 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004302
4303 item = &set->val.nodes[0];
4304 }
4305
4306 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01004307 case LYXP_NODE_NONE:
4308 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004309 case LYXP_NODE_ROOT:
4310 case LYXP_NODE_ROOT_CONFIG:
4311 case LYXP_NODE_TEXT:
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02004312 /* keep NULL */
Michal Vasko03ff5a72019-09-11 13:49:33 +02004313 break;
4314 case LYXP_NODE_ELEM:
4315 mod = item->node->schema->module;
4316 name = item->node->schema->name;
4317 break;
Michal Vasko9f96a052020-03-10 09:41:45 +01004318 case LYXP_NODE_META:
4319 mod = ((struct lyd_meta *)item->node)->annotation->module;
4320 name = ((struct lyd_meta *)item->node)->name;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004321 break;
4322 }
4323
4324 if (mod && name) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004325 int rc = asprintf(&str, "%s:%s", ly_get_prefix(mod, set->format, set->prefix_data), name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004326 LY_CHECK_ERR_RET(rc == -1, LOGMEM(set->ctx), LY_EMEM);
4327 set_fill_string(set, str, strlen(str));
4328 free(str);
4329 } else {
4330 set_fill_string(set, "", 0);
4331 }
4332
4333 return LY_SUCCESS;
4334}
4335
4336/**
4337 * @brief Execute the XPath namespace-uri(node-set?) function. Returns LYXP_SET_STRING
4338 * with the namespace of the node from the argument or the context.
4339 *
4340 * @param[in] args Array of arguments.
4341 * @param[in] arg_count Count of elements in @p args.
4342 * @param[in,out] set Context and result set at the same time.
4343 * @param[in] options XPath options.
4344 * @return LY_ERR (LY_EINVAL for wrong arguments on schema)
4345 */
4346static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004347xpath_namespace_uri(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004348{
4349 struct lyxp_set_node *item;
4350 struct lys_module *mod;
Michal Vasko69730152020-10-09 16:30:07 +02004351
Michal Vasko03ff5a72019-09-11 13:49:33 +02004352 /* suppress unused variable warning */
4353 (void)options;
4354
4355 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004356 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004357 return LY_SUCCESS;
4358 }
4359
4360 if (arg_count) {
Michal Vaskod3678892020-05-21 10:06:58 +02004361 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004362 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]),
Michal Vasko69730152020-10-09 16:30:07 +02004363 "namespace-uri(node-set?)");
Michal Vaskod3678892020-05-21 10:06:58 +02004364 return LY_EVALID;
4365 } else if (!args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004366 set_fill_string(set, "", 0);
4367 return LY_SUCCESS;
4368 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004369
4370 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004371 assert(!set_sort(args[0]));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004372
4373 item = &args[0]->val.nodes[0];
4374 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004375 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004376 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "namespace-uri(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004377 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004378 } else if (!set->used) {
4379 set_fill_string(set, "", 0);
4380 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004381 }
4382
4383 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004384 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004385
4386 item = &set->val.nodes[0];
4387 }
4388
4389 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01004390 case LYXP_NODE_NONE:
4391 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004392 case LYXP_NODE_ROOT:
4393 case LYXP_NODE_ROOT_CONFIG:
4394 case LYXP_NODE_TEXT:
4395 set_fill_string(set, "", 0);
4396 break;
4397 case LYXP_NODE_ELEM:
Michal Vasko9f96a052020-03-10 09:41:45 +01004398 case LYXP_NODE_META:
Michal Vasko03ff5a72019-09-11 13:49:33 +02004399 if (item->type == LYXP_NODE_ELEM) {
4400 mod = item->node->schema->module;
Michal Vasko9f96a052020-03-10 09:41:45 +01004401 } else { /* LYXP_NODE_META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02004402 /* annotations */
Michal Vasko9f96a052020-03-10 09:41:45 +01004403 mod = ((struct lyd_meta *)item->node)->annotation->module;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004404 }
4405
4406 set_fill_string(set, mod->ns, strlen(mod->ns));
4407 break;
4408 }
4409
4410 return LY_SUCCESS;
4411}
4412
4413/**
4414 * @brief Execute the XPath node() function (node type). Returns LYXP_SET_NODE_SET
4415 * with only nodes from the context. In practice it either leaves the context
4416 * as it is or returns an empty node set.
4417 *
4418 * @param[in] args Array of arguments.
4419 * @param[in] arg_count Count of elements in @p args.
4420 * @param[in,out] set Context and result set at the same time.
4421 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004422 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004423 */
4424static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004425xpath_node(struct lyxp_set **UNUSED(args), uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004426{
4427 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004428 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004429 return LY_SUCCESS;
4430 }
4431
4432 if (set->type != LYXP_SET_NODE_SET) {
Michal Vaskod3678892020-05-21 10:06:58 +02004433 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004434 }
4435 return LY_SUCCESS;
4436}
4437
4438/**
4439 * @brief Execute the XPath normalize-space(string?) function. Returns LYXP_SET_STRING
4440 * with normalized value (no leading, trailing, double white spaces) of the node
4441 * from the argument or the context.
4442 *
4443 * @param[in] args Array of arguments.
4444 * @param[in] arg_count Count of elements in @p args.
4445 * @param[in,out] set Context and result set at the same time.
4446 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004447 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004448 */
4449static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004450xpath_normalize_space(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004451{
4452 uint16_t i, new_used;
4453 char *new;
Radek Krejci857189e2020-09-01 13:26:36 +02004454 ly_bool have_spaces = 0, space_before = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004455 struct lysc_node_leaf *sleaf;
4456 LY_ERR rc = LY_SUCCESS;
4457
4458 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004459 if (arg_count && (args[0]->type == LYXP_SET_SCNODE_SET) &&
4460 (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004461 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004462 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
4463 sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004464 } else if (!warn_is_string_type(sleaf->type)) {
4465 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004466 }
4467 }
Michal Vasko1a09b212021-05-06 13:00:10 +02004468 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004469 return rc;
4470 }
4471
4472 if (arg_count) {
4473 set_fill_set(set, args[0]);
4474 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004475 rc = lyxp_set_cast(set, LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004476 LY_CHECK_RET(rc);
4477
4478 /* is there any normalization necessary? */
4479 for (i = 0; set->val.str[i]; ++i) {
4480 if (is_xmlws(set->val.str[i])) {
4481 if ((i == 0) || space_before || (!set->val.str[i + 1])) {
4482 have_spaces = 1;
4483 break;
4484 }
4485 space_before = 1;
4486 } else {
4487 space_before = 0;
4488 }
4489 }
4490
4491 /* yep, there is */
4492 if (have_spaces) {
4493 /* it's enough, at least one character will go, makes space for ending '\0' */
4494 new = malloc(strlen(set->val.str) * sizeof(char));
4495 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
4496 new_used = 0;
4497
4498 space_before = 0;
4499 for (i = 0; set->val.str[i]; ++i) {
4500 if (is_xmlws(set->val.str[i])) {
4501 if ((i == 0) || space_before) {
4502 space_before = 1;
4503 continue;
4504 } else {
4505 space_before = 1;
4506 }
4507 } else {
4508 space_before = 0;
4509 }
4510
4511 new[new_used] = (space_before ? ' ' : set->val.str[i]);
4512 ++new_used;
4513 }
4514
4515 /* at worst there is one trailing space now */
4516 if (new_used && is_xmlws(new[new_used - 1])) {
4517 --new_used;
4518 }
4519
4520 new = ly_realloc(new, (new_used + 1) * sizeof(char));
4521 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
4522 new[new_used] = '\0';
4523
4524 free(set->val.str);
4525 set->val.str = new;
4526 }
4527
4528 return LY_SUCCESS;
4529}
4530
4531/**
4532 * @brief Execute the XPath not(boolean) function. Returns LYXP_SET_BOOLEAN
4533 * with the argument converted to boolean and logically inverted.
4534 *
4535 * @param[in] args Array of arguments.
4536 * @param[in] arg_count Count of elements in @p args.
4537 * @param[in,out] set Context and result set at the same time.
4538 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004539 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004540 */
4541static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004542xpath_not(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004543{
4544 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004545 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004546 return LY_SUCCESS;
4547 }
4548
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004549 lyxp_set_cast(args[0], LYXP_SET_BOOLEAN);
Michal Vasko004d3152020-06-11 19:59:22 +02004550 if (args[0]->val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004551 set_fill_boolean(set, 0);
4552 } else {
4553 set_fill_boolean(set, 1);
4554 }
4555
4556 return LY_SUCCESS;
4557}
4558
4559/**
4560 * @brief Execute the XPath number(object?) function. Returns LYXP_SET_NUMBER
4561 * with the number representation of either the argument or the context.
4562 *
4563 * @param[in] args Array of arguments.
4564 * @param[in] arg_count Count of elements in @p args.
4565 * @param[in,out] set Context and result set at the same time.
4566 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004567 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004568 */
4569static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004570xpath_number(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004571{
4572 LY_ERR rc;
4573
4574 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004575 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004576 return LY_SUCCESS;
4577 }
4578
4579 if (arg_count) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004580 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004581 LY_CHECK_RET(rc);
4582 set_fill_set(set, args[0]);
4583 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004584 rc = lyxp_set_cast(set, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004585 LY_CHECK_RET(rc);
4586 }
4587
4588 return LY_SUCCESS;
4589}
4590
4591/**
4592 * @brief Execute the XPath position() function. Returns LYXP_SET_NUMBER
4593 * with the context position.
4594 *
4595 * @param[in] args Array of arguments.
4596 * @param[in] arg_count Count of elements in @p args.
4597 * @param[in,out] set Context and result set at the same time.
4598 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004599 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004600 */
4601static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004602xpath_position(struct lyxp_set **UNUSED(args), uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004603{
4604 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004605 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004606 return LY_SUCCESS;
4607 }
4608
Michal Vasko03ff5a72019-09-11 13:49:33 +02004609 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004610 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "position()");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004611 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004612 } else if (!set->used) {
4613 set_fill_number(set, 0);
4614 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004615 }
4616
4617 set_fill_number(set, set->ctx_pos);
4618
4619 /* UNUSED in 'Release' build type */
4620 (void)options;
4621 return LY_SUCCESS;
4622}
4623
4624/**
4625 * @brief Execute the YANG 1.1 re-match(string, string) function. Returns LYXP_SET_BOOLEAN
4626 * depending on whether the second argument regex matches the first argument string. For details refer to
4627 * YANG 1.1 RFC section 10.2.1.
4628 *
4629 * @param[in] args Array of arguments.
4630 * @param[in] arg_count Count of elements in @p args.
4631 * @param[in,out] set Context and result set at the same time.
4632 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004633 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004634 */
4635static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004636xpath_re_match(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004637{
4638 struct lysc_pattern **patterns = NULL, **pattern;
4639 struct lysc_node_leaf *sleaf;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004640 LY_ERR rc = LY_SUCCESS;
4641 struct ly_err_item *err;
4642
4643 if (options & LYXP_SCNODE_ALL) {
4644 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4645 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4646 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 +02004647 } else if (!warn_is_string_type(sleaf->type)) {
4648 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004649 }
4650 }
4651
4652 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4653 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4654 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 +02004655 } else if (!warn_is_string_type(sleaf->type)) {
4656 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004657 }
4658 }
Michal Vasko1a09b212021-05-06 13:00:10 +02004659 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004660 return rc;
4661 }
4662
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004663 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004664 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004665 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004666 LY_CHECK_RET(rc);
4667
4668 LY_ARRAY_NEW_RET(set->ctx, patterns, pattern, LY_EMEM);
Radek IÅ¡a45802b52021-02-09 09:21:58 +01004669 *pattern = calloc(1, sizeof **pattern);
Radek Krejciddace2c2021-01-08 11:30:56 +01004670 LOG_LOCSET(NULL, set->cur_node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01004671 rc = lys_compile_type_pattern_check(set->ctx, args[1]->val.str, &(*pattern)->code);
Michal Vasko0245d502021-12-13 17:05:06 +01004672 if (set->cur_node) {
4673 LOG_LOCBACK(0, 1, 0, 0);
4674 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004675 if (rc != LY_SUCCESS) {
4676 LY_ARRAY_FREE(patterns);
4677 return rc;
4678 }
4679
Radek Krejci0b013302021-03-29 15:22:32 +02004680 rc = lyplg_type_validate_patterns(patterns, args[0]->val.str, strlen(args[0]->val.str), &err);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004681 pcre2_code_free((*pattern)->code);
4682 free(*pattern);
4683 LY_ARRAY_FREE(patterns);
4684 if (rc && (rc != LY_EVALID)) {
Michal Vasko177d0ed2020-11-23 16:43:03 +01004685 ly_err_print(set->ctx, err);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004686 ly_err_free(err);
4687 return rc;
4688 }
4689
4690 if (rc == LY_EVALID) {
4691 ly_err_free(err);
4692 set_fill_boolean(set, 0);
4693 } else {
4694 set_fill_boolean(set, 1);
4695 }
4696
4697 return LY_SUCCESS;
4698}
4699
4700/**
4701 * @brief Execute the XPath round(number) function. Returns LYXP_SET_NUMBER
4702 * with the rounded first argument. For details refer to
4703 * http://www.w3.org/TR/1999/REC-xpath-19991116/#function-round.
4704 *
4705 * @param[in] args Array of arguments.
4706 * @param[in] arg_count Count of elements in @p args.
4707 * @param[in,out] set Context and result set at the same time.
4708 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004709 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004710 */
4711static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004712xpath_round(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004713{
4714 struct lysc_node_leaf *sleaf;
4715 LY_ERR rc = LY_SUCCESS;
4716
4717 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02004718 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004719 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko5676f4e2021-04-06 17:14:45 +02004720 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4721 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4722 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
4723 sleaf->name);
4724 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_DEC64)) {
4725 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"decimal64\".", __func__, sleaf->name);
4726 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004727 }
Michal Vasko1a09b212021-05-06 13:00:10 +02004728 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004729 return rc;
4730 }
4731
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004732 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004733 LY_CHECK_RET(rc);
4734
4735 /* cover only the cases where floor can't be used */
4736 if ((args[0]->val.num == -0.0f) || ((args[0]->val.num < 0) && (args[0]->val.num >= -0.5))) {
4737 set_fill_number(set, -0.0f);
4738 } else {
4739 args[0]->val.num += 0.5;
4740 rc = xpath_floor(args, 1, args[0], options);
4741 LY_CHECK_RET(rc);
4742 set_fill_number(set, args[0]->val.num);
4743 }
4744
4745 return LY_SUCCESS;
4746}
4747
4748/**
4749 * @brief Execute the XPath starts-with(string, string) function.
4750 * Returns LYXP_SET_BOOLEAN whether the second argument is
4751 * the prefix of the first or not.
4752 *
4753 * @param[in] args Array of arguments.
4754 * @param[in] arg_count Count of elements in @p args.
4755 * @param[in,out] set Context and result set at the same time.
4756 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004757 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004758 */
4759static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004760xpath_starts_with(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004761{
4762 struct lysc_node_leaf *sleaf;
4763 LY_ERR rc = LY_SUCCESS;
4764
4765 if (options & LYXP_SCNODE_ALL) {
4766 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4767 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4768 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 +02004769 } else if (!warn_is_string_type(sleaf->type)) {
4770 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004771 }
4772 }
4773
4774 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4775 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4776 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 +02004777 } else if (!warn_is_string_type(sleaf->type)) {
4778 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004779 }
4780 }
Michal Vasko1a09b212021-05-06 13:00:10 +02004781 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004782 return rc;
4783 }
4784
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004785 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004786 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004787 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004788 LY_CHECK_RET(rc);
4789
4790 if (strncmp(args[0]->val.str, args[1]->val.str, strlen(args[1]->val.str))) {
4791 set_fill_boolean(set, 0);
4792 } else {
4793 set_fill_boolean(set, 1);
4794 }
4795
4796 return LY_SUCCESS;
4797}
4798
4799/**
4800 * @brief Execute the XPath string(object?) function. Returns LYXP_SET_STRING
4801 * with the string representation of either the argument or the context.
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
Radek Krejci1deb5be2020-08-26 16:43:36 +02004810xpath_string(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004811{
4812 LY_ERR rc;
4813
4814 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02004815 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004816 return LY_SUCCESS;
4817 }
4818
4819 if (arg_count) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004820 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004821 LY_CHECK_RET(rc);
4822 set_fill_set(set, args[0]);
4823 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004824 rc = lyxp_set_cast(set, LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004825 LY_CHECK_RET(rc);
4826 }
4827
4828 return LY_SUCCESS;
4829}
4830
4831/**
4832 * @brief Execute the XPath string-length(string?) function. Returns LYXP_SET_NUMBER
4833 * with the length of the string in either the argument or the context.
4834 *
4835 * @param[in] args Array of arguments.
4836 * @param[in] arg_count Count of elements in @p args.
4837 * @param[in,out] set Context and result set at the same time.
4838 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004839 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004840 */
4841static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004842xpath_string_length(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004843{
4844 struct lysc_node_leaf *sleaf;
4845 LY_ERR rc = LY_SUCCESS;
4846
4847 if (options & LYXP_SCNODE_ALL) {
4848 if (arg_count && (args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4849 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4850 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 +02004851 } else if (!warn_is_string_type(sleaf->type)) {
4852 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004853 }
4854 }
4855 if (!arg_count && (set->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set))) {
4856 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4857 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 +02004858 } else if (!warn_is_string_type(sleaf->type)) {
4859 LOGWRN(set->ctx, "Argument #0 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004860 }
4861 }
Michal Vasko1a09b212021-05-06 13:00:10 +02004862 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004863 return rc;
4864 }
4865
4866 if (arg_count) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004867 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004868 LY_CHECK_RET(rc);
4869 set_fill_number(set, strlen(args[0]->val.str));
4870 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004871 rc = lyxp_set_cast(set, LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004872 LY_CHECK_RET(rc);
4873 set_fill_number(set, strlen(set->val.str));
4874 }
4875
4876 return LY_SUCCESS;
4877}
4878
4879/**
4880 * @brief Execute the XPath substring(string, number, number?) function.
4881 * Returns LYXP_SET_STRING substring of the first argument starting
4882 * on the second argument index ending on the third argument index,
4883 * indexed from 1. For exact definition refer to
4884 * http://www.w3.org/TR/1999/REC-xpath-19991116/#function-substring.
4885 *
4886 * @param[in] args Array of arguments.
4887 * @param[in] arg_count Count of elements in @p args.
4888 * @param[in,out] set Context and result set at the same time.
4889 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004890 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004891 */
4892static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004893xpath_substring(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004894{
Radek Krejci1deb5be2020-08-26 16:43:36 +02004895 int32_t start, len;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004896 uint16_t str_start, str_len, pos;
4897 struct lysc_node_leaf *sleaf;
4898 LY_ERR rc = LY_SUCCESS;
4899
4900 if (options & LYXP_SCNODE_ALL) {
4901 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4902 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4903 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 +02004904 } else if (!warn_is_string_type(sleaf->type)) {
4905 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004906 }
4907 }
4908
4909 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4910 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4911 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 +02004912 } else if (!warn_is_numeric_type(sleaf->type)) {
4913 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004914 }
4915 }
4916
Michal Vasko69730152020-10-09 16:30:07 +02004917 if ((arg_count == 3) && (args[2]->type == LYXP_SET_SCNODE_SET) &&
4918 (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[2]))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004919 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4920 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 +02004921 } else if (!warn_is_numeric_type(sleaf->type)) {
4922 LOGWRN(set->ctx, "Argument #3 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004923 }
4924 }
Michal Vasko1a09b212021-05-06 13:00:10 +02004925 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004926 return rc;
4927 }
4928
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004929 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004930 LY_CHECK_RET(rc);
4931
4932 /* start */
4933 if (xpath_round(&args[1], 1, args[1], options)) {
4934 return -1;
4935 }
4936 if (isfinite(args[1]->val.num)) {
4937 start = args[1]->val.num - 1;
4938 } else if (isinf(args[1]->val.num) && signbit(args[1]->val.num)) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004939 start = INT32_MIN;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004940 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004941 start = INT32_MAX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004942 }
4943
4944 /* len */
4945 if (arg_count == 3) {
4946 rc = xpath_round(&args[2], 1, args[2], options);
4947 LY_CHECK_RET(rc);
Radek Krejci1deb5be2020-08-26 16:43:36 +02004948 if (isnan(args[2]->val.num) || signbit(args[2]->val.num)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004949 len = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02004950 } else if (isfinite(args[2]->val.num)) {
4951 len = args[2]->val.num;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004952 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004953 len = INT32_MAX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004954 }
4955 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004956 len = INT32_MAX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004957 }
4958
4959 /* find matching character positions */
4960 str_start = 0;
4961 str_len = 0;
4962 for (pos = 0; args[0]->val.str[pos]; ++pos) {
4963 if (pos < start) {
4964 ++str_start;
4965 } else if (pos < start + len) {
4966 ++str_len;
4967 } else {
4968 break;
4969 }
4970 }
4971
4972 set_fill_string(set, args[0]->val.str + str_start, str_len);
4973 return LY_SUCCESS;
4974}
4975
4976/**
4977 * @brief Execute the XPath substring-after(string, string) function.
4978 * Returns LYXP_SET_STRING with the string succeeding the occurance
4979 * of the second argument in the first or an empty string.
4980 *
4981 * @param[in] args Array of arguments.
4982 * @param[in] arg_count Count of elements in @p args.
4983 * @param[in,out] set Context and result set at the same time.
4984 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004985 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004986 */
4987static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004988xpath_substring_after(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004989{
4990 char *ptr;
4991 struct lysc_node_leaf *sleaf;
4992 LY_ERR rc = LY_SUCCESS;
4993
4994 if (options & LYXP_SCNODE_ALL) {
4995 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4996 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4997 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 +02004998 } else if (!warn_is_string_type(sleaf->type)) {
4999 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005000 }
5001 }
5002
5003 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
5004 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5005 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 +02005006 } else if (!warn_is_string_type(sleaf->type)) {
5007 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005008 }
5009 }
Michal Vasko1a09b212021-05-06 13:00:10 +02005010 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005011 return rc;
5012 }
5013
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005014 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005015 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005016 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005017 LY_CHECK_RET(rc);
5018
5019 ptr = strstr(args[0]->val.str, args[1]->val.str);
5020 if (ptr) {
5021 set_fill_string(set, ptr + strlen(args[1]->val.str), strlen(ptr + strlen(args[1]->val.str)));
5022 } else {
5023 set_fill_string(set, "", 0);
5024 }
5025
5026 return LY_SUCCESS;
5027}
5028
5029/**
5030 * @brief Execute the XPath substring-before(string, string) function.
5031 * Returns LYXP_SET_STRING with the string preceding the occurance
5032 * of the second argument in the first or an empty string.
5033 *
5034 * @param[in] args Array of arguments.
5035 * @param[in] arg_count Count of elements in @p args.
5036 * @param[in,out] set Context and result set at the same time.
5037 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005038 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005039 */
5040static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005041xpath_substring_before(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005042{
5043 char *ptr;
5044 struct lysc_node_leaf *sleaf;
5045 LY_ERR rc = LY_SUCCESS;
5046
5047 if (options & LYXP_SCNODE_ALL) {
5048 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
5049 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5050 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 +02005051 } else if (!warn_is_string_type(sleaf->type)) {
5052 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005053 }
5054 }
5055
5056 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
5057 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5058 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 +02005059 } else if (!warn_is_string_type(sleaf->type)) {
5060 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005061 }
5062 }
Michal Vasko1a09b212021-05-06 13:00:10 +02005063 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005064 return rc;
5065 }
5066
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005067 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005068 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005069 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005070 LY_CHECK_RET(rc);
5071
5072 ptr = strstr(args[0]->val.str, args[1]->val.str);
5073 if (ptr) {
5074 set_fill_string(set, args[0]->val.str, ptr - args[0]->val.str);
5075 } else {
5076 set_fill_string(set, "", 0);
5077 }
5078
5079 return LY_SUCCESS;
5080}
5081
5082/**
5083 * @brief Execute the XPath sum(node-set) function. Returns LYXP_SET_NUMBER
5084 * with the sum of all the nodes in the context.
5085 *
5086 * @param[in] args Array of arguments.
5087 * @param[in] arg_count Count of elements in @p args.
5088 * @param[in,out] set Context and result set at the same time.
5089 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005090 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005091 */
5092static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005093xpath_sum(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005094{
5095 long double num;
5096 char *str;
Michal Vasko1fdd8fa2021-01-08 09:21:45 +01005097 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005098 struct lyxp_set set_item;
5099 struct lysc_node_leaf *sleaf;
5100 LY_ERR rc = LY_SUCCESS;
5101
5102 if (options & LYXP_SCNODE_ALL) {
5103 if (args[0]->type == LYXP_SET_SCNODE_SET) {
5104 for (i = 0; i < args[0]->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005105 if (args[0]->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005106 sleaf = (struct lysc_node_leaf *)args[0]->val.scnodes[i].scnode;
5107 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5108 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__,
Michal Vasko69730152020-10-09 16:30:07 +02005109 lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005110 } else if (!warn_is_numeric_type(sleaf->type)) {
5111 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005112 }
5113 }
5114 }
5115 }
Michal Vasko1a09b212021-05-06 13:00:10 +02005116 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005117 return rc;
5118 }
5119
5120 set_fill_number(set, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005121
5122 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005123 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "sum(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02005124 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02005125 } else if (!args[0]->used) {
5126 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005127 }
5128
Michal Vasko5c4e5892019-11-14 12:31:38 +01005129 set_init(&set_item, set);
5130
Michal Vasko03ff5a72019-09-11 13:49:33 +02005131 set_item.type = LYXP_SET_NODE_SET;
Michal Vasko41decbf2021-11-02 11:50:21 +01005132 set_item.val.nodes = calloc(1, sizeof *set_item.val.nodes);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005133 LY_CHECK_ERR_RET(!set_item.val.nodes, LOGMEM(set->ctx), LY_EMEM);
5134
5135 set_item.used = 1;
5136 set_item.size = 1;
5137
5138 for (i = 0; i < args[0]->used; ++i) {
5139 set_item.val.nodes[0] = args[0]->val.nodes[i];
5140
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005141 rc = cast_node_set_to_string(&set_item, &str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005142 LY_CHECK_RET(rc);
5143 num = cast_string_to_number(str);
5144 free(str);
5145 set->val.num += num;
5146 }
5147
5148 free(set_item.val.nodes);
5149
5150 return LY_SUCCESS;
5151}
5152
5153/**
5154 * @brief Execute the XPath text() function (node type). Returns LYXP_SET_NODE_SET
5155 * with the text content of the nodes in the context.
5156 *
5157 * @param[in] args Array of arguments.
5158 * @param[in] arg_count Count of elements in @p args.
5159 * @param[in,out] set Context and result set at the same time.
5160 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005161 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005162 */
5163static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005164xpath_text(struct lyxp_set **UNUSED(args), uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005165{
5166 uint32_t i;
5167
5168 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02005169 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005170 return LY_SUCCESS;
5171 }
5172
Michal Vasko03ff5a72019-09-11 13:49:33 +02005173 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005174 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "text()");
Michal Vasko03ff5a72019-09-11 13:49:33 +02005175 return LY_EVALID;
5176 }
5177
Michal Vaskod989ba02020-08-24 10:59:24 +02005178 for (i = 0; i < set->used; ) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005179 switch (set->val.nodes[i].type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01005180 case LYXP_NODE_NONE:
5181 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005182 case LYXP_NODE_ELEM:
Michal Vasko03ff5a72019-09-11 13:49:33 +02005183 if (set->val.nodes[i].node->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
5184 set->val.nodes[i].type = LYXP_NODE_TEXT;
5185 ++i;
5186 break;
5187 }
Radek Krejci0f969882020-08-21 16:56:47 +02005188 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005189 case LYXP_NODE_ROOT:
5190 case LYXP_NODE_ROOT_CONFIG:
5191 case LYXP_NODE_TEXT:
Michal Vasko9f96a052020-03-10 09:41:45 +01005192 case LYXP_NODE_META:
Michal Vasko03ff5a72019-09-11 13:49:33 +02005193 set_remove_node(set, i);
5194 break;
5195 }
5196 }
5197
5198 return LY_SUCCESS;
5199}
5200
5201/**
5202 * @brief Execute the XPath translate(string, string, string) function.
5203 * Returns LYXP_SET_STRING with the first argument with the characters
5204 * from the second argument replaced by those on the corresponding
5205 * positions in the third argument.
5206 *
5207 * @param[in] args Array of arguments.
5208 * @param[in] arg_count Count of elements in @p args.
5209 * @param[in,out] set Context and result set at the same time.
5210 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005211 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005212 */
5213static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005214xpath_translate(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005215{
5216 uint16_t i, j, new_used;
5217 char *new;
Radek Krejci857189e2020-09-01 13:26:36 +02005218 ly_bool have_removed;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005219 struct lysc_node_leaf *sleaf;
5220 LY_ERR rc = LY_SUCCESS;
5221
5222 if (options & LYXP_SCNODE_ALL) {
5223 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
5224 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5225 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 +02005226 } else if (!warn_is_string_type(sleaf->type)) {
5227 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005228 }
5229 }
5230
5231 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
5232 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5233 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 +02005234 } else if (!warn_is_string_type(sleaf->type)) {
5235 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005236 }
5237 }
5238
5239 if ((args[2]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[2]))) {
5240 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5241 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 +02005242 } else if (!warn_is_string_type(sleaf->type)) {
5243 LOGWRN(set->ctx, "Argument #3 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005244 }
5245 }
Michal Vasko1a09b212021-05-06 13:00:10 +02005246 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005247 return rc;
5248 }
5249
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005250 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005251 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005252 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005253 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005254 rc = lyxp_set_cast(args[2], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005255 LY_CHECK_RET(rc);
5256
5257 new = malloc((strlen(args[0]->val.str) + 1) * sizeof(char));
5258 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
5259 new_used = 0;
5260
5261 have_removed = 0;
5262 for (i = 0; args[0]->val.str[i]; ++i) {
Radek Krejci857189e2020-09-01 13:26:36 +02005263 ly_bool found = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005264
5265 for (j = 0; args[1]->val.str[j]; ++j) {
5266 if (args[0]->val.str[i] == args[1]->val.str[j]) {
5267 /* removing this char */
5268 if (j >= strlen(args[2]->val.str)) {
5269 have_removed = 1;
5270 found = 1;
5271 break;
5272 }
5273 /* replacing this char */
5274 new[new_used] = args[2]->val.str[j];
5275 ++new_used;
5276 found = 1;
5277 break;
5278 }
5279 }
5280
5281 /* copying this char */
5282 if (!found) {
5283 new[new_used] = args[0]->val.str[i];
5284 ++new_used;
5285 }
5286 }
5287
5288 if (have_removed) {
5289 new = ly_realloc(new, (new_used + 1) * sizeof(char));
5290 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
5291 }
5292 new[new_used] = '\0';
5293
Michal Vaskod3678892020-05-21 10:06:58 +02005294 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005295 set->type = LYXP_SET_STRING;
5296 set->val.str = new;
5297
5298 return LY_SUCCESS;
5299}
5300
5301/**
5302 * @brief Execute the XPath true() function. Returns LYXP_SET_BOOLEAN
5303 * with true value.
5304 *
5305 * @param[in] args Array of arguments.
5306 * @param[in] arg_count Count of elements in @p args.
5307 * @param[in,out] set Context and result set at the same time.
5308 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005309 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005310 */
5311static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005312xpath_true(struct lyxp_set **UNUSED(args), uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005313{
5314 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02005315 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005316 return LY_SUCCESS;
5317 }
5318
5319 set_fill_boolean(set, 1);
5320 return LY_SUCCESS;
5321}
5322
Michal Vasko03ff5a72019-09-11 13:49:33 +02005323/**
Michal Vasko6346ece2019-09-24 13:12:53 +02005324 * @brief Skip prefix and return corresponding model if there is a prefix. Logs directly.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005325 *
Michal Vasko2104e9f2020-03-06 08:23:25 +01005326 * XPath @p set is expected to be a (sc)node set!
5327 *
Michal Vasko6346ece2019-09-24 13:12:53 +02005328 * @param[in,out] qname Qualified node name. If includes prefix, it is skipped.
5329 * @param[in,out] qname_len Length of @p qname, is updated accordingly.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005330 * @param[in] set Set with general XPath context.
5331 * @param[in] ctx_scnode Context node to inherit module for unprefixed node for ::LY_PREF_JSON.
Michal Vasko6346ece2019-09-24 13:12:53 +02005332 * @param[out] moveto_mod Expected module of a matching node.
5333 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005334 */
Michal Vasko6346ece2019-09-24 13:12:53 +02005335static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005336moveto_resolve_model(const char **qname, uint16_t *qname_len, const struct lyxp_set *set,
5337 const struct lysc_node *ctx_scnode, const struct lys_module **moveto_mod)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005338{
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02005339 const struct lys_module *mod = NULL;
Michal Vasko6346ece2019-09-24 13:12:53 +02005340 const char *ptr;
Radek Krejci1deb5be2020-08-26 16:43:36 +02005341 size_t pref_len;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005342
Michal Vasko2104e9f2020-03-06 08:23:25 +01005343 assert((set->type == LYXP_SET_NODE_SET) || (set->type == LYXP_SET_SCNODE_SET));
5344
Michal Vasko6346ece2019-09-24 13:12:53 +02005345 if ((ptr = ly_strnchr(*qname, ':', *qname_len))) {
5346 /* specific module */
5347 pref_len = ptr - *qname;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005348 mod = ly_resolve_prefix(set->ctx, *qname, pref_len, set->format, set->prefix_data);
Michal Vasko6346ece2019-09-24 13:12:53 +02005349
Michal Vasko004d3152020-06-11 19:59:22 +02005350 /* check for errors and non-implemented modules, as they are not valid */
Juraj Vijtiukd75faa62019-11-26 14:10:10 +01005351 if (!mod || !mod->implemented) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005352 LOGVAL(set->ctx, LY_VCODE_XP_INMOD, pref_len, *qname);
Michal Vasko6346ece2019-09-24 13:12:53 +02005353 return LY_EVALID;
5354 }
Juraj Vijtiukd75faa62019-11-26 14:10:10 +01005355
Michal Vasko6346ece2019-09-24 13:12:53 +02005356 *qname += pref_len + 1;
5357 *qname_len -= pref_len + 1;
5358 } else if (((*qname)[0] == '*') && (*qname_len == 1)) {
5359 /* all modules - special case */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005360 mod = NULL;
Michal Vasko6346ece2019-09-24 13:12:53 +02005361 } else {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005362 switch (set->format) {
Radek Krejci8df109d2021-04-23 12:19:08 +02005363 case LY_VALUE_SCHEMA:
5364 case LY_VALUE_SCHEMA_RESOLVED:
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005365 /* current module */
5366 mod = set->cur_mod;
5367 break;
Radek Krejci224d4b42021-04-23 13:54:59 +02005368 case LY_VALUE_CANON:
Radek Krejci8df109d2021-04-23 12:19:08 +02005369 case LY_VALUE_JSON:
Radek Krejcif9943642021-04-26 10:18:21 +02005370 case LY_VALUE_LYB:
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005371 /* inherit parent (context node) module */
5372 if (ctx_scnode) {
5373 mod = ctx_scnode->module;
5374 } else {
5375 mod = NULL;
5376 }
5377 break;
Radek Krejci8df109d2021-04-23 12:19:08 +02005378 case LY_VALUE_XML:
Michal Vasko52143d12021-04-14 15:36:39 +02005379 /* all nodes need to be prefixed */
5380 LOGVAL(set->ctx, LYVE_DATA, "Non-prefixed node \"%.*s\" in XML xpath found.", *qname_len, *qname);
5381 return LY_EVALID;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005382 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005383 }
5384
Michal Vasko6346ece2019-09-24 13:12:53 +02005385 *moveto_mod = mod;
5386 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005387}
5388
5389/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02005390 * @brief Move context @p set to the root. Handles absolute path.
5391 * Result is LYXP_SET_NODE_SET.
5392 *
5393 * @param[in,out] set Set to use.
5394 * @param[in] options Xpath options.
Michal Vaskob0099a92020-08-31 14:55:23 +02005395 * @return LY_ERR value.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005396 */
Michal Vaskob0099a92020-08-31 14:55:23 +02005397static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005398moveto_root(struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005399{
aPiecek8b0cc152021-05-31 16:40:31 +02005400 assert(!(options & LYXP_SKIP_EXPR));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005401
5402 if (options & LYXP_SCNODE_ALL) {
Michal Vasko1a09b212021-05-06 13:00:10 +02005403 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vaskob0099a92020-08-31 14:55:23 +02005404 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, NULL, set->root_type, NULL));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005405 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02005406 set->type = LYXP_SET_NODE_SET;
5407 set->used = 0;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005408 set_insert_node(set, NULL, 0, set->root_type, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005409 }
Michal Vaskob0099a92020-08-31 14:55:23 +02005410
5411 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005412}
5413
5414/**
5415 * @brief Check @p node as a part of NameTest processing.
5416 *
5417 * @param[in] node Node to check.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005418 * @param[in] set Set to read general context from.
Michal Vaskod3678892020-05-21 10:06:58 +02005419 * @param[in] node_name Node name in the dictionary to move to, NULL for any node.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005420 * @param[in] moveto_mod Expected module of the node, NULL for no prefix.
Michal Vaskocdad7122020-11-09 21:04:44 +01005421 * @param[in] options XPath options.
Michal Vasko6346ece2019-09-24 13:12:53 +02005422 * @return LY_ERR (LY_ENOT if node does not match, LY_EINCOMPLETE on unresolved when,
5423 * LY_EINVAL if netither node nor any children match)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005424 */
5425static LY_ERR
Michal Vaskodb08ce52021-10-06 08:57:49 +02005426moveto_node_check(const struct lyd_node *node, const struct lyxp_set *set, const char *node_name,
5427 const struct lys_module *moveto_mod, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005428{
Michal Vaskodca9f122021-07-16 13:56:22 +02005429 if (!node->schema) {
5430 /* opaque node never matches */
5431 return LY_ENOT;
5432 }
5433
Michal Vasko03ff5a72019-09-11 13:49:33 +02005434 /* module check */
5435 if (moveto_mod && (node->schema->module != moveto_mod)) {
Michal Vasko6346ece2019-09-24 13:12:53 +02005436 return LY_ENOT;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005437 }
5438
Michal Vasko5c4e5892019-11-14 12:31:38 +01005439 /* context check */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005440 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (node->schema->flags & LYS_CONFIG_R)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005441 return LY_EINVAL;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005442 } else if (set->context_op && (node->schema->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) &&
5443 (node->schema != set->context_op)) {
Michal Vasko6b26e742020-07-17 15:02:10 +02005444 return LY_EINVAL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005445 }
5446
5447 /* name check */
Michal Vasko61ac2f62020-05-25 12:39:51 +02005448 if (node_name && strcmp(node_name, "*") && (node->schema->name != node_name)) {
Michal Vasko6346ece2019-09-24 13:12:53 +02005449 return LY_ENOT;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005450 }
5451
Michal Vaskoa1424542019-11-14 16:08:52 +01005452 /* when check */
Michal Vaskod5cfa6e2020-11-23 16:56:08 +01005453 if (!(options & LYXP_IGNORE_WHEN) && lysc_has_when(node->schema) && !(node->flags & LYD_WHEN_TRUE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005454 return LY_EINCOMPLETE;
Michal Vaskoa1424542019-11-14 16:08:52 +01005455 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005456
5457 /* match */
5458 return LY_SUCCESS;
5459}
5460
5461/**
5462 * @brief Check @p node as a part of schema NameTest processing.
5463 *
5464 * @param[in] node Schema node to check.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005465 * @param[in] ctx_scnode Context node.
5466 * @param[in] set Set to read general context from.
Michal Vaskod3678892020-05-21 10:06:58 +02005467 * @param[in] node_name Node name in the dictionary to move to, NULL for any nodes.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005468 * @param[in] moveto_mod Expected module of the node, NULL for no prefix.
Michal Vasko6346ece2019-09-24 13:12:53 +02005469 * @return LY_ERR (LY_ENOT if node does not match, LY_EINVAL if neither node nor any children match)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005470 */
5471static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005472moveto_scnode_check(const struct lysc_node *node, const struct lysc_node *ctx_scnode, const struct lyxp_set *set,
Radek Krejci0f969882020-08-21 16:56:47 +02005473 const char *node_name, const struct lys_module *moveto_mod)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005474{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005475 if (!moveto_mod && (!node_name || strcmp(node_name, "*"))) {
5476 switch (set->format) {
Radek Krejci8df109d2021-04-23 12:19:08 +02005477 case LY_VALUE_SCHEMA:
5478 case LY_VALUE_SCHEMA_RESOLVED:
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005479 /* use current module */
5480 moveto_mod = set->cur_mod;
5481 break;
Radek Krejci8df109d2021-04-23 12:19:08 +02005482 case LY_VALUE_JSON:
Radek Krejcif9943642021-04-26 10:18:21 +02005483 case LY_VALUE_LYB:
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005484 /* inherit module of the context node, if any */
5485 if (ctx_scnode) {
5486 moveto_mod = ctx_scnode->module;
5487 }
5488 break;
Radek Krejci224d4b42021-04-23 13:54:59 +02005489 case LY_VALUE_CANON:
Radek Krejci8df109d2021-04-23 12:19:08 +02005490 case LY_VALUE_XML:
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005491 /* not defined */
5492 LOGINT(set->ctx);
5493 return LY_EINVAL;
5494 }
5495 }
5496
Michal Vasko03ff5a72019-09-11 13:49:33 +02005497 /* module check */
Michal Vaskod3678892020-05-21 10:06:58 +02005498 if (moveto_mod && (node->module != moveto_mod)) {
Michal Vasko6346ece2019-09-24 13:12:53 +02005499 return LY_ENOT;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005500 }
5501
5502 /* context check */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005503 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (node->flags & LYS_CONFIG_R)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005504 return LY_EINVAL;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005505 } else if (set->context_op && (node->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) && (node != set->context_op)) {
Michal Vasko6b26e742020-07-17 15:02:10 +02005506 return LY_EINVAL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005507 }
5508
5509 /* name check */
Michal Vasko61ac2f62020-05-25 12:39:51 +02005510 if (node_name && strcmp(node_name, "*") && (node->name != node_name)) {
Michal Vasko6346ece2019-09-24 13:12:53 +02005511 return LY_ENOT;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005512 }
5513
5514 /* match */
5515 return LY_SUCCESS;
5516}
5517
5518/**
Michal Vaskod3678892020-05-21 10:06:58 +02005519 * @brief Move context @p set to a node. Result is LYXP_SET_NODE_SET (or LYXP_SET_EMPTY). Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005520 *
5521 * @param[in,out] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005522 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02005523 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vaskocdad7122020-11-09 21:04:44 +01005524 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005525 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
5526 */
5527static LY_ERR
Michal Vaskocdad7122020-11-09 21:04:44 +01005528moveto_node(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005529{
Michal Vasko9d414112021-12-02 12:31:00 +01005530 LY_ERR r, rc = LY_SUCCESS;
Michal Vaskodb08ce52021-10-06 08:57:49 +02005531 const struct lyd_node *siblings, *sub;
Michal Vasko9d414112021-12-02 12:31:00 +01005532 struct lyxp_set result;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005533
aPiecek8b0cc152021-05-31 16:40:31 +02005534 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005535 return LY_SUCCESS;
5536 }
5537
5538 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005539 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005540 return LY_EVALID;
5541 }
5542
Michal Vasko9d414112021-12-02 12:31:00 +01005543 /* init result set */
5544 set_init(&result, set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005545
Michal Vasko9d414112021-12-02 12:31:00 +01005546 for (uint32_t i = 0; i < set->used; ++i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005547 if ((set->val.nodes[i].type == LYXP_NODE_ROOT_CONFIG) || (set->val.nodes[i].type == LYXP_NODE_ROOT)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005548 assert(!set->val.nodes[i].node);
Michal Vaskod3678892020-05-21 10:06:58 +02005549
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005550 /* search in all the trees */
Michal Vaskod3678892020-05-21 10:06:58 +02005551 siblings = set->tree;
Michal Vasko5bfd4be2020-06-23 13:26:19 +02005552 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02005553 /* search in children */
Michal Vaskodb08ce52021-10-06 08:57:49 +02005554 siblings = lyd_child(set->val.nodes[i].node);
Michal Vaskod3678892020-05-21 10:06:58 +02005555 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005556
Michal Vaskod3678892020-05-21 10:06:58 +02005557 for (sub = siblings; sub; sub = sub->next) {
Michal Vasko9d414112021-12-02 12:31:00 +01005558 r = moveto_node_check(sub, set, ncname, moveto_mod, options);
5559 if (r == LY_SUCCESS) {
5560 /* matching node */
5561 set_insert_node(&result, sub, 0, LYXP_NODE_ELEM, result.used);
5562 } else if (r == LY_EINCOMPLETE) {
5563 rc = r;
5564 goto cleanup;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005565 }
5566 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005567 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005568
Michal Vasko9d414112021-12-02 12:31:00 +01005569 /* move result to the set */
5570 lyxp_set_free_content(set);
5571 *set = result;
5572 result.type = LYXP_SET_NUMBER;
5573 assert(!set_sort(set));
5574
5575cleanup:
5576 lyxp_set_free_content(&result);
5577 return rc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005578}
5579
5580/**
Michal Vaskod3678892020-05-21 10:06:58 +02005581 * @brief Move context @p set to a node using hashes. Result is LYXP_SET_NODE_SET (or LYXP_SET_EMPTY).
5582 * Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005583 *
5584 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02005585 * @param[in] scnode Matching node schema.
Michal Vasko004d3152020-06-11 19:59:22 +02005586 * @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 +01005587 * @param[in] options XPath options.
Michal Vaskod3678892020-05-21 10:06:58 +02005588 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
5589 */
5590static LY_ERR
Michal Vaskocdad7122020-11-09 21:04:44 +01005591moveto_node_hash(struct lyxp_set *set, const struct lysc_node *scnode, const struct ly_path_predicate *predicates,
5592 uint32_t options)
Michal Vaskod3678892020-05-21 10:06:58 +02005593{
Michal Vasko004d3152020-06-11 19:59:22 +02005594 LY_ERR ret = LY_SUCCESS;
Michal Vaskod3678892020-05-21 10:06:58 +02005595 uint32_t i;
Michal Vaskod3678892020-05-21 10:06:58 +02005596 const struct lyd_node *siblings;
Michal Vasko9d414112021-12-02 12:31:00 +01005597 struct lyxp_set result;
Michal Vasko004d3152020-06-11 19:59:22 +02005598 struct lyd_node *sub, *inst = NULL;
Michal Vaskod3678892020-05-21 10:06:58 +02005599
Michal Vasko004d3152020-06-11 19:59:22 +02005600 assert(scnode && (!(scnode->nodetype & (LYS_LIST | LYS_LEAFLIST)) || predicates));
Michal Vaskod3678892020-05-21 10:06:58 +02005601
Michal Vaskoa5af7762021-12-02 13:11:56 +01005602 /* init result set */
5603 set_init(&result, set);
5604
aPiecek8b0cc152021-05-31 16:40:31 +02005605 if (options & LYXP_SKIP_EXPR) {
Michal Vasko004d3152020-06-11 19:59:22 +02005606 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02005607 }
5608
5609 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005610 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko004d3152020-06-11 19:59:22 +02005611 ret = LY_EVALID;
5612 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02005613 }
5614
5615 /* context check for all the nodes since we have the schema node */
5616 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (scnode->flags & LYS_CONFIG_R)) {
5617 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02005618 goto cleanup;
Michal Vasko69730152020-10-09 16:30:07 +02005619 } else if (set->context_op && (scnode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) &&
5620 (scnode != set->context_op)) {
Michal Vasko6b26e742020-07-17 15:02:10 +02005621 lyxp_set_free_content(set);
5622 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +02005623 }
5624
5625 /* create specific data instance if needed */
5626 if (scnode->nodetype == LYS_LIST) {
5627 LY_CHECK_GOTO(ret = lyd_create_list(scnode, predicates, &inst), cleanup);
5628 } else if (scnode->nodetype == LYS_LEAFLIST) {
5629 LY_CHECK_GOTO(ret = lyd_create_term2(scnode, &predicates[0].value, &inst), cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02005630 }
5631
Michal Vasko9d414112021-12-02 12:31:00 +01005632 for (i = 0; i < set->used; ++i) {
Michal Vaskod3678892020-05-21 10:06:58 +02005633 siblings = NULL;
5634
5635 if ((set->val.nodes[i].type == LYXP_NODE_ROOT_CONFIG) || (set->val.nodes[i].type == LYXP_NODE_ROOT)) {
5636 assert(!set->val.nodes[i].node);
5637
5638 /* search in all the trees */
5639 siblings = set->tree;
5640 } else if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
5641 /* search in children */
Radek Krejcia1c1e542020-09-29 16:06:52 +02005642 siblings = lyd_child(set->val.nodes[i].node);
Michal Vaskod3678892020-05-21 10:06:58 +02005643 }
5644
5645 /* find the node using hashes */
Michal Vasko004d3152020-06-11 19:59:22 +02005646 if (inst) {
5647 lyd_find_sibling_first(siblings, inst, &sub);
Michal Vaskod3678892020-05-21 10:06:58 +02005648 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02005649 lyd_find_sibling_val(siblings, scnode, NULL, 0, &sub);
Michal Vaskod3678892020-05-21 10:06:58 +02005650 }
5651
5652 /* when check */
Michal Vaskod5cfa6e2020-11-23 16:56:08 +01005653 if (!(options & LYXP_IGNORE_WHEN) && sub && lysc_has_when(sub->schema) && !(sub->flags & LYD_WHEN_TRUE)) {
Michal Vasko004d3152020-06-11 19:59:22 +02005654 ret = LY_EINCOMPLETE;
5655 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02005656 }
5657
5658 if (sub) {
5659 /* pos filled later */
Michal Vasko9d414112021-12-02 12:31:00 +01005660 set_insert_node(&result, sub, 0, LYXP_NODE_ELEM, result.used);
Michal Vaskod3678892020-05-21 10:06:58 +02005661 }
5662 }
5663
Michal Vasko9d414112021-12-02 12:31:00 +01005664 /* move result to the set */
5665 lyxp_set_free_content(set);
5666 *set = result;
5667 result.type = LYXP_SET_NUMBER;
5668 assert(!set_sort(set));
5669
Michal Vasko004d3152020-06-11 19:59:22 +02005670cleanup:
Michal Vasko9d414112021-12-02 12:31:00 +01005671 lyxp_set_free_content(&result);
Michal Vasko004d3152020-06-11 19:59:22 +02005672 lyd_free_tree(inst);
5673 return ret;
Michal Vaskod3678892020-05-21 10:06:58 +02005674}
5675
5676/**
5677 * @brief Move context @p set to a schema node. Result is LYXP_SET_SCNODE_SET (or LYXP_SET_EMPTY).
5678 *
5679 * @param[in,out] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005680 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02005681 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005682 * @param[in] options XPath options.
5683 * @return LY_ERR
5684 */
5685static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005686moveto_scnode(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005687{
Radek Krejci857189e2020-09-01 13:26:36 +02005688 ly_bool temp_ctx = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02005689 uint32_t getnext_opts;
5690 uint32_t orig_used, i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005691 uint32_t mod_idx;
Michal Vasko519fd602020-05-26 12:17:39 +02005692 const struct lysc_node *iter, *start_parent;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005693 const struct lys_module *mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005694
aPiecek8b0cc152021-05-31 16:40:31 +02005695 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005696 return LY_SUCCESS;
5697 }
5698
5699 if (set->type != LYXP_SET_SCNODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005700 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005701 return LY_EVALID;
5702 }
5703
Michal Vaskocafad9d2019-11-07 15:20:03 +01005704 /* getnext opts */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01005705 getnext_opts = 0;
Michal Vaskocafad9d2019-11-07 15:20:03 +01005706 if (options & LYXP_SCNODE_OUTPUT) {
5707 getnext_opts |= LYS_GETNEXT_OUTPUT;
5708 }
5709
Michal Vasko03ff5a72019-09-11 13:49:33 +02005710 orig_used = set->used;
5711 for (i = 0; i < orig_used; ++i) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005712 uint32_t idx;
5713
Radek Krejcif13b87b2020-12-01 22:02:17 +01005714 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
5715 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01005716 continue;
5717 }
5718
5719 /* remember context node */
Radek Krejcif13b87b2020-12-01 22:02:17 +01005720 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vaskoec4df482019-12-16 10:02:18 +01005721 } else {
Michal Vasko1a09b212021-05-06 13:00:10 +02005722 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005723 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005724
5725 start_parent = set->val.scnodes[i].scnode;
5726
5727 if ((set->val.scnodes[i].type == LYXP_NODE_ROOT_CONFIG) || (set->val.scnodes[i].type == LYXP_NODE_ROOT)) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005728 /* it can actually be in any module, it's all <running>, and even if it's moveto_mod (if set),
Michal Vasko9e9f26d2020-10-12 16:31:33 +02005729 * it can be in a top-level augment (the root node itself is useless in this case) */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005730 mod_idx = 0;
Michal Vaskoa51ef072021-07-02 10:40:30 +02005731 while ((mod = ly_ctx_get_module_iter(set->ctx, &mod_idx))) {
Michal Vasko519fd602020-05-26 12:17:39 +02005732 iter = NULL;
Michal Vasko919954a2021-07-26 09:21:42 +02005733 /* module may not be implemented or not compiled yet */
5734 while (mod->compiled && (iter = lys_getnext(iter, NULL, mod->compiled, getnext_opts))) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005735 if (!moveto_scnode_check(iter, NULL, set, ncname, moveto_mod)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005736 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, iter, LYXP_NODE_ELEM, &idx));
5737
Michal Vasko03ff5a72019-09-11 13:49:33 +02005738 /* we need to prevent these nodes from being considered in this moveto */
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005739 if ((idx < orig_used) && (idx > i)) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005740 set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_NEW_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005741 temp_ctx = 1;
5742 }
5743 }
5744 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005745 }
5746
Michal Vasko519fd602020-05-26 12:17:39 +02005747 } else if (set->val.scnodes[i].type == LYXP_NODE_ELEM) {
5748 iter = NULL;
5749 while ((iter = lys_getnext(iter, start_parent, NULL, getnext_opts))) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005750 if (!moveto_scnode_check(iter, start_parent, set, ncname, moveto_mod)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005751 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, iter, LYXP_NODE_ELEM, &idx));
5752
5753 if ((idx < orig_used) && (idx > i)) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005754 set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_NEW_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005755 temp_ctx = 1;
5756 }
5757 }
5758 }
5759 }
5760 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005761
5762 /* correct temporary in_ctx values */
5763 if (temp_ctx) {
5764 for (i = 0; i < orig_used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005765 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_NEW_CTX) {
5766 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005767 }
5768 }
5769 }
5770
5771 return LY_SUCCESS;
5772}
5773
5774/**
Michal Vaskod3678892020-05-21 10:06:58 +02005775 * @brief Move context @p set to a node and all its descendants. Result is LYXP_SET_NODE_SET (or LYXP_SET_EMPTY).
Michal Vasko03ff5a72019-09-11 13:49:33 +02005776 * Context position aware.
5777 *
5778 * @param[in] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005779 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02005780 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vaskocdad7122020-11-09 21:04:44 +01005781 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005782 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
5783 */
5784static LY_ERR
Michal Vaskocdad7122020-11-09 21:04:44 +01005785moveto_node_alldesc(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005786{
5787 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005788 const struct lyd_node *next, *elem, *start;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005789 struct lyxp_set ret_set;
5790 LY_ERR rc;
5791
aPiecek8b0cc152021-05-31 16:40:31 +02005792 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005793 return LY_SUCCESS;
5794 }
5795
5796 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005797 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005798 return LY_EVALID;
5799 }
5800
Michal Vasko9f96a052020-03-10 09:41:45 +01005801 /* replace the original nodes (and throws away all text and meta nodes, root is replaced by a child) */
Michal Vaskocdad7122020-11-09 21:04:44 +01005802 rc = moveto_node(set, NULL, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005803 LY_CHECK_RET(rc);
5804
Michal Vasko6346ece2019-09-24 13:12:53 +02005805 /* this loop traverses all the nodes in the set and adds/keeps only those that match qname */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005806 set_init(&ret_set, set);
5807 for (i = 0; i < set->used; ++i) {
5808
5809 /* TREE DFS */
5810 start = set->val.nodes[i].node;
5811 for (elem = next = start; elem; elem = next) {
Michal Vaskodb08ce52021-10-06 08:57:49 +02005812 rc = moveto_node_check(elem, set, ncname, moveto_mod, options);
Michal Vasko6346ece2019-09-24 13:12:53 +02005813 if (!rc) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005814 /* add matching node into result set */
5815 set_insert_node(&ret_set, elem, 0, LYXP_NODE_ELEM, ret_set.used);
5816 if (set_dup_node_check(set, elem, LYXP_NODE_ELEM, i)) {
5817 /* the node is a duplicate, we'll process it later in the set */
5818 goto skip_children;
5819 }
Michal Vasko6346ece2019-09-24 13:12:53 +02005820 } else if (rc == LY_EINCOMPLETE) {
Michal Vasko6346ece2019-09-24 13:12:53 +02005821 return rc;
5822 } else if (rc == LY_EINVAL) {
5823 goto skip_children;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005824 }
5825
5826 /* TREE DFS NEXT ELEM */
5827 /* select element for the next run - children first */
Radek Krejcia1c1e542020-09-29 16:06:52 +02005828 next = lyd_child(elem);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005829 if (!next) {
5830skip_children:
5831 /* no children, so try siblings, but only if it's not the start,
5832 * that is considered to be the root and it's siblings are not traversed */
5833 if (elem != start) {
5834 next = elem->next;
5835 } else {
5836 break;
5837 }
5838 }
5839 while (!next) {
5840 /* no siblings, go back through the parents */
Michal Vasko9e685082021-01-29 14:49:09 +01005841 if (lyd_parent(elem) == start) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005842 /* we are done, no next element to process */
5843 break;
5844 }
5845 /* parent is already processed, go to its sibling */
Michal Vasko9e685082021-01-29 14:49:09 +01005846 elem = lyd_parent(elem);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005847 next = elem->next;
5848 }
5849 }
5850 }
5851
5852 /* make the temporary set the current one */
5853 ret_set.ctx_pos = set->ctx_pos;
5854 ret_set.ctx_size = set->ctx_size;
Michal Vaskod3678892020-05-21 10:06:58 +02005855 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005856 memcpy(set, &ret_set, sizeof *set);
5857
5858 return LY_SUCCESS;
5859}
5860
5861/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02005862 * @brief Move context @p set to a schema node and all its descendants. Result is LYXP_SET_NODE_SET.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005863 *
5864 * @param[in] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005865 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02005866 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005867 * @param[in] options XPath options.
5868 * @return LY_ERR
5869 */
5870static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005871moveto_scnode_alldesc(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005872{
Radek Krejci1deb5be2020-08-26 16:43:36 +02005873 uint32_t i, orig_used;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005874 const struct lysc_node *next, *elem, *start;
Michal Vasko6346ece2019-09-24 13:12:53 +02005875 LY_ERR rc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005876
aPiecek8b0cc152021-05-31 16:40:31 +02005877 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005878 return LY_SUCCESS;
5879 }
5880
5881 if (set->type != LYXP_SET_SCNODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005882 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005883 return LY_EVALID;
5884 }
5885
Michal Vasko03ff5a72019-09-11 13:49:33 +02005886 orig_used = set->used;
5887 for (i = 0; i < orig_used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005888 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
5889 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01005890 continue;
5891 }
5892
5893 /* remember context node */
Radek Krejcif13b87b2020-12-01 22:02:17 +01005894 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vaskoec4df482019-12-16 10:02:18 +01005895 } else {
Michal Vasko1a09b212021-05-06 13:00:10 +02005896 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005897 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005898
5899 /* TREE DFS */
5900 start = set->val.scnodes[i].scnode;
5901 for (elem = next = start; elem; elem = next) {
Michal Vasko6346ece2019-09-24 13:12:53 +02005902 if ((elem == start) || (elem->nodetype & (LYS_CHOICE | LYS_CASE))) {
5903 /* schema-only nodes, skip root */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005904 goto next_iter;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005905 }
5906
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005907 rc = moveto_scnode_check(elem, start, set, ncname, moveto_mod);
Michal Vasko6346ece2019-09-24 13:12:53 +02005908 if (!rc) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005909 uint32_t idx;
5910
5911 if (lyxp_set_scnode_contains(set, elem, LYXP_NODE_ELEM, i, &idx)) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005912 set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Radek Krejci1deb5be2020-08-26 16:43:36 +02005913 if ((uint32_t)idx > i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005914 /* we will process it later in the set */
5915 goto skip_children;
5916 }
5917 } else {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005918 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, elem, LYXP_NODE_ELEM, NULL));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005919 }
Michal Vasko6346ece2019-09-24 13:12:53 +02005920 } else if (rc == LY_EINVAL) {
5921 goto skip_children;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005922 }
5923
5924next_iter:
5925 /* TREE DFS NEXT ELEM */
5926 /* select element for the next run - children first */
Michal Vasko544e58a2021-01-28 14:33:41 +01005927 next = lysc_node_child(elem);
5928 if (next && (next->nodetype == LYS_INPUT) && (options & LYXP_SCNODE_OUTPUT)) {
5929 next = next->next;
5930 } else if (next && (next->nodetype == LYS_OUTPUT) && !(options & LYXP_SCNODE_OUTPUT)) {
5931 next = next->next;
5932 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005933 if (!next) {
5934skip_children:
5935 /* no children, so try siblings, but only if it's not the start,
5936 * that is considered to be the root and it's siblings are not traversed */
5937 if (elem != start) {
5938 next = elem->next;
5939 } else {
5940 break;
5941 }
5942 }
5943 while (!next) {
5944 /* no siblings, go back through the parents */
5945 if (elem->parent == start) {
5946 /* we are done, no next element to process */
5947 break;
5948 }
5949 /* parent is already processed, go to its sibling */
5950 elem = elem->parent;
5951 next = elem->next;
5952 }
5953 }
5954 }
5955
5956 return LY_SUCCESS;
5957}
5958
5959/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02005960 * @brief Move context @p set to an attribute. Result is LYXP_SET_NODE_SET.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005961 * Indirectly context position aware.
5962 *
5963 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02005964 * @param[in] mod Matching metadata module, NULL for any.
5965 * @param[in] ncname Matching metadata name in the dictionary, NULL for any.
aPiecek8b0cc152021-05-31 16:40:31 +02005966 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005967 * @return LY_ERR
5968 */
5969static LY_ERR
aPiecek8b0cc152021-05-31 16:40:31 +02005970moveto_attr(struct lyxp_set *set, const struct lys_module *mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005971{
Michal Vasko9f96a052020-03-10 09:41:45 +01005972 struct lyd_meta *sub;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005973
aPiecek8b0cc152021-05-31 16:40:31 +02005974 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005975 return LY_SUCCESS;
5976 }
5977
5978 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005979 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005980 return LY_EVALID;
5981 }
5982
Radek Krejci1deb5be2020-08-26 16:43:36 +02005983 for (uint32_t i = 0; i < set->used; ) {
Radek Krejci857189e2020-09-01 13:26:36 +02005984 ly_bool replaced = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005985
5986 /* only attributes of an elem (not dummy) can be in the result, skip all the rest;
5987 * our attributes are always qualified */
Michal Vasko5c4e5892019-11-14 12:31:38 +01005988 if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko9f96a052020-03-10 09:41:45 +01005989 for (sub = set->val.nodes[i].node->meta; sub; sub = sub->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005990
5991 /* check "namespace" */
Michal Vaskod3678892020-05-21 10:06:58 +02005992 if (mod && (sub->annotation->module != mod)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005993 continue;
5994 }
5995
Michal Vaskod3678892020-05-21 10:06:58 +02005996 if (!ncname || (sub->name == ncname)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005997 /* match */
5998 if (!replaced) {
Michal Vasko9f96a052020-03-10 09:41:45 +01005999 set->val.meta[i].meta = sub;
6000 set->val.meta[i].type = LYXP_NODE_META;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006001 /* pos does not change */
6002 replaced = 1;
6003 } else {
Michal Vasko9f96a052020-03-10 09:41:45 +01006004 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 +02006005 }
6006 ++i;
6007 }
6008 }
6009 }
6010
6011 if (!replaced) {
6012 /* no match */
6013 set_remove_node(set, i);
6014 }
6015 }
6016
6017 return LY_SUCCESS;
6018}
6019
6020/**
6021 * @brief Move context @p set1 to union with @p set2. @p set2 is emptied afterwards.
Michal Vasko61ac2f62020-05-25 12:39:51 +02006022 * Result is LYXP_SET_NODE_SET. Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006023 *
6024 * @param[in,out] set1 Set to use for the result.
6025 * @param[in] set2 Set that is copied to @p set1.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006026 * @return LY_ERR
6027 */
6028static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006029moveto_union(struct lyxp_set *set1, struct lyxp_set *set2)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006030{
6031 LY_ERR rc;
6032
Michal Vaskod3678892020-05-21 10:06:58 +02006033 if ((set1->type != LYXP_SET_NODE_SET) || (set2->type != LYXP_SET_NODE_SET)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006034 LOGVAL(set1->ctx, LY_VCODE_XP_INOP_2, "union", print_set_type(set1), print_set_type(set2));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006035 return LY_EVALID;
6036 }
6037
6038 /* set2 is empty or both set1 and set2 */
Michal Vaskod3678892020-05-21 10:06:58 +02006039 if (!set2->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006040 return LY_SUCCESS;
6041 }
6042
Michal Vaskod3678892020-05-21 10:06:58 +02006043 if (!set1->used) {
aPiecekadc1e4f2021-10-07 11:15:12 +02006044 /* release hidden allocated data (lyxp_set.size) */
6045 lyxp_set_free_content(set1);
6046 /* direct copying of the entire structure */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006047 memcpy(set1, set2, sizeof *set1);
6048 /* dynamic memory belongs to set1 now, do not free */
Michal Vaskod3678892020-05-21 10:06:58 +02006049 memset(set2, 0, sizeof *set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006050 return LY_SUCCESS;
6051 }
6052
6053 /* we assume sets are sorted */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006054 assert(!set_sort(set1) && !set_sort(set2));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006055
6056 /* sort, remove duplicates */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006057 rc = set_sorted_merge(set1, set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006058 LY_CHECK_RET(rc);
6059
6060 /* final set must be sorted */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006061 assert(!set_sort(set1));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006062
6063 return LY_SUCCESS;
6064}
6065
6066/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02006067 * @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 +02006068 * Context position aware.
6069 *
6070 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02006071 * @param[in] mod Matching metadata module, NULL for any.
6072 * @param[in] ncname Matching metadata name in the dictionary, NULL for any.
Michal Vaskocdad7122020-11-09 21:04:44 +01006073 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006074 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6075 */
6076static int
Michal Vaskocdad7122020-11-09 21:04:44 +01006077moveto_attr_alldesc(struct lyxp_set *set, const struct lys_module *mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006078{
Michal Vasko9f96a052020-03-10 09:41:45 +01006079 struct lyd_meta *sub;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006080 struct lyxp_set *set_all_desc = NULL;
6081 LY_ERR rc;
6082
aPiecek8b0cc152021-05-31 16:40:31 +02006083 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006084 return LY_SUCCESS;
6085 }
6086
6087 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006088 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006089 return LY_EVALID;
6090 }
6091
Michal Vasko03ff5a72019-09-11 13:49:33 +02006092 /* can be optimized similarly to moveto_node_alldesc() and save considerable amount of memory,
6093 * but it likely won't be used much, so it's a waste of time */
6094 /* copy the context */
6095 set_all_desc = set_copy(set);
6096 /* get all descendant nodes (the original context nodes are removed) */
Michal Vaskocdad7122020-11-09 21:04:44 +01006097 rc = moveto_node_alldesc(set_all_desc, NULL, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006098 if (rc != LY_SUCCESS) {
6099 lyxp_set_free(set_all_desc);
6100 return rc;
6101 }
6102 /* prepend the original context nodes */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006103 rc = moveto_union(set, set_all_desc);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006104 if (rc != LY_SUCCESS) {
6105 lyxp_set_free(set_all_desc);
6106 return rc;
6107 }
6108 lyxp_set_free(set_all_desc);
6109
Radek Krejci1deb5be2020-08-26 16:43:36 +02006110 for (uint32_t i = 0; i < set->used; ) {
Radek Krejci857189e2020-09-01 13:26:36 +02006111 ly_bool replaced = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006112
6113 /* only attributes of an elem can be in the result, skip all the rest,
6114 * we have all attributes qualified in lyd tree */
6115 if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko9f96a052020-03-10 09:41:45 +01006116 for (sub = set->val.nodes[i].node->meta; sub; sub = sub->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006117 /* check "namespace" */
Michal Vaskod3678892020-05-21 10:06:58 +02006118 if (mod && (sub->annotation->module != mod)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006119 continue;
6120 }
6121
Michal Vaskod3678892020-05-21 10:06:58 +02006122 if (!ncname || (sub->name == ncname)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006123 /* match */
6124 if (!replaced) {
Michal Vasko9f96a052020-03-10 09:41:45 +01006125 set->val.meta[i].meta = sub;
6126 set->val.meta[i].type = LYXP_NODE_META;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006127 /* pos does not change */
6128 replaced = 1;
6129 } else {
Michal Vasko9f96a052020-03-10 09:41:45 +01006130 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 +02006131 }
6132 ++i;
6133 }
6134 }
6135 }
6136
6137 if (!replaced) {
6138 /* no match */
6139 set_remove_node(set, i);
6140 }
6141 }
6142
6143 return LY_SUCCESS;
6144}
6145
6146/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02006147 * @brief Move context @p set to self and al chilren, recursively. Handles '/' or '//' and '.'. Result is LYXP_SET_NODE_SET.
6148 * Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006149 *
6150 * @param[in] parent Current parent.
6151 * @param[in] parent_pos Position of @p parent.
6152 * @param[in] parent_type Node type of @p parent.
6153 * @param[in,out] to_set Set to use.
6154 * @param[in] dup_check_set Set for checking duplicities.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006155 * @param[in] options XPath options.
6156 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6157 */
6158static LY_ERR
6159moveto_self_add_children_r(const struct lyd_node *parent, uint32_t parent_pos, enum lyxp_node_type parent_type,
Radek Krejci1deb5be2020-08-26 16:43:36 +02006160 struct lyxp_set *to_set, const struct lyxp_set *dup_check_set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006161{
Michal Vasko61ac2f62020-05-25 12:39:51 +02006162 const struct lyd_node *iter, *first;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006163 LY_ERR rc;
6164
6165 switch (parent_type) {
6166 case LYXP_NODE_ROOT:
6167 case LYXP_NODE_ROOT_CONFIG:
Michal Vasko61ac2f62020-05-25 12:39:51 +02006168 assert(!parent);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006169
Michal Vasko61ac2f62020-05-25 12:39:51 +02006170 /* add all top-level nodes as elements */
6171 first = to_set->tree;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006172 break;
6173 case LYXP_NODE_ELEM:
Michal Vasko61ac2f62020-05-25 12:39:51 +02006174 /* add just the text node of this term element node */
6175 if (parent->schema->nodetype & (LYD_NODE_TERM | LYD_NODE_ANY)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006176 if (!set_dup_node_check(dup_check_set, parent, LYXP_NODE_TEXT, -1)) {
6177 set_insert_node(to_set, parent, parent_pos, LYXP_NODE_TEXT, to_set->used);
6178 }
Michal Vasko61ac2f62020-05-25 12:39:51 +02006179 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006180 }
Michal Vasko61ac2f62020-05-25 12:39:51 +02006181
6182 /* add all the children of this node */
Radek Krejcia1c1e542020-09-29 16:06:52 +02006183 first = lyd_child(parent);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006184 break;
6185 default:
6186 LOGINT_RET(parent->schema->module->ctx);
6187 }
6188
Michal Vasko61ac2f62020-05-25 12:39:51 +02006189 /* add all top-level nodes as elements */
6190 LY_LIST_FOR(first, iter) {
6191 /* context check */
6192 if ((parent_type == LYXP_NODE_ROOT_CONFIG) && (iter->schema->flags & LYS_CONFIG_R)) {
6193 continue;
6194 }
6195
6196 /* when check */
Michal Vaskod5cfa6e2020-11-23 16:56:08 +01006197 if (!(options & LYXP_IGNORE_WHEN) && lysc_has_when(iter->schema) && !(iter->flags & LYD_WHEN_TRUE)) {
Michal Vasko61ac2f62020-05-25 12:39:51 +02006198 return LY_EINCOMPLETE;
6199 }
6200
6201 if (!set_dup_node_check(dup_check_set, iter, LYXP_NODE_ELEM, -1)) {
6202 set_insert_node(to_set, iter, 0, LYXP_NODE_ELEM, to_set->used);
6203
6204 /* also add all the children of this node, recursively */
6205 rc = moveto_self_add_children_r(iter, 0, LYXP_NODE_ELEM, to_set, dup_check_set, options);
6206 LY_CHECK_RET(rc);
6207 }
6208 }
6209
Michal Vasko03ff5a72019-09-11 13:49:33 +02006210 return LY_SUCCESS;
6211}
6212
6213/**
6214 * @brief Move context @p set to self. Handles '/' or '//' and '.'. Result is LYXP_SET_NODE_SET
6215 * (or LYXP_SET_EMPTY). Context position aware.
6216 *
6217 * @param[in,out] set Set to use.
6218 * @param[in] all_desc Whether to go to all descendants ('//') or not ('/').
6219 * @param[in] options XPath options.
6220 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6221 */
6222static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02006223moveto_self(struct lyxp_set *set, ly_bool all_desc, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006224{
Michal Vasko03ff5a72019-09-11 13:49:33 +02006225 struct lyxp_set ret_set;
6226 LY_ERR rc;
6227
aPiecek8b0cc152021-05-31 16:40:31 +02006228 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006229 return LY_SUCCESS;
6230 }
6231
6232 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006233 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006234 return LY_EVALID;
6235 }
6236
6237 /* nothing to do */
6238 if (!all_desc) {
6239 return LY_SUCCESS;
6240 }
6241
Michal Vasko03ff5a72019-09-11 13:49:33 +02006242 /* add all the children, they get added recursively */
6243 set_init(&ret_set, set);
Radek Krejci1deb5be2020-08-26 16:43:36 +02006244 for (uint32_t i = 0; i < set->used; ++i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006245 /* copy the current node to tmp */
6246 set_insert_node(&ret_set, set->val.nodes[i].node, set->val.nodes[i].pos, set->val.nodes[i].type, ret_set.used);
6247
6248 /* do not touch attributes and text nodes */
Michal Vasko9f96a052020-03-10 09:41:45 +01006249 if ((set->val.nodes[i].type == LYXP_NODE_TEXT) || (set->val.nodes[i].type == LYXP_NODE_META)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006250 continue;
6251 }
6252
Michal Vasko03ff5a72019-09-11 13:49:33 +02006253 /* add all the children */
6254 rc = moveto_self_add_children_r(set->val.nodes[i].node, set->val.nodes[i].pos, set->val.nodes[i].type, &ret_set,
Michal Vasko69730152020-10-09 16:30:07 +02006255 set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006256 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02006257 lyxp_set_free_content(&ret_set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006258 return rc;
6259 }
6260 }
6261
6262 /* use the temporary set as the current one */
6263 ret_set.ctx_pos = set->ctx_pos;
6264 ret_set.ctx_size = set->ctx_size;
Michal Vaskod3678892020-05-21 10:06:58 +02006265 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006266 memcpy(set, &ret_set, sizeof *set);
6267
6268 return LY_SUCCESS;
6269}
6270
6271/**
6272 * @brief Move context schema @p set to self. Handles '/' or '//' and '.'. Result is LYXP_SET_SCNODE_SET
6273 * (or LYXP_SET_EMPTY).
6274 *
6275 * @param[in,out] set Set to use.
6276 * @param[in] all_desc Whether to go to all descendants ('//') or not ('/').
6277 * @param[in] options XPath options.
6278 * @return LY_ERR
6279 */
6280static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02006281moveto_scnode_self(struct lyxp_set *set, ly_bool all_desc, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006282{
Radek Krejci1deb5be2020-08-26 16:43:36 +02006283 uint32_t getnext_opts;
6284 uint32_t mod_idx;
Michal Vasko519fd602020-05-26 12:17:39 +02006285 const struct lysc_node *iter, *start_parent;
6286 const struct lys_module *mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006287
aPiecek8b0cc152021-05-31 16:40:31 +02006288 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006289 return LY_SUCCESS;
6290 }
6291
6292 if (set->type != LYXP_SET_SCNODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006293 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006294 return LY_EVALID;
6295 }
6296
Michal Vasko519fd602020-05-26 12:17:39 +02006297 /* getnext opts */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01006298 getnext_opts = 0;
Michal Vasko519fd602020-05-26 12:17:39 +02006299 if (options & LYXP_SCNODE_OUTPUT) {
6300 getnext_opts |= LYS_GETNEXT_OUTPUT;
6301 }
6302
6303 /* add all the children, recursively as they are being added into the same set */
Radek Krejci1deb5be2020-08-26 16:43:36 +02006304 for (uint32_t i = 0; i < set->used; ++i) {
Michal Vaskoe657f962020-12-10 12:19:48 +01006305 if (!all_desc) {
6306 /* traverse the start node */
6307 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_START) {
6308 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
6309 }
6310 continue;
6311 }
6312
Radek Krejcif13b87b2020-12-01 22:02:17 +01006313 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
6314 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01006315 continue;
6316 }
6317
Michal Vasko519fd602020-05-26 12:17:39 +02006318 /* remember context node */
Radek Krejcif13b87b2020-12-01 22:02:17 +01006319 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vasko519fd602020-05-26 12:17:39 +02006320 } else {
Michal Vasko1a09b212021-05-06 13:00:10 +02006321 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006322 }
6323
Michal Vasko519fd602020-05-26 12:17:39 +02006324 start_parent = set->val.scnodes[i].scnode;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006325
Michal Vasko519fd602020-05-26 12:17:39 +02006326 if ((set->val.scnodes[i].type == LYXP_NODE_ROOT_CONFIG) || (set->val.scnodes[i].type == LYXP_NODE_ROOT)) {
6327 /* it can actually be in any module, it's all <running> */
6328 mod_idx = 0;
Michal Vaskoa51ef072021-07-02 10:40:30 +02006329 while ((mod = ly_ctx_get_module_iter(set->ctx, &mod_idx))) {
Michal Vasko519fd602020-05-26 12:17:39 +02006330 iter = NULL;
6331 /* module may not be implemented */
6332 while (mod->implemented && (iter = lys_getnext(iter, NULL, mod->compiled, getnext_opts))) {
6333 /* context check */
6334 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (iter->flags & LYS_CONFIG_R)) {
6335 continue;
6336 }
6337
Radek Krejciaa6b53f2020-08-27 15:19:03 +02006338 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, iter, LYXP_NODE_ELEM, NULL));
Michal Vasko519fd602020-05-26 12:17:39 +02006339 /* throw away the insert index, we want to consider that node again, recursively */
6340 }
6341 }
6342
6343 } else if (set->val.scnodes[i].type == LYXP_NODE_ELEM) {
6344 iter = NULL;
6345 while ((iter = lys_getnext(iter, start_parent, NULL, getnext_opts))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006346 /* context check */
Michal Vasko519fd602020-05-26 12:17:39 +02006347 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (iter->flags & LYS_CONFIG_R)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006348 continue;
6349 }
6350
Radek Krejciaa6b53f2020-08-27 15:19:03 +02006351 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, iter, LYXP_NODE_ELEM, NULL));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006352 }
6353 }
6354 }
6355
6356 return LY_SUCCESS;
6357}
6358
6359/**
6360 * @brief Move context @p set to parent. Handles '/' or '//' and '..'. Result is LYXP_SET_NODE_SET
6361 * (or LYXP_SET_EMPTY). Context position aware.
6362 *
6363 * @param[in] set Set to use.
6364 * @param[in] all_desc Whether to go to all descendants ('//') or not ('/').
6365 * @param[in] options XPath options.
6366 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6367 */
6368static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02006369moveto_parent(struct lyxp_set *set, ly_bool all_desc, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006370{
Michal Vasko9d414112021-12-02 12:31:00 +01006371 LY_ERR rc = LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006372 struct lyd_node *node, *new_node;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006373 enum lyxp_node_type new_type;
Michal Vasko9d414112021-12-02 12:31:00 +01006374 struct lyxp_set result;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006375
aPiecek8b0cc152021-05-31 16:40:31 +02006376 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006377 return LY_SUCCESS;
6378 }
6379
6380 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006381 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006382 return LY_EVALID;
6383 }
6384
6385 if (all_desc) {
6386 /* <path>//.. == <path>//./.. */
6387 rc = moveto_self(set, 1, options);
6388 LY_CHECK_RET(rc);
6389 }
6390
Michal Vasko9d414112021-12-02 12:31:00 +01006391 /* init result set */
6392 set_init(&result, set);
6393
Radek Krejci1deb5be2020-08-26 16:43:36 +02006394 for (uint32_t i = 0; i < set->used; ++i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006395 node = set->val.nodes[i].node;
6396
6397 if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko9e685082021-01-29 14:49:09 +01006398 new_node = lyd_parent(node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006399 } else if (set->val.nodes[i].type == LYXP_NODE_TEXT) {
6400 new_node = node;
Michal Vasko9f96a052020-03-10 09:41:45 +01006401 } else if (set->val.nodes[i].type == LYXP_NODE_META) {
6402 new_node = set->val.meta[i].meta->parent;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006403 if (!new_node) {
Michal Vasko9d414112021-12-02 12:31:00 +01006404 LOGINT(set->ctx);
6405 rc = LY_EINT;
6406 goto cleanup;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006407 }
6408 } else {
6409 /* root does not have a parent */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006410 continue;
6411 }
6412
Michal Vaskoa1424542019-11-14 16:08:52 +01006413 /* when check */
Michal Vasko9d414112021-12-02 12:31:00 +01006414 if (!(options & LYXP_IGNORE_WHEN) && new_node && lysc_has_when(new_node->schema) &&
6415 !(new_node->flags & LYD_WHEN_TRUE)) {
6416 rc = LY_EINCOMPLETE;
6417 goto cleanup;
Michal Vaskoa1424542019-11-14 16:08:52 +01006418 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006419
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006420 if (!new_node) {
Radek Krejcif6a11002020-08-21 13:29:07 +02006421 /* node already there can also be the root */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006422 new_type = set->root_type;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006423 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02006424 /* node has a standard parent (it can equal the root, it's not the root yet since they are fake) */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006425 new_type = LYXP_NODE_ELEM;
6426 }
6427
Michal Vasko9d414112021-12-02 12:31:00 +01006428 /* check for duplicates, several nodes may have the same parent */
6429 if (!set_dup_node_check(&result, new_node, new_type, -1)) {
6430 set_insert_node(&result, new_node, 0, new_type, result.used);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006431 }
6432 }
6433
Michal Vasko9d414112021-12-02 12:31:00 +01006434 /* move result to the set */
6435 lyxp_set_free_content(set);
6436 *set = result;
6437 result.type = LYXP_SET_NUMBER;
6438 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006439
Michal Vasko9d414112021-12-02 12:31:00 +01006440cleanup:
6441 lyxp_set_free_content(&result);
6442 return rc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006443}
6444
6445/**
6446 * @brief Move context schema @p set to parent. Handles '/' or '//' and '..'. Result is LYXP_SET_SCNODE_SET
6447 * (or LYXP_SET_EMPTY).
6448 *
6449 * @param[in] set Set to use.
6450 * @param[in] all_desc Whether to go to all descendants ('//') or not ('/').
6451 * @param[in] options XPath options.
6452 * @return LY_ERR
6453 */
6454static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02006455moveto_scnode_parent(struct lyxp_set *set, ly_bool all_desc, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006456{
Radek Krejciaa6b53f2020-08-27 15:19:03 +02006457 uint32_t i, orig_used, idx;
Radek Krejci857189e2020-09-01 13:26:36 +02006458 ly_bool temp_ctx = 0;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006459 const struct lysc_node *node, *new_node;
6460 enum lyxp_node_type new_type;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006461
aPiecek8b0cc152021-05-31 16:40:31 +02006462 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006463 return LY_SUCCESS;
6464 }
6465
6466 if (set->type != LYXP_SET_SCNODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006467 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006468 return LY_EVALID;
6469 }
6470
6471 if (all_desc) {
6472 /* <path>//.. == <path>//./.. */
Radek Krejci1deb5be2020-08-26 16:43:36 +02006473 LY_CHECK_RET(moveto_scnode_self(set, 1, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006474 }
6475
Michal Vasko03ff5a72019-09-11 13:49:33 +02006476 orig_used = set->used;
6477 for (i = 0; i < orig_used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006478 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
6479 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01006480 continue;
6481 }
6482
6483 /* remember context node */
Radek Krejcif13b87b2020-12-01 22:02:17 +01006484 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vaskoec4df482019-12-16 10:02:18 +01006485 } else {
Michal Vasko1a09b212021-05-06 13:00:10 +02006486 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006487 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006488
6489 node = set->val.scnodes[i].scnode;
6490
6491 if (set->val.scnodes[i].type == LYXP_NODE_ELEM) {
Michal Vaskod3678892020-05-21 10:06:58 +02006492 new_node = lysc_data_parent(node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006493 } else {
6494 /* root does not have a parent */
6495 continue;
6496 }
6497
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006498 if (!new_node) {
Radek Krejcif6a11002020-08-21 13:29:07 +02006499 /* node has no parent */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006500 new_type = set->root_type;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006501
Michal Vasko03ff5a72019-09-11 13:49:33 +02006502 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02006503 /* node has a standard parent (it can equal the root, it's not the root yet since they are fake) */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006504 new_type = LYXP_NODE_ELEM;
6505 }
6506
Radek Krejciaa6b53f2020-08-27 15:19:03 +02006507 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, new_node, new_type, &idx));
6508 if ((idx < orig_used) && (idx > i)) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006509 set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_NEW_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006510 temp_ctx = 1;
6511 }
6512 }
6513
6514 if (temp_ctx) {
6515 for (i = 0; i < orig_used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006516 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_NEW_CTX) {
6517 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006518 }
6519 }
6520 }
6521
6522 return LY_SUCCESS;
6523}
6524
6525/**
6526 * @brief Move context @p set to the result of a comparison. Handles '=', '!=', '<=', '<', '>=', or '>'.
6527 * Result is LYXP_SET_BOOLEAN. Indirectly context position aware.
6528 *
6529 * @param[in,out] set1 Set to use for the result.
6530 * @param[in] set2 Set acting as the second operand for @p op.
6531 * @param[in] op Comparison operator to process.
6532 * @param[in] options XPath options.
6533 * @return LY_ERR
6534 */
6535static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02006536moveto_op_comp(struct lyxp_set *set1, struct lyxp_set *set2, const char *op, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006537{
6538 /*
6539 * NODE SET + NODE SET = NODE SET + STRING /(1 NODE SET) 2 STRING
6540 * NODE SET + STRING = STRING + STRING /1 STRING (2 STRING)
6541 * NODE SET + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
6542 * NODE SET + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
6543 * STRING + NODE SET = STRING + STRING /(1 STRING) 2 STRING
6544 * NUMBER + NODE SET = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6545 * BOOLEAN + NODE SET = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
6546 *
6547 * '=' or '!='
6548 * BOOLEAN + BOOLEAN
6549 * BOOLEAN + STRING = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
6550 * BOOLEAN + NUMBER = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
6551 * STRING + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
6552 * NUMBER + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
6553 * NUMBER + NUMBER
6554 * NUMBER + STRING = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6555 * STRING + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
6556 * STRING + STRING
6557 *
6558 * '<=', '<', '>=', '>'
6559 * NUMBER + NUMBER
6560 * BOOLEAN + BOOLEAN = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
6561 * BOOLEAN + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
6562 * BOOLEAN + STRING = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
6563 * NUMBER + STRING = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6564 * STRING + STRING = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
6565 * STRING + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
6566 * NUMBER + BOOLEAN = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6567 * STRING + BOOLEAN = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6568 */
6569 struct lyxp_set iter1, iter2;
6570 int result;
6571 int64_t i;
6572 LY_ERR rc;
6573
Michal Vasko004d3152020-06-11 19:59:22 +02006574 memset(&iter1, 0, sizeof iter1);
6575 memset(&iter2, 0, sizeof iter2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006576
6577 /* iterative evaluation with node-sets */
6578 if ((set1->type == LYXP_SET_NODE_SET) || (set2->type == LYXP_SET_NODE_SET)) {
6579 if (set1->type == LYXP_SET_NODE_SET) {
6580 for (i = 0; i < set1->used; ++i) {
Michal Vasko4c7763f2020-07-27 17:40:37 +02006581 /* cast set1 */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006582 switch (set2->type) {
6583 case LYXP_SET_NUMBER:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006584 rc = set_comp_cast(&iter1, set1, LYXP_SET_NUMBER, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006585 break;
6586 case LYXP_SET_BOOLEAN:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006587 rc = set_comp_cast(&iter1, set1, LYXP_SET_BOOLEAN, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006588 break;
6589 default:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006590 rc = set_comp_cast(&iter1, set1, LYXP_SET_STRING, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006591 break;
6592 }
6593 LY_CHECK_RET(rc);
6594
Michal Vasko4c7763f2020-07-27 17:40:37 +02006595 /* canonize set2 */
6596 LY_CHECK_ERR_RET(rc = set_comp_canonize(&iter2, set2, &set1->val.nodes[i]), lyxp_set_free_content(&iter1), rc);
6597
6598 /* compare recursively */
6599 rc = moveto_op_comp(&iter1, &iter2, op, options);
6600 lyxp_set_free_content(&iter2);
6601 LY_CHECK_ERR_RET(rc, lyxp_set_free_content(&iter1), rc);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006602
6603 /* lazy evaluation until true */
Michal Vasko004d3152020-06-11 19:59:22 +02006604 if (iter1.val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006605 set_fill_boolean(set1, 1);
6606 return LY_SUCCESS;
6607 }
6608 }
6609 } else {
6610 for (i = 0; i < set2->used; ++i) {
Michal Vasko4c7763f2020-07-27 17:40:37 +02006611 /* set set2 */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006612 switch (set1->type) {
Michal Vasko4c7763f2020-07-27 17:40:37 +02006613 case LYXP_SET_NUMBER:
6614 rc = set_comp_cast(&iter2, set2, LYXP_SET_NUMBER, i);
6615 break;
6616 case LYXP_SET_BOOLEAN:
6617 rc = set_comp_cast(&iter2, set2, LYXP_SET_BOOLEAN, i);
6618 break;
6619 default:
6620 rc = set_comp_cast(&iter2, set2, LYXP_SET_STRING, i);
6621 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006622 }
6623 LY_CHECK_RET(rc);
6624
Michal Vasko4c7763f2020-07-27 17:40:37 +02006625 /* canonize set1 */
6626 LY_CHECK_ERR_RET(rc = set_comp_canonize(&iter1, set1, &set2->val.nodes[i]), lyxp_set_free_content(&iter2), rc);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006627
Michal Vasko4c7763f2020-07-27 17:40:37 +02006628 /* compare recursively */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006629 rc = moveto_op_comp(&iter1, &iter2, op, options);
Michal Vaskod3678892020-05-21 10:06:58 +02006630 lyxp_set_free_content(&iter2);
Michal Vasko4c7763f2020-07-27 17:40:37 +02006631 LY_CHECK_ERR_RET(rc, lyxp_set_free_content(&iter1), rc);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006632
6633 /* lazy evaluation until true */
Michal Vasko004d3152020-06-11 19:59:22 +02006634 if (iter1.val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006635 set_fill_boolean(set1, 1);
6636 return LY_SUCCESS;
6637 }
6638 }
6639 }
6640
6641 /* false for all nodes */
6642 set_fill_boolean(set1, 0);
6643 return LY_SUCCESS;
6644 }
6645
6646 /* first convert properly */
6647 if ((op[0] == '=') || (op[0] == '!')) {
6648 if ((set1->type == LYXP_SET_BOOLEAN) || (set2->type == LYXP_SET_BOOLEAN)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006649 lyxp_set_cast(set1, LYXP_SET_BOOLEAN);
6650 lyxp_set_cast(set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006651 } else if ((set1->type == LYXP_SET_NUMBER) || (set2->type == LYXP_SET_NUMBER)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006652 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006653 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006654 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006655 LY_CHECK_RET(rc);
6656 } /* else we have 2 strings */
6657 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006658 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006659 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006660 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006661 LY_CHECK_RET(rc);
6662 }
6663
6664 assert(set1->type == set2->type);
6665
6666 /* compute result */
6667 if (op[0] == '=') {
6668 if (set1->type == LYXP_SET_BOOLEAN) {
Michal Vasko004d3152020-06-11 19:59:22 +02006669 result = (set1->val.bln == set2->val.bln);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006670 } else if (set1->type == LYXP_SET_NUMBER) {
6671 result = (set1->val.num == set2->val.num);
6672 } else {
6673 assert(set1->type == LYXP_SET_STRING);
Michal Vaskoac6c72f2019-11-14 16:09:34 +01006674 result = !strcmp(set1->val.str, set2->val.str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006675 }
6676 } else if (op[0] == '!') {
6677 if (set1->type == LYXP_SET_BOOLEAN) {
Michal Vasko004d3152020-06-11 19:59:22 +02006678 result = (set1->val.bln != set2->val.bln);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006679 } else if (set1->type == LYXP_SET_NUMBER) {
6680 result = (set1->val.num != set2->val.num);
6681 } else {
6682 assert(set1->type == LYXP_SET_STRING);
Michal Vaskoc2058432020-11-06 17:26:21 +01006683 result = strcmp(set1->val.str, set2->val.str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006684 }
6685 } else {
6686 assert(set1->type == LYXP_SET_NUMBER);
6687 if (op[0] == '<') {
6688 if (op[1] == '=') {
6689 result = (set1->val.num <= set2->val.num);
6690 } else {
6691 result = (set1->val.num < set2->val.num);
6692 }
6693 } else {
6694 if (op[1] == '=') {
6695 result = (set1->val.num >= set2->val.num);
6696 } else {
6697 result = (set1->val.num > set2->val.num);
6698 }
6699 }
6700 }
6701
6702 /* assign result */
6703 if (result) {
6704 set_fill_boolean(set1, 1);
6705 } else {
6706 set_fill_boolean(set1, 0);
6707 }
6708
6709 return LY_SUCCESS;
6710}
6711
6712/**
6713 * @brief Move context @p set to the result of a basic operation. Handles '+', '-', unary '-', '*', 'div',
6714 * or 'mod'. Result is LYXP_SET_NUMBER. Indirectly context position aware.
6715 *
6716 * @param[in,out] set1 Set to use for the result.
6717 * @param[in] set2 Set acting as the second operand for @p op.
6718 * @param[in] op Operator to process.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006719 * @return LY_ERR
6720 */
6721static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006722moveto_op_math(struct lyxp_set *set1, struct lyxp_set *set2, const char *op)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006723{
6724 LY_ERR rc;
6725
6726 /* unary '-' */
6727 if (!set2 && (op[0] == '-')) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006728 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006729 LY_CHECK_RET(rc);
6730 set1->val.num *= -1;
6731 lyxp_set_free(set2);
6732 return LY_SUCCESS;
6733 }
6734
6735 assert(set1 && set2);
6736
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006737 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006738 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006739 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006740 LY_CHECK_RET(rc);
6741
6742 switch (op[0]) {
6743 /* '+' */
6744 case '+':
6745 set1->val.num += set2->val.num;
6746 break;
6747
6748 /* '-' */
6749 case '-':
6750 set1->val.num -= set2->val.num;
6751 break;
6752
6753 /* '*' */
6754 case '*':
6755 set1->val.num *= set2->val.num;
6756 break;
6757
6758 /* 'div' */
6759 case 'd':
6760 set1->val.num /= set2->val.num;
6761 break;
6762
6763 /* 'mod' */
6764 case 'm':
6765 set1->val.num = ((long long)set1->val.num) % ((long long)set2->val.num);
6766 break;
6767
6768 default:
6769 LOGINT_RET(set1->ctx);
6770 }
6771
6772 return LY_SUCCESS;
6773}
6774
Michal Vasko03ff5a72019-09-11 13:49:33 +02006775/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02006776 * @brief Evaluate Predicate. Logs directly on error.
6777 *
Michal Vaskod3678892020-05-21 10:06:58 +02006778 * [9] Predicate ::= '[' Expr ']'
Michal Vasko03ff5a72019-09-11 13:49:33 +02006779 *
6780 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02006781 * @param[in] tok_idx Position in the expression @p exp.
aPiecek8b0cc152021-05-31 16:40:31 +02006782 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006783 * @param[in] options XPath options.
6784 * @param[in] parent_pos_pred Whether parent predicate was a positional one.
6785 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6786 */
6787static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02006788eval_predicate(const struct lyxp_expr *exp, uint16_t *tok_idx, struct lyxp_set *set, uint32_t options, ly_bool parent_pos_pred)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006789{
6790 LY_ERR rc;
Michal Vasko1fdd8fa2021-01-08 09:21:45 +01006791 uint16_t orig_exp;
6792 uint32_t i, orig_pos, orig_size;
Michal Vasko5c4e5892019-11-14 12:31:38 +01006793 int32_t pred_in_ctx;
aPiecekfff4dca2021-10-07 10:59:53 +02006794 struct lyxp_set set2 = {0};
Michal Vasko03ff5a72019-09-11 13:49:33 +02006795 struct lyd_node *orig_parent;
6796
6797 /* '[' */
aPiecek8b0cc152021-05-31 16:40:31 +02006798 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02006799 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02006800 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006801
aPiecek8b0cc152021-05-31 16:40:31 +02006802 if (options & LYXP_SKIP_EXPR) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006803only_parse:
aPiecek8b0cc152021-05-31 16:40:31 +02006804 rc = eval_expr_select(exp, tok_idx, 0, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006805 LY_CHECK_RET(rc);
6806 } else if (set->type == LYXP_SET_NODE_SET) {
6807 /* 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 +01006808 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006809
6810 /* empty set, nothing to evaluate */
6811 if (!set->used) {
6812 goto only_parse;
6813 }
6814
Michal Vasko004d3152020-06-11 19:59:22 +02006815 orig_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006816 orig_pos = 0;
6817 orig_size = set->used;
6818 orig_parent = NULL;
Michal Vasko39dbf352020-05-21 10:08:59 +02006819 for (i = 0; i < set->used; ++i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006820 set_init(&set2, set);
6821 set_insert_node(&set2, set->val.nodes[i].node, set->val.nodes[i].pos, set->val.nodes[i].type, 0);
6822 /* remember the node context position for position() and context size for last(),
6823 * predicates should always be evaluated with respect to the child axis (since we do
6824 * not support explicit axes) so we assign positions based on their parents */
Michal Vasko9e685082021-01-29 14:49:09 +01006825 if (parent_pos_pred && (lyd_parent(set->val.nodes[i].node) != orig_parent)) {
6826 orig_parent = lyd_parent(set->val.nodes[i].node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006827 orig_pos = 1;
6828 } else {
6829 ++orig_pos;
6830 }
6831
6832 set2.ctx_pos = orig_pos;
6833 set2.ctx_size = orig_size;
Michal Vasko004d3152020-06-11 19:59:22 +02006834 *tok_idx = orig_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006835
Michal Vasko004d3152020-06-11 19:59:22 +02006836 rc = eval_expr_select(exp, tok_idx, 0, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006837 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02006838 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006839 return rc;
6840 }
6841
6842 /* number is a position */
6843 if (set2.type == LYXP_SET_NUMBER) {
6844 if ((long long)set2.val.num == orig_pos) {
6845 set2.val.num = 1;
6846 } else {
6847 set2.val.num = 0;
6848 }
6849 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006850 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006851
6852 /* predicate satisfied or not? */
Michal Vasko004d3152020-06-11 19:59:22 +02006853 if (!set2.val.bln) {
Michal Vasko2caefc12019-11-14 16:07:56 +01006854 set_remove_node_none(set, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006855 }
6856 }
Michal Vasko2caefc12019-11-14 16:07:56 +01006857 set_remove_nodes_none(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006858
6859 } else if (set->type == LYXP_SET_SCNODE_SET) {
6860 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006861 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006862 /* there is a currently-valid node */
6863 break;
6864 }
6865 }
6866 /* empty set, nothing to evaluate */
6867 if (i == set->used) {
6868 goto only_parse;
6869 }
6870
Michal Vasko004d3152020-06-11 19:59:22 +02006871 orig_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006872
Michal Vasko03ff5a72019-09-11 13:49:33 +02006873 /* set special in_ctx to all the valid snodes */
6874 pred_in_ctx = set_scnode_new_in_ctx(set);
6875
6876 /* use the valid snodes one-by-one */
6877 for (i = 0; i < set->used; ++i) {
6878 if (set->val.scnodes[i].in_ctx != pred_in_ctx) {
6879 continue;
6880 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01006881 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006882
Michal Vasko004d3152020-06-11 19:59:22 +02006883 *tok_idx = orig_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006884
Michal Vasko004d3152020-06-11 19:59:22 +02006885 rc = eval_expr_select(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006886 LY_CHECK_RET(rc);
6887
6888 set->val.scnodes[i].in_ctx = pred_in_ctx;
6889 }
6890
6891 /* restore the state as it was before the predicate */
6892 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006893 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko1a09b212021-05-06 13:00:10 +02006894 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006895 } else if (set->val.scnodes[i].in_ctx == pred_in_ctx) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006896 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006897 }
6898 }
6899
6900 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02006901 set2.type = LYXP_SET_NODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006902 set_fill_set(&set2, set);
6903
Michal Vasko004d3152020-06-11 19:59:22 +02006904 rc = eval_expr_select(exp, tok_idx, 0, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006905 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02006906 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006907 return rc;
6908 }
6909
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006910 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko004d3152020-06-11 19:59:22 +02006911 if (!set2.val.bln) {
Michal Vaskod3678892020-05-21 10:06:58 +02006912 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006913 }
Michal Vaskod3678892020-05-21 10:06:58 +02006914 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006915 }
6916
6917 /* ']' */
Michal Vasko004d3152020-06-11 19:59:22 +02006918 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
aPiecek8b0cc152021-05-31 16:40:31 +02006919 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02006920 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02006921 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006922
6923 return LY_SUCCESS;
6924}
6925
6926/**
Michal Vaskod3678892020-05-21 10:06:58 +02006927 * @brief Evaluate Literal. Logs directly on error.
6928 *
6929 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02006930 * @param[in] tok_idx Position in the expression @p exp.
Michal Vaskod3678892020-05-21 10:06:58 +02006931 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
6932 */
6933static void
Michal Vasko40308e72020-10-20 16:38:40 +02006934eval_literal(const struct lyxp_expr *exp, uint16_t *tok_idx, struct lyxp_set *set)
Michal Vaskod3678892020-05-21 10:06:58 +02006935{
6936 if (set) {
Michal Vasko004d3152020-06-11 19:59:22 +02006937 if (exp->tok_len[*tok_idx] == 2) {
Michal Vaskod3678892020-05-21 10:06:58 +02006938 set_fill_string(set, "", 0);
6939 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02006940 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 +02006941 }
6942 }
6943 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02006944 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02006945 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02006946}
6947
6948/**
Michal Vasko004d3152020-06-11 19:59:22 +02006949 * @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 +02006950 *
Michal Vasko004d3152020-06-11 19:59:22 +02006951 * @param[in] exp Full parsed XPath expression.
6952 * @param[in,out] tok_idx Index in @p exp at the beginning of the predicate, is updated on success.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006953 * @param[in] ctx_node Found schema node as the context for the predicate.
6954 * @param[in] cur_mod Current module for the expression.
6955 * @param[in] cur_node Current (original context) node.
Michal Vasko004d3152020-06-11 19:59:22 +02006956 * @param[in] format Format of any prefixes in key names/values.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006957 * @param[in] prefix_data Format-specific prefix data (see ::ly_resolve_prefix).
Michal Vasko004d3152020-06-11 19:59:22 +02006958 * @param[out] predicates Parsed predicates.
6959 * @param[out] pred_type Type of @p predicates.
6960 * @return LY_SUCCESS on success,
6961 * @return LY_ERR on any error.
Michal Vaskod3678892020-05-21 10:06:58 +02006962 */
6963static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02006964eval_name_test_try_compile_predicates(const struct lyxp_expr *exp, uint16_t *tok_idx, const struct lysc_node *ctx_node,
Radek Krejci8df109d2021-04-23 12:19:08 +02006965 const struct lys_module *cur_mod, const struct lysc_node *cur_node, LY_VALUE_FORMAT format, void *prefix_data,
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006966 struct ly_path_predicate **predicates, enum ly_path_pred_type *pred_type)
Michal Vaskod3678892020-05-21 10:06:58 +02006967{
Michal Vasko004d3152020-06-11 19:59:22 +02006968 LY_ERR ret = LY_SUCCESS;
6969 uint16_t key_count, e_idx, pred_idx = 0;
Michal Vaskod3678892020-05-21 10:06:58 +02006970 const struct lysc_node *key;
Michal Vasko004d3152020-06-11 19:59:22 +02006971 size_t pred_len;
Radek Krejci1deb5be2020-08-26 16:43:36 +02006972 uint32_t prev_lo;
Michal Vasko004d3152020-06-11 19:59:22 +02006973 struct lyxp_expr *exp2 = NULL;
Michal Vaskod3678892020-05-21 10:06:58 +02006974
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006975 assert(ctx_node->nodetype & (LYS_LIST | LYS_LEAFLIST));
Michal Vaskod3678892020-05-21 10:06:58 +02006976
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006977 if (ctx_node->nodetype == LYS_LIST) {
Michal Vasko004d3152020-06-11 19:59:22 +02006978 /* get key count */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006979 if (ctx_node->flags & LYS_KEYLESS) {
Michal Vasko004d3152020-06-11 19:59:22 +02006980 return LY_EINVAL;
6981 }
Michal Vasko544e58a2021-01-28 14:33:41 +01006982 for (key_count = 0, key = lysc_node_child(ctx_node); key && (key->flags & LYS_KEY); key = key->next, ++key_count) {}
Michal Vasko004d3152020-06-11 19:59:22 +02006983 assert(key_count);
Michal Vaskod3678892020-05-21 10:06:58 +02006984
Michal Vasko004d3152020-06-11 19:59:22 +02006985 /* learn where the predicates end */
6986 e_idx = *tok_idx;
6987 while (key_count) {
6988 /* '[' */
6989 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
6990 return LY_EINVAL;
6991 }
6992 ++e_idx;
6993
Michal Vasko3354d272021-04-06 09:40:06 +02006994 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_NAMETEST)) {
6995 /* definitely not a key */
6996 return LY_EINVAL;
6997 }
6998
Michal Vasko004d3152020-06-11 19:59:22 +02006999 /* ']' */
7000 while (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK2)) {
7001 ++e_idx;
7002 }
7003 ++e_idx;
7004
7005 /* another presumably key predicate parsed */
7006 --key_count;
7007 }
Michal Vasko004d3152020-06-11 19:59:22 +02007008 } else {
7009 /* learn just where this single predicate ends */
7010 e_idx = *tok_idx;
7011
Michal Vaskod3678892020-05-21 10:06:58 +02007012 /* '[' */
Michal Vasko004d3152020-06-11 19:59:22 +02007013 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
7014 return LY_EINVAL;
7015 }
7016 ++e_idx;
Michal Vaskod3678892020-05-21 10:06:58 +02007017
Michal Vasko3354d272021-04-06 09:40:06 +02007018 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_DOT)) {
7019 /* definitely not the value */
7020 return LY_EINVAL;
7021 }
7022
Michal Vaskod3678892020-05-21 10:06:58 +02007023 /* ']' */
Michal Vasko004d3152020-06-11 19:59:22 +02007024 while (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK2)) {
7025 ++e_idx;
7026 }
7027 ++e_idx;
Michal Vaskod3678892020-05-21 10:06:58 +02007028 }
7029
Michal Vasko004d3152020-06-11 19:59:22 +02007030 /* get the joined length of all the keys predicates/of the single leaf-list predicate */
7031 pred_len = (exp->tok_pos[e_idx - 1] + exp->tok_len[e_idx - 1]) - exp->tok_pos[*tok_idx];
7032
7033 /* turn logging off */
7034 prev_lo = ly_log_options(0);
7035
7036 /* parse the predicate(s) */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007037 LY_CHECK_GOTO(ret = ly_path_parse_predicate(ctx_node->module->ctx, ctx_node, exp->expr + exp->tok_pos[*tok_idx],
7038 pred_len, LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &exp2), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02007039
7040 /* compile */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007041 ret = ly_path_compile_predicate(ctx_node->module->ctx, cur_node, cur_mod, ctx_node, exp2, &pred_idx, format,
7042 prefix_data, predicates, pred_type);
Michal Vasko004d3152020-06-11 19:59:22 +02007043 LY_CHECK_GOTO(ret, cleanup);
7044
7045 /* success, the predicate must include all the needed information for hash-based search */
7046 *tok_idx = e_idx;
7047
7048cleanup:
7049 ly_log_options(prev_lo);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007050 lyxp_expr_free(ctx_node->module->ctx, exp2);
Michal Vasko004d3152020-06-11 19:59:22 +02007051 return ret;
Michal Vaskod3678892020-05-21 10:06:58 +02007052}
7053
7054/**
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007055 * @brief Search for/check the next schema node that could be the only matching schema node meaning the
7056 * data node(s) could be found using a single hash-based search.
7057 *
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007058 * @param[in] ctx libyang context.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007059 * @param[in] node Next context node to check.
7060 * @param[in] name Expected node name.
7061 * @param[in] name_len Length of @p name.
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007062 * @param[in] moveto_mod Expected node module, can be NULL for JSON format with no prefix.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007063 * @param[in] root_type XPath root type.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007064 * @param[in] format Prefix format.
7065 * @param[in,out] found Previously found node, is updated.
7066 * @return LY_SUCCESS on success,
7067 * @return LY_ENOT if the whole check failed and hashes cannot be used.
7068 */
7069static LY_ERR
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007070eval_name_test_with_predicate_get_scnode(const struct ly_ctx *ctx, const struct lyd_node *node, const char *name,
Radek Krejci8df109d2021-04-23 12:19:08 +02007071 uint16_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 +02007072 const struct lysc_node **found)
7073{
7074 const struct lysc_node *scnode;
7075 const struct lys_module *mod;
7076 uint32_t idx = 0;
7077
Radek Krejci8df109d2021-04-23 12:19:08 +02007078 assert((format == LY_VALUE_JSON) || moveto_mod);
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007079
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007080continue_search:
Michal Vasko7d1d0912020-10-16 08:38:30 +02007081 scnode = NULL;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007082 if (!node) {
Radek Krejci8df109d2021-04-23 12:19:08 +02007083 if ((format == LY_VALUE_JSON) && !moveto_mod) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007084 /* search all modules for a single match */
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007085 while ((mod = ly_ctx_get_module_iter(ctx, &idx))) {
Michal Vasko35a3b1d2021-07-14 09:34:16 +02007086 if (!mod->implemented) {
7087 continue;
7088 }
7089
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007090 scnode = lys_find_child(NULL, mod, name, name_len, 0, 0);
7091 if (scnode) {
7092 /* we have found a match */
7093 break;
7094 }
7095 }
7096
Michal Vasko7d1d0912020-10-16 08:38:30 +02007097 if (!scnode) {
7098 /* all modules searched */
7099 idx = 0;
7100 }
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007101 } else {
7102 /* search in top-level */
7103 scnode = lys_find_child(NULL, moveto_mod, name, name_len, 0, 0);
7104 }
7105 } else if (!*found || (lysc_data_parent(*found) != node->schema)) {
Radek Krejci8df109d2021-04-23 12:19:08 +02007106 if ((format == LY_VALUE_JSON) && !moveto_mod) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007107 /* we must adjust the module to inherit the one from the context node */
7108 moveto_mod = node->schema->module;
7109 }
7110
7111 /* search in children, do not repeat the same search */
7112 scnode = lys_find_child(node->schema, moveto_mod, name, name_len, 0, 0);
Michal Vasko7d1d0912020-10-16 08:38:30 +02007113 } /* else skip redundant search */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007114
7115 /* additional context check */
7116 if (scnode && (root_type == LYXP_NODE_ROOT_CONFIG) && (scnode->flags & LYS_CONFIG_R)) {
7117 scnode = NULL;
7118 }
7119
7120 if (scnode) {
7121 if (*found) {
7122 /* we found a schema node with the same name but at different level, give up, too complicated
7123 * (more hash-based searches would be required, not supported) */
7124 return LY_ENOT;
7125 } else {
7126 /* remember the found schema node and continue to make sure it can be used */
7127 *found = scnode;
7128 }
7129 }
7130
7131 if (idx) {
7132 /* continue searching all the following models */
7133 goto continue_search;
7134 }
7135
7136 return LY_SUCCESS;
7137}
7138
7139/**
Michal Vasko4ad69e72021-10-26 16:25:55 +02007140 * @brief Generate message when no matching schema nodes were found for a path segment.
7141 *
7142 * @param[in] set XPath set.
7143 * @param[in] scparent Previous schema parent in the context, if only one.
7144 * @param[in] ncname XPath NCName being evaluated.
7145 * @param[in] ncname_len Length of @p ncname.
7146 * @param[in] expr Whole XPath expression.
7147 * @param[in] options XPath options.
7148 */
7149static void
7150eval_name_test_scnode_no_match_msg(struct lyxp_set *set, const struct lyxp_set_scnode *scparent, const char *ncname,
7151 uint16_t ncname_len, const char *expr, uint32_t options)
7152{
7153 const char *format;
7154 char *path = NULL, *ppath = NULL;
7155
7156 path = lysc_path(set->cur_scnode, LYSC_PATH_LOG, NULL, 0);
7157 if (scparent) {
7158 /* generate path for the parent */
7159 if (scparent->type == LYXP_NODE_ELEM) {
7160 ppath = lysc_path(scparent->scnode, LYSC_PATH_LOG, NULL, 0);
7161 } else if (scparent->type == LYXP_NODE_ROOT) {
7162 ppath = strdup("<root>");
7163 } else if (scparent->type == LYXP_NODE_ROOT_CONFIG) {
7164 ppath = strdup("<config-root>");
7165 }
7166 }
7167 if (ppath) {
7168 format = "Schema node \"%.*s\" for parent \"%s\" not found; in expr \"%.*s\" with context node \"%s\".";
7169 if (options & LYXP_SCNODE_ERROR) {
7170 LOGERR(set->ctx, LY_EVALID, format, ncname_len, ncname, ppath, (ncname - expr) + ncname_len, expr, path);
7171 } else {
7172 LOGWRN(set->ctx, format, ncname_len, ncname, ppath, (ncname - expr) + ncname_len, expr, path);
7173 }
7174 } else {
7175 format = "Schema node \"%.*s\" not found; in expr \"%.*s\" with context node \"%s\".";
7176 if (options & LYXP_SCNODE_ERROR) {
7177 LOGERR(set->ctx, LY_EVALID, format, ncname_len, ncname, (ncname - expr) + ncname_len, expr, path);
7178 } else {
7179 LOGWRN(set->ctx, format, ncname_len, ncname, (ncname - expr) + ncname_len, expr, path);
7180 }
7181 }
7182 free(path);
7183 free(ppath);
7184}
7185
7186/**
Michal Vaskod3678892020-05-21 10:06:58 +02007187 * @brief Evaluate NameTest and any following Predicates. Logs directly on error.
7188 *
7189 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
7190 * [6] NodeTest ::= NameTest | NodeType '(' ')'
7191 * [7] NameTest ::= '*' | NCName ':' '*' | QName
7192 *
7193 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007194 * @param[in] tok_idx Position in the expression @p exp.
Michal Vaskod3678892020-05-21 10:06:58 +02007195 * @param[in] attr_axis Whether to search attributes or standard nodes.
7196 * @param[in] all_desc Whether to search all the descendants or children only.
aPiecek8b0cc152021-05-31 16:40:31 +02007197 * @param[in,out] set Context and result set.
Michal Vaskod3678892020-05-21 10:06:58 +02007198 * @param[in] options XPath options.
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007199 * @return LY_ERR (LY_EINCOMPLETE on unresolved when, LY_ENOT for not found schema node)
Michal Vaskod3678892020-05-21 10:06:58 +02007200 */
7201static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007202eval_name_test_with_predicate(const struct lyxp_expr *exp, uint16_t *tok_idx, ly_bool attr_axis, ly_bool all_desc,
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007203 struct lyxp_set *set, uint32_t options)
Michal Vaskod3678892020-05-21 10:06:58 +02007204{
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007205 LY_ERR rc = LY_SUCCESS, r;
Michal Vasko004d3152020-06-11 19:59:22 +02007206 const char *ncname, *ncname_dict = NULL;
7207 uint16_t ncname_len;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007208 const struct lys_module *moveto_mod = NULL;
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007209 const struct lysc_node *scnode = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02007210 struct ly_path_predicate *predicates = NULL;
7211 enum ly_path_pred_type pred_type = 0;
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007212 int scnode_skip_pred = 0;
Michal Vaskod3678892020-05-21 10:06:58 +02007213
aPiecek8b0cc152021-05-31 16:40:31 +02007214 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007215 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007216 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007217
aPiecek8b0cc152021-05-31 16:40:31 +02007218 if (options & LYXP_SKIP_EXPR) {
Michal Vaskod3678892020-05-21 10:06:58 +02007219 goto moveto;
7220 }
7221
Michal Vasko004d3152020-06-11 19:59:22 +02007222 ncname = &exp->expr[exp->tok_pos[*tok_idx - 1]];
7223 ncname_len = exp->tok_len[*tok_idx - 1];
Michal Vaskod3678892020-05-21 10:06:58 +02007224
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007225 if ((ncname[0] == '*') && (ncname_len == 1)) {
7226 /* all nodes will match */
7227 goto moveto;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007228 }
7229
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007230 /* parse (and skip) module name */
7231 rc = moveto_resolve_model(&ncname, &ncname_len, set, NULL, &moveto_mod);
Michal Vaskod3678892020-05-21 10:06:58 +02007232 LY_CHECK_GOTO(rc, cleanup);
7233
Radek Krejci8df109d2021-04-23 12:19:08 +02007234 if (((set->format == LY_VALUE_JSON) || moveto_mod) && !attr_axis && !all_desc && (set->type == LYXP_SET_NODE_SET)) {
Michal Vaskod3678892020-05-21 10:06:58 +02007235 /* find the matching schema node in some parent in the context */
Radek Krejci1deb5be2020-08-26 16:43:36 +02007236 for (uint32_t i = 0; i < set->used; ++i) {
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007237 if (eval_name_test_with_predicate_get_scnode(set->ctx, set->val.nodes[i].node, ncname, ncname_len,
7238 moveto_mod, set->root_type, set->format, &scnode)) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007239 /* check failed */
7240 scnode = NULL;
7241 break;
Michal Vaskod3678892020-05-21 10:06:58 +02007242 }
7243 }
7244
Michal Vasko004d3152020-06-11 19:59:22 +02007245 if (scnode && (scnode->nodetype & (LYS_LIST | LYS_LEAFLIST))) {
7246 /* try to create the predicates */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007247 if (eval_name_test_try_compile_predicates(exp, tok_idx, scnode, set->cur_mod, set->cur_node ?
7248 set->cur_node->schema : NULL, set->format, set->prefix_data, &predicates, &pred_type)) {
Michal Vasko004d3152020-06-11 19:59:22 +02007249 /* hashes cannot be used */
Michal Vaskod3678892020-05-21 10:06:58 +02007250 scnode = NULL;
7251 }
7252 }
7253 }
7254
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007255 if (!scnode) {
7256 /* we are not able to match based on a schema node and not all the modules match ("*"),
Michal Vasko004d3152020-06-11 19:59:22 +02007257 * use dictionary for efficient comparison */
Radek Krejci011e4aa2020-09-04 15:22:31 +02007258 LY_CHECK_GOTO(rc = lydict_insert(set->ctx, ncname, ncname_len, &ncname_dict), cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02007259 }
7260
7261moveto:
7262 /* move to the attribute(s), data node(s), or schema node(s) */
7263 if (attr_axis) {
aPiecek8b0cc152021-05-31 16:40:31 +02007264 if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02007265 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vaskod3678892020-05-21 10:06:58 +02007266 } else {
7267 if (all_desc) {
Michal Vaskocdad7122020-11-09 21:04:44 +01007268 rc = moveto_attr_alldesc(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007269 } else {
aPiecek8b0cc152021-05-31 16:40:31 +02007270 rc = moveto_attr(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007271 }
7272 LY_CHECK_GOTO(rc, cleanup);
7273 }
7274 } else {
aPiecek8b0cc152021-05-31 16:40:31 +02007275 if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02007276 int64_t i;
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007277 const struct lyxp_set_scnode *scparent = NULL;
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007278
7279 /* remember parent if there is only one, to print in the warning */
7280 for (i = 0; i < set->used; ++i) {
7281 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
7282 if (!scparent) {
7283 /* remember the context node */
7284 scparent = &set->val.scnodes[i];
7285 } else {
7286 /* several context nodes, no reasonable error possible */
7287 scparent = NULL;
7288 break;
7289 }
7290 }
7291 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02007292
Michal Vaskod3678892020-05-21 10:06:58 +02007293 if (all_desc) {
Michal Vasko004d3152020-06-11 19:59:22 +02007294 rc = moveto_scnode_alldesc(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007295 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007296 rc = moveto_scnode(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007297 }
7298 LY_CHECK_GOTO(rc, cleanup);
7299
7300 for (i = set->used - 1; i > -1; --i) {
Michal Vasko1a09b212021-05-06 13:00:10 +02007301 if (set->val.scnodes[i].in_ctx > LYXP_SET_SCNODE_ATOM_NODE) {
Michal Vaskod3678892020-05-21 10:06:58 +02007302 break;
7303 }
7304 }
7305 if (i == -1) {
Michal Vasko4ad69e72021-10-26 16:25:55 +02007306 /* generate message */
7307 eval_name_test_scnode_no_match_msg(set, scparent, ncname, ncname_len, exp->expr, options);
7308
7309 if (options & LYXP_SCNODE_ERROR) {
7310 /* error */
7311 rc = LY_EVALID;
7312 goto cleanup;
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007313 }
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007314
7315 /* skip the predicates and the rest of this path to not generate invalid warnings */
7316 rc = LY_ENOT;
7317 scnode_skip_pred = 1;
Michal Vaskod3678892020-05-21 10:06:58 +02007318 }
7319 } else {
7320 if (all_desc) {
Michal Vaskocdad7122020-11-09 21:04:44 +01007321 rc = moveto_node_alldesc(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007322 } else {
7323 if (scnode) {
7324 /* we can find the nodes using hashes */
Michal Vaskocdad7122020-11-09 21:04:44 +01007325 rc = moveto_node_hash(set, scnode, predicates, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007326 } else {
Michal Vaskocdad7122020-11-09 21:04:44 +01007327 rc = moveto_node(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007328 }
7329 }
7330 LY_CHECK_GOTO(rc, cleanup);
7331 }
7332 }
7333
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007334 if (scnode_skip_pred) {
7335 /* skip predicates */
7336 options |= LYXP_SKIP_EXPR;
7337 }
7338
Michal Vaskod3678892020-05-21 10:06:58 +02007339 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02007340 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007341 r = eval_predicate(exp, tok_idx, set, options, 1);
7342 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02007343 }
7344
7345cleanup:
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007346 if (scnode_skip_pred) {
7347 /* restore options */
7348 options &= ~LYXP_SKIP_EXPR;
7349 }
aPiecek8b0cc152021-05-31 16:40:31 +02007350 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko004d3152020-06-11 19:59:22 +02007351 lydict_remove(set->ctx, ncname_dict);
Michal Vaskof7e16e22020-10-21 09:24:39 +02007352 ly_path_predicates_free(set->ctx, pred_type, predicates);
Michal Vaskodb51a8d2020-05-27 15:22:29 +02007353 }
Michal Vaskod3678892020-05-21 10:06:58 +02007354 return rc;
7355}
7356
7357/**
7358 * @brief Evaluate NodeType and any following Predicates. Logs directly on error.
7359 *
7360 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
7361 * [6] NodeTest ::= NameTest | NodeType '(' ')'
7362 * [8] NodeType ::= 'text' | 'node'
7363 *
7364 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007365 * @param[in] tok_idx Position in the expression @p exp.
Michal Vaskod3678892020-05-21 10:06:58 +02007366 * @param[in] attr_axis Whether to search attributes or standard nodes.
7367 * @param[in] all_desc Whether to search all the descendants or children only.
aPiecek8b0cc152021-05-31 16:40:31 +02007368 * @param[in,out] set Context and result set.
Michal Vaskod3678892020-05-21 10:06:58 +02007369 * @param[in] options XPath options.
7370 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7371 */
7372static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007373eval_node_type_with_predicate(const struct lyxp_expr *exp, uint16_t *tok_idx, ly_bool attr_axis, ly_bool all_desc,
Radek Krejci1deb5be2020-08-26 16:43:36 +02007374 struct lyxp_set *set, uint32_t options)
Michal Vaskod3678892020-05-21 10:06:58 +02007375{
7376 LY_ERR rc;
7377
7378 /* TODO */
7379 (void)attr_axis;
7380 (void)all_desc;
7381
aPiecek8b0cc152021-05-31 16:40:31 +02007382 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko004d3152020-06-11 19:59:22 +02007383 assert(exp->tok_len[*tok_idx] == 4);
Michal Vaskod3678892020-05-21 10:06:58 +02007384 if (set->type == LYXP_SET_SCNODE_SET) {
Michal Vasko1a09b212021-05-06 13:00:10 +02007385 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
aPiecek8b0cc152021-05-31 16:40:31 +02007386 options |= LYXP_SKIP_EXPR;
Michal Vaskod3678892020-05-21 10:06:58 +02007387 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007388 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "node", 4)) {
Michal Vaskod3678892020-05-21 10:06:58 +02007389 rc = xpath_node(NULL, 0, set, options);
7390 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007391 assert(!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "text", 4));
Michal Vaskod3678892020-05-21 10:06:58 +02007392 rc = xpath_text(NULL, 0, set, options);
7393 }
7394 LY_CHECK_RET(rc);
7395 }
7396 }
aPiecek8b0cc152021-05-31 16:40:31 +02007397 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007398 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007399 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007400
7401 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02007402 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
aPiecek8b0cc152021-05-31 16:40:31 +02007403 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007404 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007405 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007406
7407 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02007408 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
aPiecek8b0cc152021-05-31 16:40:31 +02007409 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007410 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007411 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007412
7413 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02007414 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
7415 rc = eval_predicate(exp, tok_idx, set, options, 1);
Michal Vaskod3678892020-05-21 10:06:58 +02007416 LY_CHECK_RET(rc);
7417 }
7418
7419 return LY_SUCCESS;
7420}
7421
7422/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02007423 * @brief Evaluate RelativeLocationPath. Logs directly on error.
7424 *
7425 * [4] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
7426 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
Michal Vaskod3678892020-05-21 10:06:58 +02007427 * [6] NodeTest ::= NameTest | NodeType '(' ')'
Michal Vasko03ff5a72019-09-11 13:49:33 +02007428 *
7429 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007430 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007431 * @param[in] all_desc Whether to search all the descendants or children only.
aPiecek8b0cc152021-05-31 16:40:31 +02007432 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007433 * @param[in] options XPath options.
7434 * @return LY_ERR (YL_EINCOMPLETE on unresolved when)
7435 */
7436static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007437eval_relative_location_path(const struct lyxp_expr *exp, uint16_t *tok_idx, ly_bool all_desc, struct lyxp_set *set,
7438 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007439{
Radek Krejci857189e2020-09-01 13:26:36 +02007440 ly_bool attr_axis;
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007441 LY_ERR rc = LY_SUCCESS;
7442 int scnode_skip_path = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007443
7444 goto step;
7445 do {
7446 /* evaluate '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02007447 if (exp->tok_len[*tok_idx] == 1) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007448 all_desc = 0;
7449 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007450 assert(exp->tok_len[*tok_idx] == 2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007451 all_desc = 1;
7452 }
aPiecek8b0cc152021-05-31 16:40:31 +02007453 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007454 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007455 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007456
7457step:
Michal Vaskod3678892020-05-21 10:06:58 +02007458 /* evaluate abbreviated axis '@'? if any */
Michal Vasko004d3152020-06-11 19:59:22 +02007459 if (exp->tokens[*tok_idx] == LYXP_TOKEN_AT) {
Michal Vaskod3678892020-05-21 10:06:58 +02007460 attr_axis = 1;
7461
aPiecek8b0cc152021-05-31 16:40:31 +02007462 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007463 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007464 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007465 } else {
7466 attr_axis = 0;
7467 }
7468
Michal Vasko03ff5a72019-09-11 13:49:33 +02007469 /* Step */
Michal Vasko004d3152020-06-11 19:59:22 +02007470 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007471 case LYXP_TOKEN_DOT:
7472 /* evaluate '.' */
aPiecek8b0cc152021-05-31 16:40:31 +02007473 if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007474 rc = moveto_scnode_self(set, all_desc, options);
7475 } else {
7476 rc = moveto_self(set, all_desc, options);
7477 }
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007478 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007479 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007480 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007481 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007482 break;
7483
7484 case LYXP_TOKEN_DDOT:
7485 /* evaluate '..' */
aPiecek8b0cc152021-05-31 16:40:31 +02007486 if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007487 rc = moveto_scnode_parent(set, all_desc, options);
7488 } else {
7489 rc = moveto_parent(set, all_desc, options);
7490 }
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007491 LY_CHECK_GOTO(rc, cleanup);
aPiecek8b0cc152021-05-31 16:40:31 +02007492 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007493 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007494 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007495 break;
7496
Michal Vasko03ff5a72019-09-11 13:49:33 +02007497 case LYXP_TOKEN_NAMETEST:
Michal Vaskod3678892020-05-21 10:06:58 +02007498 /* evaluate NameTest Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02007499 rc = eval_name_test_with_predicate(exp, tok_idx, attr_axis, all_desc, set, options);
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007500 if (rc == LY_ENOT) {
7501 assert(options & LYXP_SCNODE_ALL);
7502 /* skip the rest of this path */
7503 rc = LY_SUCCESS;
7504 scnode_skip_path = 1;
7505 options |= LYXP_SKIP_EXPR;
7506 }
7507 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02007508 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007509
Michal Vaskod3678892020-05-21 10:06:58 +02007510 case LYXP_TOKEN_NODETYPE:
7511 /* evaluate NodeType Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02007512 rc = eval_node_type_with_predicate(exp, tok_idx, attr_axis, all_desc, set, options);
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007513 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007514 break;
7515
7516 default:
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007517 LOGINT(set->ctx);
7518 rc = LY_EINT;
7519 goto cleanup;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007520 }
Michal Vasko004d3152020-06-11 19:59:22 +02007521 } while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007522
Michal Vaskoa036a6b2021-10-12 16:05:23 +02007523cleanup:
7524 if (scnode_skip_path) {
7525 options &= ~LYXP_SKIP_EXPR;
7526 }
7527 return rc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007528}
7529
7530/**
7531 * @brief Evaluate AbsoluteLocationPath. Logs directly on error.
7532 *
7533 * [3] AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
7534 *
7535 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007536 * @param[in] tok_idx Position in the expression @p exp.
aPiecek8b0cc152021-05-31 16:40:31 +02007537 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007538 * @param[in] options XPath options.
7539 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7540 */
7541static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007542eval_absolute_location_path(const struct lyxp_expr *exp, uint16_t *tok_idx, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007543{
Radek Krejci857189e2020-09-01 13:26:36 +02007544 ly_bool all_desc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007545
aPiecek8b0cc152021-05-31 16:40:31 +02007546 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007547 /* no matter what tokens follow, we need to be at the root */
Michal Vaskob0099a92020-08-31 14:55:23 +02007548 LY_CHECK_RET(moveto_root(set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007549 }
7550
7551 /* '/' RelativeLocationPath? */
Michal Vasko004d3152020-06-11 19:59:22 +02007552 if (exp->tok_len[*tok_idx] == 1) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007553 /* evaluate '/' - deferred */
7554 all_desc = 0;
aPiecek8b0cc152021-05-31 16:40:31 +02007555 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007556 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007557 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007558
Michal Vasko004d3152020-06-11 19:59:22 +02007559 if (lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007560 return LY_SUCCESS;
7561 }
Michal Vasko004d3152020-06-11 19:59:22 +02007562 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007563 case LYXP_TOKEN_DOT:
7564 case LYXP_TOKEN_DDOT:
7565 case LYXP_TOKEN_AT:
7566 case LYXP_TOKEN_NAMETEST:
7567 case LYXP_TOKEN_NODETYPE:
Michal Vaskob0099a92020-08-31 14:55:23 +02007568 LY_CHECK_RET(eval_relative_location_path(exp, tok_idx, all_desc, set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007569 break;
7570 default:
7571 break;
7572 }
7573
Michal Vasko03ff5a72019-09-11 13:49:33 +02007574 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02007575 /* '//' RelativeLocationPath */
Michal Vasko03ff5a72019-09-11 13:49:33 +02007576 /* evaluate '//' - deferred so as not to waste memory by remembering all the nodes */
7577 all_desc = 1;
aPiecek8b0cc152021-05-31 16:40:31 +02007578 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007579 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007580 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007581
Michal Vaskob0099a92020-08-31 14:55:23 +02007582 LY_CHECK_RET(eval_relative_location_path(exp, tok_idx, all_desc, set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007583 }
7584
7585 return LY_SUCCESS;
7586}
7587
7588/**
7589 * @brief Evaluate FunctionCall. Logs directly on error.
7590 *
Michal Vaskod3678892020-05-21 10:06:58 +02007591 * [11] FunctionCall ::= FunctionName '(' ( Expr ( ',' Expr )* )? ')'
Michal Vasko03ff5a72019-09-11 13:49:33 +02007592 *
7593 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007594 * @param[in] tok_idx Position in the expression @p exp.
aPiecek8b0cc152021-05-31 16:40:31 +02007595 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007596 * @param[in] options XPath options.
7597 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7598 */
7599static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007600eval_function_call(const struct lyxp_expr *exp, uint16_t *tok_idx, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007601{
7602 LY_ERR rc;
Michal Vasko69730152020-10-09 16:30:07 +02007603
Radek Krejci1deb5be2020-08-26 16:43:36 +02007604 LY_ERR (*xpath_func)(struct lyxp_set **, uint16_t, struct lyxp_set *, uint32_t) = NULL;
Michal Vasko0cbf54f2019-12-16 10:01:06 +01007605 uint16_t arg_count = 0, i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007606 struct lyxp_set **args = NULL, **args_aux;
7607
aPiecek8b0cc152021-05-31 16:40:31 +02007608 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007609 /* FunctionName */
Michal Vasko004d3152020-06-11 19:59:22 +02007610 switch (exp->tok_len[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007611 case 3:
Michal Vasko004d3152020-06-11 19:59:22 +02007612 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "not", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007613 xpath_func = &xpath_not;
Michal Vasko004d3152020-06-11 19:59:22 +02007614 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "sum", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007615 xpath_func = &xpath_sum;
7616 }
7617 break;
7618 case 4:
Michal Vasko004d3152020-06-11 19:59:22 +02007619 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "lang", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007620 xpath_func = &xpath_lang;
Michal Vasko004d3152020-06-11 19:59:22 +02007621 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "last", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007622 xpath_func = &xpath_last;
Michal Vasko004d3152020-06-11 19:59:22 +02007623 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "name", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007624 xpath_func = &xpath_name;
Michal Vasko004d3152020-06-11 19:59:22 +02007625 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "true", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007626 xpath_func = &xpath_true;
7627 }
7628 break;
7629 case 5:
Michal Vasko004d3152020-06-11 19:59:22 +02007630 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "count", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007631 xpath_func = &xpath_count;
Michal Vasko004d3152020-06-11 19:59:22 +02007632 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "false", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007633 xpath_func = &xpath_false;
Michal Vasko004d3152020-06-11 19:59:22 +02007634 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "floor", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007635 xpath_func = &xpath_floor;
Michal Vasko004d3152020-06-11 19:59:22 +02007636 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "round", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007637 xpath_func = &xpath_round;
Michal Vasko004d3152020-06-11 19:59:22 +02007638 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "deref", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007639 xpath_func = &xpath_deref;
7640 }
7641 break;
7642 case 6:
Michal Vasko004d3152020-06-11 19:59:22 +02007643 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "concat", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007644 xpath_func = &xpath_concat;
Michal Vasko004d3152020-06-11 19:59:22 +02007645 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "number", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007646 xpath_func = &xpath_number;
Michal Vasko004d3152020-06-11 19:59:22 +02007647 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007648 xpath_func = &xpath_string;
7649 }
7650 break;
7651 case 7:
Michal Vasko004d3152020-06-11 19:59:22 +02007652 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "boolean", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007653 xpath_func = &xpath_boolean;
Michal Vasko004d3152020-06-11 19:59:22 +02007654 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "ceiling", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007655 xpath_func = &xpath_ceiling;
Michal Vasko004d3152020-06-11 19:59:22 +02007656 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "current", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007657 xpath_func = &xpath_current;
7658 }
7659 break;
7660 case 8:
Michal Vasko004d3152020-06-11 19:59:22 +02007661 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "contains", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007662 xpath_func = &xpath_contains;
Michal Vasko004d3152020-06-11 19:59:22 +02007663 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "position", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007664 xpath_func = &xpath_position;
Michal Vasko004d3152020-06-11 19:59:22 +02007665 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "re-match", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007666 xpath_func = &xpath_re_match;
7667 }
7668 break;
7669 case 9:
Michal Vasko004d3152020-06-11 19:59:22 +02007670 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007671 xpath_func = &xpath_substring;
Michal Vasko004d3152020-06-11 19:59:22 +02007672 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "translate", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007673 xpath_func = &xpath_translate;
7674 }
7675 break;
7676 case 10:
Michal Vasko004d3152020-06-11 19:59:22 +02007677 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "local-name", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007678 xpath_func = &xpath_local_name;
Michal Vasko004d3152020-06-11 19:59:22 +02007679 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "enum-value", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007680 xpath_func = &xpath_enum_value;
Michal Vasko004d3152020-06-11 19:59:22 +02007681 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "bit-is-set", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007682 xpath_func = &xpath_bit_is_set;
7683 }
7684 break;
7685 case 11:
Michal Vasko004d3152020-06-11 19:59:22 +02007686 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "starts-with", 11)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007687 xpath_func = &xpath_starts_with;
7688 }
7689 break;
7690 case 12:
Michal Vasko004d3152020-06-11 19:59:22 +02007691 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from", 12)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007692 xpath_func = &xpath_derived_from;
7693 }
7694 break;
7695 case 13:
Michal Vasko004d3152020-06-11 19:59:22 +02007696 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "namespace-uri", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007697 xpath_func = &xpath_namespace_uri;
Michal Vasko004d3152020-06-11 19:59:22 +02007698 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string-length", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007699 xpath_func = &xpath_string_length;
7700 }
7701 break;
7702 case 15:
Michal Vasko004d3152020-06-11 19:59:22 +02007703 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "normalize-space", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007704 xpath_func = &xpath_normalize_space;
Michal Vasko004d3152020-06-11 19:59:22 +02007705 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-after", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007706 xpath_func = &xpath_substring_after;
7707 }
7708 break;
7709 case 16:
Michal Vasko004d3152020-06-11 19:59:22 +02007710 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-before", 16)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007711 xpath_func = &xpath_substring_before;
7712 }
7713 break;
7714 case 20:
Michal Vasko004d3152020-06-11 19:59:22 +02007715 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from-or-self", 20)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007716 xpath_func = &xpath_derived_from_or_self;
7717 }
7718 break;
7719 }
7720
7721 if (!xpath_func) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01007722 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 +02007723 return LY_EVALID;
7724 }
7725 }
7726
aPiecek8b0cc152021-05-31 16:40:31 +02007727 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007728 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007729 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007730
7731 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02007732 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
aPiecek8b0cc152021-05-31 16:40:31 +02007733 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007734 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007735 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007736
7737 /* ( Expr ( ',' Expr )* )? */
Michal Vasko004d3152020-06-11 19:59:22 +02007738 if (exp->tokens[*tok_idx] != LYXP_TOKEN_PAR2) {
aPiecek8b0cc152021-05-31 16:40:31 +02007739 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007740 args = malloc(sizeof *args);
7741 LY_CHECK_ERR_GOTO(!args, LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
7742 arg_count = 1;
7743 args[0] = set_copy(set);
7744 if (!args[0]) {
7745 rc = LY_EMEM;
7746 goto cleanup;
7747 }
7748
Michal Vasko004d3152020-06-11 19:59:22 +02007749 rc = eval_expr_select(exp, tok_idx, 0, args[0], options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007750 LY_CHECK_GOTO(rc, cleanup);
7751 } else {
aPiecek8b0cc152021-05-31 16:40:31 +02007752 rc = eval_expr_select(exp, tok_idx, 0, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007753 LY_CHECK_GOTO(rc, cleanup);
7754 }
7755 }
Michal Vasko004d3152020-06-11 19:59:22 +02007756 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_COMMA)) {
aPiecek8b0cc152021-05-31 16:40:31 +02007757 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007758 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007759 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007760
aPiecek8b0cc152021-05-31 16:40:31 +02007761 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007762 ++arg_count;
7763 args_aux = realloc(args, arg_count * sizeof *args);
7764 LY_CHECK_ERR_GOTO(!args_aux, arg_count--; LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
7765 args = args_aux;
7766 args[arg_count - 1] = set_copy(set);
7767 if (!args[arg_count - 1]) {
7768 rc = LY_EMEM;
7769 goto cleanup;
7770 }
7771
Michal Vasko004d3152020-06-11 19:59:22 +02007772 rc = eval_expr_select(exp, tok_idx, 0, args[arg_count - 1], options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007773 LY_CHECK_GOTO(rc, cleanup);
7774 } else {
aPiecek8b0cc152021-05-31 16:40:31 +02007775 rc = eval_expr_select(exp, tok_idx, 0, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007776 LY_CHECK_GOTO(rc, cleanup);
7777 }
7778 }
7779
7780 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02007781 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
aPiecek8b0cc152021-05-31 16:40:31 +02007782 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007783 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007784 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007785
aPiecek8b0cc152021-05-31 16:40:31 +02007786 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007787 /* evaluate function */
7788 rc = xpath_func(args, arg_count, set, options);
7789
7790 if (options & LYXP_SCNODE_ALL) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007791 /* merge all nodes from arg evaluations */
7792 for (i = 0; i < arg_count; ++i) {
Michal Vasko1a09b212021-05-06 13:00:10 +02007793 set_scnode_clear_ctx(args[i], LYXP_SET_SCNODE_ATOM_NODE);
Michal Vaskoecd62de2019-11-13 12:35:11 +01007794 lyxp_set_scnode_merge(set, args[i]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007795 }
7796 }
7797 } else {
7798 rc = LY_SUCCESS;
7799 }
7800
7801cleanup:
7802 for (i = 0; i < arg_count; ++i) {
7803 lyxp_set_free(args[i]);
7804 }
7805 free(args);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007806 return rc;
7807}
7808
7809/**
7810 * @brief Evaluate Number. Logs directly on error.
7811 *
7812 * @param[in] ctx Context for errors.
7813 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007814 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007815 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7816 * @return LY_ERR
7817 */
7818static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007819eval_number(struct ly_ctx *ctx, const struct lyxp_expr *exp, uint16_t *tok_idx, struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007820{
7821 long double num;
7822 char *endptr;
7823
7824 if (set) {
7825 errno = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02007826 num = strtold(&exp->expr[exp->tok_pos[*tok_idx]], &endptr);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007827 if (errno) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01007828 LOGVAL(ctx, LY_VCODE_XP_INTOK, "Unknown", &exp->expr[exp->tok_pos[*tok_idx]]);
7829 LOGVAL(ctx, LYVE_XPATH, "Failed to convert \"%.*s\" into a long double (%s).",
Michal Vasko69730152020-10-09 16:30:07 +02007830 exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]], strerror(errno));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007831 return LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +02007832 } else if (endptr - &exp->expr[exp->tok_pos[*tok_idx]] != exp->tok_len[*tok_idx]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01007833 LOGVAL(ctx, LY_VCODE_XP_INTOK, "Unknown", &exp->expr[exp->tok_pos[*tok_idx]]);
7834 LOGVAL(ctx, LYVE_XPATH, "Failed to convert \"%.*s\" into a long double.",
Michal Vasko69730152020-10-09 16:30:07 +02007835 exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007836 return LY_EVALID;
7837 }
7838
7839 set_fill_number(set, num);
7840 }
7841
7842 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007843 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007844 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007845 return LY_SUCCESS;
7846}
7847
aPiecekdf23eee2021-10-07 12:21:50 +02007848LY_ERR
7849lyxp_vars_find(struct lyxp_var *vars, const char *name, size_t name_len, struct lyxp_var **var)
7850{
7851 LY_ERR ret = LY_ENOTFOUND;
7852 LY_ARRAY_COUNT_TYPE u;
7853
7854 assert(vars && name);
7855
7856 name_len = name_len ? name_len : strlen(name);
7857
7858 LY_ARRAY_FOR(vars, u) {
7859 if (!strncmp(vars[u].name, name, name_len)) {
7860 ret = LY_SUCCESS;
7861 break;
7862 }
7863 }
7864
7865 if (var && !ret) {
7866 *var = &vars[u];
7867 }
7868
7869 return ret;
7870}
7871
Michal Vasko03ff5a72019-09-11 13:49:33 +02007872/**
aPiecekfba75362021-10-07 12:39:48 +02007873 * @brief Evaluate VariableReference.
7874 *
7875 * @param[in] exp Parsed XPath expression.
7876 * @param[in] tok_idx Position in the expression @p exp.
7877 * @param[in] vars [Sized array](@ref sizedarrays) of XPath variables.
7878 * @param[in,out] set Context and result set.
7879 * @param[in] options XPath options.
7880 * @return LY_ERR value.
7881 */
7882static LY_ERR
7883eval_variable_reference(const struct lyxp_expr *exp, uint16_t *tok_idx, struct lyxp_set *set, uint32_t options)
7884{
7885 LY_ERR ret;
7886 const char *name;
7887 struct lyxp_var *var;
7888 const struct lyxp_var *vars;
7889 struct lyxp_expr *tokens = NULL;
7890 uint16_t token_index;
7891
7892 vars = set->vars;
7893
7894 /* Find out the name and value of the variable. */
7895 name = &exp->expr[exp->tok_pos[*tok_idx]];
7896 ret = lyxp_vars_find((struct lyxp_var *)vars, name, exp->tok_len[*tok_idx], &var);
7897 LY_CHECK_ERR_RET(ret, LOGERR(set->ctx, ret,
7898 "XPath variable \"%s\" not defined.", name), ret);
7899
7900 /* Parse value. */
7901 ret = lyxp_expr_parse(set->ctx, var->value, 0, 1, &tokens);
7902 LY_CHECK_GOTO(ret, cleanup);
7903
7904 /* Evaluate value. */
7905 token_index = 0;
7906 ret = eval_expr_select(tokens, &token_index, 0, set, options);
7907 LY_CHECK_GOTO(ret, cleanup);
7908
7909cleanup:
7910 lyxp_expr_free(set->ctx, tokens);
7911
7912 return ret;
7913}
7914
7915/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02007916 * @brief Evaluate PathExpr. Logs directly on error.
7917 *
Michal Vaskod3678892020-05-21 10:06:58 +02007918 * [12] PathExpr ::= LocationPath | PrimaryExpr Predicate*
Michal Vasko03ff5a72019-09-11 13:49:33 +02007919 * | PrimaryExpr Predicate* '/' RelativeLocationPath
7920 * | PrimaryExpr Predicate* '//' RelativeLocationPath
7921 * [2] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
aPiecekfba75362021-10-07 12:39:48 +02007922 * [10] PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
Michal Vasko03ff5a72019-09-11 13:49:33 +02007923 *
7924 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007925 * @param[in] tok_idx Position in the expression @p exp.
aPiecek8b0cc152021-05-31 16:40:31 +02007926 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007927 * @param[in] options XPath options.
7928 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7929 */
7930static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007931eval_path_expr(const struct lyxp_expr *exp, uint16_t *tok_idx, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007932{
Radek Krejci857189e2020-09-01 13:26:36 +02007933 ly_bool all_desc, parent_pos_pred;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007934 LY_ERR rc;
7935
Michal Vasko004d3152020-06-11 19:59:22 +02007936 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007937 case LYXP_TOKEN_PAR1:
7938 /* '(' Expr ')' */
7939
7940 /* '(' */
aPiecek8b0cc152021-05-31 16:40:31 +02007941 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007942 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007943 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007944
7945 /* Expr */
Michal Vasko004d3152020-06-11 19:59:22 +02007946 rc = eval_expr_select(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007947 LY_CHECK_RET(rc);
7948
7949 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02007950 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
aPiecek8b0cc152021-05-31 16:40:31 +02007951 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02007952 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007953 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007954
7955 parent_pos_pred = 0;
7956 goto predicate;
7957
7958 case LYXP_TOKEN_DOT:
7959 case LYXP_TOKEN_DDOT:
7960 case LYXP_TOKEN_AT:
7961 case LYXP_TOKEN_NAMETEST:
7962 case LYXP_TOKEN_NODETYPE:
7963 /* RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02007964 rc = eval_relative_location_path(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007965 LY_CHECK_RET(rc);
7966 break;
7967
aPiecekfba75362021-10-07 12:39:48 +02007968 case LYXP_TOKEN_VARREF:
7969 /* VariableReference */
7970 rc = eval_variable_reference(exp, tok_idx, set, options);
7971 LY_CHECK_RET(rc);
7972 ++(*tok_idx);
7973
7974 parent_pos_pred = 1;
7975 goto predicate;
7976
Michal Vasko03ff5a72019-09-11 13:49:33 +02007977 case LYXP_TOKEN_FUNCNAME:
7978 /* FunctionCall */
aPiecek8b0cc152021-05-31 16:40:31 +02007979 rc = eval_function_call(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007980 LY_CHECK_RET(rc);
7981
7982 parent_pos_pred = 1;
7983 goto predicate;
7984
Michal Vasko3e48bf32020-06-01 08:39:07 +02007985 case LYXP_TOKEN_OPER_PATH:
7986 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +02007987 /* AbsoluteLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02007988 rc = eval_absolute_location_path(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007989 LY_CHECK_RET(rc);
7990 break;
7991
7992 case LYXP_TOKEN_LITERAL:
7993 /* Literal */
aPiecek8b0cc152021-05-31 16:40:31 +02007994 if ((options & LYXP_SKIP_EXPR) || (options & LYXP_SCNODE_ALL)) {
7995 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02007996 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007997 }
Michal Vasko004d3152020-06-11 19:59:22 +02007998 eval_literal(exp, tok_idx, NULL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007999 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02008000 eval_literal(exp, tok_idx, set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008001 }
8002
8003 parent_pos_pred = 1;
8004 goto predicate;
8005
8006 case LYXP_TOKEN_NUMBER:
8007 /* Number */
aPiecek8b0cc152021-05-31 16:40:31 +02008008 if ((options & LYXP_SKIP_EXPR) || (options & LYXP_SCNODE_ALL)) {
8009 if (!(options & LYXP_SKIP_EXPR)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02008010 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008011 }
Michal Vasko004d3152020-06-11 19:59:22 +02008012 rc = eval_number(NULL, exp, tok_idx, NULL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008013 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02008014 rc = eval_number(set->ctx, exp, tok_idx, set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008015 }
8016 LY_CHECK_RET(rc);
8017
8018 parent_pos_pred = 1;
8019 goto predicate;
8020
8021 default:
Radek Krejci2efc45b2020-12-22 16:25:44 +01008022 LOGVAL(set->ctx, LY_VCODE_XP_INTOK, lyxp_print_token(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008023 return LY_EVALID;
8024 }
8025
8026 return LY_SUCCESS;
8027
8028predicate:
8029 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02008030 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
8031 rc = eval_predicate(exp, tok_idx, set, options, parent_pos_pred);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008032 LY_CHECK_RET(rc);
8033 }
8034
8035 /* ('/' or '//') RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02008036 if (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008037
8038 /* evaluate '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02008039 if (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008040 all_desc = 0;
8041 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008042 all_desc = 1;
8043 }
8044
aPiecek8b0cc152021-05-31 16:40:31 +02008045 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02008046 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008047 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008048
Michal Vasko004d3152020-06-11 19:59:22 +02008049 rc = eval_relative_location_path(exp, tok_idx, all_desc, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008050 LY_CHECK_RET(rc);
8051 }
8052
8053 return LY_SUCCESS;
8054}
8055
8056/**
8057 * @brief Evaluate UnionExpr. Logs directly on error.
8058 *
Michal Vaskod3678892020-05-21 10:06:58 +02008059 * [20] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008060 *
8061 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008062 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008063 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02008064 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008065 * @param[in] options XPath options.
8066 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8067 */
8068static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02008069eval_union_expr(const struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t repeat, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008070{
8071 LY_ERR rc = LY_SUCCESS;
8072 struct lyxp_set orig_set, set2;
8073 uint16_t i;
8074
8075 assert(repeat);
8076
8077 set_init(&orig_set, set);
8078 set_init(&set2, set);
8079
8080 set_fill_set(&orig_set, set);
8081
Michal Vasko004d3152020-06-11 19:59:22 +02008082 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008083 LY_CHECK_GOTO(rc, cleanup);
8084
8085 /* ('|' PathExpr)* */
8086 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008087 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_UNI);
aPiecek8b0cc152021-05-31 16:40:31 +02008088 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02008089 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008090 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008091
aPiecek8b0cc152021-05-31 16:40:31 +02008092 if (options & LYXP_SKIP_EXPR) {
8093 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008094 LY_CHECK_GOTO(rc, cleanup);
8095 continue;
8096 }
8097
8098 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008099 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008100 LY_CHECK_GOTO(rc, cleanup);
8101
8102 /* eval */
8103 if (options & LYXP_SCNODE_ALL) {
Michal Vaskoecd62de2019-11-13 12:35:11 +01008104 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008105 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008106 rc = moveto_union(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008107 LY_CHECK_GOTO(rc, cleanup);
8108 }
8109 }
8110
8111cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008112 lyxp_set_free_content(&orig_set);
8113 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008114 return rc;
8115}
8116
8117/**
8118 * @brief Evaluate UnaryExpr. Logs directly on error.
8119 *
Michal Vaskod3678892020-05-21 10:06:58 +02008120 * [19] UnaryExpr ::= UnionExpr | '-' UnaryExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008121 *
8122 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008123 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008124 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02008125 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008126 * @param[in] options XPath options.
8127 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8128 */
8129static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02008130eval_unary_expr(const struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t repeat, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008131{
8132 LY_ERR rc;
8133 uint16_t this_op, i;
8134
8135 assert(repeat);
8136
8137 /* ('-')+ */
Michal Vasko004d3152020-06-11 19:59:22 +02008138 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008139 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008140 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 +02008141
aPiecek8b0cc152021-05-31 16:40:31 +02008142 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02008143 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008144 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008145 }
8146
Michal Vasko004d3152020-06-11 19:59:22 +02008147 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNARY, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008148 LY_CHECK_RET(rc);
8149
aPiecek8b0cc152021-05-31 16:40:31 +02008150 if (!(options & LYXP_SKIP_EXPR) && (repeat % 2)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008151 if (options & LYXP_SCNODE_ALL) {
8152 warn_operands(set->ctx, set, NULL, 1, exp->expr, exp->tok_pos[this_op]);
8153 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008154 rc = moveto_op_math(set, NULL, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008155 LY_CHECK_RET(rc);
8156 }
8157 }
8158
8159 return LY_SUCCESS;
8160}
8161
8162/**
8163 * @brief Evaluate MultiplicativeExpr. Logs directly on error.
8164 *
Michal Vaskod3678892020-05-21 10:06:58 +02008165 * [18] MultiplicativeExpr ::= UnaryExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008166 * | MultiplicativeExpr '*' UnaryExpr
8167 * | MultiplicativeExpr 'div' UnaryExpr
8168 * | MultiplicativeExpr 'mod' UnaryExpr
8169 *
8170 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008171 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008172 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02008173 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008174 * @param[in] options XPath options.
8175 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8176 */
8177static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02008178eval_multiplicative_expr(const struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t repeat, struct lyxp_set *set,
8179 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008180{
8181 LY_ERR rc;
8182 uint16_t this_op;
8183 struct lyxp_set orig_set, set2;
8184 uint16_t i;
8185
8186 assert(repeat);
8187
8188 set_init(&orig_set, set);
8189 set_init(&set2, set);
8190
8191 set_fill_set(&orig_set, set);
8192
Michal Vasko004d3152020-06-11 19:59:22 +02008193 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008194 LY_CHECK_GOTO(rc, cleanup);
8195
8196 /* ('*' / 'div' / 'mod' UnaryExpr)* */
8197 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008198 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008199
Michal Vasko004d3152020-06-11 19:59:22 +02008200 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_MATH);
aPiecek8b0cc152021-05-31 16:40:31 +02008201 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02008202 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008203 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008204
aPiecek8b0cc152021-05-31 16:40:31 +02008205 if (options & LYXP_SKIP_EXPR) {
8206 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008207 LY_CHECK_GOTO(rc, cleanup);
8208 continue;
8209 }
8210
8211 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008212 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008213 LY_CHECK_GOTO(rc, cleanup);
8214
8215 /* eval */
8216 if (options & LYXP_SCNODE_ALL) {
8217 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008218 lyxp_set_scnode_merge(set, &set2);
Michal Vasko1a09b212021-05-06 13:00:10 +02008219 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008220 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008221 rc = moveto_op_math(set, &set2, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008222 LY_CHECK_GOTO(rc, cleanup);
8223 }
8224 }
8225
8226cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008227 lyxp_set_free_content(&orig_set);
8228 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008229 return rc;
8230}
8231
8232/**
8233 * @brief Evaluate AdditiveExpr. Logs directly on error.
8234 *
Michal Vaskod3678892020-05-21 10:06:58 +02008235 * [17] AdditiveExpr ::= MultiplicativeExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008236 * | AdditiveExpr '+' MultiplicativeExpr
8237 * | AdditiveExpr '-' MultiplicativeExpr
8238 *
8239 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008240 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008241 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02008242 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008243 * @param[in] options XPath options.
8244 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8245 */
8246static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02008247eval_additive_expr(const struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t repeat, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008248{
8249 LY_ERR rc;
8250 uint16_t this_op;
8251 struct lyxp_set orig_set, set2;
8252 uint16_t i;
8253
8254 assert(repeat);
8255
8256 set_init(&orig_set, set);
8257 set_init(&set2, set);
8258
8259 set_fill_set(&orig_set, set);
8260
Michal Vasko004d3152020-06-11 19:59:22 +02008261 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008262 LY_CHECK_GOTO(rc, cleanup);
8263
8264 /* ('+' / '-' MultiplicativeExpr)* */
8265 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008266 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008267
Michal Vasko004d3152020-06-11 19:59:22 +02008268 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_MATH);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008269 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02008270 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008271 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008272
aPiecek8b0cc152021-05-31 16:40:31 +02008273 if (options & LYXP_SKIP_EXPR) {
8274 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008275 LY_CHECK_GOTO(rc, cleanup);
8276 continue;
8277 }
8278
8279 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008280 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008281 LY_CHECK_GOTO(rc, cleanup);
8282
8283 /* eval */
8284 if (options & LYXP_SCNODE_ALL) {
8285 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008286 lyxp_set_scnode_merge(set, &set2);
Michal Vasko1a09b212021-05-06 13:00:10 +02008287 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008288 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008289 rc = moveto_op_math(set, &set2, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008290 LY_CHECK_GOTO(rc, cleanup);
8291 }
8292 }
8293
8294cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008295 lyxp_set_free_content(&orig_set);
8296 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008297 return rc;
8298}
8299
8300/**
8301 * @brief Evaluate RelationalExpr. Logs directly on error.
8302 *
Michal Vaskod3678892020-05-21 10:06:58 +02008303 * [16] RelationalExpr ::= AdditiveExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008304 * | RelationalExpr '<' AdditiveExpr
8305 * | RelationalExpr '>' AdditiveExpr
8306 * | RelationalExpr '<=' AdditiveExpr
8307 * | RelationalExpr '>=' AdditiveExpr
8308 *
8309 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008310 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008311 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02008312 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008313 * @param[in] options XPath options.
8314 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8315 */
8316static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02008317eval_relational_expr(const struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t repeat, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008318{
8319 LY_ERR rc;
8320 uint16_t this_op;
8321 struct lyxp_set orig_set, set2;
8322 uint16_t i;
8323
8324 assert(repeat);
8325
8326 set_init(&orig_set, set);
8327 set_init(&set2, set);
8328
8329 set_fill_set(&orig_set, set);
8330
Michal Vasko004d3152020-06-11 19:59:22 +02008331 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008332 LY_CHECK_GOTO(rc, cleanup);
8333
8334 /* ('<' / '>' / '<=' / '>=' AdditiveExpr)* */
8335 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008336 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008337
Michal Vasko004d3152020-06-11 19:59:22 +02008338 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_COMP);
aPiecek8b0cc152021-05-31 16:40:31 +02008339 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02008340 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008341 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008342
aPiecek8b0cc152021-05-31 16:40:31 +02008343 if (options & LYXP_SKIP_EXPR) {
8344 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008345 LY_CHECK_GOTO(rc, cleanup);
8346 continue;
8347 }
8348
8349 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008350 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008351 LY_CHECK_GOTO(rc, cleanup);
8352
8353 /* eval */
8354 if (options & LYXP_SCNODE_ALL) {
8355 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008356 lyxp_set_scnode_merge(set, &set2);
Michal Vasko1a09b212021-05-06 13:00:10 +02008357 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008358 } else {
8359 rc = moveto_op_comp(set, &set2, &exp->expr[exp->tok_pos[this_op]], options);
8360 LY_CHECK_GOTO(rc, cleanup);
8361 }
8362 }
8363
8364cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008365 lyxp_set_free_content(&orig_set);
8366 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008367 return rc;
8368}
8369
8370/**
8371 * @brief Evaluate EqualityExpr. Logs directly on error.
8372 *
Michal Vaskod3678892020-05-21 10:06:58 +02008373 * [15] EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008374 * | EqualityExpr '!=' RelationalExpr
8375 *
8376 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008377 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008378 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02008379 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008380 * @param[in] options XPath options.
8381 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8382 */
8383static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02008384eval_equality_expr(const struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t repeat, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008385{
8386 LY_ERR rc;
8387 uint16_t this_op;
8388 struct lyxp_set orig_set, set2;
8389 uint16_t i;
8390
8391 assert(repeat);
8392
8393 set_init(&orig_set, set);
8394 set_init(&set2, set);
8395
8396 set_fill_set(&orig_set, set);
8397
Michal Vasko004d3152020-06-11 19:59:22 +02008398 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008399 LY_CHECK_GOTO(rc, cleanup);
8400
8401 /* ('=' / '!=' RelationalExpr)* */
8402 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008403 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008404
Michal Vasko004d3152020-06-11 19:59:22 +02008405 assert((exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL) || (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_NEQUAL));
aPiecek8b0cc152021-05-31 16:40:31 +02008406 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (options & LYXP_SKIP_EXPR ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02008407 lyxp_print_token(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
aPiecek8b0cc152021-05-31 16:40:31 +02008410 if (options & LYXP_SKIP_EXPR) {
8411 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008412 LY_CHECK_GOTO(rc, cleanup);
8413 continue;
8414 }
8415
8416 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008417 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008418 LY_CHECK_GOTO(rc, cleanup);
8419
8420 /* eval */
8421 if (options & LYXP_SCNODE_ALL) {
8422 warn_operands(set->ctx, set, &set2, 0, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vasko004d3152020-06-11 19:59:22 +02008423 warn_equality_value(exp, set, *tok_idx - 1, this_op - 1, *tok_idx - 1);
8424 warn_equality_value(exp, &set2, this_op - 1, this_op - 1, *tok_idx - 1);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008425 lyxp_set_scnode_merge(set, &set2);
Michal Vasko1a09b212021-05-06 13:00:10 +02008426 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_VAL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008427 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008428 rc = moveto_op_comp(set, &set2, &exp->expr[exp->tok_pos[this_op]], options);
8429 LY_CHECK_GOTO(rc, cleanup);
8430 }
8431 }
8432
8433cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008434 lyxp_set_free_content(&orig_set);
8435 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008436 return rc;
8437}
8438
8439/**
8440 * @brief Evaluate AndExpr. Logs directly on error.
8441 *
Michal Vaskod3678892020-05-21 10:06:58 +02008442 * [14] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008443 *
8444 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008445 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008446 * @param[in] repeat How many times this expression is repeated.
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 Vasko40308e72020-10-20 16:38:40 +02008452eval_and_expr(const struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t repeat, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008453{
8454 LY_ERR rc;
8455 struct lyxp_set orig_set, set2;
8456 uint16_t i;
8457
8458 assert(repeat);
8459
8460 set_init(&orig_set, set);
8461 set_init(&set2, set);
8462
8463 set_fill_set(&orig_set, set);
8464
Michal Vasko004d3152020-06-11 19:59:22 +02008465 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008466 LY_CHECK_GOTO(rc, cleanup);
8467
8468 /* cast to boolean, we know that will be the final result */
aPiecek8b0cc152021-05-31 16:40:31 +02008469 if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02008470 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008471 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008472 lyxp_set_cast(set, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008473 }
8474
8475 /* ('and' EqualityExpr)* */
8476 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008477 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_LOG);
aPiecek8b0cc152021-05-31 16:40:31 +02008478 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, ((options & LYXP_SKIP_EXPR) || !set->val.bln ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02008479 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008480 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008481
8482 /* lazy evaluation */
aPiecek8b0cc152021-05-31 16:40:31 +02008483 if ((options & LYXP_SKIP_EXPR) || ((set->type == LYXP_SET_BOOLEAN) && !set->val.bln)) {
8484 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008485 LY_CHECK_GOTO(rc, cleanup);
8486 continue;
8487 }
8488
8489 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008490 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008491 LY_CHECK_GOTO(rc, cleanup);
8492
8493 /* eval - just get boolean value actually */
8494 if (set->type == LYXP_SET_SCNODE_SET) {
Michal Vasko1a09b212021-05-06 13:00:10 +02008495 set_scnode_clear_ctx(&set2, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008496 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008497 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008498 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008499 set_fill_set(set, &set2);
8500 }
8501 }
8502
8503cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008504 lyxp_set_free_content(&orig_set);
8505 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008506 return rc;
8507}
8508
8509/**
8510 * @brief Evaluate OrExpr. Logs directly on error.
8511 *
Michal Vaskod3678892020-05-21 10:06:58 +02008512 * [13] OrExpr ::= AndExpr | OrExpr 'or' AndExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008513 *
8514 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008515 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008516 * @param[in] repeat How many times this expression is repeated.
aPiecek8b0cc152021-05-31 16:40:31 +02008517 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008518 * @param[in] options XPath options.
8519 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8520 */
8521static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02008522eval_or_expr(const struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t repeat, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008523{
8524 LY_ERR rc;
8525 struct lyxp_set orig_set, set2;
8526 uint16_t i;
8527
8528 assert(repeat);
8529
8530 set_init(&orig_set, set);
8531 set_init(&set2, set);
8532
8533 set_fill_set(&orig_set, set);
8534
Michal Vasko004d3152020-06-11 19:59:22 +02008535 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008536 LY_CHECK_GOTO(rc, cleanup);
8537
8538 /* cast to boolean, we know that will be the final result */
aPiecek8b0cc152021-05-31 16:40:31 +02008539 if (!(options & LYXP_SKIP_EXPR) && (options & LYXP_SCNODE_ALL)) {
Michal Vasko1a09b212021-05-06 13:00:10 +02008540 set_scnode_clear_ctx(set, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008541 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008542 lyxp_set_cast(set, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008543 }
8544
8545 /* ('or' AndExpr)* */
8546 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008547 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_LOG);
aPiecek8b0cc152021-05-31 16:40:31 +02008548 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, ((options & LYXP_SKIP_EXPR) || set->val.bln ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02008549 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008550 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008551
8552 /* lazy evaluation */
aPiecek8b0cc152021-05-31 16:40:31 +02008553 if ((options & LYXP_SKIP_EXPR) || ((set->type == LYXP_SET_BOOLEAN) && set->val.bln)) {
8554 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, set, options | LYXP_SKIP_EXPR);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008555 LY_CHECK_GOTO(rc, cleanup);
8556 continue;
8557 }
8558
8559 set_fill_set(&set2, &orig_set);
8560 /* expr_type cound have been LYXP_EXPR_NONE in all these later calls (except for the first one),
8561 * but it does not matter */
Michal Vasko004d3152020-06-11 19:59:22 +02008562 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008563 LY_CHECK_GOTO(rc, cleanup);
8564
8565 /* eval - just get boolean value actually */
8566 if (set->type == LYXP_SET_SCNODE_SET) {
Michal Vasko1a09b212021-05-06 13:00:10 +02008567 set_scnode_clear_ctx(&set2, LYXP_SET_SCNODE_ATOM_NODE);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008568 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008569 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008570 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008571 set_fill_set(set, &set2);
8572 }
8573 }
8574
8575cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008576 lyxp_set_free_content(&orig_set);
8577 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008578 return rc;
8579}
8580
8581/**
Michal Vasko004d3152020-06-11 19:59:22 +02008582 * @brief Decide what expression is at the pointer @p tok_idx and evaluate it accordingly.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008583 *
8584 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008585 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008586 * @param[in] etype Expression type to evaluate.
aPiecek8b0cc152021-05-31 16:40:31 +02008587 * @param[in,out] set Context and result set.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008588 * @param[in] options XPath options.
8589 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8590 */
8591static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02008592eval_expr_select(const struct lyxp_expr *exp, uint16_t *tok_idx, enum lyxp_expr_type etype, struct lyxp_set *set,
8593 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008594{
8595 uint16_t i, count;
8596 enum lyxp_expr_type next_etype;
8597 LY_ERR rc;
8598
8599 /* process operator repeats */
Michal Vasko004d3152020-06-11 19:59:22 +02008600 if (!exp->repeat[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008601 next_etype = LYXP_EXPR_NONE;
8602 } else {
8603 /* find etype repeat */
Radek Krejci1e008d22020-08-17 11:37:37 +02008604 for (i = 0; exp->repeat[*tok_idx][i] > etype; ++i) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02008605
8606 /* select one-priority lower because etype expression called us */
8607 if (i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008608 next_etype = exp->repeat[*tok_idx][i - 1];
Michal Vasko03ff5a72019-09-11 13:49:33 +02008609 /* count repeats for that expression */
Radek Krejci1e008d22020-08-17 11:37:37 +02008610 for (count = 0; i && exp->repeat[*tok_idx][i - 1] == next_etype; ++count, --i) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02008611 } else {
8612 next_etype = LYXP_EXPR_NONE;
8613 }
8614 }
8615
8616 /* decide what expression are we parsing based on the repeat */
8617 switch (next_etype) {
8618 case LYXP_EXPR_OR:
Michal Vasko004d3152020-06-11 19:59:22 +02008619 rc = eval_or_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008620 break;
8621 case LYXP_EXPR_AND:
Michal Vasko004d3152020-06-11 19:59:22 +02008622 rc = eval_and_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008623 break;
8624 case LYXP_EXPR_EQUALITY:
Michal Vasko004d3152020-06-11 19:59:22 +02008625 rc = eval_equality_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008626 break;
8627 case LYXP_EXPR_RELATIONAL:
Michal Vasko004d3152020-06-11 19:59:22 +02008628 rc = eval_relational_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008629 break;
8630 case LYXP_EXPR_ADDITIVE:
Michal Vasko004d3152020-06-11 19:59:22 +02008631 rc = eval_additive_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008632 break;
8633 case LYXP_EXPR_MULTIPLICATIVE:
Michal Vasko004d3152020-06-11 19:59:22 +02008634 rc = eval_multiplicative_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008635 break;
8636 case LYXP_EXPR_UNARY:
Michal Vasko004d3152020-06-11 19:59:22 +02008637 rc = eval_unary_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008638 break;
8639 case LYXP_EXPR_UNION:
Michal Vasko004d3152020-06-11 19:59:22 +02008640 rc = eval_union_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008641 break;
8642 case LYXP_EXPR_NONE:
Michal Vasko004d3152020-06-11 19:59:22 +02008643 rc = eval_path_expr(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008644 break;
8645 default:
8646 LOGINT_RET(set->ctx);
8647 }
8648
8649 return rc;
8650}
8651
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008652/**
8653 * @brief Get root type.
8654 *
8655 * @param[in] ctx_node Context node.
8656 * @param[in] ctx_scnode Schema context node.
8657 * @param[in] options XPath options.
8658 * @return Root type.
8659 */
8660static enum lyxp_node_type
Radek Krejci1deb5be2020-08-26 16:43:36 +02008661lyxp_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 +01008662{
Michal Vasko6b26e742020-07-17 15:02:10 +02008663 const struct lysc_node *op;
8664
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008665 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008666 /* schema */
Radek Krejci1e008d22020-08-17 11:37:37 +02008667 for (op = ctx_scnode; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
Michal Vasko6b26e742020-07-17 15:02:10 +02008668
8669 if (op || (options & LYXP_SCNODE)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008670 /* general root that can access everything */
8671 return LYXP_NODE_ROOT;
8672 } else if (!ctx_scnode || (ctx_scnode->flags & LYS_CONFIG_W)) {
8673 /* root context node can access only config data (because we said so, it is unspecified) */
8674 return LYXP_NODE_ROOT_CONFIG;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008675 }
Michal Vasko6b26e742020-07-17 15:02:10 +02008676 return LYXP_NODE_ROOT;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008677 }
8678
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008679 /* data */
Michal Vasko6b26e742020-07-17 15:02:10 +02008680 op = ctx_node ? ctx_node->schema : NULL;
Michal Vaskod989ba02020-08-24 10:59:24 +02008681 for ( ; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
Michal Vasko6b26e742020-07-17 15:02:10 +02008682
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008683 if (op || !(options & LYXP_SCHEMA)) {
8684 /* general root that can access everything */
8685 return LYXP_NODE_ROOT;
Christian Hoppsb6ecaea2021-02-06 09:45:38 -05008686 } else if (!ctx_node || !ctx_node->schema || (ctx_node->schema->flags & LYS_CONFIG_W)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008687 /* root context node can access only config data (because we said so, it is unspecified) */
8688 return LYXP_NODE_ROOT_CONFIG;
8689 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008690 return LYXP_NODE_ROOT;
8691}
8692
Michal Vasko03ff5a72019-09-11 13:49:33 +02008693LY_ERR
Michal Vasko400e9672021-01-11 13:39:17 +01008694lyxp_eval(const struct ly_ctx *ctx, const struct lyxp_expr *exp, const struct lys_module *cur_mod,
Radek Krejci8df109d2021-04-23 12:19:08 +02008695 LY_VALUE_FORMAT format, void *prefix_data, const struct lyd_node *ctx_node, const struct lyd_node *tree,
aPiecekfba75362021-10-07 12:39:48 +02008696 const struct lyxp_var *vars, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008697{
Michal Vasko004d3152020-06-11 19:59:22 +02008698 uint16_t tok_idx = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008699 LY_ERR rc;
8700
Michal Vasko400e9672021-01-11 13:39:17 +01008701 LY_CHECK_ARG_RET(ctx, ctx, exp, set, LY_EINVAL);
Radek Krejci8df109d2021-04-23 12:19:08 +02008702 if (!cur_mod && ((format == LY_VALUE_SCHEMA) || (format == LY_VALUE_SCHEMA_RESOLVED))) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008703 LOGARG(NULL, "Current module must be set if schema format is used.");
8704 return LY_EINVAL;
Michal Vasko004d3152020-06-11 19:59:22 +02008705 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02008706
Michal Vaskod3bb12f2020-12-04 14:33:09 +01008707 if (tree) {
8708 /* adjust the pointer to be the first top-level sibling */
8709 while (tree->parent) {
8710 tree = lyd_parent(tree);
8711 }
8712 tree = lyd_first_sibling(tree);
8713 }
8714
Michal Vasko03ff5a72019-09-11 13:49:33 +02008715 /* prepare set for evaluation */
Michal Vasko03ff5a72019-09-11 13:49:33 +02008716 memset(set, 0, sizeof *set);
Michal Vaskod3678892020-05-21 10:06:58 +02008717 set->type = LYXP_SET_NODE_SET;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008718 set->root_type = lyxp_get_root_type(ctx_node, NULL, options);
8719 set_insert_node(set, (struct lyd_node *)ctx_node, 0, ctx_node ? LYXP_NODE_ELEM : set->root_type, 0);
8720
Michal Vasko400e9672021-01-11 13:39:17 +01008721 set->ctx = (struct ly_ctx *)ctx;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008722 set->cur_node = ctx_node;
8723 for (set->context_op = ctx_node ? ctx_node->schema : NULL;
Radek Krejci0f969882020-08-21 16:56:47 +02008724 set->context_op && !(set->context_op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF));
8725 set->context_op = set->context_op->parent) {}
Michal Vaskof03ed032020-03-04 13:31:44 +01008726 set->tree = tree;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008727 set->cur_mod = cur_mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008728 set->format = format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008729 set->prefix_data = prefix_data;
aPiecekfba75362021-10-07 12:39:48 +02008730 set->vars = vars;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008731
Radek Krejciddace2c2021-01-08 11:30:56 +01008732 LOG_LOCSET(NULL, set->cur_node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01008733
Michal Vasko03ff5a72019-09-11 13:49:33 +02008734 /* evaluate */
Michal Vasko004d3152020-06-11 19:59:22 +02008735 rc = eval_expr_select(exp, &tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008736 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02008737 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008738 }
8739
Michal Vasko0245d502021-12-13 17:05:06 +01008740 if (set->cur_node) {
8741 LOG_LOCBACK(0, 1, 0, 0);
8742 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02008743 return rc;
8744}
8745
8746#if 0
8747
8748/* full xml printing of set elements, not used currently */
8749
8750void
8751lyxp_set_print_xml(FILE *f, struct lyxp_set *set)
8752{
8753 uint32_t i;
8754 char *str_num;
8755 struct lyout out;
8756
8757 memset(&out, 0, sizeof out);
8758
8759 out.type = LYOUT_STREAM;
8760 out.method.f = f;
8761
8762 switch (set->type) {
8763 case LYXP_SET_EMPTY:
Michal Vasko5233e962020-08-14 14:26:20 +02008764 ly_print_(&out, "Empty XPath set\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008765 break;
8766 case LYXP_SET_BOOLEAN:
Michal Vasko5233e962020-08-14 14:26:20 +02008767 ly_print_(&out, "Boolean XPath set:\n");
8768 ly_print_(&out, "%s\n\n", set->value.bool ? "true" : "false");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008769 break;
8770 case LYXP_SET_STRING:
Michal Vasko5233e962020-08-14 14:26:20 +02008771 ly_print_(&out, "String XPath set:\n");
8772 ly_print_(&out, "\"%s\"\n\n", set->value.str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008773 break;
8774 case LYXP_SET_NUMBER:
Michal Vasko5233e962020-08-14 14:26:20 +02008775 ly_print_(&out, "Number XPath set:\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008776
8777 if (isnan(set->value.num)) {
8778 str_num = strdup("NaN");
8779 } else if ((set->value.num == 0) || (set->value.num == -0.0f)) {
8780 str_num = strdup("0");
8781 } else if (isinf(set->value.num) && !signbit(set->value.num)) {
8782 str_num = strdup("Infinity");
8783 } else if (isinf(set->value.num) && signbit(set->value.num)) {
8784 str_num = strdup("-Infinity");
8785 } else if ((long long)set->value.num == set->value.num) {
8786 if (asprintf(&str_num, "%lld", (long long)set->value.num) == -1) {
8787 str_num = NULL;
8788 }
8789 } else {
8790 if (asprintf(&str_num, "%03.1Lf", set->value.num) == -1) {
8791 str_num = NULL;
8792 }
8793 }
8794 if (!str_num) {
8795 LOGMEM;
8796 return;
8797 }
Michal Vasko5233e962020-08-14 14:26:20 +02008798 ly_print_(&out, "%s\n\n", str_num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008799 free(str_num);
8800 break;
8801 case LYXP_SET_NODE_SET:
Michal Vasko5233e962020-08-14 14:26:20 +02008802 ly_print_(&out, "Node XPath set:\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008803
8804 for (i = 0; i < set->used; ++i) {
Michal Vasko5233e962020-08-14 14:26:20 +02008805 ly_print_(&out, "%d. ", i + 1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008806 switch (set->node_type[i]) {
8807 case LYXP_NODE_ROOT_ALL:
Michal Vasko5233e962020-08-14 14:26:20 +02008808 ly_print_(&out, "ROOT all\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008809 break;
8810 case LYXP_NODE_ROOT_CONFIG:
Michal Vasko5233e962020-08-14 14:26:20 +02008811 ly_print_(&out, "ROOT config\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008812 break;
8813 case LYXP_NODE_ROOT_STATE:
Michal Vasko5233e962020-08-14 14:26:20 +02008814 ly_print_(&out, "ROOT state\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008815 break;
8816 case LYXP_NODE_ROOT_NOTIF:
Michal Vasko5233e962020-08-14 14:26:20 +02008817 ly_print_(&out, "ROOT notification \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008818 break;
8819 case LYXP_NODE_ROOT_RPC:
Michal Vasko5233e962020-08-14 14:26:20 +02008820 ly_print_(&out, "ROOT rpc \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008821 break;
8822 case LYXP_NODE_ROOT_OUTPUT:
Michal Vasko5233e962020-08-14 14:26:20 +02008823 ly_print_(&out, "ROOT output \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008824 break;
8825 case LYXP_NODE_ELEM:
Michal Vasko5233e962020-08-14 14:26:20 +02008826 ly_print_(&out, "ELEM \"%s\"\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008827 xml_print_node(&out, 1, set->value.nodes[i], 1, LYP_FORMAT);
Michal Vasko5233e962020-08-14 14:26:20 +02008828 ly_print_(&out, "\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008829 break;
8830 case LYXP_NODE_TEXT:
Michal Vasko5233e962020-08-14 14:26:20 +02008831 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 +02008832 break;
8833 case LYXP_NODE_ATTR:
Michal Vasko5233e962020-08-14 14:26:20 +02008834 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 +02008835 break;
8836 }
8837 }
8838 break;
8839 }
8840}
8841
8842#endif
8843
8844LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008845lyxp_set_cast(struct lyxp_set *set, enum lyxp_set_type target)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008846{
8847 long double num;
8848 char *str;
8849 LY_ERR rc;
8850
8851 if (!set || (set->type == target)) {
8852 return LY_SUCCESS;
8853 }
8854
8855 /* it's not possible to convert anything into a node set */
Michal Vaskod3678892020-05-21 10:06:58 +02008856 assert(target != LYXP_SET_NODE_SET);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008857
8858 if (set->type == LYXP_SET_SCNODE_SET) {
Michal Vaskod3678892020-05-21 10:06:58 +02008859 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008860 return LY_EINVAL;
8861 }
8862
8863 /* to STRING */
Michal Vaskod3678892020-05-21 10:06:58 +02008864 if ((target == LYXP_SET_STRING) || ((target == LYXP_SET_NUMBER) && (set->type == LYXP_SET_NODE_SET))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008865 switch (set->type) {
8866 case LYXP_SET_NUMBER:
8867 if (isnan(set->val.num)) {
8868 set->val.str = strdup("NaN");
8869 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
8870 } else if ((set->val.num == 0) || (set->val.num == -0.0f)) {
8871 set->val.str = strdup("0");
8872 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
8873 } else if (isinf(set->val.num) && !signbit(set->val.num)) {
8874 set->val.str = strdup("Infinity");
8875 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
8876 } else if (isinf(set->val.num) && signbit(set->val.num)) {
8877 set->val.str = strdup("-Infinity");
8878 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
8879 } else if ((long long)set->val.num == set->val.num) {
8880 if (asprintf(&str, "%lld", (long long)set->val.num) == -1) {
8881 LOGMEM_RET(set->ctx);
8882 }
8883 set->val.str = str;
8884 } else {
8885 if (asprintf(&str, "%03.1Lf", set->val.num) == -1) {
8886 LOGMEM_RET(set->ctx);
8887 }
8888 set->val.str = str;
8889 }
8890 break;
8891 case LYXP_SET_BOOLEAN:
Michal Vasko004d3152020-06-11 19:59:22 +02008892 if (set->val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008893 set->val.str = strdup("true");
8894 } else {
8895 set->val.str = strdup("false");
8896 }
8897 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), LY_EMEM);
8898 break;
8899 case LYXP_SET_NODE_SET:
Michal Vasko03ff5a72019-09-11 13:49:33 +02008900 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008901 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008902
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008903 rc = cast_node_set_to_string(set, &str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008904 LY_CHECK_RET(rc);
Michal Vaskod3678892020-05-21 10:06:58 +02008905 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008906 set->val.str = str;
8907 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008908 default:
8909 LOGINT_RET(set->ctx);
8910 }
8911 set->type = LYXP_SET_STRING;
8912 }
8913
8914 /* to NUMBER */
8915 if (target == LYXP_SET_NUMBER) {
8916 switch (set->type) {
8917 case LYXP_SET_STRING:
8918 num = cast_string_to_number(set->val.str);
Michal Vaskod3678892020-05-21 10:06:58 +02008919 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008920 set->val.num = num;
8921 break;
8922 case LYXP_SET_BOOLEAN:
Michal Vasko004d3152020-06-11 19:59:22 +02008923 if (set->val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008924 set->val.num = 1;
8925 } else {
8926 set->val.num = 0;
8927 }
8928 break;
8929 default:
8930 LOGINT_RET(set->ctx);
8931 }
8932 set->type = LYXP_SET_NUMBER;
8933 }
8934
8935 /* to BOOLEAN */
8936 if (target == LYXP_SET_BOOLEAN) {
8937 switch (set->type) {
8938 case LYXP_SET_NUMBER:
8939 if ((set->val.num == 0) || (set->val.num == -0.0f) || isnan(set->val.num)) {
Michal Vasko004d3152020-06-11 19:59:22 +02008940 set->val.bln = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008941 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02008942 set->val.bln = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008943 }
8944 break;
8945 case LYXP_SET_STRING:
8946 if (set->val.str[0]) {
Michal Vaskod3678892020-05-21 10:06:58 +02008947 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02008948 set->val.bln = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008949 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02008950 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02008951 set->val.bln = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008952 }
8953 break;
8954 case LYXP_SET_NODE_SET:
Michal Vaskod3678892020-05-21 10:06:58 +02008955 if (set->used) {
8956 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02008957 set->val.bln = 1;
Michal Vaskod3678892020-05-21 10:06:58 +02008958 } else {
8959 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02008960 set->val.bln = 0;
Michal Vaskod3678892020-05-21 10:06:58 +02008961 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02008962 break;
8963 default:
8964 LOGINT_RET(set->ctx);
8965 }
8966 set->type = LYXP_SET_BOOLEAN;
8967 }
8968
Michal Vasko03ff5a72019-09-11 13:49:33 +02008969 return LY_SUCCESS;
8970}
8971
8972LY_ERR
Michal Vasko400e9672021-01-11 13:39:17 +01008973lyxp_atomize(const struct ly_ctx *ctx, const struct lyxp_expr *exp, const struct lys_module *cur_mod,
Radek Krejci8df109d2021-04-23 12:19:08 +02008974 LY_VALUE_FORMAT format, void *prefix_data, const struct lysc_node *ctx_scnode, struct lyxp_set *set,
Michal Vasko400e9672021-01-11 13:39:17 +01008975 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008976{
Radek Krejci2efc45b2020-12-22 16:25:44 +01008977 LY_ERR ret;
Michal Vasko004d3152020-06-11 19:59:22 +02008978 uint16_t tok_idx = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008979
Michal Vasko400e9672021-01-11 13:39:17 +01008980 LY_CHECK_ARG_RET(ctx, ctx, exp, set, LY_EINVAL);
Radek Krejci8df109d2021-04-23 12:19:08 +02008981 if (!cur_mod && ((format == LY_VALUE_SCHEMA) || (format == LY_VALUE_SCHEMA_RESOLVED))) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008982 LOGARG(NULL, "Current module must be set if schema format is used.");
8983 return LY_EINVAL;
Michal Vasko004d3152020-06-11 19:59:22 +02008984 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02008985
8986 /* prepare set for evaluation */
Michal Vasko03ff5a72019-09-11 13:49:33 +02008987 memset(set, 0, sizeof *set);
8988 set->type = LYXP_SET_SCNODE_SET;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008989 set->root_type = lyxp_get_root_type(NULL, ctx_scnode, options);
8990 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, ctx_scnode, ctx_scnode ? LYXP_NODE_ELEM : set->root_type, NULL));
Radek Krejcif13b87b2020-12-01 22:02:17 +01008991 set->val.scnodes[0].in_ctx = LYXP_SET_SCNODE_START;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008992
Michal Vasko400e9672021-01-11 13:39:17 +01008993 set->ctx = (struct ly_ctx *)ctx;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008994 set->cur_scnode = ctx_scnode;
Michal Vasko6b26e742020-07-17 15:02:10 +02008995 for (set->context_op = ctx_scnode;
Radek Krejci0f969882020-08-21 16:56:47 +02008996 set->context_op && !(set->context_op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF));
8997 set->context_op = set->context_op->parent) {}
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008998 set->cur_mod = cur_mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008999 set->format = format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02009000 set->prefix_data = prefix_data;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009001
Radek Krejciddace2c2021-01-08 11:30:56 +01009002 LOG_LOCSET(set->cur_scnode, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01009003
Michal Vasko03ff5a72019-09-11 13:49:33 +02009004 /* evaluate */
Radek Krejci2efc45b2020-12-22 16:25:44 +01009005 ret = eval_expr_select(exp, &tok_idx, 0, set, options);
9006
Radek Krejciddace2c2021-01-08 11:30:56 +01009007 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01009008 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02009009}
Michal Vaskod43d71a2020-08-07 14:54:58 +02009010
9011API const char *
9012lyxp_get_expr(const struct lyxp_expr *path)
9013{
9014 if (!path) {
9015 return NULL;
9016 }
9017
9018 return path->expr;
9019}