blob: c5898b7791014720cfd3b660adbb807a9b7242ee [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 */
Michal Vasko03ff5a72019-09-11 13:49:33 +020014#define _GNU_SOURCE
Radek Krejcif8dc59a2020-11-25 13:47:44 +010015#define _POSIX_C_SOURCE 200809L /* strdup, strndup */
Michal Vasko03ff5a72019-09-11 13:49:33 +020016
17/* needed by libmath functions isfinite(), isinf(), isnan(), signbit(), ... */
18#define _ISOC99_SOURCE
Radek Krejcib1646a92018-11-02 16:08:26 +010019
Radek Krejci535ea9f2020-05-29 16:01:05 +020020#include "xpath.h"
Radek Krejcib1646a92018-11-02 16:08:26 +010021
Radek Krejci535ea9f2020-05-29 16:01:05 +020022#include <assert.h>
Radek Krejcib1646a92018-11-02 16:08:26 +010023#include <ctype.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020024#include <errno.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020025#include <math.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020026#include <stdint.h>
Radek Krejcib1646a92018-11-02 16:08:26 +010027#include <stdio.h>
28#include <stdlib.h>
Radek Krejcib1646a92018-11-02 16:08:26 +010029#include <string.h>
Radek Krejcib1646a92018-11-02 16:08:26 +010030
Radek Krejci535ea9f2020-05-29 16:01:05 +020031#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020032#include "compat.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020033#include "context.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020034#include "dict.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020035#include "hash_table.h"
Radek Krejci47fab892020-11-05 17:02:41 +010036#include "out.h"
Radek Krejci7931b192020-06-25 17:05:03 +020037#include "parser_data.h"
Michal Vasko004d3152020-06-11 19:59:22 +020038#include "path.h"
Michal Vasko03ff5a72019-09-11 13:49:33 +020039#include "plugins_types.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020040#include "printer_data.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020041#include "schema_compile_node.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020042#include "tree.h"
Radek Krejci77114102021-03-10 15:21:57 +010043#include "tree_data.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020044#include "tree_data_internal.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010045#include "tree_edit.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020046#include "tree_schema_internal.h"
47#include "xml.h"
Michal Vasko03ff5a72019-09-11 13:49:33 +020048
Michal Vasko004d3152020-06-11 19:59:22 +020049static LY_ERR reparse_or_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx);
Michal Vasko40308e72020-10-20 16:38:40 +020050static LY_ERR eval_expr_select(const struct lyxp_expr *exp, uint16_t *tok_idx, enum lyxp_expr_type etype,
51 struct lyxp_set *set, uint32_t options);
Michal Vasko03ff5a72019-09-11 13:49:33 +020052
53/**
54 * @brief Print the type of an XPath \p set.
55 *
56 * @param[in] set Set to use.
57 * @return Set type string.
58 */
59static const char *
60print_set_type(struct lyxp_set *set)
61{
62 switch (set->type) {
Michal Vasko03ff5a72019-09-11 13:49:33 +020063 case LYXP_SET_NODE_SET:
64 return "node set";
65 case LYXP_SET_SCNODE_SET:
66 return "schema node set";
67 case LYXP_SET_BOOLEAN:
68 return "boolean";
69 case LYXP_SET_NUMBER:
70 return "number";
71 case LYXP_SET_STRING:
72 return "string";
73 }
74
75 return NULL;
76}
77
Michal Vasko24cddf82020-06-01 08:17:01 +020078const char *
79lyxp_print_token(enum lyxp_token tok)
Michal Vasko03ff5a72019-09-11 13:49:33 +020080{
81 switch (tok) {
82 case LYXP_TOKEN_PAR1:
83 return "(";
84 case LYXP_TOKEN_PAR2:
85 return ")";
86 case LYXP_TOKEN_BRACK1:
87 return "[";
88 case LYXP_TOKEN_BRACK2:
89 return "]";
90 case LYXP_TOKEN_DOT:
91 return ".";
92 case LYXP_TOKEN_DDOT:
93 return "..";
94 case LYXP_TOKEN_AT:
95 return "@";
96 case LYXP_TOKEN_COMMA:
97 return ",";
98 case LYXP_TOKEN_NAMETEST:
99 return "NameTest";
100 case LYXP_TOKEN_NODETYPE:
101 return "NodeType";
102 case LYXP_TOKEN_FUNCNAME:
103 return "FunctionName";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200104 case LYXP_TOKEN_OPER_LOG:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200105 return "Operator(Logic)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200106 case LYXP_TOKEN_OPER_EQUAL:
107 return "Operator(Equal)";
108 case LYXP_TOKEN_OPER_NEQUAL:
109 return "Operator(Non-equal)";
110 case LYXP_TOKEN_OPER_COMP:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200111 return "Operator(Comparison)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200112 case LYXP_TOKEN_OPER_MATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200113 return "Operator(Math)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200114 case LYXP_TOKEN_OPER_UNI:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200115 return "Operator(Union)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200116 case LYXP_TOKEN_OPER_PATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200117 return "Operator(Path)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200118 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko14676352020-05-29 11:35:55 +0200119 return "Operator(Recursive Path)";
Michal Vasko03ff5a72019-09-11 13:49:33 +0200120 case LYXP_TOKEN_LITERAL:
121 return "Literal";
122 case LYXP_TOKEN_NUMBER:
123 return "Number";
124 default:
125 LOGINT(NULL);
126 return "";
127 }
128}
129
130/**
131 * @brief Print the whole expression \p exp to debug output.
132 *
133 * @param[in] exp Expression to use.
134 */
135static void
Michal Vasko40308e72020-10-20 16:38:40 +0200136print_expr_struct_debug(const struct lyxp_expr *exp)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200137{
Radek Krejcif13b87b2020-12-01 22:02:17 +0100138#define MSG_BUFFER_SIZE 128
139 char tmp[MSG_BUFFER_SIZE];
Michal Vasko1fdd8fa2021-01-08 09:21:45 +0100140 uint32_t i, j;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200141
Radek Krejci52b6d512020-10-12 12:33:17 +0200142 if (!exp || (ly_ll < LY_LLDBG)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200143 return;
144 }
145
146 LOGDBG(LY_LDGXPATH, "expression \"%s\":", exp->expr);
147 for (i = 0; i < exp->used; ++i) {
Michal Vasko24cddf82020-06-01 08:17:01 +0200148 sprintf(tmp, "\ttoken %s, in expression \"%.*s\"", lyxp_print_token(exp->tokens[i]), exp->tok_len[i],
Michal Vasko69730152020-10-09 16:30:07 +0200149 &exp->expr[exp->tok_pos[i]]);
Michal Vasko23049552021-03-04 15:57:44 +0100150 if (exp->repeat && exp->repeat[i]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200151 sprintf(tmp + strlen(tmp), " (repeat %d", exp->repeat[i][0]);
152 for (j = 1; exp->repeat[i][j]; ++j) {
153 sprintf(tmp + strlen(tmp), ", %d", exp->repeat[i][j]);
154 }
155 strcat(tmp, ")");
156 }
157 LOGDBG(LY_LDGXPATH, tmp);
158 }
Radek Krejcif13b87b2020-12-01 22:02:17 +0100159#undef MSG_BUFFER_SIZE
Michal Vasko03ff5a72019-09-11 13:49:33 +0200160}
161
162#ifndef NDEBUG
163
164/**
165 * @brief Print XPath set content to debug output.
166 *
167 * @param[in] set Set to print.
168 */
169static void
170print_set_debug(struct lyxp_set *set)
171{
172 uint32_t i;
173 char *str;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200174 struct lyxp_set_node *item;
175 struct lyxp_set_scnode *sitem;
176
Radek Krejci52b6d512020-10-12 12:33:17 +0200177 if (ly_ll < LY_LLDBG) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200178 return;
179 }
180
181 switch (set->type) {
182 case LYXP_SET_NODE_SET:
183 LOGDBG(LY_LDGXPATH, "set NODE SET:");
184 for (i = 0; i < set->used; ++i) {
185 item = &set->val.nodes[i];
186
187 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +0100188 case LYXP_NODE_NONE:
189 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): NONE", i + 1, item->pos);
190 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200191 case LYXP_NODE_ROOT:
192 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ROOT", i + 1, item->pos);
193 break;
194 case LYXP_NODE_ROOT_CONFIG:
195 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ROOT CONFIG", i + 1, item->pos);
196 break;
197 case LYXP_NODE_ELEM:
Michal Vasko9e685082021-01-29 14:49:09 +0100198 if ((item->node->schema->nodetype == LYS_LIST) && (lyd_child(item->node)->schema->nodetype == LYS_LEAF)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200199 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s (1st child val: %s)", i + 1, item->pos,
Michal Vasko69730152020-10-09 16:30:07 +0200200 item->node->schema->name, LYD_CANON_VALUE(lyd_child(item->node)));
Michal Vasko9e685082021-01-29 14:49:09 +0100201 } else if (item->node->schema->nodetype == LYS_LEAFLIST) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200202 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s (val: %s)", i + 1, item->pos,
Michal Vasko69730152020-10-09 16:30:07 +0200203 item->node->schema->name, LYD_CANON_VALUE(item->node));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200204 } else {
205 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s", i + 1, item->pos, item->node->schema->name);
206 }
207 break;
208 case LYXP_NODE_TEXT:
209 if (item->node->schema->nodetype & LYS_ANYDATA) {
210 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): TEXT <%s>", i + 1, item->pos,
Michal Vasko69730152020-10-09 16:30:07 +0200211 item->node->schema->nodetype == LYS_ANYXML ? "anyxml" : "anydata");
Michal Vasko03ff5a72019-09-11 13:49:33 +0200212 } else {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200213 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): TEXT %s", i + 1, item->pos, LYD_CANON_VALUE(item->node));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200214 }
215 break;
Michal Vasko9f96a052020-03-10 09:41:45 +0100216 case LYXP_NODE_META:
217 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 +0200218 set->val.meta[i].meta->value);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200219 break;
220 }
221 }
222 break;
223
224 case LYXP_SET_SCNODE_SET:
225 LOGDBG(LY_LDGXPATH, "set SCNODE SET:");
226 for (i = 0; i < set->used; ++i) {
227 sitem = &set->val.scnodes[i];
228
229 switch (sitem->type) {
230 case LYXP_NODE_ROOT:
231 LOGDBG(LY_LDGXPATH, "\t%d (%u): ROOT", i + 1, sitem->in_ctx);
232 break;
233 case LYXP_NODE_ROOT_CONFIG:
234 LOGDBG(LY_LDGXPATH, "\t%d (%u): ROOT CONFIG", i + 1, sitem->in_ctx);
235 break;
236 case LYXP_NODE_ELEM:
237 LOGDBG(LY_LDGXPATH, "\t%d (%u): ELEM %s", i + 1, sitem->in_ctx, sitem->scnode->name);
238 break;
239 default:
240 LOGINT(NULL);
241 break;
242 }
243 }
244 break;
245
Michal Vasko03ff5a72019-09-11 13:49:33 +0200246 case LYXP_SET_BOOLEAN:
247 LOGDBG(LY_LDGXPATH, "set BOOLEAN");
Michal Vasko004d3152020-06-11 19:59:22 +0200248 LOGDBG(LY_LDGXPATH, "\t%s", (set->val.bln ? "true" : "false"));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200249 break;
250
251 case LYXP_SET_STRING:
252 LOGDBG(LY_LDGXPATH, "set STRING");
253 LOGDBG(LY_LDGXPATH, "\t%s", set->val.str);
254 break;
255
256 case LYXP_SET_NUMBER:
257 LOGDBG(LY_LDGXPATH, "set NUMBER");
258
259 if (isnan(set->val.num)) {
260 str = strdup("NaN");
261 } else if ((set->val.num == 0) || (set->val.num == -0.0f)) {
262 str = strdup("0");
263 } else if (isinf(set->val.num) && !signbit(set->val.num)) {
264 str = strdup("Infinity");
265 } else if (isinf(set->val.num) && signbit(set->val.num)) {
266 str = strdup("-Infinity");
267 } else if ((long long)set->val.num == set->val.num) {
268 if (asprintf(&str, "%lld", (long long)set->val.num) == -1) {
269 str = NULL;
270 }
271 } else {
272 if (asprintf(&str, "%03.1Lf", set->val.num) == -1) {
273 str = NULL;
274 }
275 }
276 LY_CHECK_ERR_RET(!str, LOGMEM(NULL), );
277
278 LOGDBG(LY_LDGXPATH, "\t%s", str);
279 free(str);
280 }
281}
282
283#endif
284
285/**
286 * @brief Realloc the string \p str.
287 *
288 * @param[in] ctx libyang context for logging.
289 * @param[in] needed How much free space is required.
290 * @param[in,out] str Pointer to the string to use.
291 * @param[in,out] used Used bytes in \p str.
292 * @param[in,out] size Allocated bytes in \p str.
293 * @return LY_ERR
294 */
295static LY_ERR
Michal Vasko52927e22020-03-16 17:26:14 +0100296cast_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 +0200297{
298 if (*size - *used < needed) {
299 do {
300 if ((UINT16_MAX - *size) < LYXP_STRING_CAST_SIZE_STEP) {
301 LOGERR(ctx, LY_EINVAL, "XPath string length limit (%u) reached.", UINT16_MAX);
302 return LY_EINVAL;
303 }
304 *size += LYXP_STRING_CAST_SIZE_STEP;
305 } while (*size - *used < needed);
306 *str = ly_realloc(*str, *size * sizeof(char));
307 LY_CHECK_ERR_RET(!(*str), LOGMEM(ctx), LY_EMEM);
308 }
309
310 return LY_SUCCESS;
311}
312
313/**
314 * @brief Cast nodes recursively to one string @p str.
315 *
316 * @param[in] node Node to cast.
317 * @param[in] fake_cont Whether to put the data into a "fake" container.
318 * @param[in] root_type Type of the XPath root.
319 * @param[in] indent Current indent.
320 * @param[in,out] str Resulting string.
321 * @param[in,out] used Used bytes in @p str.
322 * @param[in,out] size Allocated bytes in @p str.
323 * @return LY_ERR
324 */
325static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200326cast_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 +0200327 uint16_t *used, uint16_t *size)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200328{
Radek Krejci7f769d72020-07-11 23:13:56 +0200329 char *buf, *line, *ptr = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200330 const char *value_str;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200331 const struct lyd_node *child;
Michal Vasko60ea6352020-06-29 13:39:39 +0200332 struct lyd_node *tree;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200333 struct lyd_node_any *any;
334 LY_ERR rc;
335
336 if ((root_type == LYXP_NODE_ROOT_CONFIG) && (node->schema->flags & LYS_CONFIG_R)) {
337 return LY_SUCCESS;
338 }
339
340 if (fake_cont) {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200341 rc = cast_string_realloc(LYD_CTX(node), 1, str, used, size);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200342 LY_CHECK_RET(rc);
343 strcpy(*str + (*used - 1), "\n");
344 ++(*used);
345
346 ++indent;
347 }
348
349 switch (node->schema->nodetype) {
350 case LYS_CONTAINER:
351 case LYS_LIST:
352 case LYS_RPC:
353 case LYS_NOTIF:
Michal Vaskob7be7a82020-08-20 09:09:04 +0200354 rc = cast_string_realloc(LYD_CTX(node), 1, str, used, size);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200355 LY_CHECK_RET(rc);
356 strcpy(*str + (*used - 1), "\n");
357 ++(*used);
358
Radek Krejcia1c1e542020-09-29 16:06:52 +0200359 for (child = lyd_child(node); child; child = child->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200360 rc = cast_string_recursive(child, 0, root_type, indent + 1, str, used, size);
361 LY_CHECK_RET(rc);
362 }
363
364 break;
365
366 case LYS_LEAF:
367 case LYS_LEAFLIST:
Michal Vaskob7be7a82020-08-20 09:09:04 +0200368 value_str = LYD_CANON_VALUE(node);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200369
370 /* print indent */
Michal Vaskob7be7a82020-08-20 09:09:04 +0200371 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 +0200372 memset(*str + (*used - 1), ' ', indent * 2);
373 *used += indent * 2;
374
375 /* print value */
376 if (*used == 1) {
377 sprintf(*str + (*used - 1), "%s", value_str);
378 *used += strlen(value_str);
379 } else {
380 sprintf(*str + (*used - 1), "%s\n", value_str);
381 *used += strlen(value_str) + 1;
382 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200383
384 break;
385
386 case LYS_ANYXML:
387 case LYS_ANYDATA:
388 any = (struct lyd_node_any *)node;
389 if (!(void *)any->value.tree) {
390 /* no content */
391 buf = strdup("");
Michal Vaskob7be7a82020-08-20 09:09:04 +0200392 LY_CHECK_ERR_RET(!buf, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200393 } else {
Radek Krejci241f6b52020-05-21 18:13:49 +0200394 struct ly_out *out;
Radek Krejcia5bba312020-01-09 15:41:20 +0100395
Michal Vasko60ea6352020-06-29 13:39:39 +0200396 if (any->value_type == LYD_ANYDATA_LYB) {
397 /* try to parse it into a data tree */
Michal Vaskob7be7a82020-08-20 09:09:04 +0200398 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 +0200399 /* successfully parsed */
400 free(any->value.mem);
401 any->value.tree = tree;
402 any->value_type = LYD_ANYDATA_DATATREE;
403 }
Radek Krejci7931b192020-06-25 17:05:03 +0200404 /* error is covered by the following switch where LYD_ANYDATA_LYB causes failure */
Michal Vasko60ea6352020-06-29 13:39:39 +0200405 }
406
Michal Vasko03ff5a72019-09-11 13:49:33 +0200407 switch (any->value_type) {
408 case LYD_ANYDATA_STRING:
409 case LYD_ANYDATA_XML:
410 case LYD_ANYDATA_JSON:
411 buf = strdup(any->value.json);
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 break;
414 case LYD_ANYDATA_DATATREE:
Radek Krejci84ce7b12020-06-11 17:28:25 +0200415 LY_CHECK_RET(ly_out_new_memory(&buf, 0, &out));
Michal Vasko3a41dff2020-07-15 14:30:28 +0200416 rc = lyd_print_all(out, any->value.tree, LYD_XML, 0);
Radek Krejci241f6b52020-05-21 18:13:49 +0200417 ly_out_free(out, NULL, 0);
Radek Krejcia5bba312020-01-09 15:41:20 +0100418 LY_CHECK_RET(rc < 0, -rc);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200419 break;
Michal Vasko60ea6352020-06-29 13:39:39 +0200420 case LYD_ANYDATA_LYB:
Michal Vaskob7be7a82020-08-20 09:09:04 +0200421 LOGERR(LYD_CTX(node), LY_EINVAL, "Cannot convert LYB anydata into string.");
Michal Vasko60ea6352020-06-29 13:39:39 +0200422 return LY_EINVAL;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200423 }
424 }
425
426 line = strtok_r(buf, "\n", &ptr);
427 do {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200428 rc = cast_string_realloc(LYD_CTX(node), indent * 2 + strlen(line) + 1, str, used, size);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200429 if (rc != LY_SUCCESS) {
430 free(buf);
431 return rc;
432 }
433 memset(*str + (*used - 1), ' ', indent * 2);
434 *used += indent * 2;
435
436 strcpy(*str + (*used - 1), line);
437 *used += strlen(line);
438
439 strcpy(*str + (*used - 1), "\n");
440 *used += 1;
441 } while ((line = strtok_r(NULL, "\n", &ptr)));
442
443 free(buf);
444 break;
445
446 default:
Michal Vaskob7be7a82020-08-20 09:09:04 +0200447 LOGINT_RET(LYD_CTX(node));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200448 }
449
450 if (fake_cont) {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200451 rc = cast_string_realloc(LYD_CTX(node), 1, str, used, size);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200452 LY_CHECK_RET(rc);
453 strcpy(*str + (*used - 1), "\n");
454 ++(*used);
455
456 --indent;
457 }
458
459 return LY_SUCCESS;
460}
461
462/**
463 * @brief Cast an element into a string.
464 *
465 * @param[in] node Node to cast.
466 * @param[in] fake_cont Whether to put the data into a "fake" container.
467 * @param[in] root_type Type of the XPath root.
468 * @param[out] str Element cast to dynamically-allocated string.
469 * @return LY_ERR
470 */
471static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200472cast_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 +0200473{
474 uint16_t used, size;
475 LY_ERR rc;
476
477 *str = malloc(LYXP_STRING_CAST_SIZE_START * sizeof(char));
Michal Vaskob7be7a82020-08-20 09:09:04 +0200478 LY_CHECK_ERR_RET(!*str, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200479 (*str)[0] = '\0';
480 used = 1;
481 size = LYXP_STRING_CAST_SIZE_START;
482
483 rc = cast_string_recursive(node, fake_cont, root_type, 0, str, &used, &size);
484 if (rc != LY_SUCCESS) {
485 free(*str);
486 return rc;
487 }
488
489 if (size > used) {
490 *str = ly_realloc(*str, used * sizeof(char));
Michal Vaskob7be7a82020-08-20 09:09:04 +0200491 LY_CHECK_ERR_RET(!*str, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200492 }
493 return LY_SUCCESS;
494}
495
496/**
497 * @brief Cast a LYXP_SET_NODE_SET set into a string.
498 * Context position aware.
499 *
500 * @param[in] set Set to cast.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200501 * @param[out] str Cast dynamically-allocated string.
502 * @return LY_ERR
503 */
504static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100505cast_node_set_to_string(struct lyxp_set *set, char **str)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200506{
Michal Vaskoaa677062021-03-09 13:52:53 +0100507 if (!set->used) {
508 *str = strdup("");
509 if (!*str) {
510 LOGMEM_RET(set->ctx);
511 }
512 return LY_SUCCESS;
513 }
514
Michal Vasko03ff5a72019-09-11 13:49:33 +0200515 switch (set->val.nodes[0].type) {
Michal Vasko2caefc12019-11-14 16:07:56 +0100516 case LYXP_NODE_NONE:
517 /* invalid */
518 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200519 case LYXP_NODE_ROOT:
520 case LYXP_NODE_ROOT_CONFIG:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100521 return cast_string_elem(set->val.nodes[0].node, 1, set->root_type, str);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200522 case LYXP_NODE_ELEM:
523 case LYXP_NODE_TEXT:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100524 return cast_string_elem(set->val.nodes[0].node, 0, set->root_type, str);
Michal Vasko9f96a052020-03-10 09:41:45 +0100525 case LYXP_NODE_META:
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200526 *str = strdup(set->val.meta[0].meta->value.canonical);
527 if (!*str) {
528 LOGMEM_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200529 }
530 return LY_SUCCESS;
531 }
532
533 LOGINT_RET(set->ctx);
534}
535
536/**
537 * @brief Cast a string into an XPath number.
538 *
539 * @param[in] str String to use.
540 * @return Cast number.
541 */
542static long double
543cast_string_to_number(const char *str)
544{
545 long double num;
546 char *ptr;
547
548 errno = 0;
549 num = strtold(str, &ptr);
550 if (errno || *ptr) {
551 num = NAN;
552 }
553 return num;
554}
555
556/**
557 * @brief Callback for checking value equality.
558 *
Michal Vasko62524a92021-02-26 10:08:50 +0100559 * Implementation of ::lyht_value_equal_cb.
Radek Krejci857189e2020-09-01 13:26:36 +0200560 *
Michal Vasko03ff5a72019-09-11 13:49:33 +0200561 * @param[in] val1_p First value.
562 * @param[in] val2_p Second value.
563 * @param[in] mod Whether hash table is being modified.
564 * @param[in] cb_data Callback data.
Radek Krejci857189e2020-09-01 13:26:36 +0200565 * @return Boolean value whether values are equal or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200566 */
Radek Krejci857189e2020-09-01 13:26:36 +0200567static ly_bool
568set_values_equal_cb(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *UNUSED(cb_data))
Michal Vasko03ff5a72019-09-11 13:49:33 +0200569{
570 struct lyxp_set_hash_node *val1, *val2;
571
572 val1 = (struct lyxp_set_hash_node *)val1_p;
573 val2 = (struct lyxp_set_hash_node *)val2_p;
574
575 if ((val1->node == val2->node) && (val1->type == val2->type)) {
576 return 1;
577 }
578
579 return 0;
580}
581
582/**
583 * @brief Insert node and its hash into set.
584 *
585 * @param[in] set et to insert to.
586 * @param[in] node Node with hash.
587 * @param[in] type Node type.
588 */
589static void
590set_insert_node_hash(struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type)
591{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200592 LY_ERR r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200593 uint32_t i, hash;
594 struct lyxp_set_hash_node hnode;
595
596 if (!set->ht && (set->used >= LYD_HT_MIN_ITEMS)) {
597 /* create hash table and add all the nodes */
598 set->ht = lyht_new(1, sizeof(struct lyxp_set_hash_node), set_values_equal_cb, NULL, 1);
599 for (i = 0; i < set->used; ++i) {
600 hnode.node = set->val.nodes[i].node;
601 hnode.type = set->val.nodes[i].type;
602
603 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
604 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
605 hash = dict_hash_multi(hash, NULL, 0);
606
607 r = lyht_insert(set->ht, &hnode, hash, NULL);
608 assert(!r);
609 (void)r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200610
Michal Vasko9d6befd2019-12-11 14:56:56 +0100611 if (hnode.node == node) {
612 /* it was just added, do not add it twice */
613 node = NULL;
614 }
615 }
616 }
617
618 if (set->ht && node) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200619 /* add the new node into hash table */
620 hnode.node = node;
621 hnode.type = 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;
630 }
631}
632
633/**
634 * @brief Remove node and its hash from set.
635 *
636 * @param[in] set Set to remove from.
637 * @param[in] node Node to remove.
638 * @param[in] type Node type.
639 */
640static void
641set_remove_node_hash(struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type)
642{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200643 LY_ERR r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200644 struct lyxp_set_hash_node hnode;
645 uint32_t hash;
646
647 if (set->ht) {
648 hnode.node = node;
649 hnode.type = type;
650
651 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
652 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
653 hash = dict_hash_multi(hash, NULL, 0);
654
655 r = lyht_remove(set->ht, &hnode, hash);
656 assert(!r);
657 (void)r;
658
659 if (!set->ht->used) {
660 lyht_free(set->ht);
661 set->ht = NULL;
662 }
663 }
664}
665
666/**
667 * @brief Check whether node is in set based on its hash.
668 *
669 * @param[in] set Set to search in.
670 * @param[in] node Node to search for.
671 * @param[in] type Node type.
672 * @param[in] skip_idx Index in @p set to skip.
673 * @return LY_ERR
674 */
675static LY_ERR
676set_dup_node_hash_check(const struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type, int skip_idx)
677{
678 struct lyxp_set_hash_node hnode, *match_p;
679 uint32_t hash;
680
681 hnode.node = node;
682 hnode.type = type;
683
684 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
685 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
686 hash = dict_hash_multi(hash, NULL, 0);
687
688 if (!lyht_find(set->ht, &hnode, hash, (void **)&match_p)) {
689 if ((skip_idx > -1) && (set->val.nodes[skip_idx].node == match_p->node) && (set->val.nodes[skip_idx].type == match_p->type)) {
690 /* we found it on the index that should be skipped, find another */
691 hnode = *match_p;
692 if (lyht_find_next(set->ht, &hnode, hash, (void **)&match_p)) {
693 /* none other found */
694 return LY_SUCCESS;
695 }
696 }
697
698 return LY_EEXIST;
699 }
700
701 /* not found */
702 return LY_SUCCESS;
703}
704
Michal Vaskod3678892020-05-21 10:06:58 +0200705void
706lyxp_set_free_content(struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200707{
708 if (!set) {
709 return;
710 }
711
712 if (set->type == LYXP_SET_NODE_SET) {
713 free(set->val.nodes);
714 lyht_free(set->ht);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200715 } else if (set->type == LYXP_SET_SCNODE_SET) {
716 free(set->val.scnodes);
Michal Vaskod3678892020-05-21 10:06:58 +0200717 lyht_free(set->ht);
718 } else {
719 if (set->type == LYXP_SET_STRING) {
720 free(set->val.str);
721 }
722 set->type = LYXP_SET_NODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200723 }
Michal Vaskod3678892020-05-21 10:06:58 +0200724
725 set->val.nodes = NULL;
726 set->used = 0;
727 set->size = 0;
728 set->ht = NULL;
729 set->ctx_pos = 0;
730 set->ctx_pos = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200731}
732
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100733/**
734 * @brief Free dynamically-allocated set.
735 *
736 * @param[in] set Set to free.
737 */
738static void
Michal Vasko03ff5a72019-09-11 13:49:33 +0200739lyxp_set_free(struct lyxp_set *set)
740{
741 if (!set) {
742 return;
743 }
744
Michal Vaskod3678892020-05-21 10:06:58 +0200745 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200746 free(set);
747}
748
749/**
750 * @brief Initialize set context.
751 *
752 * @param[in] new Set to initialize.
753 * @param[in] set Arbitrary initialized set.
754 */
755static void
Michal Vasko4c7763f2020-07-27 17:40:37 +0200756set_init(struct lyxp_set *new, const struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200757{
758 memset(new, 0, sizeof *new);
Michal Vasko02a77382019-09-12 11:47:35 +0200759 if (set) {
760 new->ctx = set->ctx;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200761 new->cur_node = set->cur_node;
Michal Vasko588112f2019-12-10 14:51:53 +0100762 new->root_type = set->root_type;
Michal Vasko6b26e742020-07-17 15:02:10 +0200763 new->context_op = set->context_op;
Michal Vaskof03ed032020-03-04 13:31:44 +0100764 new->tree = set->tree;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200765 new->cur_mod = set->cur_mod;
Michal Vasko02a77382019-09-12 11:47:35 +0200766 new->format = set->format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200767 new->prefix_data = set->prefix_data;
Michal Vasko02a77382019-09-12 11:47:35 +0200768 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200769}
770
771/**
772 * @brief Create a deep copy of a set.
773 *
774 * @param[in] set Set to copy.
775 * @return Copy of @p set.
776 */
777static struct lyxp_set *
778set_copy(struct lyxp_set *set)
779{
780 struct lyxp_set *ret;
Michal Vasko1fdd8fa2021-01-08 09:21:45 +0100781 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200782
783 if (!set) {
784 return NULL;
785 }
786
787 ret = malloc(sizeof *ret);
788 LY_CHECK_ERR_RET(!ret, LOGMEM(set->ctx), NULL);
789 set_init(ret, set);
790
791 if (set->type == LYXP_SET_SCNODE_SET) {
792 ret->type = set->type;
793
794 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100795 if ((set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) ||
796 (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_START)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +0200797 uint32_t idx;
798 LY_CHECK_ERR_RET(lyxp_set_scnode_insert_node(ret, set->val.scnodes[i].scnode, set->val.scnodes[i].type, &idx),
799 lyxp_set_free(ret), NULL);
Michal Vasko3f27c522020-01-06 08:37:49 +0100800 /* coverity seems to think scnodes can be NULL */
Radek Krejciaa6b53f2020-08-27 15:19:03 +0200801 if (!ret->val.scnodes) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200802 lyxp_set_free(ret);
803 return NULL;
804 }
Michal Vaskoba716542019-12-16 10:01:58 +0100805 ret->val.scnodes[idx].in_ctx = set->val.scnodes[i].in_ctx;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200806 }
807 }
808 } else if (set->type == LYXP_SET_NODE_SET) {
809 ret->type = set->type;
810 ret->val.nodes = malloc(set->used * sizeof *ret->val.nodes);
811 LY_CHECK_ERR_RET(!ret->val.nodes, LOGMEM(set->ctx); free(ret), NULL);
812 memcpy(ret->val.nodes, set->val.nodes, set->used * sizeof *ret->val.nodes);
813
814 ret->used = ret->size = set->used;
815 ret->ctx_pos = set->ctx_pos;
816 ret->ctx_size = set->ctx_size;
Michal Vasko4a04e542021-02-01 08:58:30 +0100817 if (set->ht) {
818 ret->ht = lyht_dup(set->ht);
819 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200820 } else {
Radek Krejci0f969882020-08-21 16:56:47 +0200821 memcpy(ret, set, sizeof *ret);
822 if (set->type == LYXP_SET_STRING) {
823 ret->val.str = strdup(set->val.str);
824 LY_CHECK_ERR_RET(!ret->val.str, LOGMEM(set->ctx); free(ret), NULL);
825 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200826 }
827
828 return ret;
829}
830
831/**
832 * @brief Fill XPath set with a string. Any current data are disposed of.
833 *
834 * @param[in] set Set to fill.
835 * @param[in] string String to fill into \p set.
836 * @param[in] str_len Length of \p string. 0 is a valid value!
837 */
838static void
839set_fill_string(struct lyxp_set *set, const char *string, uint16_t str_len)
840{
Michal Vaskod3678892020-05-21 10:06:58 +0200841 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200842
843 set->type = LYXP_SET_STRING;
844 if ((str_len == 0) && (string[0] != '\0')) {
845 string = "";
846 }
847 set->val.str = strndup(string, str_len);
848}
849
850/**
851 * @brief Fill XPath set with a number. Any current data are disposed of.
852 *
853 * @param[in] set Set to fill.
854 * @param[in] number Number to fill into \p set.
855 */
856static void
857set_fill_number(struct lyxp_set *set, long double number)
858{
Michal Vaskod3678892020-05-21 10:06:58 +0200859 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200860
861 set->type = LYXP_SET_NUMBER;
862 set->val.num = number;
863}
864
865/**
866 * @brief Fill XPath set with a boolean. Any current data are disposed of.
867 *
868 * @param[in] set Set to fill.
869 * @param[in] boolean Boolean to fill into \p set.
870 */
871static void
Radek Krejci857189e2020-09-01 13:26:36 +0200872set_fill_boolean(struct lyxp_set *set, ly_bool boolean)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200873{
Michal Vaskod3678892020-05-21 10:06:58 +0200874 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200875
876 set->type = LYXP_SET_BOOLEAN;
Michal Vasko004d3152020-06-11 19:59:22 +0200877 set->val.bln = boolean;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200878}
879
880/**
881 * @brief Fill XPath set with the value from another set (deep assign).
882 * Any current data are disposed of.
883 *
884 * @param[in] trg Set to fill.
885 * @param[in] src Source set to copy into \p trg.
886 */
887static void
Michal Vasko4c7763f2020-07-27 17:40:37 +0200888set_fill_set(struct lyxp_set *trg, const struct lyxp_set *src)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200889{
890 if (!trg || !src) {
891 return;
892 }
893
894 if (trg->type == LYXP_SET_NODE_SET) {
895 free(trg->val.nodes);
896 } else if (trg->type == LYXP_SET_STRING) {
897 free(trg->val.str);
898 }
899 set_init(trg, src);
900
901 if (src->type == LYXP_SET_SCNODE_SET) {
902 trg->type = LYXP_SET_SCNODE_SET;
903 trg->used = src->used;
904 trg->size = src->used;
905
906 trg->val.scnodes = ly_realloc(trg->val.scnodes, trg->size * sizeof *trg->val.scnodes);
907 LY_CHECK_ERR_RET(!trg->val.scnodes, LOGMEM(src->ctx); memset(trg, 0, sizeof *trg), );
908 memcpy(trg->val.scnodes, src->val.scnodes, src->used * sizeof *src->val.scnodes);
909 } else if (src->type == LYXP_SET_BOOLEAN) {
Michal Vasko004d3152020-06-11 19:59:22 +0200910 set_fill_boolean(trg, src->val.bln);
Michal Vasko44f3d2c2020-08-24 09:49:38 +0200911 } else if (src->type == LYXP_SET_NUMBER) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200912 set_fill_number(trg, src->val.num);
913 } else if (src->type == LYXP_SET_STRING) {
914 set_fill_string(trg, src->val.str, strlen(src->val.str));
915 } else {
916 if (trg->type == LYXP_SET_NODE_SET) {
917 free(trg->val.nodes);
918 } else if (trg->type == LYXP_SET_STRING) {
919 free(trg->val.str);
920 }
921
Michal Vaskod3678892020-05-21 10:06:58 +0200922 assert(src->type == LYXP_SET_NODE_SET);
923
924 trg->type = LYXP_SET_NODE_SET;
925 trg->used = src->used;
926 trg->size = src->used;
927 trg->ctx_pos = src->ctx_pos;
928 trg->ctx_size = src->ctx_size;
929
930 trg->val.nodes = malloc(trg->used * sizeof *trg->val.nodes);
931 LY_CHECK_ERR_RET(!trg->val.nodes, LOGMEM(src->ctx); memset(trg, 0, sizeof *trg), );
932 memcpy(trg->val.nodes, src->val.nodes, src->used * sizeof *src->val.nodes);
933 if (src->ht) {
934 trg->ht = lyht_dup(src->ht);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200935 } else {
Michal Vaskod3678892020-05-21 10:06:58 +0200936 trg->ht = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200937 }
938 }
939}
940
941/**
942 * @brief Clear context of all schema nodes.
943 *
944 * @param[in] set Set to clear.
945 */
946static void
947set_scnode_clear_ctx(struct lyxp_set *set)
948{
949 uint32_t i;
950
951 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100952 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
953 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM;
954 } else if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_START) {
955 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200956 }
957 }
958}
959
960/**
961 * @brief Remove a node from a set. Removing last node changes
962 * set into LYXP_SET_EMPTY. Context position aware.
963 *
964 * @param[in] set Set to use.
965 * @param[in] idx Index from @p set of the node to be removed.
966 */
967static void
968set_remove_node(struct lyxp_set *set, uint32_t idx)
969{
970 assert(set && (set->type == LYXP_SET_NODE_SET));
971 assert(idx < set->used);
972
973 set_remove_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
974
975 --set->used;
976 if (set->used) {
977 memmove(&set->val.nodes[idx], &set->val.nodes[idx + 1],
978 (set->used - idx) * sizeof *set->val.nodes);
979 } else {
Michal Vaskod3678892020-05-21 10:06:58 +0200980 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200981 }
982}
983
984/**
Michal Vasko2caefc12019-11-14 16:07:56 +0100985 * @brief Remove a node from a set by setting its type to LYXP_NODE_NONE.
Michal Vasko57eab132019-09-24 11:46:26 +0200986 *
987 * @param[in] set Set to use.
988 * @param[in] idx Index from @p set of the node to be removed.
989 */
990static void
Michal Vasko2caefc12019-11-14 16:07:56 +0100991set_remove_node_none(struct lyxp_set *set, uint32_t idx)
Michal Vasko57eab132019-09-24 11:46:26 +0200992{
993 assert(set && (set->type == LYXP_SET_NODE_SET));
994 assert(idx < set->used);
995
Michal Vasko2caefc12019-11-14 16:07:56 +0100996 if (set->val.nodes[idx].type == LYXP_NODE_ELEM) {
997 set_remove_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
998 }
999 set->val.nodes[idx].type = LYXP_NODE_NONE;
Michal Vasko57eab132019-09-24 11:46:26 +02001000}
1001
1002/**
Michal Vasko2caefc12019-11-14 16:07:56 +01001003 * @brief Remove all LYXP_NODE_NONE nodes from a set. Removing last node changes
Michal Vasko57eab132019-09-24 11:46:26 +02001004 * set into LYXP_SET_EMPTY. Context position aware.
1005 *
1006 * @param[in] set Set to consolidate.
1007 */
1008static void
Michal Vasko2caefc12019-11-14 16:07:56 +01001009set_remove_nodes_none(struct lyxp_set *set)
Michal Vasko57eab132019-09-24 11:46:26 +02001010{
Michal Vasko1fdd8fa2021-01-08 09:21:45 +01001011 uint32_t i, orig_used, end = 0;
1012 int64_t start;
Michal Vasko57eab132019-09-24 11:46:26 +02001013
Michal Vaskod3678892020-05-21 10:06:58 +02001014 assert(set);
Michal Vasko57eab132019-09-24 11:46:26 +02001015
1016 orig_used = set->used;
1017 set->used = 0;
Michal Vaskod989ba02020-08-24 10:59:24 +02001018 for (i = 0; i < orig_used; ) {
Michal Vasko57eab132019-09-24 11:46:26 +02001019 start = -1;
1020 do {
Michal Vasko2caefc12019-11-14 16:07:56 +01001021 if ((set->val.nodes[i].type != LYXP_NODE_NONE) && (start == -1)) {
Michal Vasko57eab132019-09-24 11:46:26 +02001022 start = i;
Michal Vasko2caefc12019-11-14 16:07:56 +01001023 } else if ((start > -1) && (set->val.nodes[i].type == LYXP_NODE_NONE)) {
Michal Vasko57eab132019-09-24 11:46:26 +02001024 end = i;
1025 ++i;
1026 break;
1027 }
1028
1029 ++i;
1030 if (i == orig_used) {
1031 end = i;
1032 }
1033 } while (i < orig_used);
1034
1035 if (start > -1) {
1036 /* move the whole chunk of valid nodes together */
1037 if (set->used != (unsigned)start) {
1038 memmove(&set->val.nodes[set->used], &set->val.nodes[start], (end - start) * sizeof *set->val.nodes);
1039 }
1040 set->used += end - start;
1041 }
1042 }
Michal Vasko57eab132019-09-24 11:46:26 +02001043}
1044
1045/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02001046 * @brief Check for duplicates in a node set.
1047 *
1048 * @param[in] set Set to check.
1049 * @param[in] node Node to look for in @p set.
1050 * @param[in] node_type Type of @p node.
1051 * @param[in] skip_idx Index from @p set to skip.
1052 * @return LY_ERR
1053 */
1054static LY_ERR
1055set_dup_node_check(const struct lyxp_set *set, const struct lyd_node *node, enum lyxp_node_type node_type, int skip_idx)
1056{
1057 uint32_t i;
1058
Michal Vasko2caefc12019-11-14 16:07:56 +01001059 if (set->ht && node) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001060 return set_dup_node_hash_check(set, (struct lyd_node *)node, node_type, skip_idx);
1061 }
1062
1063 for (i = 0; i < set->used; ++i) {
1064 if ((skip_idx > -1) && (i == (unsigned)skip_idx)) {
1065 continue;
1066 }
1067
1068 if ((set->val.nodes[i].node == node) && (set->val.nodes[i].type == node_type)) {
1069 return LY_EEXIST;
1070 }
1071 }
1072
1073 return LY_SUCCESS;
1074}
1075
Radek Krejci857189e2020-09-01 13:26:36 +02001076ly_bool
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001077lyxp_set_scnode_contains(struct lyxp_set *set, const struct lysc_node *node, enum lyxp_node_type node_type, int skip_idx,
1078 uint32_t *index_p)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001079{
1080 uint32_t i;
1081
1082 for (i = 0; i < set->used; ++i) {
1083 if ((skip_idx > -1) && (i == (unsigned)skip_idx)) {
1084 continue;
1085 }
1086
1087 if ((set->val.scnodes[i].scnode == node) && (set->val.scnodes[i].type == node_type)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001088 if (index_p) {
1089 *index_p = i;
1090 }
1091 return 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001092 }
1093 }
1094
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001095 return 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001096}
1097
Michal Vaskoecd62de2019-11-13 12:35:11 +01001098void
1099lyxp_set_scnode_merge(struct lyxp_set *set1, struct lyxp_set *set2)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001100{
1101 uint32_t orig_used, i, j;
1102
Michal Vaskod3678892020-05-21 10:06:58 +02001103 assert((set1->type == LYXP_SET_SCNODE_SET) && (set2->type == LYXP_SET_SCNODE_SET));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001104
Michal Vaskod3678892020-05-21 10:06:58 +02001105 if (!set2->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001106 return;
1107 }
1108
Michal Vaskod3678892020-05-21 10:06:58 +02001109 if (!set1->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001110 memcpy(set1, set2, sizeof *set1);
1111 return;
1112 }
1113
1114 if (set1->used + set2->used > set1->size) {
1115 set1->size = set1->used + set2->used;
1116 set1->val.scnodes = ly_realloc(set1->val.scnodes, set1->size * sizeof *set1->val.scnodes);
1117 LY_CHECK_ERR_RET(!set1->val.scnodes, LOGMEM(set1->ctx), );
1118 }
1119
1120 orig_used = set1->used;
1121
1122 for (i = 0; i < set2->used; ++i) {
1123 for (j = 0; j < orig_used; ++j) {
1124 /* detect duplicities */
1125 if (set1->val.scnodes[j].scnode == set2->val.scnodes[i].scnode) {
1126 break;
1127 }
1128 }
1129
Michal Vasko0587bce2020-12-10 12:19:21 +01001130 if (j < orig_used) {
1131 /* node is there, but update its status if needed */
1132 if (set1->val.scnodes[j].in_ctx == LYXP_SET_SCNODE_START_USED) {
1133 set1->val.scnodes[j].in_ctx = set2->val.scnodes[i].in_ctx;
1134 }
1135 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001136 memcpy(&set1->val.scnodes[set1->used], &set2->val.scnodes[i], sizeof *set2->val.scnodes);
1137 ++set1->used;
1138 }
1139 }
1140
Michal Vaskod3678892020-05-21 10:06:58 +02001141 lyxp_set_free_content(set2);
1142 set2->type = LYXP_SET_SCNODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001143}
1144
1145/**
1146 * @brief Insert a node into a set. Context position aware.
1147 *
1148 * @param[in] set Set to use.
1149 * @param[in] node Node to insert to @p set.
1150 * @param[in] pos Sort position of @p node. If left 0, it is filled just before sorting.
1151 * @param[in] node_type Node type of @p node.
1152 * @param[in] idx Index in @p set to insert into.
1153 */
1154static void
1155set_insert_node(struct lyxp_set *set, const struct lyd_node *node, uint32_t pos, enum lyxp_node_type node_type, uint32_t idx)
1156{
Michal Vaskod3678892020-05-21 10:06:58 +02001157 assert(set && (set->type == LYXP_SET_NODE_SET));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001158
Michal Vaskod3678892020-05-21 10:06:58 +02001159 if (!set->size) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001160 /* first item */
1161 if (idx) {
1162 /* no real harm done, but it is a bug */
1163 LOGINT(set->ctx);
1164 idx = 0;
1165 }
1166 set->val.nodes = malloc(LYXP_SET_SIZE_START * sizeof *set->val.nodes);
1167 LY_CHECK_ERR_RET(!set->val.nodes, LOGMEM(set->ctx), );
1168 set->type = LYXP_SET_NODE_SET;
1169 set->used = 0;
1170 set->size = LYXP_SET_SIZE_START;
1171 set->ctx_pos = 1;
1172 set->ctx_size = 1;
1173 set->ht = NULL;
1174 } else {
1175 /* not an empty set */
1176 if (set->used == set->size) {
1177
1178 /* set is full */
1179 set->val.nodes = ly_realloc(set->val.nodes, (set->size + LYXP_SET_SIZE_STEP) * sizeof *set->val.nodes);
1180 LY_CHECK_ERR_RET(!set->val.nodes, LOGMEM(set->ctx), );
1181 set->size += LYXP_SET_SIZE_STEP;
1182 }
1183
1184 if (idx > set->used) {
1185 LOGINT(set->ctx);
1186 idx = set->used;
1187 }
1188
1189 /* make space for the new node */
1190 if (idx < set->used) {
1191 memmove(&set->val.nodes[idx + 1], &set->val.nodes[idx], (set->used - idx) * sizeof *set->val.nodes);
1192 }
1193 }
1194
1195 /* finally assign the value */
1196 set->val.nodes[idx].node = (struct lyd_node *)node;
1197 set->val.nodes[idx].type = node_type;
1198 set->val.nodes[idx].pos = pos;
1199 ++set->used;
1200
Michal Vasko2caefc12019-11-14 16:07:56 +01001201 if (set->val.nodes[idx].type == LYXP_NODE_ELEM) {
1202 set_insert_node_hash(set, (struct lyd_node *)node, node_type);
1203 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02001204}
1205
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001206LY_ERR
1207lyxp_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 +02001208{
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001209 uint32_t index;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001210
1211 assert(set->type == LYXP_SET_SCNODE_SET);
1212
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001213 if (lyxp_set_scnode_contains(set, node, node_type, -1, &index)) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01001214 set->val.scnodes[index].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001215 } else {
1216 if (set->used == set->size) {
1217 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 +02001218 LY_CHECK_ERR_RET(!set->val.scnodes, LOGMEM(set->ctx), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001219 set->size += LYXP_SET_SIZE_STEP;
1220 }
1221
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001222 index = set->used;
1223 set->val.scnodes[index].scnode = (struct lysc_node *)node;
1224 set->val.scnodes[index].type = node_type;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001225 set->val.scnodes[index].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001226 ++set->used;
1227 }
1228
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001229 if (index_p) {
1230 *index_p = index;
1231 }
1232
1233 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001234}
1235
1236/**
1237 * @brief Replace a node in a set with another. Context position aware.
1238 *
1239 * @param[in] set Set to use.
1240 * @param[in] node Node to insert to @p set.
1241 * @param[in] pos Sort position of @p node. If left 0, it is filled just before sorting.
1242 * @param[in] node_type Node type of @p node.
1243 * @param[in] idx Index in @p set of the node to replace.
1244 */
1245static void
1246set_replace_node(struct lyxp_set *set, const struct lyd_node *node, uint32_t pos, enum lyxp_node_type node_type, uint32_t idx)
1247{
1248 assert(set && (idx < set->used));
1249
Michal Vasko2caefc12019-11-14 16:07:56 +01001250 if (set->val.nodes[idx].type == LYXP_NODE_ELEM) {
1251 set_remove_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
1252 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02001253 set->val.nodes[idx].node = (struct lyd_node *)node;
1254 set->val.nodes[idx].type = node_type;
1255 set->val.nodes[idx].pos = pos;
Michal Vasko2caefc12019-11-14 16:07:56 +01001256 if (set->val.nodes[idx].type == LYXP_NODE_ELEM) {
1257 set_insert_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
1258 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02001259}
1260
1261/**
1262 * @brief Set all nodes with ctx 1 to a new unique context value.
1263 *
1264 * @param[in] set Set to modify.
1265 * @return New context value.
1266 */
Michal Vasko5c4e5892019-11-14 12:31:38 +01001267static int32_t
Michal Vasko03ff5a72019-09-11 13:49:33 +02001268set_scnode_new_in_ctx(struct lyxp_set *set)
1269{
Michal Vasko5c4e5892019-11-14 12:31:38 +01001270 uint32_t i;
1271 int32_t ret_ctx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001272
1273 assert(set->type == LYXP_SET_SCNODE_SET);
1274
Radek Krejcif13b87b2020-12-01 22:02:17 +01001275 ret_ctx = LYXP_SET_SCNODE_ATOM_PRED_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001276retry:
1277 for (i = 0; i < set->used; ++i) {
1278 if (set->val.scnodes[i].in_ctx >= ret_ctx) {
1279 ret_ctx = set->val.scnodes[i].in_ctx + 1;
1280 goto retry;
1281 }
1282 }
1283 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01001284 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001285 set->val.scnodes[i].in_ctx = ret_ctx;
1286 }
1287 }
1288
1289 return ret_ctx;
1290}
1291
1292/**
1293 * @brief Get unique @p node position in the data.
1294 *
1295 * @param[in] node Node to find.
1296 * @param[in] node_type Node type of @p node.
1297 * @param[in] root Root node.
1298 * @param[in] root_type Type of the XPath @p root node.
1299 * @param[in] prev Node that we think is before @p node in DFS from @p root. Can optionally
1300 * be used to increase efficiency and start the DFS from this node.
1301 * @param[in] prev_pos Node @p prev position. Optional, but must be set if @p prev is set.
1302 * @return Node position.
1303 */
1304static uint32_t
1305get_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 +02001306 enum lyxp_node_type root_type, const struct lyd_node **prev, uint32_t *prev_pos)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001307{
Michal Vasko56daf732020-08-10 10:57:18 +02001308 const struct lyd_node *elem = NULL, *top_sibling;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001309 uint32_t pos = 1;
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001310 ly_bool found = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001311
1312 assert(prev && prev_pos && !root->prev->next);
1313
1314 if ((node_type == LYXP_NODE_ROOT) || (node_type == LYXP_NODE_ROOT_CONFIG)) {
1315 return 0;
1316 }
1317
1318 if (*prev) {
1319 /* start from the previous element instead from the root */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001320 pos = *prev_pos;
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001321 for (top_sibling = *prev; top_sibling->parent; top_sibling = lyd_parent(top_sibling)) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001322 goto dfs_search;
1323 }
1324
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001325 LY_LIST_FOR(root, top_sibling) {
Michal Vasko56daf732020-08-10 10:57:18 +02001326 LYD_TREE_DFS_BEGIN(top_sibling, elem) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001327dfs_search:
Michal Vasko56daf732020-08-10 10:57:18 +02001328 if (*prev && !elem) {
1329 /* resume previous DFS */
1330 elem = LYD_TREE_DFS_next = (struct lyd_node *)*prev;
1331 LYD_TREE_DFS_continue = 0;
1332 }
1333
Michal Vasko03ff5a72019-09-11 13:49:33 +02001334 if ((root_type == LYXP_NODE_ROOT_CONFIG) && (elem->schema->flags & LYS_CONFIG_R)) {
Michal Vasko56daf732020-08-10 10:57:18 +02001335 /* skip */
1336 LYD_TREE_DFS_continue = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001337 } else {
Michal Vasko56daf732020-08-10 10:57:18 +02001338 if (elem == node) {
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001339 found = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001340 break;
1341 }
Michal Vasko56daf732020-08-10 10:57:18 +02001342 ++pos;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001343 }
Michal Vasko56daf732020-08-10 10:57:18 +02001344
1345 LYD_TREE_DFS_END(top_sibling, elem);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001346 }
1347
1348 /* node found */
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001349 if (found) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001350 break;
1351 }
1352 }
1353
Michal Vaskofb6c9dd2020-11-18 18:18:47 +01001354 if (!found) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001355 if (!(*prev)) {
1356 /* we went from root and failed to find it, cannot be */
Michal Vaskob7be7a82020-08-20 09:09:04 +02001357 LOGINT(LYD_CTX(node));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001358 return 0;
1359 } else {
Michal Vasko56daf732020-08-10 10:57:18 +02001360 /* start the search again from the beginning */
1361 *prev = root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001362
Michal Vasko56daf732020-08-10 10:57:18 +02001363 top_sibling = root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001364 pos = 1;
1365 goto dfs_search;
1366 }
1367 }
1368
1369 /* remember the last found node for next time */
1370 *prev = node;
1371 *prev_pos = pos;
1372
1373 return pos;
1374}
1375
1376/**
1377 * @brief Assign (fill) missing node positions.
1378 *
1379 * @param[in] set Set to fill positions in.
1380 * @param[in] root Context root node.
1381 * @param[in] root_type Context root type.
1382 * @return LY_ERR
1383 */
1384static LY_ERR
1385set_assign_pos(struct lyxp_set *set, const struct lyd_node *root, enum lyxp_node_type root_type)
1386{
1387 const struct lyd_node *prev = NULL, *tmp_node;
1388 uint32_t i, tmp_pos = 0;
1389
1390 for (i = 0; i < set->used; ++i) {
1391 if (!set->val.nodes[i].pos) {
1392 tmp_node = NULL;
1393 switch (set->val.nodes[i].type) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001394 case LYXP_NODE_META:
1395 tmp_node = set->val.meta[i].meta->parent;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001396 if (!tmp_node) {
1397 LOGINT_RET(root->schema->module->ctx);
1398 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01001399 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001400 case LYXP_NODE_ELEM:
1401 case LYXP_NODE_TEXT:
1402 if (!tmp_node) {
1403 tmp_node = set->val.nodes[i].node;
1404 }
1405 set->val.nodes[i].pos = get_node_pos(tmp_node, set->val.nodes[i].type, root, root_type, &prev, &tmp_pos);
1406 break;
1407 default:
1408 /* all roots have position 0 */
1409 break;
1410 }
1411 }
1412 }
1413
1414 return LY_SUCCESS;
1415}
1416
1417/**
Michal Vasko9f96a052020-03-10 09:41:45 +01001418 * @brief Get unique @p meta position in the parent metadata.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001419 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001420 * @param[in] meta Metadata to use.
1421 * @return Metadata position.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001422 */
1423static uint16_t
Michal Vasko9f96a052020-03-10 09:41:45 +01001424get_meta_pos(struct lyd_meta *meta)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001425{
1426 uint16_t pos = 0;
Michal Vasko9f96a052020-03-10 09:41:45 +01001427 struct lyd_meta *meta2;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001428
Michal Vasko9f96a052020-03-10 09:41:45 +01001429 for (meta2 = meta->parent->meta; meta2 && (meta2 != meta); meta2 = meta2->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001430 ++pos;
1431 }
1432
Michal Vasko9f96a052020-03-10 09:41:45 +01001433 assert(meta2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001434 return pos;
1435}
1436
1437/**
1438 * @brief Compare 2 nodes in respect to XPath document order.
1439 *
1440 * @param[in] item1 1st node.
1441 * @param[in] item2 2nd node.
1442 * @return If 1st > 2nd returns 1, 1st == 2nd returns 0, and 1st < 2nd returns -1.
1443 */
1444static int
1445set_sort_compare(struct lyxp_set_node *item1, struct lyxp_set_node *item2)
1446{
Michal Vasko9f96a052020-03-10 09:41:45 +01001447 uint32_t meta_pos1 = 0, meta_pos2 = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001448
1449 if (item1->pos < item2->pos) {
1450 return -1;
1451 }
1452
1453 if (item1->pos > item2->pos) {
1454 return 1;
1455 }
1456
1457 /* node positions are equal, the fun case */
1458
1459 /* 1st ELEM - == - 2nd TEXT, 1st TEXT - == - 2nd ELEM */
1460 /* special case since text nodes are actually saved as their parents */
1461 if ((item1->node == item2->node) && (item1->type != item2->type)) {
1462 if (item1->type == LYXP_NODE_ELEM) {
1463 assert(item2->type == LYXP_NODE_TEXT);
1464 return -1;
1465 } else {
1466 assert((item1->type == LYXP_NODE_TEXT) && (item2->type == LYXP_NODE_ELEM));
1467 return 1;
1468 }
1469 }
1470
Michal Vasko9f96a052020-03-10 09:41:45 +01001471 /* we need meta positions now */
1472 if (item1->type == LYXP_NODE_META) {
1473 meta_pos1 = get_meta_pos((struct lyd_meta *)item1->node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001474 }
Michal Vasko9f96a052020-03-10 09:41:45 +01001475 if (item2->type == LYXP_NODE_META) {
1476 meta_pos2 = get_meta_pos((struct lyd_meta *)item2->node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001477 }
1478
Michal Vasko9f96a052020-03-10 09:41:45 +01001479 /* 1st ROOT - 2nd ROOT, 1st ELEM - 2nd ELEM, 1st TEXT - 2nd TEXT, 1st META - =pos= - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001480 /* check for duplicates */
1481 if (item1->node == item2->node) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001482 assert((item1->type == item2->type) && ((item1->type != LYXP_NODE_META) || (meta_pos1 == meta_pos2)));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001483 return 0;
1484 }
1485
Michal Vasko9f96a052020-03-10 09:41:45 +01001486 /* 1st ELEM - 2nd TEXT, 1st ELEM - any pos - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001487 /* elem is always first, 2nd node is after it */
1488 if (item1->type == LYXP_NODE_ELEM) {
1489 assert(item2->type != LYXP_NODE_ELEM);
1490 return -1;
1491 }
1492
Michal Vasko9f96a052020-03-10 09:41:45 +01001493 /* 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 +02001494 /* 2nd is before 1st */
Michal Vasko69730152020-10-09 16:30:07 +02001495 if (((item1->type == LYXP_NODE_TEXT) &&
1496 ((item2->type == LYXP_NODE_ELEM) || (item2->type == LYXP_NODE_META))) ||
1497 ((item1->type == LYXP_NODE_META) && (item2->type == LYXP_NODE_ELEM)) ||
1498 (((item1->type == LYXP_NODE_META) && (item2->type == LYXP_NODE_META)) &&
1499 (meta_pos1 > meta_pos2))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001500 return 1;
1501 }
1502
Michal Vasko9f96a052020-03-10 09:41:45 +01001503 /* 1st META - any pos - 2nd TEXT, 1st META <pos< - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001504 /* 2nd is after 1st */
1505 return -1;
1506}
1507
1508/**
1509 * @brief Set cast for comparisons.
1510 *
1511 * @param[in] trg Target set to cast source into.
1512 * @param[in] src Source set.
1513 * @param[in] type Target set type.
1514 * @param[in] src_idx Source set node index.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001515 * @return LY_ERR
1516 */
1517static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001518set_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 +02001519{
1520 assert(src->type == LYXP_SET_NODE_SET);
1521
1522 set_init(trg, src);
1523
1524 /* insert node into target set */
1525 set_insert_node(trg, src->val.nodes[src_idx].node, src->val.nodes[src_idx].pos, src->val.nodes[src_idx].type, 0);
1526
1527 /* cast target set appropriately */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001528 return lyxp_set_cast(trg, type);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001529}
1530
Michal Vasko4c7763f2020-07-27 17:40:37 +02001531/**
1532 * @brief Set content canonization for comparisons.
1533 *
1534 * @param[in] trg Target set to put the canononized source into.
1535 * @param[in] src Source set.
1536 * @param[in] xp_node Source XPath node/meta to use for canonization.
1537 * @return LY_ERR
1538 */
1539static LY_ERR
1540set_comp_canonize(struct lyxp_set *trg, const struct lyxp_set *src, const struct lyxp_set_node *xp_node)
1541{
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001542 const struct lysc_type *type = NULL;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001543 struct lyd_value val;
1544 struct ly_err_item *err = NULL;
1545 char *str, *ptr;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001546 LY_ERR rc;
1547
1548 /* is there anything to canonize even? */
1549 if ((src->type == LYXP_SET_NUMBER) || (src->type == LYXP_SET_STRING)) {
1550 /* do we have a type to use for canonization? */
1551 if ((xp_node->type == LYXP_NODE_ELEM) && (xp_node->node->schema->nodetype & LYD_NODE_TERM)) {
1552 type = ((struct lyd_node_term *)xp_node->node)->value.realtype;
1553 } else if (xp_node->type == LYXP_NODE_META) {
1554 type = ((struct lyd_meta *)xp_node->node)->value.realtype;
1555 }
1556 }
1557 if (!type) {
1558 goto fill;
1559 }
1560
1561 if (src->type == LYXP_SET_NUMBER) {
1562 /* canonize number */
1563 if (asprintf(&str, "%Lf", src->val.num) == -1) {
1564 LOGMEM(src->ctx);
1565 return LY_EMEM;
1566 }
1567 } else {
1568 /* canonize string */
1569 str = strdup(src->val.str);
1570 }
1571
1572 /* ignore errors, the value may not satisfy schema constraints */
Radek Krejci0b013302021-03-29 15:22:32 +02001573 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 +01001574 LYD_HINT_DATA, xp_node->node->schema, &val, NULL, &err);
Michal Vasko4c7763f2020-07-27 17:40:37 +02001575 ly_err_free(err);
1576 if (rc) {
1577 /* invalid value */
Radek IÅ¡a48460222021-03-02 15:18:32 +01001578 /* function store automaticaly dealloc value when fail */
Michal Vasko4c7763f2020-07-27 17:40:37 +02001579 goto fill;
1580 }
1581
Michal Vasko4c7763f2020-07-27 17:40:37 +02001582 /* use the canonized value */
1583 set_init(trg, src);
1584 trg->type = src->type;
1585 if (src->type == LYXP_SET_NUMBER) {
Michal Vasko0fdb0d92020-11-06 17:25:50 +01001586 trg->val.num = strtold(val.canonical, &ptr);
Michal Vasko4c7763f2020-07-27 17:40:37 +02001587 LY_CHECK_ERR_RET(ptr[0], LOGINT(src->ctx), LY_EINT);
1588 } else {
Michal Vasko0fdb0d92020-11-06 17:25:50 +01001589 trg->val.str = strdup(val.canonical);
Michal Vasko4c7763f2020-07-27 17:40:37 +02001590 }
1591 type->plugin->free(src->ctx, &val);
1592 return LY_SUCCESS;
1593
1594fill:
1595 /* no canonization needed/possible */
1596 set_fill_set(trg, src);
1597 return LY_SUCCESS;
1598}
1599
Michal Vasko03ff5a72019-09-11 13:49:33 +02001600#ifndef NDEBUG
1601
1602/**
1603 * @brief Bubble sort @p set into XPath document order.
1604 * Context position aware. Unused in the 'Release' build target.
1605 *
1606 * @param[in] set Set to sort.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001607 * @return How many times the whole set was traversed - 1 (if set was sorted, returns 0).
1608 */
1609static int
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001610set_sort(struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001611{
1612 uint32_t i, j;
Radek Krejci1deb5be2020-08-26 16:43:36 +02001613 int ret = 0, cmp;
Radek Krejci857189e2020-09-01 13:26:36 +02001614 ly_bool inverted, change;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001615 const struct lyd_node *root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001616 struct lyxp_set_node item;
1617 struct lyxp_set_hash_node hnode;
1618 uint64_t hash;
1619
Michal Vasko3cf8fbf2020-05-27 15:21:21 +02001620 if ((set->type != LYXP_SET_NODE_SET) || (set->used < 2)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001621 return 0;
1622 }
1623
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001624 /* find first top-level node to be used as anchor for positions */
Michal Vasko9e685082021-01-29 14:49:09 +01001625 for (root = set->cur_node; root->parent; root = lyd_parent(root)) {}
Michal Vaskod989ba02020-08-24 10:59:24 +02001626 for ( ; root->prev->next; root = root->prev) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001627
1628 /* fill positions */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001629 if (set_assign_pos(set, root, set->root_type)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001630 return -1;
1631 }
1632
1633 LOGDBG(LY_LDGXPATH, "SORT BEGIN");
1634 print_set_debug(set);
1635
1636 for (i = 0; i < set->used; ++i) {
1637 inverted = 0;
1638 change = 0;
1639
1640 for (j = 1; j < set->used - i; ++j) {
1641 /* compare node positions */
1642 if (inverted) {
1643 cmp = set_sort_compare(&set->val.nodes[j], &set->val.nodes[j - 1]);
1644 } else {
1645 cmp = set_sort_compare(&set->val.nodes[j - 1], &set->val.nodes[j]);
1646 }
1647
1648 /* swap if needed */
1649 if ((inverted && (cmp < 0)) || (!inverted && (cmp > 0))) {
1650 change = 1;
1651
1652 item = set->val.nodes[j - 1];
1653 set->val.nodes[j - 1] = set->val.nodes[j];
1654 set->val.nodes[j] = item;
1655 } else {
1656 /* whether node_pos1 should be smaller than node_pos2 or the other way around */
1657 inverted = !inverted;
1658 }
1659 }
1660
1661 ++ret;
1662
1663 if (!change) {
1664 break;
1665 }
1666 }
1667
1668 LOGDBG(LY_LDGXPATH, "SORT END %d", ret);
1669 print_set_debug(set);
1670
1671 /* check node hashes */
1672 if (set->used >= LYD_HT_MIN_ITEMS) {
1673 assert(set->ht);
1674 for (i = 0; i < set->used; ++i) {
1675 hnode.node = set->val.nodes[i].node;
1676 hnode.type = set->val.nodes[i].type;
1677
1678 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
1679 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
1680 hash = dict_hash_multi(hash, NULL, 0);
1681
1682 assert(!lyht_find(set->ht, &hnode, hash, NULL));
1683 }
1684 }
1685
1686 return ret - 1;
1687}
1688
1689/**
1690 * @brief Remove duplicate entries in a sorted node set.
1691 *
1692 * @param[in] set Sorted set to check.
1693 * @return LY_ERR (LY_EEXIST if some duplicates are found)
1694 */
1695static LY_ERR
1696set_sorted_dup_node_clean(struct lyxp_set *set)
1697{
1698 uint32_t i = 0;
1699 LY_ERR ret = LY_SUCCESS;
1700
1701 if (set->used > 1) {
1702 while (i < set->used - 1) {
Michal Vasko69730152020-10-09 16:30:07 +02001703 if ((set->val.nodes[i].node == set->val.nodes[i + 1].node) &&
1704 (set->val.nodes[i].type == set->val.nodes[i + 1].type)) {
Michal Vasko2caefc12019-11-14 16:07:56 +01001705 set_remove_node_none(set, i + 1);
Michal Vasko57eab132019-09-24 11:46:26 +02001706 ret = LY_EEXIST;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001707 }
Michal Vasko57eab132019-09-24 11:46:26 +02001708 ++i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001709 }
1710 }
1711
Michal Vasko2caefc12019-11-14 16:07:56 +01001712 set_remove_nodes_none(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001713 return ret;
1714}
1715
1716#endif
1717
1718/**
1719 * @brief Merge 2 sorted sets into one.
1720 *
1721 * @param[in,out] trg Set to merge into. Duplicates are removed.
1722 * @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 +02001723 * @return LY_ERR
1724 */
1725static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001726set_sorted_merge(struct lyxp_set *trg, struct lyxp_set *src)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001727{
1728 uint32_t i, j, k, count, dup_count;
1729 int cmp;
1730 const struct lyd_node *root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001731
Michal Vaskod3678892020-05-21 10:06:58 +02001732 if ((trg->type != LYXP_SET_NODE_SET) || (src->type != LYXP_SET_NODE_SET)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001733 return LY_EINVAL;
1734 }
1735
Michal Vaskod3678892020-05-21 10:06:58 +02001736 if (!src->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001737 return LY_SUCCESS;
Michal Vaskod3678892020-05-21 10:06:58 +02001738 } else if (!trg->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001739 set_fill_set(trg, src);
Michal Vaskod3678892020-05-21 10:06:58 +02001740 lyxp_set_free_content(src);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001741 return LY_SUCCESS;
1742 }
1743
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001744 /* find first top-level node to be used as anchor for positions */
Michal Vasko9e685082021-01-29 14:49:09 +01001745 for (root = trg->cur_node; root->parent; root = lyd_parent(root)) {}
Michal Vaskod989ba02020-08-24 10:59:24 +02001746 for ( ; root->prev->next; root = root->prev) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001747
1748 /* fill positions */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001749 if (set_assign_pos(trg, root, trg->root_type) || set_assign_pos(src, root, src->root_type)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001750 return LY_EINT;
1751 }
1752
1753#ifndef NDEBUG
1754 LOGDBG(LY_LDGXPATH, "MERGE target");
1755 print_set_debug(trg);
1756 LOGDBG(LY_LDGXPATH, "MERGE source");
1757 print_set_debug(src);
1758#endif
1759
1760 /* make memory for the merge (duplicates are not detected yet, so space
1761 * will likely be wasted on them, too bad) */
1762 if (trg->size - trg->used < src->used) {
1763 trg->size = trg->used + src->used;
1764
1765 trg->val.nodes = ly_realloc(trg->val.nodes, trg->size * sizeof *trg->val.nodes);
1766 LY_CHECK_ERR_RET(!trg->val.nodes, LOGMEM(src->ctx), LY_EMEM);
1767 }
1768
1769 i = 0;
1770 j = 0;
1771 count = 0;
1772 dup_count = 0;
1773 do {
1774 cmp = set_sort_compare(&src->val.nodes[i], &trg->val.nodes[j]);
1775 if (!cmp) {
1776 if (!count) {
1777 /* duplicate, just skip it */
1778 ++i;
1779 ++j;
1780 } else {
1781 /* we are copying something already, so let's copy the duplicate too,
1782 * we are hoping that afterwards there are some more nodes to
1783 * copy and this way we can copy them all together */
1784 ++count;
1785 ++dup_count;
1786 ++i;
1787 ++j;
1788 }
1789 } else if (cmp < 0) {
1790 /* inserting src node into trg, just remember it for now */
1791 ++count;
1792 ++i;
1793
1794 /* insert the hash now */
1795 set_insert_node_hash(trg, src->val.nodes[i - 1].node, src->val.nodes[i - 1].type);
1796 } else if (count) {
1797copy_nodes:
1798 /* time to actually copy the nodes, we have found the largest block of nodes */
1799 memmove(&trg->val.nodes[j + (count - dup_count)],
1800 &trg->val.nodes[j],
1801 (trg->used - j) * sizeof *trg->val.nodes);
1802 memcpy(&trg->val.nodes[j - dup_count], &src->val.nodes[i - count], count * sizeof *src->val.nodes);
1803
1804 trg->used += count - dup_count;
1805 /* do not change i, except the copying above, we are basically doing exactly what is in the else branch below */
1806 j += count - dup_count;
1807
1808 count = 0;
1809 dup_count = 0;
1810 } else {
1811 ++j;
1812 }
1813 } while ((i < src->used) && (j < trg->used));
1814
1815 if ((i < src->used) || count) {
1816 /* insert all the hashes first */
1817 for (k = i; k < src->used; ++k) {
1818 set_insert_node_hash(trg, src->val.nodes[k].node, src->val.nodes[k].type);
1819 }
1820
1821 /* loop ended, but we need to copy something at trg end */
1822 count += src->used - i;
1823 i = src->used;
1824 goto copy_nodes;
1825 }
1826
1827 /* we are inserting hashes before the actual node insert, which causes
1828 * situations when there were initially not enough items for a hash table,
1829 * but even after some were inserted, hash table was not created (during
1830 * insertion the number of items is not updated yet) */
1831 if (!trg->ht && (trg->used >= LYD_HT_MIN_ITEMS)) {
1832 set_insert_node_hash(trg, NULL, 0);
1833 }
1834
1835#ifndef NDEBUG
1836 LOGDBG(LY_LDGXPATH, "MERGE result");
1837 print_set_debug(trg);
1838#endif
1839
Michal Vaskod3678892020-05-21 10:06:58 +02001840 lyxp_set_free_content(src);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001841 return LY_SUCCESS;
1842}
1843
1844/*
1845 * (re)parse functions
1846 *
1847 * Parse functions parse the expression into
1848 * tokens (syntactic analysis).
1849 *
1850 * Reparse functions perform semantic analysis
1851 * (do not save the result, just a check) of
1852 * the expression and fill repeat indices.
1853 */
1854
Michal Vasko14676352020-05-29 11:35:55 +02001855LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02001856lyxp_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 +02001857{
Michal Vasko004d3152020-06-11 19:59:22 +02001858 if (exp->used == tok_idx) {
Michal Vasko14676352020-05-29 11:35:55 +02001859 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001860 LOGVAL(ctx, LY_VCODE_XP_EOF);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001861 }
Michal Vasko14676352020-05-29 11:35:55 +02001862 return LY_EINCOMPLETE;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001863 }
1864
Michal Vasko004d3152020-06-11 19:59:22 +02001865 if (want_tok && (exp->tokens[tok_idx] != want_tok)) {
Michal Vasko14676352020-05-29 11:35:55 +02001866 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001867 LOGVAL(ctx, LY_VCODE_XP_INTOK2, lyxp_print_token(exp->tokens[tok_idx]),
Michal Vasko0b468e62020-10-19 09:33:04 +02001868 &exp->expr[exp->tok_pos[tok_idx]], lyxp_print_token(want_tok));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001869 }
Michal Vasko14676352020-05-29 11:35:55 +02001870 return LY_ENOT;
1871 }
1872
1873 return LY_SUCCESS;
1874}
1875
Michal Vasko004d3152020-06-11 19:59:22 +02001876LY_ERR
1877lyxp_next_token(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint16_t *tok_idx, enum lyxp_token want_tok)
1878{
1879 LY_CHECK_RET(lyxp_check_token(ctx, exp, *tok_idx, want_tok));
1880
1881 /* skip the token */
1882 ++(*tok_idx);
1883
1884 return LY_SUCCESS;
1885}
1886
Michal Vasko14676352020-05-29 11:35:55 +02001887/* just like lyxp_check_token() but tests for 2 tokens */
1888static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02001889exp_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 +02001890 enum lyxp_token want_tok2)
Michal Vasko14676352020-05-29 11:35:55 +02001891{
Michal Vasko004d3152020-06-11 19:59:22 +02001892 if (exp->used == tok_idx) {
Michal Vasko14676352020-05-29 11:35:55 +02001893 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001894 LOGVAL(ctx, LY_VCODE_XP_EOF);
Michal Vasko14676352020-05-29 11:35:55 +02001895 }
1896 return LY_EINCOMPLETE;
1897 }
1898
Michal Vasko004d3152020-06-11 19:59:22 +02001899 if ((exp->tokens[tok_idx] != want_tok1) && (exp->tokens[tok_idx] != want_tok2)) {
Michal Vasko14676352020-05-29 11:35:55 +02001900 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001901 LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_print_token(exp->tokens[tok_idx]),
Michal Vasko0b468e62020-10-19 09:33:04 +02001902 &exp->expr[exp->tok_pos[tok_idx]]);
Michal Vasko14676352020-05-29 11:35:55 +02001903 }
1904 return LY_ENOT;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001905 }
1906
1907 return LY_SUCCESS;
1908}
1909
1910/**
1911 * @brief Stack operation push on the repeat array.
1912 *
1913 * @param[in] exp Expression to use.
Michal Vasko004d3152020-06-11 19:59:22 +02001914 * @param[in] tok_idx Position in the expresion \p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001915 * @param[in] repeat_op_idx Index from \p exp of the operator token. This value is pushed.
1916 */
1917static void
Michal Vasko004d3152020-06-11 19:59:22 +02001918exp_repeat_push(struct lyxp_expr *exp, uint16_t tok_idx, uint16_t repeat_op_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001919{
1920 uint16_t i;
1921
Michal Vasko004d3152020-06-11 19:59:22 +02001922 if (exp->repeat[tok_idx]) {
Radek Krejci1e008d22020-08-17 11:37:37 +02001923 for (i = 0; exp->repeat[tok_idx][i]; ++i) {}
Michal Vasko004d3152020-06-11 19:59:22 +02001924 exp->repeat[tok_idx] = realloc(exp->repeat[tok_idx], (i + 2) * sizeof *exp->repeat[tok_idx]);
1925 LY_CHECK_ERR_RET(!exp->repeat[tok_idx], LOGMEM(NULL), );
1926 exp->repeat[tok_idx][i] = repeat_op_idx;
1927 exp->repeat[tok_idx][i + 1] = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001928 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02001929 exp->repeat[tok_idx] = calloc(2, sizeof *exp->repeat[tok_idx]);
1930 LY_CHECK_ERR_RET(!exp->repeat[tok_idx], LOGMEM(NULL), );
1931 exp->repeat[tok_idx][0] = repeat_op_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001932 }
1933}
1934
1935/**
1936 * @brief Reparse Predicate. Logs directly on error.
1937 *
1938 * [7] Predicate ::= '[' Expr ']'
1939 *
1940 * @param[in] ctx Context for logging.
1941 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02001942 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001943 * @return LY_ERR
1944 */
1945static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02001946reparse_predicate(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001947{
1948 LY_ERR rc;
1949
Michal Vasko004d3152020-06-11 19:59:22 +02001950 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_BRACK1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001951 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02001952 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001953
Michal Vasko004d3152020-06-11 19:59:22 +02001954 rc = reparse_or_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001955 LY_CHECK_RET(rc);
1956
Michal Vasko004d3152020-06-11 19:59:22 +02001957 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_BRACK2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001958 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02001959 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001960
1961 return LY_SUCCESS;
1962}
1963
1964/**
1965 * @brief Reparse RelativeLocationPath. Logs directly on error.
1966 *
1967 * [4] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
1968 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
1969 * [6] NodeTest ::= NameTest | NodeType '(' ')'
1970 *
1971 * @param[in] ctx Context for logging.
1972 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02001973 * @param[in] tok_idx Position in the expression \p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001974 * @return LY_ERR (LY_EINCOMPLETE on forward reference)
1975 */
1976static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02001977reparse_relative_location_path(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001978{
1979 LY_ERR rc;
1980
Michal Vasko004d3152020-06-11 19:59:22 +02001981 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001982 LY_CHECK_RET(rc);
1983
1984 goto step;
1985 do {
1986 /* '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02001987 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001988
Michal Vasko004d3152020-06-11 19:59:22 +02001989 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001990 LY_CHECK_RET(rc);
1991step:
1992 /* Step */
Michal Vasko004d3152020-06-11 19:59:22 +02001993 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001994 case LYXP_TOKEN_DOT:
Michal Vasko004d3152020-06-11 19:59:22 +02001995 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001996 break;
1997
1998 case LYXP_TOKEN_DDOT:
Michal Vasko004d3152020-06-11 19:59:22 +02001999 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002000 break;
2001
2002 case LYXP_TOKEN_AT:
Michal Vasko004d3152020-06-11 19:59:22 +02002003 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002004
Michal Vasko004d3152020-06-11 19:59:22 +02002005 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002006 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002007 if ((exp->tokens[*tok_idx] != LYXP_TOKEN_NAMETEST) && (exp->tokens[*tok_idx] != LYXP_TOKEN_NODETYPE)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002008 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 +02002009 return LY_EVALID;
2010 }
Radek Krejci0f969882020-08-21 16:56:47 +02002011 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02002012 case LYXP_TOKEN_NAMETEST:
Michal Vasko004d3152020-06-11 19:59:22 +02002013 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002014 goto reparse_predicate;
2015 break;
2016
2017 case LYXP_TOKEN_NODETYPE:
Michal Vasko004d3152020-06-11 19:59:22 +02002018 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002019
2020 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02002021 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002022 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002023 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002024
2025 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02002026 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002027 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002028 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002029
2030reparse_predicate:
2031 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002032 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
2033 rc = reparse_predicate(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002034 LY_CHECK_RET(rc);
2035 }
2036 break;
2037 default:
Radek Krejci2efc45b2020-12-22 16:25:44 +01002038 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 +02002039 return LY_EVALID;
2040 }
Michal Vasko004d3152020-06-11 19:59:22 +02002041 } while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH));
Michal Vasko03ff5a72019-09-11 13:49:33 +02002042
2043 return LY_SUCCESS;
2044}
2045
2046/**
2047 * @brief Reparse AbsoluteLocationPath. Logs directly on error.
2048 *
2049 * [3] AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
2050 *
2051 * @param[in] ctx Context for logging.
2052 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002053 * @param[in] tok_idx Position in the expression \p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002054 * @return LY_ERR
2055 */
2056static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002057reparse_absolute_location_path(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002058{
2059 LY_ERR rc;
2060
Michal Vasko004d3152020-06-11 19:59:22 +02002061 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 +02002062
2063 /* '/' RelativeLocationPath? */
Michal Vasko004d3152020-06-11 19:59:22 +02002064 if (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002065 /* '/' */
Michal Vasko004d3152020-06-11 19:59:22 +02002066 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002067
Michal Vasko004d3152020-06-11 19:59:22 +02002068 if (lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002069 return LY_SUCCESS;
2070 }
Michal Vasko004d3152020-06-11 19:59:22 +02002071 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002072 case LYXP_TOKEN_DOT:
2073 case LYXP_TOKEN_DDOT:
2074 case LYXP_TOKEN_AT:
2075 case LYXP_TOKEN_NAMETEST:
2076 case LYXP_TOKEN_NODETYPE:
Michal Vasko004d3152020-06-11 19:59:22 +02002077 rc = reparse_relative_location_path(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002078 LY_CHECK_RET(rc);
Radek Krejci0f969882020-08-21 16:56:47 +02002079 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02002080 default:
2081 break;
2082 }
2083
Michal Vasko03ff5a72019-09-11 13:49:33 +02002084 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02002085 /* '//' RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02002086 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002087
Michal Vasko004d3152020-06-11 19:59:22 +02002088 rc = reparse_relative_location_path(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002089 LY_CHECK_RET(rc);
2090 }
2091
2092 return LY_SUCCESS;
2093}
2094
2095/**
2096 * @brief Reparse FunctionCall. Logs directly on error.
2097 *
2098 * [9] FunctionCall ::= FunctionName '(' ( Expr ( ',' Expr )* )? ')'
2099 *
2100 * @param[in] ctx Context for logging.
2101 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002102 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002103 * @return LY_ERR
2104 */
2105static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002106reparse_function_call(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002107{
Radek Krejci1deb5be2020-08-26 16:43:36 +02002108 int8_t min_arg_count = -1;
2109 uint32_t arg_count, max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002110 uint16_t func_tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002111 LY_ERR rc;
2112
Michal Vasko004d3152020-06-11 19:59:22 +02002113 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_FUNCNAME);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002114 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002115 func_tok_idx = *tok_idx;
2116 switch (exp->tok_len[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002117 case 3:
Michal Vasko004d3152020-06-11 19:59:22 +02002118 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "not", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002119 min_arg_count = 1;
2120 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002121 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "sum", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002122 min_arg_count = 1;
2123 max_arg_count = 1;
2124 }
2125 break;
2126 case 4:
Michal Vasko004d3152020-06-11 19:59:22 +02002127 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "lang", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002128 min_arg_count = 1;
2129 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002130 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "last", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002131 min_arg_count = 0;
2132 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002133 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "name", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002134 min_arg_count = 0;
2135 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002136 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "true", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002137 min_arg_count = 0;
2138 max_arg_count = 0;
2139 }
2140 break;
2141 case 5:
Michal Vasko004d3152020-06-11 19:59:22 +02002142 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "count", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002143 min_arg_count = 1;
2144 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002145 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "false", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002146 min_arg_count = 0;
2147 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002148 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "floor", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002149 min_arg_count = 1;
2150 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002151 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "round", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002152 min_arg_count = 1;
2153 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002154 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "deref", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002155 min_arg_count = 1;
2156 max_arg_count = 1;
2157 }
2158 break;
2159 case 6:
Michal Vasko004d3152020-06-11 19:59:22 +02002160 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "concat", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002161 min_arg_count = 2;
Radek Krejci1deb5be2020-08-26 16:43:36 +02002162 max_arg_count = UINT32_MAX;
Michal Vasko004d3152020-06-11 19:59:22 +02002163 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "number", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002164 min_arg_count = 0;
2165 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002166 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002167 min_arg_count = 0;
2168 max_arg_count = 1;
2169 }
2170 break;
2171 case 7:
Michal Vasko004d3152020-06-11 19:59:22 +02002172 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "boolean", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002173 min_arg_count = 1;
2174 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002175 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "ceiling", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002176 min_arg_count = 1;
2177 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002178 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "current", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002179 min_arg_count = 0;
2180 max_arg_count = 0;
2181 }
2182 break;
2183 case 8:
Michal Vasko004d3152020-06-11 19:59:22 +02002184 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "contains", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002185 min_arg_count = 2;
2186 max_arg_count = 2;
Michal Vasko004d3152020-06-11 19:59:22 +02002187 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "position", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002188 min_arg_count = 0;
2189 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002190 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "re-match", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002191 min_arg_count = 2;
2192 max_arg_count = 2;
2193 }
2194 break;
2195 case 9:
Michal Vasko004d3152020-06-11 19:59:22 +02002196 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002197 min_arg_count = 2;
2198 max_arg_count = 3;
Michal Vasko004d3152020-06-11 19:59:22 +02002199 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "translate", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002200 min_arg_count = 3;
2201 max_arg_count = 3;
2202 }
2203 break;
2204 case 10:
Michal Vasko004d3152020-06-11 19:59:22 +02002205 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "local-name", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002206 min_arg_count = 0;
2207 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002208 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "enum-value", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002209 min_arg_count = 1;
2210 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002211 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "bit-is-set", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002212 min_arg_count = 2;
2213 max_arg_count = 2;
2214 }
2215 break;
2216 case 11:
Michal Vasko004d3152020-06-11 19:59:22 +02002217 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "starts-with", 11)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002218 min_arg_count = 2;
2219 max_arg_count = 2;
2220 }
2221 break;
2222 case 12:
Michal Vasko004d3152020-06-11 19:59:22 +02002223 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from", 12)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002224 min_arg_count = 2;
2225 max_arg_count = 2;
2226 }
2227 break;
2228 case 13:
Michal Vasko004d3152020-06-11 19:59:22 +02002229 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "namespace-uri", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002230 min_arg_count = 0;
2231 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002232 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string-length", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002233 min_arg_count = 0;
2234 max_arg_count = 1;
2235 }
2236 break;
2237 case 15:
Michal Vasko004d3152020-06-11 19:59:22 +02002238 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "normalize-space", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002239 min_arg_count = 0;
2240 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002241 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-after", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002242 min_arg_count = 2;
2243 max_arg_count = 2;
2244 }
2245 break;
2246 case 16:
Michal Vasko004d3152020-06-11 19:59:22 +02002247 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-before", 16)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002248 min_arg_count = 2;
2249 max_arg_count = 2;
2250 }
2251 break;
2252 case 20:
Michal Vasko004d3152020-06-11 19:59:22 +02002253 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from-or-self", 20)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002254 min_arg_count = 2;
2255 max_arg_count = 2;
2256 }
2257 break;
2258 }
2259 if (min_arg_count == -1) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002260 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 +02002261 return LY_EINVAL;
2262 }
Michal Vasko004d3152020-06-11 19:59:22 +02002263 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002264
2265 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02002266 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002267 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002268 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002269
2270 /* ( Expr ( ',' Expr )* )? */
2271 arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002272 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002273 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002274 if (exp->tokens[*tok_idx] != LYXP_TOKEN_PAR2) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002275 ++arg_count;
Michal Vasko004d3152020-06-11 19:59:22 +02002276 rc = reparse_or_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002277 LY_CHECK_RET(rc);
2278 }
Michal Vasko004d3152020-06-11 19:59:22 +02002279 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_COMMA)) {
2280 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002281
2282 ++arg_count;
Michal Vasko004d3152020-06-11 19:59:22 +02002283 rc = reparse_or_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002284 LY_CHECK_RET(rc);
2285 }
2286
2287 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02002288 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002289 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002290 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002291
Radek Krejci857189e2020-09-01 13:26:36 +02002292 if ((arg_count < (uint32_t)min_arg_count) || (arg_count > max_arg_count)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002293 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 +02002294 return LY_EVALID;
2295 }
2296
2297 return LY_SUCCESS;
2298}
2299
2300/**
2301 * @brief Reparse PathExpr. Logs directly on error.
2302 *
2303 * [10] PathExpr ::= LocationPath | PrimaryExpr Predicate*
2304 * | PrimaryExpr Predicate* '/' RelativeLocationPath
2305 * | PrimaryExpr Predicate* '//' RelativeLocationPath
2306 * [2] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
2307 * [8] PrimaryExpr ::= '(' Expr ')' | Literal | Number | FunctionCall
2308 *
2309 * @param[in] ctx Context for logging.
2310 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002311 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002312 * @return LY_ERR
2313 */
2314static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002315reparse_path_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002316{
2317 LY_ERR rc;
2318
Michal Vasko004d3152020-06-11 19:59:22 +02002319 if (lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko14676352020-05-29 11:35:55 +02002320 return LY_EVALID;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002321 }
2322
Michal Vasko004d3152020-06-11 19:59:22 +02002323 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002324 case LYXP_TOKEN_PAR1:
2325 /* '(' Expr ')' Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002326 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002327
Michal Vasko004d3152020-06-11 19:59:22 +02002328 rc = reparse_or_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002329 LY_CHECK_RET(rc);
2330
Michal Vasko004d3152020-06-11 19:59:22 +02002331 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002332 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002333 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002334 goto predicate;
2335 break;
2336 case LYXP_TOKEN_DOT:
2337 case LYXP_TOKEN_DDOT:
2338 case LYXP_TOKEN_AT:
2339 case LYXP_TOKEN_NAMETEST:
2340 case LYXP_TOKEN_NODETYPE:
2341 /* RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02002342 rc = reparse_relative_location_path(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002343 LY_CHECK_RET(rc);
2344 break;
2345 case LYXP_TOKEN_FUNCNAME:
2346 /* FunctionCall */
Michal Vasko004d3152020-06-11 19:59:22 +02002347 rc = reparse_function_call(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002348 LY_CHECK_RET(rc);
2349 goto predicate;
2350 break;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002351 case LYXP_TOKEN_OPER_PATH:
2352 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +02002353 /* AbsoluteLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02002354 rc = reparse_absolute_location_path(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002355 LY_CHECK_RET(rc);
2356 break;
2357 case LYXP_TOKEN_LITERAL:
2358 /* Literal */
Michal Vasko004d3152020-06-11 19:59:22 +02002359 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002360 goto predicate;
2361 break;
2362 case LYXP_TOKEN_NUMBER:
2363 /* Number */
Michal Vasko004d3152020-06-11 19:59:22 +02002364 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002365 goto predicate;
2366 break;
2367 default:
Radek Krejci2efc45b2020-12-22 16:25:44 +01002368 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 +02002369 return LY_EVALID;
2370 }
2371
2372 return LY_SUCCESS;
2373
2374predicate:
2375 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002376 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
2377 rc = reparse_predicate(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002378 LY_CHECK_RET(rc);
2379 }
2380
2381 /* ('/' or '//') RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02002382 if (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002383
2384 /* '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02002385 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002386
Michal Vasko004d3152020-06-11 19:59:22 +02002387 rc = reparse_relative_location_path(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002388 LY_CHECK_RET(rc);
2389 }
2390
2391 return LY_SUCCESS;
2392}
2393
2394/**
2395 * @brief Reparse UnaryExpr. Logs directly on error.
2396 *
2397 * [17] UnaryExpr ::= UnionExpr | '-' UnaryExpr
2398 * [18] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
2399 *
2400 * @param[in] ctx Context for logging.
2401 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002402 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002403 * @return LY_ERR
2404 */
2405static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002406reparse_unary_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002407{
2408 uint16_t prev_exp;
2409 LY_ERR rc;
2410
2411 /* ('-')* */
Michal Vasko004d3152020-06-11 19:59:22 +02002412 prev_exp = *tok_idx;
Michal Vasko69730152020-10-09 16:30:07 +02002413 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2414 (exp->expr[exp->tok_pos[*tok_idx]] == '-')) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002415 exp_repeat_push(exp, prev_exp, LYXP_EXPR_UNARY);
Michal Vasko004d3152020-06-11 19:59:22 +02002416 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002417 }
2418
2419 /* PathExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002420 prev_exp = *tok_idx;
2421 rc = reparse_path_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002422 LY_CHECK_RET(rc);
2423
2424 /* ('|' PathExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002425 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_UNI)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002426 exp_repeat_push(exp, prev_exp, LYXP_EXPR_UNION);
Michal Vasko004d3152020-06-11 19:59:22 +02002427 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002428
Michal Vasko004d3152020-06-11 19:59:22 +02002429 rc = reparse_path_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002430 LY_CHECK_RET(rc);
2431 }
2432
2433 return LY_SUCCESS;
2434}
2435
2436/**
2437 * @brief Reparse AdditiveExpr. Logs directly on error.
2438 *
2439 * [15] AdditiveExpr ::= MultiplicativeExpr
2440 * | AdditiveExpr '+' MultiplicativeExpr
2441 * | AdditiveExpr '-' MultiplicativeExpr
2442 * [16] MultiplicativeExpr ::= UnaryExpr
2443 * | MultiplicativeExpr '*' UnaryExpr
2444 * | MultiplicativeExpr 'div' UnaryExpr
2445 * | MultiplicativeExpr 'mod' UnaryExpr
2446 *
2447 * @param[in] ctx Context for logging.
2448 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002449 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002450 * @return LY_ERR
2451 */
2452static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002453reparse_additive_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002454{
2455 uint16_t prev_add_exp, prev_mul_exp;
2456 LY_ERR rc;
2457
Michal Vasko004d3152020-06-11 19:59:22 +02002458 prev_add_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002459 goto reparse_multiplicative_expr;
2460
2461 /* ('+' / '-' MultiplicativeExpr)* */
Michal Vasko69730152020-10-09 16:30:07 +02002462 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2463 ((exp->expr[exp->tok_pos[*tok_idx]] == '+') || (exp->expr[exp->tok_pos[*tok_idx]] == '-'))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002464 exp_repeat_push(exp, prev_add_exp, LYXP_EXPR_ADDITIVE);
Michal Vasko004d3152020-06-11 19:59:22 +02002465 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002466
2467reparse_multiplicative_expr:
2468 /* UnaryExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002469 prev_mul_exp = *tok_idx;
2470 rc = reparse_unary_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002471 LY_CHECK_RET(rc);
2472
2473 /* ('*' / 'div' / 'mod' UnaryExpr)* */
Michal Vasko69730152020-10-09 16:30:07 +02002474 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2475 ((exp->expr[exp->tok_pos[*tok_idx]] == '*') || (exp->tok_len[*tok_idx] == 3))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002476 exp_repeat_push(exp, prev_mul_exp, LYXP_EXPR_MULTIPLICATIVE);
Michal Vasko004d3152020-06-11 19:59:22 +02002477 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002478
Michal Vasko004d3152020-06-11 19:59:22 +02002479 rc = reparse_unary_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002480 LY_CHECK_RET(rc);
2481 }
2482 }
2483
2484 return LY_SUCCESS;
2485}
2486
2487/**
2488 * @brief Reparse EqualityExpr. Logs directly on error.
2489 *
2490 * [13] EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr
2491 * | EqualityExpr '!=' RelationalExpr
2492 * [14] RelationalExpr ::= AdditiveExpr
2493 * | RelationalExpr '<' AdditiveExpr
2494 * | RelationalExpr '>' AdditiveExpr
2495 * | RelationalExpr '<=' AdditiveExpr
2496 * | RelationalExpr '>=' AdditiveExpr
2497 *
2498 * @param[in] ctx Context for logging.
2499 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002500 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002501 * @return LY_ERR
2502 */
2503static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002504reparse_equality_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002505{
2506 uint16_t prev_eq_exp, prev_rel_exp;
2507 LY_ERR rc;
2508
Michal Vasko004d3152020-06-11 19:59:22 +02002509 prev_eq_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002510 goto reparse_additive_expr;
2511
2512 /* ('=' / '!=' RelationalExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002513 while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_EQUAL, LYXP_TOKEN_OPER_NEQUAL)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002514 exp_repeat_push(exp, prev_eq_exp, LYXP_EXPR_EQUALITY);
Michal Vasko004d3152020-06-11 19:59:22 +02002515 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002516
2517reparse_additive_expr:
2518 /* AdditiveExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002519 prev_rel_exp = *tok_idx;
2520 rc = reparse_additive_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002521 LY_CHECK_RET(rc);
2522
2523 /* ('<' / '>' / '<=' / '>=' AdditiveExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002524 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_COMP)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002525 exp_repeat_push(exp, prev_rel_exp, LYXP_EXPR_RELATIONAL);
Michal Vasko004d3152020-06-11 19:59:22 +02002526 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002527
Michal Vasko004d3152020-06-11 19:59:22 +02002528 rc = reparse_additive_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002529 LY_CHECK_RET(rc);
2530 }
2531 }
2532
2533 return LY_SUCCESS;
2534}
2535
2536/**
2537 * @brief Reparse OrExpr. Logs directly on error.
2538 *
2539 * [11] OrExpr ::= AndExpr | OrExpr 'or' AndExpr
2540 * [12] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
2541 *
2542 * @param[in] ctx Context for logging.
2543 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002544 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002545 * @return LY_ERR
2546 */
2547static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002548reparse_or_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002549{
2550 uint16_t prev_or_exp, prev_and_exp;
2551 LY_ERR rc;
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;
2564 rc = reparse_equality_expr(ctx, exp, tok_idx);
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
Michal Vasko004d3152020-06-11 19:59:22 +02002572 rc = reparse_equality_expr(ctx, exp, tok_idx);
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
Radek Krejcif03a9e22020-09-18 20:09:31 +02002809 } else if (expr_str[parsed] == '/') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002810
2811 /* Operator '/', '//' */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002812 if (!strncmp(&expr_str[parsed], "//", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002813 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002814 tok_type = LYXP_TOKEN_OPER_RPATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002815 } else {
2816 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002817 tok_type = LYXP_TOKEN_OPER_PATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002818 }
Radek Krejcib1646a92018-11-02 16:08:26 +01002819
Radek Krejcif03a9e22020-09-18 20:09:31 +02002820 } else if (!strncmp(&expr_str[parsed], "!=", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002821
Michal Vasko3e48bf32020-06-01 08:39:07 +02002822 /* Operator '!=' */
Radek Krejcib1646a92018-11-02 16:08:26 +01002823 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002824 tok_type = LYXP_TOKEN_OPER_NEQUAL;
2825
Radek Krejcif03a9e22020-09-18 20:09:31 +02002826 } else if (!strncmp(&expr_str[parsed], "<=", 2) || !strncmp(&expr_str[parsed], ">=", 2)) {
Michal Vasko3e48bf32020-06-01 08:39:07 +02002827
2828 /* Operator '<=', '>=' */
2829 tok_len = 2;
2830 tok_type = LYXP_TOKEN_OPER_COMP;
Radek Krejcib1646a92018-11-02 16:08:26 +01002831
Radek Krejcif03a9e22020-09-18 20:09:31 +02002832 } else if (expr_str[parsed] == '|') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002833
2834 /* Operator '|' */
2835 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002836 tok_type = LYXP_TOKEN_OPER_UNI;
Radek Krejcib1646a92018-11-02 16:08:26 +01002837
Radek Krejcif03a9e22020-09-18 20:09:31 +02002838 } else if ((expr_str[parsed] == '+') || (expr_str[parsed] == '-')) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002839
2840 /* Operator '+', '-' */
2841 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002842 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002843
Radek Krejcif03a9e22020-09-18 20:09:31 +02002844 } else if (expr_str[parsed] == '=') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002845
Michal Vasko3e48bf32020-06-01 08:39:07 +02002846 /* Operator '=' */
Radek Krejcib1646a92018-11-02 16:08:26 +01002847 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002848 tok_type = LYXP_TOKEN_OPER_EQUAL;
2849
Radek Krejcif03a9e22020-09-18 20:09:31 +02002850 } else if ((expr_str[parsed] == '<') || (expr_str[parsed] == '>')) {
Michal Vasko3e48bf32020-06-01 08:39:07 +02002851
2852 /* Operator '<', '>' */
2853 tok_len = 1;
2854 tok_type = LYXP_TOKEN_OPER_COMP;
Radek Krejcib1646a92018-11-02 16:08:26 +01002855
Michal Vasko69730152020-10-09 16:30:07 +02002856 } else if (expr->used && (expr->tokens[expr->used - 1] != LYXP_TOKEN_AT) &&
2857 (expr->tokens[expr->used - 1] != LYXP_TOKEN_PAR1) &&
2858 (expr->tokens[expr->used - 1] != LYXP_TOKEN_BRACK1) &&
2859 (expr->tokens[expr->used - 1] != LYXP_TOKEN_COMMA) &&
2860 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_LOG) &&
2861 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_EQUAL) &&
2862 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_NEQUAL) &&
2863 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_COMP) &&
2864 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_MATH) &&
2865 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_UNI) &&
2866 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_PATH) &&
2867 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_RPATH)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002868
2869 /* Operator '*', 'or', 'and', 'mod', or 'div' */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002870 if (expr_str[parsed] == '*') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002871 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002872 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002873
Radek Krejcif03a9e22020-09-18 20:09:31 +02002874 } else if (!strncmp(&expr_str[parsed], "or", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002875 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002876 tok_type = LYXP_TOKEN_OPER_LOG;
Radek Krejcib1646a92018-11-02 16:08:26 +01002877
Radek Krejcif03a9e22020-09-18 20:09:31 +02002878 } else if (!strncmp(&expr_str[parsed], "and", 3)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002879 tok_len = 3;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002880 tok_type = LYXP_TOKEN_OPER_LOG;
Radek Krejcib1646a92018-11-02 16:08:26 +01002881
Radek Krejcif03a9e22020-09-18 20:09:31 +02002882 } else if (!strncmp(&expr_str[parsed], "mod", 3) || !strncmp(&expr_str[parsed], "div", 3)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002883 tok_len = 3;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002884 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002885
2886 } else if (prev_function_check) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002887 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 +02002888 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 +02002889 ret = LY_EVALID;
Radek Krejcib1646a92018-11-02 16:08:26 +01002890 goto error;
2891 } else {
Michal Vasko774ce402021-04-14 15:35:06 +02002892 LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed], parsed + 1, expr_str);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002893 ret = LY_EVALID;
Radek Krejcib1646a92018-11-02 16:08:26 +01002894 goto error;
2895 }
Radek Krejcif03a9e22020-09-18 20:09:31 +02002896 } else if (expr_str[parsed] == '*') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002897
2898 /* NameTest '*' */
2899 tok_len = 1;
2900 tok_type = LYXP_TOKEN_NAMETEST;
2901
2902 } else {
2903
2904 /* NameTest (NCName ':' '*' | QName) or NodeType/FunctionName */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002905 long int ncname_len = parse_ncname(&expr_str[parsed]);
Michal Vasko774ce402021-04-14 15:35:06 +02002906 LY_CHECK_ERR_GOTO(ncname_len < 0, LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed - ncname_len],
2907 parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002908 tok_len = ncname_len;
2909
Radek Krejcif03a9e22020-09-18 20:09:31 +02002910 if (expr_str[parsed + tok_len] == ':') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002911 ++tok_len;
Radek Krejcif03a9e22020-09-18 20:09:31 +02002912 if (expr_str[parsed + tok_len] == '*') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002913 ++tok_len;
2914 } else {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002915 ncname_len = parse_ncname(&expr_str[parsed + tok_len]);
Michal Vasko774ce402021-04-14 15:35:06 +02002916 LY_CHECK_ERR_GOTO(ncname_len < 0, LOGVAL(ctx, LY_VCODE_XP_INEXPR, expr_str[parsed - ncname_len],
2917 parsed - ncname_len + 1, expr_str); ret = LY_EVALID, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002918 tok_len += ncname_len;
2919 }
2920 /* remove old flag to prevent ambiguities */
2921 prev_function_check = 0;
2922 tok_type = LYXP_TOKEN_NAMETEST;
2923 } else {
2924 /* there is no prefix so it can still be NodeType/FunctionName, we can't finally decide now */
2925 prev_function_check = 1;
2926 tok_type = LYXP_TOKEN_NAMETEST;
2927 }
2928 }
2929
2930 /* store the token, move on to the next one */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002931 LY_CHECK_GOTO(ret = exp_add_token(ctx, expr, tok_type, parsed, tok_len), error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002932 parsed += tok_len;
Radek Krejcif03a9e22020-09-18 20:09:31 +02002933 while (is_xmlws(expr_str[parsed])) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002934 ++parsed;
2935 }
2936
Radek Krejcif03a9e22020-09-18 20:09:31 +02002937 } while (expr_str[parsed]);
Radek Krejcib1646a92018-11-02 16:08:26 +01002938
Michal Vasko004d3152020-06-11 19:59:22 +02002939 if (reparse) {
2940 /* prealloc repeat */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002941 expr->repeat = calloc(expr->size, sizeof *expr->repeat);
2942 LY_CHECK_ERR_GOTO(!expr->repeat, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002943
Michal Vasko004d3152020-06-11 19:59:22 +02002944 /* fill repeat */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002945 LY_CHECK_ERR_GOTO(reparse_or_expr(ctx, expr, &tok_idx), ret = LY_EVALID, error);
2946 if (expr->used > tok_idx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01002947 LOGVAL(ctx, LYVE_XPATH, "Unparsed characters \"%s\" left at the end of an XPath expression.",
Michal Vasko69730152020-10-09 16:30:07 +02002948 &expr->expr[expr->tok_pos[tok_idx]]);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002949 ret = LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +02002950 goto error;
2951 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02002952 }
2953
Radek Krejcif03a9e22020-09-18 20:09:31 +02002954 print_expr_struct_debug(expr);
2955 *expr_p = expr;
2956 return LY_SUCCESS;
Radek Krejcib1646a92018-11-02 16:08:26 +01002957
2958error:
Radek Krejcif03a9e22020-09-18 20:09:31 +02002959 lyxp_expr_free(ctx, expr);
2960 return ret;
Radek Krejcib1646a92018-11-02 16:08:26 +01002961}
2962
Michal Vasko1734be92020-09-22 08:55:10 +02002963LY_ERR
2964lyxp_expr_dup(const struct ly_ctx *ctx, const struct lyxp_expr *exp, struct lyxp_expr **dup_p)
Michal Vasko004d3152020-06-11 19:59:22 +02002965{
Michal Vasko1734be92020-09-22 08:55:10 +02002966 LY_ERR ret = LY_SUCCESS;
2967 struct lyxp_expr *dup = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02002968 uint32_t i, j;
2969
Michal Vasko7f45cf22020-10-01 12:49:44 +02002970 if (!exp) {
2971 goto cleanup;
2972 }
2973
Michal Vasko004d3152020-06-11 19:59:22 +02002974 dup = calloc(1, sizeof *dup);
Michal Vasko1734be92020-09-22 08:55:10 +02002975 LY_CHECK_ERR_GOTO(!dup, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02002976
2977 dup->tokens = malloc(exp->used * sizeof *dup->tokens);
Michal Vasko1734be92020-09-22 08:55:10 +02002978 LY_CHECK_ERR_GOTO(!dup->tokens, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02002979 memcpy(dup->tokens, exp->tokens, exp->used * sizeof *dup->tokens);
2980
2981 dup->tok_pos = malloc(exp->used * sizeof *dup->tok_pos);
Michal Vasko1734be92020-09-22 08:55:10 +02002982 LY_CHECK_ERR_GOTO(!dup->tok_pos, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02002983 memcpy(dup->tok_pos, exp->tok_pos, exp->used * sizeof *dup->tok_pos);
2984
2985 dup->tok_len = malloc(exp->used * sizeof *dup->tok_len);
Michal Vasko1734be92020-09-22 08:55:10 +02002986 LY_CHECK_ERR_GOTO(!dup->tok_len, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02002987 memcpy(dup->tok_len, exp->tok_len, exp->used * sizeof *dup->tok_len);
2988
2989 dup->repeat = malloc(exp->used * sizeof *dup->repeat);
Michal Vasko1734be92020-09-22 08:55:10 +02002990 LY_CHECK_ERR_GOTO(!dup->repeat, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02002991 for (i = 0; i < exp->used; ++i) {
2992 if (!exp->repeat[i]) {
2993 dup->repeat[i] = NULL;
2994 } else {
Radek Krejci1e008d22020-08-17 11:37:37 +02002995 for (j = 0; exp->repeat[i][j]; ++j) {}
Michal Vasko004d3152020-06-11 19:59:22 +02002996 /* the ending 0 as well */
2997 ++j;
2998
Michal Vasko99c71642020-07-03 13:33:36 +02002999 dup->repeat[i] = malloc(j * sizeof **dup->repeat);
Michal Vasko1734be92020-09-22 08:55:10 +02003000 LY_CHECK_ERR_GOTO(!dup->repeat[i], LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02003001 memcpy(dup->repeat[i], exp->repeat[i], j * sizeof **dup->repeat);
3002 dup->repeat[i][j - 1] = 0;
3003 }
3004 }
3005
3006 dup->used = exp->used;
3007 dup->size = exp->used;
Michal Vasko1734be92020-09-22 08:55:10 +02003008 LY_CHECK_GOTO(ret = lydict_insert(ctx, exp->expr, 0, &dup->expr), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02003009
Michal Vasko1734be92020-09-22 08:55:10 +02003010cleanup:
3011 if (ret) {
3012 lyxp_expr_free(ctx, dup);
3013 } else {
3014 *dup_p = dup;
3015 }
3016 return ret;
Michal Vasko004d3152020-06-11 19:59:22 +02003017}
3018
Michal Vasko03ff5a72019-09-11 13:49:33 +02003019/*
3020 * warn functions
3021 *
3022 * Warn functions check specific reasonable conditions for schema XPath
3023 * and print a warning if they are not satisfied.
3024 */
3025
3026/**
3027 * @brief Get the last-added schema node that is currently in the context.
3028 *
3029 * @param[in] set Set to search in.
3030 * @return Last-added schema context node, NULL if no node is in context.
3031 */
3032static struct lysc_node *
3033warn_get_scnode_in_ctx(struct lyxp_set *set)
3034{
3035 uint32_t i;
3036
3037 if (!set || (set->type != LYXP_SET_SCNODE_SET)) {
3038 return NULL;
3039 }
3040
3041 i = set->used;
3042 do {
3043 --i;
Radek Krejcif13b87b2020-12-01 22:02:17 +01003044 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003045 /* if there are more, simply return the first found (last added) */
3046 return set->val.scnodes[i].scnode;
3047 }
3048 } while (i);
3049
3050 return NULL;
3051}
3052
3053/**
3054 * @brief Test whether a type is numeric - integer type or decimal64.
3055 *
3056 * @param[in] type Type to test.
Radek Krejci857189e2020-09-01 13:26:36 +02003057 * @return Boolean value whether @p type is numeric type or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003058 */
Radek Krejci857189e2020-09-01 13:26:36 +02003059static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003060warn_is_numeric_type(struct lysc_type *type)
3061{
3062 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003063 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003064 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003065
3066 switch (type->basetype) {
3067 case LY_TYPE_DEC64:
3068 case LY_TYPE_INT8:
3069 case LY_TYPE_UINT8:
3070 case LY_TYPE_INT16:
3071 case LY_TYPE_UINT16:
3072 case LY_TYPE_INT32:
3073 case LY_TYPE_UINT32:
3074 case LY_TYPE_INT64:
3075 case LY_TYPE_UINT64:
3076 return 1;
3077 case LY_TYPE_UNION:
3078 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003079 LY_ARRAY_FOR(uni->types, u) {
3080 ret = warn_is_numeric_type(uni->types[u]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003081 if (ret) {
3082 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003083 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003084 }
3085 }
3086 /* did not find any suitable type */
3087 return 0;
3088 case LY_TYPE_LEAFREF:
3089 return warn_is_numeric_type(((struct lysc_type_leafref *)type)->realtype);
3090 default:
3091 return 0;
3092 }
3093}
3094
3095/**
3096 * @brief Test whether a type is string-like - no integers, decimal64 or binary.
3097 *
3098 * @param[in] type Type to test.
Radek Krejci857189e2020-09-01 13:26:36 +02003099 * @return Boolean value whether @p type's basetype is string type or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003100 */
Radek Krejci857189e2020-09-01 13:26:36 +02003101static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003102warn_is_string_type(struct lysc_type *type)
3103{
3104 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003105 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003106 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003107
3108 switch (type->basetype) {
3109 case LY_TYPE_BITS:
3110 case LY_TYPE_ENUM:
3111 case LY_TYPE_IDENT:
3112 case LY_TYPE_INST:
3113 case LY_TYPE_STRING:
3114 return 1;
3115 case LY_TYPE_UNION:
3116 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003117 LY_ARRAY_FOR(uni->types, u) {
3118 ret = warn_is_string_type(uni->types[u]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003119 if (ret) {
3120 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003121 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003122 }
3123 }
3124 /* did not find any suitable type */
3125 return 0;
3126 case LY_TYPE_LEAFREF:
3127 return warn_is_string_type(((struct lysc_type_leafref *)type)->realtype);
3128 default:
3129 return 0;
3130 }
3131}
3132
3133/**
3134 * @brief Test whether a type is one specific type.
3135 *
3136 * @param[in] type Type to test.
3137 * @param[in] base Expected type.
Radek Krejci857189e2020-09-01 13:26:36 +02003138 * @return Boolean value whether the given @p type is of the specific basetype @p base.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003139 */
Radek Krejci857189e2020-09-01 13:26:36 +02003140static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003141warn_is_specific_type(struct lysc_type *type, LY_DATA_TYPE base)
3142{
3143 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003144 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003145 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003146
3147 if (type->basetype == base) {
3148 return 1;
3149 } else if (type->basetype == LY_TYPE_UNION) {
3150 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003151 LY_ARRAY_FOR(uni->types, u) {
3152 ret = warn_is_specific_type(uni->types[u], base);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003153 if (ret) {
3154 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003155 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003156 }
3157 }
3158 /* did not find any suitable type */
3159 return 0;
3160 } else if (type->basetype == LY_TYPE_LEAFREF) {
3161 return warn_is_specific_type(((struct lysc_type_leafref *)type)->realtype, base);
3162 }
3163
3164 return 0;
3165}
3166
3167/**
3168 * @brief Get next type of a (union) type.
3169 *
3170 * @param[in] type Base type.
3171 * @param[in] prev_type Previously returned type.
3172 * @return Next type or NULL.
3173 */
3174static struct lysc_type *
3175warn_is_equal_type_next_type(struct lysc_type *type, struct lysc_type *prev_type)
3176{
3177 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003178 ly_bool found = 0;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003179 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003180
3181 switch (type->basetype) {
3182 case LY_TYPE_UNION:
3183 uni = (struct lysc_type_union *)type;
3184 if (!prev_type) {
3185 return uni->types[0];
3186 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003187 LY_ARRAY_FOR(uni->types, u) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003188 if (found) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003189 return uni->types[u];
Michal Vasko03ff5a72019-09-11 13:49:33 +02003190 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003191 if (prev_type == uni->types[u]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003192 found = 1;
3193 }
3194 }
3195 return NULL;
3196 default:
3197 if (prev_type) {
3198 assert(type == prev_type);
3199 return NULL;
3200 } else {
3201 return type;
3202 }
3203 }
3204}
3205
3206/**
3207 * @brief Test whether 2 types have a common type.
3208 *
3209 * @param[in] type1 First type.
3210 * @param[in] type2 Second type.
3211 * @return 1 if they do, 0 otherwise.
3212 */
3213static int
3214warn_is_equal_type(struct lysc_type *type1, struct lysc_type *type2)
3215{
3216 struct lysc_type *t1, *rt1, *t2, *rt2;
3217
3218 t1 = NULL;
3219 while ((t1 = warn_is_equal_type_next_type(type1, t1))) {
3220 if (t1->basetype == LY_TYPE_LEAFREF) {
3221 rt1 = ((struct lysc_type_leafref *)t1)->realtype;
3222 } else {
3223 rt1 = t1;
3224 }
3225
3226 t2 = NULL;
3227 while ((t2 = warn_is_equal_type_next_type(type2, t2))) {
3228 if (t2->basetype == LY_TYPE_LEAFREF) {
3229 rt2 = ((struct lysc_type_leafref *)t2)->realtype;
3230 } else {
3231 rt2 = t2;
3232 }
3233
3234 if (rt2->basetype == rt1->basetype) {
3235 /* match found */
3236 return 1;
3237 }
3238 }
3239 }
3240
3241 return 0;
3242}
3243
3244/**
3245 * @brief Check both operands of comparison operators.
3246 *
3247 * @param[in] ctx Context for errors.
3248 * @param[in] set1 First operand set.
3249 * @param[in] set2 Second operand set.
3250 * @param[in] numbers_only Whether accept only numbers or other types are fine too (for '=' and '!=').
3251 * @param[in] expr Start of the expression to print with the warning.
3252 * @param[in] tok_pos Token position.
3253 */
3254static void
Radek Krejci857189e2020-09-01 13:26:36 +02003255warn_operands(struct ly_ctx *ctx, struct lyxp_set *set1, struct lyxp_set *set2, ly_bool numbers_only, const char *expr, uint16_t tok_pos)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003256{
3257 struct lysc_node_leaf *node1, *node2;
Radek Krejci857189e2020-09-01 13:26:36 +02003258 ly_bool leaves = 1, warning = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003259
3260 node1 = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set1);
3261 node2 = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set2);
3262
3263 if (!node1 && !node2) {
3264 /* no node-sets involved, nothing to do */
3265 return;
3266 }
3267
3268 if (node1) {
3269 if (!(node1->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3270 LOGWRN(ctx, "Node type %s \"%s\" used as operand.", lys_nodetype2str(node1->nodetype), node1->name);
3271 warning = 1;
3272 leaves = 0;
3273 } else if (numbers_only && !warn_is_numeric_type(node1->type)) {
3274 LOGWRN(ctx, "Node \"%s\" is not of a numeric type, but used where it was expected.", node1->name);
3275 warning = 1;
3276 }
3277 }
3278
3279 if (node2) {
3280 if (!(node2->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3281 LOGWRN(ctx, "Node type %s \"%s\" used as operand.", lys_nodetype2str(node2->nodetype), node2->name);
3282 warning = 1;
3283 leaves = 0;
3284 } else if (numbers_only && !warn_is_numeric_type(node2->type)) {
3285 LOGWRN(ctx, "Node \"%s\" is not of a numeric type, but used where it was expected.", node2->name);
3286 warning = 1;
3287 }
3288 }
3289
3290 if (node1 && node2 && leaves && !numbers_only) {
Michal Vasko69730152020-10-09 16:30:07 +02003291 if ((warn_is_numeric_type(node1->type) && !warn_is_numeric_type(node2->type)) ||
3292 (!warn_is_numeric_type(node1->type) && warn_is_numeric_type(node2->type)) ||
3293 (!warn_is_numeric_type(node1->type) && !warn_is_numeric_type(node2->type) &&
3294 !warn_is_equal_type(node1->type, node2->type))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003295 LOGWRN(ctx, "Incompatible types of operands \"%s\" and \"%s\" for comparison.", node1->name, node2->name);
3296 warning = 1;
3297 }
3298 }
3299
3300 if (warning) {
3301 LOGWRN(ctx, "Previous warning generated by XPath subexpression[%u] \"%.20s\".", tok_pos, expr + tok_pos);
3302 }
3303}
3304
3305/**
3306 * @brief Check that a value is valid for a leaf. If not applicable, does nothing.
3307 *
3308 * @param[in] exp Parsed XPath expression.
3309 * @param[in] set Set with the leaf/leaf-list.
3310 * @param[in] val_exp Index of the value (literal/number) in @p exp.
3311 * @param[in] equal_exp Index of the start of the equality expression in @p exp.
3312 * @param[in] last_equal_exp Index of the end of the equality expression in @p exp.
3313 */
3314static void
Michal Vasko40308e72020-10-20 16:38:40 +02003315warn_equality_value(const struct lyxp_expr *exp, struct lyxp_set *set, uint16_t val_exp, uint16_t equal_exp,
3316 uint16_t last_equal_exp)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003317{
3318 struct lysc_node *scnode;
3319 struct lysc_type *type;
3320 char *value;
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003321 struct lyd_value storage;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003322 LY_ERR rc;
3323 struct ly_err_item *err = NULL;
3324
Michal Vasko69730152020-10-09 16:30:07 +02003325 if ((scnode = warn_get_scnode_in_ctx(set)) && (scnode->nodetype & (LYS_LEAF | LYS_LEAFLIST)) &&
3326 ((exp->tokens[val_exp] == LYXP_TOKEN_LITERAL) || (exp->tokens[val_exp] == LYXP_TOKEN_NUMBER))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003327 /* check that the node can have the specified value */
3328 if (exp->tokens[val_exp] == LYXP_TOKEN_LITERAL) {
3329 value = strndup(exp->expr + exp->tok_pos[val_exp] + 1, exp->tok_len[val_exp] - 2);
3330 } else {
3331 value = strndup(exp->expr + exp->tok_pos[val_exp], exp->tok_len[val_exp]);
3332 }
3333 if (!value) {
3334 LOGMEM(set->ctx);
3335 return;
3336 }
3337
3338 if ((((struct lysc_node_leaf *)scnode)->type->basetype == LY_TYPE_IDENT) && !strchr(value, ':')) {
3339 LOGWRN(set->ctx, "Identityref \"%s\" comparison with identity \"%s\" without prefix, consider adding"
Michal Vasko69730152020-10-09 16:30:07 +02003340 " a prefix or best using \"derived-from(-or-self)()\" functions.", scnode->name, value);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003341 LOGWRN(set->ctx, "Previous warning generated by XPath subexpression[%u] \"%.*s\".", exp->tok_pos[equal_exp],
Radek Krejci0f969882020-08-21 16:56:47 +02003342 (exp->tok_pos[last_equal_exp] - exp->tok_pos[equal_exp]) + exp->tok_len[last_equal_exp],
Michal Vasko69730152020-10-09 16:30:07 +02003343 exp->expr + exp->tok_pos[equal_exp]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003344 }
3345
3346 type = ((struct lysc_node_leaf *)scnode)->type;
3347 if (type->basetype != LY_TYPE_IDENT) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003348 rc = type->plugin->store(set->ctx, type, value, strlen(value), 0, set->format, set->prefix_data,
Michal Vasko405cc9e2020-12-01 12:01:27 +01003349 LYD_HINT_DATA, scnode, &storage, NULL, &err);
Michal Vaskobf42e832020-11-23 16:59:42 +01003350 if (rc == LY_EINCOMPLETE) {
3351 rc = LY_SUCCESS;
3352 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003353
3354 if (err) {
3355 LOGWRN(set->ctx, "Invalid value \"%s\" which does not fit the type (%s).", value, err->msg);
3356 ly_err_free(err);
3357 } else if (rc != LY_SUCCESS) {
3358 LOGWRN(set->ctx, "Invalid value \"%s\" which does not fit the type.", value);
3359 }
3360 if (rc != LY_SUCCESS) {
3361 LOGWRN(set->ctx, "Previous warning generated by XPath subexpression[%u] \"%.*s\".", exp->tok_pos[equal_exp],
Radek Krejci0f969882020-08-21 16:56:47 +02003362 (exp->tok_pos[last_equal_exp] - exp->tok_pos[equal_exp]) + exp->tok_len[last_equal_exp],
Michal Vasko69730152020-10-09 16:30:07 +02003363 exp->expr + exp->tok_pos[equal_exp]);
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003364 } else {
3365 type->plugin->free(set->ctx, &storage);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003366 }
3367 }
3368 free(value);
3369 }
3370}
3371
3372/*
3373 * XPath functions
3374 */
3375
3376/**
3377 * @brief Execute the YANG 1.1 bit-is-set(node-set, string) function. Returns LYXP_SET_BOOLEAN
3378 * depending on whether the first node bit value from the second argument is set.
3379 *
3380 * @param[in] args Array of arguments.
3381 * @param[in] arg_count Count of elements in @p args.
3382 * @param[in,out] set Context and result set at the same time.
3383 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003384 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003385 */
3386static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003387xpath_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 +02003388{
3389 struct lyd_node_term *leaf;
3390 struct lysc_node_leaf *sleaf;
3391 struct lysc_type_bits *bits;
3392 LY_ERR rc = LY_SUCCESS;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003393 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003394
3395 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003396 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003397 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko5676f4e2021-04-06 17:14:45 +02003398 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3399 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3400 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3401 sleaf->name);
3402 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_BITS)) {
3403 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"bits\".", __func__, sleaf->name);
3404 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003405 }
3406
3407 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
3408 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003409 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3410 sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003411 } else if (!warn_is_string_type(sleaf->type)) {
3412 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003413 }
3414 }
3415 set_scnode_clear_ctx(set);
3416 return rc;
3417 }
3418
Michal Vaskod3678892020-05-21 10:06:58 +02003419 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003420 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 +02003421 return LY_EVALID;
3422 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003423 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003424 LY_CHECK_RET(rc);
3425
3426 set_fill_boolean(set, 0);
Michal Vaskod3678892020-05-21 10:06:58 +02003427 if (args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003428 leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
Michal Vasko69730152020-10-09 16:30:07 +02003429 if ((leaf->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST)) &&
3430 (((struct lysc_node_leaf *)leaf->schema)->type->basetype == LY_TYPE_BITS)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003431 bits = (struct lysc_type_bits *)((struct lysc_node_leaf *)leaf->schema)->type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003432 LY_ARRAY_FOR(bits->bits, u) {
3433 if (!strcmp(bits->bits[u].name, args[1]->val.str)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003434 set_fill_boolean(set, 1);
3435 break;
3436 }
3437 }
3438 }
3439 }
3440
3441 return LY_SUCCESS;
3442}
3443
3444/**
3445 * @brief Execute the XPath boolean(object) function. Returns LYXP_SET_BOOLEAN
3446 * with the argument converted to boolean.
3447 *
3448 * @param[in] args Array of arguments.
3449 * @param[in] arg_count Count of elements in @p args.
3450 * @param[in,out] set Context and result set at the same time.
3451 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003452 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003453 */
3454static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003455xpath_boolean(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003456{
3457 LY_ERR rc;
3458
3459 if (options & LYXP_SCNODE_ALL) {
3460 set_scnode_clear_ctx(set);
3461 return LY_SUCCESS;
3462 }
3463
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003464 rc = lyxp_set_cast(args[0], LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003465 LY_CHECK_RET(rc);
3466 set_fill_set(set, args[0]);
3467
3468 return LY_SUCCESS;
3469}
3470
3471/**
3472 * @brief Execute the XPath ceiling(number) function. Returns LYXP_SET_NUMBER
3473 * with the first argument rounded up to the nearest integer.
3474 *
3475 * @param[in] args Array of arguments.
3476 * @param[in] arg_count Count of elements in @p args.
3477 * @param[in,out] set Context and result set at the same time.
3478 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003479 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003480 */
3481static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003482xpath_ceiling(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003483{
3484 struct lysc_node_leaf *sleaf;
3485 LY_ERR rc = LY_SUCCESS;
3486
3487 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003488 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003489 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko5676f4e2021-04-06 17:14:45 +02003490 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3491 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3492 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3493 sleaf->name);
3494 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_DEC64)) {
3495 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"decimal64\".", __func__, sleaf->name);
3496 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003497 }
3498 set_scnode_clear_ctx(set);
3499 return rc;
3500 }
3501
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003502 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003503 LY_CHECK_RET(rc);
3504 if ((long long)args[0]->val.num != args[0]->val.num) {
3505 set_fill_number(set, ((long long)args[0]->val.num) + 1);
3506 } else {
3507 set_fill_number(set, args[0]->val.num);
3508 }
3509
3510 return LY_SUCCESS;
3511}
3512
3513/**
3514 * @brief Execute the XPath concat(string, string, string*) function.
3515 * Returns LYXP_SET_STRING with the concatenation of all the arguments.
3516 *
3517 * @param[in] args Array of arguments.
3518 * @param[in] arg_count Count of elements in @p args.
3519 * @param[in,out] set Context and result set at the same time.
3520 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003521 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003522 */
3523static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003524xpath_concat(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003525{
3526 uint16_t i;
3527 char *str = NULL;
3528 size_t used = 1;
3529 LY_ERR rc = LY_SUCCESS;
3530 struct lysc_node_leaf *sleaf;
3531
3532 if (options & LYXP_SCNODE_ALL) {
3533 for (i = 0; i < arg_count; ++i) {
3534 if ((args[i]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[i]))) {
3535 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3536 LOGWRN(set->ctx, "Argument #%u of %s is a %s node \"%s\".",
Michal Vasko69730152020-10-09 16:30:07 +02003537 i + 1, __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003538 } else if (!warn_is_string_type(sleaf->type)) {
Radek Krejci70124c82020-08-14 22:17:03 +02003539 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 +02003540 }
3541 }
3542 }
3543 set_scnode_clear_ctx(set);
3544 return rc;
3545 }
3546
3547 for (i = 0; i < arg_count; ++i) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003548 rc = lyxp_set_cast(args[i], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003549 if (rc != LY_SUCCESS) {
3550 free(str);
3551 return rc;
3552 }
3553
3554 str = ly_realloc(str, (used + strlen(args[i]->val.str)) * sizeof(char));
3555 LY_CHECK_ERR_RET(!str, LOGMEM(set->ctx), LY_EMEM);
3556 strcpy(str + used - 1, args[i]->val.str);
3557 used += strlen(args[i]->val.str);
3558 }
3559
3560 /* free, kind of */
Michal Vaskod3678892020-05-21 10:06:58 +02003561 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003562 set->type = LYXP_SET_STRING;
3563 set->val.str = str;
3564
3565 return LY_SUCCESS;
3566}
3567
3568/**
3569 * @brief Execute the XPath contains(string, string) function.
3570 * Returns LYXP_SET_BOOLEAN whether the second argument can
3571 * be found in the first or not.
3572 *
3573 * @param[in] args Array of arguments.
3574 * @param[in] arg_count Count of elements in @p args.
3575 * @param[in,out] set Context and result set at the same time.
3576 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003577 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003578 */
3579static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003580xpath_contains(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003581{
3582 struct lysc_node_leaf *sleaf;
3583 LY_ERR rc = LY_SUCCESS;
3584
3585 if (options & LYXP_SCNODE_ALL) {
3586 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3587 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003588 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3589 sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003590 } else if (!warn_is_string_type(sleaf->type)) {
3591 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003592 }
3593 }
3594
3595 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
3596 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003597 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3598 sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003599 } else if (!warn_is_string_type(sleaf->type)) {
3600 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003601 }
3602 }
3603 set_scnode_clear_ctx(set);
3604 return rc;
3605 }
3606
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003607 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003608 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003609 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003610 LY_CHECK_RET(rc);
3611
3612 if (strstr(args[0]->val.str, args[1]->val.str)) {
3613 set_fill_boolean(set, 1);
3614 } else {
3615 set_fill_boolean(set, 0);
3616 }
3617
3618 return LY_SUCCESS;
3619}
3620
3621/**
3622 * @brief Execute the XPath count(node-set) function. Returns LYXP_SET_NUMBER
3623 * with the size of the node-set from the argument.
3624 *
3625 * @param[in] args Array of arguments.
3626 * @param[in] arg_count Count of elements in @p args.
3627 * @param[in,out] set Context and result set at the same time.
3628 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003629 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003630 */
3631static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003632xpath_count(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003633{
Michal Vasko03ff5a72019-09-11 13:49:33 +02003634 LY_ERR rc = LY_SUCCESS;
3635
3636 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003637 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003638 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003639 }
3640 set_scnode_clear_ctx(set);
3641 return rc;
3642 }
3643
Michal Vasko03ff5a72019-09-11 13:49:33 +02003644 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003645 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "count(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02003646 return LY_EVALID;
3647 }
3648
3649 set_fill_number(set, args[0]->used);
3650 return LY_SUCCESS;
3651}
3652
3653/**
3654 * @brief Execute the XPath current() function. Returns LYXP_SET_NODE_SET
3655 * with the context with the intial node.
3656 *
3657 * @param[in] args Array of arguments.
3658 * @param[in] arg_count Count of elements in @p args.
3659 * @param[in,out] set Context and result set at the same time.
3660 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003661 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003662 */
3663static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003664xpath_current(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003665{
3666 if (arg_count || args) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003667 LOGVAL(set->ctx, LY_VCODE_XP_INARGCOUNT, arg_count, "current()");
Michal Vasko03ff5a72019-09-11 13:49:33 +02003668 return LY_EVALID;
3669 }
3670
3671 if (options & LYXP_SCNODE_ALL) {
3672 set_scnode_clear_ctx(set);
3673
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003674 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, set->cur_scnode, LYXP_NODE_ELEM, NULL));
Michal Vasko03ff5a72019-09-11 13:49:33 +02003675 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02003676 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003677
3678 /* position is filled later */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003679 set_insert_node(set, set->cur_node, 0, LYXP_NODE_ELEM, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003680 }
3681
3682 return LY_SUCCESS;
3683}
3684
3685/**
3686 * @brief Execute the YANG 1.1 deref(node-set) function. Returns LYXP_SET_NODE_SET with either
3687 * leafref or instance-identifier target node(s).
3688 *
3689 * @param[in] args Array of arguments.
3690 * @param[in] arg_count Count of elements in @p args.
3691 * @param[in,out] set Context and result set at the same time.
3692 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003693 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003694 */
3695static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003696xpath_deref(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003697{
3698 struct lyd_node_term *leaf;
Michal Vasko42e497c2020-01-06 08:38:25 +01003699 struct lysc_node_leaf *sleaf = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02003700 struct lysc_type_leafref *lref;
Michal Vaskoae9e4cb2019-09-25 08:43:05 +02003701 const struct lysc_node *target;
Michal Vasko004d3152020-06-11 19:59:22 +02003702 struct ly_path *p;
3703 struct lyd_node *node;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003704 char *errmsg = NULL;
Michal Vasko00cbf532020-06-15 13:58:47 +02003705 uint8_t oper;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003706 LY_ERR rc = LY_SUCCESS;
3707
3708 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003709 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003710 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko5676f4e2021-04-06 17:14:45 +02003711 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3712 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3713 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3714 sleaf->name);
3715 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_LEAFREF) && !warn_is_specific_type(sleaf->type, LY_TYPE_INST)) {
3716 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"leafref\" nor \"instance-identifier\".",
3717 __func__, sleaf->name);
3718 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003719 }
3720 set_scnode_clear_ctx(set);
Michal Vasko42e497c2020-01-06 08:38:25 +01003721 if (sleaf && (sleaf->type->basetype == LY_TYPE_LEAFREF)) {
Michal Vasko004d3152020-06-11 19:59:22 +02003722 lref = (struct lysc_type_leafref *)sleaf->type;
Michal Vaskod1e53b92021-01-28 13:11:06 +01003723 oper = (sleaf->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Michal Vasko004d3152020-06-11 19:59:22 +02003724
3725 /* it was already evaluated on schema, it must succeed */
Radek Krejcid5d37432021-03-12 13:46:40 +01003726 rc = ly_path_compile(set->ctx, lref->cur_mod, &sleaf->node, NULL, lref->path, LY_PATH_LREF_TRUE, oper,
Michal Vasko14ed9cd2021-01-28 14:16:25 +01003727 LY_PATH_TARGET_MANY, LY_PREF_SCHEMA_RESOLVED, lref->prefixes, NULL, &p);
Michal Vasko004d3152020-06-11 19:59:22 +02003728 assert(!rc);
3729
3730 /* get the target node */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003731 target = p[LY_ARRAY_COUNT(p) - 1].node;
Michal Vasko004d3152020-06-11 19:59:22 +02003732 ly_path_free(set->ctx, p);
3733
Radek Krejciaa6b53f2020-08-27 15:19:03 +02003734 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, target, LYXP_NODE_ELEM, NULL));
Michal Vaskoae9e4cb2019-09-25 08:43:05 +02003735 }
3736
Michal Vasko03ff5a72019-09-11 13:49:33 +02003737 return rc;
3738 }
3739
Michal Vaskod3678892020-05-21 10:06:58 +02003740 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003741 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "deref(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02003742 return LY_EVALID;
3743 }
3744
Michal Vaskod3678892020-05-21 10:06:58 +02003745 lyxp_set_free_content(set);
3746 if (args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003747 leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
3748 sleaf = (struct lysc_node_leaf *)leaf->schema;
3749 if (sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
3750 if (sleaf->type->basetype == LY_TYPE_LEAFREF) {
3751 /* find leafref target */
Radek Krejci0b013302021-03-29 15:22:32 +02003752 if (lyplg_type_resolve_leafref((struct lysc_type_leafref *)sleaf->type, &leaf->node, &leaf->value, set->tree,
Michal Vasko9e685082021-01-29 14:49:09 +01003753 &node, &errmsg)) {
Michal Vasko004d3152020-06-11 19:59:22 +02003754 LOGERR(set->ctx, LY_EVALID, errmsg);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003755 free(errmsg);
Michal Vasko004d3152020-06-11 19:59:22 +02003756 return LY_EVALID;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003757 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003758 } else {
3759 assert(sleaf->type->basetype == LY_TYPE_INST);
Michal Vasko004d3152020-06-11 19:59:22 +02003760 if (ly_path_eval(leaf->value.target, set->tree, &node)) {
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003761 LOGERR(set->ctx, LY_EVALID, "Invalid instance-identifier \"%s\" value - required instance not found.",
Michal Vasko69730152020-10-09 16:30:07 +02003762 LYD_CANON_VALUE(leaf));
Michal Vasko03ff5a72019-09-11 13:49:33 +02003763 return LY_EVALID;
3764 }
3765 }
Michal Vasko004d3152020-06-11 19:59:22 +02003766
3767 /* insert it */
3768 set_insert_node(set, node, 0, LYXP_NODE_ELEM, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003769 }
3770 }
3771
3772 return LY_SUCCESS;
3773}
3774
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003775static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003776xpath_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 +02003777{
Michal Vasko1fdd8fa2021-01-08 09:21:45 +01003778 uint32_t i;
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003779 LY_ARRAY_COUNT_TYPE u;
3780 struct lyd_node_term *leaf;
3781 struct lysc_node_leaf *sleaf;
3782 struct lyd_meta *meta;
3783 struct lyd_value data = {0}, *val;
3784 struct ly_err_item *err = NULL;
3785 LY_ERR rc = LY_SUCCESS;
Radek Krejci857189e2020-09-01 13:26:36 +02003786 ly_bool found;
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003787
3788 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003789 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003790 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", func);
Michal Vasko5676f4e2021-04-06 17:14:45 +02003791 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3792 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3793 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", func, lys_nodetype2str(sleaf->nodetype),
3794 sleaf->name);
3795 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_IDENT)) {
3796 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"identityref\".", func, sleaf->name);
3797 }
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003798 }
3799
3800 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
3801 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3802 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", func, lys_nodetype2str(sleaf->nodetype),
Michal Vasko69730152020-10-09 16:30:07 +02003803 sleaf->name);
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003804 } else if (!warn_is_string_type(sleaf->type)) {
3805 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", func, sleaf->name);
3806 }
3807 }
3808 set_scnode_clear_ctx(set);
3809 return rc;
3810 }
3811
3812 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003813 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 +02003814 return LY_EVALID;
3815 }
3816 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
3817 LY_CHECK_RET(rc);
3818
3819 set_fill_boolean(set, 0);
3820 found = 0;
3821 for (i = 0; i < args[0]->used; ++i) {
3822 if ((args[0]->val.nodes[i].type != LYXP_NODE_ELEM) && (args[0]->val.nodes[i].type != LYXP_NODE_META)) {
3823 continue;
3824 }
3825
3826 if (args[0]->val.nodes[i].type == LYXP_NODE_ELEM) {
3827 leaf = (struct lyd_node_term *)args[0]->val.nodes[i].node;
3828 sleaf = (struct lysc_node_leaf *)leaf->schema;
3829 val = &leaf->value;
3830 if (!(sleaf->nodetype & LYD_NODE_TERM) || (leaf->value.realtype->basetype != LY_TYPE_IDENT)) {
3831 /* uninteresting */
3832 continue;
3833 }
3834
3835 /* store args[1] as ident */
3836 rc = val->realtype->plugin->store(set->ctx, val->realtype, args[1]->val.str, strlen(args[1]->val.str),
Michal Vasko405cc9e2020-12-01 12:01:27 +01003837 0, set->format, set->prefix_data, LYD_HINT_DATA, leaf->schema, &data, NULL, &err);
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003838 } else {
3839 meta = args[0]->val.meta[i].meta;
3840 val = &meta->value;
3841 if (val->realtype->basetype != LY_TYPE_IDENT) {
3842 /* uninteresting */
3843 continue;
3844 }
3845
3846 /* store args[1] as ident */
Michal Vaskofeca4fb2020-10-05 08:58:40 +02003847 rc = val->realtype->plugin->store(set->ctx, val->realtype, args[1]->val.str, strlen(args[1]->val.str), 0,
Michal Vasko405cc9e2020-12-01 12:01:27 +01003848 set->format, set->prefix_data, LYD_HINT_DATA, meta->parent->schema, &data, NULL, &err);
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003849 }
3850
3851 if (err) {
Michal Vasko177d0ed2020-11-23 16:43:03 +01003852 ly_err_print(set->ctx, err);
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003853 ly_err_free(err);
3854 }
3855 LY_CHECK_RET(rc);
3856
3857 /* finally check the identity itself */
3858 if (self_match && (data.ident == val->ident)) {
3859 set_fill_boolean(set, 1);
3860 found = 1;
3861 }
3862 if (!found) {
3863 LY_ARRAY_FOR(data.ident->derived, u) {
3864 if (data.ident->derived[u] == val->ident) {
3865 set_fill_boolean(set, 1);
3866 found = 1;
3867 break;
3868 }
3869 }
3870 }
3871
3872 /* free temporary value */
3873 val->realtype->plugin->free(set->ctx, &data);
3874 if (found) {
3875 break;
3876 }
3877 }
3878
3879 return LY_SUCCESS;
3880}
3881
Michal Vasko03ff5a72019-09-11 13:49:33 +02003882/**
3883 * @brief Execute the YANG 1.1 derived-from(node-set, string) function. Returns LYXP_SET_BOOLEAN depending
3884 * on whether the first argument nodes contain a node of an identity derived from the second
3885 * argument identity.
3886 *
3887 * @param[in] args Array of arguments.
3888 * @param[in] arg_count Count of elements in @p args.
3889 * @param[in,out] set Context and result set at the same time.
3890 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003891 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003892 */
3893static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003894xpath_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 +02003895{
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003896 return xpath_derived_(args, set, options, 0, __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003897}
3898
3899/**
3900 * @brief Execute the YANG 1.1 derived-from-or-self(node-set, string) function. Returns LYXP_SET_BOOLEAN depending
3901 * on whether the first argument nodes contain a node of an identity that either is or is derived from
3902 * the second argument identity.
3903 *
3904 * @param[in] args Array of arguments.
3905 * @param[in] arg_count Count of elements in @p args.
3906 * @param[in,out] set Context and result set at the same time.
3907 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003908 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003909 */
3910static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003911xpath_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 +02003912{
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003913 return xpath_derived_(args, set, options, 1, __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003914}
3915
3916/**
3917 * @brief Execute the YANG 1.1 enum-value(node-set) function. Returns LYXP_SET_NUMBER
3918 * with the integer value of the first node's enum value, otherwise NaN.
3919 *
3920 * @param[in] args Array of arguments.
3921 * @param[in] arg_count Count of elements in @p args.
3922 * @param[in,out] set Context and result set at the same time.
3923 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003924 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003925 */
3926static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003927xpath_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 +02003928{
3929 struct lyd_node_term *leaf;
3930 struct lysc_node_leaf *sleaf;
3931 LY_ERR rc = LY_SUCCESS;
3932
3933 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02003934 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003935 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko5676f4e2021-04-06 17:14:45 +02003936 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3937 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3938 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
3939 sleaf->name);
3940 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_ENUM)) {
3941 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"enumeration\".", __func__, sleaf->name);
3942 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003943 }
3944 set_scnode_clear_ctx(set);
3945 return rc;
3946 }
3947
Michal Vaskod3678892020-05-21 10:06:58 +02003948 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01003949 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "enum-value(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02003950 return LY_EVALID;
3951 }
3952
3953 set_fill_number(set, NAN);
Michal Vaskod3678892020-05-21 10:06:58 +02003954 if (args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003955 leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
3956 sleaf = (struct lysc_node_leaf *)leaf->schema;
3957 if ((sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST)) && (sleaf->type->basetype == LY_TYPE_ENUM)) {
3958 set_fill_number(set, leaf->value.enum_item->value);
3959 }
3960 }
3961
3962 return LY_SUCCESS;
3963}
3964
3965/**
3966 * @brief Execute the XPath false() function. Returns LYXP_SET_BOOLEAN
3967 * with false value.
3968 *
3969 * @param[in] args Array of arguments.
3970 * @param[in] arg_count Count of elements in @p args.
3971 * @param[in,out] set Context and result set at the same time.
3972 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003973 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003974 */
3975static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003976xpath_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 +02003977{
3978 if (options & LYXP_SCNODE_ALL) {
3979 set_scnode_clear_ctx(set);
3980 return LY_SUCCESS;
3981 }
3982
3983 set_fill_boolean(set, 0);
3984 return LY_SUCCESS;
3985}
3986
3987/**
3988 * @brief Execute the XPath floor(number) function. Returns LYXP_SET_NUMBER
3989 * with the first argument floored (truncated).
3990 *
3991 * @param[in] args Array of arguments.
3992 * @param[in] arg_count Count of elements in @p args.
3993 * @param[in,out] set Context and result set at the same time.
3994 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003995 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003996 */
3997static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003998xpath_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 +02003999{
4000 LY_ERR rc;
4001
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004002 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004003 LY_CHECK_RET(rc);
4004 if (isfinite(args[0]->val.num)) {
4005 set_fill_number(set, (long long)args[0]->val.num);
4006 }
4007
4008 return LY_SUCCESS;
4009}
4010
4011/**
4012 * @brief Execute the XPath lang(string) function. Returns LYXP_SET_BOOLEAN
4013 * whether the language of the text matches the one from the argument.
4014 *
4015 * @param[in] args Array of arguments.
4016 * @param[in] arg_count Count of elements in @p args.
4017 * @param[in,out] set Context and result set at the same time.
4018 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004019 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004020 */
4021static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004022xpath_lang(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004023{
4024 const struct lyd_node *node;
4025 struct lysc_node_leaf *sleaf;
Michal Vasko9f96a052020-03-10 09:41:45 +01004026 struct lyd_meta *meta = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004027 const char *val;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004028 LY_ERR rc = LY_SUCCESS;
4029
4030 if (options & LYXP_SCNODE_ALL) {
4031 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4032 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4033 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 +02004034 } else if (!warn_is_string_type(sleaf->type)) {
4035 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004036 }
4037 }
4038 set_scnode_clear_ctx(set);
4039 return rc;
4040 }
4041
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004042 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004043 LY_CHECK_RET(rc);
4044
Michal Vasko03ff5a72019-09-11 13:49:33 +02004045 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004046 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "lang(string)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004047 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004048 } else if (!set->used) {
4049 set_fill_boolean(set, 0);
4050 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004051 }
4052
4053 switch (set->val.nodes[0].type) {
4054 case LYXP_NODE_ELEM:
4055 case LYXP_NODE_TEXT:
4056 node = set->val.nodes[0].node;
4057 break;
Michal Vasko9f96a052020-03-10 09:41:45 +01004058 case LYXP_NODE_META:
4059 node = set->val.meta[0].meta->parent;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004060 break;
4061 default:
4062 /* nothing to do with roots */
4063 set_fill_boolean(set, 0);
4064 return LY_SUCCESS;
4065 }
4066
Michal Vasko9f96a052020-03-10 09:41:45 +01004067 /* find lang metadata */
Michal Vasko9e685082021-01-29 14:49:09 +01004068 for ( ; node; node = lyd_parent(node)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01004069 for (meta = node->meta; meta; meta = meta->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004070 /* annotations */
Michal Vasko9f96a052020-03-10 09:41:45 +01004071 if (meta->name && !strcmp(meta->name, "lang") && !strcmp(meta->annotation->module->name, "xml")) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004072 break;
4073 }
4074 }
4075
Michal Vasko9f96a052020-03-10 09:41:45 +01004076 if (meta) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004077 break;
4078 }
4079 }
4080
4081 /* compare languages */
Michal Vasko9f96a052020-03-10 09:41:45 +01004082 if (!meta) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004083 set_fill_boolean(set, 0);
4084 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004085 uint64_t i;
4086
Michal Vaskoba99a3e2020-08-18 15:50:05 +02004087 val = meta->value.canonical;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004088 for (i = 0; args[0]->val.str[i]; ++i) {
4089 if (tolower(args[0]->val.str[i]) != tolower(val[i])) {
4090 set_fill_boolean(set, 0);
4091 break;
4092 }
4093 }
4094 if (!args[0]->val.str[i]) {
4095 if (!val[i] || (val[i] == '-')) {
4096 set_fill_boolean(set, 1);
4097 } else {
4098 set_fill_boolean(set, 0);
4099 }
4100 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004101 }
4102
4103 return LY_SUCCESS;
4104}
4105
4106/**
4107 * @brief Execute the XPath last() function. Returns LYXP_SET_NUMBER
4108 * with the context size.
4109 *
4110 * @param[in] args Array of arguments.
4111 * @param[in] arg_count Count of elements in @p args.
4112 * @param[in,out] set Context and result set at the same time.
4113 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004114 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004115 */
4116static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004117xpath_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 +02004118{
4119 if (options & LYXP_SCNODE_ALL) {
4120 set_scnode_clear_ctx(set);
4121 return LY_SUCCESS;
4122 }
4123
Michal Vasko03ff5a72019-09-11 13:49:33 +02004124 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004125 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "last()");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004126 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004127 } else if (!set->used) {
4128 set_fill_number(set, 0);
4129 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004130 }
4131
4132 set_fill_number(set, set->ctx_size);
4133 return LY_SUCCESS;
4134}
4135
4136/**
4137 * @brief Execute the XPath local-name(node-set?) function. Returns LYXP_SET_STRING
4138 * with the node name without namespace from the argument or the context.
4139 *
4140 * @param[in] args Array of arguments.
4141 * @param[in] arg_count Count of elements in @p args.
4142 * @param[in,out] set Context and result set at the same time.
4143 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004144 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004145 */
4146static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004147xpath_local_name(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004148{
4149 struct lyxp_set_node *item;
Michal Vasko69730152020-10-09 16:30:07 +02004150
Michal Vasko03ff5a72019-09-11 13:49:33 +02004151 /* suppress unused variable warning */
4152 (void)options;
4153
4154 if (options & LYXP_SCNODE_ALL) {
4155 set_scnode_clear_ctx(set);
4156 return LY_SUCCESS;
4157 }
4158
4159 if (arg_count) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004160 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004161 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]),
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004162 "local-name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004163 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004164 } else if (!args[0]->used) {
4165 set_fill_string(set, "", 0);
4166 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004167 }
4168
4169 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004170 assert(!set_sort(args[0]));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004171
4172 item = &args[0]->val.nodes[0];
4173 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004174 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004175 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "local-name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004176 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004177 } else if (!set->used) {
4178 set_fill_string(set, "", 0);
4179 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004180 }
4181
4182 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004183 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004184
4185 item = &set->val.nodes[0];
4186 }
4187
4188 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01004189 case LYXP_NODE_NONE:
4190 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004191 case LYXP_NODE_ROOT:
4192 case LYXP_NODE_ROOT_CONFIG:
4193 case LYXP_NODE_TEXT:
4194 set_fill_string(set, "", 0);
4195 break;
4196 case LYXP_NODE_ELEM:
4197 set_fill_string(set, item->node->schema->name, strlen(item->node->schema->name));
4198 break;
Michal Vasko9f96a052020-03-10 09:41:45 +01004199 case LYXP_NODE_META:
4200 set_fill_string(set, ((struct lyd_meta *)item->node)->name, strlen(((struct lyd_meta *)item->node)->name));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004201 break;
4202 }
4203
4204 return LY_SUCCESS;
4205}
4206
4207/**
4208 * @brief Execute the XPath name(node-set?) function. Returns LYXP_SET_STRING
4209 * with the node name fully qualified (with namespace) from the argument or the context.
4210 *
4211 * @param[in] args Array of arguments.
4212 * @param[in] arg_count Count of elements in @p args.
4213 * @param[in,out] set Context and result set at the same time.
4214 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004215 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004216 */
4217static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004218xpath_name(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004219{
4220 struct lyxp_set_node *item;
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02004221 struct lys_module *mod = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004222 char *str;
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02004223 const char *name = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004224
4225 if (options & LYXP_SCNODE_ALL) {
4226 set_scnode_clear_ctx(set);
4227 return LY_SUCCESS;
4228 }
4229
4230 if (arg_count) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004231 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004232 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004233 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004234 } else if (!args[0]->used) {
4235 set_fill_string(set, "", 0);
4236 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004237 }
4238
4239 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004240 assert(!set_sort(args[0]));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004241
4242 item = &args[0]->val.nodes[0];
4243 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004244 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004245 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004246 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004247 } else if (!set->used) {
4248 set_fill_string(set, "", 0);
4249 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004250 }
4251
4252 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004253 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004254
4255 item = &set->val.nodes[0];
4256 }
4257
4258 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01004259 case LYXP_NODE_NONE:
4260 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004261 case LYXP_NODE_ROOT:
4262 case LYXP_NODE_ROOT_CONFIG:
4263 case LYXP_NODE_TEXT:
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02004264 /* keep NULL */
Michal Vasko03ff5a72019-09-11 13:49:33 +02004265 break;
4266 case LYXP_NODE_ELEM:
4267 mod = item->node->schema->module;
4268 name = item->node->schema->name;
4269 break;
Michal Vasko9f96a052020-03-10 09:41:45 +01004270 case LYXP_NODE_META:
4271 mod = ((struct lyd_meta *)item->node)->annotation->module;
4272 name = ((struct lyd_meta *)item->node)->name;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004273 break;
4274 }
4275
4276 if (mod && name) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004277 int rc = asprintf(&str, "%s:%s", ly_get_prefix(mod, set->format, set->prefix_data), name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004278 LY_CHECK_ERR_RET(rc == -1, LOGMEM(set->ctx), LY_EMEM);
4279 set_fill_string(set, str, strlen(str));
4280 free(str);
4281 } else {
4282 set_fill_string(set, "", 0);
4283 }
4284
4285 return LY_SUCCESS;
4286}
4287
4288/**
4289 * @brief Execute the XPath namespace-uri(node-set?) function. Returns LYXP_SET_STRING
4290 * with the namespace of the node from the argument or the context.
4291 *
4292 * @param[in] args Array of arguments.
4293 * @param[in] arg_count Count of elements in @p args.
4294 * @param[in,out] set Context and result set at the same time.
4295 * @param[in] options XPath options.
4296 * @return LY_ERR (LY_EINVAL for wrong arguments on schema)
4297 */
4298static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004299xpath_namespace_uri(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004300{
4301 struct lyxp_set_node *item;
4302 struct lys_module *mod;
Michal Vasko69730152020-10-09 16:30:07 +02004303
Michal Vasko03ff5a72019-09-11 13:49:33 +02004304 /* suppress unused variable warning */
4305 (void)options;
4306
4307 if (options & LYXP_SCNODE_ALL) {
4308 set_scnode_clear_ctx(set);
4309 return LY_SUCCESS;
4310 }
4311
4312 if (arg_count) {
Michal Vaskod3678892020-05-21 10:06:58 +02004313 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004314 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]),
Michal Vasko69730152020-10-09 16:30:07 +02004315 "namespace-uri(node-set?)");
Michal Vaskod3678892020-05-21 10:06:58 +02004316 return LY_EVALID;
4317 } else if (!args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004318 set_fill_string(set, "", 0);
4319 return LY_SUCCESS;
4320 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004321
4322 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004323 assert(!set_sort(args[0]));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004324
4325 item = &args[0]->val.nodes[0];
4326 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004327 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004328 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "namespace-uri(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004329 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004330 } else if (!set->used) {
4331 set_fill_string(set, "", 0);
4332 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004333 }
4334
4335 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004336 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004337
4338 item = &set->val.nodes[0];
4339 }
4340
4341 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01004342 case LYXP_NODE_NONE:
4343 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004344 case LYXP_NODE_ROOT:
4345 case LYXP_NODE_ROOT_CONFIG:
4346 case LYXP_NODE_TEXT:
4347 set_fill_string(set, "", 0);
4348 break;
4349 case LYXP_NODE_ELEM:
Michal Vasko9f96a052020-03-10 09:41:45 +01004350 case LYXP_NODE_META:
Michal Vasko03ff5a72019-09-11 13:49:33 +02004351 if (item->type == LYXP_NODE_ELEM) {
4352 mod = item->node->schema->module;
Michal Vasko9f96a052020-03-10 09:41:45 +01004353 } else { /* LYXP_NODE_META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02004354 /* annotations */
Michal Vasko9f96a052020-03-10 09:41:45 +01004355 mod = ((struct lyd_meta *)item->node)->annotation->module;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004356 }
4357
4358 set_fill_string(set, mod->ns, strlen(mod->ns));
4359 break;
4360 }
4361
4362 return LY_SUCCESS;
4363}
4364
4365/**
4366 * @brief Execute the XPath node() function (node type). Returns LYXP_SET_NODE_SET
4367 * with only nodes from the context. In practice it either leaves the context
4368 * as it is or returns an empty node set.
4369 *
4370 * @param[in] args Array of arguments.
4371 * @param[in] arg_count Count of elements in @p args.
4372 * @param[in,out] set Context and result set at the same time.
4373 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004374 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004375 */
4376static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004377xpath_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 +02004378{
4379 if (options & LYXP_SCNODE_ALL) {
4380 set_scnode_clear_ctx(set);
4381 return LY_SUCCESS;
4382 }
4383
4384 if (set->type != LYXP_SET_NODE_SET) {
Michal Vaskod3678892020-05-21 10:06:58 +02004385 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004386 }
4387 return LY_SUCCESS;
4388}
4389
4390/**
4391 * @brief Execute the XPath normalize-space(string?) function. Returns LYXP_SET_STRING
4392 * with normalized value (no leading, trailing, double white spaces) of the node
4393 * from the argument or the context.
4394 *
4395 * @param[in] args Array of arguments.
4396 * @param[in] arg_count Count of elements in @p args.
4397 * @param[in,out] set Context and result set at the same time.
4398 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004399 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004400 */
4401static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004402xpath_normalize_space(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004403{
4404 uint16_t i, new_used;
4405 char *new;
Radek Krejci857189e2020-09-01 13:26:36 +02004406 ly_bool have_spaces = 0, space_before = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004407 struct lysc_node_leaf *sleaf;
4408 LY_ERR rc = LY_SUCCESS;
4409
4410 if (options & LYXP_SCNODE_ALL) {
4411 if (arg_count && (args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4412 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4413 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 +02004414 } else if (!warn_is_string_type(sleaf->type)) {
4415 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004416 }
4417 }
4418 set_scnode_clear_ctx(set);
4419 return rc;
4420 }
4421
4422 if (arg_count) {
4423 set_fill_set(set, args[0]);
4424 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004425 rc = lyxp_set_cast(set, LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004426 LY_CHECK_RET(rc);
4427
4428 /* is there any normalization necessary? */
4429 for (i = 0; set->val.str[i]; ++i) {
4430 if (is_xmlws(set->val.str[i])) {
4431 if ((i == 0) || space_before || (!set->val.str[i + 1])) {
4432 have_spaces = 1;
4433 break;
4434 }
4435 space_before = 1;
4436 } else {
4437 space_before = 0;
4438 }
4439 }
4440
4441 /* yep, there is */
4442 if (have_spaces) {
4443 /* it's enough, at least one character will go, makes space for ending '\0' */
4444 new = malloc(strlen(set->val.str) * sizeof(char));
4445 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
4446 new_used = 0;
4447
4448 space_before = 0;
4449 for (i = 0; set->val.str[i]; ++i) {
4450 if (is_xmlws(set->val.str[i])) {
4451 if ((i == 0) || space_before) {
4452 space_before = 1;
4453 continue;
4454 } else {
4455 space_before = 1;
4456 }
4457 } else {
4458 space_before = 0;
4459 }
4460
4461 new[new_used] = (space_before ? ' ' : set->val.str[i]);
4462 ++new_used;
4463 }
4464
4465 /* at worst there is one trailing space now */
4466 if (new_used && is_xmlws(new[new_used - 1])) {
4467 --new_used;
4468 }
4469
4470 new = ly_realloc(new, (new_used + 1) * sizeof(char));
4471 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
4472 new[new_used] = '\0';
4473
4474 free(set->val.str);
4475 set->val.str = new;
4476 }
4477
4478 return LY_SUCCESS;
4479}
4480
4481/**
4482 * @brief Execute the XPath not(boolean) function. Returns LYXP_SET_BOOLEAN
4483 * with the argument converted to boolean and logically inverted.
4484 *
4485 * @param[in] args Array of arguments.
4486 * @param[in] arg_count Count of elements in @p args.
4487 * @param[in,out] set Context and result set at the same time.
4488 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004489 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004490 */
4491static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004492xpath_not(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004493{
4494 if (options & LYXP_SCNODE_ALL) {
4495 set_scnode_clear_ctx(set);
4496 return LY_SUCCESS;
4497 }
4498
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004499 lyxp_set_cast(args[0], LYXP_SET_BOOLEAN);
Michal Vasko004d3152020-06-11 19:59:22 +02004500 if (args[0]->val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004501 set_fill_boolean(set, 0);
4502 } else {
4503 set_fill_boolean(set, 1);
4504 }
4505
4506 return LY_SUCCESS;
4507}
4508
4509/**
4510 * @brief Execute the XPath number(object?) function. Returns LYXP_SET_NUMBER
4511 * with the number representation of either the argument or the context.
4512 *
4513 * @param[in] args Array of arguments.
4514 * @param[in] arg_count Count of elements in @p args.
4515 * @param[in,out] set Context and result set at the same time.
4516 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004517 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004518 */
4519static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004520xpath_number(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004521{
4522 LY_ERR rc;
4523
4524 if (options & LYXP_SCNODE_ALL) {
4525 set_scnode_clear_ctx(set);
4526 return LY_SUCCESS;
4527 }
4528
4529 if (arg_count) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004530 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004531 LY_CHECK_RET(rc);
4532 set_fill_set(set, args[0]);
4533 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004534 rc = lyxp_set_cast(set, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004535 LY_CHECK_RET(rc);
4536 }
4537
4538 return LY_SUCCESS;
4539}
4540
4541/**
4542 * @brief Execute the XPath position() function. Returns LYXP_SET_NUMBER
4543 * with the context position.
4544 *
4545 * @param[in] args Array of arguments.
4546 * @param[in] arg_count Count of elements in @p args.
4547 * @param[in,out] set Context and result set at the same time.
4548 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004549 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004550 */
4551static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004552xpath_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 +02004553{
4554 if (options & LYXP_SCNODE_ALL) {
4555 set_scnode_clear_ctx(set);
4556 return LY_SUCCESS;
4557 }
4558
Michal Vasko03ff5a72019-09-11 13:49:33 +02004559 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01004560 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "position()");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004561 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004562 } else if (!set->used) {
4563 set_fill_number(set, 0);
4564 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004565 }
4566
4567 set_fill_number(set, set->ctx_pos);
4568
4569 /* UNUSED in 'Release' build type */
4570 (void)options;
4571 return LY_SUCCESS;
4572}
4573
4574/**
4575 * @brief Execute the YANG 1.1 re-match(string, string) function. Returns LYXP_SET_BOOLEAN
4576 * depending on whether the second argument regex matches the first argument string. For details refer to
4577 * YANG 1.1 RFC section 10.2.1.
4578 *
4579 * @param[in] args Array of arguments.
4580 * @param[in] arg_count Count of elements in @p args.
4581 * @param[in,out] set Context and result set at the same time.
4582 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004583 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004584 */
4585static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004586xpath_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 +02004587{
4588 struct lysc_pattern **patterns = NULL, **pattern;
4589 struct lysc_node_leaf *sleaf;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004590 LY_ERR rc = LY_SUCCESS;
4591 struct ly_err_item *err;
4592
4593 if (options & LYXP_SCNODE_ALL) {
4594 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4595 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4596 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 +02004597 } else if (!warn_is_string_type(sleaf->type)) {
4598 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004599 }
4600 }
4601
4602 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4603 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4604 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 +02004605 } else if (!warn_is_string_type(sleaf->type)) {
4606 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004607 }
4608 }
4609 set_scnode_clear_ctx(set);
4610 return rc;
4611 }
4612
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004613 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004614 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004615 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004616 LY_CHECK_RET(rc);
4617
4618 LY_ARRAY_NEW_RET(set->ctx, patterns, pattern, LY_EMEM);
Radek IÅ¡a45802b52021-02-09 09:21:58 +01004619 *pattern = calloc(1, sizeof **pattern);
Radek Krejciddace2c2021-01-08 11:30:56 +01004620 LOG_LOCSET(NULL, set->cur_node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01004621 rc = lys_compile_type_pattern_check(set->ctx, args[1]->val.str, &(*pattern)->code);
Radek Krejciddace2c2021-01-08 11:30:56 +01004622 LOG_LOCBACK(0, 1, 0, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004623 if (rc != LY_SUCCESS) {
4624 LY_ARRAY_FREE(patterns);
4625 return rc;
4626 }
4627
Radek Krejci0b013302021-03-29 15:22:32 +02004628 rc = lyplg_type_validate_patterns(patterns, args[0]->val.str, strlen(args[0]->val.str), &err);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004629 pcre2_code_free((*pattern)->code);
4630 free(*pattern);
4631 LY_ARRAY_FREE(patterns);
4632 if (rc && (rc != LY_EVALID)) {
Michal Vasko177d0ed2020-11-23 16:43:03 +01004633 ly_err_print(set->ctx, err);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004634 ly_err_free(err);
4635 return rc;
4636 }
4637
4638 if (rc == LY_EVALID) {
4639 ly_err_free(err);
4640 set_fill_boolean(set, 0);
4641 } else {
4642 set_fill_boolean(set, 1);
4643 }
4644
4645 return LY_SUCCESS;
4646}
4647
4648/**
4649 * @brief Execute the XPath round(number) function. Returns LYXP_SET_NUMBER
4650 * with the rounded first argument. For details refer to
4651 * http://www.w3.org/TR/1999/REC-xpath-19991116/#function-round.
4652 *
4653 * @param[in] args Array of arguments.
4654 * @param[in] arg_count Count of elements in @p args.
4655 * @param[in,out] set Context and result set at the same time.
4656 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004657 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004658 */
4659static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004660xpath_round(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004661{
4662 struct lysc_node_leaf *sleaf;
4663 LY_ERR rc = LY_SUCCESS;
4664
4665 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5676f4e2021-04-06 17:14:45 +02004666 if (args[0]->type != LYXP_SET_SCNODE_SET) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004667 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko5676f4e2021-04-06 17:14:45 +02004668 } else if ((sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4669 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4670 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__, lys_nodetype2str(sleaf->nodetype),
4671 sleaf->name);
4672 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_DEC64)) {
4673 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"decimal64\".", __func__, sleaf->name);
4674 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004675 }
4676 set_scnode_clear_ctx(set);
4677 return rc;
4678 }
4679
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004680 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004681 LY_CHECK_RET(rc);
4682
4683 /* cover only the cases where floor can't be used */
4684 if ((args[0]->val.num == -0.0f) || ((args[0]->val.num < 0) && (args[0]->val.num >= -0.5))) {
4685 set_fill_number(set, -0.0f);
4686 } else {
4687 args[0]->val.num += 0.5;
4688 rc = xpath_floor(args, 1, args[0], options);
4689 LY_CHECK_RET(rc);
4690 set_fill_number(set, args[0]->val.num);
4691 }
4692
4693 return LY_SUCCESS;
4694}
4695
4696/**
4697 * @brief Execute the XPath starts-with(string, string) function.
4698 * Returns LYXP_SET_BOOLEAN whether the second argument is
4699 * the prefix of the first or not.
4700 *
4701 * @param[in] args Array of arguments.
4702 * @param[in] arg_count Count of elements in @p args.
4703 * @param[in,out] set Context and result set at the same time.
4704 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004705 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004706 */
4707static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004708xpath_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 +02004709{
4710 struct lysc_node_leaf *sleaf;
4711 LY_ERR rc = LY_SUCCESS;
4712
4713 if (options & LYXP_SCNODE_ALL) {
4714 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4715 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4716 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 +02004717 } else if (!warn_is_string_type(sleaf->type)) {
4718 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004719 }
4720 }
4721
4722 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4723 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4724 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 +02004725 } else if (!warn_is_string_type(sleaf->type)) {
4726 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004727 }
4728 }
4729 set_scnode_clear_ctx(set);
4730 return rc;
4731 }
4732
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004733 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004734 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004735 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004736 LY_CHECK_RET(rc);
4737
4738 if (strncmp(args[0]->val.str, args[1]->val.str, strlen(args[1]->val.str))) {
4739 set_fill_boolean(set, 0);
4740 } else {
4741 set_fill_boolean(set, 1);
4742 }
4743
4744 return LY_SUCCESS;
4745}
4746
4747/**
4748 * @brief Execute the XPath string(object?) function. Returns LYXP_SET_STRING
4749 * with the string representation of either the argument or the context.
4750 *
4751 * @param[in] args Array of arguments.
4752 * @param[in] arg_count Count of elements in @p args.
4753 * @param[in,out] set Context and result set at the same time.
4754 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004755 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004756 */
4757static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004758xpath_string(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004759{
4760 LY_ERR rc;
4761
4762 if (options & LYXP_SCNODE_ALL) {
4763 set_scnode_clear_ctx(set);
4764 return LY_SUCCESS;
4765 }
4766
4767 if (arg_count) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004768 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004769 LY_CHECK_RET(rc);
4770 set_fill_set(set, args[0]);
4771 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004772 rc = lyxp_set_cast(set, LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004773 LY_CHECK_RET(rc);
4774 }
4775
4776 return LY_SUCCESS;
4777}
4778
4779/**
4780 * @brief Execute the XPath string-length(string?) function. Returns LYXP_SET_NUMBER
4781 * with the length of the string in either the argument or the context.
4782 *
4783 * @param[in] args Array of arguments.
4784 * @param[in] arg_count Count of elements in @p args.
4785 * @param[in,out] set Context and result set at the same time.
4786 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004787 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004788 */
4789static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004790xpath_string_length(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004791{
4792 struct lysc_node_leaf *sleaf;
4793 LY_ERR rc = LY_SUCCESS;
4794
4795 if (options & LYXP_SCNODE_ALL) {
4796 if (arg_count && (args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4797 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4798 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 +02004799 } else if (!warn_is_string_type(sleaf->type)) {
4800 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004801 }
4802 }
4803 if (!arg_count && (set->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set))) {
4804 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4805 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 +02004806 } else if (!warn_is_string_type(sleaf->type)) {
4807 LOGWRN(set->ctx, "Argument #0 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004808 }
4809 }
4810 set_scnode_clear_ctx(set);
4811 return rc;
4812 }
4813
4814 if (arg_count) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004815 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004816 LY_CHECK_RET(rc);
4817 set_fill_number(set, strlen(args[0]->val.str));
4818 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004819 rc = lyxp_set_cast(set, LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004820 LY_CHECK_RET(rc);
4821 set_fill_number(set, strlen(set->val.str));
4822 }
4823
4824 return LY_SUCCESS;
4825}
4826
4827/**
4828 * @brief Execute the XPath substring(string, number, number?) function.
4829 * Returns LYXP_SET_STRING substring of the first argument starting
4830 * on the second argument index ending on the third argument index,
4831 * indexed from 1. For exact definition refer to
4832 * http://www.w3.org/TR/1999/REC-xpath-19991116/#function-substring.
4833 *
4834 * @param[in] args Array of arguments.
4835 * @param[in] arg_count Count of elements in @p args.
4836 * @param[in,out] set Context and result set at the same time.
4837 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004838 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004839 */
4840static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004841xpath_substring(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004842{
Radek Krejci1deb5be2020-08-26 16:43:36 +02004843 int32_t start, len;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004844 uint16_t str_start, str_len, pos;
4845 struct lysc_node_leaf *sleaf;
4846 LY_ERR rc = LY_SUCCESS;
4847
4848 if (options & LYXP_SCNODE_ALL) {
4849 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4850 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4851 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 +02004852 } else if (!warn_is_string_type(sleaf->type)) {
4853 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004854 }
4855 }
4856
4857 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4858 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4859 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 +02004860 } else if (!warn_is_numeric_type(sleaf->type)) {
4861 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004862 }
4863 }
4864
Michal Vasko69730152020-10-09 16:30:07 +02004865 if ((arg_count == 3) && (args[2]->type == LYXP_SET_SCNODE_SET) &&
4866 (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[2]))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004867 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4868 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 +02004869 } else if (!warn_is_numeric_type(sleaf->type)) {
4870 LOGWRN(set->ctx, "Argument #3 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004871 }
4872 }
4873 set_scnode_clear_ctx(set);
4874 return rc;
4875 }
4876
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004877 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004878 LY_CHECK_RET(rc);
4879
4880 /* start */
4881 if (xpath_round(&args[1], 1, args[1], options)) {
4882 return -1;
4883 }
4884 if (isfinite(args[1]->val.num)) {
4885 start = args[1]->val.num - 1;
4886 } else if (isinf(args[1]->val.num) && signbit(args[1]->val.num)) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004887 start = INT32_MIN;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004888 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004889 start = INT32_MAX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004890 }
4891
4892 /* len */
4893 if (arg_count == 3) {
4894 rc = xpath_round(&args[2], 1, args[2], options);
4895 LY_CHECK_RET(rc);
Radek Krejci1deb5be2020-08-26 16:43:36 +02004896 if (isnan(args[2]->val.num) || signbit(args[2]->val.num)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004897 len = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02004898 } else if (isfinite(args[2]->val.num)) {
4899 len = args[2]->val.num;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004900 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004901 len = INT32_MAX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004902 }
4903 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004904 len = INT32_MAX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004905 }
4906
4907 /* find matching character positions */
4908 str_start = 0;
4909 str_len = 0;
4910 for (pos = 0; args[0]->val.str[pos]; ++pos) {
4911 if (pos < start) {
4912 ++str_start;
4913 } else if (pos < start + len) {
4914 ++str_len;
4915 } else {
4916 break;
4917 }
4918 }
4919
4920 set_fill_string(set, args[0]->val.str + str_start, str_len);
4921 return LY_SUCCESS;
4922}
4923
4924/**
4925 * @brief Execute the XPath substring-after(string, string) function.
4926 * Returns LYXP_SET_STRING with the string succeeding the occurance
4927 * of the second argument in the first or an empty string.
4928 *
4929 * @param[in] args Array of arguments.
4930 * @param[in] arg_count Count of elements in @p args.
4931 * @param[in,out] set Context and result set at the same time.
4932 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004933 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004934 */
4935static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004936xpath_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 +02004937{
4938 char *ptr;
4939 struct lysc_node_leaf *sleaf;
4940 LY_ERR rc = LY_SUCCESS;
4941
4942 if (options & LYXP_SCNODE_ALL) {
4943 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4944 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4945 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 +02004946 } else if (!warn_is_string_type(sleaf->type)) {
4947 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004948 }
4949 }
4950
4951 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4952 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4953 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 +02004954 } else if (!warn_is_string_type(sleaf->type)) {
4955 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004956 }
4957 }
4958 set_scnode_clear_ctx(set);
4959 return rc;
4960 }
4961
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004962 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004963 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004964 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004965 LY_CHECK_RET(rc);
4966
4967 ptr = strstr(args[0]->val.str, args[1]->val.str);
4968 if (ptr) {
4969 set_fill_string(set, ptr + strlen(args[1]->val.str), strlen(ptr + strlen(args[1]->val.str)));
4970 } else {
4971 set_fill_string(set, "", 0);
4972 }
4973
4974 return LY_SUCCESS;
4975}
4976
4977/**
4978 * @brief Execute the XPath substring-before(string, string) function.
4979 * Returns LYXP_SET_STRING with the string preceding the occurance
4980 * of the second argument in the first or an empty string.
4981 *
4982 * @param[in] args Array of arguments.
4983 * @param[in] arg_count Count of elements in @p args.
4984 * @param[in,out] set Context and result set at the same time.
4985 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004986 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004987 */
4988static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004989xpath_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 +02004990{
4991 char *ptr;
4992 struct lysc_node_leaf *sleaf;
4993 LY_ERR rc = LY_SUCCESS;
4994
4995 if (options & LYXP_SCNODE_ALL) {
4996 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4997 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4998 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 +02004999 } else if (!warn_is_string_type(sleaf->type)) {
5000 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005001 }
5002 }
5003
5004 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
5005 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5006 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 +02005007 } else if (!warn_is_string_type(sleaf->type)) {
5008 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005009 }
5010 }
5011 set_scnode_clear_ctx(set);
5012 return rc;
5013 }
5014
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005015 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005016 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005017 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005018 LY_CHECK_RET(rc);
5019
5020 ptr = strstr(args[0]->val.str, args[1]->val.str);
5021 if (ptr) {
5022 set_fill_string(set, args[0]->val.str, ptr - args[0]->val.str);
5023 } else {
5024 set_fill_string(set, "", 0);
5025 }
5026
5027 return LY_SUCCESS;
5028}
5029
5030/**
5031 * @brief Execute the XPath sum(node-set) function. Returns LYXP_SET_NUMBER
5032 * with the sum of all the nodes in the context.
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_sum(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 long double num;
5044 char *str;
Michal Vasko1fdd8fa2021-01-08 09:21:45 +01005045 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005046 struct lyxp_set set_item;
5047 struct lysc_node_leaf *sleaf;
5048 LY_ERR rc = LY_SUCCESS;
5049
5050 if (options & LYXP_SCNODE_ALL) {
5051 if (args[0]->type == LYXP_SET_SCNODE_SET) {
5052 for (i = 0; i < args[0]->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005053 if (args[0]->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005054 sleaf = (struct lysc_node_leaf *)args[0]->val.scnodes[i].scnode;
5055 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5056 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__,
Michal Vasko69730152020-10-09 16:30:07 +02005057 lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005058 } else if (!warn_is_numeric_type(sleaf->type)) {
5059 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005060 }
5061 }
5062 }
5063 }
5064 set_scnode_clear_ctx(set);
5065 return rc;
5066 }
5067
5068 set_fill_number(set, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005069
5070 if (args[0]->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005071 LOGVAL(set->ctx, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "sum(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02005072 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02005073 } else if (!args[0]->used) {
5074 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005075 }
5076
Michal Vasko5c4e5892019-11-14 12:31:38 +01005077 set_init(&set_item, set);
5078
Michal Vasko03ff5a72019-09-11 13:49:33 +02005079 set_item.type = LYXP_SET_NODE_SET;
5080 set_item.val.nodes = malloc(sizeof *set_item.val.nodes);
5081 LY_CHECK_ERR_RET(!set_item.val.nodes, LOGMEM(set->ctx), LY_EMEM);
5082
5083 set_item.used = 1;
5084 set_item.size = 1;
5085
5086 for (i = 0; i < args[0]->used; ++i) {
5087 set_item.val.nodes[0] = args[0]->val.nodes[i];
5088
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005089 rc = cast_node_set_to_string(&set_item, &str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005090 LY_CHECK_RET(rc);
5091 num = cast_string_to_number(str);
5092 free(str);
5093 set->val.num += num;
5094 }
5095
5096 free(set_item.val.nodes);
5097
5098 return LY_SUCCESS;
5099}
5100
5101/**
5102 * @brief Execute the XPath text() function (node type). Returns LYXP_SET_NODE_SET
5103 * with the text content of the nodes in the context.
5104 *
5105 * @param[in] args Array of arguments.
5106 * @param[in] arg_count Count of elements in @p args.
5107 * @param[in,out] set Context and result set at the same time.
5108 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005109 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005110 */
5111static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005112xpath_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 +02005113{
5114 uint32_t i;
5115
5116 if (options & LYXP_SCNODE_ALL) {
5117 set_scnode_clear_ctx(set);
5118 return LY_SUCCESS;
5119 }
5120
Michal Vasko03ff5a72019-09-11 13:49:33 +02005121 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005122 LOGVAL(set->ctx, LY_VCODE_XP_INCTX, print_set_type(set), "text()");
Michal Vasko03ff5a72019-09-11 13:49:33 +02005123 return LY_EVALID;
5124 }
5125
Michal Vaskod989ba02020-08-24 10:59:24 +02005126 for (i = 0; i < set->used; ) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005127 switch (set->val.nodes[i].type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01005128 case LYXP_NODE_NONE:
5129 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005130 case LYXP_NODE_ELEM:
Michal Vasko03ff5a72019-09-11 13:49:33 +02005131 if (set->val.nodes[i].node->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
5132 set->val.nodes[i].type = LYXP_NODE_TEXT;
5133 ++i;
5134 break;
5135 }
Radek Krejci0f969882020-08-21 16:56:47 +02005136 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005137 case LYXP_NODE_ROOT:
5138 case LYXP_NODE_ROOT_CONFIG:
5139 case LYXP_NODE_TEXT:
Michal Vasko9f96a052020-03-10 09:41:45 +01005140 case LYXP_NODE_META:
Michal Vasko03ff5a72019-09-11 13:49:33 +02005141 set_remove_node(set, i);
5142 break;
5143 }
5144 }
5145
5146 return LY_SUCCESS;
5147}
5148
5149/**
5150 * @brief Execute the XPath translate(string, string, string) function.
5151 * Returns LYXP_SET_STRING with the first argument with the characters
5152 * from the second argument replaced by those on the corresponding
5153 * positions in the third argument.
5154 *
5155 * @param[in] args Array of arguments.
5156 * @param[in] arg_count Count of elements in @p args.
5157 * @param[in,out] set Context and result set at the same time.
5158 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005159 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005160 */
5161static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005162xpath_translate(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005163{
5164 uint16_t i, j, new_used;
5165 char *new;
Radek Krejci857189e2020-09-01 13:26:36 +02005166 ly_bool have_removed;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005167 struct lysc_node_leaf *sleaf;
5168 LY_ERR rc = LY_SUCCESS;
5169
5170 if (options & LYXP_SCNODE_ALL) {
5171 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
5172 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5173 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 +02005174 } else if (!warn_is_string_type(sleaf->type)) {
5175 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005176 }
5177 }
5178
5179 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
5180 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5181 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 +02005182 } else if (!warn_is_string_type(sleaf->type)) {
5183 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005184 }
5185 }
5186
5187 if ((args[2]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[2]))) {
5188 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5189 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 +02005190 } else if (!warn_is_string_type(sleaf->type)) {
5191 LOGWRN(set->ctx, "Argument #3 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005192 }
5193 }
5194 set_scnode_clear_ctx(set);
5195 return rc;
5196 }
5197
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005198 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005199 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005200 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005201 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005202 rc = lyxp_set_cast(args[2], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005203 LY_CHECK_RET(rc);
5204
5205 new = malloc((strlen(args[0]->val.str) + 1) * sizeof(char));
5206 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
5207 new_used = 0;
5208
5209 have_removed = 0;
5210 for (i = 0; args[0]->val.str[i]; ++i) {
Radek Krejci857189e2020-09-01 13:26:36 +02005211 ly_bool found = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005212
5213 for (j = 0; args[1]->val.str[j]; ++j) {
5214 if (args[0]->val.str[i] == args[1]->val.str[j]) {
5215 /* removing this char */
5216 if (j >= strlen(args[2]->val.str)) {
5217 have_removed = 1;
5218 found = 1;
5219 break;
5220 }
5221 /* replacing this char */
5222 new[new_used] = args[2]->val.str[j];
5223 ++new_used;
5224 found = 1;
5225 break;
5226 }
5227 }
5228
5229 /* copying this char */
5230 if (!found) {
5231 new[new_used] = args[0]->val.str[i];
5232 ++new_used;
5233 }
5234 }
5235
5236 if (have_removed) {
5237 new = ly_realloc(new, (new_used + 1) * sizeof(char));
5238 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
5239 }
5240 new[new_used] = '\0';
5241
Michal Vaskod3678892020-05-21 10:06:58 +02005242 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005243 set->type = LYXP_SET_STRING;
5244 set->val.str = new;
5245
5246 return LY_SUCCESS;
5247}
5248
5249/**
5250 * @brief Execute the XPath true() function. Returns LYXP_SET_BOOLEAN
5251 * with true value.
5252 *
5253 * @param[in] args Array of arguments.
5254 * @param[in] arg_count Count of elements in @p args.
5255 * @param[in,out] set Context and result set at the same time.
5256 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005257 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005258 */
5259static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005260xpath_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 +02005261{
5262 if (options & LYXP_SCNODE_ALL) {
5263 set_scnode_clear_ctx(set);
5264 return LY_SUCCESS;
5265 }
5266
5267 set_fill_boolean(set, 1);
5268 return LY_SUCCESS;
5269}
5270
5271/*
5272 * moveto functions
5273 *
5274 * They and only they actually change the context (set).
5275 */
5276
5277/**
Michal Vasko6346ece2019-09-24 13:12:53 +02005278 * @brief Skip prefix and return corresponding model if there is a prefix. Logs directly.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005279 *
Michal Vasko2104e9f2020-03-06 08:23:25 +01005280 * XPath @p set is expected to be a (sc)node set!
5281 *
Michal Vasko6346ece2019-09-24 13:12:53 +02005282 * @param[in,out] qname Qualified node name. If includes prefix, it is skipped.
5283 * @param[in,out] qname_len Length of @p qname, is updated accordingly.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005284 * @param[in] set Set with general XPath context.
5285 * @param[in] ctx_scnode Context node to inherit module for unprefixed node for ::LY_PREF_JSON.
Michal Vasko6346ece2019-09-24 13:12:53 +02005286 * @param[out] moveto_mod Expected module of a matching node.
5287 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005288 */
Michal Vasko6346ece2019-09-24 13:12:53 +02005289static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005290moveto_resolve_model(const char **qname, uint16_t *qname_len, const struct lyxp_set *set,
5291 const struct lysc_node *ctx_scnode, const struct lys_module **moveto_mod)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005292{
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02005293 const struct lys_module *mod = NULL;
Michal Vasko6346ece2019-09-24 13:12:53 +02005294 const char *ptr;
Radek Krejci1deb5be2020-08-26 16:43:36 +02005295 size_t pref_len;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005296
Michal Vasko2104e9f2020-03-06 08:23:25 +01005297 assert((set->type == LYXP_SET_NODE_SET) || (set->type == LYXP_SET_SCNODE_SET));
5298
Michal Vasko6346ece2019-09-24 13:12:53 +02005299 if ((ptr = ly_strnchr(*qname, ':', *qname_len))) {
5300 /* specific module */
5301 pref_len = ptr - *qname;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005302 mod = ly_resolve_prefix(set->ctx, *qname, pref_len, set->format, set->prefix_data);
Michal Vasko6346ece2019-09-24 13:12:53 +02005303
Michal Vasko004d3152020-06-11 19:59:22 +02005304 /* check for errors and non-implemented modules, as they are not valid */
Juraj Vijtiukd75faa62019-11-26 14:10:10 +01005305 if (!mod || !mod->implemented) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005306 LOGVAL(set->ctx, LY_VCODE_XP_INMOD, pref_len, *qname);
Michal Vasko6346ece2019-09-24 13:12:53 +02005307 return LY_EVALID;
5308 }
Juraj Vijtiukd75faa62019-11-26 14:10:10 +01005309
Michal Vasko6346ece2019-09-24 13:12:53 +02005310 *qname += pref_len + 1;
5311 *qname_len -= pref_len + 1;
5312 } else if (((*qname)[0] == '*') && (*qname_len == 1)) {
5313 /* all modules - special case */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005314 mod = NULL;
Michal Vasko6346ece2019-09-24 13:12:53 +02005315 } else {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005316 switch (set->format) {
5317 case LY_PREF_SCHEMA:
5318 case LY_PREF_SCHEMA_RESOLVED:
5319 /* current module */
5320 mod = set->cur_mod;
5321 break;
5322 case LY_PREF_JSON:
5323 /* inherit parent (context node) module */
5324 if (ctx_scnode) {
5325 mod = ctx_scnode->module;
5326 } else {
5327 mod = NULL;
5328 }
5329 break;
5330 case LY_PREF_XML:
5331 /* not defined */
5332 LOGINT_RET(set->ctx);
5333 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005334 }
5335
Michal Vasko6346ece2019-09-24 13:12:53 +02005336 *moveto_mod = mod;
5337 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005338}
5339
5340/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02005341 * @brief Move context @p set to the root. Handles absolute path.
5342 * Result is LYXP_SET_NODE_SET.
5343 *
5344 * @param[in,out] set Set to use.
5345 * @param[in] options Xpath options.
Michal Vaskob0099a92020-08-31 14:55:23 +02005346 * @return LY_ERR value.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005347 */
Michal Vaskob0099a92020-08-31 14:55:23 +02005348static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005349moveto_root(struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005350{
Michal Vasko03ff5a72019-09-11 13:49:33 +02005351 if (!set) {
Michal Vaskob0099a92020-08-31 14:55:23 +02005352 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005353 }
5354
5355 if (options & LYXP_SCNODE_ALL) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005356 set_scnode_clear_ctx(set);
Michal Vaskob0099a92020-08-31 14:55:23 +02005357 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, NULL, set->root_type, NULL));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005358 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02005359 set->type = LYXP_SET_NODE_SET;
5360 set->used = 0;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005361 set_insert_node(set, NULL, 0, set->root_type, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005362 }
Michal Vaskob0099a92020-08-31 14:55:23 +02005363
5364 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005365}
5366
5367/**
5368 * @brief Check @p node as a part of NameTest processing.
5369 *
5370 * @param[in] node Node to check.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005371 * @param[in] ctx_node Context node.
5372 * @param[in] set Set to read general context from.
Michal Vaskod3678892020-05-21 10:06:58 +02005373 * @param[in] node_name Node name in the dictionary to move to, NULL for any node.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005374 * @param[in] moveto_mod Expected module of the node, NULL for no prefix.
Michal Vaskocdad7122020-11-09 21:04:44 +01005375 * @param[in] options XPath options.
Michal Vasko6346ece2019-09-24 13:12:53 +02005376 * @return LY_ERR (LY_ENOT if node does not match, LY_EINCOMPLETE on unresolved when,
5377 * LY_EINVAL if netither node nor any children match)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005378 */
5379static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005380moveto_node_check(const struct lyd_node *node, const struct lyd_node *ctx_node, const struct lyxp_set *set,
Michal Vaskocdad7122020-11-09 21:04:44 +01005381 const char *node_name, const struct lys_module *moveto_mod, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005382{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005383 if (!moveto_mod && (!node_name || strcmp(node_name, "*"))) {
5384 switch (set->format) {
5385 case LY_PREF_SCHEMA:
5386 case LY_PREF_SCHEMA_RESOLVED:
5387 /* use current module */
5388 moveto_mod = set->cur_mod;
5389 break;
5390 case LY_PREF_JSON:
5391 /* inherit module of the context node, if any */
5392 if (ctx_node) {
5393 moveto_mod = ctx_node->schema->module;
5394 }
5395 break;
5396 case LY_PREF_XML:
5397 /* not defined */
5398 LOGINT(set->ctx);
5399 return LY_EINVAL;
5400 }
5401 }
5402
Michal Vasko03ff5a72019-09-11 13:49:33 +02005403 /* module check */
5404 if (moveto_mod && (node->schema->module != moveto_mod)) {
Michal Vasko6346ece2019-09-24 13:12:53 +02005405 return LY_ENOT;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005406 }
5407
Michal Vasko5c4e5892019-11-14 12:31:38 +01005408 /* context check */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005409 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (node->schema->flags & LYS_CONFIG_R)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005410 return LY_EINVAL;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005411 } else if (set->context_op && (node->schema->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) &&
5412 (node->schema != set->context_op)) {
Michal Vasko6b26e742020-07-17 15:02:10 +02005413 return LY_EINVAL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005414 }
5415
5416 /* name check */
Michal Vasko61ac2f62020-05-25 12:39:51 +02005417 if (node_name && strcmp(node_name, "*") && (node->schema->name != node_name)) {
Michal Vasko6346ece2019-09-24 13:12:53 +02005418 return LY_ENOT;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005419 }
5420
Michal Vaskoa1424542019-11-14 16:08:52 +01005421 /* when check */
Michal Vaskod5cfa6e2020-11-23 16:56:08 +01005422 if (!(options & LYXP_IGNORE_WHEN) && lysc_has_when(node->schema) && !(node->flags & LYD_WHEN_TRUE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005423 return LY_EINCOMPLETE;
Michal Vaskoa1424542019-11-14 16:08:52 +01005424 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005425
5426 /* match */
5427 return LY_SUCCESS;
5428}
5429
5430/**
5431 * @brief Check @p node as a part of schema NameTest processing.
5432 *
5433 * @param[in] node Schema node to check.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005434 * @param[in] ctx_scnode Context node.
5435 * @param[in] set Set to read general context from.
Michal Vaskod3678892020-05-21 10:06:58 +02005436 * @param[in] node_name Node name in the dictionary to move to, NULL for any nodes.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005437 * @param[in] moveto_mod Expected module of the node, NULL for no prefix.
Michal Vasko6346ece2019-09-24 13:12:53 +02005438 * @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 +02005439 */
5440static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005441moveto_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 +02005442 const char *node_name, const struct lys_module *moveto_mod)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005443{
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005444 if (!moveto_mod && (!node_name || strcmp(node_name, "*"))) {
5445 switch (set->format) {
5446 case LY_PREF_SCHEMA:
5447 case LY_PREF_SCHEMA_RESOLVED:
5448 /* use current module */
5449 moveto_mod = set->cur_mod;
5450 break;
5451 case LY_PREF_JSON:
5452 /* inherit module of the context node, if any */
5453 if (ctx_scnode) {
5454 moveto_mod = ctx_scnode->module;
5455 }
5456 break;
5457 case LY_PREF_XML:
5458 /* not defined */
5459 LOGINT(set->ctx);
5460 return LY_EINVAL;
5461 }
5462 }
5463
Michal Vasko03ff5a72019-09-11 13:49:33 +02005464 /* module check */
Michal Vaskod3678892020-05-21 10:06:58 +02005465 if (moveto_mod && (node->module != moveto_mod)) {
Michal Vasko6346ece2019-09-24 13:12:53 +02005466 return LY_ENOT;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005467 }
5468
5469 /* context check */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005470 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (node->flags & LYS_CONFIG_R)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005471 return LY_EINVAL;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005472 } else if (set->context_op && (node->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) && (node != set->context_op)) {
Michal Vasko6b26e742020-07-17 15:02:10 +02005473 return LY_EINVAL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005474 }
5475
5476 /* name check */
Michal Vasko61ac2f62020-05-25 12:39:51 +02005477 if (node_name && strcmp(node_name, "*") && (node->name != node_name)) {
Michal Vasko6346ece2019-09-24 13:12:53 +02005478 return LY_ENOT;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005479 }
5480
5481 /* match */
5482 return LY_SUCCESS;
5483}
5484
5485/**
Michal Vaskod3678892020-05-21 10:06:58 +02005486 * @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 +02005487 *
5488 * @param[in,out] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005489 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02005490 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vaskocdad7122020-11-09 21:04:44 +01005491 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005492 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
5493 */
5494static LY_ERR
Michal Vaskocdad7122020-11-09 21:04:44 +01005495moveto_node(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005496{
Michal Vaskof03ed032020-03-04 13:31:44 +01005497 uint32_t i;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005498 const struct lyd_node *siblings, *sub, *ctx_node;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005499 LY_ERR rc;
5500
Michal Vaskod3678892020-05-21 10:06:58 +02005501 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005502 return LY_SUCCESS;
5503 }
5504
5505 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005506 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005507 return LY_EVALID;
5508 }
5509
Michal Vasko03ff5a72019-09-11 13:49:33 +02005510 for (i = 0; i < set->used; ) {
Radek Krejci857189e2020-09-01 13:26:36 +02005511 ly_bool replaced = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005512
5513 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 +01005514 assert(!set->val.nodes[i].node);
Michal Vaskod3678892020-05-21 10:06:58 +02005515
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005516 /* search in all the trees */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005517 ctx_node = NULL;
Michal Vaskod3678892020-05-21 10:06:58 +02005518 siblings = set->tree;
Michal Vasko5bfd4be2020-06-23 13:26:19 +02005519 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02005520 /* search in children */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005521 ctx_node = set->val.nodes[i].node;
5522 siblings = lyd_child(ctx_node);
Michal Vaskod3678892020-05-21 10:06:58 +02005523 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005524
Michal Vaskod3678892020-05-21 10:06:58 +02005525 for (sub = siblings; sub; sub = sub->next) {
Michal Vaskocdad7122020-11-09 21:04:44 +01005526 rc = moveto_node_check(sub, ctx_node, set, ncname, moveto_mod, options);
Michal Vaskod3678892020-05-21 10:06:58 +02005527 if (rc == LY_SUCCESS) {
5528 if (!replaced) {
5529 set_replace_node(set, sub, 0, LYXP_NODE_ELEM, i);
5530 replaced = 1;
5531 } else {
5532 set_insert_node(set, sub, 0, LYXP_NODE_ELEM, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005533 }
Michal Vaskod3678892020-05-21 10:06:58 +02005534 ++i;
5535 } else if (rc == LY_EINCOMPLETE) {
5536 return rc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005537 }
5538 }
5539
5540 if (!replaced) {
5541 /* no match */
5542 set_remove_node(set, i);
5543 }
5544 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005545
5546 return LY_SUCCESS;
5547}
5548
5549/**
Michal Vaskod3678892020-05-21 10:06:58 +02005550 * @brief Move context @p set to a node using hashes. Result is LYXP_SET_NODE_SET (or LYXP_SET_EMPTY).
5551 * Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005552 *
5553 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02005554 * @param[in] scnode Matching node schema.
Michal Vasko004d3152020-06-11 19:59:22 +02005555 * @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 +01005556 * @param[in] options XPath options.
Michal Vaskod3678892020-05-21 10:06:58 +02005557 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
5558 */
5559static LY_ERR
Michal Vaskocdad7122020-11-09 21:04:44 +01005560moveto_node_hash(struct lyxp_set *set, const struct lysc_node *scnode, const struct ly_path_predicate *predicates,
5561 uint32_t options)
Michal Vaskod3678892020-05-21 10:06:58 +02005562{
Michal Vasko004d3152020-06-11 19:59:22 +02005563 LY_ERR ret = LY_SUCCESS;
Michal Vaskod3678892020-05-21 10:06:58 +02005564 uint32_t i;
Michal Vaskod3678892020-05-21 10:06:58 +02005565 const struct lyd_node *siblings;
Michal Vasko004d3152020-06-11 19:59:22 +02005566 struct lyd_node *sub, *inst = NULL;
Michal Vaskod3678892020-05-21 10:06:58 +02005567
Michal Vasko004d3152020-06-11 19:59:22 +02005568 assert(scnode && (!(scnode->nodetype & (LYS_LIST | LYS_LEAFLIST)) || predicates));
Michal Vaskod3678892020-05-21 10:06:58 +02005569
5570 if (!set) {
Michal Vasko004d3152020-06-11 19:59:22 +02005571 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02005572 }
5573
5574 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005575 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko004d3152020-06-11 19:59:22 +02005576 ret = LY_EVALID;
5577 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02005578 }
5579
5580 /* context check for all the nodes since we have the schema node */
5581 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (scnode->flags & LYS_CONFIG_R)) {
5582 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02005583 goto cleanup;
Michal Vasko69730152020-10-09 16:30:07 +02005584 } else if (set->context_op && (scnode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) &&
5585 (scnode != set->context_op)) {
Michal Vasko6b26e742020-07-17 15:02:10 +02005586 lyxp_set_free_content(set);
5587 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +02005588 }
5589
5590 /* create specific data instance if needed */
5591 if (scnode->nodetype == LYS_LIST) {
5592 LY_CHECK_GOTO(ret = lyd_create_list(scnode, predicates, &inst), cleanup);
5593 } else if (scnode->nodetype == LYS_LEAFLIST) {
5594 LY_CHECK_GOTO(ret = lyd_create_term2(scnode, &predicates[0].value, &inst), cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02005595 }
5596
5597 for (i = 0; i < set->used; ) {
Michal Vaskod3678892020-05-21 10:06:58 +02005598 siblings = NULL;
5599
5600 if ((set->val.nodes[i].type == LYXP_NODE_ROOT_CONFIG) || (set->val.nodes[i].type == LYXP_NODE_ROOT)) {
5601 assert(!set->val.nodes[i].node);
5602
5603 /* search in all the trees */
5604 siblings = set->tree;
5605 } else if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
5606 /* search in children */
Radek Krejcia1c1e542020-09-29 16:06:52 +02005607 siblings = lyd_child(set->val.nodes[i].node);
Michal Vaskod3678892020-05-21 10:06:58 +02005608 }
5609
5610 /* find the node using hashes */
Michal Vasko004d3152020-06-11 19:59:22 +02005611 if (inst) {
5612 lyd_find_sibling_first(siblings, inst, &sub);
Michal Vaskod3678892020-05-21 10:06:58 +02005613 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02005614 lyd_find_sibling_val(siblings, scnode, NULL, 0, &sub);
Michal Vaskod3678892020-05-21 10:06:58 +02005615 }
5616
5617 /* when check */
Michal Vaskod5cfa6e2020-11-23 16:56:08 +01005618 if (!(options & LYXP_IGNORE_WHEN) && sub && lysc_has_when(sub->schema) && !(sub->flags & LYD_WHEN_TRUE)) {
Michal Vasko004d3152020-06-11 19:59:22 +02005619 ret = LY_EINCOMPLETE;
5620 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02005621 }
5622
5623 if (sub) {
5624 /* pos filled later */
Michal Vaskocb1b7c02020-07-03 13:38:12 +02005625 set_replace_node(set, sub, 0, LYXP_NODE_ELEM, i);
Michal Vaskod3678892020-05-21 10:06:58 +02005626 ++i;
Michal Vaskocb1b7c02020-07-03 13:38:12 +02005627 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02005628 /* no match */
5629 set_remove_node(set, i);
5630 }
5631 }
5632
Michal Vasko004d3152020-06-11 19:59:22 +02005633cleanup:
5634 lyd_free_tree(inst);
5635 return ret;
Michal Vaskod3678892020-05-21 10:06:58 +02005636}
5637
5638/**
5639 * @brief Move context @p set to a schema node. Result is LYXP_SET_SCNODE_SET (or LYXP_SET_EMPTY).
5640 *
5641 * @param[in,out] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005642 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02005643 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005644 * @param[in] options XPath options.
5645 * @return LY_ERR
5646 */
5647static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005648moveto_scnode(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005649{
Radek Krejci857189e2020-09-01 13:26:36 +02005650 ly_bool temp_ctx = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02005651 uint32_t getnext_opts;
5652 uint32_t orig_used, i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005653 uint32_t mod_idx;
Michal Vasko519fd602020-05-26 12:17:39 +02005654 const struct lysc_node *iter, *start_parent;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005655 const struct lys_module *mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005656
Michal Vaskod3678892020-05-21 10:06:58 +02005657 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005658 return LY_SUCCESS;
5659 }
5660
5661 if (set->type != LYXP_SET_SCNODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005662 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005663 return LY_EVALID;
5664 }
5665
Michal Vaskocafad9d2019-11-07 15:20:03 +01005666 /* getnext opts */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01005667 getnext_opts = 0;
Michal Vaskocafad9d2019-11-07 15:20:03 +01005668 if (options & LYXP_SCNODE_OUTPUT) {
5669 getnext_opts |= LYS_GETNEXT_OUTPUT;
5670 }
5671
Michal Vasko03ff5a72019-09-11 13:49:33 +02005672 orig_used = set->used;
5673 for (i = 0; i < orig_used; ++i) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005674 uint32_t idx;
5675
Radek Krejcif13b87b2020-12-01 22:02:17 +01005676 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
5677 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01005678 continue;
5679 }
5680
5681 /* remember context node */
Radek Krejcif13b87b2020-12-01 22:02:17 +01005682 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vaskoec4df482019-12-16 10:02:18 +01005683 } else {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005684 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005685 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005686
5687 start_parent = set->val.scnodes[i].scnode;
5688
5689 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 +02005690 /* 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 +02005691 * it can be in a top-level augment (the root node itself is useless in this case) */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005692 mod_idx = 0;
Michal Vasko9e9f26d2020-10-12 16:31:33 +02005693 while ((mod = (struct lys_module *)ly_ctx_get_module_iter(set->ctx, &mod_idx))) {
Michal Vasko519fd602020-05-26 12:17:39 +02005694 iter = NULL;
Michal Vasko509de4d2019-12-10 14:51:30 +01005695 /* module may not be implemented */
Michal Vasko519fd602020-05-26 12:17:39 +02005696 while (mod->implemented && (iter = lys_getnext(iter, NULL, mod->compiled, getnext_opts))) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005697 if (!moveto_scnode_check(iter, NULL, set, ncname, moveto_mod)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005698 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, iter, LYXP_NODE_ELEM, &idx));
5699
Michal Vasko03ff5a72019-09-11 13:49:33 +02005700 /* we need to prevent these nodes from being considered in this moveto */
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005701 if ((idx < orig_used) && (idx > i)) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005702 set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_NEW_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005703 temp_ctx = 1;
5704 }
5705 }
5706 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005707 }
5708
Michal Vasko519fd602020-05-26 12:17:39 +02005709 } else if (set->val.scnodes[i].type == LYXP_NODE_ELEM) {
5710 iter = NULL;
5711 while ((iter = lys_getnext(iter, start_parent, NULL, getnext_opts))) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005712 if (!moveto_scnode_check(iter, start_parent, set, ncname, moveto_mod)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005713 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, iter, LYXP_NODE_ELEM, &idx));
5714
5715 if ((idx < orig_used) && (idx > i)) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005716 set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_NEW_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005717 temp_ctx = 1;
5718 }
5719 }
5720 }
5721 }
5722 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005723
5724 /* correct temporary in_ctx values */
5725 if (temp_ctx) {
5726 for (i = 0; i < orig_used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005727 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_NEW_CTX) {
5728 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005729 }
5730 }
5731 }
5732
5733 return LY_SUCCESS;
5734}
5735
5736/**
Michal Vaskod3678892020-05-21 10:06:58 +02005737 * @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 +02005738 * Context position aware.
5739 *
5740 * @param[in] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005741 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02005742 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vaskocdad7122020-11-09 21:04:44 +01005743 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005744 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
5745 */
5746static LY_ERR
Michal Vaskocdad7122020-11-09 21:04:44 +01005747moveto_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 +02005748{
5749 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005750 const struct lyd_node *next, *elem, *start;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005751 struct lyxp_set ret_set;
5752 LY_ERR rc;
5753
Michal Vaskod3678892020-05-21 10:06:58 +02005754 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005755 return LY_SUCCESS;
5756 }
5757
5758 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005759 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005760 return LY_EVALID;
5761 }
5762
Michal Vasko9f96a052020-03-10 09:41:45 +01005763 /* 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 +01005764 rc = moveto_node(set, NULL, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005765 LY_CHECK_RET(rc);
5766
Michal Vasko6346ece2019-09-24 13:12:53 +02005767 /* this loop traverses all the nodes in the set and adds/keeps only those that match qname */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005768 set_init(&ret_set, set);
5769 for (i = 0; i < set->used; ++i) {
5770
5771 /* TREE DFS */
5772 start = set->val.nodes[i].node;
5773 for (elem = next = start; elem; elem = next) {
Michal Vaskocdad7122020-11-09 21:04:44 +01005774 rc = moveto_node_check(elem, start, set, ncname, moveto_mod, options);
Michal Vasko6346ece2019-09-24 13:12:53 +02005775 if (!rc) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005776 /* add matching node into result set */
5777 set_insert_node(&ret_set, elem, 0, LYXP_NODE_ELEM, ret_set.used);
5778 if (set_dup_node_check(set, elem, LYXP_NODE_ELEM, i)) {
5779 /* the node is a duplicate, we'll process it later in the set */
5780 goto skip_children;
5781 }
Michal Vasko6346ece2019-09-24 13:12:53 +02005782 } else if (rc == LY_EINCOMPLETE) {
Michal Vasko6346ece2019-09-24 13:12:53 +02005783 return rc;
5784 } else if (rc == LY_EINVAL) {
5785 goto skip_children;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005786 }
5787
5788 /* TREE DFS NEXT ELEM */
5789 /* select element for the next run - children first */
Radek Krejcia1c1e542020-09-29 16:06:52 +02005790 next = lyd_child(elem);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005791 if (!next) {
5792skip_children:
5793 /* no children, so try siblings, but only if it's not the start,
5794 * that is considered to be the root and it's siblings are not traversed */
5795 if (elem != start) {
5796 next = elem->next;
5797 } else {
5798 break;
5799 }
5800 }
5801 while (!next) {
5802 /* no siblings, go back through the parents */
Michal Vasko9e685082021-01-29 14:49:09 +01005803 if (lyd_parent(elem) == start) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005804 /* we are done, no next element to process */
5805 break;
5806 }
5807 /* parent is already processed, go to its sibling */
Michal Vasko9e685082021-01-29 14:49:09 +01005808 elem = lyd_parent(elem);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005809 next = elem->next;
5810 }
5811 }
5812 }
5813
5814 /* make the temporary set the current one */
5815 ret_set.ctx_pos = set->ctx_pos;
5816 ret_set.ctx_size = set->ctx_size;
Michal Vaskod3678892020-05-21 10:06:58 +02005817 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005818 memcpy(set, &ret_set, sizeof *set);
5819
5820 return LY_SUCCESS;
5821}
5822
5823/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02005824 * @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 +02005825 *
5826 * @param[in] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005827 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02005828 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005829 * @param[in] options XPath options.
5830 * @return LY_ERR
5831 */
5832static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005833moveto_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 +02005834{
Radek Krejci1deb5be2020-08-26 16:43:36 +02005835 uint32_t i, orig_used;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005836 const struct lysc_node *next, *elem, *start;
Michal Vasko6346ece2019-09-24 13:12:53 +02005837 LY_ERR rc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005838
Michal Vaskod3678892020-05-21 10:06:58 +02005839 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005840 return LY_SUCCESS;
5841 }
5842
5843 if (set->type != LYXP_SET_SCNODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005844 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005845 return LY_EVALID;
5846 }
5847
Michal Vasko03ff5a72019-09-11 13:49:33 +02005848 orig_used = set->used;
5849 for (i = 0; i < orig_used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005850 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
5851 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01005852 continue;
5853 }
5854
5855 /* remember context node */
Radek Krejcif13b87b2020-12-01 22:02:17 +01005856 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vaskoec4df482019-12-16 10:02:18 +01005857 } else {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005858 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005859 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005860
5861 /* TREE DFS */
5862 start = set->val.scnodes[i].scnode;
5863 for (elem = next = start; elem; elem = next) {
Michal Vasko6346ece2019-09-24 13:12:53 +02005864 if ((elem == start) || (elem->nodetype & (LYS_CHOICE | LYS_CASE))) {
5865 /* schema-only nodes, skip root */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005866 goto next_iter;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005867 }
5868
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005869 rc = moveto_scnode_check(elem, start, set, ncname, moveto_mod);
Michal Vasko6346ece2019-09-24 13:12:53 +02005870 if (!rc) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005871 uint32_t idx;
5872
5873 if (lyxp_set_scnode_contains(set, elem, LYXP_NODE_ELEM, i, &idx)) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01005874 set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Radek Krejci1deb5be2020-08-26 16:43:36 +02005875 if ((uint32_t)idx > i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005876 /* we will process it later in the set */
5877 goto skip_children;
5878 }
5879 } else {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005880 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, elem, LYXP_NODE_ELEM, NULL));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005881 }
Michal Vasko6346ece2019-09-24 13:12:53 +02005882 } else if (rc == LY_EINVAL) {
5883 goto skip_children;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005884 }
5885
5886next_iter:
5887 /* TREE DFS NEXT ELEM */
5888 /* select element for the next run - children first */
Michal Vasko544e58a2021-01-28 14:33:41 +01005889 next = lysc_node_child(elem);
5890 if (next && (next->nodetype == LYS_INPUT) && (options & LYXP_SCNODE_OUTPUT)) {
5891 next = next->next;
5892 } else if (next && (next->nodetype == LYS_OUTPUT) && !(options & LYXP_SCNODE_OUTPUT)) {
5893 next = next->next;
5894 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005895 if (!next) {
5896skip_children:
5897 /* no children, so try siblings, but only if it's not the start,
5898 * that is considered to be the root and it's siblings are not traversed */
5899 if (elem != start) {
5900 next = elem->next;
5901 } else {
5902 break;
5903 }
5904 }
5905 while (!next) {
5906 /* no siblings, go back through the parents */
5907 if (elem->parent == start) {
5908 /* we are done, no next element to process */
5909 break;
5910 }
5911 /* parent is already processed, go to its sibling */
5912 elem = elem->parent;
5913 next = elem->next;
5914 }
5915 }
5916 }
5917
5918 return LY_SUCCESS;
5919}
5920
5921/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02005922 * @brief Move context @p set to an attribute. Result is LYXP_SET_NODE_SET.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005923 * Indirectly context position aware.
5924 *
5925 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02005926 * @param[in] mod Matching metadata module, NULL for any.
5927 * @param[in] ncname Matching metadata name in the dictionary, NULL for any.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005928 * @return LY_ERR
5929 */
5930static LY_ERR
Michal Vaskod3678892020-05-21 10:06:58 +02005931moveto_attr(struct lyxp_set *set, const struct lys_module *mod, const char *ncname)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005932{
Michal Vasko9f96a052020-03-10 09:41:45 +01005933 struct lyd_meta *sub;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005934
Michal Vaskod3678892020-05-21 10:06:58 +02005935 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005936 return LY_SUCCESS;
5937 }
5938
5939 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005940 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005941 return LY_EVALID;
5942 }
5943
Radek Krejci1deb5be2020-08-26 16:43:36 +02005944 for (uint32_t i = 0; i < set->used; ) {
Radek Krejci857189e2020-09-01 13:26:36 +02005945 ly_bool replaced = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005946
5947 /* only attributes of an elem (not dummy) can be in the result, skip all the rest;
5948 * our attributes are always qualified */
Michal Vasko5c4e5892019-11-14 12:31:38 +01005949 if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko9f96a052020-03-10 09:41:45 +01005950 for (sub = set->val.nodes[i].node->meta; sub; sub = sub->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005951
5952 /* check "namespace" */
Michal Vaskod3678892020-05-21 10:06:58 +02005953 if (mod && (sub->annotation->module != mod)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005954 continue;
5955 }
5956
Michal Vaskod3678892020-05-21 10:06:58 +02005957 if (!ncname || (sub->name == ncname)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005958 /* match */
5959 if (!replaced) {
Michal Vasko9f96a052020-03-10 09:41:45 +01005960 set->val.meta[i].meta = sub;
5961 set->val.meta[i].type = LYXP_NODE_META;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005962 /* pos does not change */
5963 replaced = 1;
5964 } else {
Michal Vasko9f96a052020-03-10 09:41:45 +01005965 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 +02005966 }
5967 ++i;
5968 }
5969 }
5970 }
5971
5972 if (!replaced) {
5973 /* no match */
5974 set_remove_node(set, i);
5975 }
5976 }
5977
5978 return LY_SUCCESS;
5979}
5980
5981/**
5982 * @brief Move context @p set1 to union with @p set2. @p set2 is emptied afterwards.
Michal Vasko61ac2f62020-05-25 12:39:51 +02005983 * Result is LYXP_SET_NODE_SET. Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005984 *
5985 * @param[in,out] set1 Set to use for the result.
5986 * @param[in] set2 Set that is copied to @p set1.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005987 * @return LY_ERR
5988 */
5989static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005990moveto_union(struct lyxp_set *set1, struct lyxp_set *set2)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005991{
5992 LY_ERR rc;
5993
Michal Vaskod3678892020-05-21 10:06:58 +02005994 if ((set1->type != LYXP_SET_NODE_SET) || (set2->type != LYXP_SET_NODE_SET)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01005995 LOGVAL(set1->ctx, LY_VCODE_XP_INOP_2, "union", print_set_type(set1), print_set_type(set2));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005996 return LY_EVALID;
5997 }
5998
5999 /* set2 is empty or both set1 and set2 */
Michal Vaskod3678892020-05-21 10:06:58 +02006000 if (!set2->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006001 return LY_SUCCESS;
6002 }
6003
Michal Vaskod3678892020-05-21 10:06:58 +02006004 if (!set1->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006005 memcpy(set1, set2, sizeof *set1);
6006 /* dynamic memory belongs to set1 now, do not free */
Michal Vaskod3678892020-05-21 10:06:58 +02006007 memset(set2, 0, sizeof *set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006008 return LY_SUCCESS;
6009 }
6010
6011 /* we assume sets are sorted */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006012 assert(!set_sort(set1) && !set_sort(set2));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006013
6014 /* sort, remove duplicates */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006015 rc = set_sorted_merge(set1, set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006016 LY_CHECK_RET(rc);
6017
6018 /* final set must be sorted */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006019 assert(!set_sort(set1));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006020
6021 return LY_SUCCESS;
6022}
6023
6024/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02006025 * @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 +02006026 * Context position aware.
6027 *
6028 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02006029 * @param[in] mod Matching metadata module, NULL for any.
6030 * @param[in] ncname Matching metadata name in the dictionary, NULL for any.
Michal Vaskocdad7122020-11-09 21:04:44 +01006031 * @param[in] options XPath options.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006032 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6033 */
6034static int
Michal Vaskocdad7122020-11-09 21:04:44 +01006035moveto_attr_alldesc(struct lyxp_set *set, const struct lys_module *mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006036{
Michal Vasko9f96a052020-03-10 09:41:45 +01006037 struct lyd_meta *sub;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006038 struct lyxp_set *set_all_desc = NULL;
6039 LY_ERR rc;
6040
Michal Vaskod3678892020-05-21 10:06:58 +02006041 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006042 return LY_SUCCESS;
6043 }
6044
6045 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006046 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006047 return LY_EVALID;
6048 }
6049
Michal Vasko03ff5a72019-09-11 13:49:33 +02006050 /* can be optimized similarly to moveto_node_alldesc() and save considerable amount of memory,
6051 * but it likely won't be used much, so it's a waste of time */
6052 /* copy the context */
6053 set_all_desc = set_copy(set);
6054 /* get all descendant nodes (the original context nodes are removed) */
Michal Vaskocdad7122020-11-09 21:04:44 +01006055 rc = moveto_node_alldesc(set_all_desc, NULL, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006056 if (rc != LY_SUCCESS) {
6057 lyxp_set_free(set_all_desc);
6058 return rc;
6059 }
6060 /* prepend the original context nodes */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006061 rc = moveto_union(set, set_all_desc);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006062 if (rc != LY_SUCCESS) {
6063 lyxp_set_free(set_all_desc);
6064 return rc;
6065 }
6066 lyxp_set_free(set_all_desc);
6067
Radek Krejci1deb5be2020-08-26 16:43:36 +02006068 for (uint32_t i = 0; i < set->used; ) {
Radek Krejci857189e2020-09-01 13:26:36 +02006069 ly_bool replaced = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006070
6071 /* only attributes of an elem can be in the result, skip all the rest,
6072 * we have all attributes qualified in lyd tree */
6073 if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko9f96a052020-03-10 09:41:45 +01006074 for (sub = set->val.nodes[i].node->meta; sub; sub = sub->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006075 /* check "namespace" */
Michal Vaskod3678892020-05-21 10:06:58 +02006076 if (mod && (sub->annotation->module != mod)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006077 continue;
6078 }
6079
Michal Vaskod3678892020-05-21 10:06:58 +02006080 if (!ncname || (sub->name == ncname)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006081 /* match */
6082 if (!replaced) {
Michal Vasko9f96a052020-03-10 09:41:45 +01006083 set->val.meta[i].meta = sub;
6084 set->val.meta[i].type = LYXP_NODE_META;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006085 /* pos does not change */
6086 replaced = 1;
6087 } else {
Michal Vasko9f96a052020-03-10 09:41:45 +01006088 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 +02006089 }
6090 ++i;
6091 }
6092 }
6093 }
6094
6095 if (!replaced) {
6096 /* no match */
6097 set_remove_node(set, i);
6098 }
6099 }
6100
6101 return LY_SUCCESS;
6102}
6103
6104/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02006105 * @brief Move context @p set to self and al chilren, recursively. Handles '/' or '//' and '.'. Result is LYXP_SET_NODE_SET.
6106 * Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006107 *
6108 * @param[in] parent Current parent.
6109 * @param[in] parent_pos Position of @p parent.
6110 * @param[in] parent_type Node type of @p parent.
6111 * @param[in,out] to_set Set to use.
6112 * @param[in] dup_check_set Set for checking duplicities.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006113 * @param[in] options XPath options.
6114 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6115 */
6116static LY_ERR
6117moveto_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 +02006118 struct lyxp_set *to_set, const struct lyxp_set *dup_check_set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006119{
Michal Vasko61ac2f62020-05-25 12:39:51 +02006120 const struct lyd_node *iter, *first;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006121 LY_ERR rc;
6122
6123 switch (parent_type) {
6124 case LYXP_NODE_ROOT:
6125 case LYXP_NODE_ROOT_CONFIG:
Michal Vasko61ac2f62020-05-25 12:39:51 +02006126 assert(!parent);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006127
Michal Vasko61ac2f62020-05-25 12:39:51 +02006128 /* add all top-level nodes as elements */
6129 first = to_set->tree;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006130 break;
6131 case LYXP_NODE_ELEM:
Michal Vasko61ac2f62020-05-25 12:39:51 +02006132 /* add just the text node of this term element node */
6133 if (parent->schema->nodetype & (LYD_NODE_TERM | LYD_NODE_ANY)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006134 if (!set_dup_node_check(dup_check_set, parent, LYXP_NODE_TEXT, -1)) {
6135 set_insert_node(to_set, parent, parent_pos, LYXP_NODE_TEXT, to_set->used);
6136 }
Michal Vasko61ac2f62020-05-25 12:39:51 +02006137 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006138 }
Michal Vasko61ac2f62020-05-25 12:39:51 +02006139
6140 /* add all the children of this node */
Radek Krejcia1c1e542020-09-29 16:06:52 +02006141 first = lyd_child(parent);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006142 break;
6143 default:
6144 LOGINT_RET(parent->schema->module->ctx);
6145 }
6146
Michal Vasko61ac2f62020-05-25 12:39:51 +02006147 /* add all top-level nodes as elements */
6148 LY_LIST_FOR(first, iter) {
6149 /* context check */
6150 if ((parent_type == LYXP_NODE_ROOT_CONFIG) && (iter->schema->flags & LYS_CONFIG_R)) {
6151 continue;
6152 }
6153
6154 /* when check */
Michal Vaskod5cfa6e2020-11-23 16:56:08 +01006155 if (!(options & LYXP_IGNORE_WHEN) && lysc_has_when(iter->schema) && !(iter->flags & LYD_WHEN_TRUE)) {
Michal Vasko61ac2f62020-05-25 12:39:51 +02006156 return LY_EINCOMPLETE;
6157 }
6158
6159 if (!set_dup_node_check(dup_check_set, iter, LYXP_NODE_ELEM, -1)) {
6160 set_insert_node(to_set, iter, 0, LYXP_NODE_ELEM, to_set->used);
6161
6162 /* also add all the children of this node, recursively */
6163 rc = moveto_self_add_children_r(iter, 0, LYXP_NODE_ELEM, to_set, dup_check_set, options);
6164 LY_CHECK_RET(rc);
6165 }
6166 }
6167
Michal Vasko03ff5a72019-09-11 13:49:33 +02006168 return LY_SUCCESS;
6169}
6170
6171/**
6172 * @brief Move context @p set to self. Handles '/' or '//' and '.'. Result is LYXP_SET_NODE_SET
6173 * (or LYXP_SET_EMPTY). Context position aware.
6174 *
6175 * @param[in,out] set Set to use.
6176 * @param[in] all_desc Whether to go to all descendants ('//') or not ('/').
6177 * @param[in] options XPath options.
6178 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6179 */
6180static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02006181moveto_self(struct lyxp_set *set, ly_bool all_desc, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006182{
Michal Vasko03ff5a72019-09-11 13:49:33 +02006183 struct lyxp_set ret_set;
6184 LY_ERR rc;
6185
Michal Vaskod3678892020-05-21 10:06:58 +02006186 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006187 return LY_SUCCESS;
6188 }
6189
6190 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006191 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006192 return LY_EVALID;
6193 }
6194
6195 /* nothing to do */
6196 if (!all_desc) {
6197 return LY_SUCCESS;
6198 }
6199
Michal Vasko03ff5a72019-09-11 13:49:33 +02006200 /* add all the children, they get added recursively */
6201 set_init(&ret_set, set);
Radek Krejci1deb5be2020-08-26 16:43:36 +02006202 for (uint32_t i = 0; i < set->used; ++i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006203 /* copy the current node to tmp */
6204 set_insert_node(&ret_set, set->val.nodes[i].node, set->val.nodes[i].pos, set->val.nodes[i].type, ret_set.used);
6205
6206 /* do not touch attributes and text nodes */
Michal Vasko9f96a052020-03-10 09:41:45 +01006207 if ((set->val.nodes[i].type == LYXP_NODE_TEXT) || (set->val.nodes[i].type == LYXP_NODE_META)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006208 continue;
6209 }
6210
Michal Vasko03ff5a72019-09-11 13:49:33 +02006211 /* add all the children */
6212 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 +02006213 set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006214 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02006215 lyxp_set_free_content(&ret_set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006216 return rc;
6217 }
6218 }
6219
6220 /* use the temporary set as the current one */
6221 ret_set.ctx_pos = set->ctx_pos;
6222 ret_set.ctx_size = set->ctx_size;
Michal Vaskod3678892020-05-21 10:06:58 +02006223 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006224 memcpy(set, &ret_set, sizeof *set);
6225
6226 return LY_SUCCESS;
6227}
6228
6229/**
6230 * @brief Move context schema @p set to self. Handles '/' or '//' and '.'. Result is LYXP_SET_SCNODE_SET
6231 * (or LYXP_SET_EMPTY).
6232 *
6233 * @param[in,out] set Set to use.
6234 * @param[in] all_desc Whether to go to all descendants ('//') or not ('/').
6235 * @param[in] options XPath options.
6236 * @return LY_ERR
6237 */
6238static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02006239moveto_scnode_self(struct lyxp_set *set, ly_bool all_desc, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006240{
Radek Krejci1deb5be2020-08-26 16:43:36 +02006241 uint32_t getnext_opts;
6242 uint32_t mod_idx;
Michal Vasko519fd602020-05-26 12:17:39 +02006243 const struct lysc_node *iter, *start_parent;
6244 const struct lys_module *mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006245
Michal Vaskod3678892020-05-21 10:06:58 +02006246 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006247 return LY_SUCCESS;
6248 }
6249
6250 if (set->type != LYXP_SET_SCNODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006251 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006252 return LY_EVALID;
6253 }
6254
Michal Vasko519fd602020-05-26 12:17:39 +02006255 /* getnext opts */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01006256 getnext_opts = 0;
Michal Vasko519fd602020-05-26 12:17:39 +02006257 if (options & LYXP_SCNODE_OUTPUT) {
6258 getnext_opts |= LYS_GETNEXT_OUTPUT;
6259 }
6260
6261 /* add all the children, recursively as they are being added into the same set */
Radek Krejci1deb5be2020-08-26 16:43:36 +02006262 for (uint32_t i = 0; i < set->used; ++i) {
Michal Vaskoe657f962020-12-10 12:19:48 +01006263 if (!all_desc) {
6264 /* traverse the start node */
6265 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_START) {
6266 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
6267 }
6268 continue;
6269 }
6270
Radek Krejcif13b87b2020-12-01 22:02:17 +01006271 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
6272 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01006273 continue;
6274 }
6275
Michal Vasko519fd602020-05-26 12:17:39 +02006276 /* remember context node */
Radek Krejcif13b87b2020-12-01 22:02:17 +01006277 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vasko519fd602020-05-26 12:17:39 +02006278 } else {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006279 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006280 }
6281
Michal Vasko519fd602020-05-26 12:17:39 +02006282 start_parent = set->val.scnodes[i].scnode;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006283
Michal Vasko519fd602020-05-26 12:17:39 +02006284 if ((set->val.scnodes[i].type == LYXP_NODE_ROOT_CONFIG) || (set->val.scnodes[i].type == LYXP_NODE_ROOT)) {
6285 /* it can actually be in any module, it's all <running> */
6286 mod_idx = 0;
6287 while ((mod = (struct lys_module *)ly_ctx_get_module_iter(set->ctx, &mod_idx))) {
6288 iter = NULL;
6289 /* module may not be implemented */
6290 while (mod->implemented && (iter = lys_getnext(iter, NULL, mod->compiled, getnext_opts))) {
6291 /* context check */
6292 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (iter->flags & LYS_CONFIG_R)) {
6293 continue;
6294 }
6295
Radek Krejciaa6b53f2020-08-27 15:19:03 +02006296 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, iter, LYXP_NODE_ELEM, NULL));
Michal Vasko519fd602020-05-26 12:17:39 +02006297 /* throw away the insert index, we want to consider that node again, recursively */
6298 }
6299 }
6300
6301 } else if (set->val.scnodes[i].type == LYXP_NODE_ELEM) {
6302 iter = NULL;
6303 while ((iter = lys_getnext(iter, start_parent, NULL, getnext_opts))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006304 /* context check */
Michal Vasko519fd602020-05-26 12:17:39 +02006305 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (iter->flags & LYS_CONFIG_R)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006306 continue;
6307 }
6308
Radek Krejciaa6b53f2020-08-27 15:19:03 +02006309 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, iter, LYXP_NODE_ELEM, NULL));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006310 }
6311 }
6312 }
6313
6314 return LY_SUCCESS;
6315}
6316
6317/**
6318 * @brief Move context @p set to parent. Handles '/' or '//' and '..'. Result is LYXP_SET_NODE_SET
6319 * (or LYXP_SET_EMPTY). Context position aware.
6320 *
6321 * @param[in] set Set to use.
6322 * @param[in] all_desc Whether to go to all descendants ('//') or not ('/').
6323 * @param[in] options XPath options.
6324 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6325 */
6326static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02006327moveto_parent(struct lyxp_set *set, ly_bool all_desc, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006328{
6329 LY_ERR rc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006330 struct lyd_node *node, *new_node;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006331 enum lyxp_node_type new_type;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006332
Michal Vaskod3678892020-05-21 10:06:58 +02006333 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006334 return LY_SUCCESS;
6335 }
6336
6337 if (set->type != LYXP_SET_NODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006338 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006339 return LY_EVALID;
6340 }
6341
6342 if (all_desc) {
6343 /* <path>//.. == <path>//./.. */
6344 rc = moveto_self(set, 1, options);
6345 LY_CHECK_RET(rc);
6346 }
6347
Radek Krejci1deb5be2020-08-26 16:43:36 +02006348 for (uint32_t i = 0; i < set->used; ++i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006349 node = set->val.nodes[i].node;
6350
6351 if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko9e685082021-01-29 14:49:09 +01006352 new_node = lyd_parent(node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006353 } else if (set->val.nodes[i].type == LYXP_NODE_TEXT) {
6354 new_node = node;
Michal Vasko9f96a052020-03-10 09:41:45 +01006355 } else if (set->val.nodes[i].type == LYXP_NODE_META) {
6356 new_node = set->val.meta[i].meta->parent;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006357 if (!new_node) {
6358 LOGINT_RET(set->ctx);
6359 }
6360 } else {
6361 /* root does not have a parent */
Michal Vasko2caefc12019-11-14 16:07:56 +01006362 set_remove_node_none(set, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006363 continue;
6364 }
6365
Michal Vaskoa1424542019-11-14 16:08:52 +01006366 /* when check */
Michal Vaskod5cfa6e2020-11-23 16:56:08 +01006367 if (!(options & LYXP_IGNORE_WHEN) && new_node && lysc_has_when(new_node->schema) && !(new_node->flags & LYD_WHEN_TRUE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006368 return LY_EINCOMPLETE;
Michal Vaskoa1424542019-11-14 16:08:52 +01006369 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006370
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006371 if (!new_node) {
Radek Krejcif6a11002020-08-21 13:29:07 +02006372 /* node already there can also be the root */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006373 new_type = set->root_type;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006374
Michal Vasko03ff5a72019-09-11 13:49:33 +02006375 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02006376 /* 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 +02006377 new_type = LYXP_NODE_ELEM;
6378 }
6379
Michal Vasko03ff5a72019-09-11 13:49:33 +02006380 if (set_dup_node_check(set, new_node, new_type, -1)) {
Michal Vasko2caefc12019-11-14 16:07:56 +01006381 set_remove_node_none(set, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006382 } else {
6383 set_replace_node(set, new_node, 0, new_type, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006384 }
6385 }
6386
Michal Vasko2caefc12019-11-14 16:07:56 +01006387 set_remove_nodes_none(set);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006388 assert(!set_sort(set) && !set_sorted_dup_node_clean(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006389
6390 return LY_SUCCESS;
6391}
6392
6393/**
6394 * @brief Move context schema @p set to parent. Handles '/' or '//' and '..'. Result is LYXP_SET_SCNODE_SET
6395 * (or LYXP_SET_EMPTY).
6396 *
6397 * @param[in] set Set to use.
6398 * @param[in] all_desc Whether to go to all descendants ('//') or not ('/').
6399 * @param[in] options XPath options.
6400 * @return LY_ERR
6401 */
6402static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02006403moveto_scnode_parent(struct lyxp_set *set, ly_bool all_desc, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006404{
Radek Krejciaa6b53f2020-08-27 15:19:03 +02006405 uint32_t i, orig_used, idx;
Radek Krejci857189e2020-09-01 13:26:36 +02006406 ly_bool temp_ctx = 0;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006407 const struct lysc_node *node, *new_node;
6408 enum lyxp_node_type new_type;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006409
Michal Vaskod3678892020-05-21 10:06:58 +02006410 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006411 return LY_SUCCESS;
6412 }
6413
6414 if (set->type != LYXP_SET_SCNODE_SET) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01006415 LOGVAL(set->ctx, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006416 return LY_EVALID;
6417 }
6418
6419 if (all_desc) {
6420 /* <path>//.. == <path>//./.. */
Radek Krejci1deb5be2020-08-26 16:43:36 +02006421 LY_CHECK_RET(moveto_scnode_self(set, 1, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006422 }
6423
Michal Vasko03ff5a72019-09-11 13:49:33 +02006424 orig_used = set->used;
6425 for (i = 0; i < orig_used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006426 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
6427 if (set->val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01006428 continue;
6429 }
6430
6431 /* remember context node */
Radek Krejcif13b87b2020-12-01 22:02:17 +01006432 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vaskoec4df482019-12-16 10:02:18 +01006433 } else {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006434 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006435 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006436
6437 node = set->val.scnodes[i].scnode;
6438
6439 if (set->val.scnodes[i].type == LYXP_NODE_ELEM) {
Michal Vaskod3678892020-05-21 10:06:58 +02006440 new_node = lysc_data_parent(node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006441 } else {
6442 /* root does not have a parent */
6443 continue;
6444 }
6445
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006446 if (!new_node) {
Radek Krejcif6a11002020-08-21 13:29:07 +02006447 /* node has no parent */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006448 new_type = set->root_type;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006449
Michal Vasko03ff5a72019-09-11 13:49:33 +02006450 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02006451 /* 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 +02006452 new_type = LYXP_NODE_ELEM;
6453 }
6454
Radek Krejciaa6b53f2020-08-27 15:19:03 +02006455 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, new_node, new_type, &idx));
6456 if ((idx < orig_used) && (idx > i)) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006457 set->val.scnodes[idx].in_ctx = LYXP_SET_SCNODE_ATOM_NEW_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006458 temp_ctx = 1;
6459 }
6460 }
6461
6462 if (temp_ctx) {
6463 for (i = 0; i < orig_used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006464 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_NEW_CTX) {
6465 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006466 }
6467 }
6468 }
6469
6470 return LY_SUCCESS;
6471}
6472
6473/**
6474 * @brief Move context @p set to the result of a comparison. Handles '=', '!=', '<=', '<', '>=', or '>'.
6475 * Result is LYXP_SET_BOOLEAN. Indirectly context position aware.
6476 *
6477 * @param[in,out] set1 Set to use for the result.
6478 * @param[in] set2 Set acting as the second operand for @p op.
6479 * @param[in] op Comparison operator to process.
6480 * @param[in] options XPath options.
6481 * @return LY_ERR
6482 */
6483static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02006484moveto_op_comp(struct lyxp_set *set1, struct lyxp_set *set2, const char *op, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006485{
6486 /*
6487 * NODE SET + NODE SET = NODE SET + STRING /(1 NODE SET) 2 STRING
6488 * NODE SET + STRING = STRING + STRING /1 STRING (2 STRING)
6489 * NODE SET + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
6490 * NODE SET + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
6491 * STRING + NODE SET = STRING + STRING /(1 STRING) 2 STRING
6492 * NUMBER + NODE SET = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6493 * BOOLEAN + NODE SET = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
6494 *
6495 * '=' or '!='
6496 * BOOLEAN + BOOLEAN
6497 * BOOLEAN + STRING = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
6498 * BOOLEAN + NUMBER = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
6499 * STRING + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
6500 * NUMBER + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
6501 * NUMBER + NUMBER
6502 * NUMBER + STRING = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6503 * STRING + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
6504 * STRING + STRING
6505 *
6506 * '<=', '<', '>=', '>'
6507 * NUMBER + NUMBER
6508 * BOOLEAN + BOOLEAN = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
6509 * BOOLEAN + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
6510 * BOOLEAN + STRING = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
6511 * NUMBER + STRING = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6512 * STRING + STRING = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
6513 * STRING + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
6514 * NUMBER + BOOLEAN = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6515 * STRING + BOOLEAN = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6516 */
6517 struct lyxp_set iter1, iter2;
6518 int result;
6519 int64_t i;
6520 LY_ERR rc;
6521
Michal Vasko004d3152020-06-11 19:59:22 +02006522 memset(&iter1, 0, sizeof iter1);
6523 memset(&iter2, 0, sizeof iter2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006524
6525 /* iterative evaluation with node-sets */
6526 if ((set1->type == LYXP_SET_NODE_SET) || (set2->type == LYXP_SET_NODE_SET)) {
6527 if (set1->type == LYXP_SET_NODE_SET) {
6528 for (i = 0; i < set1->used; ++i) {
Michal Vasko4c7763f2020-07-27 17:40:37 +02006529 /* cast set1 */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006530 switch (set2->type) {
6531 case LYXP_SET_NUMBER:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006532 rc = set_comp_cast(&iter1, set1, LYXP_SET_NUMBER, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006533 break;
6534 case LYXP_SET_BOOLEAN:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006535 rc = set_comp_cast(&iter1, set1, LYXP_SET_BOOLEAN, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006536 break;
6537 default:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006538 rc = set_comp_cast(&iter1, set1, LYXP_SET_STRING, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006539 break;
6540 }
6541 LY_CHECK_RET(rc);
6542
Michal Vasko4c7763f2020-07-27 17:40:37 +02006543 /* canonize set2 */
6544 LY_CHECK_ERR_RET(rc = set_comp_canonize(&iter2, set2, &set1->val.nodes[i]), lyxp_set_free_content(&iter1), rc);
6545
6546 /* compare recursively */
6547 rc = moveto_op_comp(&iter1, &iter2, op, options);
6548 lyxp_set_free_content(&iter2);
6549 LY_CHECK_ERR_RET(rc, lyxp_set_free_content(&iter1), rc);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006550
6551 /* lazy evaluation until true */
Michal Vasko004d3152020-06-11 19:59:22 +02006552 if (iter1.val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006553 set_fill_boolean(set1, 1);
6554 return LY_SUCCESS;
6555 }
6556 }
6557 } else {
6558 for (i = 0; i < set2->used; ++i) {
Michal Vasko4c7763f2020-07-27 17:40:37 +02006559 /* set set2 */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006560 switch (set1->type) {
Michal Vasko4c7763f2020-07-27 17:40:37 +02006561 case LYXP_SET_NUMBER:
6562 rc = set_comp_cast(&iter2, set2, LYXP_SET_NUMBER, i);
6563 break;
6564 case LYXP_SET_BOOLEAN:
6565 rc = set_comp_cast(&iter2, set2, LYXP_SET_BOOLEAN, i);
6566 break;
6567 default:
6568 rc = set_comp_cast(&iter2, set2, LYXP_SET_STRING, i);
6569 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006570 }
6571 LY_CHECK_RET(rc);
6572
Michal Vasko4c7763f2020-07-27 17:40:37 +02006573 /* canonize set1 */
6574 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 +02006575
Michal Vasko4c7763f2020-07-27 17:40:37 +02006576 /* compare recursively */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006577 rc = moveto_op_comp(&iter1, &iter2, op, options);
Michal Vaskod3678892020-05-21 10:06:58 +02006578 lyxp_set_free_content(&iter2);
Michal Vasko4c7763f2020-07-27 17:40:37 +02006579 LY_CHECK_ERR_RET(rc, lyxp_set_free_content(&iter1), rc);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006580
6581 /* lazy evaluation until true */
Michal Vasko004d3152020-06-11 19:59:22 +02006582 if (iter1.val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006583 set_fill_boolean(set1, 1);
6584 return LY_SUCCESS;
6585 }
6586 }
6587 }
6588
6589 /* false for all nodes */
6590 set_fill_boolean(set1, 0);
6591 return LY_SUCCESS;
6592 }
6593
6594 /* first convert properly */
6595 if ((op[0] == '=') || (op[0] == '!')) {
6596 if ((set1->type == LYXP_SET_BOOLEAN) || (set2->type == LYXP_SET_BOOLEAN)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006597 lyxp_set_cast(set1, LYXP_SET_BOOLEAN);
6598 lyxp_set_cast(set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006599 } else if ((set1->type == LYXP_SET_NUMBER) || (set2->type == LYXP_SET_NUMBER)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006600 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006601 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006602 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006603 LY_CHECK_RET(rc);
6604 } /* else we have 2 strings */
6605 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006606 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006607 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006608 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006609 LY_CHECK_RET(rc);
6610 }
6611
6612 assert(set1->type == set2->type);
6613
6614 /* compute result */
6615 if (op[0] == '=') {
6616 if (set1->type == LYXP_SET_BOOLEAN) {
Michal Vasko004d3152020-06-11 19:59:22 +02006617 result = (set1->val.bln == set2->val.bln);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006618 } else if (set1->type == LYXP_SET_NUMBER) {
6619 result = (set1->val.num == set2->val.num);
6620 } else {
6621 assert(set1->type == LYXP_SET_STRING);
Michal Vaskoac6c72f2019-11-14 16:09:34 +01006622 result = !strcmp(set1->val.str, set2->val.str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006623 }
6624 } else if (op[0] == '!') {
6625 if (set1->type == LYXP_SET_BOOLEAN) {
Michal Vasko004d3152020-06-11 19:59:22 +02006626 result = (set1->val.bln != set2->val.bln);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006627 } else if (set1->type == LYXP_SET_NUMBER) {
6628 result = (set1->val.num != set2->val.num);
6629 } else {
6630 assert(set1->type == LYXP_SET_STRING);
Michal Vaskoc2058432020-11-06 17:26:21 +01006631 result = strcmp(set1->val.str, set2->val.str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006632 }
6633 } else {
6634 assert(set1->type == LYXP_SET_NUMBER);
6635 if (op[0] == '<') {
6636 if (op[1] == '=') {
6637 result = (set1->val.num <= set2->val.num);
6638 } else {
6639 result = (set1->val.num < set2->val.num);
6640 }
6641 } else {
6642 if (op[1] == '=') {
6643 result = (set1->val.num >= set2->val.num);
6644 } else {
6645 result = (set1->val.num > set2->val.num);
6646 }
6647 }
6648 }
6649
6650 /* assign result */
6651 if (result) {
6652 set_fill_boolean(set1, 1);
6653 } else {
6654 set_fill_boolean(set1, 0);
6655 }
6656
6657 return LY_SUCCESS;
6658}
6659
6660/**
6661 * @brief Move context @p set to the result of a basic operation. Handles '+', '-', unary '-', '*', 'div',
6662 * or 'mod'. Result is LYXP_SET_NUMBER. Indirectly context position aware.
6663 *
6664 * @param[in,out] set1 Set to use for the result.
6665 * @param[in] set2 Set acting as the second operand for @p op.
6666 * @param[in] op Operator to process.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006667 * @return LY_ERR
6668 */
6669static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006670moveto_op_math(struct lyxp_set *set1, struct lyxp_set *set2, const char *op)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006671{
6672 LY_ERR rc;
6673
6674 /* unary '-' */
6675 if (!set2 && (op[0] == '-')) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006676 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006677 LY_CHECK_RET(rc);
6678 set1->val.num *= -1;
6679 lyxp_set_free(set2);
6680 return LY_SUCCESS;
6681 }
6682
6683 assert(set1 && set2);
6684
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006685 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006686 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006687 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006688 LY_CHECK_RET(rc);
6689
6690 switch (op[0]) {
6691 /* '+' */
6692 case '+':
6693 set1->val.num += set2->val.num;
6694 break;
6695
6696 /* '-' */
6697 case '-':
6698 set1->val.num -= set2->val.num;
6699 break;
6700
6701 /* '*' */
6702 case '*':
6703 set1->val.num *= set2->val.num;
6704 break;
6705
6706 /* 'div' */
6707 case 'd':
6708 set1->val.num /= set2->val.num;
6709 break;
6710
6711 /* 'mod' */
6712 case 'm':
6713 set1->val.num = ((long long)set1->val.num) % ((long long)set2->val.num);
6714 break;
6715
6716 default:
6717 LOGINT_RET(set1->ctx);
6718 }
6719
6720 return LY_SUCCESS;
6721}
6722
6723/*
6724 * eval functions
6725 *
6726 * They execute a parsed XPath expression on some data subtree.
6727 */
6728
6729/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02006730 * @brief Evaluate Predicate. Logs directly on error.
6731 *
Michal Vaskod3678892020-05-21 10:06:58 +02006732 * [9] Predicate ::= '[' Expr ']'
Michal Vasko03ff5a72019-09-11 13:49:33 +02006733 *
6734 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02006735 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006736 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
6737 * @param[in] options XPath options.
6738 * @param[in] parent_pos_pred Whether parent predicate was a positional one.
6739 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6740 */
6741static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02006742eval_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 +02006743{
6744 LY_ERR rc;
Michal Vasko1fdd8fa2021-01-08 09:21:45 +01006745 uint16_t orig_exp;
6746 uint32_t i, orig_pos, orig_size;
Michal Vasko5c4e5892019-11-14 12:31:38 +01006747 int32_t pred_in_ctx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006748 struct lyxp_set set2;
6749 struct lyd_node *orig_parent;
6750
6751 /* '[' */
6752 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02006753 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02006754 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006755
6756 if (!set) {
6757only_parse:
Michal Vasko004d3152020-06-11 19:59:22 +02006758 rc = eval_expr_select(exp, tok_idx, 0, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006759 LY_CHECK_RET(rc);
6760 } else if (set->type == LYXP_SET_NODE_SET) {
6761 /* 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 +01006762 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006763
6764 /* empty set, nothing to evaluate */
6765 if (!set->used) {
6766 goto only_parse;
6767 }
6768
Michal Vasko004d3152020-06-11 19:59:22 +02006769 orig_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006770 orig_pos = 0;
6771 orig_size = set->used;
6772 orig_parent = NULL;
Michal Vasko39dbf352020-05-21 10:08:59 +02006773 for (i = 0; i < set->used; ++i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006774 set_init(&set2, set);
6775 set_insert_node(&set2, set->val.nodes[i].node, set->val.nodes[i].pos, set->val.nodes[i].type, 0);
6776 /* remember the node context position for position() and context size for last(),
6777 * predicates should always be evaluated with respect to the child axis (since we do
6778 * not support explicit axes) so we assign positions based on their parents */
Michal Vasko9e685082021-01-29 14:49:09 +01006779 if (parent_pos_pred && (lyd_parent(set->val.nodes[i].node) != orig_parent)) {
6780 orig_parent = lyd_parent(set->val.nodes[i].node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006781 orig_pos = 1;
6782 } else {
6783 ++orig_pos;
6784 }
6785
6786 set2.ctx_pos = orig_pos;
6787 set2.ctx_size = orig_size;
Michal Vasko004d3152020-06-11 19:59:22 +02006788 *tok_idx = orig_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006789
Michal Vasko004d3152020-06-11 19:59:22 +02006790 rc = eval_expr_select(exp, tok_idx, 0, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006791 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02006792 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006793 return rc;
6794 }
6795
6796 /* number is a position */
6797 if (set2.type == LYXP_SET_NUMBER) {
6798 if ((long long)set2.val.num == orig_pos) {
6799 set2.val.num = 1;
6800 } else {
6801 set2.val.num = 0;
6802 }
6803 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006804 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006805
6806 /* predicate satisfied or not? */
Michal Vasko004d3152020-06-11 19:59:22 +02006807 if (!set2.val.bln) {
Michal Vasko2caefc12019-11-14 16:07:56 +01006808 set_remove_node_none(set, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006809 }
6810 }
Michal Vasko2caefc12019-11-14 16:07:56 +01006811 set_remove_nodes_none(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006812
6813 } else if (set->type == LYXP_SET_SCNODE_SET) {
6814 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006815 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006816 /* there is a currently-valid node */
6817 break;
6818 }
6819 }
6820 /* empty set, nothing to evaluate */
6821 if (i == set->used) {
6822 goto only_parse;
6823 }
6824
Michal Vasko004d3152020-06-11 19:59:22 +02006825 orig_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006826
Michal Vasko03ff5a72019-09-11 13:49:33 +02006827 /* set special in_ctx to all the valid snodes */
6828 pred_in_ctx = set_scnode_new_in_ctx(set);
6829
6830 /* use the valid snodes one-by-one */
6831 for (i = 0; i < set->used; ++i) {
6832 if (set->val.scnodes[i].in_ctx != pred_in_ctx) {
6833 continue;
6834 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01006835 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006836
Michal Vasko004d3152020-06-11 19:59:22 +02006837 *tok_idx = orig_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006838
Michal Vasko004d3152020-06-11 19:59:22 +02006839 rc = eval_expr_select(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006840 LY_CHECK_RET(rc);
6841
6842 set->val.scnodes[i].in_ctx = pred_in_ctx;
6843 }
6844
6845 /* restore the state as it was before the predicate */
6846 for (i = 0; i < set->used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006847 if (set->val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX) {
6848 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006849 } else if (set->val.scnodes[i].in_ctx == pred_in_ctx) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01006850 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006851 }
6852 }
6853
6854 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02006855 set2.type = LYXP_SET_NODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006856 set_fill_set(&set2, set);
6857
Michal Vasko004d3152020-06-11 19:59:22 +02006858 rc = eval_expr_select(exp, tok_idx, 0, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006859 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02006860 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006861 return rc;
6862 }
6863
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006864 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko004d3152020-06-11 19:59:22 +02006865 if (!set2.val.bln) {
Michal Vaskod3678892020-05-21 10:06:58 +02006866 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006867 }
Michal Vaskod3678892020-05-21 10:06:58 +02006868 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006869 }
6870
6871 /* ']' */
Michal Vasko004d3152020-06-11 19:59:22 +02006872 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006873 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02006874 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02006875 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006876
6877 return LY_SUCCESS;
6878}
6879
6880/**
Michal Vaskod3678892020-05-21 10:06:58 +02006881 * @brief Evaluate Literal. Logs directly on error.
6882 *
6883 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02006884 * @param[in] tok_idx Position in the expression @p exp.
Michal Vaskod3678892020-05-21 10:06:58 +02006885 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
6886 */
6887static void
Michal Vasko40308e72020-10-20 16:38:40 +02006888eval_literal(const struct lyxp_expr *exp, uint16_t *tok_idx, struct lyxp_set *set)
Michal Vaskod3678892020-05-21 10:06:58 +02006889{
6890 if (set) {
Michal Vasko004d3152020-06-11 19:59:22 +02006891 if (exp->tok_len[*tok_idx] == 2) {
Michal Vaskod3678892020-05-21 10:06:58 +02006892 set_fill_string(set, "", 0);
6893 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02006894 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 +02006895 }
6896 }
6897 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02006898 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02006899 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02006900}
6901
6902/**
Michal Vasko004d3152020-06-11 19:59:22 +02006903 * @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 +02006904 *
Michal Vasko004d3152020-06-11 19:59:22 +02006905 * @param[in] exp Full parsed XPath expression.
6906 * @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 +02006907 * @param[in] ctx_node Found schema node as the context for the predicate.
6908 * @param[in] cur_mod Current module for the expression.
6909 * @param[in] cur_node Current (original context) node.
Michal Vasko004d3152020-06-11 19:59:22 +02006910 * @param[in] format Format of any prefixes in key names/values.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006911 * @param[in] prefix_data Format-specific prefix data (see ::ly_resolve_prefix).
Michal Vasko004d3152020-06-11 19:59:22 +02006912 * @param[out] predicates Parsed predicates.
6913 * @param[out] pred_type Type of @p predicates.
6914 * @return LY_SUCCESS on success,
6915 * @return LY_ERR on any error.
Michal Vaskod3678892020-05-21 10:06:58 +02006916 */
6917static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02006918eval_name_test_try_compile_predicates(const struct lyxp_expr *exp, uint16_t *tok_idx, const struct lysc_node *ctx_node,
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006919 const struct lys_module *cur_mod, const struct lysc_node *cur_node, LY_PREFIX_FORMAT format, void *prefix_data,
6920 struct ly_path_predicate **predicates, enum ly_path_pred_type *pred_type)
Michal Vaskod3678892020-05-21 10:06:58 +02006921{
Michal Vasko004d3152020-06-11 19:59:22 +02006922 LY_ERR ret = LY_SUCCESS;
6923 uint16_t key_count, e_idx, pred_idx = 0;
Michal Vaskod3678892020-05-21 10:06:58 +02006924 const struct lysc_node *key;
Michal Vasko004d3152020-06-11 19:59:22 +02006925 size_t pred_len;
Radek Krejci1deb5be2020-08-26 16:43:36 +02006926 uint32_t prev_lo;
Michal Vasko004d3152020-06-11 19:59:22 +02006927 struct lyxp_expr *exp2 = NULL;
Michal Vaskod3678892020-05-21 10:06:58 +02006928
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006929 assert(ctx_node->nodetype & (LYS_LIST | LYS_LEAFLIST));
Michal Vaskod3678892020-05-21 10:06:58 +02006930
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006931 if (ctx_node->nodetype == LYS_LIST) {
Michal Vasko004d3152020-06-11 19:59:22 +02006932 /* get key count */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006933 if (ctx_node->flags & LYS_KEYLESS) {
Michal Vasko004d3152020-06-11 19:59:22 +02006934 return LY_EINVAL;
6935 }
Michal Vasko544e58a2021-01-28 14:33:41 +01006936 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 +02006937 assert(key_count);
Michal Vaskod3678892020-05-21 10:06:58 +02006938
Michal Vasko004d3152020-06-11 19:59:22 +02006939 /* learn where the predicates end */
6940 e_idx = *tok_idx;
6941 while (key_count) {
6942 /* '[' */
6943 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
6944 return LY_EINVAL;
6945 }
6946 ++e_idx;
6947
Michal Vasko3354d272021-04-06 09:40:06 +02006948 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_NAMETEST)) {
6949 /* definitely not a key */
6950 return LY_EINVAL;
6951 }
6952
Michal Vasko004d3152020-06-11 19:59:22 +02006953 /* ']' */
6954 while (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK2)) {
6955 ++e_idx;
6956 }
6957 ++e_idx;
6958
6959 /* another presumably key predicate parsed */
6960 --key_count;
6961 }
Michal Vasko004d3152020-06-11 19:59:22 +02006962 } else {
6963 /* learn just where this single predicate ends */
6964 e_idx = *tok_idx;
6965
Michal Vaskod3678892020-05-21 10:06:58 +02006966 /* '[' */
Michal Vasko004d3152020-06-11 19:59:22 +02006967 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
6968 return LY_EINVAL;
6969 }
6970 ++e_idx;
Michal Vaskod3678892020-05-21 10:06:58 +02006971
Michal Vasko3354d272021-04-06 09:40:06 +02006972 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_DOT)) {
6973 /* definitely not the value */
6974 return LY_EINVAL;
6975 }
6976
Michal Vaskod3678892020-05-21 10:06:58 +02006977 /* ']' */
Michal Vasko004d3152020-06-11 19:59:22 +02006978 while (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK2)) {
6979 ++e_idx;
6980 }
6981 ++e_idx;
Michal Vaskod3678892020-05-21 10:06:58 +02006982 }
6983
Michal Vasko004d3152020-06-11 19:59:22 +02006984 /* get the joined length of all the keys predicates/of the single leaf-list predicate */
6985 pred_len = (exp->tok_pos[e_idx - 1] + exp->tok_len[e_idx - 1]) - exp->tok_pos[*tok_idx];
6986
6987 /* turn logging off */
6988 prev_lo = ly_log_options(0);
6989
6990 /* parse the predicate(s) */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006991 LY_CHECK_GOTO(ret = ly_path_parse_predicate(ctx_node->module->ctx, ctx_node, exp->expr + exp->tok_pos[*tok_idx],
6992 pred_len, LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &exp2), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02006993
6994 /* compile */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006995 ret = ly_path_compile_predicate(ctx_node->module->ctx, cur_node, cur_mod, ctx_node, exp2, &pred_idx, format,
6996 prefix_data, predicates, pred_type);
Michal Vasko004d3152020-06-11 19:59:22 +02006997 LY_CHECK_GOTO(ret, cleanup);
6998
6999 /* success, the predicate must include all the needed information for hash-based search */
7000 *tok_idx = e_idx;
7001
7002cleanup:
7003 ly_log_options(prev_lo);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007004 lyxp_expr_free(ctx_node->module->ctx, exp2);
Michal Vasko004d3152020-06-11 19:59:22 +02007005 return ret;
Michal Vaskod3678892020-05-21 10:06:58 +02007006}
7007
7008/**
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007009 * @brief Search for/check the next schema node that could be the only matching schema node meaning the
7010 * data node(s) could be found using a single hash-based search.
7011 *
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007012 * @param[in] ctx libyang context.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007013 * @param[in] node Next context node to check.
7014 * @param[in] name Expected node name.
7015 * @param[in] name_len Length of @p name.
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007016 * @param[in] moveto_mod Expected node module, can be NULL for JSON format with no prefix.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007017 * @param[in] root_type XPath root type.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007018 * @param[in] format Prefix format.
7019 * @param[in,out] found Previously found node, is updated.
7020 * @return LY_SUCCESS on success,
7021 * @return LY_ENOT if the whole check failed and hashes cannot be used.
7022 */
7023static LY_ERR
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007024eval_name_test_with_predicate_get_scnode(const struct ly_ctx *ctx, const struct lyd_node *node, const char *name,
7025 uint16_t name_len, const struct lys_module *moveto_mod, enum lyxp_node_type root_type, LY_PREFIX_FORMAT format,
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007026 const struct lysc_node **found)
7027{
7028 const struct lysc_node *scnode;
7029 const struct lys_module *mod;
7030 uint32_t idx = 0;
7031
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007032 assert((format == LY_PREF_JSON) || moveto_mod);
7033
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007034continue_search:
Michal Vasko7d1d0912020-10-16 08:38:30 +02007035 scnode = NULL;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007036 if (!node) {
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007037 if ((format == LY_PREF_JSON) && !moveto_mod) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007038 /* search all modules for a single match */
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007039 while ((mod = ly_ctx_get_module_iter(ctx, &idx))) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007040 scnode = lys_find_child(NULL, mod, name, name_len, 0, 0);
7041 if (scnode) {
7042 /* we have found a match */
7043 break;
7044 }
7045 }
7046
Michal Vasko7d1d0912020-10-16 08:38:30 +02007047 if (!scnode) {
7048 /* all modules searched */
7049 idx = 0;
7050 }
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007051 } else {
7052 /* search in top-level */
7053 scnode = lys_find_child(NULL, moveto_mod, name, name_len, 0, 0);
7054 }
7055 } else if (!*found || (lysc_data_parent(*found) != node->schema)) {
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007056 if ((format == LY_PREF_JSON) && !moveto_mod) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007057 /* we must adjust the module to inherit the one from the context node */
7058 moveto_mod = node->schema->module;
7059 }
7060
7061 /* search in children, do not repeat the same search */
7062 scnode = lys_find_child(node->schema, moveto_mod, name, name_len, 0, 0);
Michal Vasko7d1d0912020-10-16 08:38:30 +02007063 } /* else skip redundant search */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007064
7065 /* additional context check */
7066 if (scnode && (root_type == LYXP_NODE_ROOT_CONFIG) && (scnode->flags & LYS_CONFIG_R)) {
7067 scnode = NULL;
7068 }
7069
7070 if (scnode) {
7071 if (*found) {
7072 /* we found a schema node with the same name but at different level, give up, too complicated
7073 * (more hash-based searches would be required, not supported) */
7074 return LY_ENOT;
7075 } else {
7076 /* remember the found schema node and continue to make sure it can be used */
7077 *found = scnode;
7078 }
7079 }
7080
7081 if (idx) {
7082 /* continue searching all the following models */
7083 goto continue_search;
7084 }
7085
7086 return LY_SUCCESS;
7087}
7088
7089/**
Michal Vaskod3678892020-05-21 10:06:58 +02007090 * @brief Evaluate NameTest and any following Predicates. Logs directly on error.
7091 *
7092 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
7093 * [6] NodeTest ::= NameTest | NodeType '(' ')'
7094 * [7] NameTest ::= '*' | NCName ':' '*' | QName
7095 *
7096 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007097 * @param[in] tok_idx Position in the expression @p exp.
Michal Vaskod3678892020-05-21 10:06:58 +02007098 * @param[in] attr_axis Whether to search attributes or standard nodes.
7099 * @param[in] all_desc Whether to search all the descendants or children only.
7100 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7101 * @param[in] options XPath options.
7102 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7103 */
7104static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007105eval_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 +02007106 struct lyxp_set *set, uint32_t options)
Michal Vaskod3678892020-05-21 10:06:58 +02007107{
Michal Vaskod3678892020-05-21 10:06:58 +02007108 char *path;
Michal Vasko004d3152020-06-11 19:59:22 +02007109 const char *ncname, *ncname_dict = NULL;
7110 uint16_t ncname_len;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007111 const struct lys_module *moveto_mod = NULL;
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007112 const struct lysc_node *scnode = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02007113 struct ly_path_predicate *predicates = NULL;
7114 enum ly_path_pred_type pred_type = 0;
Michal Vaskod3678892020-05-21 10:06:58 +02007115 LY_ERR rc = LY_SUCCESS;
7116
7117 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007118 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007119 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007120
7121 if (!set) {
7122 goto moveto;
7123 }
7124
Michal Vasko004d3152020-06-11 19:59:22 +02007125 ncname = &exp->expr[exp->tok_pos[*tok_idx - 1]];
7126 ncname_len = exp->tok_len[*tok_idx - 1];
Michal Vaskod3678892020-05-21 10:06:58 +02007127
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007128 if ((ncname[0] == '*') && (ncname_len == 1)) {
7129 /* all nodes will match */
7130 goto moveto;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007131 }
7132
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007133 /* parse (and skip) module name */
7134 rc = moveto_resolve_model(&ncname, &ncname_len, set, NULL, &moveto_mod);
Michal Vaskod3678892020-05-21 10:06:58 +02007135 LY_CHECK_GOTO(rc, cleanup);
7136
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007137 if (((set->format == LY_PREF_JSON) || moveto_mod) && !attr_axis && !all_desc && (set->type == LYXP_SET_NODE_SET)) {
Michal Vaskod3678892020-05-21 10:06:58 +02007138 /* find the matching schema node in some parent in the context */
Radek Krejci1deb5be2020-08-26 16:43:36 +02007139 for (uint32_t i = 0; i < set->used; ++i) {
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007140 if (eval_name_test_with_predicate_get_scnode(set->ctx, set->val.nodes[i].node, ncname, ncname_len,
7141 moveto_mod, set->root_type, set->format, &scnode)) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007142 /* check failed */
7143 scnode = NULL;
7144 break;
Michal Vaskod3678892020-05-21 10:06:58 +02007145 }
7146 }
7147
Michal Vasko004d3152020-06-11 19:59:22 +02007148 if (scnode && (scnode->nodetype & (LYS_LIST | LYS_LEAFLIST))) {
7149 /* try to create the predicates */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007150 if (eval_name_test_try_compile_predicates(exp, tok_idx, scnode, set->cur_mod, set->cur_node ?
7151 set->cur_node->schema : NULL, set->format, set->prefix_data, &predicates, &pred_type)) {
Michal Vasko004d3152020-06-11 19:59:22 +02007152 /* hashes cannot be used */
Michal Vaskod3678892020-05-21 10:06:58 +02007153 scnode = NULL;
7154 }
7155 }
7156 }
7157
Michal Vaskoc71c37b2021-01-11 13:40:02 +01007158 if (!scnode) {
7159 /* we are not able to match based on a schema node and not all the modules match ("*"),
Michal Vasko004d3152020-06-11 19:59:22 +02007160 * use dictionary for efficient comparison */
Radek Krejci011e4aa2020-09-04 15:22:31 +02007161 LY_CHECK_GOTO(rc = lydict_insert(set->ctx, ncname, ncname_len, &ncname_dict), cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02007162 }
7163
7164moveto:
7165 /* move to the attribute(s), data node(s), or schema node(s) */
7166 if (attr_axis) {
7167 if (set && (options & LYXP_SCNODE_ALL)) {
7168 set_scnode_clear_ctx(set);
7169 } else {
7170 if (all_desc) {
Michal Vaskocdad7122020-11-09 21:04:44 +01007171 rc = moveto_attr_alldesc(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007172 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007173 rc = moveto_attr(set, moveto_mod, ncname_dict);
Michal Vaskod3678892020-05-21 10:06:58 +02007174 }
7175 LY_CHECK_GOTO(rc, cleanup);
7176 }
7177 } else {
7178 if (set && (options & LYXP_SCNODE_ALL)) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02007179 int64_t i;
7180
Michal Vaskod3678892020-05-21 10:06:58 +02007181 if (all_desc) {
Michal Vasko004d3152020-06-11 19:59:22 +02007182 rc = moveto_scnode_alldesc(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007183 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007184 rc = moveto_scnode(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007185 }
7186 LY_CHECK_GOTO(rc, cleanup);
7187
7188 for (i = set->used - 1; i > -1; --i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01007189 if (set->val.scnodes[i].in_ctx > LYXP_SET_SCNODE_ATOM) {
Michal Vaskod3678892020-05-21 10:06:58 +02007190 break;
7191 }
7192 }
7193 if (i == -1) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007194 path = lysc_path(set->cur_scnode, LYSC_PATH_LOG, NULL, 0);
Michal Vasko90f12dc2020-12-03 14:20:42 +01007195 LOGWRN(set->ctx, "Schema node \"%.*s\" not found (\"%.*s\") with context node \"%s\".",
7196 ncname_len, ncname, (ncname - exp->expr) + ncname_len, exp->expr, path);
Michal Vaskod3678892020-05-21 10:06:58 +02007197 free(path);
7198 }
7199 } else {
7200 if (all_desc) {
Michal Vaskocdad7122020-11-09 21:04:44 +01007201 rc = moveto_node_alldesc(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007202 } else {
7203 if (scnode) {
7204 /* we can find the nodes using hashes */
Michal Vaskocdad7122020-11-09 21:04:44 +01007205 rc = moveto_node_hash(set, scnode, predicates, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007206 } else {
Michal Vaskocdad7122020-11-09 21:04:44 +01007207 rc = moveto_node(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007208 }
7209 }
7210 LY_CHECK_GOTO(rc, cleanup);
7211 }
7212 }
7213
7214 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02007215 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
7216 rc = eval_predicate(exp, tok_idx, set, options, 1);
Michal Vaskod3678892020-05-21 10:06:58 +02007217 LY_CHECK_RET(rc);
7218 }
7219
7220cleanup:
Michal Vaskodb51a8d2020-05-27 15:22:29 +02007221 if (set) {
Michal Vasko004d3152020-06-11 19:59:22 +02007222 lydict_remove(set->ctx, ncname_dict);
Michal Vaskof7e16e22020-10-21 09:24:39 +02007223 ly_path_predicates_free(set->ctx, pred_type, predicates);
Michal Vaskodb51a8d2020-05-27 15:22:29 +02007224 }
Michal Vaskod3678892020-05-21 10:06:58 +02007225 return rc;
7226}
7227
7228/**
7229 * @brief Evaluate NodeType and any following Predicates. Logs directly on error.
7230 *
7231 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
7232 * [6] NodeTest ::= NameTest | NodeType '(' ')'
7233 * [8] NodeType ::= 'text' | 'node'
7234 *
7235 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007236 * @param[in] tok_idx Position in the expression @p exp.
Michal Vaskod3678892020-05-21 10:06:58 +02007237 * @param[in] attr_axis Whether to search attributes or standard nodes.
7238 * @param[in] all_desc Whether to search all the descendants or children only.
7239 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7240 * @param[in] options XPath options.
7241 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7242 */
7243static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007244eval_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 +02007245 struct lyxp_set *set, uint32_t options)
Michal Vaskod3678892020-05-21 10:06:58 +02007246{
7247 LY_ERR rc;
7248
7249 /* TODO */
7250 (void)attr_axis;
7251 (void)all_desc;
7252
7253 if (set) {
Michal Vasko004d3152020-06-11 19:59:22 +02007254 assert(exp->tok_len[*tok_idx] == 4);
Michal Vaskod3678892020-05-21 10:06:58 +02007255 if (set->type == LYXP_SET_SCNODE_SET) {
7256 set_scnode_clear_ctx(set);
7257 /* just for the debug message below */
7258 set = NULL;
7259 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007260 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "node", 4)) {
Michal Vaskod3678892020-05-21 10:06:58 +02007261 rc = xpath_node(NULL, 0, set, options);
7262 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007263 assert(!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "text", 4));
Michal Vaskod3678892020-05-21 10:06:58 +02007264 rc = xpath_text(NULL, 0, set, options);
7265 }
7266 LY_CHECK_RET(rc);
7267 }
7268 }
7269 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007270 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007271 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007272
7273 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02007274 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
Michal Vaskod3678892020-05-21 10:06:58 +02007275 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007276 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007277 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007278
7279 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02007280 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
Michal Vaskod3678892020-05-21 10:06:58 +02007281 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007282 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007283 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007284
7285 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02007286 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
7287 rc = eval_predicate(exp, tok_idx, set, options, 1);
Michal Vaskod3678892020-05-21 10:06:58 +02007288 LY_CHECK_RET(rc);
7289 }
7290
7291 return LY_SUCCESS;
7292}
7293
7294/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02007295 * @brief Evaluate RelativeLocationPath. Logs directly on error.
7296 *
7297 * [4] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
7298 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
Michal Vaskod3678892020-05-21 10:06:58 +02007299 * [6] NodeTest ::= NameTest | NodeType '(' ')'
Michal Vasko03ff5a72019-09-11 13:49:33 +02007300 *
7301 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007302 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007303 * @param[in] all_desc Whether to search all the descendants or children only.
7304 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7305 * @param[in] options XPath options.
7306 * @return LY_ERR (YL_EINCOMPLETE on unresolved when)
7307 */
7308static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007309eval_relative_location_path(const struct lyxp_expr *exp, uint16_t *tok_idx, ly_bool all_desc, struct lyxp_set *set,
7310 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007311{
Radek Krejci857189e2020-09-01 13:26:36 +02007312 ly_bool attr_axis;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007313 LY_ERR rc;
7314
7315 goto step;
7316 do {
7317 /* evaluate '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02007318 if (exp->tok_len[*tok_idx] == 1) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007319 all_desc = 0;
7320 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007321 assert(exp->tok_len[*tok_idx] == 2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007322 all_desc = 1;
7323 }
7324 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007325 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007326 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007327
7328step:
Michal Vaskod3678892020-05-21 10:06:58 +02007329 /* evaluate abbreviated axis '@'? if any */
Michal Vasko004d3152020-06-11 19:59:22 +02007330 if (exp->tokens[*tok_idx] == LYXP_TOKEN_AT) {
Michal Vaskod3678892020-05-21 10:06:58 +02007331 attr_axis = 1;
7332
7333 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007334 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007335 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007336 } else {
7337 attr_axis = 0;
7338 }
7339
Michal Vasko03ff5a72019-09-11 13:49:33 +02007340 /* Step */
Michal Vasko004d3152020-06-11 19:59:22 +02007341 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007342 case LYXP_TOKEN_DOT:
7343 /* evaluate '.' */
7344 if (set && (options & LYXP_SCNODE_ALL)) {
7345 rc = moveto_scnode_self(set, all_desc, options);
7346 } else {
7347 rc = moveto_self(set, all_desc, options);
7348 }
7349 LY_CHECK_RET(rc);
7350 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007351 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007352 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007353 break;
7354
7355 case LYXP_TOKEN_DDOT:
7356 /* evaluate '..' */
7357 if (set && (options & LYXP_SCNODE_ALL)) {
7358 rc = moveto_scnode_parent(set, all_desc, options);
7359 } else {
7360 rc = moveto_parent(set, all_desc, options);
7361 }
7362 LY_CHECK_RET(rc);
7363 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007364 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007365 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007366 break;
7367
Michal Vasko03ff5a72019-09-11 13:49:33 +02007368 case LYXP_TOKEN_NAMETEST:
Michal Vaskod3678892020-05-21 10:06:58 +02007369 /* evaluate NameTest Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02007370 rc = eval_name_test_with_predicate(exp, tok_idx, attr_axis, all_desc, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007371 LY_CHECK_RET(rc);
Michal Vaskod3678892020-05-21 10:06:58 +02007372 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007373
Michal Vaskod3678892020-05-21 10:06:58 +02007374 case LYXP_TOKEN_NODETYPE:
7375 /* evaluate NodeType Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02007376 rc = eval_node_type_with_predicate(exp, tok_idx, attr_axis, all_desc, set, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007377 LY_CHECK_RET(rc);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007378 break;
7379
7380 default:
Michal Vasko02a77382019-09-12 11:47:35 +02007381 LOGINT_RET(set ? set->ctx : NULL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007382 }
Michal Vasko004d3152020-06-11 19:59:22 +02007383 } while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007384
7385 return LY_SUCCESS;
7386}
7387
7388/**
7389 * @brief Evaluate AbsoluteLocationPath. Logs directly on error.
7390 *
7391 * [3] AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
7392 *
7393 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007394 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007395 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7396 * @param[in] options XPath options.
7397 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7398 */
7399static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007400eval_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 +02007401{
Radek Krejci857189e2020-09-01 13:26:36 +02007402 ly_bool all_desc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007403
7404 if (set) {
7405 /* no matter what tokens follow, we need to be at the root */
Michal Vaskob0099a92020-08-31 14:55:23 +02007406 LY_CHECK_RET(moveto_root(set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007407 }
7408
7409 /* '/' RelativeLocationPath? */
Michal Vasko004d3152020-06-11 19:59:22 +02007410 if (exp->tok_len[*tok_idx] == 1) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007411 /* evaluate '/' - deferred */
7412 all_desc = 0;
7413 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007414 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007415 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007416
Michal Vasko004d3152020-06-11 19:59:22 +02007417 if (lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007418 return LY_SUCCESS;
7419 }
Michal Vasko004d3152020-06-11 19:59:22 +02007420 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007421 case LYXP_TOKEN_DOT:
7422 case LYXP_TOKEN_DDOT:
7423 case LYXP_TOKEN_AT:
7424 case LYXP_TOKEN_NAMETEST:
7425 case LYXP_TOKEN_NODETYPE:
Michal Vaskob0099a92020-08-31 14:55:23 +02007426 LY_CHECK_RET(eval_relative_location_path(exp, tok_idx, all_desc, set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007427 break;
7428 default:
7429 break;
7430 }
7431
Michal Vasko03ff5a72019-09-11 13:49:33 +02007432 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02007433 /* '//' RelativeLocationPath */
Michal Vasko03ff5a72019-09-11 13:49:33 +02007434 /* evaluate '//' - deferred so as not to waste memory by remembering all the nodes */
7435 all_desc = 1;
7436 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007437 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007438 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007439
Michal Vaskob0099a92020-08-31 14:55:23 +02007440 LY_CHECK_RET(eval_relative_location_path(exp, tok_idx, all_desc, set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007441 }
7442
7443 return LY_SUCCESS;
7444}
7445
7446/**
7447 * @brief Evaluate FunctionCall. Logs directly on error.
7448 *
Michal Vaskod3678892020-05-21 10:06:58 +02007449 * [11] FunctionCall ::= FunctionName '(' ( Expr ( ',' Expr )* )? ')'
Michal Vasko03ff5a72019-09-11 13:49:33 +02007450 *
7451 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007452 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007453 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7454 * @param[in] options XPath options.
7455 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7456 */
7457static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007458eval_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 +02007459{
7460 LY_ERR rc;
Michal Vasko69730152020-10-09 16:30:07 +02007461
Radek Krejci1deb5be2020-08-26 16:43:36 +02007462 LY_ERR (*xpath_func)(struct lyxp_set **, uint16_t, struct lyxp_set *, uint32_t) = NULL;
Michal Vasko0cbf54f2019-12-16 10:01:06 +01007463 uint16_t arg_count = 0, i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007464 struct lyxp_set **args = NULL, **args_aux;
7465
7466 if (set) {
7467 /* FunctionName */
Michal Vasko004d3152020-06-11 19:59:22 +02007468 switch (exp->tok_len[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007469 case 3:
Michal Vasko004d3152020-06-11 19:59:22 +02007470 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "not", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007471 xpath_func = &xpath_not;
Michal Vasko004d3152020-06-11 19:59:22 +02007472 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "sum", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007473 xpath_func = &xpath_sum;
7474 }
7475 break;
7476 case 4:
Michal Vasko004d3152020-06-11 19:59:22 +02007477 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "lang", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007478 xpath_func = &xpath_lang;
Michal Vasko004d3152020-06-11 19:59:22 +02007479 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "last", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007480 xpath_func = &xpath_last;
Michal Vasko004d3152020-06-11 19:59:22 +02007481 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "name", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007482 xpath_func = &xpath_name;
Michal Vasko004d3152020-06-11 19:59:22 +02007483 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "true", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007484 xpath_func = &xpath_true;
7485 }
7486 break;
7487 case 5:
Michal Vasko004d3152020-06-11 19:59:22 +02007488 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "count", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007489 xpath_func = &xpath_count;
Michal Vasko004d3152020-06-11 19:59:22 +02007490 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "false", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007491 xpath_func = &xpath_false;
Michal Vasko004d3152020-06-11 19:59:22 +02007492 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "floor", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007493 xpath_func = &xpath_floor;
Michal Vasko004d3152020-06-11 19:59:22 +02007494 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "round", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007495 xpath_func = &xpath_round;
Michal Vasko004d3152020-06-11 19:59:22 +02007496 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "deref", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007497 xpath_func = &xpath_deref;
7498 }
7499 break;
7500 case 6:
Michal Vasko004d3152020-06-11 19:59:22 +02007501 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "concat", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007502 xpath_func = &xpath_concat;
Michal Vasko004d3152020-06-11 19:59:22 +02007503 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "number", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007504 xpath_func = &xpath_number;
Michal Vasko004d3152020-06-11 19:59:22 +02007505 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007506 xpath_func = &xpath_string;
7507 }
7508 break;
7509 case 7:
Michal Vasko004d3152020-06-11 19:59:22 +02007510 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "boolean", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007511 xpath_func = &xpath_boolean;
Michal Vasko004d3152020-06-11 19:59:22 +02007512 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "ceiling", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007513 xpath_func = &xpath_ceiling;
Michal Vasko004d3152020-06-11 19:59:22 +02007514 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "current", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007515 xpath_func = &xpath_current;
7516 }
7517 break;
7518 case 8:
Michal Vasko004d3152020-06-11 19:59:22 +02007519 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "contains", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007520 xpath_func = &xpath_contains;
Michal Vasko004d3152020-06-11 19:59:22 +02007521 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "position", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007522 xpath_func = &xpath_position;
Michal Vasko004d3152020-06-11 19:59:22 +02007523 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "re-match", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007524 xpath_func = &xpath_re_match;
7525 }
7526 break;
7527 case 9:
Michal Vasko004d3152020-06-11 19:59:22 +02007528 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007529 xpath_func = &xpath_substring;
Michal Vasko004d3152020-06-11 19:59:22 +02007530 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "translate", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007531 xpath_func = &xpath_translate;
7532 }
7533 break;
7534 case 10:
Michal Vasko004d3152020-06-11 19:59:22 +02007535 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "local-name", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007536 xpath_func = &xpath_local_name;
Michal Vasko004d3152020-06-11 19:59:22 +02007537 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "enum-value", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007538 xpath_func = &xpath_enum_value;
Michal Vasko004d3152020-06-11 19:59:22 +02007539 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "bit-is-set", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007540 xpath_func = &xpath_bit_is_set;
7541 }
7542 break;
7543 case 11:
Michal Vasko004d3152020-06-11 19:59:22 +02007544 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "starts-with", 11)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007545 xpath_func = &xpath_starts_with;
7546 }
7547 break;
7548 case 12:
Michal Vasko004d3152020-06-11 19:59:22 +02007549 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from", 12)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007550 xpath_func = &xpath_derived_from;
7551 }
7552 break;
7553 case 13:
Michal Vasko004d3152020-06-11 19:59:22 +02007554 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "namespace-uri", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007555 xpath_func = &xpath_namespace_uri;
Michal Vasko004d3152020-06-11 19:59:22 +02007556 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string-length", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007557 xpath_func = &xpath_string_length;
7558 }
7559 break;
7560 case 15:
Michal Vasko004d3152020-06-11 19:59:22 +02007561 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "normalize-space", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007562 xpath_func = &xpath_normalize_space;
Michal Vasko004d3152020-06-11 19:59:22 +02007563 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-after", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007564 xpath_func = &xpath_substring_after;
7565 }
7566 break;
7567 case 16:
Michal Vasko004d3152020-06-11 19:59:22 +02007568 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-before", 16)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007569 xpath_func = &xpath_substring_before;
7570 }
7571 break;
7572 case 20:
Michal Vasko004d3152020-06-11 19:59:22 +02007573 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from-or-self", 20)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007574 xpath_func = &xpath_derived_from_or_self;
7575 }
7576 break;
7577 }
7578
7579 if (!xpath_func) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01007580 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 +02007581 return LY_EVALID;
7582 }
7583 }
7584
7585 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007586 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007587 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007588
7589 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02007590 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007591 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007592 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007593 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007594
7595 /* ( Expr ( ',' Expr )* )? */
Michal Vasko004d3152020-06-11 19:59:22 +02007596 if (exp->tokens[*tok_idx] != LYXP_TOKEN_PAR2) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007597 if (set) {
7598 args = malloc(sizeof *args);
7599 LY_CHECK_ERR_GOTO(!args, LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
7600 arg_count = 1;
7601 args[0] = set_copy(set);
7602 if (!args[0]) {
7603 rc = LY_EMEM;
7604 goto cleanup;
7605 }
7606
Michal Vasko004d3152020-06-11 19:59:22 +02007607 rc = eval_expr_select(exp, tok_idx, 0, args[0], options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007608 LY_CHECK_GOTO(rc, cleanup);
7609 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007610 rc = eval_expr_select(exp, tok_idx, 0, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007611 LY_CHECK_GOTO(rc, cleanup);
7612 }
7613 }
Michal Vasko004d3152020-06-11 19:59:22 +02007614 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_COMMA)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007615 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007616 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007617 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007618
7619 if (set) {
7620 ++arg_count;
7621 args_aux = realloc(args, arg_count * sizeof *args);
7622 LY_CHECK_ERR_GOTO(!args_aux, arg_count--; LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
7623 args = args_aux;
7624 args[arg_count - 1] = set_copy(set);
7625 if (!args[arg_count - 1]) {
7626 rc = LY_EMEM;
7627 goto cleanup;
7628 }
7629
Michal Vasko004d3152020-06-11 19:59:22 +02007630 rc = eval_expr_select(exp, tok_idx, 0, args[arg_count - 1], options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007631 LY_CHECK_GOTO(rc, cleanup);
7632 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007633 rc = eval_expr_select(exp, tok_idx, 0, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007634 LY_CHECK_GOTO(rc, cleanup);
7635 }
7636 }
7637
7638 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02007639 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007640 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007641 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007642 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007643
7644 if (set) {
7645 /* evaluate function */
7646 rc = xpath_func(args, arg_count, set, options);
7647
7648 if (options & LYXP_SCNODE_ALL) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007649 /* merge all nodes from arg evaluations */
7650 for (i = 0; i < arg_count; ++i) {
7651 set_scnode_clear_ctx(args[i]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01007652 lyxp_set_scnode_merge(set, args[i]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007653 }
7654 }
7655 } else {
7656 rc = LY_SUCCESS;
7657 }
7658
7659cleanup:
7660 for (i = 0; i < arg_count; ++i) {
7661 lyxp_set_free(args[i]);
7662 }
7663 free(args);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007664 return rc;
7665}
7666
7667/**
7668 * @brief Evaluate Number. Logs directly on error.
7669 *
7670 * @param[in] ctx Context for errors.
7671 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007672 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007673 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7674 * @return LY_ERR
7675 */
7676static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007677eval_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 +02007678{
7679 long double num;
7680 char *endptr;
7681
7682 if (set) {
7683 errno = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02007684 num = strtold(&exp->expr[exp->tok_pos[*tok_idx]], &endptr);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007685 if (errno) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01007686 LOGVAL(ctx, LY_VCODE_XP_INTOK, "Unknown", &exp->expr[exp->tok_pos[*tok_idx]]);
7687 LOGVAL(ctx, LYVE_XPATH, "Failed to convert \"%.*s\" into a long double (%s).",
Michal Vasko69730152020-10-09 16:30:07 +02007688 exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]], strerror(errno));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007689 return LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +02007690 } else if (endptr - &exp->expr[exp->tok_pos[*tok_idx]] != exp->tok_len[*tok_idx]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01007691 LOGVAL(ctx, LY_VCODE_XP_INTOK, "Unknown", &exp->expr[exp->tok_pos[*tok_idx]]);
7692 LOGVAL(ctx, LYVE_XPATH, "Failed to convert \"%.*s\" into a long double.",
Michal Vasko69730152020-10-09 16:30:07 +02007693 exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007694 return LY_EVALID;
7695 }
7696
7697 set_fill_number(set, num);
7698 }
7699
7700 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007701 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007702 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007703 return LY_SUCCESS;
7704}
7705
7706/**
7707 * @brief Evaluate PathExpr. Logs directly on error.
7708 *
Michal Vaskod3678892020-05-21 10:06:58 +02007709 * [12] PathExpr ::= LocationPath | PrimaryExpr Predicate*
Michal Vasko03ff5a72019-09-11 13:49:33 +02007710 * | PrimaryExpr Predicate* '/' RelativeLocationPath
7711 * | PrimaryExpr Predicate* '//' RelativeLocationPath
7712 * [2] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
Michal Vaskod3678892020-05-21 10:06:58 +02007713 * [10] PrimaryExpr ::= '(' Expr ')' | Literal | Number | FunctionCall
Michal Vasko03ff5a72019-09-11 13:49:33 +02007714 *
7715 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007716 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007717 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7718 * @param[in] options XPath options.
7719 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7720 */
7721static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007722eval_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 +02007723{
Radek Krejci857189e2020-09-01 13:26:36 +02007724 ly_bool all_desc, parent_pos_pred;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007725 LY_ERR rc;
7726
Michal Vasko004d3152020-06-11 19:59:22 +02007727 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007728 case LYXP_TOKEN_PAR1:
7729 /* '(' Expr ')' */
7730
7731 /* '(' */
7732 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007733 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007734 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007735
7736 /* Expr */
Michal Vasko004d3152020-06-11 19:59:22 +02007737 rc = eval_expr_select(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007738 LY_CHECK_RET(rc);
7739
7740 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02007741 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007742 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007743 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007744 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007745
7746 parent_pos_pred = 0;
7747 goto predicate;
7748
7749 case LYXP_TOKEN_DOT:
7750 case LYXP_TOKEN_DDOT:
7751 case LYXP_TOKEN_AT:
7752 case LYXP_TOKEN_NAMETEST:
7753 case LYXP_TOKEN_NODETYPE:
7754 /* RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02007755 rc = eval_relative_location_path(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007756 LY_CHECK_RET(rc);
7757 break;
7758
7759 case LYXP_TOKEN_FUNCNAME:
7760 /* FunctionCall */
7761 if (!set) {
Michal Vasko004d3152020-06-11 19:59:22 +02007762 rc = eval_function_call(exp, tok_idx, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007763 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007764 rc = eval_function_call(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007765 }
7766 LY_CHECK_RET(rc);
7767
7768 parent_pos_pred = 1;
7769 goto predicate;
7770
Michal Vasko3e48bf32020-06-01 08:39:07 +02007771 case LYXP_TOKEN_OPER_PATH:
7772 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +02007773 /* AbsoluteLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02007774 rc = eval_absolute_location_path(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007775 LY_CHECK_RET(rc);
7776 break;
7777
7778 case LYXP_TOKEN_LITERAL:
7779 /* Literal */
7780 if (!set || (options & LYXP_SCNODE_ALL)) {
7781 if (set) {
7782 set_scnode_clear_ctx(set);
7783 }
Michal Vasko004d3152020-06-11 19:59:22 +02007784 eval_literal(exp, tok_idx, NULL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007785 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007786 eval_literal(exp, tok_idx, set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007787 }
7788
7789 parent_pos_pred = 1;
7790 goto predicate;
7791
7792 case LYXP_TOKEN_NUMBER:
7793 /* Number */
7794 if (!set || (options & LYXP_SCNODE_ALL)) {
7795 if (set) {
7796 set_scnode_clear_ctx(set);
7797 }
Michal Vasko004d3152020-06-11 19:59:22 +02007798 rc = eval_number(NULL, exp, tok_idx, NULL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007799 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007800 rc = eval_number(set->ctx, exp, tok_idx, set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007801 }
7802 LY_CHECK_RET(rc);
7803
7804 parent_pos_pred = 1;
7805 goto predicate;
7806
7807 default:
Radek Krejci2efc45b2020-12-22 16:25:44 +01007808 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 +02007809 return LY_EVALID;
7810 }
7811
7812 return LY_SUCCESS;
7813
7814predicate:
7815 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02007816 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
7817 rc = eval_predicate(exp, tok_idx, set, options, parent_pos_pred);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007818 LY_CHECK_RET(rc);
7819 }
7820
7821 /* ('/' or '//') RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02007822 if (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007823
7824 /* evaluate '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02007825 if (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007826 all_desc = 0;
7827 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007828 all_desc = 1;
7829 }
7830
7831 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007832 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007833 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007834
Michal Vasko004d3152020-06-11 19:59:22 +02007835 rc = eval_relative_location_path(exp, tok_idx, all_desc, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007836 LY_CHECK_RET(rc);
7837 }
7838
7839 return LY_SUCCESS;
7840}
7841
7842/**
7843 * @brief Evaluate UnionExpr. Logs directly on error.
7844 *
Michal Vaskod3678892020-05-21 10:06:58 +02007845 * [20] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02007846 *
7847 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007848 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007849 * @param[in] repeat How many times this expression is repeated.
7850 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7851 * @param[in] options XPath options.
7852 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7853 */
7854static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007855eval_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 +02007856{
7857 LY_ERR rc = LY_SUCCESS;
7858 struct lyxp_set orig_set, set2;
7859 uint16_t i;
7860
7861 assert(repeat);
7862
7863 set_init(&orig_set, set);
7864 set_init(&set2, set);
7865
7866 set_fill_set(&orig_set, set);
7867
Michal Vasko004d3152020-06-11 19:59:22 +02007868 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007869 LY_CHECK_GOTO(rc, cleanup);
7870
7871 /* ('|' PathExpr)* */
7872 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02007873 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_UNI);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007874 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007875 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007876 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007877
7878 if (!set) {
Michal Vasko004d3152020-06-11 19:59:22 +02007879 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007880 LY_CHECK_GOTO(rc, cleanup);
7881 continue;
7882 }
7883
7884 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02007885 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007886 LY_CHECK_GOTO(rc, cleanup);
7887
7888 /* eval */
7889 if (options & LYXP_SCNODE_ALL) {
Michal Vaskoecd62de2019-11-13 12:35:11 +01007890 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007891 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007892 rc = moveto_union(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007893 LY_CHECK_GOTO(rc, cleanup);
7894 }
7895 }
7896
7897cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02007898 lyxp_set_free_content(&orig_set);
7899 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007900 return rc;
7901}
7902
7903/**
7904 * @brief Evaluate UnaryExpr. Logs directly on error.
7905 *
Michal Vaskod3678892020-05-21 10:06:58 +02007906 * [19] UnaryExpr ::= UnionExpr | '-' UnaryExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02007907 *
7908 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007909 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007910 * @param[in] repeat How many times this expression is repeated.
7911 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7912 * @param[in] options XPath options.
7913 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7914 */
7915static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007916eval_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 +02007917{
7918 LY_ERR rc;
7919 uint16_t this_op, i;
7920
7921 assert(repeat);
7922
7923 /* ('-')+ */
Michal Vasko004d3152020-06-11 19:59:22 +02007924 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007925 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02007926 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 +02007927
7928 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007929 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007930 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007931 }
7932
Michal Vasko004d3152020-06-11 19:59:22 +02007933 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNARY, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007934 LY_CHECK_RET(rc);
7935
7936 if (set && (repeat % 2)) {
7937 if (options & LYXP_SCNODE_ALL) {
7938 warn_operands(set->ctx, set, NULL, 1, exp->expr, exp->tok_pos[this_op]);
7939 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007940 rc = moveto_op_math(set, NULL, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007941 LY_CHECK_RET(rc);
7942 }
7943 }
7944
7945 return LY_SUCCESS;
7946}
7947
7948/**
7949 * @brief Evaluate MultiplicativeExpr. Logs directly on error.
7950 *
Michal Vaskod3678892020-05-21 10:06:58 +02007951 * [18] MultiplicativeExpr ::= UnaryExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02007952 * | MultiplicativeExpr '*' UnaryExpr
7953 * | MultiplicativeExpr 'div' UnaryExpr
7954 * | MultiplicativeExpr 'mod' UnaryExpr
7955 *
7956 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007957 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007958 * @param[in] repeat How many times this expression is repeated.
7959 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7960 * @param[in] options XPath options.
7961 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7962 */
7963static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02007964eval_multiplicative_expr(const struct lyxp_expr *exp, uint16_t *tok_idx, uint16_t repeat, struct lyxp_set *set,
7965 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007966{
7967 LY_ERR rc;
7968 uint16_t this_op;
7969 struct lyxp_set orig_set, set2;
7970 uint16_t i;
7971
7972 assert(repeat);
7973
7974 set_init(&orig_set, set);
7975 set_init(&set2, set);
7976
7977 set_fill_set(&orig_set, set);
7978
Michal Vasko004d3152020-06-11 19:59:22 +02007979 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007980 LY_CHECK_GOTO(rc, cleanup);
7981
7982 /* ('*' / 'div' / 'mod' UnaryExpr)* */
7983 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02007984 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007985
Michal Vasko004d3152020-06-11 19:59:22 +02007986 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_MATH);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007987 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007988 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007989 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007990
7991 if (!set) {
Michal Vasko004d3152020-06-11 19:59:22 +02007992 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007993 LY_CHECK_GOTO(rc, cleanup);
7994 continue;
7995 }
7996
7997 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02007998 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007999 LY_CHECK_GOTO(rc, cleanup);
8000
8001 /* eval */
8002 if (options & LYXP_SCNODE_ALL) {
8003 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008004 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008005 set_scnode_clear_ctx(set);
8006 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008007 rc = moveto_op_math(set, &set2, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008008 LY_CHECK_GOTO(rc, cleanup);
8009 }
8010 }
8011
8012cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008013 lyxp_set_free_content(&orig_set);
8014 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008015 return rc;
8016}
8017
8018/**
8019 * @brief Evaluate AdditiveExpr. Logs directly on error.
8020 *
Michal Vaskod3678892020-05-21 10:06:58 +02008021 * [17] AdditiveExpr ::= MultiplicativeExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008022 * | AdditiveExpr '+' MultiplicativeExpr
8023 * | AdditiveExpr '-' MultiplicativeExpr
8024 *
8025 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008026 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008027 * @param[in] repeat How many times this expression is repeated.
8028 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
8029 * @param[in] options XPath options.
8030 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8031 */
8032static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02008033eval_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 +02008034{
8035 LY_ERR rc;
8036 uint16_t this_op;
8037 struct lyxp_set orig_set, set2;
8038 uint16_t i;
8039
8040 assert(repeat);
8041
8042 set_init(&orig_set, set);
8043 set_init(&set2, set);
8044
8045 set_fill_set(&orig_set, set);
8046
Michal Vasko004d3152020-06-11 19:59:22 +02008047 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008048 LY_CHECK_GOTO(rc, cleanup);
8049
8050 /* ('+' / '-' MultiplicativeExpr)* */
8051 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008052 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008053
Michal Vasko004d3152020-06-11 19:59:22 +02008054 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_MATH);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008055 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02008056 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008057 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008058
8059 if (!set) {
Michal Vasko004d3152020-06-11 19:59:22 +02008060 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008061 LY_CHECK_GOTO(rc, cleanup);
8062 continue;
8063 }
8064
8065 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008066 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008067 LY_CHECK_GOTO(rc, cleanup);
8068
8069 /* eval */
8070 if (options & LYXP_SCNODE_ALL) {
8071 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008072 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008073 set_scnode_clear_ctx(set);
8074 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008075 rc = moveto_op_math(set, &set2, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008076 LY_CHECK_GOTO(rc, cleanup);
8077 }
8078 }
8079
8080cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008081 lyxp_set_free_content(&orig_set);
8082 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008083 return rc;
8084}
8085
8086/**
8087 * @brief Evaluate RelationalExpr. Logs directly on error.
8088 *
Michal Vaskod3678892020-05-21 10:06:58 +02008089 * [16] RelationalExpr ::= AdditiveExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008090 * | RelationalExpr '<' AdditiveExpr
8091 * | RelationalExpr '>' AdditiveExpr
8092 * | RelationalExpr '<=' AdditiveExpr
8093 * | RelationalExpr '>=' AdditiveExpr
8094 *
8095 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008096 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008097 * @param[in] repeat How many times this expression is repeated.
8098 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
8099 * @param[in] options XPath options.
8100 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8101 */
8102static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02008103eval_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 +02008104{
8105 LY_ERR rc;
8106 uint16_t this_op;
8107 struct lyxp_set orig_set, set2;
8108 uint16_t i;
8109
8110 assert(repeat);
8111
8112 set_init(&orig_set, set);
8113 set_init(&set2, set);
8114
8115 set_fill_set(&orig_set, set);
8116
Michal Vasko004d3152020-06-11 19:59:22 +02008117 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008118 LY_CHECK_GOTO(rc, cleanup);
8119
8120 /* ('<' / '>' / '<=' / '>=' AdditiveExpr)* */
8121 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008122 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008123
Michal Vasko004d3152020-06-11 19:59:22 +02008124 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_COMP);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008125 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02008126 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008127 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008128
8129 if (!set) {
Michal Vasko004d3152020-06-11 19:59:22 +02008130 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008131 LY_CHECK_GOTO(rc, cleanup);
8132 continue;
8133 }
8134
8135 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008136 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008137 LY_CHECK_GOTO(rc, cleanup);
8138
8139 /* eval */
8140 if (options & LYXP_SCNODE_ALL) {
8141 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008142 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008143 set_scnode_clear_ctx(set);
8144 } else {
8145 rc = moveto_op_comp(set, &set2, &exp->expr[exp->tok_pos[this_op]], options);
8146 LY_CHECK_GOTO(rc, cleanup);
8147 }
8148 }
8149
8150cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008151 lyxp_set_free_content(&orig_set);
8152 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008153 return rc;
8154}
8155
8156/**
8157 * @brief Evaluate EqualityExpr. Logs directly on error.
8158 *
Michal Vaskod3678892020-05-21 10:06:58 +02008159 * [15] EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008160 * | EqualityExpr '!=' RelationalExpr
8161 *
8162 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008163 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008164 * @param[in] repeat How many times this expression is repeated.
8165 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
8166 * @param[in] options XPath options.
8167 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8168 */
8169static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02008170eval_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 +02008171{
8172 LY_ERR rc;
8173 uint16_t this_op;
8174 struct lyxp_set orig_set, set2;
8175 uint16_t i;
8176
8177 assert(repeat);
8178
8179 set_init(&orig_set, set);
8180 set_init(&set2, set);
8181
8182 set_fill_set(&orig_set, set);
8183
Michal Vasko004d3152020-06-11 19:59:22 +02008184 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008185 LY_CHECK_GOTO(rc, cleanup);
8186
8187 /* ('=' / '!=' RelationalExpr)* */
8188 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008189 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008190
Michal Vasko004d3152020-06-11 19:59:22 +02008191 assert((exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL) || (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_NEQUAL));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008192 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02008193 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008194 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008195
8196 if (!set) {
Michal Vasko004d3152020-06-11 19:59:22 +02008197 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008198 LY_CHECK_GOTO(rc, cleanup);
8199 continue;
8200 }
8201
8202 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008203 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008204 LY_CHECK_GOTO(rc, cleanup);
8205
8206 /* eval */
8207 if (options & LYXP_SCNODE_ALL) {
8208 warn_operands(set->ctx, set, &set2, 0, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vasko004d3152020-06-11 19:59:22 +02008209 warn_equality_value(exp, set, *tok_idx - 1, this_op - 1, *tok_idx - 1);
8210 warn_equality_value(exp, &set2, this_op - 1, this_op - 1, *tok_idx - 1);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008211 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008212 set_scnode_clear_ctx(set);
8213 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008214 rc = moveto_op_comp(set, &set2, &exp->expr[exp->tok_pos[this_op]], options);
8215 LY_CHECK_GOTO(rc, cleanup);
8216 }
8217 }
8218
8219cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008220 lyxp_set_free_content(&orig_set);
8221 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008222 return rc;
8223}
8224
8225/**
8226 * @brief Evaluate AndExpr. Logs directly on error.
8227 *
Michal Vaskod3678892020-05-21 10:06:58 +02008228 * [14] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008229 *
8230 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008231 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008232 * @param[in] repeat How many times this expression is repeated.
8233 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
8234 * @param[in] options XPath options.
8235 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8236 */
8237static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02008238eval_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 +02008239{
8240 LY_ERR rc;
8241 struct lyxp_set orig_set, set2;
8242 uint16_t i;
8243
8244 assert(repeat);
8245
8246 set_init(&orig_set, set);
8247 set_init(&set2, set);
8248
8249 set_fill_set(&orig_set, set);
8250
Michal Vasko004d3152020-06-11 19:59:22 +02008251 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008252 LY_CHECK_GOTO(rc, cleanup);
8253
8254 /* cast to boolean, we know that will be the final result */
8255 if (set && (options & LYXP_SCNODE_ALL)) {
8256 set_scnode_clear_ctx(set);
8257 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008258 lyxp_set_cast(set, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008259 }
8260
8261 /* ('and' EqualityExpr)* */
8262 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008263 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_LOG);
8264 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (!set || !set->val.bln ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02008265 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008266 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008267
8268 /* lazy evaluation */
Michal Vasko004d3152020-06-11 19:59:22 +02008269 if (!set || ((set->type == LYXP_SET_BOOLEAN) && !set->val.bln)) {
8270 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008271 LY_CHECK_GOTO(rc, cleanup);
8272 continue;
8273 }
8274
8275 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008276 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008277 LY_CHECK_GOTO(rc, cleanup);
8278
8279 /* eval - just get boolean value actually */
8280 if (set->type == LYXP_SET_SCNODE_SET) {
8281 set_scnode_clear_ctx(&set2);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008282 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008283 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008284 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008285 set_fill_set(set, &set2);
8286 }
8287 }
8288
8289cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008290 lyxp_set_free_content(&orig_set);
8291 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008292 return rc;
8293}
8294
8295/**
8296 * @brief Evaluate OrExpr. Logs directly on error.
8297 *
Michal Vaskod3678892020-05-21 10:06:58 +02008298 * [13] OrExpr ::= AndExpr | OrExpr 'or' AndExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008299 *
8300 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008301 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008302 * @param[in] repeat How many times this expression is repeated.
8303 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
8304 * @param[in] options XPath options.
8305 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8306 */
8307static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02008308eval_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 +02008309{
8310 LY_ERR rc;
8311 struct lyxp_set orig_set, set2;
8312 uint16_t i;
8313
8314 assert(repeat);
8315
8316 set_init(&orig_set, set);
8317 set_init(&set2, set);
8318
8319 set_fill_set(&orig_set, set);
8320
Michal Vasko004d3152020-06-11 19:59:22 +02008321 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008322 LY_CHECK_GOTO(rc, cleanup);
8323
8324 /* cast to boolean, we know that will be the final result */
8325 if (set && (options & LYXP_SCNODE_ALL)) {
8326 set_scnode_clear_ctx(set);
8327 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008328 lyxp_set_cast(set, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008329 }
8330
8331 /* ('or' AndExpr)* */
8332 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008333 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_LOG);
8334 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (!set || set->val.bln ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02008335 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008336 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008337
8338 /* lazy evaluation */
Michal Vasko004d3152020-06-11 19:59:22 +02008339 if (!set || ((set->type == LYXP_SET_BOOLEAN) && set->val.bln)) {
8340 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008341 LY_CHECK_GOTO(rc, cleanup);
8342 continue;
8343 }
8344
8345 set_fill_set(&set2, &orig_set);
8346 /* expr_type cound have been LYXP_EXPR_NONE in all these later calls (except for the first one),
8347 * but it does not matter */
Michal Vasko004d3152020-06-11 19:59:22 +02008348 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008349 LY_CHECK_GOTO(rc, cleanup);
8350
8351 /* eval - just get boolean value actually */
8352 if (set->type == LYXP_SET_SCNODE_SET) {
8353 set_scnode_clear_ctx(&set2);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008354 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008355 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008356 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008357 set_fill_set(set, &set2);
8358 }
8359 }
8360
8361cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008362 lyxp_set_free_content(&orig_set);
8363 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008364 return rc;
8365}
8366
8367/**
Michal Vasko004d3152020-06-11 19:59:22 +02008368 * @brief Decide what expression is at the pointer @p tok_idx and evaluate it accordingly.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008369 *
8370 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008371 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008372 * @param[in] etype Expression type to evaluate.
8373 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
8374 * @param[in] options XPath options.
8375 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8376 */
8377static LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +02008378eval_expr_select(const struct lyxp_expr *exp, uint16_t *tok_idx, enum lyxp_expr_type etype, struct lyxp_set *set,
8379 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008380{
8381 uint16_t i, count;
8382 enum lyxp_expr_type next_etype;
8383 LY_ERR rc;
8384
8385 /* process operator repeats */
Michal Vasko004d3152020-06-11 19:59:22 +02008386 if (!exp->repeat[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008387 next_etype = LYXP_EXPR_NONE;
8388 } else {
8389 /* find etype repeat */
Radek Krejci1e008d22020-08-17 11:37:37 +02008390 for (i = 0; exp->repeat[*tok_idx][i] > etype; ++i) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02008391
8392 /* select one-priority lower because etype expression called us */
8393 if (i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008394 next_etype = exp->repeat[*tok_idx][i - 1];
Michal Vasko03ff5a72019-09-11 13:49:33 +02008395 /* count repeats for that expression */
Radek Krejci1e008d22020-08-17 11:37:37 +02008396 for (count = 0; i && exp->repeat[*tok_idx][i - 1] == next_etype; ++count, --i) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02008397 } else {
8398 next_etype = LYXP_EXPR_NONE;
8399 }
8400 }
8401
8402 /* decide what expression are we parsing based on the repeat */
8403 switch (next_etype) {
8404 case LYXP_EXPR_OR:
Michal Vasko004d3152020-06-11 19:59:22 +02008405 rc = eval_or_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008406 break;
8407 case LYXP_EXPR_AND:
Michal Vasko004d3152020-06-11 19:59:22 +02008408 rc = eval_and_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008409 break;
8410 case LYXP_EXPR_EQUALITY:
Michal Vasko004d3152020-06-11 19:59:22 +02008411 rc = eval_equality_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008412 break;
8413 case LYXP_EXPR_RELATIONAL:
Michal Vasko004d3152020-06-11 19:59:22 +02008414 rc = eval_relational_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008415 break;
8416 case LYXP_EXPR_ADDITIVE:
Michal Vasko004d3152020-06-11 19:59:22 +02008417 rc = eval_additive_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008418 break;
8419 case LYXP_EXPR_MULTIPLICATIVE:
Michal Vasko004d3152020-06-11 19:59:22 +02008420 rc = eval_multiplicative_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008421 break;
8422 case LYXP_EXPR_UNARY:
Michal Vasko004d3152020-06-11 19:59:22 +02008423 rc = eval_unary_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008424 break;
8425 case LYXP_EXPR_UNION:
Michal Vasko004d3152020-06-11 19:59:22 +02008426 rc = eval_union_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008427 break;
8428 case LYXP_EXPR_NONE:
Michal Vasko004d3152020-06-11 19:59:22 +02008429 rc = eval_path_expr(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008430 break;
8431 default:
8432 LOGINT_RET(set->ctx);
8433 }
8434
8435 return rc;
8436}
8437
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008438/**
8439 * @brief Get root type.
8440 *
8441 * @param[in] ctx_node Context node.
8442 * @param[in] ctx_scnode Schema context node.
8443 * @param[in] options XPath options.
8444 * @return Root type.
8445 */
8446static enum lyxp_node_type
Radek Krejci1deb5be2020-08-26 16:43:36 +02008447lyxp_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 +01008448{
Michal Vasko6b26e742020-07-17 15:02:10 +02008449 const struct lysc_node *op;
8450
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008451 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008452 /* schema */
Radek Krejci1e008d22020-08-17 11:37:37 +02008453 for (op = ctx_scnode; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
Michal Vasko6b26e742020-07-17 15:02:10 +02008454
8455 if (op || (options & LYXP_SCNODE)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008456 /* general root that can access everything */
8457 return LYXP_NODE_ROOT;
8458 } else if (!ctx_scnode || (ctx_scnode->flags & LYS_CONFIG_W)) {
8459 /* root context node can access only config data (because we said so, it is unspecified) */
8460 return LYXP_NODE_ROOT_CONFIG;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008461 }
Michal Vasko6b26e742020-07-17 15:02:10 +02008462 return LYXP_NODE_ROOT;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008463 }
8464
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008465 /* data */
Michal Vasko6b26e742020-07-17 15:02:10 +02008466 op = ctx_node ? ctx_node->schema : NULL;
Michal Vaskod989ba02020-08-24 10:59:24 +02008467 for ( ; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
Michal Vasko6b26e742020-07-17 15:02:10 +02008468
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008469 if (op || !(options & LYXP_SCHEMA)) {
8470 /* general root that can access everything */
8471 return LYXP_NODE_ROOT;
Christian Hoppsb6ecaea2021-02-06 09:45:38 -05008472 } else if (!ctx_node || !ctx_node->schema || (ctx_node->schema->flags & LYS_CONFIG_W)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008473 /* root context node can access only config data (because we said so, it is unspecified) */
8474 return LYXP_NODE_ROOT_CONFIG;
8475 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008476 return LYXP_NODE_ROOT;
8477}
8478
Michal Vasko03ff5a72019-09-11 13:49:33 +02008479LY_ERR
Michal Vasko400e9672021-01-11 13:39:17 +01008480lyxp_eval(const struct ly_ctx *ctx, const struct lyxp_expr *exp, const struct lys_module *cur_mod,
8481 LY_PREFIX_FORMAT format, void *prefix_data, const struct lyd_node *ctx_node, const struct lyd_node *tree,
8482 struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008483{
Michal Vasko004d3152020-06-11 19:59:22 +02008484 uint16_t tok_idx = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008485 LY_ERR rc;
8486
Michal Vasko400e9672021-01-11 13:39:17 +01008487 LY_CHECK_ARG_RET(ctx, ctx, exp, set, LY_EINVAL);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008488 if (!cur_mod && ((format == LY_PREF_SCHEMA) || (format == LY_PREF_SCHEMA_RESOLVED))) {
8489 LOGARG(NULL, "Current module must be set if schema format is used.");
8490 return LY_EINVAL;
Michal Vasko004d3152020-06-11 19:59:22 +02008491 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02008492
Michal Vaskod3bb12f2020-12-04 14:33:09 +01008493 if (tree) {
8494 /* adjust the pointer to be the first top-level sibling */
8495 while (tree->parent) {
8496 tree = lyd_parent(tree);
8497 }
8498 tree = lyd_first_sibling(tree);
8499 }
8500
Michal Vasko03ff5a72019-09-11 13:49:33 +02008501 /* prepare set for evaluation */
Michal Vasko03ff5a72019-09-11 13:49:33 +02008502 memset(set, 0, sizeof *set);
Michal Vaskod3678892020-05-21 10:06:58 +02008503 set->type = LYXP_SET_NODE_SET;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008504 set->root_type = lyxp_get_root_type(ctx_node, NULL, options);
8505 set_insert_node(set, (struct lyd_node *)ctx_node, 0, ctx_node ? LYXP_NODE_ELEM : set->root_type, 0);
8506
Michal Vasko400e9672021-01-11 13:39:17 +01008507 set->ctx = (struct ly_ctx *)ctx;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008508 set->cur_node = ctx_node;
8509 for (set->context_op = ctx_node ? ctx_node->schema : NULL;
Radek Krejci0f969882020-08-21 16:56:47 +02008510 set->context_op && !(set->context_op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF));
8511 set->context_op = set->context_op->parent) {}
Michal Vaskof03ed032020-03-04 13:31:44 +01008512 set->tree = tree;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008513 set->cur_mod = cur_mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008514 set->format = format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008515 set->prefix_data = prefix_data;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008516
Radek Krejciddace2c2021-01-08 11:30:56 +01008517 LOG_LOCSET(NULL, set->cur_node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01008518
Michal Vasko03ff5a72019-09-11 13:49:33 +02008519 /* evaluate */
Michal Vasko004d3152020-06-11 19:59:22 +02008520 rc = eval_expr_select(exp, &tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008521 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02008522 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008523 }
8524
Radek Krejciddace2c2021-01-08 11:30:56 +01008525 LOG_LOCBACK(0, 1, 0, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008526 return rc;
8527}
8528
8529#if 0
8530
8531/* full xml printing of set elements, not used currently */
8532
8533void
8534lyxp_set_print_xml(FILE *f, struct lyxp_set *set)
8535{
8536 uint32_t i;
8537 char *str_num;
8538 struct lyout out;
8539
8540 memset(&out, 0, sizeof out);
8541
8542 out.type = LYOUT_STREAM;
8543 out.method.f = f;
8544
8545 switch (set->type) {
8546 case LYXP_SET_EMPTY:
Michal Vasko5233e962020-08-14 14:26:20 +02008547 ly_print_(&out, "Empty XPath set\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008548 break;
8549 case LYXP_SET_BOOLEAN:
Michal Vasko5233e962020-08-14 14:26:20 +02008550 ly_print_(&out, "Boolean XPath set:\n");
8551 ly_print_(&out, "%s\n\n", set->value.bool ? "true" : "false");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008552 break;
8553 case LYXP_SET_STRING:
Michal Vasko5233e962020-08-14 14:26:20 +02008554 ly_print_(&out, "String XPath set:\n");
8555 ly_print_(&out, "\"%s\"\n\n", set->value.str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008556 break;
8557 case LYXP_SET_NUMBER:
Michal Vasko5233e962020-08-14 14:26:20 +02008558 ly_print_(&out, "Number XPath set:\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008559
8560 if (isnan(set->value.num)) {
8561 str_num = strdup("NaN");
8562 } else if ((set->value.num == 0) || (set->value.num == -0.0f)) {
8563 str_num = strdup("0");
8564 } else if (isinf(set->value.num) && !signbit(set->value.num)) {
8565 str_num = strdup("Infinity");
8566 } else if (isinf(set->value.num) && signbit(set->value.num)) {
8567 str_num = strdup("-Infinity");
8568 } else if ((long long)set->value.num == set->value.num) {
8569 if (asprintf(&str_num, "%lld", (long long)set->value.num) == -1) {
8570 str_num = NULL;
8571 }
8572 } else {
8573 if (asprintf(&str_num, "%03.1Lf", set->value.num) == -1) {
8574 str_num = NULL;
8575 }
8576 }
8577 if (!str_num) {
8578 LOGMEM;
8579 return;
8580 }
Michal Vasko5233e962020-08-14 14:26:20 +02008581 ly_print_(&out, "%s\n\n", str_num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008582 free(str_num);
8583 break;
8584 case LYXP_SET_NODE_SET:
Michal Vasko5233e962020-08-14 14:26:20 +02008585 ly_print_(&out, "Node XPath set:\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008586
8587 for (i = 0; i < set->used; ++i) {
Michal Vasko5233e962020-08-14 14:26:20 +02008588 ly_print_(&out, "%d. ", i + 1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008589 switch (set->node_type[i]) {
8590 case LYXP_NODE_ROOT_ALL:
Michal Vasko5233e962020-08-14 14:26:20 +02008591 ly_print_(&out, "ROOT all\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008592 break;
8593 case LYXP_NODE_ROOT_CONFIG:
Michal Vasko5233e962020-08-14 14:26:20 +02008594 ly_print_(&out, "ROOT config\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008595 break;
8596 case LYXP_NODE_ROOT_STATE:
Michal Vasko5233e962020-08-14 14:26:20 +02008597 ly_print_(&out, "ROOT state\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008598 break;
8599 case LYXP_NODE_ROOT_NOTIF:
Michal Vasko5233e962020-08-14 14:26:20 +02008600 ly_print_(&out, "ROOT notification \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008601 break;
8602 case LYXP_NODE_ROOT_RPC:
Michal Vasko5233e962020-08-14 14:26:20 +02008603 ly_print_(&out, "ROOT rpc \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008604 break;
8605 case LYXP_NODE_ROOT_OUTPUT:
Michal Vasko5233e962020-08-14 14:26:20 +02008606 ly_print_(&out, "ROOT output \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008607 break;
8608 case LYXP_NODE_ELEM:
Michal Vasko5233e962020-08-14 14:26:20 +02008609 ly_print_(&out, "ELEM \"%s\"\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008610 xml_print_node(&out, 1, set->value.nodes[i], 1, LYP_FORMAT);
Michal Vasko5233e962020-08-14 14:26:20 +02008611 ly_print_(&out, "\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008612 break;
8613 case LYXP_NODE_TEXT:
Michal Vasko5233e962020-08-14 14:26:20 +02008614 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 +02008615 break;
8616 case LYXP_NODE_ATTR:
Michal Vasko5233e962020-08-14 14:26:20 +02008617 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 +02008618 break;
8619 }
8620 }
8621 break;
8622 }
8623}
8624
8625#endif
8626
8627LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008628lyxp_set_cast(struct lyxp_set *set, enum lyxp_set_type target)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008629{
8630 long double num;
8631 char *str;
8632 LY_ERR rc;
8633
8634 if (!set || (set->type == target)) {
8635 return LY_SUCCESS;
8636 }
8637
8638 /* it's not possible to convert anything into a node set */
Michal Vaskod3678892020-05-21 10:06:58 +02008639 assert(target != LYXP_SET_NODE_SET);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008640
8641 if (set->type == LYXP_SET_SCNODE_SET) {
Michal Vaskod3678892020-05-21 10:06:58 +02008642 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008643 return LY_EINVAL;
8644 }
8645
8646 /* to STRING */
Michal Vaskod3678892020-05-21 10:06:58 +02008647 if ((target == LYXP_SET_STRING) || ((target == LYXP_SET_NUMBER) && (set->type == LYXP_SET_NODE_SET))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008648 switch (set->type) {
8649 case LYXP_SET_NUMBER:
8650 if (isnan(set->val.num)) {
8651 set->val.str = strdup("NaN");
8652 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
8653 } else if ((set->val.num == 0) || (set->val.num == -0.0f)) {
8654 set->val.str = strdup("0");
8655 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
8656 } else if (isinf(set->val.num) && !signbit(set->val.num)) {
8657 set->val.str = strdup("Infinity");
8658 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
8659 } else if (isinf(set->val.num) && signbit(set->val.num)) {
8660 set->val.str = strdup("-Infinity");
8661 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
8662 } else if ((long long)set->val.num == set->val.num) {
8663 if (asprintf(&str, "%lld", (long long)set->val.num) == -1) {
8664 LOGMEM_RET(set->ctx);
8665 }
8666 set->val.str = str;
8667 } else {
8668 if (asprintf(&str, "%03.1Lf", set->val.num) == -1) {
8669 LOGMEM_RET(set->ctx);
8670 }
8671 set->val.str = str;
8672 }
8673 break;
8674 case LYXP_SET_BOOLEAN:
Michal Vasko004d3152020-06-11 19:59:22 +02008675 if (set->val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008676 set->val.str = strdup("true");
8677 } else {
8678 set->val.str = strdup("false");
8679 }
8680 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), LY_EMEM);
8681 break;
8682 case LYXP_SET_NODE_SET:
Michal Vasko03ff5a72019-09-11 13:49:33 +02008683 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008684 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008685
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008686 rc = cast_node_set_to_string(set, &str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008687 LY_CHECK_RET(rc);
Michal Vaskod3678892020-05-21 10:06:58 +02008688 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008689 set->val.str = str;
8690 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008691 default:
8692 LOGINT_RET(set->ctx);
8693 }
8694 set->type = LYXP_SET_STRING;
8695 }
8696
8697 /* to NUMBER */
8698 if (target == LYXP_SET_NUMBER) {
8699 switch (set->type) {
8700 case LYXP_SET_STRING:
8701 num = cast_string_to_number(set->val.str);
Michal Vaskod3678892020-05-21 10:06:58 +02008702 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008703 set->val.num = num;
8704 break;
8705 case LYXP_SET_BOOLEAN:
Michal Vasko004d3152020-06-11 19:59:22 +02008706 if (set->val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008707 set->val.num = 1;
8708 } else {
8709 set->val.num = 0;
8710 }
8711 break;
8712 default:
8713 LOGINT_RET(set->ctx);
8714 }
8715 set->type = LYXP_SET_NUMBER;
8716 }
8717
8718 /* to BOOLEAN */
8719 if (target == LYXP_SET_BOOLEAN) {
8720 switch (set->type) {
8721 case LYXP_SET_NUMBER:
8722 if ((set->val.num == 0) || (set->val.num == -0.0f) || isnan(set->val.num)) {
Michal Vasko004d3152020-06-11 19:59:22 +02008723 set->val.bln = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008724 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02008725 set->val.bln = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008726 }
8727 break;
8728 case LYXP_SET_STRING:
8729 if (set->val.str[0]) {
Michal Vaskod3678892020-05-21 10:06:58 +02008730 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02008731 set->val.bln = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008732 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02008733 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02008734 set->val.bln = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008735 }
8736 break;
8737 case LYXP_SET_NODE_SET:
Michal Vaskod3678892020-05-21 10:06:58 +02008738 if (set->used) {
8739 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02008740 set->val.bln = 1;
Michal Vaskod3678892020-05-21 10:06:58 +02008741 } else {
8742 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02008743 set->val.bln = 0;
Michal Vaskod3678892020-05-21 10:06:58 +02008744 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02008745 break;
8746 default:
8747 LOGINT_RET(set->ctx);
8748 }
8749 set->type = LYXP_SET_BOOLEAN;
8750 }
8751
Michal Vasko03ff5a72019-09-11 13:49:33 +02008752 return LY_SUCCESS;
8753}
8754
8755LY_ERR
Michal Vasko400e9672021-01-11 13:39:17 +01008756lyxp_atomize(const struct ly_ctx *ctx, const struct lyxp_expr *exp, const struct lys_module *cur_mod,
8757 LY_PREFIX_FORMAT format, void *prefix_data, const struct lysc_node *ctx_scnode, struct lyxp_set *set,
8758 uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008759{
Radek Krejci2efc45b2020-12-22 16:25:44 +01008760 LY_ERR ret;
Michal Vasko004d3152020-06-11 19:59:22 +02008761 uint16_t tok_idx = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008762
Michal Vasko400e9672021-01-11 13:39:17 +01008763 LY_CHECK_ARG_RET(ctx, ctx, exp, set, LY_EINVAL);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008764 if (!cur_mod && ((format == LY_PREF_SCHEMA) || (format == LY_PREF_SCHEMA_RESOLVED))) {
8765 LOGARG(NULL, "Current module must be set if schema format is used.");
8766 return LY_EINVAL;
Michal Vasko004d3152020-06-11 19:59:22 +02008767 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02008768
8769 /* prepare set for evaluation */
Michal Vasko03ff5a72019-09-11 13:49:33 +02008770 memset(set, 0, sizeof *set);
8771 set->type = LYXP_SET_SCNODE_SET;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008772 set->root_type = lyxp_get_root_type(NULL, ctx_scnode, options);
8773 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 +01008774 set->val.scnodes[0].in_ctx = LYXP_SET_SCNODE_START;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008775
Michal Vasko400e9672021-01-11 13:39:17 +01008776 set->ctx = (struct ly_ctx *)ctx;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008777 set->cur_scnode = ctx_scnode;
Michal Vasko6b26e742020-07-17 15:02:10 +02008778 for (set->context_op = ctx_scnode;
Radek Krejci0f969882020-08-21 16:56:47 +02008779 set->context_op && !(set->context_op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF));
8780 set->context_op = set->context_op->parent) {}
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008781 set->cur_mod = cur_mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008782 set->format = format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008783 set->prefix_data = prefix_data;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008784
Radek Krejciddace2c2021-01-08 11:30:56 +01008785 LOG_LOCSET(set->cur_scnode, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01008786
Michal Vasko03ff5a72019-09-11 13:49:33 +02008787 /* evaluate */
Radek Krejci2efc45b2020-12-22 16:25:44 +01008788 ret = eval_expr_select(exp, &tok_idx, 0, set, options);
8789
Radek Krejciddace2c2021-01-08 11:30:56 +01008790 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01008791 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008792}
Michal Vaskod43d71a2020-08-07 14:54:58 +02008793
8794API const char *
8795lyxp_get_expr(const struct lyxp_expr *path)
8796{
8797 if (!path) {
8798 return NULL;
8799 }
8800
8801 return path->expr;
8802}