blob: 102c4ceb5e9b1736fb4241944700d6dd694cc4b8 [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
15
16/* needed by libmath functions isfinite(), isinf(), isnan(), signbit(), ... */
17#define _ISOC99_SOURCE
Radek Krejcib1646a92018-11-02 16:08:26 +010018
Radek Krejci535ea9f2020-05-29 16:01:05 +020019#include "xpath.h"
Radek Krejcib1646a92018-11-02 16:08:26 +010020
Radek Krejci535ea9f2020-05-29 16:01:05 +020021#include <assert.h>
Radek Krejcib1646a92018-11-02 16:08:26 +010022#include <ctype.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020023#include <errno.h>
24#include <limits.h>
25#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 Krejci7931b192020-06-25 17:05:03 +020036#include "parser_data.h"
Michal Vasko004d3152020-06-11 19:59:22 +020037#include "path.h"
Michal Vasko03ff5a72019-09-11 13:49:33 +020038#include "plugins_types.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020039#include "printer.h"
40#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"
43#include "tree_data_internal.h"
44#include "tree_schema_internal.h"
45#include "xml.h"
Michal Vasko03ff5a72019-09-11 13:49:33 +020046
Michal Vasko004d3152020-06-11 19:59:22 +020047static LY_ERR reparse_or_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx);
Radek Krejci1deb5be2020-08-26 16:43:36 +020048static LY_ERR eval_expr_select(struct lyxp_expr *exp, uint16_t *tok_idx, enum lyxp_expr_type etype, struct lyxp_set *set, uint32_t options);
Michal Vasko03ff5a72019-09-11 13:49:33 +020049
50/**
51 * @brief Print the type of an XPath \p set.
52 *
53 * @param[in] set Set to use.
54 * @return Set type string.
55 */
56static const char *
57print_set_type(struct lyxp_set *set)
58{
59 switch (set->type) {
Michal Vasko03ff5a72019-09-11 13:49:33 +020060 case LYXP_SET_NODE_SET:
61 return "node set";
62 case LYXP_SET_SCNODE_SET:
63 return "schema node set";
64 case LYXP_SET_BOOLEAN:
65 return "boolean";
66 case LYXP_SET_NUMBER:
67 return "number";
68 case LYXP_SET_STRING:
69 return "string";
70 }
71
72 return NULL;
73}
74
Michal Vasko24cddf82020-06-01 08:17:01 +020075const char *
76lyxp_print_token(enum lyxp_token tok)
Michal Vasko03ff5a72019-09-11 13:49:33 +020077{
78 switch (tok) {
79 case LYXP_TOKEN_PAR1:
80 return "(";
81 case LYXP_TOKEN_PAR2:
82 return ")";
83 case LYXP_TOKEN_BRACK1:
84 return "[";
85 case LYXP_TOKEN_BRACK2:
86 return "]";
87 case LYXP_TOKEN_DOT:
88 return ".";
89 case LYXP_TOKEN_DDOT:
90 return "..";
91 case LYXP_TOKEN_AT:
92 return "@";
93 case LYXP_TOKEN_COMMA:
94 return ",";
95 case LYXP_TOKEN_NAMETEST:
96 return "NameTest";
97 case LYXP_TOKEN_NODETYPE:
98 return "NodeType";
99 case LYXP_TOKEN_FUNCNAME:
100 return "FunctionName";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200101 case LYXP_TOKEN_OPER_LOG:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200102 return "Operator(Logic)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200103 case LYXP_TOKEN_OPER_EQUAL:
104 return "Operator(Equal)";
105 case LYXP_TOKEN_OPER_NEQUAL:
106 return "Operator(Non-equal)";
107 case LYXP_TOKEN_OPER_COMP:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200108 return "Operator(Comparison)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200109 case LYXP_TOKEN_OPER_MATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200110 return "Operator(Math)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200111 case LYXP_TOKEN_OPER_UNI:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200112 return "Operator(Union)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200113 case LYXP_TOKEN_OPER_PATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +0200114 return "Operator(Path)";
Michal Vasko3e48bf32020-06-01 08:39:07 +0200115 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko14676352020-05-29 11:35:55 +0200116 return "Operator(Recursive Path)";
Michal Vasko03ff5a72019-09-11 13:49:33 +0200117 case LYXP_TOKEN_LITERAL:
118 return "Literal";
119 case LYXP_TOKEN_NUMBER:
120 return "Number";
121 default:
122 LOGINT(NULL);
123 return "";
124 }
125}
126
127/**
128 * @brief Print the whole expression \p exp to debug output.
129 *
130 * @param[in] exp Expression to use.
131 */
132static void
133print_expr_struct_debug(struct lyxp_expr *exp)
134{
135 uint16_t i, j;
136 char tmp[128];
137
Radek Krejci52b6d512020-10-12 12:33:17 +0200138 if (!exp || (ly_ll < LY_LLDBG)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200139 return;
140 }
141
142 LOGDBG(LY_LDGXPATH, "expression \"%s\":", exp->expr);
143 for (i = 0; i < exp->used; ++i) {
Michal Vasko24cddf82020-06-01 08:17:01 +0200144 sprintf(tmp, "\ttoken %s, in expression \"%.*s\"", lyxp_print_token(exp->tokens[i]), exp->tok_len[i],
Michal Vasko69730152020-10-09 16:30:07 +0200145 &exp->expr[exp->tok_pos[i]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200146 if (exp->repeat[i]) {
147 sprintf(tmp + strlen(tmp), " (repeat %d", exp->repeat[i][0]);
148 for (j = 1; exp->repeat[i][j]; ++j) {
149 sprintf(tmp + strlen(tmp), ", %d", exp->repeat[i][j]);
150 }
151 strcat(tmp, ")");
152 }
153 LOGDBG(LY_LDGXPATH, tmp);
154 }
155}
156
157#ifndef NDEBUG
158
159/**
160 * @brief Print XPath set content to debug output.
161 *
162 * @param[in] set Set to print.
163 */
164static void
165print_set_debug(struct lyxp_set *set)
166{
167 uint32_t i;
168 char *str;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200169 struct lyxp_set_node *item;
170 struct lyxp_set_scnode *sitem;
171
Radek Krejci52b6d512020-10-12 12:33:17 +0200172 if (ly_ll < LY_LLDBG) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200173 return;
174 }
175
176 switch (set->type) {
177 case LYXP_SET_NODE_SET:
178 LOGDBG(LY_LDGXPATH, "set NODE SET:");
179 for (i = 0; i < set->used; ++i) {
180 item = &set->val.nodes[i];
181
182 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +0100183 case LYXP_NODE_NONE:
184 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): NONE", i + 1, item->pos);
185 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200186 case LYXP_NODE_ROOT:
187 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ROOT", i + 1, item->pos);
188 break;
189 case LYXP_NODE_ROOT_CONFIG:
190 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ROOT CONFIG", i + 1, item->pos);
191 break;
192 case LYXP_NODE_ELEM:
Michal Vasko69730152020-10-09 16:30:07 +0200193 if ((item->node->schema->nodetype == LYS_LIST) &&
194 (((struct lyd_node_inner *)item->node)->child->schema->nodetype == LYS_LEAF)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200195 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s (1st child val: %s)", i + 1, item->pos,
Michal Vasko69730152020-10-09 16:30:07 +0200196 item->node->schema->name, LYD_CANON_VALUE(lyd_child(item->node)));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200197 } else if (((struct lyd_node_inner *)item->node)->schema->nodetype == LYS_LEAFLIST) {
198 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s (val: %s)", i + 1, item->pos,
Michal Vasko69730152020-10-09 16:30:07 +0200199 item->node->schema->name, LYD_CANON_VALUE(item->node));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200200 } else {
201 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s", i + 1, item->pos, item->node->schema->name);
202 }
203 break;
204 case LYXP_NODE_TEXT:
205 if (item->node->schema->nodetype & LYS_ANYDATA) {
206 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): TEXT <%s>", i + 1, item->pos,
Michal Vasko69730152020-10-09 16:30:07 +0200207 item->node->schema->nodetype == LYS_ANYXML ? "anyxml" : "anydata");
Michal Vasko03ff5a72019-09-11 13:49:33 +0200208 } else {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200209 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 +0200210 }
211 break;
Michal Vasko9f96a052020-03-10 09:41:45 +0100212 case LYXP_NODE_META:
213 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 +0200214 set->val.meta[i].meta->value);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200215 break;
216 }
217 }
218 break;
219
220 case LYXP_SET_SCNODE_SET:
221 LOGDBG(LY_LDGXPATH, "set SCNODE SET:");
222 for (i = 0; i < set->used; ++i) {
223 sitem = &set->val.scnodes[i];
224
225 switch (sitem->type) {
226 case LYXP_NODE_ROOT:
227 LOGDBG(LY_LDGXPATH, "\t%d (%u): ROOT", i + 1, sitem->in_ctx);
228 break;
229 case LYXP_NODE_ROOT_CONFIG:
230 LOGDBG(LY_LDGXPATH, "\t%d (%u): ROOT CONFIG", i + 1, sitem->in_ctx);
231 break;
232 case LYXP_NODE_ELEM:
233 LOGDBG(LY_LDGXPATH, "\t%d (%u): ELEM %s", i + 1, sitem->in_ctx, sitem->scnode->name);
234 break;
235 default:
236 LOGINT(NULL);
237 break;
238 }
239 }
240 break;
241
Michal Vasko03ff5a72019-09-11 13:49:33 +0200242 case LYXP_SET_BOOLEAN:
243 LOGDBG(LY_LDGXPATH, "set BOOLEAN");
Michal Vasko004d3152020-06-11 19:59:22 +0200244 LOGDBG(LY_LDGXPATH, "\t%s", (set->val.bln ? "true" : "false"));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200245 break;
246
247 case LYXP_SET_STRING:
248 LOGDBG(LY_LDGXPATH, "set STRING");
249 LOGDBG(LY_LDGXPATH, "\t%s", set->val.str);
250 break;
251
252 case LYXP_SET_NUMBER:
253 LOGDBG(LY_LDGXPATH, "set NUMBER");
254
255 if (isnan(set->val.num)) {
256 str = strdup("NaN");
257 } else if ((set->val.num == 0) || (set->val.num == -0.0f)) {
258 str = strdup("0");
259 } else if (isinf(set->val.num) && !signbit(set->val.num)) {
260 str = strdup("Infinity");
261 } else if (isinf(set->val.num) && signbit(set->val.num)) {
262 str = strdup("-Infinity");
263 } else if ((long long)set->val.num == set->val.num) {
264 if (asprintf(&str, "%lld", (long long)set->val.num) == -1) {
265 str = NULL;
266 }
267 } else {
268 if (asprintf(&str, "%03.1Lf", set->val.num) == -1) {
269 str = NULL;
270 }
271 }
272 LY_CHECK_ERR_RET(!str, LOGMEM(NULL), );
273
274 LOGDBG(LY_LDGXPATH, "\t%s", str);
275 free(str);
276 }
277}
278
279#endif
280
281/**
282 * @brief Realloc the string \p str.
283 *
284 * @param[in] ctx libyang context for logging.
285 * @param[in] needed How much free space is required.
286 * @param[in,out] str Pointer to the string to use.
287 * @param[in,out] used Used bytes in \p str.
288 * @param[in,out] size Allocated bytes in \p str.
289 * @return LY_ERR
290 */
291static LY_ERR
Michal Vasko52927e22020-03-16 17:26:14 +0100292cast_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 +0200293{
294 if (*size - *used < needed) {
295 do {
296 if ((UINT16_MAX - *size) < LYXP_STRING_CAST_SIZE_STEP) {
297 LOGERR(ctx, LY_EINVAL, "XPath string length limit (%u) reached.", UINT16_MAX);
298 return LY_EINVAL;
299 }
300 *size += LYXP_STRING_CAST_SIZE_STEP;
301 } while (*size - *used < needed);
302 *str = ly_realloc(*str, *size * sizeof(char));
303 LY_CHECK_ERR_RET(!(*str), LOGMEM(ctx), LY_EMEM);
304 }
305
306 return LY_SUCCESS;
307}
308
309/**
310 * @brief Cast nodes recursively to one string @p str.
311 *
312 * @param[in] node Node to cast.
313 * @param[in] fake_cont Whether to put the data into a "fake" container.
314 * @param[in] root_type Type of the XPath root.
315 * @param[in] indent Current indent.
316 * @param[in,out] str Resulting string.
317 * @param[in,out] used Used bytes in @p str.
318 * @param[in,out] size Allocated bytes in @p str.
319 * @return LY_ERR
320 */
321static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200322cast_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 +0200323 uint16_t *used, uint16_t *size)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200324{
Radek Krejci7f769d72020-07-11 23:13:56 +0200325 char *buf, *line, *ptr = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200326 const char *value_str;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200327 const struct lyd_node *child;
Michal Vasko60ea6352020-06-29 13:39:39 +0200328 struct lyd_node *tree;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200329 struct lyd_node_any *any;
330 LY_ERR rc;
331
332 if ((root_type == LYXP_NODE_ROOT_CONFIG) && (node->schema->flags & LYS_CONFIG_R)) {
333 return LY_SUCCESS;
334 }
335
336 if (fake_cont) {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200337 rc = cast_string_realloc(LYD_CTX(node), 1, str, used, size);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200338 LY_CHECK_RET(rc);
339 strcpy(*str + (*used - 1), "\n");
340 ++(*used);
341
342 ++indent;
343 }
344
345 switch (node->schema->nodetype) {
346 case LYS_CONTAINER:
347 case LYS_LIST:
348 case LYS_RPC:
349 case LYS_NOTIF:
Michal Vaskob7be7a82020-08-20 09:09:04 +0200350 rc = cast_string_realloc(LYD_CTX(node), 1, str, used, size);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200351 LY_CHECK_RET(rc);
352 strcpy(*str + (*used - 1), "\n");
353 ++(*used);
354
Radek Krejcia1c1e542020-09-29 16:06:52 +0200355 for (child = lyd_child(node); child; child = child->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200356 rc = cast_string_recursive(child, 0, root_type, indent + 1, str, used, size);
357 LY_CHECK_RET(rc);
358 }
359
360 break;
361
362 case LYS_LEAF:
363 case LYS_LEAFLIST:
Michal Vaskob7be7a82020-08-20 09:09:04 +0200364 value_str = LYD_CANON_VALUE(node);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200365
366 /* print indent */
Michal Vaskob7be7a82020-08-20 09:09:04 +0200367 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 +0200368 memset(*str + (*used - 1), ' ', indent * 2);
369 *used += indent * 2;
370
371 /* print value */
372 if (*used == 1) {
373 sprintf(*str + (*used - 1), "%s", value_str);
374 *used += strlen(value_str);
375 } else {
376 sprintf(*str + (*used - 1), "%s\n", value_str);
377 *used += strlen(value_str) + 1;
378 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200379
380 break;
381
382 case LYS_ANYXML:
383 case LYS_ANYDATA:
384 any = (struct lyd_node_any *)node;
385 if (!(void *)any->value.tree) {
386 /* no content */
387 buf = strdup("");
Michal Vaskob7be7a82020-08-20 09:09:04 +0200388 LY_CHECK_ERR_RET(!buf, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200389 } else {
Radek Krejci241f6b52020-05-21 18:13:49 +0200390 struct ly_out *out;
Radek Krejcia5bba312020-01-09 15:41:20 +0100391
Michal Vasko60ea6352020-06-29 13:39:39 +0200392 if (any->value_type == LYD_ANYDATA_LYB) {
393 /* try to parse it into a data tree */
Michal Vaskob7be7a82020-08-20 09:09:04 +0200394 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 +0200395 /* successfully parsed */
396 free(any->value.mem);
397 any->value.tree = tree;
398 any->value_type = LYD_ANYDATA_DATATREE;
399 }
Radek Krejci7931b192020-06-25 17:05:03 +0200400 /* error is covered by the following switch where LYD_ANYDATA_LYB causes failure */
Michal Vasko60ea6352020-06-29 13:39:39 +0200401 }
402
Michal Vasko03ff5a72019-09-11 13:49:33 +0200403 switch (any->value_type) {
404 case LYD_ANYDATA_STRING:
405 case LYD_ANYDATA_XML:
406 case LYD_ANYDATA_JSON:
407 buf = strdup(any->value.json);
Michal Vaskob7be7a82020-08-20 09:09:04 +0200408 LY_CHECK_ERR_RET(!buf, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200409 break;
410 case LYD_ANYDATA_DATATREE:
Radek Krejci84ce7b12020-06-11 17:28:25 +0200411 LY_CHECK_RET(ly_out_new_memory(&buf, 0, &out));
Michal Vasko3a41dff2020-07-15 14:30:28 +0200412 rc = lyd_print_all(out, any->value.tree, LYD_XML, 0);
Radek Krejci241f6b52020-05-21 18:13:49 +0200413 ly_out_free(out, NULL, 0);
Radek Krejcia5bba312020-01-09 15:41:20 +0100414 LY_CHECK_RET(rc < 0, -rc);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200415 break;
Michal Vasko60ea6352020-06-29 13:39:39 +0200416 case LYD_ANYDATA_LYB:
Michal Vaskob7be7a82020-08-20 09:09:04 +0200417 LOGERR(LYD_CTX(node), LY_EINVAL, "Cannot convert LYB anydata into string.");
Michal Vasko60ea6352020-06-29 13:39:39 +0200418 return LY_EINVAL;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200419 }
420 }
421
422 line = strtok_r(buf, "\n", &ptr);
423 do {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200424 rc = cast_string_realloc(LYD_CTX(node), indent * 2 + strlen(line) + 1, str, used, size);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200425 if (rc != LY_SUCCESS) {
426 free(buf);
427 return rc;
428 }
429 memset(*str + (*used - 1), ' ', indent * 2);
430 *used += indent * 2;
431
432 strcpy(*str + (*used - 1), line);
433 *used += strlen(line);
434
435 strcpy(*str + (*used - 1), "\n");
436 *used += 1;
437 } while ((line = strtok_r(NULL, "\n", &ptr)));
438
439 free(buf);
440 break;
441
442 default:
Michal Vaskob7be7a82020-08-20 09:09:04 +0200443 LOGINT_RET(LYD_CTX(node));
Michal Vasko03ff5a72019-09-11 13:49:33 +0200444 }
445
446 if (fake_cont) {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200447 rc = cast_string_realloc(LYD_CTX(node), 1, str, used, size);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200448 LY_CHECK_RET(rc);
449 strcpy(*str + (*used - 1), "\n");
450 ++(*used);
451
452 --indent;
453 }
454
455 return LY_SUCCESS;
456}
457
458/**
459 * @brief Cast an element into a string.
460 *
461 * @param[in] node Node to cast.
462 * @param[in] fake_cont Whether to put the data into a "fake" container.
463 * @param[in] root_type Type of the XPath root.
464 * @param[out] str Element cast to dynamically-allocated string.
465 * @return LY_ERR
466 */
467static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200468cast_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 +0200469{
470 uint16_t used, size;
471 LY_ERR rc;
472
473 *str = malloc(LYXP_STRING_CAST_SIZE_START * sizeof(char));
Michal Vaskob7be7a82020-08-20 09:09:04 +0200474 LY_CHECK_ERR_RET(!*str, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200475 (*str)[0] = '\0';
476 used = 1;
477 size = LYXP_STRING_CAST_SIZE_START;
478
479 rc = cast_string_recursive(node, fake_cont, root_type, 0, str, &used, &size);
480 if (rc != LY_SUCCESS) {
481 free(*str);
482 return rc;
483 }
484
485 if (size > used) {
486 *str = ly_realloc(*str, used * sizeof(char));
Michal Vaskob7be7a82020-08-20 09:09:04 +0200487 LY_CHECK_ERR_RET(!*str, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200488 }
489 return LY_SUCCESS;
490}
491
492/**
493 * @brief Cast a LYXP_SET_NODE_SET set into a string.
494 * Context position aware.
495 *
496 * @param[in] set Set to cast.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200497 * @param[out] str Cast dynamically-allocated string.
498 * @return LY_ERR
499 */
500static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100501cast_node_set_to_string(struct lyxp_set *set, char **str)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200502{
Michal Vasko03ff5a72019-09-11 13:49:33 +0200503 switch (set->val.nodes[0].type) {
Michal Vasko2caefc12019-11-14 16:07:56 +0100504 case LYXP_NODE_NONE:
505 /* invalid */
506 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200507 case LYXP_NODE_ROOT:
508 case LYXP_NODE_ROOT_CONFIG:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100509 return cast_string_elem(set->val.nodes[0].node, 1, set->root_type, str);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200510 case LYXP_NODE_ELEM:
511 case LYXP_NODE_TEXT:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100512 return cast_string_elem(set->val.nodes[0].node, 0, set->root_type, str);
Michal Vasko9f96a052020-03-10 09:41:45 +0100513 case LYXP_NODE_META:
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200514 *str = strdup(set->val.meta[0].meta->value.canonical);
515 if (!*str) {
516 LOGMEM_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200517 }
518 return LY_SUCCESS;
519 }
520
521 LOGINT_RET(set->ctx);
522}
523
524/**
525 * @brief Cast a string into an XPath number.
526 *
527 * @param[in] str String to use.
528 * @return Cast number.
529 */
530static long double
531cast_string_to_number(const char *str)
532{
533 long double num;
534 char *ptr;
535
536 errno = 0;
537 num = strtold(str, &ptr);
538 if (errno || *ptr) {
539 num = NAN;
540 }
541 return num;
542}
543
544/**
545 * @brief Callback for checking value equality.
546 *
Radek Krejci857189e2020-09-01 13:26:36 +0200547 * Implementation of ::values_equal_cb.
548 *
Michal Vasko03ff5a72019-09-11 13:49:33 +0200549 * @param[in] val1_p First value.
550 * @param[in] val2_p Second value.
551 * @param[in] mod Whether hash table is being modified.
552 * @param[in] cb_data Callback data.
Radek Krejci857189e2020-09-01 13:26:36 +0200553 * @return Boolean value whether values are equal or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +0200554 */
Radek Krejci857189e2020-09-01 13:26:36 +0200555static ly_bool
556set_values_equal_cb(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *UNUSED(cb_data))
Michal Vasko03ff5a72019-09-11 13:49:33 +0200557{
558 struct lyxp_set_hash_node *val1, *val2;
559
560 val1 = (struct lyxp_set_hash_node *)val1_p;
561 val2 = (struct lyxp_set_hash_node *)val2_p;
562
563 if ((val1->node == val2->node) && (val1->type == val2->type)) {
564 return 1;
565 }
566
567 return 0;
568}
569
570/**
571 * @brief Insert node and its hash into set.
572 *
573 * @param[in] set et to insert to.
574 * @param[in] node Node with hash.
575 * @param[in] type Node type.
576 */
577static void
578set_insert_node_hash(struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type)
579{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200580 LY_ERR r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200581 uint32_t i, hash;
582 struct lyxp_set_hash_node hnode;
583
584 if (!set->ht && (set->used >= LYD_HT_MIN_ITEMS)) {
585 /* create hash table and add all the nodes */
586 set->ht = lyht_new(1, sizeof(struct lyxp_set_hash_node), set_values_equal_cb, NULL, 1);
587 for (i = 0; i < set->used; ++i) {
588 hnode.node = set->val.nodes[i].node;
589 hnode.type = set->val.nodes[i].type;
590
591 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
592 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
593 hash = dict_hash_multi(hash, NULL, 0);
594
595 r = lyht_insert(set->ht, &hnode, hash, NULL);
596 assert(!r);
597 (void)r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200598
Michal Vasko9d6befd2019-12-11 14:56:56 +0100599 if (hnode.node == node) {
600 /* it was just added, do not add it twice */
601 node = NULL;
602 }
603 }
604 }
605
606 if (set->ht && node) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200607 /* add the new node into hash table */
608 hnode.node = node;
609 hnode.type = type;
610
611 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
612 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
613 hash = dict_hash_multi(hash, NULL, 0);
614
615 r = lyht_insert(set->ht, &hnode, hash, NULL);
616 assert(!r);
617 (void)r;
618 }
619}
620
621/**
622 * @brief Remove node and its hash from set.
623 *
624 * @param[in] set Set to remove from.
625 * @param[in] node Node to remove.
626 * @param[in] type Node type.
627 */
628static void
629set_remove_node_hash(struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type)
630{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200631 LY_ERR r;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200632 struct lyxp_set_hash_node hnode;
633 uint32_t hash;
634
635 if (set->ht) {
636 hnode.node = node;
637 hnode.type = type;
638
639 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
640 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
641 hash = dict_hash_multi(hash, NULL, 0);
642
643 r = lyht_remove(set->ht, &hnode, hash);
644 assert(!r);
645 (void)r;
646
647 if (!set->ht->used) {
648 lyht_free(set->ht);
649 set->ht = NULL;
650 }
651 }
652}
653
654/**
655 * @brief Check whether node is in set based on its hash.
656 *
657 * @param[in] set Set to search in.
658 * @param[in] node Node to search for.
659 * @param[in] type Node type.
660 * @param[in] skip_idx Index in @p set to skip.
661 * @return LY_ERR
662 */
663static LY_ERR
664set_dup_node_hash_check(const struct lyxp_set *set, struct lyd_node *node, enum lyxp_node_type type, int skip_idx)
665{
666 struct lyxp_set_hash_node hnode, *match_p;
667 uint32_t hash;
668
669 hnode.node = node;
670 hnode.type = type;
671
672 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
673 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
674 hash = dict_hash_multi(hash, NULL, 0);
675
676 if (!lyht_find(set->ht, &hnode, hash, (void **)&match_p)) {
677 if ((skip_idx > -1) && (set->val.nodes[skip_idx].node == match_p->node) && (set->val.nodes[skip_idx].type == match_p->type)) {
678 /* we found it on the index that should be skipped, find another */
679 hnode = *match_p;
680 if (lyht_find_next(set->ht, &hnode, hash, (void **)&match_p)) {
681 /* none other found */
682 return LY_SUCCESS;
683 }
684 }
685
686 return LY_EEXIST;
687 }
688
689 /* not found */
690 return LY_SUCCESS;
691}
692
Michal Vaskod3678892020-05-21 10:06:58 +0200693void
694lyxp_set_free_content(struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200695{
696 if (!set) {
697 return;
698 }
699
700 if (set->type == LYXP_SET_NODE_SET) {
701 free(set->val.nodes);
702 lyht_free(set->ht);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200703 } else if (set->type == LYXP_SET_SCNODE_SET) {
704 free(set->val.scnodes);
Michal Vaskod3678892020-05-21 10:06:58 +0200705 lyht_free(set->ht);
706 } else {
707 if (set->type == LYXP_SET_STRING) {
708 free(set->val.str);
709 }
710 set->type = LYXP_SET_NODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200711 }
Michal Vaskod3678892020-05-21 10:06:58 +0200712
713 set->val.nodes = NULL;
714 set->used = 0;
715 set->size = 0;
716 set->ht = NULL;
717 set->ctx_pos = 0;
718 set->ctx_pos = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200719}
720
Michal Vasko5e0e6eb2019-11-06 15:47:50 +0100721/**
722 * @brief Free dynamically-allocated set.
723 *
724 * @param[in] set Set to free.
725 */
726static void
Michal Vasko03ff5a72019-09-11 13:49:33 +0200727lyxp_set_free(struct lyxp_set *set)
728{
729 if (!set) {
730 return;
731 }
732
Michal Vaskod3678892020-05-21 10:06:58 +0200733 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200734 free(set);
735}
736
737/**
738 * @brief Initialize set context.
739 *
740 * @param[in] new Set to initialize.
741 * @param[in] set Arbitrary initialized set.
742 */
743static void
Michal Vasko4c7763f2020-07-27 17:40:37 +0200744set_init(struct lyxp_set *new, const struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200745{
746 memset(new, 0, sizeof *new);
Michal Vasko02a77382019-09-12 11:47:35 +0200747 if (set) {
748 new->ctx = set->ctx;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200749 new->cur_node = set->cur_node;
Michal Vasko588112f2019-12-10 14:51:53 +0100750 new->root_type = set->root_type;
Michal Vasko6b26e742020-07-17 15:02:10 +0200751 new->context_op = set->context_op;
Michal Vaskof03ed032020-03-04 13:31:44 +0100752 new->tree = set->tree;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200753 new->cur_mod = set->cur_mod;
Michal Vasko02a77382019-09-12 11:47:35 +0200754 new->format = set->format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200755 new->prefix_data = set->prefix_data;
Michal Vasko02a77382019-09-12 11:47:35 +0200756 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200757}
758
759/**
760 * @brief Create a deep copy of a set.
761 *
762 * @param[in] set Set to copy.
763 * @return Copy of @p set.
764 */
765static struct lyxp_set *
766set_copy(struct lyxp_set *set)
767{
768 struct lyxp_set *ret;
769 uint16_t i;
770
771 if (!set) {
772 return NULL;
773 }
774
775 ret = malloc(sizeof *ret);
776 LY_CHECK_ERR_RET(!ret, LOGMEM(set->ctx), NULL);
777 set_init(ret, set);
778
779 if (set->type == LYXP_SET_SCNODE_SET) {
780 ret->type = set->type;
781
782 for (i = 0; i < set->used; ++i) {
Michal Vaskoba716542019-12-16 10:01:58 +0100783 if ((set->val.scnodes[i].in_ctx == 1) || (set->val.scnodes[i].in_ctx == -2)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +0200784 uint32_t idx;
785 LY_CHECK_ERR_RET(lyxp_set_scnode_insert_node(ret, set->val.scnodes[i].scnode, set->val.scnodes[i].type, &idx),
786 lyxp_set_free(ret), NULL);
Michal Vasko3f27c522020-01-06 08:37:49 +0100787 /* coverity seems to think scnodes can be NULL */
Radek Krejciaa6b53f2020-08-27 15:19:03 +0200788 if (!ret->val.scnodes) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200789 lyxp_set_free(ret);
790 return NULL;
791 }
Michal Vaskoba716542019-12-16 10:01:58 +0100792 ret->val.scnodes[idx].in_ctx = set->val.scnodes[i].in_ctx;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200793 }
794 }
795 } else if (set->type == LYXP_SET_NODE_SET) {
796 ret->type = set->type;
797 ret->val.nodes = malloc(set->used * sizeof *ret->val.nodes);
798 LY_CHECK_ERR_RET(!ret->val.nodes, LOGMEM(set->ctx); free(ret), NULL);
799 memcpy(ret->val.nodes, set->val.nodes, set->used * sizeof *ret->val.nodes);
800
801 ret->used = ret->size = set->used;
802 ret->ctx_pos = set->ctx_pos;
803 ret->ctx_size = set->ctx_size;
804 ret->ht = lyht_dup(set->ht);
805 } else {
Radek Krejci0f969882020-08-21 16:56:47 +0200806 memcpy(ret, set, sizeof *ret);
807 if (set->type == LYXP_SET_STRING) {
808 ret->val.str = strdup(set->val.str);
809 LY_CHECK_ERR_RET(!ret->val.str, LOGMEM(set->ctx); free(ret), NULL);
810 }
Michal Vasko03ff5a72019-09-11 13:49:33 +0200811 }
812
813 return ret;
814}
815
816/**
817 * @brief Fill XPath set with a string. Any current data are disposed of.
818 *
819 * @param[in] set Set to fill.
820 * @param[in] string String to fill into \p set.
821 * @param[in] str_len Length of \p string. 0 is a valid value!
822 */
823static void
824set_fill_string(struct lyxp_set *set, const char *string, uint16_t str_len)
825{
Michal Vaskod3678892020-05-21 10:06:58 +0200826 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200827
828 set->type = LYXP_SET_STRING;
829 if ((str_len == 0) && (string[0] != '\0')) {
830 string = "";
831 }
832 set->val.str = strndup(string, str_len);
833}
834
835/**
836 * @brief Fill XPath set with a number. Any current data are disposed of.
837 *
838 * @param[in] set Set to fill.
839 * @param[in] number Number to fill into \p set.
840 */
841static void
842set_fill_number(struct lyxp_set *set, long double number)
843{
Michal Vaskod3678892020-05-21 10:06:58 +0200844 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200845
846 set->type = LYXP_SET_NUMBER;
847 set->val.num = number;
848}
849
850/**
851 * @brief Fill XPath set with a boolean. Any current data are disposed of.
852 *
853 * @param[in] set Set to fill.
854 * @param[in] boolean Boolean to fill into \p set.
855 */
856static void
Radek Krejci857189e2020-09-01 13:26:36 +0200857set_fill_boolean(struct lyxp_set *set, ly_bool boolean)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200858{
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_BOOLEAN;
Michal Vasko004d3152020-06-11 19:59:22 +0200862 set->val.bln = boolean;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200863}
864
865/**
866 * @brief Fill XPath set with the value from another set (deep assign).
867 * Any current data are disposed of.
868 *
869 * @param[in] trg Set to fill.
870 * @param[in] src Source set to copy into \p trg.
871 */
872static void
Michal Vasko4c7763f2020-07-27 17:40:37 +0200873set_fill_set(struct lyxp_set *trg, const struct lyxp_set *src)
Michal Vasko03ff5a72019-09-11 13:49:33 +0200874{
875 if (!trg || !src) {
876 return;
877 }
878
879 if (trg->type == LYXP_SET_NODE_SET) {
880 free(trg->val.nodes);
881 } else if (trg->type == LYXP_SET_STRING) {
882 free(trg->val.str);
883 }
884 set_init(trg, src);
885
886 if (src->type == LYXP_SET_SCNODE_SET) {
887 trg->type = LYXP_SET_SCNODE_SET;
888 trg->used = src->used;
889 trg->size = src->used;
890
891 trg->val.scnodes = ly_realloc(trg->val.scnodes, trg->size * sizeof *trg->val.scnodes);
892 LY_CHECK_ERR_RET(!trg->val.scnodes, LOGMEM(src->ctx); memset(trg, 0, sizeof *trg), );
893 memcpy(trg->val.scnodes, src->val.scnodes, src->used * sizeof *src->val.scnodes);
894 } else if (src->type == LYXP_SET_BOOLEAN) {
Michal Vasko004d3152020-06-11 19:59:22 +0200895 set_fill_boolean(trg, src->val.bln);
Michal Vasko44f3d2c2020-08-24 09:49:38 +0200896 } else if (src->type == LYXP_SET_NUMBER) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200897 set_fill_number(trg, src->val.num);
898 } else if (src->type == LYXP_SET_STRING) {
899 set_fill_string(trg, src->val.str, strlen(src->val.str));
900 } else {
901 if (trg->type == LYXP_SET_NODE_SET) {
902 free(trg->val.nodes);
903 } else if (trg->type == LYXP_SET_STRING) {
904 free(trg->val.str);
905 }
906
Michal Vaskod3678892020-05-21 10:06:58 +0200907 assert(src->type == LYXP_SET_NODE_SET);
908
909 trg->type = LYXP_SET_NODE_SET;
910 trg->used = src->used;
911 trg->size = src->used;
912 trg->ctx_pos = src->ctx_pos;
913 trg->ctx_size = src->ctx_size;
914
915 trg->val.nodes = malloc(trg->used * sizeof *trg->val.nodes);
916 LY_CHECK_ERR_RET(!trg->val.nodes, LOGMEM(src->ctx); memset(trg, 0, sizeof *trg), );
917 memcpy(trg->val.nodes, src->val.nodes, src->used * sizeof *src->val.nodes);
918 if (src->ht) {
919 trg->ht = lyht_dup(src->ht);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200920 } else {
Michal Vaskod3678892020-05-21 10:06:58 +0200921 trg->ht = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200922 }
923 }
924}
925
926/**
927 * @brief Clear context of all schema nodes.
928 *
929 * @param[in] set Set to clear.
930 */
931static void
932set_scnode_clear_ctx(struct lyxp_set *set)
933{
934 uint32_t i;
935
936 for (i = 0; i < set->used; ++i) {
937 if (set->val.scnodes[i].in_ctx == 1) {
938 set->val.scnodes[i].in_ctx = 0;
Michal Vasko5c4e5892019-11-14 12:31:38 +0100939 } else if (set->val.scnodes[i].in_ctx == -2) {
940 set->val.scnodes[i].in_ctx = -1;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200941 }
942 }
943}
944
945/**
946 * @brief Remove a node from a set. Removing last node changes
947 * set into LYXP_SET_EMPTY. Context position aware.
948 *
949 * @param[in] set Set to use.
950 * @param[in] idx Index from @p set of the node to be removed.
951 */
952static void
953set_remove_node(struct lyxp_set *set, uint32_t idx)
954{
955 assert(set && (set->type == LYXP_SET_NODE_SET));
956 assert(idx < set->used);
957
958 set_remove_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
959
960 --set->used;
961 if (set->used) {
962 memmove(&set->val.nodes[idx], &set->val.nodes[idx + 1],
963 (set->used - idx) * sizeof *set->val.nodes);
964 } else {
Michal Vaskod3678892020-05-21 10:06:58 +0200965 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200966 }
967}
968
969/**
Michal Vasko2caefc12019-11-14 16:07:56 +0100970 * @brief Remove a node from a set by setting its type to LYXP_NODE_NONE.
Michal Vasko57eab132019-09-24 11:46:26 +0200971 *
972 * @param[in] set Set to use.
973 * @param[in] idx Index from @p set of the node to be removed.
974 */
975static void
Michal Vasko2caefc12019-11-14 16:07:56 +0100976set_remove_node_none(struct lyxp_set *set, uint32_t idx)
Michal Vasko57eab132019-09-24 11:46:26 +0200977{
978 assert(set && (set->type == LYXP_SET_NODE_SET));
979 assert(idx < set->used);
980
Michal Vasko2caefc12019-11-14 16:07:56 +0100981 if (set->val.nodes[idx].type == LYXP_NODE_ELEM) {
982 set_remove_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
983 }
984 set->val.nodes[idx].type = LYXP_NODE_NONE;
Michal Vasko57eab132019-09-24 11:46:26 +0200985}
986
987/**
Michal Vasko2caefc12019-11-14 16:07:56 +0100988 * @brief Remove all LYXP_NODE_NONE nodes from a set. Removing last node changes
Michal Vasko57eab132019-09-24 11:46:26 +0200989 * set into LYXP_SET_EMPTY. Context position aware.
990 *
991 * @param[in] set Set to consolidate.
992 */
993static void
Michal Vasko2caefc12019-11-14 16:07:56 +0100994set_remove_nodes_none(struct lyxp_set *set)
Michal Vasko57eab132019-09-24 11:46:26 +0200995{
Michal Vaskoed4fcfe2020-07-08 10:38:56 +0200996 uint16_t i, orig_used, end = 0;
Michal Vasko57eab132019-09-24 11:46:26 +0200997 int32_t start;
998
Michal Vaskod3678892020-05-21 10:06:58 +0200999 assert(set);
Michal Vasko57eab132019-09-24 11:46:26 +02001000
1001 orig_used = set->used;
1002 set->used = 0;
Michal Vaskod989ba02020-08-24 10:59:24 +02001003 for (i = 0; i < orig_used; ) {
Michal Vasko57eab132019-09-24 11:46:26 +02001004 start = -1;
1005 do {
Michal Vasko2caefc12019-11-14 16:07:56 +01001006 if ((set->val.nodes[i].type != LYXP_NODE_NONE) && (start == -1)) {
Michal Vasko57eab132019-09-24 11:46:26 +02001007 start = i;
Michal Vasko2caefc12019-11-14 16:07:56 +01001008 } else if ((start > -1) && (set->val.nodes[i].type == LYXP_NODE_NONE)) {
Michal Vasko57eab132019-09-24 11:46:26 +02001009 end = i;
1010 ++i;
1011 break;
1012 }
1013
1014 ++i;
1015 if (i == orig_used) {
1016 end = i;
1017 }
1018 } while (i < orig_used);
1019
1020 if (start > -1) {
1021 /* move the whole chunk of valid nodes together */
1022 if (set->used != (unsigned)start) {
1023 memmove(&set->val.nodes[set->used], &set->val.nodes[start], (end - start) * sizeof *set->val.nodes);
1024 }
1025 set->used += end - start;
1026 }
1027 }
Michal Vasko57eab132019-09-24 11:46:26 +02001028}
1029
1030/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02001031 * @brief Check for duplicates in a node set.
1032 *
1033 * @param[in] set Set to check.
1034 * @param[in] node Node to look for in @p set.
1035 * @param[in] node_type Type of @p node.
1036 * @param[in] skip_idx Index from @p set to skip.
1037 * @return LY_ERR
1038 */
1039static LY_ERR
1040set_dup_node_check(const struct lyxp_set *set, const struct lyd_node *node, enum lyxp_node_type node_type, int skip_idx)
1041{
1042 uint32_t i;
1043
Michal Vasko2caefc12019-11-14 16:07:56 +01001044 if (set->ht && node) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001045 return set_dup_node_hash_check(set, (struct lyd_node *)node, node_type, skip_idx);
1046 }
1047
1048 for (i = 0; i < set->used; ++i) {
1049 if ((skip_idx > -1) && (i == (unsigned)skip_idx)) {
1050 continue;
1051 }
1052
1053 if ((set->val.nodes[i].node == node) && (set->val.nodes[i].type == node_type)) {
1054 return LY_EEXIST;
1055 }
1056 }
1057
1058 return LY_SUCCESS;
1059}
1060
Radek Krejci857189e2020-09-01 13:26:36 +02001061ly_bool
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001062lyxp_set_scnode_contains(struct lyxp_set *set, const struct lysc_node *node, enum lyxp_node_type node_type, int skip_idx,
1063 uint32_t *index_p)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001064{
1065 uint32_t i;
1066
1067 for (i = 0; i < set->used; ++i) {
1068 if ((skip_idx > -1) && (i == (unsigned)skip_idx)) {
1069 continue;
1070 }
1071
1072 if ((set->val.scnodes[i].scnode == node) && (set->val.scnodes[i].type == node_type)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001073 if (index_p) {
1074 *index_p = i;
1075 }
1076 return 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001077 }
1078 }
1079
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001080 return 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001081}
1082
Michal Vaskoecd62de2019-11-13 12:35:11 +01001083void
1084lyxp_set_scnode_merge(struct lyxp_set *set1, struct lyxp_set *set2)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001085{
1086 uint32_t orig_used, i, j;
1087
Michal Vaskod3678892020-05-21 10:06:58 +02001088 assert((set1->type == LYXP_SET_SCNODE_SET) && (set2->type == LYXP_SET_SCNODE_SET));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001089
Michal Vaskod3678892020-05-21 10:06:58 +02001090 if (!set2->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001091 return;
1092 }
1093
Michal Vaskod3678892020-05-21 10:06:58 +02001094 if (!set1->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001095 memcpy(set1, set2, sizeof *set1);
1096 return;
1097 }
1098
1099 if (set1->used + set2->used > set1->size) {
1100 set1->size = set1->used + set2->used;
1101 set1->val.scnodes = ly_realloc(set1->val.scnodes, set1->size * sizeof *set1->val.scnodes);
1102 LY_CHECK_ERR_RET(!set1->val.scnodes, LOGMEM(set1->ctx), );
1103 }
1104
1105 orig_used = set1->used;
1106
1107 for (i = 0; i < set2->used; ++i) {
1108 for (j = 0; j < orig_used; ++j) {
1109 /* detect duplicities */
1110 if (set1->val.scnodes[j].scnode == set2->val.scnodes[i].scnode) {
1111 break;
1112 }
1113 }
1114
1115 if (j == orig_used) {
1116 memcpy(&set1->val.scnodes[set1->used], &set2->val.scnodes[i], sizeof *set2->val.scnodes);
1117 ++set1->used;
1118 }
1119 }
1120
Michal Vaskod3678892020-05-21 10:06:58 +02001121 lyxp_set_free_content(set2);
1122 set2->type = LYXP_SET_SCNODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001123}
1124
1125/**
1126 * @brief Insert a node into a set. Context position aware.
1127 *
1128 * @param[in] set Set to use.
1129 * @param[in] node Node to insert to @p set.
1130 * @param[in] pos Sort position of @p node. If left 0, it is filled just before sorting.
1131 * @param[in] node_type Node type of @p node.
1132 * @param[in] idx Index in @p set to insert into.
1133 */
1134static void
1135set_insert_node(struct lyxp_set *set, const struct lyd_node *node, uint32_t pos, enum lyxp_node_type node_type, uint32_t idx)
1136{
Michal Vaskod3678892020-05-21 10:06:58 +02001137 assert(set && (set->type == LYXP_SET_NODE_SET));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001138
Michal Vaskod3678892020-05-21 10:06:58 +02001139 if (!set->size) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001140 /* first item */
1141 if (idx) {
1142 /* no real harm done, but it is a bug */
1143 LOGINT(set->ctx);
1144 idx = 0;
1145 }
1146 set->val.nodes = malloc(LYXP_SET_SIZE_START * sizeof *set->val.nodes);
1147 LY_CHECK_ERR_RET(!set->val.nodes, LOGMEM(set->ctx), );
1148 set->type = LYXP_SET_NODE_SET;
1149 set->used = 0;
1150 set->size = LYXP_SET_SIZE_START;
1151 set->ctx_pos = 1;
1152 set->ctx_size = 1;
1153 set->ht = NULL;
1154 } else {
1155 /* not an empty set */
1156 if (set->used == set->size) {
1157
1158 /* set is full */
1159 set->val.nodes = ly_realloc(set->val.nodes, (set->size + LYXP_SET_SIZE_STEP) * sizeof *set->val.nodes);
1160 LY_CHECK_ERR_RET(!set->val.nodes, LOGMEM(set->ctx), );
1161 set->size += LYXP_SET_SIZE_STEP;
1162 }
1163
1164 if (idx > set->used) {
1165 LOGINT(set->ctx);
1166 idx = set->used;
1167 }
1168
1169 /* make space for the new node */
1170 if (idx < set->used) {
1171 memmove(&set->val.nodes[idx + 1], &set->val.nodes[idx], (set->used - idx) * sizeof *set->val.nodes);
1172 }
1173 }
1174
1175 /* finally assign the value */
1176 set->val.nodes[idx].node = (struct lyd_node *)node;
1177 set->val.nodes[idx].type = node_type;
1178 set->val.nodes[idx].pos = pos;
1179 ++set->used;
1180
Michal Vasko2caefc12019-11-14 16:07:56 +01001181 if (set->val.nodes[idx].type == LYXP_NODE_ELEM) {
1182 set_insert_node_hash(set, (struct lyd_node *)node, node_type);
1183 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02001184}
1185
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001186LY_ERR
1187lyxp_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 +02001188{
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001189 uint32_t index;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001190
1191 assert(set->type == LYXP_SET_SCNODE_SET);
1192
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001193 if (lyxp_set_scnode_contains(set, node, node_type, -1, &index)) {
1194 set->val.scnodes[index].in_ctx = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001195 } else {
1196 if (set->used == set->size) {
1197 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 +02001198 LY_CHECK_ERR_RET(!set->val.scnodes, LOGMEM(set->ctx), LY_EMEM);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001199 set->size += LYXP_SET_SIZE_STEP;
1200 }
1201
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001202 index = set->used;
1203 set->val.scnodes[index].scnode = (struct lysc_node *)node;
1204 set->val.scnodes[index].type = node_type;
1205 set->val.scnodes[index].in_ctx = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001206 ++set->used;
1207 }
1208
Radek Krejciaa6b53f2020-08-27 15:19:03 +02001209 if (index_p) {
1210 *index_p = index;
1211 }
1212
1213 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001214}
1215
1216/**
1217 * @brief Replace a node in a set with another. Context position aware.
1218 *
1219 * @param[in] set Set to use.
1220 * @param[in] node Node to insert to @p set.
1221 * @param[in] pos Sort position of @p node. If left 0, it is filled just before sorting.
1222 * @param[in] node_type Node type of @p node.
1223 * @param[in] idx Index in @p set of the node to replace.
1224 */
1225static void
1226set_replace_node(struct lyxp_set *set, const struct lyd_node *node, uint32_t pos, enum lyxp_node_type node_type, uint32_t idx)
1227{
1228 assert(set && (idx < set->used));
1229
Michal Vasko2caefc12019-11-14 16:07:56 +01001230 if (set->val.nodes[idx].type == LYXP_NODE_ELEM) {
1231 set_remove_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
1232 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02001233 set->val.nodes[idx].node = (struct lyd_node *)node;
1234 set->val.nodes[idx].type = node_type;
1235 set->val.nodes[idx].pos = pos;
Michal Vasko2caefc12019-11-14 16:07:56 +01001236 if (set->val.nodes[idx].type == LYXP_NODE_ELEM) {
1237 set_insert_node_hash(set, set->val.nodes[idx].node, set->val.nodes[idx].type);
1238 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02001239}
1240
1241/**
1242 * @brief Set all nodes with ctx 1 to a new unique context value.
1243 *
1244 * @param[in] set Set to modify.
1245 * @return New context value.
1246 */
Michal Vasko5c4e5892019-11-14 12:31:38 +01001247static int32_t
Michal Vasko03ff5a72019-09-11 13:49:33 +02001248set_scnode_new_in_ctx(struct lyxp_set *set)
1249{
Michal Vasko5c4e5892019-11-14 12:31:38 +01001250 uint32_t i;
1251 int32_t ret_ctx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001252
1253 assert(set->type == LYXP_SET_SCNODE_SET);
1254
1255 ret_ctx = 3;
1256retry:
1257 for (i = 0; i < set->used; ++i) {
1258 if (set->val.scnodes[i].in_ctx >= ret_ctx) {
1259 ret_ctx = set->val.scnodes[i].in_ctx + 1;
1260 goto retry;
1261 }
1262 }
1263 for (i = 0; i < set->used; ++i) {
1264 if (set->val.scnodes[i].in_ctx == 1) {
1265 set->val.scnodes[i].in_ctx = ret_ctx;
1266 }
1267 }
1268
1269 return ret_ctx;
1270}
1271
1272/**
1273 * @brief Get unique @p node position in the data.
1274 *
1275 * @param[in] node Node to find.
1276 * @param[in] node_type Node type of @p node.
1277 * @param[in] root Root node.
1278 * @param[in] root_type Type of the XPath @p root node.
1279 * @param[in] prev Node that we think is before @p node in DFS from @p root. Can optionally
1280 * be used to increase efficiency and start the DFS from this node.
1281 * @param[in] prev_pos Node @p prev position. Optional, but must be set if @p prev is set.
1282 * @return Node position.
1283 */
1284static uint32_t
1285get_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 +02001286 enum lyxp_node_type root_type, const struct lyd_node **prev, uint32_t *prev_pos)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001287{
Michal Vasko56daf732020-08-10 10:57:18 +02001288 const struct lyd_node *elem = NULL, *top_sibling;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001289 uint32_t pos = 1;
1290
1291 assert(prev && prev_pos && !root->prev->next);
1292
1293 if ((node_type == LYXP_NODE_ROOT) || (node_type == LYXP_NODE_ROOT_CONFIG)) {
1294 return 0;
1295 }
1296
1297 if (*prev) {
1298 /* start from the previous element instead from the root */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001299 pos = *prev_pos;
Radek Krejci1e008d22020-08-17 11:37:37 +02001300 for (top_sibling = *prev; top_sibling->parent; top_sibling = (struct lyd_node *)top_sibling->parent) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001301 goto dfs_search;
1302 }
1303
1304 for (top_sibling = root; top_sibling; top_sibling = top_sibling->next) {
Michal Vasko56daf732020-08-10 10:57:18 +02001305 LYD_TREE_DFS_BEGIN(top_sibling, elem) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001306dfs_search:
Michal Vasko56daf732020-08-10 10:57:18 +02001307 if (*prev && !elem) {
1308 /* resume previous DFS */
1309 elem = LYD_TREE_DFS_next = (struct lyd_node *)*prev;
1310 LYD_TREE_DFS_continue = 0;
1311 }
1312
Michal Vasko03ff5a72019-09-11 13:49:33 +02001313 if ((root_type == LYXP_NODE_ROOT_CONFIG) && (elem->schema->flags & LYS_CONFIG_R)) {
Michal Vasko56daf732020-08-10 10:57:18 +02001314 /* skip */
1315 LYD_TREE_DFS_continue = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001316 } else {
Michal Vasko56daf732020-08-10 10:57:18 +02001317 if (elem == node) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001318 break;
1319 }
Michal Vasko56daf732020-08-10 10:57:18 +02001320 ++pos;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001321 }
Michal Vasko56daf732020-08-10 10:57:18 +02001322
1323 LYD_TREE_DFS_END(top_sibling, elem);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001324 }
1325
1326 /* node found */
1327 if (elem) {
1328 break;
1329 }
1330 }
1331
1332 if (!elem) {
1333 if (!(*prev)) {
1334 /* we went from root and failed to find it, cannot be */
Michal Vaskob7be7a82020-08-20 09:09:04 +02001335 LOGINT(LYD_CTX(node));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001336 return 0;
1337 } else {
Michal Vasko56daf732020-08-10 10:57:18 +02001338 /* start the search again from the beginning */
1339 *prev = root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001340
Michal Vasko56daf732020-08-10 10:57:18 +02001341 top_sibling = root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001342 pos = 1;
1343 goto dfs_search;
1344 }
1345 }
1346
1347 /* remember the last found node for next time */
1348 *prev = node;
1349 *prev_pos = pos;
1350
1351 return pos;
1352}
1353
1354/**
1355 * @brief Assign (fill) missing node positions.
1356 *
1357 * @param[in] set Set to fill positions in.
1358 * @param[in] root Context root node.
1359 * @param[in] root_type Context root type.
1360 * @return LY_ERR
1361 */
1362static LY_ERR
1363set_assign_pos(struct lyxp_set *set, const struct lyd_node *root, enum lyxp_node_type root_type)
1364{
1365 const struct lyd_node *prev = NULL, *tmp_node;
1366 uint32_t i, tmp_pos = 0;
1367
1368 for (i = 0; i < set->used; ++i) {
1369 if (!set->val.nodes[i].pos) {
1370 tmp_node = NULL;
1371 switch (set->val.nodes[i].type) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001372 case LYXP_NODE_META:
1373 tmp_node = set->val.meta[i].meta->parent;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001374 if (!tmp_node) {
1375 LOGINT_RET(root->schema->module->ctx);
1376 }
Radek Krejci0f969882020-08-21 16:56:47 +02001377 /* fallthrough */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001378 case LYXP_NODE_ELEM:
1379 case LYXP_NODE_TEXT:
1380 if (!tmp_node) {
1381 tmp_node = set->val.nodes[i].node;
1382 }
1383 set->val.nodes[i].pos = get_node_pos(tmp_node, set->val.nodes[i].type, root, root_type, &prev, &tmp_pos);
1384 break;
1385 default:
1386 /* all roots have position 0 */
1387 break;
1388 }
1389 }
1390 }
1391
1392 return LY_SUCCESS;
1393}
1394
1395/**
Michal Vasko9f96a052020-03-10 09:41:45 +01001396 * @brief Get unique @p meta position in the parent metadata.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001397 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001398 * @param[in] meta Metadata to use.
1399 * @return Metadata position.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001400 */
1401static uint16_t
Michal Vasko9f96a052020-03-10 09:41:45 +01001402get_meta_pos(struct lyd_meta *meta)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001403{
1404 uint16_t pos = 0;
Michal Vasko9f96a052020-03-10 09:41:45 +01001405 struct lyd_meta *meta2;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001406
Michal Vasko9f96a052020-03-10 09:41:45 +01001407 for (meta2 = meta->parent->meta; meta2 && (meta2 != meta); meta2 = meta2->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001408 ++pos;
1409 }
1410
Michal Vasko9f96a052020-03-10 09:41:45 +01001411 assert(meta2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001412 return pos;
1413}
1414
1415/**
1416 * @brief Compare 2 nodes in respect to XPath document order.
1417 *
1418 * @param[in] item1 1st node.
1419 * @param[in] item2 2nd node.
1420 * @return If 1st > 2nd returns 1, 1st == 2nd returns 0, and 1st < 2nd returns -1.
1421 */
1422static int
1423set_sort_compare(struct lyxp_set_node *item1, struct lyxp_set_node *item2)
1424{
Michal Vasko9f96a052020-03-10 09:41:45 +01001425 uint32_t meta_pos1 = 0, meta_pos2 = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001426
1427 if (item1->pos < item2->pos) {
1428 return -1;
1429 }
1430
1431 if (item1->pos > item2->pos) {
1432 return 1;
1433 }
1434
1435 /* node positions are equal, the fun case */
1436
1437 /* 1st ELEM - == - 2nd TEXT, 1st TEXT - == - 2nd ELEM */
1438 /* special case since text nodes are actually saved as their parents */
1439 if ((item1->node == item2->node) && (item1->type != item2->type)) {
1440 if (item1->type == LYXP_NODE_ELEM) {
1441 assert(item2->type == LYXP_NODE_TEXT);
1442 return -1;
1443 } else {
1444 assert((item1->type == LYXP_NODE_TEXT) && (item2->type == LYXP_NODE_ELEM));
1445 return 1;
1446 }
1447 }
1448
Michal Vasko9f96a052020-03-10 09:41:45 +01001449 /* we need meta positions now */
1450 if (item1->type == LYXP_NODE_META) {
1451 meta_pos1 = get_meta_pos((struct lyd_meta *)item1->node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001452 }
Michal Vasko9f96a052020-03-10 09:41:45 +01001453 if (item2->type == LYXP_NODE_META) {
1454 meta_pos2 = get_meta_pos((struct lyd_meta *)item2->node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001455 }
1456
Michal Vasko9f96a052020-03-10 09:41:45 +01001457 /* 1st ROOT - 2nd ROOT, 1st ELEM - 2nd ELEM, 1st TEXT - 2nd TEXT, 1st META - =pos= - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001458 /* check for duplicates */
1459 if (item1->node == item2->node) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001460 assert((item1->type == item2->type) && ((item1->type != LYXP_NODE_META) || (meta_pos1 == meta_pos2)));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001461 return 0;
1462 }
1463
Michal Vasko9f96a052020-03-10 09:41:45 +01001464 /* 1st ELEM - 2nd TEXT, 1st ELEM - any pos - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001465 /* elem is always first, 2nd node is after it */
1466 if (item1->type == LYXP_NODE_ELEM) {
1467 assert(item2->type != LYXP_NODE_ELEM);
1468 return -1;
1469 }
1470
Michal Vasko9f96a052020-03-10 09:41:45 +01001471 /* 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 +02001472 /* 2nd is before 1st */
Michal Vasko69730152020-10-09 16:30:07 +02001473 if (((item1->type == LYXP_NODE_TEXT) &&
1474 ((item2->type == LYXP_NODE_ELEM) || (item2->type == LYXP_NODE_META))) ||
1475 ((item1->type == LYXP_NODE_META) && (item2->type == LYXP_NODE_ELEM)) ||
1476 (((item1->type == LYXP_NODE_META) && (item2->type == LYXP_NODE_META)) &&
1477 (meta_pos1 > meta_pos2))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001478 return 1;
1479 }
1480
Michal Vasko9f96a052020-03-10 09:41:45 +01001481 /* 1st META - any pos - 2nd TEXT, 1st META <pos< - 2nd META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001482 /* 2nd is after 1st */
1483 return -1;
1484}
1485
1486/**
1487 * @brief Set cast for comparisons.
1488 *
1489 * @param[in] trg Target set to cast source into.
1490 * @param[in] src Source set.
1491 * @param[in] type Target set type.
1492 * @param[in] src_idx Source set node index.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001493 * @return LY_ERR
1494 */
1495static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001496set_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 +02001497{
1498 assert(src->type == LYXP_SET_NODE_SET);
1499
1500 set_init(trg, src);
1501
1502 /* insert node into target set */
1503 set_insert_node(trg, src->val.nodes[src_idx].node, src->val.nodes[src_idx].pos, src->val.nodes[src_idx].type, 0);
1504
1505 /* cast target set appropriately */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001506 return lyxp_set_cast(trg, type);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001507}
1508
Michal Vasko4c7763f2020-07-27 17:40:37 +02001509/**
1510 * @brief Set content canonization for comparisons.
1511 *
1512 * @param[in] trg Target set to put the canononized source into.
1513 * @param[in] src Source set.
1514 * @param[in] xp_node Source XPath node/meta to use for canonization.
1515 * @return LY_ERR
1516 */
1517static LY_ERR
1518set_comp_canonize(struct lyxp_set *trg, const struct lyxp_set *src, const struct lyxp_set_node *xp_node)
1519{
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001520 const struct lysc_type *type = NULL;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001521 struct lyd_value val;
1522 struct ly_err_item *err = NULL;
1523 char *str, *ptr;
Radek Krejci857189e2020-09-01 13:26:36 +02001524 ly_bool dynamic;
Michal Vasko4c7763f2020-07-27 17:40:37 +02001525 LY_ERR rc;
1526
1527 /* is there anything to canonize even? */
1528 if ((src->type == LYXP_SET_NUMBER) || (src->type == LYXP_SET_STRING)) {
1529 /* do we have a type to use for canonization? */
1530 if ((xp_node->type == LYXP_NODE_ELEM) && (xp_node->node->schema->nodetype & LYD_NODE_TERM)) {
1531 type = ((struct lyd_node_term *)xp_node->node)->value.realtype;
1532 } else if (xp_node->type == LYXP_NODE_META) {
1533 type = ((struct lyd_meta *)xp_node->node)->value.realtype;
1534 }
1535 }
1536 if (!type) {
1537 goto fill;
1538 }
1539
1540 if (src->type == LYXP_SET_NUMBER) {
1541 /* canonize number */
1542 if (asprintf(&str, "%Lf", src->val.num) == -1) {
1543 LOGMEM(src->ctx);
1544 return LY_EMEM;
1545 }
1546 } else {
1547 /* canonize string */
1548 str = strdup(src->val.str);
1549 }
1550
1551 /* ignore errors, the value may not satisfy schema constraints */
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001552 rc = type->plugin->store(src->ctx, type, str, strlen(str), LY_TYPE_OPTS_DYNAMIC, LY_PREF_JSON, NULL, LYD_HINT_DATA,
1553 xp_node->node->schema, &val, &err);
Michal Vasko4c7763f2020-07-27 17:40:37 +02001554 ly_err_free(err);
1555 if (rc) {
1556 /* invalid value */
1557 free(str);
1558 goto fill;
1559 }
1560
1561 /* storing successful, now print the canonical value */
Michal Vaskoc8a230d2020-08-14 12:17:10 +02001562 str = (char *)type->plugin->print(&val, LY_PREF_JSON, NULL, &dynamic);
Michal Vasko4c7763f2020-07-27 17:40:37 +02001563
1564 /* use the canonized value */
1565 set_init(trg, src);
1566 trg->type = src->type;
1567 if (src->type == LYXP_SET_NUMBER) {
1568 trg->val.num = strtold(str, &ptr);
1569 if (dynamic) {
1570 free(str);
1571 }
1572 LY_CHECK_ERR_RET(ptr[0], LOGINT(src->ctx), LY_EINT);
1573 } else {
1574 trg->val.str = (dynamic ? str : strdup(str));
1575 }
1576 type->plugin->free(src->ctx, &val);
1577 return LY_SUCCESS;
1578
1579fill:
1580 /* no canonization needed/possible */
1581 set_fill_set(trg, src);
1582 return LY_SUCCESS;
1583}
1584
Michal Vasko03ff5a72019-09-11 13:49:33 +02001585#ifndef NDEBUG
1586
1587/**
1588 * @brief Bubble sort @p set into XPath document order.
1589 * Context position aware. Unused in the 'Release' build target.
1590 *
1591 * @param[in] set Set to sort.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001592 * @return How many times the whole set was traversed - 1 (if set was sorted, returns 0).
1593 */
1594static int
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001595set_sort(struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001596{
1597 uint32_t i, j;
Radek Krejci1deb5be2020-08-26 16:43:36 +02001598 int ret = 0, cmp;
Radek Krejci857189e2020-09-01 13:26:36 +02001599 ly_bool inverted, change;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001600 const struct lyd_node *root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001601 struct lyxp_set_node item;
1602 struct lyxp_set_hash_node hnode;
1603 uint64_t hash;
1604
Michal Vasko3cf8fbf2020-05-27 15:21:21 +02001605 if ((set->type != LYXP_SET_NODE_SET) || (set->used < 2)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001606 return 0;
1607 }
1608
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001609 /* find first top-level node to be used as anchor for positions */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001610 for (root = set->cur_node; root->parent; root = (const struct lyd_node *)root->parent) {}
Michal Vaskod989ba02020-08-24 10:59:24 +02001611 for ( ; root->prev->next; root = root->prev) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001612
1613 /* fill positions */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001614 if (set_assign_pos(set, root, set->root_type)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001615 return -1;
1616 }
1617
1618 LOGDBG(LY_LDGXPATH, "SORT BEGIN");
1619 print_set_debug(set);
1620
1621 for (i = 0; i < set->used; ++i) {
1622 inverted = 0;
1623 change = 0;
1624
1625 for (j = 1; j < set->used - i; ++j) {
1626 /* compare node positions */
1627 if (inverted) {
1628 cmp = set_sort_compare(&set->val.nodes[j], &set->val.nodes[j - 1]);
1629 } else {
1630 cmp = set_sort_compare(&set->val.nodes[j - 1], &set->val.nodes[j]);
1631 }
1632
1633 /* swap if needed */
1634 if ((inverted && (cmp < 0)) || (!inverted && (cmp > 0))) {
1635 change = 1;
1636
1637 item = set->val.nodes[j - 1];
1638 set->val.nodes[j - 1] = set->val.nodes[j];
1639 set->val.nodes[j] = item;
1640 } else {
1641 /* whether node_pos1 should be smaller than node_pos2 or the other way around */
1642 inverted = !inverted;
1643 }
1644 }
1645
1646 ++ret;
1647
1648 if (!change) {
1649 break;
1650 }
1651 }
1652
1653 LOGDBG(LY_LDGXPATH, "SORT END %d", ret);
1654 print_set_debug(set);
1655
1656 /* check node hashes */
1657 if (set->used >= LYD_HT_MIN_ITEMS) {
1658 assert(set->ht);
1659 for (i = 0; i < set->used; ++i) {
1660 hnode.node = set->val.nodes[i].node;
1661 hnode.type = set->val.nodes[i].type;
1662
1663 hash = dict_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
1664 hash = dict_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
1665 hash = dict_hash_multi(hash, NULL, 0);
1666
1667 assert(!lyht_find(set->ht, &hnode, hash, NULL));
1668 }
1669 }
1670
1671 return ret - 1;
1672}
1673
1674/**
1675 * @brief Remove duplicate entries in a sorted node set.
1676 *
1677 * @param[in] set Sorted set to check.
1678 * @return LY_ERR (LY_EEXIST if some duplicates are found)
1679 */
1680static LY_ERR
1681set_sorted_dup_node_clean(struct lyxp_set *set)
1682{
1683 uint32_t i = 0;
1684 LY_ERR ret = LY_SUCCESS;
1685
1686 if (set->used > 1) {
1687 while (i < set->used - 1) {
Michal Vasko69730152020-10-09 16:30:07 +02001688 if ((set->val.nodes[i].node == set->val.nodes[i + 1].node) &&
1689 (set->val.nodes[i].type == set->val.nodes[i + 1].type)) {
Michal Vasko2caefc12019-11-14 16:07:56 +01001690 set_remove_node_none(set, i + 1);
Michal Vasko57eab132019-09-24 11:46:26 +02001691 ret = LY_EEXIST;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001692 }
Michal Vasko57eab132019-09-24 11:46:26 +02001693 ++i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001694 }
1695 }
1696
Michal Vasko2caefc12019-11-14 16:07:56 +01001697 set_remove_nodes_none(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001698 return ret;
1699}
1700
1701#endif
1702
1703/**
1704 * @brief Merge 2 sorted sets into one.
1705 *
1706 * @param[in,out] trg Set to merge into. Duplicates are removed.
1707 * @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 +02001708 * @return LY_ERR
1709 */
1710static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001711set_sorted_merge(struct lyxp_set *trg, struct lyxp_set *src)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001712{
1713 uint32_t i, j, k, count, dup_count;
1714 int cmp;
1715 const struct lyd_node *root;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001716
Michal Vaskod3678892020-05-21 10:06:58 +02001717 if ((trg->type != LYXP_SET_NODE_SET) || (src->type != LYXP_SET_NODE_SET)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001718 return LY_EINVAL;
1719 }
1720
Michal Vaskod3678892020-05-21 10:06:58 +02001721 if (!src->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001722 return LY_SUCCESS;
Michal Vaskod3678892020-05-21 10:06:58 +02001723 } else if (!trg->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001724 set_fill_set(trg, src);
Michal Vaskod3678892020-05-21 10:06:58 +02001725 lyxp_set_free_content(src);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001726 return LY_SUCCESS;
1727 }
1728
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001729 /* find first top-level node to be used as anchor for positions */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001730 for (root = trg->cur_node; root->parent; root = (const struct lyd_node *)root->parent) {}
Michal Vaskod989ba02020-08-24 10:59:24 +02001731 for ( ; root->prev->next; root = root->prev) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02001732
1733 /* fill positions */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01001734 if (set_assign_pos(trg, root, trg->root_type) || set_assign_pos(src, root, src->root_type)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001735 return LY_EINT;
1736 }
1737
1738#ifndef NDEBUG
1739 LOGDBG(LY_LDGXPATH, "MERGE target");
1740 print_set_debug(trg);
1741 LOGDBG(LY_LDGXPATH, "MERGE source");
1742 print_set_debug(src);
1743#endif
1744
1745 /* make memory for the merge (duplicates are not detected yet, so space
1746 * will likely be wasted on them, too bad) */
1747 if (trg->size - trg->used < src->used) {
1748 trg->size = trg->used + src->used;
1749
1750 trg->val.nodes = ly_realloc(trg->val.nodes, trg->size * sizeof *trg->val.nodes);
1751 LY_CHECK_ERR_RET(!trg->val.nodes, LOGMEM(src->ctx), LY_EMEM);
1752 }
1753
1754 i = 0;
1755 j = 0;
1756 count = 0;
1757 dup_count = 0;
1758 do {
1759 cmp = set_sort_compare(&src->val.nodes[i], &trg->val.nodes[j]);
1760 if (!cmp) {
1761 if (!count) {
1762 /* duplicate, just skip it */
1763 ++i;
1764 ++j;
1765 } else {
1766 /* we are copying something already, so let's copy the duplicate too,
1767 * we are hoping that afterwards there are some more nodes to
1768 * copy and this way we can copy them all together */
1769 ++count;
1770 ++dup_count;
1771 ++i;
1772 ++j;
1773 }
1774 } else if (cmp < 0) {
1775 /* inserting src node into trg, just remember it for now */
1776 ++count;
1777 ++i;
1778
1779 /* insert the hash now */
1780 set_insert_node_hash(trg, src->val.nodes[i - 1].node, src->val.nodes[i - 1].type);
1781 } else if (count) {
1782copy_nodes:
1783 /* time to actually copy the nodes, we have found the largest block of nodes */
1784 memmove(&trg->val.nodes[j + (count - dup_count)],
1785 &trg->val.nodes[j],
1786 (trg->used - j) * sizeof *trg->val.nodes);
1787 memcpy(&trg->val.nodes[j - dup_count], &src->val.nodes[i - count], count * sizeof *src->val.nodes);
1788
1789 trg->used += count - dup_count;
1790 /* do not change i, except the copying above, we are basically doing exactly what is in the else branch below */
1791 j += count - dup_count;
1792
1793 count = 0;
1794 dup_count = 0;
1795 } else {
1796 ++j;
1797 }
1798 } while ((i < src->used) && (j < trg->used));
1799
1800 if ((i < src->used) || count) {
1801 /* insert all the hashes first */
1802 for (k = i; k < src->used; ++k) {
1803 set_insert_node_hash(trg, src->val.nodes[k].node, src->val.nodes[k].type);
1804 }
1805
1806 /* loop ended, but we need to copy something at trg end */
1807 count += src->used - i;
1808 i = src->used;
1809 goto copy_nodes;
1810 }
1811
1812 /* we are inserting hashes before the actual node insert, which causes
1813 * situations when there were initially not enough items for a hash table,
1814 * but even after some were inserted, hash table was not created (during
1815 * insertion the number of items is not updated yet) */
1816 if (!trg->ht && (trg->used >= LYD_HT_MIN_ITEMS)) {
1817 set_insert_node_hash(trg, NULL, 0);
1818 }
1819
1820#ifndef NDEBUG
1821 LOGDBG(LY_LDGXPATH, "MERGE result");
1822 print_set_debug(trg);
1823#endif
1824
Michal Vaskod3678892020-05-21 10:06:58 +02001825 lyxp_set_free_content(src);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001826 return LY_SUCCESS;
1827}
1828
1829/*
1830 * (re)parse functions
1831 *
1832 * Parse functions parse the expression into
1833 * tokens (syntactic analysis).
1834 *
1835 * Reparse functions perform semantic analysis
1836 * (do not save the result, just a check) of
1837 * the expression and fill repeat indices.
1838 */
1839
Michal Vasko14676352020-05-29 11:35:55 +02001840LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02001841lyxp_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 +02001842{
Michal Vasko004d3152020-06-11 19:59:22 +02001843 if (exp->used == tok_idx) {
Michal Vasko14676352020-05-29 11:35:55 +02001844 if (ctx) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001845 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_EOF);
1846 }
Michal Vasko14676352020-05-29 11:35:55 +02001847 return LY_EINCOMPLETE;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001848 }
1849
Michal Vasko004d3152020-06-11 19:59:22 +02001850 if (want_tok && (exp->tokens[tok_idx] != want_tok)) {
Michal Vasko14676352020-05-29 11:35:55 +02001851 if (ctx) {
Michal Vasko0b468e62020-10-19 09:33:04 +02001852 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_INTOK2, lyxp_print_token(exp->tokens[tok_idx]),
1853 &exp->expr[exp->tok_pos[tok_idx]], lyxp_print_token(want_tok));
Michal Vasko03ff5a72019-09-11 13:49:33 +02001854 }
Michal Vasko14676352020-05-29 11:35:55 +02001855 return LY_ENOT;
1856 }
1857
1858 return LY_SUCCESS;
1859}
1860
Michal Vasko004d3152020-06-11 19:59:22 +02001861LY_ERR
1862lyxp_next_token(const struct ly_ctx *ctx, const struct lyxp_expr *exp, uint16_t *tok_idx, enum lyxp_token want_tok)
1863{
1864 LY_CHECK_RET(lyxp_check_token(ctx, exp, *tok_idx, want_tok));
1865
1866 /* skip the token */
1867 ++(*tok_idx);
1868
1869 return LY_SUCCESS;
1870}
1871
Michal Vasko14676352020-05-29 11:35:55 +02001872/* just like lyxp_check_token() but tests for 2 tokens */
1873static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02001874exp_check_token2(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t tok_idx, enum lyxp_token want_tok1,
Radek Krejci0f969882020-08-21 16:56:47 +02001875 enum lyxp_token want_tok2)
Michal Vasko14676352020-05-29 11:35:55 +02001876{
Michal Vasko004d3152020-06-11 19:59:22 +02001877 if (exp->used == tok_idx) {
Michal Vasko14676352020-05-29 11:35:55 +02001878 if (ctx) {
1879 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_EOF);
1880 }
1881 return LY_EINCOMPLETE;
1882 }
1883
Michal Vasko004d3152020-06-11 19:59:22 +02001884 if ((exp->tokens[tok_idx] != want_tok1) && (exp->tokens[tok_idx] != want_tok2)) {
Michal Vasko14676352020-05-29 11:35:55 +02001885 if (ctx) {
Michal Vasko0b468e62020-10-19 09:33:04 +02001886 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_INTOK, lyxp_print_token(exp->tokens[tok_idx]),
1887 &exp->expr[exp->tok_pos[tok_idx]]);
Michal Vasko14676352020-05-29 11:35:55 +02001888 }
1889 return LY_ENOT;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001890 }
1891
1892 return LY_SUCCESS;
1893}
1894
1895/**
1896 * @brief Stack operation push on the repeat array.
1897 *
1898 * @param[in] exp Expression to use.
Michal Vasko004d3152020-06-11 19:59:22 +02001899 * @param[in] tok_idx Position in the expresion \p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001900 * @param[in] repeat_op_idx Index from \p exp of the operator token. This value is pushed.
1901 */
1902static void
Michal Vasko004d3152020-06-11 19:59:22 +02001903exp_repeat_push(struct lyxp_expr *exp, uint16_t tok_idx, uint16_t repeat_op_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001904{
1905 uint16_t i;
1906
Michal Vasko004d3152020-06-11 19:59:22 +02001907 if (exp->repeat[tok_idx]) {
Radek Krejci1e008d22020-08-17 11:37:37 +02001908 for (i = 0; exp->repeat[tok_idx][i]; ++i) {}
Michal Vasko004d3152020-06-11 19:59:22 +02001909 exp->repeat[tok_idx] = realloc(exp->repeat[tok_idx], (i + 2) * sizeof *exp->repeat[tok_idx]);
1910 LY_CHECK_ERR_RET(!exp->repeat[tok_idx], LOGMEM(NULL), );
1911 exp->repeat[tok_idx][i] = repeat_op_idx;
1912 exp->repeat[tok_idx][i + 1] = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001913 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02001914 exp->repeat[tok_idx] = calloc(2, sizeof *exp->repeat[tok_idx]);
1915 LY_CHECK_ERR_RET(!exp->repeat[tok_idx], LOGMEM(NULL), );
1916 exp->repeat[tok_idx][0] = repeat_op_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02001917 }
1918}
1919
1920/**
1921 * @brief Reparse Predicate. Logs directly on error.
1922 *
1923 * [7] Predicate ::= '[' Expr ']'
1924 *
1925 * @param[in] ctx Context for logging.
1926 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02001927 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001928 * @return LY_ERR
1929 */
1930static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02001931reparse_predicate(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001932{
1933 LY_ERR rc;
1934
Michal Vasko004d3152020-06-11 19:59:22 +02001935 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_BRACK1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001936 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02001937 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001938
Michal Vasko004d3152020-06-11 19:59:22 +02001939 rc = reparse_or_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001940 LY_CHECK_RET(rc);
1941
Michal Vasko004d3152020-06-11 19:59:22 +02001942 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_BRACK2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001943 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02001944 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001945
1946 return LY_SUCCESS;
1947}
1948
1949/**
1950 * @brief Reparse RelativeLocationPath. Logs directly on error.
1951 *
1952 * [4] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
1953 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
1954 * [6] NodeTest ::= NameTest | NodeType '(' ')'
1955 *
1956 * @param[in] ctx Context for logging.
1957 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02001958 * @param[in] tok_idx Position in the expression \p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02001959 * @return LY_ERR (LY_EINCOMPLETE on forward reference)
1960 */
1961static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02001962reparse_relative_location_path(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02001963{
1964 LY_ERR rc;
1965
Michal Vasko004d3152020-06-11 19:59:22 +02001966 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001967 LY_CHECK_RET(rc);
1968
1969 goto step;
1970 do {
1971 /* '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02001972 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001973
Michal Vasko004d3152020-06-11 19:59:22 +02001974 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001975 LY_CHECK_RET(rc);
1976step:
1977 /* Step */
Michal Vasko004d3152020-06-11 19:59:22 +02001978 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001979 case LYXP_TOKEN_DOT:
Michal Vasko004d3152020-06-11 19:59:22 +02001980 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001981 break;
1982
1983 case LYXP_TOKEN_DDOT:
Michal Vasko004d3152020-06-11 19:59:22 +02001984 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001985 break;
1986
1987 case LYXP_TOKEN_AT:
Michal Vasko004d3152020-06-11 19:59:22 +02001988 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001989
Michal Vasko004d3152020-06-11 19:59:22 +02001990 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001991 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02001992 if ((exp->tokens[*tok_idx] != LYXP_TOKEN_NAMETEST) && (exp->tokens[*tok_idx] != LYXP_TOKEN_NODETYPE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02001993 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_INTOK,
Michal Vasko69730152020-10-09 16:30:07 +02001994 lyxp_print_token(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001995 return LY_EVALID;
1996 }
Radek Krejci0f969882020-08-21 16:56:47 +02001997 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001998 case LYXP_TOKEN_NAMETEST:
Michal Vasko004d3152020-06-11 19:59:22 +02001999 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002000 goto reparse_predicate;
2001 break;
2002
2003 case LYXP_TOKEN_NODETYPE:
Michal Vasko004d3152020-06-11 19:59:22 +02002004 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002005
2006 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02002007 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002008 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002009 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002010
2011 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02002012 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002013 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002014 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002015
2016reparse_predicate:
2017 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002018 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
2019 rc = reparse_predicate(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002020 LY_CHECK_RET(rc);
2021 }
2022 break;
2023 default:
2024 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_INTOK,
Michal Vasko69730152020-10-09 16:30:07 +02002025 lyxp_print_token(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002026 return LY_EVALID;
2027 }
Michal Vasko004d3152020-06-11 19:59:22 +02002028 } while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH));
Michal Vasko03ff5a72019-09-11 13:49:33 +02002029
2030 return LY_SUCCESS;
2031}
2032
2033/**
2034 * @brief Reparse AbsoluteLocationPath. Logs directly on error.
2035 *
2036 * [3] AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
2037 *
2038 * @param[in] ctx Context for logging.
2039 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002040 * @param[in] tok_idx Position in the expression \p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002041 * @return LY_ERR
2042 */
2043static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002044reparse_absolute_location_path(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002045{
2046 LY_ERR rc;
2047
Michal Vasko004d3152020-06-11 19:59:22 +02002048 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 +02002049
2050 /* '/' RelativeLocationPath? */
Michal Vasko004d3152020-06-11 19:59:22 +02002051 if (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002052 /* '/' */
Michal Vasko004d3152020-06-11 19:59:22 +02002053 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002054
Michal Vasko004d3152020-06-11 19:59:22 +02002055 if (lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002056 return LY_SUCCESS;
2057 }
Michal Vasko004d3152020-06-11 19:59:22 +02002058 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002059 case LYXP_TOKEN_DOT:
2060 case LYXP_TOKEN_DDOT:
2061 case LYXP_TOKEN_AT:
2062 case LYXP_TOKEN_NAMETEST:
2063 case LYXP_TOKEN_NODETYPE:
Michal Vasko004d3152020-06-11 19:59:22 +02002064 rc = reparse_relative_location_path(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002065 LY_CHECK_RET(rc);
Radek Krejci0f969882020-08-21 16:56:47 +02002066 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02002067 default:
2068 break;
2069 }
2070
Michal Vasko03ff5a72019-09-11 13:49:33 +02002071 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02002072 /* '//' RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02002073 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002074
Michal Vasko004d3152020-06-11 19:59:22 +02002075 rc = reparse_relative_location_path(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002076 LY_CHECK_RET(rc);
2077 }
2078
2079 return LY_SUCCESS;
2080}
2081
2082/**
2083 * @brief Reparse FunctionCall. Logs directly on error.
2084 *
2085 * [9] FunctionCall ::= FunctionName '(' ( Expr ( ',' Expr )* )? ')'
2086 *
2087 * @param[in] ctx Context for logging.
2088 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002089 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002090 * @return LY_ERR
2091 */
2092static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002093reparse_function_call(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002094{
Radek Krejci1deb5be2020-08-26 16:43:36 +02002095 int8_t min_arg_count = -1;
2096 uint32_t arg_count, max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002097 uint16_t func_tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002098 LY_ERR rc;
2099
Michal Vasko004d3152020-06-11 19:59:22 +02002100 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_FUNCNAME);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002101 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002102 func_tok_idx = *tok_idx;
2103 switch (exp->tok_len[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002104 case 3:
Michal Vasko004d3152020-06-11 19:59:22 +02002105 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "not", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002106 min_arg_count = 1;
2107 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002108 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "sum", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002109 min_arg_count = 1;
2110 max_arg_count = 1;
2111 }
2112 break;
2113 case 4:
Michal Vasko004d3152020-06-11 19:59:22 +02002114 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "lang", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002115 min_arg_count = 1;
2116 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002117 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "last", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002118 min_arg_count = 0;
2119 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002120 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "name", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002121 min_arg_count = 0;
2122 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002123 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "true", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002124 min_arg_count = 0;
2125 max_arg_count = 0;
2126 }
2127 break;
2128 case 5:
Michal Vasko004d3152020-06-11 19:59:22 +02002129 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "count", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002130 min_arg_count = 1;
2131 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002132 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "false", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002133 min_arg_count = 0;
2134 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002135 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "floor", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002136 min_arg_count = 1;
2137 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002138 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "round", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002139 min_arg_count = 1;
2140 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002141 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "deref", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002142 min_arg_count = 1;
2143 max_arg_count = 1;
2144 }
2145 break;
2146 case 6:
Michal Vasko004d3152020-06-11 19:59:22 +02002147 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "concat", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002148 min_arg_count = 2;
Radek Krejci1deb5be2020-08-26 16:43:36 +02002149 max_arg_count = UINT32_MAX;
Michal Vasko004d3152020-06-11 19:59:22 +02002150 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "number", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002151 min_arg_count = 0;
2152 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002153 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002154 min_arg_count = 0;
2155 max_arg_count = 1;
2156 }
2157 break;
2158 case 7:
Michal Vasko004d3152020-06-11 19:59:22 +02002159 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "boolean", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002160 min_arg_count = 1;
2161 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002162 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "ceiling", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002163 min_arg_count = 1;
2164 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002165 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "current", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002166 min_arg_count = 0;
2167 max_arg_count = 0;
2168 }
2169 break;
2170 case 8:
Michal Vasko004d3152020-06-11 19:59:22 +02002171 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "contains", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002172 min_arg_count = 2;
2173 max_arg_count = 2;
Michal Vasko004d3152020-06-11 19:59:22 +02002174 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "position", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002175 min_arg_count = 0;
2176 max_arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002177 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "re-match", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002178 min_arg_count = 2;
2179 max_arg_count = 2;
2180 }
2181 break;
2182 case 9:
Michal Vasko004d3152020-06-11 19:59:22 +02002183 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002184 min_arg_count = 2;
2185 max_arg_count = 3;
Michal Vasko004d3152020-06-11 19:59:22 +02002186 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "translate", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002187 min_arg_count = 3;
2188 max_arg_count = 3;
2189 }
2190 break;
2191 case 10:
Michal Vasko004d3152020-06-11 19:59:22 +02002192 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "local-name", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002193 min_arg_count = 0;
2194 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002195 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "enum-value", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002196 min_arg_count = 1;
2197 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002198 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "bit-is-set", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002199 min_arg_count = 2;
2200 max_arg_count = 2;
2201 }
2202 break;
2203 case 11:
Michal Vasko004d3152020-06-11 19:59:22 +02002204 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "starts-with", 11)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002205 min_arg_count = 2;
2206 max_arg_count = 2;
2207 }
2208 break;
2209 case 12:
Michal Vasko004d3152020-06-11 19:59:22 +02002210 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from", 12)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002211 min_arg_count = 2;
2212 max_arg_count = 2;
2213 }
2214 break;
2215 case 13:
Michal Vasko004d3152020-06-11 19:59:22 +02002216 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "namespace-uri", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002217 min_arg_count = 0;
2218 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002219 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string-length", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002220 min_arg_count = 0;
2221 max_arg_count = 1;
2222 }
2223 break;
2224 case 15:
Michal Vasko004d3152020-06-11 19:59:22 +02002225 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "normalize-space", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002226 min_arg_count = 0;
2227 max_arg_count = 1;
Michal Vasko004d3152020-06-11 19:59:22 +02002228 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-after", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002229 min_arg_count = 2;
2230 max_arg_count = 2;
2231 }
2232 break;
2233 case 16:
Michal Vasko004d3152020-06-11 19:59:22 +02002234 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-before", 16)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002235 min_arg_count = 2;
2236 max_arg_count = 2;
2237 }
2238 break;
2239 case 20:
Michal Vasko004d3152020-06-11 19:59:22 +02002240 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from-or-self", 20)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002241 min_arg_count = 2;
2242 max_arg_count = 2;
2243 }
2244 break;
2245 }
2246 if (min_arg_count == -1) {
Michal Vasko004d3152020-06-11 19:59:22 +02002247 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_INFUNC, exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002248 return LY_EINVAL;
2249 }
Michal Vasko004d3152020-06-11 19:59:22 +02002250 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002251
2252 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02002253 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002254 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002255 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002256
2257 /* ( Expr ( ',' Expr )* )? */
2258 arg_count = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002259 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002260 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002261 if (exp->tokens[*tok_idx] != LYXP_TOKEN_PAR2) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002262 ++arg_count;
Michal Vasko004d3152020-06-11 19:59:22 +02002263 rc = reparse_or_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002264 LY_CHECK_RET(rc);
2265 }
Michal Vasko004d3152020-06-11 19:59:22 +02002266 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_COMMA)) {
2267 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002268
2269 ++arg_count;
Michal Vasko004d3152020-06-11 19:59:22 +02002270 rc = reparse_or_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002271 LY_CHECK_RET(rc);
2272 }
2273
2274 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02002275 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002276 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002277 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002278
Radek Krejci857189e2020-09-01 13:26:36 +02002279 if ((arg_count < (uint32_t)min_arg_count) || (arg_count > max_arg_count)) {
Michal Vasko004d3152020-06-11 19:59:22 +02002280 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_INARGCOUNT, arg_count, exp->tok_len[func_tok_idx],
Michal Vasko69730152020-10-09 16:30:07 +02002281 &exp->expr[exp->tok_pos[func_tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002282 return LY_EVALID;
2283 }
2284
2285 return LY_SUCCESS;
2286}
2287
2288/**
2289 * @brief Reparse PathExpr. Logs directly on error.
2290 *
2291 * [10] PathExpr ::= LocationPath | PrimaryExpr Predicate*
2292 * | PrimaryExpr Predicate* '/' RelativeLocationPath
2293 * | PrimaryExpr Predicate* '//' RelativeLocationPath
2294 * [2] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
2295 * [8] PrimaryExpr ::= '(' Expr ')' | Literal | Number | FunctionCall
2296 *
2297 * @param[in] ctx Context for logging.
2298 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002299 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002300 * @return LY_ERR
2301 */
2302static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002303reparse_path_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002304{
2305 LY_ERR rc;
2306
Michal Vasko004d3152020-06-11 19:59:22 +02002307 if (lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko14676352020-05-29 11:35:55 +02002308 return LY_EVALID;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002309 }
2310
Michal Vasko004d3152020-06-11 19:59:22 +02002311 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002312 case LYXP_TOKEN_PAR1:
2313 /* '(' Expr ')' Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002314 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002315
Michal Vasko004d3152020-06-11 19:59:22 +02002316 rc = reparse_or_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002317 LY_CHECK_RET(rc);
2318
Michal Vasko004d3152020-06-11 19:59:22 +02002319 rc = lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002320 LY_CHECK_RET(rc);
Michal Vasko004d3152020-06-11 19:59:22 +02002321 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002322 goto predicate;
2323 break;
2324 case LYXP_TOKEN_DOT:
2325 case LYXP_TOKEN_DDOT:
2326 case LYXP_TOKEN_AT:
2327 case LYXP_TOKEN_NAMETEST:
2328 case LYXP_TOKEN_NODETYPE:
2329 /* RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02002330 rc = reparse_relative_location_path(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002331 LY_CHECK_RET(rc);
2332 break;
2333 case LYXP_TOKEN_FUNCNAME:
2334 /* FunctionCall */
Michal Vasko004d3152020-06-11 19:59:22 +02002335 rc = reparse_function_call(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002336 LY_CHECK_RET(rc);
2337 goto predicate;
2338 break;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002339 case LYXP_TOKEN_OPER_PATH:
2340 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +02002341 /* AbsoluteLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02002342 rc = reparse_absolute_location_path(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002343 LY_CHECK_RET(rc);
2344 break;
2345 case LYXP_TOKEN_LITERAL:
2346 /* Literal */
Michal Vasko004d3152020-06-11 19:59:22 +02002347 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002348 goto predicate;
2349 break;
2350 case LYXP_TOKEN_NUMBER:
2351 /* Number */
Michal Vasko004d3152020-06-11 19:59:22 +02002352 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002353 goto predicate;
2354 break;
2355 default:
2356 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_INTOK,
Michal Vasko69730152020-10-09 16:30:07 +02002357 lyxp_print_token(exp->tokens[*tok_idx]), &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002358 return LY_EVALID;
2359 }
2360
2361 return LY_SUCCESS;
2362
2363predicate:
2364 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02002365 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
2366 rc = reparse_predicate(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002367 LY_CHECK_RET(rc);
2368 }
2369
2370 /* ('/' or '//') RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02002371 if (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002372
2373 /* '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02002374 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002375
Michal Vasko004d3152020-06-11 19:59:22 +02002376 rc = reparse_relative_location_path(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002377 LY_CHECK_RET(rc);
2378 }
2379
2380 return LY_SUCCESS;
2381}
2382
2383/**
2384 * @brief Reparse UnaryExpr. Logs directly on error.
2385 *
2386 * [17] UnaryExpr ::= UnionExpr | '-' UnaryExpr
2387 * [18] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
2388 *
2389 * @param[in] ctx Context for logging.
2390 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002391 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002392 * @return LY_ERR
2393 */
2394static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002395reparse_unary_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002396{
2397 uint16_t prev_exp;
2398 LY_ERR rc;
2399
2400 /* ('-')* */
Michal Vasko004d3152020-06-11 19:59:22 +02002401 prev_exp = *tok_idx;
Michal Vasko69730152020-10-09 16:30:07 +02002402 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2403 (exp->expr[exp->tok_pos[*tok_idx]] == '-')) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002404 exp_repeat_push(exp, prev_exp, LYXP_EXPR_UNARY);
Michal Vasko004d3152020-06-11 19:59:22 +02002405 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002406 }
2407
2408 /* PathExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002409 prev_exp = *tok_idx;
2410 rc = reparse_path_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002411 LY_CHECK_RET(rc);
2412
2413 /* ('|' PathExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002414 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_UNI)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002415 exp_repeat_push(exp, prev_exp, LYXP_EXPR_UNION);
Michal Vasko004d3152020-06-11 19:59:22 +02002416 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002417
Michal Vasko004d3152020-06-11 19:59:22 +02002418 rc = reparse_path_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002419 LY_CHECK_RET(rc);
2420 }
2421
2422 return LY_SUCCESS;
2423}
2424
2425/**
2426 * @brief Reparse AdditiveExpr. Logs directly on error.
2427 *
2428 * [15] AdditiveExpr ::= MultiplicativeExpr
2429 * | AdditiveExpr '+' MultiplicativeExpr
2430 * | AdditiveExpr '-' MultiplicativeExpr
2431 * [16] MultiplicativeExpr ::= UnaryExpr
2432 * | MultiplicativeExpr '*' UnaryExpr
2433 * | MultiplicativeExpr 'div' UnaryExpr
2434 * | MultiplicativeExpr 'mod' UnaryExpr
2435 *
2436 * @param[in] ctx Context for logging.
2437 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002438 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002439 * @return LY_ERR
2440 */
2441static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002442reparse_additive_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002443{
2444 uint16_t prev_add_exp, prev_mul_exp;
2445 LY_ERR rc;
2446
Michal Vasko004d3152020-06-11 19:59:22 +02002447 prev_add_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002448 goto reparse_multiplicative_expr;
2449
2450 /* ('+' / '-' MultiplicativeExpr)* */
Michal Vasko69730152020-10-09 16:30:07 +02002451 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2452 ((exp->expr[exp->tok_pos[*tok_idx]] == '+') || (exp->expr[exp->tok_pos[*tok_idx]] == '-'))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002453 exp_repeat_push(exp, prev_add_exp, LYXP_EXPR_ADDITIVE);
Michal Vasko004d3152020-06-11 19:59:22 +02002454 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002455
2456reparse_multiplicative_expr:
2457 /* UnaryExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002458 prev_mul_exp = *tok_idx;
2459 rc = reparse_unary_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002460 LY_CHECK_RET(rc);
2461
2462 /* ('*' / 'div' / 'mod' UnaryExpr)* */
Michal Vasko69730152020-10-09 16:30:07 +02002463 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_MATH) &&
2464 ((exp->expr[exp->tok_pos[*tok_idx]] == '*') || (exp->tok_len[*tok_idx] == 3))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002465 exp_repeat_push(exp, prev_mul_exp, LYXP_EXPR_MULTIPLICATIVE);
Michal Vasko004d3152020-06-11 19:59:22 +02002466 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002467
Michal Vasko004d3152020-06-11 19:59:22 +02002468 rc = reparse_unary_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002469 LY_CHECK_RET(rc);
2470 }
2471 }
2472
2473 return LY_SUCCESS;
2474}
2475
2476/**
2477 * @brief Reparse EqualityExpr. Logs directly on error.
2478 *
2479 * [13] EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr
2480 * | EqualityExpr '!=' RelationalExpr
2481 * [14] RelationalExpr ::= AdditiveExpr
2482 * | RelationalExpr '<' AdditiveExpr
2483 * | RelationalExpr '>' AdditiveExpr
2484 * | RelationalExpr '<=' AdditiveExpr
2485 * | RelationalExpr '>=' AdditiveExpr
2486 *
2487 * @param[in] ctx Context for logging.
2488 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002489 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002490 * @return LY_ERR
2491 */
2492static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002493reparse_equality_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002494{
2495 uint16_t prev_eq_exp, prev_rel_exp;
2496 LY_ERR rc;
2497
Michal Vasko004d3152020-06-11 19:59:22 +02002498 prev_eq_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002499 goto reparse_additive_expr;
2500
2501 /* ('=' / '!=' RelationalExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002502 while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_EQUAL, LYXP_TOKEN_OPER_NEQUAL)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002503 exp_repeat_push(exp, prev_eq_exp, LYXP_EXPR_EQUALITY);
Michal Vasko004d3152020-06-11 19:59:22 +02002504 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002505
2506reparse_additive_expr:
2507 /* AdditiveExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002508 prev_rel_exp = *tok_idx;
2509 rc = reparse_additive_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002510 LY_CHECK_RET(rc);
2511
2512 /* ('<' / '>' / '<=' / '>=' AdditiveExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002513 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_COMP)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002514 exp_repeat_push(exp, prev_rel_exp, LYXP_EXPR_RELATIONAL);
Michal Vasko004d3152020-06-11 19:59:22 +02002515 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002516
Michal Vasko004d3152020-06-11 19:59:22 +02002517 rc = reparse_additive_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002518 LY_CHECK_RET(rc);
2519 }
2520 }
2521
2522 return LY_SUCCESS;
2523}
2524
2525/**
2526 * @brief Reparse OrExpr. Logs directly on error.
2527 *
2528 * [11] OrExpr ::= AndExpr | OrExpr 'or' AndExpr
2529 * [12] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
2530 *
2531 * @param[in] ctx Context for logging.
2532 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02002533 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002534 * @return LY_ERR
2535 */
2536static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002537reparse_or_expr(const struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx)
Michal Vasko03ff5a72019-09-11 13:49:33 +02002538{
2539 uint16_t prev_or_exp, prev_and_exp;
2540 LY_ERR rc;
2541
Michal Vasko004d3152020-06-11 19:59:22 +02002542 prev_or_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002543 goto reparse_equality_expr;
2544
2545 /* ('or' AndExpr)* */
Michal Vasko004d3152020-06-11 19:59:22 +02002546 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 +02002547 exp_repeat_push(exp, prev_or_exp, LYXP_EXPR_OR);
Michal Vasko004d3152020-06-11 19:59:22 +02002548 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002549
2550reparse_equality_expr:
2551 /* EqualityExpr */
Michal Vasko004d3152020-06-11 19:59:22 +02002552 prev_and_exp = *tok_idx;
2553 rc = reparse_equality_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002554 LY_CHECK_RET(rc);
2555
2556 /* ('and' EqualityExpr)* */
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] == 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002558 exp_repeat_push(exp, prev_and_exp, LYXP_EXPR_AND);
Michal Vasko004d3152020-06-11 19:59:22 +02002559 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002560
Michal Vasko004d3152020-06-11 19:59:22 +02002561 rc = reparse_equality_expr(ctx, exp, tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002562 LY_CHECK_RET(rc);
2563 }
2564 }
2565
2566 return LY_SUCCESS;
2567}
Radek Krejcib1646a92018-11-02 16:08:26 +01002568
2569/**
2570 * @brief Parse NCName.
2571 *
2572 * @param[in] ncname Name to parse.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002573 * @return Length of @p ncname valid bytes.
Radek Krejcib1646a92018-11-02 16:08:26 +01002574 */
Radek Krejcid4270262019-01-07 15:07:25 +01002575static long int
Radek Krejcib1646a92018-11-02 16:08:26 +01002576parse_ncname(const char *ncname)
2577{
Radek Krejci1deb5be2020-08-26 16:43:36 +02002578 uint32_t uc;
Radek Krejcid4270262019-01-07 15:07:25 +01002579 size_t size;
2580 long int len = 0;
Radek Krejcib1646a92018-11-02 16:08:26 +01002581
2582 LY_CHECK_RET(ly_getutf8(&ncname, &uc, &size), 0);
2583 if (!is_xmlqnamestartchar(uc) || (uc == ':')) {
2584 return len;
2585 }
2586
2587 do {
2588 len += size;
Radek Krejci9a564c92019-01-07 14:53:57 +01002589 if (!*ncname) {
2590 break;
2591 }
Radek Krejcid4270262019-01-07 15:07:25 +01002592 LY_CHECK_RET(ly_getutf8(&ncname, &uc, &size), -len);
Radek Krejcib1646a92018-11-02 16:08:26 +01002593 } while (is_xmlqnamechar(uc) && (uc != ':'));
2594
2595 return len;
2596}
2597
2598/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02002599 * @brief Add @p token into the expression @p exp.
Radek Krejcib1646a92018-11-02 16:08:26 +01002600 *
Michal Vasko03ff5a72019-09-11 13:49:33 +02002601 * @param[in] ctx Context for logging.
Radek Krejcib1646a92018-11-02 16:08:26 +01002602 * @param[in] exp Expression to use.
2603 * @param[in] token Token to add.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002604 * @param[in] tok_pos Token position in the XPath expression.
Radek Krejcib1646a92018-11-02 16:08:26 +01002605 * @param[in] tok_len Token length in the XPath expression.
Michal Vasko03ff5a72019-09-11 13:49:33 +02002606 * @return LY_ERR
Radek Krejcib1646a92018-11-02 16:08:26 +01002607 */
2608static LY_ERR
Michal Vasko14676352020-05-29 11:35:55 +02002609exp_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 +01002610{
2611 uint32_t prev;
2612
2613 if (exp->used == exp->size) {
2614 prev = exp->size;
2615 exp->size += LYXP_EXPR_SIZE_STEP;
2616 if (prev > exp->size) {
2617 LOGINT(ctx);
2618 return LY_EINT;
2619 }
2620
2621 exp->tokens = ly_realloc(exp->tokens, exp->size * sizeof *exp->tokens);
2622 LY_CHECK_ERR_RET(!exp->tokens, LOGMEM(ctx), LY_EMEM);
2623 exp->tok_pos = ly_realloc(exp->tok_pos, exp->size * sizeof *exp->tok_pos);
2624 LY_CHECK_ERR_RET(!exp->tok_pos, LOGMEM(ctx), LY_EMEM);
2625 exp->tok_len = ly_realloc(exp->tok_len, exp->size * sizeof *exp->tok_len);
2626 LY_CHECK_ERR_RET(!exp->tok_len, LOGMEM(ctx), LY_EMEM);
2627 }
2628
2629 exp->tokens[exp->used] = token;
Michal Vasko03ff5a72019-09-11 13:49:33 +02002630 exp->tok_pos[exp->used] = tok_pos;
Radek Krejcib1646a92018-11-02 16:08:26 +01002631 exp->tok_len[exp->used] = tok_len;
2632 ++exp->used;
2633 return LY_SUCCESS;
2634}
2635
2636void
Michal Vasko14676352020-05-29 11:35:55 +02002637lyxp_expr_free(const struct ly_ctx *ctx, struct lyxp_expr *expr)
Radek Krejcib1646a92018-11-02 16:08:26 +01002638{
2639 uint16_t i;
2640
2641 if (!expr) {
2642 return;
2643 }
2644
2645 lydict_remove(ctx, expr->expr);
2646 free(expr->tokens);
2647 free(expr->tok_pos);
2648 free(expr->tok_len);
2649 if (expr->repeat) {
2650 for (i = 0; i < expr->used; ++i) {
2651 free(expr->repeat[i]);
2652 }
2653 }
2654 free(expr->repeat);
2655 free(expr);
2656}
2657
Radek Krejcif03a9e22020-09-18 20:09:31 +02002658LY_ERR
2659lyxp_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 +01002660{
Radek Krejcif03a9e22020-09-18 20:09:31 +02002661 LY_ERR ret = LY_SUCCESS;
2662 struct lyxp_expr *expr;
Radek Krejcid4270262019-01-07 15:07:25 +01002663 size_t parsed = 0, tok_len;
Radek Krejcib1646a92018-11-02 16:08:26 +01002664 enum lyxp_token tok_type;
Radek Krejci857189e2020-09-01 13:26:36 +02002665 ly_bool prev_function_check = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02002666 uint16_t tok_idx = 0;
Radek Krejcib1646a92018-11-02 16:08:26 +01002667
Radek Krejcif03a9e22020-09-18 20:09:31 +02002668 assert(expr_p);
2669
2670 if (!expr_str[0]) {
Michal Vasko004d3152020-06-11 19:59:22 +02002671 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_EOF);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002672 return LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +02002673 }
2674
2675 if (!expr_len) {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002676 expr_len = strlen(expr_str);
Michal Vasko004d3152020-06-11 19:59:22 +02002677 }
2678 if (expr_len > UINT16_MAX) {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002679 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_XPATH, "XPath expression cannot be longer than %ud characters.", UINT16_MAX);
2680 return LY_EVALID;
Radek Krejcib1646a92018-11-02 16:08:26 +01002681 }
2682
2683 /* init lyxp_expr structure */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002684 expr = calloc(1, sizeof *expr);
2685 LY_CHECK_ERR_GOTO(!expr, LOGMEM(ctx); ret = LY_EMEM, error);
2686 LY_CHECK_GOTO(ret = lydict_insert(ctx, expr_str, expr_len, &expr->expr), error);
2687 expr->used = 0;
2688 expr->size = LYXP_EXPR_SIZE_START;
2689 expr->tokens = malloc(expr->size * sizeof *expr->tokens);
2690 LY_CHECK_ERR_GOTO(!expr->tokens, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002691
Radek Krejcif03a9e22020-09-18 20:09:31 +02002692 expr->tok_pos = malloc(expr->size * sizeof *expr->tok_pos);
2693 LY_CHECK_ERR_GOTO(!expr->tok_pos, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002694
Radek Krejcif03a9e22020-09-18 20:09:31 +02002695 expr->tok_len = malloc(expr->size * sizeof *expr->tok_len);
2696 LY_CHECK_ERR_GOTO(!expr->tok_len, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002697
Michal Vasko004d3152020-06-11 19:59:22 +02002698 /* make expr 0-terminated */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002699 expr_str = expr->expr;
Michal Vasko004d3152020-06-11 19:59:22 +02002700
Radek Krejcif03a9e22020-09-18 20:09:31 +02002701 while (is_xmlws(expr_str[parsed])) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002702 ++parsed;
2703 }
2704
2705 do {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002706 if (expr_str[parsed] == '(') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002707
2708 /* '(' */
2709 tok_len = 1;
2710 tok_type = LYXP_TOKEN_PAR1;
2711
Radek Krejcif03a9e22020-09-18 20:09:31 +02002712 if (prev_function_check && expr->used && (expr->tokens[expr->used - 1] == LYXP_TOKEN_NAMETEST)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002713 /* it is a NodeType/FunctionName after all */
Michal Vasko69730152020-10-09 16:30:07 +02002714 if (((expr->tok_len[expr->used - 1] == 4) &&
2715 (!strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "node", 4) ||
2716 !strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "text", 4))) ||
2717 ((expr->tok_len[expr->used - 1] == 7) &&
2718 !strncmp(&expr_str[expr->tok_pos[expr->used - 1]], "comment", 7))) {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002719 expr->tokens[expr->used - 1] = LYXP_TOKEN_NODETYPE;
Radek Krejcib1646a92018-11-02 16:08:26 +01002720 } else {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002721 expr->tokens[expr->used - 1] = LYXP_TOKEN_FUNCNAME;
Radek Krejcib1646a92018-11-02 16:08:26 +01002722 }
2723 prev_function_check = 0;
2724 }
2725
Radek Krejcif03a9e22020-09-18 20:09:31 +02002726 } else if (expr_str[parsed] == ')') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002727
2728 /* ')' */
2729 tok_len = 1;
2730 tok_type = LYXP_TOKEN_PAR2;
2731
Radek Krejcif03a9e22020-09-18 20:09:31 +02002732 } else if (expr_str[parsed] == '[') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002733
2734 /* '[' */
2735 tok_len = 1;
2736 tok_type = LYXP_TOKEN_BRACK1;
2737
Radek Krejcif03a9e22020-09-18 20:09:31 +02002738 } else if (expr_str[parsed] == ']') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002739
2740 /* ']' */
2741 tok_len = 1;
2742 tok_type = LYXP_TOKEN_BRACK2;
2743
Radek Krejcif03a9e22020-09-18 20:09:31 +02002744 } else if (!strncmp(&expr_str[parsed], "..", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002745
2746 /* '..' */
2747 tok_len = 2;
2748 tok_type = LYXP_TOKEN_DDOT;
2749
Radek Krejcif03a9e22020-09-18 20:09:31 +02002750 } else if ((expr_str[parsed] == '.') && (!isdigit(expr_str[parsed + 1]))) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002751
2752 /* '.' */
2753 tok_len = 1;
2754 tok_type = LYXP_TOKEN_DOT;
2755
Radek Krejcif03a9e22020-09-18 20:09:31 +02002756 } else if (expr_str[parsed] == '@') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002757
2758 /* '@' */
2759 tok_len = 1;
2760 tok_type = LYXP_TOKEN_AT;
2761
Radek Krejcif03a9e22020-09-18 20:09:31 +02002762 } else if (expr_str[parsed] == ',') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002763
2764 /* ',' */
2765 tok_len = 1;
2766 tok_type = LYXP_TOKEN_COMMA;
2767
Radek Krejcif03a9e22020-09-18 20:09:31 +02002768 } else if (expr_str[parsed] == '\'') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002769
2770 /* Literal with ' */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002771 for (tok_len = 1; (expr_str[parsed + tok_len] != '\0') && (expr_str[parsed + tok_len] != '\''); ++tok_len) {}
2772 LY_CHECK_ERR_GOTO(expr_str[parsed + tok_len] == '\0',
Michal Vasko69730152020-10-09 16:30:07 +02002773 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_EOE, expr_str[parsed], &expr_str[parsed]); ret = LY_EVALID,
2774 error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002775 ++tok_len;
2776 tok_type = LYXP_TOKEN_LITERAL;
2777
Radek Krejcif03a9e22020-09-18 20:09:31 +02002778 } else if (expr_str[parsed] == '\"') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002779
2780 /* Literal with " */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002781 for (tok_len = 1; (expr_str[parsed + tok_len] != '\0') && (expr_str[parsed + tok_len] != '\"'); ++tok_len) {}
2782 LY_CHECK_ERR_GOTO(expr_str[parsed + tok_len] == '\0',
Michal Vasko69730152020-10-09 16:30:07 +02002783 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_EOE, expr_str[parsed], &expr_str[parsed]); ret = LY_EVALID,
2784 error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002785 ++tok_len;
2786 tok_type = LYXP_TOKEN_LITERAL;
2787
Radek Krejcif03a9e22020-09-18 20:09:31 +02002788 } else if ((expr_str[parsed] == '.') || (isdigit(expr_str[parsed]))) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002789
2790 /* Number */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002791 for (tok_len = 0; isdigit(expr_str[parsed + tok_len]); ++tok_len) {}
2792 if (expr_str[parsed + tok_len] == '.') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002793 ++tok_len;
Radek Krejcif03a9e22020-09-18 20:09:31 +02002794 for ( ; isdigit(expr_str[parsed + tok_len]); ++tok_len) {}
Radek Krejcib1646a92018-11-02 16:08:26 +01002795 }
2796 tok_type = LYXP_TOKEN_NUMBER;
2797
Radek Krejcif03a9e22020-09-18 20:09:31 +02002798 } else if (expr_str[parsed] == '/') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002799
2800 /* Operator '/', '//' */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002801 if (!strncmp(&expr_str[parsed], "//", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002802 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002803 tok_type = LYXP_TOKEN_OPER_RPATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002804 } else {
2805 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002806 tok_type = LYXP_TOKEN_OPER_PATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002807 }
Radek Krejcib1646a92018-11-02 16:08:26 +01002808
Radek Krejcif03a9e22020-09-18 20:09:31 +02002809 } else if (!strncmp(&expr_str[parsed], "!=", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002810
Michal Vasko3e48bf32020-06-01 08:39:07 +02002811 /* Operator '!=' */
Radek Krejcib1646a92018-11-02 16:08:26 +01002812 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002813 tok_type = LYXP_TOKEN_OPER_NEQUAL;
2814
Radek Krejcif03a9e22020-09-18 20:09:31 +02002815 } else if (!strncmp(&expr_str[parsed], "<=", 2) || !strncmp(&expr_str[parsed], ">=", 2)) {
Michal Vasko3e48bf32020-06-01 08:39:07 +02002816
2817 /* Operator '<=', '>=' */
2818 tok_len = 2;
2819 tok_type = LYXP_TOKEN_OPER_COMP;
Radek Krejcib1646a92018-11-02 16:08:26 +01002820
Radek Krejcif03a9e22020-09-18 20:09:31 +02002821 } else if (expr_str[parsed] == '|') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002822
2823 /* Operator '|' */
2824 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002825 tok_type = LYXP_TOKEN_OPER_UNI;
Radek Krejcib1646a92018-11-02 16:08:26 +01002826
Radek Krejcif03a9e22020-09-18 20:09:31 +02002827 } else if ((expr_str[parsed] == '+') || (expr_str[parsed] == '-')) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002828
2829 /* Operator '+', '-' */
2830 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002831 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002832
Radek Krejcif03a9e22020-09-18 20:09:31 +02002833 } else if (expr_str[parsed] == '=') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002834
Michal Vasko3e48bf32020-06-01 08:39:07 +02002835 /* Operator '=' */
Radek Krejcib1646a92018-11-02 16:08:26 +01002836 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002837 tok_type = LYXP_TOKEN_OPER_EQUAL;
2838
Radek Krejcif03a9e22020-09-18 20:09:31 +02002839 } else if ((expr_str[parsed] == '<') || (expr_str[parsed] == '>')) {
Michal Vasko3e48bf32020-06-01 08:39:07 +02002840
2841 /* Operator '<', '>' */
2842 tok_len = 1;
2843 tok_type = LYXP_TOKEN_OPER_COMP;
Radek Krejcib1646a92018-11-02 16:08:26 +01002844
Michal Vasko69730152020-10-09 16:30:07 +02002845 } else if (expr->used && (expr->tokens[expr->used - 1] != LYXP_TOKEN_AT) &&
2846 (expr->tokens[expr->used - 1] != LYXP_TOKEN_PAR1) &&
2847 (expr->tokens[expr->used - 1] != LYXP_TOKEN_BRACK1) &&
2848 (expr->tokens[expr->used - 1] != LYXP_TOKEN_COMMA) &&
2849 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_LOG) &&
2850 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_EQUAL) &&
2851 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_NEQUAL) &&
2852 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_COMP) &&
2853 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_MATH) &&
2854 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_UNI) &&
2855 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_PATH) &&
2856 (expr->tokens[expr->used - 1] != LYXP_TOKEN_OPER_RPATH)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002857
2858 /* Operator '*', 'or', 'and', 'mod', or 'div' */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002859 if (expr_str[parsed] == '*') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002860 tok_len = 1;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002861 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002862
Radek Krejcif03a9e22020-09-18 20:09:31 +02002863 } else if (!strncmp(&expr_str[parsed], "or", 2)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002864 tok_len = 2;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002865 tok_type = LYXP_TOKEN_OPER_LOG;
Radek Krejcib1646a92018-11-02 16:08:26 +01002866
Radek Krejcif03a9e22020-09-18 20:09:31 +02002867 } else if (!strncmp(&expr_str[parsed], "and", 3)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002868 tok_len = 3;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002869 tok_type = LYXP_TOKEN_OPER_LOG;
Radek Krejcib1646a92018-11-02 16:08:26 +01002870
Radek Krejcif03a9e22020-09-18 20:09:31 +02002871 } else if (!strncmp(&expr_str[parsed], "mod", 3) || !strncmp(&expr_str[parsed], "div", 3)) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002872 tok_len = 3;
Michal Vasko3e48bf32020-06-01 08:39:07 +02002873 tok_type = LYXP_TOKEN_OPER_MATH;
Radek Krejcib1646a92018-11-02 16:08:26 +01002874
2875 } else if (prev_function_check) {
Michal Vasko53078572019-05-24 08:50:15 +02002876 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_XPATH, "Invalid character 0x%x ('%c'), perhaps \"%.*s\" is supposed to be a function call.",
Michal Vasko69730152020-10-09 16:30:07 +02002877 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 +02002878 ret = LY_EVALID;
Radek Krejcib1646a92018-11-02 16:08:26 +01002879 goto error;
2880 } else {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002881 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_INEXPR, parsed + 1, expr_str);
2882 ret = LY_EVALID;
Radek Krejcib1646a92018-11-02 16:08:26 +01002883 goto error;
2884 }
Radek Krejcif03a9e22020-09-18 20:09:31 +02002885 } else if (expr_str[parsed] == '*') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002886
2887 /* NameTest '*' */
2888 tok_len = 1;
2889 tok_type = LYXP_TOKEN_NAMETEST;
2890
2891 } else {
2892
2893 /* NameTest (NCName ':' '*' | QName) or NodeType/FunctionName */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002894 long int ncname_len = parse_ncname(&expr_str[parsed]);
2895 LY_CHECK_ERR_GOTO(ncname_len < 0,
Michal Vasko69730152020-10-09 16:30:07 +02002896 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_INEXPR, parsed - ncname_len + 1, expr_str); ret = LY_EVALID,
2897 error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002898 tok_len = ncname_len;
2899
Radek Krejcif03a9e22020-09-18 20:09:31 +02002900 if (expr_str[parsed + tok_len] == ':') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002901 ++tok_len;
Radek Krejcif03a9e22020-09-18 20:09:31 +02002902 if (expr_str[parsed + tok_len] == '*') {
Radek Krejcib1646a92018-11-02 16:08:26 +01002903 ++tok_len;
2904 } else {
Radek Krejcif03a9e22020-09-18 20:09:31 +02002905 ncname_len = parse_ncname(&expr_str[parsed + tok_len]);
2906 LY_CHECK_ERR_GOTO(ncname_len < 0,
Michal Vasko69730152020-10-09 16:30:07 +02002907 LOGVAL(ctx, LY_VLOG_NONE, NULL, LY_VCODE_XP_INEXPR, parsed - ncname_len + 1, expr_str); ret = LY_EVALID,
2908 error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002909 tok_len += ncname_len;
2910 }
2911 /* remove old flag to prevent ambiguities */
2912 prev_function_check = 0;
2913 tok_type = LYXP_TOKEN_NAMETEST;
2914 } else {
2915 /* there is no prefix so it can still be NodeType/FunctionName, we can't finally decide now */
2916 prev_function_check = 1;
2917 tok_type = LYXP_TOKEN_NAMETEST;
2918 }
2919 }
2920
2921 /* store the token, move on to the next one */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002922 LY_CHECK_GOTO(ret = exp_add_token(ctx, expr, tok_type, parsed, tok_len), error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002923 parsed += tok_len;
Radek Krejcif03a9e22020-09-18 20:09:31 +02002924 while (is_xmlws(expr_str[parsed])) {
Radek Krejcib1646a92018-11-02 16:08:26 +01002925 ++parsed;
2926 }
2927
Radek Krejcif03a9e22020-09-18 20:09:31 +02002928 } while (expr_str[parsed]);
Radek Krejcib1646a92018-11-02 16:08:26 +01002929
Michal Vasko004d3152020-06-11 19:59:22 +02002930 if (reparse) {
2931 /* prealloc repeat */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002932 expr->repeat = calloc(expr->size, sizeof *expr->repeat);
2933 LY_CHECK_ERR_GOTO(!expr->repeat, LOGMEM(ctx); ret = LY_EMEM, error);
Radek Krejcib1646a92018-11-02 16:08:26 +01002934
Michal Vasko004d3152020-06-11 19:59:22 +02002935 /* fill repeat */
Radek Krejcif03a9e22020-09-18 20:09:31 +02002936 LY_CHECK_ERR_GOTO(reparse_or_expr(ctx, expr, &tok_idx), ret = LY_EVALID, error);
2937 if (expr->used > tok_idx) {
Michal Vasko004d3152020-06-11 19:59:22 +02002938 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_XPATH, "Unparsed characters \"%s\" left at the end of an XPath expression.",
Michal Vasko69730152020-10-09 16:30:07 +02002939 &expr->expr[expr->tok_pos[tok_idx]]);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002940 ret = LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +02002941 goto error;
2942 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02002943 }
2944
Radek Krejcif03a9e22020-09-18 20:09:31 +02002945 print_expr_struct_debug(expr);
2946 *expr_p = expr;
2947 return LY_SUCCESS;
Radek Krejcib1646a92018-11-02 16:08:26 +01002948
2949error:
Radek Krejcif03a9e22020-09-18 20:09:31 +02002950 lyxp_expr_free(ctx, expr);
2951 return ret;
Radek Krejcib1646a92018-11-02 16:08:26 +01002952}
2953
Michal Vasko1734be92020-09-22 08:55:10 +02002954LY_ERR
2955lyxp_expr_dup(const struct ly_ctx *ctx, const struct lyxp_expr *exp, struct lyxp_expr **dup_p)
Michal Vasko004d3152020-06-11 19:59:22 +02002956{
Michal Vasko1734be92020-09-22 08:55:10 +02002957 LY_ERR ret = LY_SUCCESS;
2958 struct lyxp_expr *dup = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02002959 uint32_t i, j;
2960
Michal Vasko7f45cf22020-10-01 12:49:44 +02002961 if (!exp) {
2962 goto cleanup;
2963 }
2964
Michal Vasko004d3152020-06-11 19:59:22 +02002965 dup = calloc(1, sizeof *dup);
Michal Vasko1734be92020-09-22 08:55:10 +02002966 LY_CHECK_ERR_GOTO(!dup, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02002967
2968 dup->tokens = malloc(exp->used * sizeof *dup->tokens);
Michal Vasko1734be92020-09-22 08:55:10 +02002969 LY_CHECK_ERR_GOTO(!dup->tokens, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02002970 memcpy(dup->tokens, exp->tokens, exp->used * sizeof *dup->tokens);
2971
2972 dup->tok_pos = malloc(exp->used * sizeof *dup->tok_pos);
Michal Vasko1734be92020-09-22 08:55:10 +02002973 LY_CHECK_ERR_GOTO(!dup->tok_pos, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02002974 memcpy(dup->tok_pos, exp->tok_pos, exp->used * sizeof *dup->tok_pos);
2975
2976 dup->tok_len = malloc(exp->used * sizeof *dup->tok_len);
Michal Vasko1734be92020-09-22 08:55:10 +02002977 LY_CHECK_ERR_GOTO(!dup->tok_len, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02002978 memcpy(dup->tok_len, exp->tok_len, exp->used * sizeof *dup->tok_len);
2979
2980 dup->repeat = malloc(exp->used * sizeof *dup->repeat);
Michal Vasko1734be92020-09-22 08:55:10 +02002981 LY_CHECK_ERR_GOTO(!dup->repeat, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02002982 for (i = 0; i < exp->used; ++i) {
2983 if (!exp->repeat[i]) {
2984 dup->repeat[i] = NULL;
2985 } else {
Radek Krejci1e008d22020-08-17 11:37:37 +02002986 for (j = 0; exp->repeat[i][j]; ++j) {}
Michal Vasko004d3152020-06-11 19:59:22 +02002987 /* the ending 0 as well */
2988 ++j;
2989
Michal Vasko99c71642020-07-03 13:33:36 +02002990 dup->repeat[i] = malloc(j * sizeof **dup->repeat);
Michal Vasko1734be92020-09-22 08:55:10 +02002991 LY_CHECK_ERR_GOTO(!dup->repeat[i], LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02002992 memcpy(dup->repeat[i], exp->repeat[i], j * sizeof **dup->repeat);
2993 dup->repeat[i][j - 1] = 0;
2994 }
2995 }
2996
2997 dup->used = exp->used;
2998 dup->size = exp->used;
Michal Vasko1734be92020-09-22 08:55:10 +02002999 LY_CHECK_GOTO(ret = lydict_insert(ctx, exp->expr, 0, &dup->expr), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02003000
Michal Vasko1734be92020-09-22 08:55:10 +02003001cleanup:
3002 if (ret) {
3003 lyxp_expr_free(ctx, dup);
3004 } else {
3005 *dup_p = dup;
3006 }
3007 return ret;
Michal Vasko004d3152020-06-11 19:59:22 +02003008}
3009
Michal Vasko03ff5a72019-09-11 13:49:33 +02003010/*
3011 * warn functions
3012 *
3013 * Warn functions check specific reasonable conditions for schema XPath
3014 * and print a warning if they are not satisfied.
3015 */
3016
3017/**
3018 * @brief Get the last-added schema node that is currently in the context.
3019 *
3020 * @param[in] set Set to search in.
3021 * @return Last-added schema context node, NULL if no node is in context.
3022 */
3023static struct lysc_node *
3024warn_get_scnode_in_ctx(struct lyxp_set *set)
3025{
3026 uint32_t i;
3027
3028 if (!set || (set->type != LYXP_SET_SCNODE_SET)) {
3029 return NULL;
3030 }
3031
3032 i = set->used;
3033 do {
3034 --i;
3035 if (set->val.scnodes[i].in_ctx == 1) {
3036 /* if there are more, simply return the first found (last added) */
3037 return set->val.scnodes[i].scnode;
3038 }
3039 } while (i);
3040
3041 return NULL;
3042}
3043
3044/**
3045 * @brief Test whether a type is numeric - integer type or decimal64.
3046 *
3047 * @param[in] type Type to test.
Radek Krejci857189e2020-09-01 13:26:36 +02003048 * @return Boolean value whether @p type is numeric type or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003049 */
Radek Krejci857189e2020-09-01 13:26:36 +02003050static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003051warn_is_numeric_type(struct lysc_type *type)
3052{
3053 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003054 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003055 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003056
3057 switch (type->basetype) {
3058 case LY_TYPE_DEC64:
3059 case LY_TYPE_INT8:
3060 case LY_TYPE_UINT8:
3061 case LY_TYPE_INT16:
3062 case LY_TYPE_UINT16:
3063 case LY_TYPE_INT32:
3064 case LY_TYPE_UINT32:
3065 case LY_TYPE_INT64:
3066 case LY_TYPE_UINT64:
3067 return 1;
3068 case LY_TYPE_UNION:
3069 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003070 LY_ARRAY_FOR(uni->types, u) {
3071 ret = warn_is_numeric_type(uni->types[u]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003072 if (ret) {
3073 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003074 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003075 }
3076 }
3077 /* did not find any suitable type */
3078 return 0;
3079 case LY_TYPE_LEAFREF:
3080 return warn_is_numeric_type(((struct lysc_type_leafref *)type)->realtype);
3081 default:
3082 return 0;
3083 }
3084}
3085
3086/**
3087 * @brief Test whether a type is string-like - no integers, decimal64 or binary.
3088 *
3089 * @param[in] type Type to test.
Radek Krejci857189e2020-09-01 13:26:36 +02003090 * @return Boolean value whether @p type's basetype is string type or not.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003091 */
Radek Krejci857189e2020-09-01 13:26:36 +02003092static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003093warn_is_string_type(struct lysc_type *type)
3094{
3095 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003096 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003097 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003098
3099 switch (type->basetype) {
3100 case LY_TYPE_BITS:
3101 case LY_TYPE_ENUM:
3102 case LY_TYPE_IDENT:
3103 case LY_TYPE_INST:
3104 case LY_TYPE_STRING:
3105 return 1;
3106 case LY_TYPE_UNION:
3107 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003108 LY_ARRAY_FOR(uni->types, u) {
3109 ret = warn_is_string_type(uni->types[u]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003110 if (ret) {
3111 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003112 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003113 }
3114 }
3115 /* did not find any suitable type */
3116 return 0;
3117 case LY_TYPE_LEAFREF:
3118 return warn_is_string_type(((struct lysc_type_leafref *)type)->realtype);
3119 default:
3120 return 0;
3121 }
3122}
3123
3124/**
3125 * @brief Test whether a type is one specific type.
3126 *
3127 * @param[in] type Type to test.
3128 * @param[in] base Expected type.
Radek Krejci857189e2020-09-01 13:26:36 +02003129 * @return Boolean value whether the given @p type is of the specific basetype @p base.
Michal Vasko03ff5a72019-09-11 13:49:33 +02003130 */
Radek Krejci857189e2020-09-01 13:26:36 +02003131static ly_bool
Michal Vasko03ff5a72019-09-11 13:49:33 +02003132warn_is_specific_type(struct lysc_type *type, LY_DATA_TYPE base)
3133{
3134 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003135 ly_bool ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003136 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003137
3138 if (type->basetype == base) {
3139 return 1;
3140 } else if (type->basetype == LY_TYPE_UNION) {
3141 uni = (struct lysc_type_union *)type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003142 LY_ARRAY_FOR(uni->types, u) {
3143 ret = warn_is_specific_type(uni->types[u], base);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003144 if (ret) {
3145 /* found a suitable type */
Radek Krejci857189e2020-09-01 13:26:36 +02003146 return ret;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003147 }
3148 }
3149 /* did not find any suitable type */
3150 return 0;
3151 } else if (type->basetype == LY_TYPE_LEAFREF) {
3152 return warn_is_specific_type(((struct lysc_type_leafref *)type)->realtype, base);
3153 }
3154
3155 return 0;
3156}
3157
3158/**
3159 * @brief Get next type of a (union) type.
3160 *
3161 * @param[in] type Base type.
3162 * @param[in] prev_type Previously returned type.
3163 * @return Next type or NULL.
3164 */
3165static struct lysc_type *
3166warn_is_equal_type_next_type(struct lysc_type *type, struct lysc_type *prev_type)
3167{
3168 struct lysc_type_union *uni;
Radek Krejci857189e2020-09-01 13:26:36 +02003169 ly_bool found = 0;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003170 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003171
3172 switch (type->basetype) {
3173 case LY_TYPE_UNION:
3174 uni = (struct lysc_type_union *)type;
3175 if (!prev_type) {
3176 return uni->types[0];
3177 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003178 LY_ARRAY_FOR(uni->types, u) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003179 if (found) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003180 return uni->types[u];
Michal Vasko03ff5a72019-09-11 13:49:33 +02003181 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003182 if (prev_type == uni->types[u]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003183 found = 1;
3184 }
3185 }
3186 return NULL;
3187 default:
3188 if (prev_type) {
3189 assert(type == prev_type);
3190 return NULL;
3191 } else {
3192 return type;
3193 }
3194 }
3195}
3196
3197/**
3198 * @brief Test whether 2 types have a common type.
3199 *
3200 * @param[in] type1 First type.
3201 * @param[in] type2 Second type.
3202 * @return 1 if they do, 0 otherwise.
3203 */
3204static int
3205warn_is_equal_type(struct lysc_type *type1, struct lysc_type *type2)
3206{
3207 struct lysc_type *t1, *rt1, *t2, *rt2;
3208
3209 t1 = NULL;
3210 while ((t1 = warn_is_equal_type_next_type(type1, t1))) {
3211 if (t1->basetype == LY_TYPE_LEAFREF) {
3212 rt1 = ((struct lysc_type_leafref *)t1)->realtype;
3213 } else {
3214 rt1 = t1;
3215 }
3216
3217 t2 = NULL;
3218 while ((t2 = warn_is_equal_type_next_type(type2, t2))) {
3219 if (t2->basetype == LY_TYPE_LEAFREF) {
3220 rt2 = ((struct lysc_type_leafref *)t2)->realtype;
3221 } else {
3222 rt2 = t2;
3223 }
3224
3225 if (rt2->basetype == rt1->basetype) {
3226 /* match found */
3227 return 1;
3228 }
3229 }
3230 }
3231
3232 return 0;
3233}
3234
3235/**
3236 * @brief Check both operands of comparison operators.
3237 *
3238 * @param[in] ctx Context for errors.
3239 * @param[in] set1 First operand set.
3240 * @param[in] set2 Second operand set.
3241 * @param[in] numbers_only Whether accept only numbers or other types are fine too (for '=' and '!=').
3242 * @param[in] expr Start of the expression to print with the warning.
3243 * @param[in] tok_pos Token position.
3244 */
3245static void
Radek Krejci857189e2020-09-01 13:26:36 +02003246warn_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 +02003247{
3248 struct lysc_node_leaf *node1, *node2;
Radek Krejci857189e2020-09-01 13:26:36 +02003249 ly_bool leaves = 1, warning = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003250
3251 node1 = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set1);
3252 node2 = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set2);
3253
3254 if (!node1 && !node2) {
3255 /* no node-sets involved, nothing to do */
3256 return;
3257 }
3258
3259 if (node1) {
3260 if (!(node1->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3261 LOGWRN(ctx, "Node type %s \"%s\" used as operand.", lys_nodetype2str(node1->nodetype), node1->name);
3262 warning = 1;
3263 leaves = 0;
3264 } else if (numbers_only && !warn_is_numeric_type(node1->type)) {
3265 LOGWRN(ctx, "Node \"%s\" is not of a numeric type, but used where it was expected.", node1->name);
3266 warning = 1;
3267 }
3268 }
3269
3270 if (node2) {
3271 if (!(node2->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3272 LOGWRN(ctx, "Node type %s \"%s\" used as operand.", lys_nodetype2str(node2->nodetype), node2->name);
3273 warning = 1;
3274 leaves = 0;
3275 } else if (numbers_only && !warn_is_numeric_type(node2->type)) {
3276 LOGWRN(ctx, "Node \"%s\" is not of a numeric type, but used where it was expected.", node2->name);
3277 warning = 1;
3278 }
3279 }
3280
3281 if (node1 && node2 && leaves && !numbers_only) {
Michal Vasko69730152020-10-09 16:30:07 +02003282 if ((warn_is_numeric_type(node1->type) && !warn_is_numeric_type(node2->type)) ||
3283 (!warn_is_numeric_type(node1->type) && warn_is_numeric_type(node2->type)) ||
3284 (!warn_is_numeric_type(node1->type) && !warn_is_numeric_type(node2->type) &&
3285 !warn_is_equal_type(node1->type, node2->type))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003286 LOGWRN(ctx, "Incompatible types of operands \"%s\" and \"%s\" for comparison.", node1->name, node2->name);
3287 warning = 1;
3288 }
3289 }
3290
3291 if (warning) {
3292 LOGWRN(ctx, "Previous warning generated by XPath subexpression[%u] \"%.20s\".", tok_pos, expr + tok_pos);
3293 }
3294}
3295
3296/**
3297 * @brief Check that a value is valid for a leaf. If not applicable, does nothing.
3298 *
3299 * @param[in] exp Parsed XPath expression.
3300 * @param[in] set Set with the leaf/leaf-list.
3301 * @param[in] val_exp Index of the value (literal/number) in @p exp.
3302 * @param[in] equal_exp Index of the start of the equality expression in @p exp.
3303 * @param[in] last_equal_exp Index of the end of the equality expression in @p exp.
3304 */
3305static void
3306warn_equality_value(struct lyxp_expr *exp, struct lyxp_set *set, uint16_t val_exp, uint16_t equal_exp, uint16_t last_equal_exp)
3307{
3308 struct lysc_node *scnode;
3309 struct lysc_type *type;
3310 char *value;
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003311 struct lyd_value storage;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003312 LY_ERR rc;
3313 struct ly_err_item *err = NULL;
3314
Michal Vasko69730152020-10-09 16:30:07 +02003315 if ((scnode = warn_get_scnode_in_ctx(set)) && (scnode->nodetype & (LYS_LEAF | LYS_LEAFLIST)) &&
3316 ((exp->tokens[val_exp] == LYXP_TOKEN_LITERAL) || (exp->tokens[val_exp] == LYXP_TOKEN_NUMBER))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003317 /* check that the node can have the specified value */
3318 if (exp->tokens[val_exp] == LYXP_TOKEN_LITERAL) {
3319 value = strndup(exp->expr + exp->tok_pos[val_exp] + 1, exp->tok_len[val_exp] - 2);
3320 } else {
3321 value = strndup(exp->expr + exp->tok_pos[val_exp], exp->tok_len[val_exp]);
3322 }
3323 if (!value) {
3324 LOGMEM(set->ctx);
3325 return;
3326 }
3327
3328 if ((((struct lysc_node_leaf *)scnode)->type->basetype == LY_TYPE_IDENT) && !strchr(value, ':')) {
3329 LOGWRN(set->ctx, "Identityref \"%s\" comparison with identity \"%s\" without prefix, consider adding"
Michal Vasko69730152020-10-09 16:30:07 +02003330 " a prefix or best using \"derived-from(-or-self)()\" functions.", scnode->name, value);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003331 LOGWRN(set->ctx, "Previous warning generated by XPath subexpression[%u] \"%.*s\".", exp->tok_pos[equal_exp],
Radek Krejci0f969882020-08-21 16:56:47 +02003332 (exp->tok_pos[last_equal_exp] - exp->tok_pos[equal_exp]) + exp->tok_len[last_equal_exp],
Michal Vasko69730152020-10-09 16:30:07 +02003333 exp->expr + exp->tok_pos[equal_exp]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003334 }
3335
3336 type = ((struct lysc_node_leaf *)scnode)->type;
3337 if (type->basetype != LY_TYPE_IDENT) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003338 rc = type->plugin->store(set->ctx, type, value, strlen(value), 0, set->format, set->prefix_data,
Michal Vaskofeca4fb2020-10-05 08:58:40 +02003339 LYD_HINT_DATA, scnode, &storage, &err);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003340
3341 if (err) {
3342 LOGWRN(set->ctx, "Invalid value \"%s\" which does not fit the type (%s).", value, err->msg);
3343 ly_err_free(err);
3344 } else if (rc != LY_SUCCESS) {
3345 LOGWRN(set->ctx, "Invalid value \"%s\" which does not fit the type.", value);
3346 }
3347 if (rc != LY_SUCCESS) {
3348 LOGWRN(set->ctx, "Previous warning generated by XPath subexpression[%u] \"%.*s\".", exp->tok_pos[equal_exp],
Radek Krejci0f969882020-08-21 16:56:47 +02003349 (exp->tok_pos[last_equal_exp] - exp->tok_pos[equal_exp]) + exp->tok_len[last_equal_exp],
Michal Vasko69730152020-10-09 16:30:07 +02003350 exp->expr + exp->tok_pos[equal_exp]);
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003351 } else {
3352 type->plugin->free(set->ctx, &storage);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003353 }
3354 }
3355 free(value);
3356 }
3357}
3358
3359/*
3360 * XPath functions
3361 */
3362
3363/**
3364 * @brief Execute the YANG 1.1 bit-is-set(node-set, string) function. Returns LYXP_SET_BOOLEAN
3365 * depending on whether the first node bit value from the second argument is set.
3366 *
3367 * @param[in] args Array of arguments.
3368 * @param[in] arg_count Count of elements in @p args.
3369 * @param[in,out] set Context and result set at the same time.
3370 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003371 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003372 */
3373static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003374xpath_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 +02003375{
3376 struct lyd_node_term *leaf;
3377 struct lysc_node_leaf *sleaf;
3378 struct lysc_type_bits *bits;
3379 LY_ERR rc = LY_SUCCESS;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003380 LY_ARRAY_COUNT_TYPE u;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003381
3382 if (options & LYXP_SCNODE_ALL) {
3383 if ((args[0]->type != LYXP_SET_SCNODE_SET) || !(sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3384 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003385 } else if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3386 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 +02003387 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_BITS)) {
3388 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"bits\".", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003389 }
3390
3391 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
3392 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3393 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 +02003394 } else if (!warn_is_string_type(sleaf->type)) {
3395 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003396 }
3397 }
3398 set_scnode_clear_ctx(set);
3399 return rc;
3400 }
3401
Michal Vaskod3678892020-05-21 10:06:58 +02003402 if (args[0]->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003403 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]),
3404 "bit-is-set(node-set, string)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02003405 return LY_EVALID;
3406 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003407 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003408 LY_CHECK_RET(rc);
3409
3410 set_fill_boolean(set, 0);
Michal Vaskod3678892020-05-21 10:06:58 +02003411 if (args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003412 leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
Michal Vasko69730152020-10-09 16:30:07 +02003413 if ((leaf->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST)) &&
3414 (((struct lysc_node_leaf *)leaf->schema)->type->basetype == LY_TYPE_BITS)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003415 bits = (struct lysc_type_bits *)((struct lysc_node_leaf *)leaf->schema)->type;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02003416 LY_ARRAY_FOR(bits->bits, u) {
3417 if (!strcmp(bits->bits[u].name, args[1]->val.str)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003418 set_fill_boolean(set, 1);
3419 break;
3420 }
3421 }
3422 }
3423 }
3424
3425 return LY_SUCCESS;
3426}
3427
3428/**
3429 * @brief Execute the XPath boolean(object) function. Returns LYXP_SET_BOOLEAN
3430 * with the argument converted to boolean.
3431 *
3432 * @param[in] args Array of arguments.
3433 * @param[in] arg_count Count of elements in @p args.
3434 * @param[in,out] set Context and result set at the same time.
3435 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003436 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003437 */
3438static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003439xpath_boolean(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003440{
3441 LY_ERR rc;
3442
3443 if (options & LYXP_SCNODE_ALL) {
3444 set_scnode_clear_ctx(set);
3445 return LY_SUCCESS;
3446 }
3447
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003448 rc = lyxp_set_cast(args[0], LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003449 LY_CHECK_RET(rc);
3450 set_fill_set(set, args[0]);
3451
3452 return LY_SUCCESS;
3453}
3454
3455/**
3456 * @brief Execute the XPath ceiling(number) function. Returns LYXP_SET_NUMBER
3457 * with the first argument rounded up to the nearest integer.
3458 *
3459 * @param[in] args Array of arguments.
3460 * @param[in] arg_count Count of elements in @p args.
3461 * @param[in,out] set Context and result set at the same time.
3462 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003463 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003464 */
3465static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003466xpath_ceiling(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003467{
3468 struct lysc_node_leaf *sleaf;
3469 LY_ERR rc = LY_SUCCESS;
3470
3471 if (options & LYXP_SCNODE_ALL) {
3472 if ((args[0]->type != LYXP_SET_SCNODE_SET) || !(sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3473 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003474 } else if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3475 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 +02003476 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_DEC64)) {
3477 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"decimal64\".", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003478 }
3479 set_scnode_clear_ctx(set);
3480 return rc;
3481 }
3482
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003483 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003484 LY_CHECK_RET(rc);
3485 if ((long long)args[0]->val.num != args[0]->val.num) {
3486 set_fill_number(set, ((long long)args[0]->val.num) + 1);
3487 } else {
3488 set_fill_number(set, args[0]->val.num);
3489 }
3490
3491 return LY_SUCCESS;
3492}
3493
3494/**
3495 * @brief Execute the XPath concat(string, string, string*) function.
3496 * Returns LYXP_SET_STRING with the concatenation of all the arguments.
3497 *
3498 * @param[in] args Array of arguments.
3499 * @param[in] arg_count Count of elements in @p args.
3500 * @param[in,out] set Context and result set at the same time.
3501 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003502 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003503 */
3504static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003505xpath_concat(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003506{
3507 uint16_t i;
3508 char *str = NULL;
3509 size_t used = 1;
3510 LY_ERR rc = LY_SUCCESS;
3511 struct lysc_node_leaf *sleaf;
3512
3513 if (options & LYXP_SCNODE_ALL) {
3514 for (i = 0; i < arg_count; ++i) {
3515 if ((args[i]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[i]))) {
3516 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3517 LOGWRN(set->ctx, "Argument #%u of %s is a %s node \"%s\".",
Michal Vasko69730152020-10-09 16:30:07 +02003518 i + 1, __func__, lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003519 } else if (!warn_is_string_type(sleaf->type)) {
Radek Krejci70124c82020-08-14 22:17:03 +02003520 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 +02003521 }
3522 }
3523 }
3524 set_scnode_clear_ctx(set);
3525 return rc;
3526 }
3527
3528 for (i = 0; i < arg_count; ++i) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003529 rc = lyxp_set_cast(args[i], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003530 if (rc != LY_SUCCESS) {
3531 free(str);
3532 return rc;
3533 }
3534
3535 str = ly_realloc(str, (used + strlen(args[i]->val.str)) * sizeof(char));
3536 LY_CHECK_ERR_RET(!str, LOGMEM(set->ctx), LY_EMEM);
3537 strcpy(str + used - 1, args[i]->val.str);
3538 used += strlen(args[i]->val.str);
3539 }
3540
3541 /* free, kind of */
Michal Vaskod3678892020-05-21 10:06:58 +02003542 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003543 set->type = LYXP_SET_STRING;
3544 set->val.str = str;
3545
3546 return LY_SUCCESS;
3547}
3548
3549/**
3550 * @brief Execute the XPath contains(string, string) function.
3551 * Returns LYXP_SET_BOOLEAN whether the second argument can
3552 * be found in the first or not.
3553 *
3554 * @param[in] args Array of arguments.
3555 * @param[in] arg_count Count of elements in @p args.
3556 * @param[in,out] set Context and result set at the same time.
3557 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003558 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003559 */
3560static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003561xpath_contains(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003562{
3563 struct lysc_node_leaf *sleaf;
3564 LY_ERR rc = LY_SUCCESS;
3565
3566 if (options & LYXP_SCNODE_ALL) {
3567 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3568 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3569 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 +02003570 } else if (!warn_is_string_type(sleaf->type)) {
3571 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003572 }
3573 }
3574
3575 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
3576 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3577 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 +02003578 } else if (!warn_is_string_type(sleaf->type)) {
3579 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003580 }
3581 }
3582 set_scnode_clear_ctx(set);
3583 return rc;
3584 }
3585
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003586 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003587 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003588 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003589 LY_CHECK_RET(rc);
3590
3591 if (strstr(args[0]->val.str, args[1]->val.str)) {
3592 set_fill_boolean(set, 1);
3593 } else {
3594 set_fill_boolean(set, 0);
3595 }
3596
3597 return LY_SUCCESS;
3598}
3599
3600/**
3601 * @brief Execute the XPath count(node-set) function. Returns LYXP_SET_NUMBER
3602 * with the size of the node-set from the argument.
3603 *
3604 * @param[in] args Array of arguments.
3605 * @param[in] arg_count Count of elements in @p args.
3606 * @param[in,out] set Context and result set at the same time.
3607 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003608 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003609 */
3610static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003611xpath_count(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003612{
3613 struct lysc_node *scnode = NULL;
3614 LY_ERR rc = LY_SUCCESS;
3615
3616 if (options & LYXP_SCNODE_ALL) {
3617 if ((args[0]->type != LYXP_SET_SCNODE_SET) || !(scnode = warn_get_scnode_in_ctx(args[0]))) {
3618 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003619 }
3620 set_scnode_clear_ctx(set);
3621 return rc;
3622 }
3623
Michal Vasko03ff5a72019-09-11 13:49:33 +02003624 if (args[0]->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003625 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "count(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02003626 return LY_EVALID;
3627 }
3628
3629 set_fill_number(set, args[0]->used);
3630 return LY_SUCCESS;
3631}
3632
3633/**
3634 * @brief Execute the XPath current() function. Returns LYXP_SET_NODE_SET
3635 * with the context with the intial node.
3636 *
3637 * @param[in] args Array of arguments.
3638 * @param[in] arg_count Count of elements in @p args.
3639 * @param[in,out] set Context and result set at the same time.
3640 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003641 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003642 */
3643static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003644xpath_current(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003645{
3646 if (arg_count || args) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003647 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INARGCOUNT, arg_count, "current()");
Michal Vasko03ff5a72019-09-11 13:49:33 +02003648 return LY_EVALID;
3649 }
3650
3651 if (options & LYXP_SCNODE_ALL) {
3652 set_scnode_clear_ctx(set);
3653
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003654 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, set->cur_scnode, LYXP_NODE_ELEM, NULL));
Michal Vasko03ff5a72019-09-11 13:49:33 +02003655 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02003656 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003657
3658 /* position is filled later */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003659 set_insert_node(set, set->cur_node, 0, LYXP_NODE_ELEM, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003660 }
3661
3662 return LY_SUCCESS;
3663}
3664
3665/**
3666 * @brief Execute the YANG 1.1 deref(node-set) function. Returns LYXP_SET_NODE_SET with either
3667 * leafref or instance-identifier target node(s).
3668 *
3669 * @param[in] args Array of arguments.
3670 * @param[in] arg_count Count of elements in @p args.
3671 * @param[in,out] set Context and result set at the same time.
3672 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003673 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003674 */
3675static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003676xpath_deref(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003677{
3678 struct lyd_node_term *leaf;
Michal Vasko42e497c2020-01-06 08:38:25 +01003679 struct lysc_node_leaf *sleaf = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02003680 struct lysc_type_leafref *lref;
Michal Vaskoae9e4cb2019-09-25 08:43:05 +02003681 const struct lysc_node *target;
Michal Vasko004d3152020-06-11 19:59:22 +02003682 struct ly_path *p;
3683 struct lyd_node *node;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003684 char *errmsg = NULL;
Michal Vasko00cbf532020-06-15 13:58:47 +02003685 uint8_t oper;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003686 LY_ERR rc = LY_SUCCESS;
3687
3688 if (options & LYXP_SCNODE_ALL) {
3689 if ((args[0]->type != LYXP_SET_SCNODE_SET) || !(sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3690 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003691 } else if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3692 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 +02003693 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_LEAFREF) && !warn_is_specific_type(sleaf->type, LY_TYPE_INST)) {
3694 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"leafref\" nor \"instance-identifier\".",
Michal Vasko69730152020-10-09 16:30:07 +02003695 __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003696 }
3697 set_scnode_clear_ctx(set);
Michal Vasko42e497c2020-01-06 08:38:25 +01003698 if (sleaf && (sleaf->type->basetype == LY_TYPE_LEAFREF)) {
Michal Vasko004d3152020-06-11 19:59:22 +02003699 lref = (struct lysc_type_leafref *)sleaf->type;
Michal Vasko00cbf532020-06-15 13:58:47 +02003700 oper = lysc_is_output((struct lysc_node *)sleaf) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Michal Vasko004d3152020-06-11 19:59:22 +02003701
3702 /* it was already evaluated on schema, it must succeed */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003703 rc = ly_path_compile(set->ctx, sleaf->module, (struct lysc_node *)sleaf, lref->path,
3704 LY_PATH_LREF_TRUE, oper, LY_PATH_TARGET_MANY, LY_PREF_SCHEMA_RESOLVED, lref->prefixes, &p);
Michal Vasko004d3152020-06-11 19:59:22 +02003705 assert(!rc);
3706
3707 /* get the target node */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003708 target = p[LY_ARRAY_COUNT(p) - 1].node;
Michal Vasko004d3152020-06-11 19:59:22 +02003709 ly_path_free(set->ctx, p);
3710
Radek Krejciaa6b53f2020-08-27 15:19:03 +02003711 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, target, LYXP_NODE_ELEM, NULL));
Michal Vaskoae9e4cb2019-09-25 08:43:05 +02003712 }
3713
Michal Vasko03ff5a72019-09-11 13:49:33 +02003714 return rc;
3715 }
3716
Michal Vaskod3678892020-05-21 10:06:58 +02003717 if (args[0]->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003718 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "deref(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02003719 return LY_EVALID;
3720 }
3721
Michal Vaskod3678892020-05-21 10:06:58 +02003722 lyxp_set_free_content(set);
3723 if (args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003724 leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
3725 sleaf = (struct lysc_node_leaf *)leaf->schema;
3726 if (sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
3727 if (sleaf->type->basetype == LY_TYPE_LEAFREF) {
3728 /* find leafref target */
Michal Vasko004d3152020-06-11 19:59:22 +02003729 if (ly_type_find_leafref((struct lysc_type_leafref *)sleaf->type, (struct lyd_node *)leaf,
Michal Vasko69730152020-10-09 16:30:07 +02003730 &leaf->value, set->tree, &node, &errmsg)) {
Michal Vasko004d3152020-06-11 19:59:22 +02003731 LOGERR(set->ctx, LY_EVALID, errmsg);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003732 free(errmsg);
Michal Vasko004d3152020-06-11 19:59:22 +02003733 return LY_EVALID;
Michal Vasko03ff5a72019-09-11 13:49:33 +02003734 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02003735 } else {
3736 assert(sleaf->type->basetype == LY_TYPE_INST);
Michal Vasko004d3152020-06-11 19:59:22 +02003737 if (ly_path_eval(leaf->value.target, set->tree, &node)) {
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003738 LOGERR(set->ctx, LY_EVALID, "Invalid instance-identifier \"%s\" value - required instance not found.",
Michal Vasko69730152020-10-09 16:30:07 +02003739 LYD_CANON_VALUE(leaf));
Michal Vasko03ff5a72019-09-11 13:49:33 +02003740 return LY_EVALID;
3741 }
3742 }
Michal Vasko004d3152020-06-11 19:59:22 +02003743
3744 /* insert it */
3745 set_insert_node(set, node, 0, LYXP_NODE_ELEM, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003746 }
3747 }
3748
3749 return LY_SUCCESS;
3750}
3751
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003752static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003753xpath_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 +02003754{
3755 uint16_t i;
3756 LY_ARRAY_COUNT_TYPE u;
3757 struct lyd_node_term *leaf;
3758 struct lysc_node_leaf *sleaf;
3759 struct lyd_meta *meta;
3760 struct lyd_value data = {0}, *val;
3761 struct ly_err_item *err = NULL;
3762 LY_ERR rc = LY_SUCCESS;
Radek Krejci857189e2020-09-01 13:26:36 +02003763 ly_bool found;
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003764
3765 if (options & LYXP_SCNODE_ALL) {
3766 if ((args[0]->type != LYXP_SET_SCNODE_SET) || !(sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3767 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", func);
3768 } else if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3769 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", func, lys_nodetype2str(sleaf->nodetype),
Michal Vasko69730152020-10-09 16:30:07 +02003770 sleaf->name);
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003771 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_IDENT)) {
3772 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"identityref\".", func, sleaf->name);
3773 }
3774
3775 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
3776 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3777 LOGWRN(set->ctx, "Argument #2 of %s is a %s node \"%s\".", func, lys_nodetype2str(sleaf->nodetype),
Michal Vasko69730152020-10-09 16:30:07 +02003778 sleaf->name);
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003779 } else if (!warn_is_string_type(sleaf->type)) {
3780 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", func, sleaf->name);
3781 }
3782 }
3783 set_scnode_clear_ctx(set);
3784 return rc;
3785 }
3786
3787 if (args[0]->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003788 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]),
Michal Vasko69730152020-10-09 16:30:07 +02003789 "derived-from(-or-self)(node-set, string)");
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003790 return LY_EVALID;
3791 }
3792 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
3793 LY_CHECK_RET(rc);
3794
3795 set_fill_boolean(set, 0);
3796 found = 0;
3797 for (i = 0; i < args[0]->used; ++i) {
3798 if ((args[0]->val.nodes[i].type != LYXP_NODE_ELEM) && (args[0]->val.nodes[i].type != LYXP_NODE_META)) {
3799 continue;
3800 }
3801
3802 if (args[0]->val.nodes[i].type == LYXP_NODE_ELEM) {
3803 leaf = (struct lyd_node_term *)args[0]->val.nodes[i].node;
3804 sleaf = (struct lysc_node_leaf *)leaf->schema;
3805 val = &leaf->value;
3806 if (!(sleaf->nodetype & LYD_NODE_TERM) || (leaf->value.realtype->basetype != LY_TYPE_IDENT)) {
3807 /* uninteresting */
3808 continue;
3809 }
3810
3811 /* store args[1] as ident */
3812 rc = val->realtype->plugin->store(set->ctx, val->realtype, args[1]->val.str, strlen(args[1]->val.str),
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003813 0, set->format, set->prefix_data, LYD_HINT_DATA, leaf->schema, &data, &err);
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003814 } else {
3815 meta = args[0]->val.meta[i].meta;
3816 val = &meta->value;
3817 if (val->realtype->basetype != LY_TYPE_IDENT) {
3818 /* uninteresting */
3819 continue;
3820 }
3821
3822 /* store args[1] as ident */
Michal Vaskofeca4fb2020-10-05 08:58:40 +02003823 rc = val->realtype->plugin->store(set->ctx, val->realtype, args[1]->val.str, strlen(args[1]->val.str), 0,
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003824 set->format, set->prefix_data, LYD_HINT_DATA, meta->parent->schema, &data, &err);
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003825 }
3826
3827 if (err) {
3828 ly_err_print(err);
3829 ly_err_free(err);
3830 }
3831 LY_CHECK_RET(rc);
3832
3833 /* finally check the identity itself */
3834 if (self_match && (data.ident == val->ident)) {
3835 set_fill_boolean(set, 1);
3836 found = 1;
3837 }
3838 if (!found) {
3839 LY_ARRAY_FOR(data.ident->derived, u) {
3840 if (data.ident->derived[u] == val->ident) {
3841 set_fill_boolean(set, 1);
3842 found = 1;
3843 break;
3844 }
3845 }
3846 }
3847
3848 /* free temporary value */
3849 val->realtype->plugin->free(set->ctx, &data);
3850 if (found) {
3851 break;
3852 }
3853 }
3854
3855 return LY_SUCCESS;
3856}
3857
Michal Vasko03ff5a72019-09-11 13:49:33 +02003858/**
3859 * @brief Execute the YANG 1.1 derived-from(node-set, string) function. Returns LYXP_SET_BOOLEAN depending
3860 * on whether the first argument nodes contain a node of an identity derived from the second
3861 * argument identity.
3862 *
3863 * @param[in] args Array of arguments.
3864 * @param[in] arg_count Count of elements in @p args.
3865 * @param[in,out] set Context and result set at the same time.
3866 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003867 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003868 */
3869static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003870xpath_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 +02003871{
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003872 return xpath_derived_(args, set, options, 0, __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003873}
3874
3875/**
3876 * @brief Execute the YANG 1.1 derived-from-or-self(node-set, string) function. Returns LYXP_SET_BOOLEAN depending
3877 * on whether the first argument nodes contain a node of an identity that either is or is derived from
3878 * the second argument identity.
3879 *
3880 * @param[in] args Array of arguments.
3881 * @param[in] arg_count Count of elements in @p args.
3882 * @param[in,out] set Context and result set at the same time.
3883 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003884 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003885 */
3886static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003887xpath_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 +02003888{
Michal Vaskoe0dd59d2020-07-17 16:10:23 +02003889 return xpath_derived_(args, set, options, 1, __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003890}
3891
3892/**
3893 * @brief Execute the YANG 1.1 enum-value(node-set) function. Returns LYXP_SET_NUMBER
3894 * with the integer value of the first node's enum value, otherwise NaN.
3895 *
3896 * @param[in] args Array of arguments.
3897 * @param[in] arg_count Count of elements in @p args.
3898 * @param[in,out] set Context and result set at the same time.
3899 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003900 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003901 */
3902static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003903xpath_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 +02003904{
3905 struct lyd_node_term *leaf;
3906 struct lysc_node_leaf *sleaf;
3907 LY_ERR rc = LY_SUCCESS;
3908
3909 if (options & LYXP_SCNODE_ALL) {
3910 if ((args[0]->type != LYXP_SET_SCNODE_SET) || !(sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
3911 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003912 } else if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
3913 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 +02003914 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_ENUM)) {
3915 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"enumeration\".", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003916 }
3917 set_scnode_clear_ctx(set);
3918 return rc;
3919 }
3920
Michal Vaskod3678892020-05-21 10:06:58 +02003921 if (args[0]->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003922 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "enum-value(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02003923 return LY_EVALID;
3924 }
3925
3926 set_fill_number(set, NAN);
Michal Vaskod3678892020-05-21 10:06:58 +02003927 if (args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02003928 leaf = (struct lyd_node_term *)args[0]->val.nodes[0].node;
3929 sleaf = (struct lysc_node_leaf *)leaf->schema;
3930 if ((sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST)) && (sleaf->type->basetype == LY_TYPE_ENUM)) {
3931 set_fill_number(set, leaf->value.enum_item->value);
3932 }
3933 }
3934
3935 return LY_SUCCESS;
3936}
3937
3938/**
3939 * @brief Execute the XPath false() function. Returns LYXP_SET_BOOLEAN
3940 * with false value.
3941 *
3942 * @param[in] args Array of arguments.
3943 * @param[in] arg_count Count of elements in @p args.
3944 * @param[in,out] set Context and result set at the same time.
3945 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003946 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003947 */
3948static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003949xpath_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 +02003950{
3951 if (options & LYXP_SCNODE_ALL) {
3952 set_scnode_clear_ctx(set);
3953 return LY_SUCCESS;
3954 }
3955
3956 set_fill_boolean(set, 0);
3957 return LY_SUCCESS;
3958}
3959
3960/**
3961 * @brief Execute the XPath floor(number) function. Returns LYXP_SET_NUMBER
3962 * with the first argument floored (truncated).
3963 *
3964 * @param[in] args Array of arguments.
3965 * @param[in] arg_count Count of elements in @p args.
3966 * @param[in,out] set Context and result set at the same time.
3967 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003968 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003969 */
3970static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003971xpath_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 +02003972{
3973 LY_ERR rc;
3974
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01003975 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02003976 LY_CHECK_RET(rc);
3977 if (isfinite(args[0]->val.num)) {
3978 set_fill_number(set, (long long)args[0]->val.num);
3979 }
3980
3981 return LY_SUCCESS;
3982}
3983
3984/**
3985 * @brief Execute the XPath lang(string) function. Returns LYXP_SET_BOOLEAN
3986 * whether the language of the text matches the one from the argument.
3987 *
3988 * @param[in] args Array of arguments.
3989 * @param[in] arg_count Count of elements in @p args.
3990 * @param[in,out] set Context and result set at the same time.
3991 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01003992 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02003993 */
3994static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003995xpath_lang(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02003996{
3997 const struct lyd_node *node;
3998 struct lysc_node_leaf *sleaf;
Michal Vasko9f96a052020-03-10 09:41:45 +01003999 struct lyd_meta *meta = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004000 const char *val;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004001 LY_ERR rc = LY_SUCCESS;
4002
4003 if (options & LYXP_SCNODE_ALL) {
4004 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4005 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4006 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 +02004007 } else if (!warn_is_string_type(sleaf->type)) {
4008 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004009 }
4010 }
4011 set_scnode_clear_ctx(set);
4012 return rc;
4013 }
4014
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004015 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004016 LY_CHECK_RET(rc);
4017
Michal Vasko03ff5a72019-09-11 13:49:33 +02004018 if (set->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004019 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INCTX, print_set_type(set), "lang(string)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004020 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004021 } else if (!set->used) {
4022 set_fill_boolean(set, 0);
4023 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004024 }
4025
4026 switch (set->val.nodes[0].type) {
4027 case LYXP_NODE_ELEM:
4028 case LYXP_NODE_TEXT:
4029 node = set->val.nodes[0].node;
4030 break;
Michal Vasko9f96a052020-03-10 09:41:45 +01004031 case LYXP_NODE_META:
4032 node = set->val.meta[0].meta->parent;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004033 break;
4034 default:
4035 /* nothing to do with roots */
4036 set_fill_boolean(set, 0);
4037 return LY_SUCCESS;
4038 }
4039
Michal Vasko9f96a052020-03-10 09:41:45 +01004040 /* find lang metadata */
Michal Vaskod989ba02020-08-24 10:59:24 +02004041 for ( ; node; node = (struct lyd_node *)node->parent) {
Michal Vasko9f96a052020-03-10 09:41:45 +01004042 for (meta = node->meta; meta; meta = meta->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004043 /* annotations */
Michal Vasko9f96a052020-03-10 09:41:45 +01004044 if (meta->name && !strcmp(meta->name, "lang") && !strcmp(meta->annotation->module->name, "xml")) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004045 break;
4046 }
4047 }
4048
Michal Vasko9f96a052020-03-10 09:41:45 +01004049 if (meta) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004050 break;
4051 }
4052 }
4053
4054 /* compare languages */
Michal Vasko9f96a052020-03-10 09:41:45 +01004055 if (!meta) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004056 set_fill_boolean(set, 0);
4057 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004058 uint64_t i;
4059
Michal Vaskoba99a3e2020-08-18 15:50:05 +02004060 val = meta->value.canonical;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004061 for (i = 0; args[0]->val.str[i]; ++i) {
4062 if (tolower(args[0]->val.str[i]) != tolower(val[i])) {
4063 set_fill_boolean(set, 0);
4064 break;
4065 }
4066 }
4067 if (!args[0]->val.str[i]) {
4068 if (!val[i] || (val[i] == '-')) {
4069 set_fill_boolean(set, 1);
4070 } else {
4071 set_fill_boolean(set, 0);
4072 }
4073 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004074 }
4075
4076 return LY_SUCCESS;
4077}
4078
4079/**
4080 * @brief Execute the XPath last() function. Returns LYXP_SET_NUMBER
4081 * with the context size.
4082 *
4083 * @param[in] args Array of arguments.
4084 * @param[in] arg_count Count of elements in @p args.
4085 * @param[in,out] set Context and result set at the same time.
4086 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004087 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004088 */
4089static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004090xpath_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 +02004091{
4092 if (options & LYXP_SCNODE_ALL) {
4093 set_scnode_clear_ctx(set);
4094 return LY_SUCCESS;
4095 }
4096
Michal Vasko03ff5a72019-09-11 13:49:33 +02004097 if (set->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004098 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INCTX, print_set_type(set), "last()");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004099 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004100 } else if (!set->used) {
4101 set_fill_number(set, 0);
4102 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004103 }
4104
4105 set_fill_number(set, set->ctx_size);
4106 return LY_SUCCESS;
4107}
4108
4109/**
4110 * @brief Execute the XPath local-name(node-set?) function. Returns LYXP_SET_STRING
4111 * with the node name without namespace from the argument or the context.
4112 *
4113 * @param[in] args Array of arguments.
4114 * @param[in] arg_count Count of elements in @p args.
4115 * @param[in,out] set Context and result set at the same time.
4116 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004117 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004118 */
4119static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004120xpath_local_name(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004121{
4122 struct lyxp_set_node *item;
Michal Vasko69730152020-10-09 16:30:07 +02004123
Michal Vasko03ff5a72019-09-11 13:49:33 +02004124 /* suppress unused variable warning */
4125 (void)options;
4126
4127 if (options & LYXP_SCNODE_ALL) {
4128 set_scnode_clear_ctx(set);
4129 return LY_SUCCESS;
4130 }
4131
4132 if (arg_count) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004133 if (args[0]->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004134 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]),
4135 "local-name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004136 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004137 } else if (!args[0]->used) {
4138 set_fill_string(set, "", 0);
4139 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004140 }
4141
4142 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004143 assert(!set_sort(args[0]));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004144
4145 item = &args[0]->val.nodes[0];
4146 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004147 if (set->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004148 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INCTX, print_set_type(set), "local-name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004149 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004150 } else if (!set->used) {
4151 set_fill_string(set, "", 0);
4152 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004153 }
4154
4155 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004156 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004157
4158 item = &set->val.nodes[0];
4159 }
4160
4161 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01004162 case LYXP_NODE_NONE:
4163 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004164 case LYXP_NODE_ROOT:
4165 case LYXP_NODE_ROOT_CONFIG:
4166 case LYXP_NODE_TEXT:
4167 set_fill_string(set, "", 0);
4168 break;
4169 case LYXP_NODE_ELEM:
4170 set_fill_string(set, item->node->schema->name, strlen(item->node->schema->name));
4171 break;
Michal Vasko9f96a052020-03-10 09:41:45 +01004172 case LYXP_NODE_META:
4173 set_fill_string(set, ((struct lyd_meta *)item->node)->name, strlen(((struct lyd_meta *)item->node)->name));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004174 break;
4175 }
4176
4177 return LY_SUCCESS;
4178}
4179
4180/**
4181 * @brief Execute the XPath name(node-set?) function. Returns LYXP_SET_STRING
4182 * with the node name fully qualified (with namespace) from the argument or the context.
4183 *
4184 * @param[in] args Array of arguments.
4185 * @param[in] arg_count Count of elements in @p args.
4186 * @param[in,out] set Context and result set at the same time.
4187 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004188 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004189 */
4190static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004191xpath_name(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004192{
4193 struct lyxp_set_node *item;
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02004194 struct lys_module *mod = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004195 char *str;
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02004196 const char *name = NULL;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004197
4198 if (options & LYXP_SCNODE_ALL) {
4199 set_scnode_clear_ctx(set);
4200 return LY_SUCCESS;
4201 }
4202
4203 if (arg_count) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004204 if (args[0]->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004205 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004206 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004207 } else if (!args[0]->used) {
4208 set_fill_string(set, "", 0);
4209 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004210 }
4211
4212 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004213 assert(!set_sort(args[0]));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004214
4215 item = &args[0]->val.nodes[0];
4216 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004217 if (set->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004218 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INCTX, print_set_type(set), "name(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004219 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004220 } else if (!set->used) {
4221 set_fill_string(set, "", 0);
4222 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004223 }
4224
4225 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004226 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004227
4228 item = &set->val.nodes[0];
4229 }
4230
4231 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01004232 case LYXP_NODE_NONE:
4233 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004234 case LYXP_NODE_ROOT:
4235 case LYXP_NODE_ROOT_CONFIG:
4236 case LYXP_NODE_TEXT:
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02004237 /* keep NULL */
Michal Vasko03ff5a72019-09-11 13:49:33 +02004238 break;
4239 case LYXP_NODE_ELEM:
4240 mod = item->node->schema->module;
4241 name = item->node->schema->name;
4242 break;
Michal Vasko9f96a052020-03-10 09:41:45 +01004243 case LYXP_NODE_META:
4244 mod = ((struct lyd_meta *)item->node)->annotation->module;
4245 name = ((struct lyd_meta *)item->node)->name;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004246 break;
4247 }
4248
4249 if (mod && name) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004250 int rc = asprintf(&str, "%s:%s", ly_get_prefix(mod, set->format, set->prefix_data), name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004251 LY_CHECK_ERR_RET(rc == -1, LOGMEM(set->ctx), LY_EMEM);
4252 set_fill_string(set, str, strlen(str));
4253 free(str);
4254 } else {
4255 set_fill_string(set, "", 0);
4256 }
4257
4258 return LY_SUCCESS;
4259}
4260
4261/**
4262 * @brief Execute the XPath namespace-uri(node-set?) function. Returns LYXP_SET_STRING
4263 * with the namespace of the node from the argument or the context.
4264 *
4265 * @param[in] args Array of arguments.
4266 * @param[in] arg_count Count of elements in @p args.
4267 * @param[in,out] set Context and result set at the same time.
4268 * @param[in] options XPath options.
4269 * @return LY_ERR (LY_EINVAL for wrong arguments on schema)
4270 */
4271static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004272xpath_namespace_uri(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004273{
4274 struct lyxp_set_node *item;
4275 struct lys_module *mod;
Michal Vasko69730152020-10-09 16:30:07 +02004276
Michal Vasko03ff5a72019-09-11 13:49:33 +02004277 /* suppress unused variable warning */
4278 (void)options;
4279
4280 if (options & LYXP_SCNODE_ALL) {
4281 set_scnode_clear_ctx(set);
4282 return LY_SUCCESS;
4283 }
4284
4285 if (arg_count) {
Michal Vaskod3678892020-05-21 10:06:58 +02004286 if (args[0]->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004287 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]),
Michal Vasko69730152020-10-09 16:30:07 +02004288 "namespace-uri(node-set?)");
Michal Vaskod3678892020-05-21 10:06:58 +02004289 return LY_EVALID;
4290 } else if (!args[0]->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004291 set_fill_string(set, "", 0);
4292 return LY_SUCCESS;
4293 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02004294
4295 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004296 assert(!set_sort(args[0]));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004297
4298 item = &args[0]->val.nodes[0];
4299 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004300 if (set->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004301 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INCTX, print_set_type(set), "namespace-uri(node-set?)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004302 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004303 } else if (!set->used) {
4304 set_fill_string(set, "", 0);
4305 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004306 }
4307
4308 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004309 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02004310
4311 item = &set->val.nodes[0];
4312 }
4313
4314 switch (item->type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01004315 case LYXP_NODE_NONE:
4316 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004317 case LYXP_NODE_ROOT:
4318 case LYXP_NODE_ROOT_CONFIG:
4319 case LYXP_NODE_TEXT:
4320 set_fill_string(set, "", 0);
4321 break;
4322 case LYXP_NODE_ELEM:
Michal Vasko9f96a052020-03-10 09:41:45 +01004323 case LYXP_NODE_META:
Michal Vasko03ff5a72019-09-11 13:49:33 +02004324 if (item->type == LYXP_NODE_ELEM) {
4325 mod = item->node->schema->module;
Michal Vasko9f96a052020-03-10 09:41:45 +01004326 } else { /* LYXP_NODE_META */
Michal Vasko03ff5a72019-09-11 13:49:33 +02004327 /* annotations */
Michal Vasko9f96a052020-03-10 09:41:45 +01004328 mod = ((struct lyd_meta *)item->node)->annotation->module;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004329 }
4330
4331 set_fill_string(set, mod->ns, strlen(mod->ns));
4332 break;
4333 }
4334
4335 return LY_SUCCESS;
4336}
4337
4338/**
4339 * @brief Execute the XPath node() function (node type). Returns LYXP_SET_NODE_SET
4340 * with only nodes from the context. In practice it either leaves the context
4341 * as it is or returns an empty node set.
4342 *
4343 * @param[in] args Array of arguments.
4344 * @param[in] arg_count Count of elements in @p args.
4345 * @param[in,out] set Context and result set at the same time.
4346 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004347 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004348 */
4349static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004350xpath_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 +02004351{
4352 if (options & LYXP_SCNODE_ALL) {
4353 set_scnode_clear_ctx(set);
4354 return LY_SUCCESS;
4355 }
4356
4357 if (set->type != LYXP_SET_NODE_SET) {
Michal Vaskod3678892020-05-21 10:06:58 +02004358 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004359 }
4360 return LY_SUCCESS;
4361}
4362
4363/**
4364 * @brief Execute the XPath normalize-space(string?) function. Returns LYXP_SET_STRING
4365 * with normalized value (no leading, trailing, double white spaces) of the node
4366 * from the argument or the context.
4367 *
4368 * @param[in] args Array of arguments.
4369 * @param[in] arg_count Count of elements in @p args.
4370 * @param[in,out] set Context and result set at the same time.
4371 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004372 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004373 */
4374static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004375xpath_normalize_space(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004376{
4377 uint16_t i, new_used;
4378 char *new;
Radek Krejci857189e2020-09-01 13:26:36 +02004379 ly_bool have_spaces = 0, space_before = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004380 struct lysc_node_leaf *sleaf;
4381 LY_ERR rc = LY_SUCCESS;
4382
4383 if (options & LYXP_SCNODE_ALL) {
4384 if (arg_count && (args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4385 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4386 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 +02004387 } else if (!warn_is_string_type(sleaf->type)) {
4388 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004389 }
4390 }
4391 set_scnode_clear_ctx(set);
4392 return rc;
4393 }
4394
4395 if (arg_count) {
4396 set_fill_set(set, args[0]);
4397 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004398 rc = lyxp_set_cast(set, LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004399 LY_CHECK_RET(rc);
4400
4401 /* is there any normalization necessary? */
4402 for (i = 0; set->val.str[i]; ++i) {
4403 if (is_xmlws(set->val.str[i])) {
4404 if ((i == 0) || space_before || (!set->val.str[i + 1])) {
4405 have_spaces = 1;
4406 break;
4407 }
4408 space_before = 1;
4409 } else {
4410 space_before = 0;
4411 }
4412 }
4413
4414 /* yep, there is */
4415 if (have_spaces) {
4416 /* it's enough, at least one character will go, makes space for ending '\0' */
4417 new = malloc(strlen(set->val.str) * sizeof(char));
4418 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
4419 new_used = 0;
4420
4421 space_before = 0;
4422 for (i = 0; set->val.str[i]; ++i) {
4423 if (is_xmlws(set->val.str[i])) {
4424 if ((i == 0) || space_before) {
4425 space_before = 1;
4426 continue;
4427 } else {
4428 space_before = 1;
4429 }
4430 } else {
4431 space_before = 0;
4432 }
4433
4434 new[new_used] = (space_before ? ' ' : set->val.str[i]);
4435 ++new_used;
4436 }
4437
4438 /* at worst there is one trailing space now */
4439 if (new_used && is_xmlws(new[new_used - 1])) {
4440 --new_used;
4441 }
4442
4443 new = ly_realloc(new, (new_used + 1) * sizeof(char));
4444 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
4445 new[new_used] = '\0';
4446
4447 free(set->val.str);
4448 set->val.str = new;
4449 }
4450
4451 return LY_SUCCESS;
4452}
4453
4454/**
4455 * @brief Execute the XPath not(boolean) function. Returns LYXP_SET_BOOLEAN
4456 * with the argument converted to boolean and logically inverted.
4457 *
4458 * @param[in] args Array of arguments.
4459 * @param[in] arg_count Count of elements in @p args.
4460 * @param[in,out] set Context and result set at the same time.
4461 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004462 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004463 */
4464static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004465xpath_not(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004466{
4467 if (options & LYXP_SCNODE_ALL) {
4468 set_scnode_clear_ctx(set);
4469 return LY_SUCCESS;
4470 }
4471
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004472 lyxp_set_cast(args[0], LYXP_SET_BOOLEAN);
Michal Vasko004d3152020-06-11 19:59:22 +02004473 if (args[0]->val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004474 set_fill_boolean(set, 0);
4475 } else {
4476 set_fill_boolean(set, 1);
4477 }
4478
4479 return LY_SUCCESS;
4480}
4481
4482/**
4483 * @brief Execute the XPath number(object?) function. Returns LYXP_SET_NUMBER
4484 * with the number representation of either the argument or the context.
4485 *
4486 * @param[in] args Array of arguments.
4487 * @param[in] arg_count Count of elements in @p args.
4488 * @param[in,out] set Context and result set at the same time.
4489 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004490 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004491 */
4492static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004493xpath_number(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004494{
4495 LY_ERR rc;
4496
4497 if (options & LYXP_SCNODE_ALL) {
4498 set_scnode_clear_ctx(set);
4499 return LY_SUCCESS;
4500 }
4501
4502 if (arg_count) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004503 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004504 LY_CHECK_RET(rc);
4505 set_fill_set(set, args[0]);
4506 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004507 rc = lyxp_set_cast(set, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004508 LY_CHECK_RET(rc);
4509 }
4510
4511 return LY_SUCCESS;
4512}
4513
4514/**
4515 * @brief Execute the XPath position() function. Returns LYXP_SET_NUMBER
4516 * with the context position.
4517 *
4518 * @param[in] args Array of arguments.
4519 * @param[in] arg_count Count of elements in @p args.
4520 * @param[in,out] set Context and result set at the same time.
4521 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004522 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004523 */
4524static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004525xpath_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 +02004526{
4527 if (options & LYXP_SCNODE_ALL) {
4528 set_scnode_clear_ctx(set);
4529 return LY_SUCCESS;
4530 }
4531
Michal Vasko03ff5a72019-09-11 13:49:33 +02004532 if (set->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004533 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INCTX, print_set_type(set), "position()");
Michal Vasko03ff5a72019-09-11 13:49:33 +02004534 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02004535 } else if (!set->used) {
4536 set_fill_number(set, 0);
4537 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004538 }
4539
4540 set_fill_number(set, set->ctx_pos);
4541
4542 /* UNUSED in 'Release' build type */
4543 (void)options;
4544 return LY_SUCCESS;
4545}
4546
4547/**
4548 * @brief Execute the YANG 1.1 re-match(string, string) function. Returns LYXP_SET_BOOLEAN
4549 * depending on whether the second argument regex matches the first argument string. For details refer to
4550 * YANG 1.1 RFC section 10.2.1.
4551 *
4552 * @param[in] args Array of arguments.
4553 * @param[in] arg_count Count of elements in @p args.
4554 * @param[in,out] set Context and result set at the same time.
4555 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004556 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004557 */
4558static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004559xpath_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 +02004560{
4561 struct lysc_pattern **patterns = NULL, **pattern;
4562 struct lysc_node_leaf *sleaf;
4563 char *path;
4564 LY_ERR rc = LY_SUCCESS;
4565 struct ly_err_item *err;
4566
4567 if (options & LYXP_SCNODE_ALL) {
4568 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4569 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4570 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 +02004571 } else if (!warn_is_string_type(sleaf->type)) {
4572 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004573 }
4574 }
4575
4576 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4577 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4578 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 +02004579 } else if (!warn_is_string_type(sleaf->type)) {
4580 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004581 }
4582 }
4583 set_scnode_clear_ctx(set);
4584 return rc;
4585 }
4586
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004587 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004588 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004589 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004590 LY_CHECK_RET(rc);
4591
4592 LY_ARRAY_NEW_RET(set->ctx, patterns, pattern, LY_EMEM);
4593 *pattern = malloc(sizeof **pattern);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004594 path = lyd_path(set->cur_node, LYD_PATH_LOG, NULL, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004595 rc = lys_compile_type_pattern_check(set->ctx, path, args[1]->val.str, &(*pattern)->code);
4596 free(path);
4597 if (rc != LY_SUCCESS) {
4598 LY_ARRAY_FREE(patterns);
4599 return rc;
4600 }
4601
4602 rc = ly_type_validate_patterns(patterns, args[0]->val.str, strlen(args[0]->val.str), &err);
4603 pcre2_code_free((*pattern)->code);
4604 free(*pattern);
4605 LY_ARRAY_FREE(patterns);
4606 if (rc && (rc != LY_EVALID)) {
4607 ly_err_print(err);
4608 ly_err_free(err);
4609 return rc;
4610 }
4611
4612 if (rc == LY_EVALID) {
4613 ly_err_free(err);
4614 set_fill_boolean(set, 0);
4615 } else {
4616 set_fill_boolean(set, 1);
4617 }
4618
4619 return LY_SUCCESS;
4620}
4621
4622/**
4623 * @brief Execute the XPath round(number) function. Returns LYXP_SET_NUMBER
4624 * with the rounded first argument. For details refer to
4625 * http://www.w3.org/TR/1999/REC-xpath-19991116/#function-round.
4626 *
4627 * @param[in] args Array of arguments.
4628 * @param[in] arg_count Count of elements in @p args.
4629 * @param[in,out] set Context and result set at the same time.
4630 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004631 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004632 */
4633static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004634xpath_round(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004635{
4636 struct lysc_node_leaf *sleaf;
4637 LY_ERR rc = LY_SUCCESS;
4638
4639 if (options & LYXP_SCNODE_ALL) {
4640 if ((args[0]->type != LYXP_SET_SCNODE_SET) || !(sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4641 LOGWRN(set->ctx, "Argument #1 of %s not a node-set as expected.", __func__);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004642 } else if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4643 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 +02004644 } else if (!warn_is_specific_type(sleaf->type, LY_TYPE_DEC64)) {
4645 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of type \"decimal64\".", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004646 }
4647 set_scnode_clear_ctx(set);
4648 return rc;
4649 }
4650
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004651 rc = lyxp_set_cast(args[0], LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004652 LY_CHECK_RET(rc);
4653
4654 /* cover only the cases where floor can't be used */
4655 if ((args[0]->val.num == -0.0f) || ((args[0]->val.num < 0) && (args[0]->val.num >= -0.5))) {
4656 set_fill_number(set, -0.0f);
4657 } else {
4658 args[0]->val.num += 0.5;
4659 rc = xpath_floor(args, 1, args[0], options);
4660 LY_CHECK_RET(rc);
4661 set_fill_number(set, args[0]->val.num);
4662 }
4663
4664 return LY_SUCCESS;
4665}
4666
4667/**
4668 * @brief Execute the XPath starts-with(string, string) function.
4669 * Returns LYXP_SET_BOOLEAN whether the second argument is
4670 * the prefix of the first or not.
4671 *
4672 * @param[in] args Array of arguments.
4673 * @param[in] arg_count Count of elements in @p args.
4674 * @param[in,out] set Context and result set at the same time.
4675 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004676 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004677 */
4678static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004679xpath_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 +02004680{
4681 struct lysc_node_leaf *sleaf;
4682 LY_ERR rc = LY_SUCCESS;
4683
4684 if (options & LYXP_SCNODE_ALL) {
4685 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4686 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4687 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 +02004688 } else if (!warn_is_string_type(sleaf->type)) {
4689 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004690 }
4691 }
4692
4693 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4694 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4695 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 +02004696 } else if (!warn_is_string_type(sleaf->type)) {
4697 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004698 }
4699 }
4700 set_scnode_clear_ctx(set);
4701 return rc;
4702 }
4703
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004704 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004705 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004706 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004707 LY_CHECK_RET(rc);
4708
4709 if (strncmp(args[0]->val.str, args[1]->val.str, strlen(args[1]->val.str))) {
4710 set_fill_boolean(set, 0);
4711 } else {
4712 set_fill_boolean(set, 1);
4713 }
4714
4715 return LY_SUCCESS;
4716}
4717
4718/**
4719 * @brief Execute the XPath string(object?) function. Returns LYXP_SET_STRING
4720 * with the string representation of either the argument or the context.
4721 *
4722 * @param[in] args Array of arguments.
4723 * @param[in] arg_count Count of elements in @p args.
4724 * @param[in,out] set Context and result set at the same time.
4725 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004726 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004727 */
4728static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004729xpath_string(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004730{
4731 LY_ERR rc;
4732
4733 if (options & LYXP_SCNODE_ALL) {
4734 set_scnode_clear_ctx(set);
4735 return LY_SUCCESS;
4736 }
4737
4738 if (arg_count) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004739 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004740 LY_CHECK_RET(rc);
4741 set_fill_set(set, args[0]);
4742 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004743 rc = lyxp_set_cast(set, LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004744 LY_CHECK_RET(rc);
4745 }
4746
4747 return LY_SUCCESS;
4748}
4749
4750/**
4751 * @brief Execute the XPath string-length(string?) function. Returns LYXP_SET_NUMBER
4752 * with the length of the string in either the argument or the context.
4753 *
4754 * @param[in] args Array of arguments.
4755 * @param[in] arg_count Count of elements in @p args.
4756 * @param[in,out] set Context and result set at the same time.
4757 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004758 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004759 */
4760static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004761xpath_string_length(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004762{
4763 struct lysc_node_leaf *sleaf;
4764 LY_ERR rc = LY_SUCCESS;
4765
4766 if (options & LYXP_SCNODE_ALL) {
4767 if (arg_count && (args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4768 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4769 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 +02004770 } else if (!warn_is_string_type(sleaf->type)) {
4771 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004772 }
4773 }
4774 if (!arg_count && (set->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(set))) {
4775 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4776 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 +02004777 } else if (!warn_is_string_type(sleaf->type)) {
4778 LOGWRN(set->ctx, "Argument #0 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004779 }
4780 }
4781 set_scnode_clear_ctx(set);
4782 return rc;
4783 }
4784
4785 if (arg_count) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004786 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004787 LY_CHECK_RET(rc);
4788 set_fill_number(set, strlen(args[0]->val.str));
4789 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004790 rc = lyxp_set_cast(set, LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004791 LY_CHECK_RET(rc);
4792 set_fill_number(set, strlen(set->val.str));
4793 }
4794
4795 return LY_SUCCESS;
4796}
4797
4798/**
4799 * @brief Execute the XPath substring(string, number, number?) function.
4800 * Returns LYXP_SET_STRING substring of the first argument starting
4801 * on the second argument index ending on the third argument index,
4802 * indexed from 1. For exact definition refer to
4803 * http://www.w3.org/TR/1999/REC-xpath-19991116/#function-substring.
4804 *
4805 * @param[in] args Array of arguments.
4806 * @param[in] arg_count Count of elements in @p args.
4807 * @param[in,out] set Context and result set at the same time.
4808 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004809 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004810 */
4811static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004812xpath_substring(struct lyxp_set **args, uint16_t arg_count, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02004813{
Radek Krejci1deb5be2020-08-26 16:43:36 +02004814 int32_t start, len;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004815 uint16_t str_start, str_len, pos;
4816 struct lysc_node_leaf *sleaf;
4817 LY_ERR rc = LY_SUCCESS;
4818
4819 if (options & LYXP_SCNODE_ALL) {
4820 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4821 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4822 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 +02004823 } else if (!warn_is_string_type(sleaf->type)) {
4824 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004825 }
4826 }
4827
4828 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4829 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4830 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 +02004831 } else if (!warn_is_numeric_type(sleaf->type)) {
4832 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004833 }
4834 }
4835
Michal Vasko69730152020-10-09 16:30:07 +02004836 if ((arg_count == 3) && (args[2]->type == LYXP_SET_SCNODE_SET) &&
4837 (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[2]))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004838 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4839 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 +02004840 } else if (!warn_is_numeric_type(sleaf->type)) {
4841 LOGWRN(set->ctx, "Argument #3 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004842 }
4843 }
4844 set_scnode_clear_ctx(set);
4845 return rc;
4846 }
4847
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004848 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004849 LY_CHECK_RET(rc);
4850
4851 /* start */
4852 if (xpath_round(&args[1], 1, args[1], options)) {
4853 return -1;
4854 }
4855 if (isfinite(args[1]->val.num)) {
4856 start = args[1]->val.num - 1;
4857 } else if (isinf(args[1]->val.num) && signbit(args[1]->val.num)) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004858 start = INT32_MIN;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004859 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004860 start = INT32_MAX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004861 }
4862
4863 /* len */
4864 if (arg_count == 3) {
4865 rc = xpath_round(&args[2], 1, args[2], options);
4866 LY_CHECK_RET(rc);
Radek Krejci1deb5be2020-08-26 16:43:36 +02004867 if (isnan(args[2]->val.num) || signbit(args[2]->val.num)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02004868 len = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02004869 } else if (isfinite(args[2]->val.num)) {
4870 len = args[2]->val.num;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004871 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004872 len = INT32_MAX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004873 }
4874 } else {
Radek Krejci1deb5be2020-08-26 16:43:36 +02004875 len = INT32_MAX;
Michal Vasko03ff5a72019-09-11 13:49:33 +02004876 }
4877
4878 /* find matching character positions */
4879 str_start = 0;
4880 str_len = 0;
4881 for (pos = 0; args[0]->val.str[pos]; ++pos) {
4882 if (pos < start) {
4883 ++str_start;
4884 } else if (pos < start + len) {
4885 ++str_len;
4886 } else {
4887 break;
4888 }
4889 }
4890
4891 set_fill_string(set, args[0]->val.str + str_start, str_len);
4892 return LY_SUCCESS;
4893}
4894
4895/**
4896 * @brief Execute the XPath substring-after(string, string) function.
4897 * Returns LYXP_SET_STRING with the string succeeding the occurance
4898 * of the second argument in the first or an empty string.
4899 *
4900 * @param[in] args Array of arguments.
4901 * @param[in] arg_count Count of elements in @p args.
4902 * @param[in,out] set Context and result set at the same time.
4903 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004904 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004905 */
4906static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004907xpath_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 +02004908{
4909 char *ptr;
4910 struct lysc_node_leaf *sleaf;
4911 LY_ERR rc = LY_SUCCESS;
4912
4913 if (options & LYXP_SCNODE_ALL) {
4914 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4915 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4916 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 +02004917 } else if (!warn_is_string_type(sleaf->type)) {
4918 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004919 }
4920 }
4921
4922 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4923 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4924 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 +02004925 } else if (!warn_is_string_type(sleaf->type)) {
4926 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004927 }
4928 }
4929 set_scnode_clear_ctx(set);
4930 return rc;
4931 }
4932
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004933 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004934 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004935 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004936 LY_CHECK_RET(rc);
4937
4938 ptr = strstr(args[0]->val.str, args[1]->val.str);
4939 if (ptr) {
4940 set_fill_string(set, ptr + strlen(args[1]->val.str), strlen(ptr + strlen(args[1]->val.str)));
4941 } else {
4942 set_fill_string(set, "", 0);
4943 }
4944
4945 return LY_SUCCESS;
4946}
4947
4948/**
4949 * @brief Execute the XPath substring-before(string, string) function.
4950 * Returns LYXP_SET_STRING with the string preceding the occurance
4951 * of the second argument in the first or an empty string.
4952 *
4953 * @param[in] args Array of arguments.
4954 * @param[in] arg_count Count of elements in @p args.
4955 * @param[in,out] set Context and result set at the same time.
4956 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01004957 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02004958 */
4959static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02004960xpath_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 +02004961{
4962 char *ptr;
4963 struct lysc_node_leaf *sleaf;
4964 LY_ERR rc = LY_SUCCESS;
4965
4966 if (options & LYXP_SCNODE_ALL) {
4967 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
4968 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4969 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 +02004970 } else if (!warn_is_string_type(sleaf->type)) {
4971 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004972 }
4973 }
4974
4975 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
4976 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
4977 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 +02004978 } else if (!warn_is_string_type(sleaf->type)) {
4979 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004980 }
4981 }
4982 set_scnode_clear_ctx(set);
4983 return rc;
4984 }
4985
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004986 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004987 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01004988 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02004989 LY_CHECK_RET(rc);
4990
4991 ptr = strstr(args[0]->val.str, args[1]->val.str);
4992 if (ptr) {
4993 set_fill_string(set, args[0]->val.str, ptr - args[0]->val.str);
4994 } else {
4995 set_fill_string(set, "", 0);
4996 }
4997
4998 return LY_SUCCESS;
4999}
5000
5001/**
5002 * @brief Execute the XPath sum(node-set) function. Returns LYXP_SET_NUMBER
5003 * with the sum of all the nodes in the context.
5004 *
5005 * @param[in] args Array of arguments.
5006 * @param[in] arg_count Count of elements in @p args.
5007 * @param[in,out] set Context and result set at the same time.
5008 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005009 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005010 */
5011static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005012xpath_sum(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005013{
5014 long double num;
5015 char *str;
5016 uint16_t i;
5017 struct lyxp_set set_item;
5018 struct lysc_node_leaf *sleaf;
5019 LY_ERR rc = LY_SUCCESS;
5020
5021 if (options & LYXP_SCNODE_ALL) {
5022 if (args[0]->type == LYXP_SET_SCNODE_SET) {
5023 for (i = 0; i < args[0]->used; ++i) {
5024 if (args[0]->val.scnodes[i].in_ctx == 1) {
5025 sleaf = (struct lysc_node_leaf *)args[0]->val.scnodes[i].scnode;
5026 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5027 LOGWRN(set->ctx, "Argument #1 of %s is a %s node \"%s\".", __func__,
Michal Vasko69730152020-10-09 16:30:07 +02005028 lys_nodetype2str(sleaf->nodetype), sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005029 } else if (!warn_is_numeric_type(sleaf->type)) {
5030 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of numeric type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005031 }
5032 }
5033 }
5034 }
5035 set_scnode_clear_ctx(set);
5036 return rc;
5037 }
5038
5039 set_fill_number(set, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005040
5041 if (args[0]->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005042 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INARGTYPE, 1, print_set_type(args[0]), "sum(node-set)");
Michal Vasko03ff5a72019-09-11 13:49:33 +02005043 return LY_EVALID;
Michal Vaskod3678892020-05-21 10:06:58 +02005044 } else if (!args[0]->used) {
5045 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005046 }
5047
Michal Vasko5c4e5892019-11-14 12:31:38 +01005048 set_init(&set_item, set);
5049
Michal Vasko03ff5a72019-09-11 13:49:33 +02005050 set_item.type = LYXP_SET_NODE_SET;
5051 set_item.val.nodes = malloc(sizeof *set_item.val.nodes);
5052 LY_CHECK_ERR_RET(!set_item.val.nodes, LOGMEM(set->ctx), LY_EMEM);
5053
5054 set_item.used = 1;
5055 set_item.size = 1;
5056
5057 for (i = 0; i < args[0]->used; ++i) {
5058 set_item.val.nodes[0] = args[0]->val.nodes[i];
5059
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005060 rc = cast_node_set_to_string(&set_item, &str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005061 LY_CHECK_RET(rc);
5062 num = cast_string_to_number(str);
5063 free(str);
5064 set->val.num += num;
5065 }
5066
5067 free(set_item.val.nodes);
5068
5069 return LY_SUCCESS;
5070}
5071
5072/**
5073 * @brief Execute the XPath text() function (node type). Returns LYXP_SET_NODE_SET
5074 * with the text content of the nodes in the context.
5075 *
5076 * @param[in] args Array of arguments.
5077 * @param[in] arg_count Count of elements in @p args.
5078 * @param[in,out] set Context and result set at the same time.
5079 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005080 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005081 */
5082static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005083xpath_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 +02005084{
5085 uint32_t i;
5086
5087 if (options & LYXP_SCNODE_ALL) {
5088 set_scnode_clear_ctx(set);
5089 return LY_SUCCESS;
5090 }
5091
Michal Vasko03ff5a72019-09-11 13:49:33 +02005092 if (set->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005093 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INCTX, print_set_type(set), "text()");
Michal Vasko03ff5a72019-09-11 13:49:33 +02005094 return LY_EVALID;
5095 }
5096
Michal Vaskod989ba02020-08-24 10:59:24 +02005097 for (i = 0; i < set->used; ) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005098 switch (set->val.nodes[i].type) {
Michal Vasko2caefc12019-11-14 16:07:56 +01005099 case LYXP_NODE_NONE:
5100 LOGINT_RET(set->ctx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005101 case LYXP_NODE_ELEM:
Michal Vasko03ff5a72019-09-11 13:49:33 +02005102 if (set->val.nodes[i].node->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
5103 set->val.nodes[i].type = LYXP_NODE_TEXT;
5104 ++i;
5105 break;
5106 }
Radek Krejci0f969882020-08-21 16:56:47 +02005107 /* fall through */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005108 case LYXP_NODE_ROOT:
5109 case LYXP_NODE_ROOT_CONFIG:
5110 case LYXP_NODE_TEXT:
Michal Vasko9f96a052020-03-10 09:41:45 +01005111 case LYXP_NODE_META:
Michal Vasko03ff5a72019-09-11 13:49:33 +02005112 set_remove_node(set, i);
5113 break;
5114 }
5115 }
5116
5117 return LY_SUCCESS;
5118}
5119
5120/**
5121 * @brief Execute the XPath translate(string, string, string) function.
5122 * Returns LYXP_SET_STRING with the first argument with the characters
5123 * from the second argument replaced by those on the corresponding
5124 * positions in the third argument.
5125 *
5126 * @param[in] args Array of arguments.
5127 * @param[in] arg_count Count of elements in @p args.
5128 * @param[in,out] set Context and result set at the same time.
5129 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005130 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005131 */
5132static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005133xpath_translate(struct lyxp_set **args, uint16_t UNUSED(arg_count), struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005134{
5135 uint16_t i, j, new_used;
5136 char *new;
Radek Krejci857189e2020-09-01 13:26:36 +02005137 ly_bool have_removed;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005138 struct lysc_node_leaf *sleaf;
5139 LY_ERR rc = LY_SUCCESS;
5140
5141 if (options & LYXP_SCNODE_ALL) {
5142 if ((args[0]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[0]))) {
5143 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5144 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 +02005145 } else if (!warn_is_string_type(sleaf->type)) {
5146 LOGWRN(set->ctx, "Argument #1 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005147 }
5148 }
5149
5150 if ((args[1]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[1]))) {
5151 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5152 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 +02005153 } else if (!warn_is_string_type(sleaf->type)) {
5154 LOGWRN(set->ctx, "Argument #2 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005155 }
5156 }
5157
5158 if ((args[2]->type == LYXP_SET_SCNODE_SET) && (sleaf = (struct lysc_node_leaf *)warn_get_scnode_in_ctx(args[2]))) {
5159 if (!(sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
5160 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 +02005161 } else if (!warn_is_string_type(sleaf->type)) {
5162 LOGWRN(set->ctx, "Argument #3 of %s is node \"%s\", not of string-type.", __func__, sleaf->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005163 }
5164 }
5165 set_scnode_clear_ctx(set);
5166 return rc;
5167 }
5168
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005169 rc = lyxp_set_cast(args[0], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005170 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005171 rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005172 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005173 rc = lyxp_set_cast(args[2], LYXP_SET_STRING);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005174 LY_CHECK_RET(rc);
5175
5176 new = malloc((strlen(args[0]->val.str) + 1) * sizeof(char));
5177 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
5178 new_used = 0;
5179
5180 have_removed = 0;
5181 for (i = 0; args[0]->val.str[i]; ++i) {
Radek Krejci857189e2020-09-01 13:26:36 +02005182 ly_bool found = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005183
5184 for (j = 0; args[1]->val.str[j]; ++j) {
5185 if (args[0]->val.str[i] == args[1]->val.str[j]) {
5186 /* removing this char */
5187 if (j >= strlen(args[2]->val.str)) {
5188 have_removed = 1;
5189 found = 1;
5190 break;
5191 }
5192 /* replacing this char */
5193 new[new_used] = args[2]->val.str[j];
5194 ++new_used;
5195 found = 1;
5196 break;
5197 }
5198 }
5199
5200 /* copying this char */
5201 if (!found) {
5202 new[new_used] = args[0]->val.str[i];
5203 ++new_used;
5204 }
5205 }
5206
5207 if (have_removed) {
5208 new = ly_realloc(new, (new_used + 1) * sizeof(char));
5209 LY_CHECK_ERR_RET(!new, LOGMEM(set->ctx), LY_EMEM);
5210 }
5211 new[new_used] = '\0';
5212
Michal Vaskod3678892020-05-21 10:06:58 +02005213 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005214 set->type = LYXP_SET_STRING;
5215 set->val.str = new;
5216
5217 return LY_SUCCESS;
5218}
5219
5220/**
5221 * @brief Execute the XPath true() function. Returns LYXP_SET_BOOLEAN
5222 * with true value.
5223 *
5224 * @param[in] args Array of arguments.
5225 * @param[in] arg_count Count of elements in @p args.
5226 * @param[in,out] set Context and result set at the same time.
5227 * @param[in] options XPath options.
Michal Vasko0cbf54f2019-12-16 10:01:06 +01005228 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005229 */
5230static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005231xpath_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 +02005232{
5233 if (options & LYXP_SCNODE_ALL) {
5234 set_scnode_clear_ctx(set);
5235 return LY_SUCCESS;
5236 }
5237
5238 set_fill_boolean(set, 1);
5239 return LY_SUCCESS;
5240}
5241
5242/*
5243 * moveto functions
5244 *
5245 * They and only they actually change the context (set).
5246 */
5247
5248/**
Michal Vasko6346ece2019-09-24 13:12:53 +02005249 * @brief Skip prefix and return corresponding model if there is a prefix. Logs directly.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005250 *
Michal Vasko2104e9f2020-03-06 08:23:25 +01005251 * XPath @p set is expected to be a (sc)node set!
5252 *
Michal Vasko6346ece2019-09-24 13:12:53 +02005253 * @param[in,out] qname Qualified node name. If includes prefix, it is skipped.
5254 * @param[in,out] qname_len Length of @p qname, is updated accordingly.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005255 * @param[in] set Set with general XPath context.
5256 * @param[in] ctx_scnode Context node to inherit module for unprefixed node for ::LY_PREF_JSON.
Michal Vasko6346ece2019-09-24 13:12:53 +02005257 * @param[out] moveto_mod Expected module of a matching node.
5258 * @return LY_ERR
Michal Vasko03ff5a72019-09-11 13:49:33 +02005259 */
Michal Vasko6346ece2019-09-24 13:12:53 +02005260static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005261moveto_resolve_model(const char **qname, uint16_t *qname_len, const struct lyxp_set *set,
5262 const struct lysc_node *ctx_scnode, const struct lys_module **moveto_mod)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005263{
Michal Vaskoed4fcfe2020-07-08 10:38:56 +02005264 const struct lys_module *mod = NULL;
Michal Vasko6346ece2019-09-24 13:12:53 +02005265 const char *ptr;
Radek Krejci1deb5be2020-08-26 16:43:36 +02005266 size_t pref_len;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005267
Michal Vasko2104e9f2020-03-06 08:23:25 +01005268 assert((set->type == LYXP_SET_NODE_SET) || (set->type == LYXP_SET_SCNODE_SET));
5269
Michal Vasko6346ece2019-09-24 13:12:53 +02005270 if ((ptr = ly_strnchr(*qname, ':', *qname_len))) {
5271 /* specific module */
5272 pref_len = ptr - *qname;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005273 mod = ly_resolve_prefix(set->ctx, *qname, pref_len, set->format, set->prefix_data);
Michal Vasko6346ece2019-09-24 13:12:53 +02005274
Michal Vasko004d3152020-06-11 19:59:22 +02005275 /* check for errors and non-implemented modules, as they are not valid */
Juraj Vijtiukd75faa62019-11-26 14:10:10 +01005276 if (!mod || !mod->implemented) {
Michal Vasko2104e9f2020-03-06 08:23:25 +01005277 if (set->type == LYXP_SET_SCNODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005278 LOGVAL(set->ctx, LY_VLOG_LYSC, set->cur_scnode, LY_VCODE_XP_INMOD, pref_len, *qname);
Michal Vasko2104e9f2020-03-06 08:23:25 +01005279 } else {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005280 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INMOD, pref_len, *qname);
Michal Vasko2104e9f2020-03-06 08:23:25 +01005281 }
Michal Vasko6346ece2019-09-24 13:12:53 +02005282 return LY_EVALID;
5283 }
Juraj Vijtiukd75faa62019-11-26 14:10:10 +01005284
Michal Vasko6346ece2019-09-24 13:12:53 +02005285 *qname += pref_len + 1;
5286 *qname_len -= pref_len + 1;
5287 } else if (((*qname)[0] == '*') && (*qname_len == 1)) {
5288 /* all modules - special case */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005289 mod = NULL;
Michal Vasko6346ece2019-09-24 13:12:53 +02005290 } else {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005291 switch (set->format) {
5292 case LY_PREF_SCHEMA:
5293 case LY_PREF_SCHEMA_RESOLVED:
5294 /* current module */
5295 mod = set->cur_mod;
5296 break;
5297 case LY_PREF_JSON:
5298 /* inherit parent (context node) module */
5299 if (ctx_scnode) {
5300 mod = ctx_scnode->module;
5301 } else {
5302 mod = NULL;
5303 }
5304 break;
5305 case LY_PREF_XML:
5306 /* not defined */
5307 LOGINT_RET(set->ctx);
5308 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005309 }
5310
Michal Vasko6346ece2019-09-24 13:12:53 +02005311 *moveto_mod = mod;
5312 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005313}
5314
5315/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02005316 * @brief Move context @p set to the root. Handles absolute path.
5317 * Result is LYXP_SET_NODE_SET.
5318 *
5319 * @param[in,out] set Set to use.
5320 * @param[in] options Xpath options.
Michal Vaskob0099a92020-08-31 14:55:23 +02005321 * @return LY_ERR value.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005322 */
Michal Vaskob0099a92020-08-31 14:55:23 +02005323static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02005324moveto_root(struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005325{
Michal Vasko03ff5a72019-09-11 13:49:33 +02005326 if (!set) {
Michal Vaskob0099a92020-08-31 14:55:23 +02005327 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005328 }
5329
5330 if (options & LYXP_SCNODE_ALL) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005331 set_scnode_clear_ctx(set);
Michal Vaskob0099a92020-08-31 14:55:23 +02005332 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, NULL, set->root_type, NULL));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005333 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02005334 set->type = LYXP_SET_NODE_SET;
5335 set->used = 0;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005336 set_insert_node(set, NULL, 0, set->root_type, 0);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005337 }
Michal Vaskob0099a92020-08-31 14:55:23 +02005338
5339 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005340}
5341
5342/**
Michal Vaskoa1424542019-11-14 16:08:52 +01005343 * @brief Check whether a node has some unresolved "when".
5344 *
5345 * @param[in] node Node to check.
5346 * @return LY_ERR value (LY_EINCOMPLETE if there are some unresolved "when")
5347 */
5348static LY_ERR
5349moveto_when_check(const struct lyd_node *node)
5350{
5351 const struct lysc_node *schema;
5352
5353 if (!node) {
5354 return LY_SUCCESS;
5355 }
5356
5357 schema = node->schema;
5358 do {
5359 if (schema->when && !(node->flags & LYD_WHEN_TRUE)) {
5360 return LY_EINCOMPLETE;
5361 }
5362 schema = schema->parent;
5363 } while (schema && (schema->nodetype & (LYS_CASE | LYS_CHOICE)));
5364
5365 return LY_SUCCESS;
5366}
5367
5368/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02005369 * @brief Check @p node as a part of NameTest processing.
5370 *
5371 * @param[in] node Node to check.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005372 * @param[in] ctx_node Context node.
5373 * @param[in] set Set to read general context from.
Michal Vaskod3678892020-05-21 10:06:58 +02005374 * @param[in] node_name Node name in the dictionary to move to, NULL for any node.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005375 * @param[in] moveto_mod Expected module of the node, NULL for no prefix.
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,
Radek Krejci0f969882020-08-21 16:56:47 +02005381 const char *node_name, const struct lys_module *moveto_mod)
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 */
5422 if (moveto_when_check(node)) {
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 Vasko03ff5a72019-09-11 13:49:33 +02005491 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
5492 */
5493static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005494moveto_node(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005495{
Michal Vaskof03ed032020-03-04 13:31:44 +01005496 uint32_t i;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005497 const struct lyd_node *siblings, *sub, *ctx_node;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005498 LY_ERR rc;
5499
Michal Vaskod3678892020-05-21 10:06:58 +02005500 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005501 return LY_SUCCESS;
5502 }
5503
5504 if (set->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005505 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005506 return LY_EVALID;
5507 }
5508
Michal Vasko03ff5a72019-09-11 13:49:33 +02005509 for (i = 0; i < set->used; ) {
Radek Krejci857189e2020-09-01 13:26:36 +02005510 ly_bool replaced = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005511
5512 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 +01005513 assert(!set->val.nodes[i].node);
Michal Vaskod3678892020-05-21 10:06:58 +02005514
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005515 /* search in all the trees */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005516 ctx_node = NULL;
Michal Vaskod3678892020-05-21 10:06:58 +02005517 siblings = set->tree;
Michal Vasko5bfd4be2020-06-23 13:26:19 +02005518 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02005519 /* search in children */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005520 ctx_node = set->val.nodes[i].node;
5521 siblings = lyd_child(ctx_node);
Michal Vaskod3678892020-05-21 10:06:58 +02005522 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005523
Michal Vaskod3678892020-05-21 10:06:58 +02005524 for (sub = siblings; sub; sub = sub->next) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005525 rc = moveto_node_check(sub, ctx_node, set, ncname, moveto_mod);
Michal Vaskod3678892020-05-21 10:06:58 +02005526 if (rc == LY_SUCCESS) {
5527 if (!replaced) {
5528 set_replace_node(set, sub, 0, LYXP_NODE_ELEM, i);
5529 replaced = 1;
5530 } else {
5531 set_insert_node(set, sub, 0, LYXP_NODE_ELEM, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005532 }
Michal Vaskod3678892020-05-21 10:06:58 +02005533 ++i;
5534 } else if (rc == LY_EINCOMPLETE) {
5535 return rc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005536 }
5537 }
5538
5539 if (!replaced) {
5540 /* no match */
5541 set_remove_node(set, i);
5542 }
5543 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005544
5545 return LY_SUCCESS;
5546}
5547
5548/**
Michal Vaskod3678892020-05-21 10:06:58 +02005549 * @brief Move context @p set to a node using hashes. Result is LYXP_SET_NODE_SET (or LYXP_SET_EMPTY).
5550 * Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005551 *
5552 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02005553 * @param[in] scnode Matching node schema.
Michal Vasko004d3152020-06-11 19:59:22 +02005554 * @param[in] predicates If @p scnode is ::LYS_LIST or ::LYS_LEAFLIST, the predicates specifying a single instance.
Michal Vaskod3678892020-05-21 10:06:58 +02005555 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
5556 */
5557static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02005558moveto_node_hash(struct lyxp_set *set, const struct lysc_node *scnode, const struct ly_path_predicate *predicates)
Michal Vaskod3678892020-05-21 10:06:58 +02005559{
Michal Vasko004d3152020-06-11 19:59:22 +02005560 LY_ERR ret = LY_SUCCESS;
Michal Vaskod3678892020-05-21 10:06:58 +02005561 uint32_t i;
Michal Vaskod3678892020-05-21 10:06:58 +02005562 const struct lyd_node *siblings;
Michal Vasko004d3152020-06-11 19:59:22 +02005563 struct lyd_node *sub, *inst = NULL;
Michal Vaskod3678892020-05-21 10:06:58 +02005564
Michal Vasko004d3152020-06-11 19:59:22 +02005565 assert(scnode && (!(scnode->nodetype & (LYS_LIST | LYS_LEAFLIST)) || predicates));
Michal Vaskod3678892020-05-21 10:06:58 +02005566
5567 if (!set) {
Michal Vasko004d3152020-06-11 19:59:22 +02005568 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02005569 }
5570
5571 if (set->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005572 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko004d3152020-06-11 19:59:22 +02005573 ret = LY_EVALID;
5574 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02005575 }
5576
5577 /* context check for all the nodes since we have the schema node */
5578 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (scnode->flags & LYS_CONFIG_R)) {
5579 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02005580 goto cleanup;
Michal Vasko69730152020-10-09 16:30:07 +02005581 } else if (set->context_op && (scnode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) &&
5582 (scnode != set->context_op)) {
Michal Vasko6b26e742020-07-17 15:02:10 +02005583 lyxp_set_free_content(set);
5584 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +02005585 }
5586
5587 /* create specific data instance if needed */
5588 if (scnode->nodetype == LYS_LIST) {
5589 LY_CHECK_GOTO(ret = lyd_create_list(scnode, predicates, &inst), cleanup);
5590 } else if (scnode->nodetype == LYS_LEAFLIST) {
5591 LY_CHECK_GOTO(ret = lyd_create_term2(scnode, &predicates[0].value, &inst), cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02005592 }
5593
5594 for (i = 0; i < set->used; ) {
Michal Vaskod3678892020-05-21 10:06:58 +02005595 siblings = NULL;
5596
5597 if ((set->val.nodes[i].type == LYXP_NODE_ROOT_CONFIG) || (set->val.nodes[i].type == LYXP_NODE_ROOT)) {
5598 assert(!set->val.nodes[i].node);
5599
5600 /* search in all the trees */
5601 siblings = set->tree;
5602 } else if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
5603 /* search in children */
Radek Krejcia1c1e542020-09-29 16:06:52 +02005604 siblings = lyd_child(set->val.nodes[i].node);
Michal Vaskod3678892020-05-21 10:06:58 +02005605 }
5606
5607 /* find the node using hashes */
Michal Vasko004d3152020-06-11 19:59:22 +02005608 if (inst) {
5609 lyd_find_sibling_first(siblings, inst, &sub);
Michal Vaskod3678892020-05-21 10:06:58 +02005610 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02005611 lyd_find_sibling_val(siblings, scnode, NULL, 0, &sub);
Michal Vaskod3678892020-05-21 10:06:58 +02005612 }
5613
5614 /* when check */
5615 if (sub && moveto_when_check(sub)) {
Michal Vasko004d3152020-06-11 19:59:22 +02005616 ret = LY_EINCOMPLETE;
5617 goto cleanup;
Michal Vaskod3678892020-05-21 10:06:58 +02005618 }
5619
5620 if (sub) {
5621 /* pos filled later */
Michal Vaskocb1b7c02020-07-03 13:38:12 +02005622 set_replace_node(set, sub, 0, LYXP_NODE_ELEM, i);
Michal Vaskod3678892020-05-21 10:06:58 +02005623 ++i;
Michal Vaskocb1b7c02020-07-03 13:38:12 +02005624 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02005625 /* no match */
5626 set_remove_node(set, i);
5627 }
5628 }
5629
Michal Vasko004d3152020-06-11 19:59:22 +02005630cleanup:
5631 lyd_free_tree(inst);
5632 return ret;
Michal Vaskod3678892020-05-21 10:06:58 +02005633}
5634
5635/**
5636 * @brief Move context @p set to a schema node. Result is LYXP_SET_SCNODE_SET (or LYXP_SET_EMPTY).
5637 *
5638 * @param[in,out] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005639 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02005640 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005641 * @param[in] options XPath options.
5642 * @return LY_ERR
5643 */
5644static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005645moveto_scnode(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005646{
Radek Krejci857189e2020-09-01 13:26:36 +02005647 ly_bool temp_ctx = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02005648 uint32_t getnext_opts;
5649 uint32_t orig_used, i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005650 uint32_t mod_idx;
Michal Vasko519fd602020-05-26 12:17:39 +02005651 const struct lysc_node *iter, *start_parent;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005652 const struct lys_module *mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005653
Michal Vaskod3678892020-05-21 10:06:58 +02005654 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005655 return LY_SUCCESS;
5656 }
5657
5658 if (set->type != LYXP_SET_SCNODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005659 LOGVAL(set->ctx, LY_VLOG_LYSC, set->cur_scnode, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005660 return LY_EVALID;
5661 }
5662
Michal Vaskocafad9d2019-11-07 15:20:03 +01005663 /* getnext opts */
5664 getnext_opts = LYS_GETNEXT_NOSTATECHECK;
5665 if (options & LYXP_SCNODE_OUTPUT) {
5666 getnext_opts |= LYS_GETNEXT_OUTPUT;
5667 }
5668
Michal Vasko03ff5a72019-09-11 13:49:33 +02005669 orig_used = set->used;
5670 for (i = 0; i < orig_used; ++i) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005671 uint32_t idx;
5672
Michal Vasko03ff5a72019-09-11 13:49:33 +02005673 if (set->val.scnodes[i].in_ctx != 1) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01005674 if (set->val.scnodes[i].in_ctx != -2) {
5675 continue;
5676 }
5677
5678 /* remember context node */
5679 set->val.scnodes[i].in_ctx = -1;
Michal Vaskoec4df482019-12-16 10:02:18 +01005680 } else {
5681 set->val.scnodes[i].in_ctx = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005682 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005683
5684 start_parent = set->val.scnodes[i].scnode;
5685
5686 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 +02005687 /* 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 +02005688 * it can be in a top-level augment (the root node itself is useless in this case) */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005689 mod_idx = 0;
Michal Vasko9e9f26d2020-10-12 16:31:33 +02005690 while ((mod = (struct lys_module *)ly_ctx_get_module_iter(set->ctx, &mod_idx))) {
Michal Vasko519fd602020-05-26 12:17:39 +02005691 iter = NULL;
Michal Vasko509de4d2019-12-10 14:51:30 +01005692 /* module may not be implemented */
Michal Vasko519fd602020-05-26 12:17:39 +02005693 while (mod->implemented && (iter = lys_getnext(iter, NULL, mod->compiled, getnext_opts))) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005694 if (!moveto_scnode_check(iter, NULL, set, ncname, moveto_mod)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005695 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, iter, LYXP_NODE_ELEM, &idx));
5696
Michal Vasko03ff5a72019-09-11 13:49:33 +02005697 /* we need to prevent these nodes from being considered in this moveto */
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005698 if ((idx < orig_used) && (idx > i)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005699 set->val.scnodes[idx].in_ctx = 2;
5700 temp_ctx = 1;
5701 }
5702 }
5703 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005704 }
5705
Michal Vasko519fd602020-05-26 12:17:39 +02005706 } else if (set->val.scnodes[i].type == LYXP_NODE_ELEM) {
5707 iter = NULL;
5708 while ((iter = lys_getnext(iter, start_parent, NULL, getnext_opts))) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005709 if (!moveto_scnode_check(iter, start_parent, set, ncname, moveto_mod)) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005710 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, iter, LYXP_NODE_ELEM, &idx));
5711
5712 if ((idx < orig_used) && (idx > i)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005713 set->val.scnodes[idx].in_ctx = 2;
5714 temp_ctx = 1;
5715 }
5716 }
5717 }
5718 }
5719 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005720
5721 /* correct temporary in_ctx values */
5722 if (temp_ctx) {
5723 for (i = 0; i < orig_used; ++i) {
5724 if (set->val.scnodes[i].in_ctx == 2) {
5725 set->val.scnodes[i].in_ctx = 1;
5726 }
5727 }
5728 }
5729
5730 return LY_SUCCESS;
5731}
5732
5733/**
Michal Vaskod3678892020-05-21 10:06:58 +02005734 * @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 +02005735 * Context position aware.
5736 *
5737 * @param[in] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005738 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02005739 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005740 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
5741 */
5742static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005743moveto_node_alldesc(struct lyxp_set *set, const struct lys_module *moveto_mod, const char *ncname)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005744{
5745 uint32_t i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005746 const struct lyd_node *next, *elem, *start;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005747 struct lyxp_set ret_set;
5748 LY_ERR rc;
5749
Michal Vaskod3678892020-05-21 10:06:58 +02005750 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005751 return LY_SUCCESS;
5752 }
5753
5754 if (set->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005755 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005756 return LY_EVALID;
5757 }
5758
Michal Vasko9f96a052020-03-10 09:41:45 +01005759 /* replace the original nodes (and throws away all text and meta nodes, root is replaced by a child) */
Michal Vaskod3678892020-05-21 10:06:58 +02005760 rc = moveto_node(set, NULL, NULL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005761 LY_CHECK_RET(rc);
5762
Michal Vasko6346ece2019-09-24 13:12:53 +02005763 /* this loop traverses all the nodes in the set and adds/keeps only those that match qname */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005764 set_init(&ret_set, set);
5765 for (i = 0; i < set->used; ++i) {
5766
5767 /* TREE DFS */
5768 start = set->val.nodes[i].node;
5769 for (elem = next = start; elem; elem = next) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005770 rc = moveto_node_check(elem, start, set, ncname, moveto_mod);
Michal Vasko6346ece2019-09-24 13:12:53 +02005771 if (!rc) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005772 /* add matching node into result set */
5773 set_insert_node(&ret_set, elem, 0, LYXP_NODE_ELEM, ret_set.used);
5774 if (set_dup_node_check(set, elem, LYXP_NODE_ELEM, i)) {
5775 /* the node is a duplicate, we'll process it later in the set */
5776 goto skip_children;
5777 }
Michal Vasko6346ece2019-09-24 13:12:53 +02005778 } else if (rc == LY_EINCOMPLETE) {
Michal Vasko6346ece2019-09-24 13:12:53 +02005779 return rc;
5780 } else if (rc == LY_EINVAL) {
5781 goto skip_children;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005782 }
5783
5784 /* TREE DFS NEXT ELEM */
5785 /* select element for the next run - children first */
Radek Krejcia1c1e542020-09-29 16:06:52 +02005786 next = lyd_child(elem);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005787 if (!next) {
5788skip_children:
5789 /* no children, so try siblings, but only if it's not the start,
5790 * that is considered to be the root and it's siblings are not traversed */
5791 if (elem != start) {
5792 next = elem->next;
5793 } else {
5794 break;
5795 }
5796 }
5797 while (!next) {
5798 /* no siblings, go back through the parents */
5799 if ((struct lyd_node *)elem->parent == start) {
5800 /* we are done, no next element to process */
5801 break;
5802 }
5803 /* parent is already processed, go to its sibling */
5804 elem = (struct lyd_node *)elem->parent;
5805 next = elem->next;
5806 }
5807 }
5808 }
5809
5810 /* make the temporary set the current one */
5811 ret_set.ctx_pos = set->ctx_pos;
5812 ret_set.ctx_size = set->ctx_size;
Michal Vaskod3678892020-05-21 10:06:58 +02005813 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005814 memcpy(set, &ret_set, sizeof *set);
5815
5816 return LY_SUCCESS;
5817}
5818
5819/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02005820 * @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 +02005821 *
5822 * @param[in] set Set to use.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005823 * @param[in] moveto_mod Matching node module, NULL for no prefix.
Michal Vaskod3678892020-05-21 10:06:58 +02005824 * @param[in] ncname Matching node name in the dictionary, NULL for any.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005825 * @param[in] options XPath options.
5826 * @return LY_ERR
5827 */
5828static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005829moveto_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 +02005830{
Radek Krejci1deb5be2020-08-26 16:43:36 +02005831 uint32_t i, orig_used;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005832 const struct lysc_node *next, *elem, *start;
Michal Vasko6346ece2019-09-24 13:12:53 +02005833 LY_ERR rc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005834
Michal Vaskod3678892020-05-21 10:06:58 +02005835 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005836 return LY_SUCCESS;
5837 }
5838
5839 if (set->type != LYXP_SET_SCNODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005840 LOGVAL(set->ctx, LY_VLOG_LYSC, set->cur_scnode, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005841 return LY_EVALID;
5842 }
5843
Michal Vasko03ff5a72019-09-11 13:49:33 +02005844 orig_used = set->used;
5845 for (i = 0; i < orig_used; ++i) {
5846 if (set->val.scnodes[i].in_ctx != 1) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01005847 if (set->val.scnodes[i].in_ctx != -2) {
5848 continue;
5849 }
5850
5851 /* remember context node */
5852 set->val.scnodes[i].in_ctx = -1;
Michal Vaskoec4df482019-12-16 10:02:18 +01005853 } else {
5854 set->val.scnodes[i].in_ctx = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005855 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02005856
5857 /* TREE DFS */
5858 start = set->val.scnodes[i].scnode;
5859 for (elem = next = start; elem; elem = next) {
Michal Vasko6346ece2019-09-24 13:12:53 +02005860 if ((elem == start) || (elem->nodetype & (LYS_CHOICE | LYS_CASE))) {
5861 /* schema-only nodes, skip root */
Michal Vasko03ff5a72019-09-11 13:49:33 +02005862 goto next_iter;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005863 }
5864
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005865 rc = moveto_scnode_check(elem, start, set, ncname, moveto_mod);
Michal Vasko6346ece2019-09-24 13:12:53 +02005866 if (!rc) {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005867 uint32_t idx;
5868
5869 if (lyxp_set_scnode_contains(set, elem, LYXP_NODE_ELEM, i, &idx)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005870 set->val.scnodes[idx].in_ctx = 1;
Radek Krejci1deb5be2020-08-26 16:43:36 +02005871 if ((uint32_t)idx > i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005872 /* we will process it later in the set */
5873 goto skip_children;
5874 }
5875 } else {
Radek Krejciaa6b53f2020-08-27 15:19:03 +02005876 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, elem, LYXP_NODE_ELEM, NULL));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005877 }
Michal Vasko6346ece2019-09-24 13:12:53 +02005878 } else if (rc == LY_EINVAL) {
5879 goto skip_children;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005880 }
5881
5882next_iter:
5883 /* TREE DFS NEXT ELEM */
5884 /* select element for the next run - children first */
5885 next = lysc_node_children(elem, options & LYXP_SCNODE_OUTPUT ? LYS_CONFIG_R : LYS_CONFIG_W);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005886 if (!next) {
5887skip_children:
5888 /* no children, so try siblings, but only if it's not the start,
5889 * that is considered to be the root and it's siblings are not traversed */
5890 if (elem != start) {
5891 next = elem->next;
5892 } else {
5893 break;
5894 }
5895 }
5896 while (!next) {
5897 /* no siblings, go back through the parents */
5898 if (elem->parent == start) {
5899 /* we are done, no next element to process */
5900 break;
5901 }
5902 /* parent is already processed, go to its sibling */
5903 elem = elem->parent;
5904 next = elem->next;
5905 }
5906 }
5907 }
5908
5909 return LY_SUCCESS;
5910}
5911
5912/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02005913 * @brief Move context @p set to an attribute. Result is LYXP_SET_NODE_SET.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005914 * Indirectly context position aware.
5915 *
5916 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02005917 * @param[in] mod Matching metadata module, NULL for any.
5918 * @param[in] ncname Matching metadata name in the dictionary, NULL for any.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005919 * @return LY_ERR
5920 */
5921static LY_ERR
Michal Vaskod3678892020-05-21 10:06:58 +02005922moveto_attr(struct lyxp_set *set, const struct lys_module *mod, const char *ncname)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005923{
Michal Vasko9f96a052020-03-10 09:41:45 +01005924 struct lyd_meta *sub;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005925
Michal Vaskod3678892020-05-21 10:06:58 +02005926 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005927 return LY_SUCCESS;
5928 }
5929
5930 if (set->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005931 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005932 return LY_EVALID;
5933 }
5934
Radek Krejci1deb5be2020-08-26 16:43:36 +02005935 for (uint32_t i = 0; i < set->used; ) {
Radek Krejci857189e2020-09-01 13:26:36 +02005936 ly_bool replaced = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005937
5938 /* only attributes of an elem (not dummy) can be in the result, skip all the rest;
5939 * our attributes are always qualified */
Michal Vasko5c4e5892019-11-14 12:31:38 +01005940 if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko9f96a052020-03-10 09:41:45 +01005941 for (sub = set->val.nodes[i].node->meta; sub; sub = sub->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005942
5943 /* check "namespace" */
Michal Vaskod3678892020-05-21 10:06:58 +02005944 if (mod && (sub->annotation->module != mod)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005945 continue;
5946 }
5947
Michal Vaskod3678892020-05-21 10:06:58 +02005948 if (!ncname || (sub->name == ncname)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005949 /* match */
5950 if (!replaced) {
Michal Vasko9f96a052020-03-10 09:41:45 +01005951 set->val.meta[i].meta = sub;
5952 set->val.meta[i].type = LYXP_NODE_META;
Michal Vasko03ff5a72019-09-11 13:49:33 +02005953 /* pos does not change */
5954 replaced = 1;
5955 } else {
Michal Vasko9f96a052020-03-10 09:41:45 +01005956 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 +02005957 }
5958 ++i;
5959 }
5960 }
5961 }
5962
5963 if (!replaced) {
5964 /* no match */
5965 set_remove_node(set, i);
5966 }
5967 }
5968
5969 return LY_SUCCESS;
5970}
5971
5972/**
5973 * @brief Move context @p set1 to union with @p set2. @p set2 is emptied afterwards.
Michal Vasko61ac2f62020-05-25 12:39:51 +02005974 * Result is LYXP_SET_NODE_SET. Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005975 *
5976 * @param[in,out] set1 Set to use for the result.
5977 * @param[in] set2 Set that is copied to @p set1.
Michal Vasko03ff5a72019-09-11 13:49:33 +02005978 * @return LY_ERR
5979 */
5980static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01005981moveto_union(struct lyxp_set *set1, struct lyxp_set *set2)
Michal Vasko03ff5a72019-09-11 13:49:33 +02005982{
5983 LY_ERR rc;
5984
Michal Vaskod3678892020-05-21 10:06:58 +02005985 if ((set1->type != LYXP_SET_NODE_SET) || (set2->type != LYXP_SET_NODE_SET)) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02005986 LOGVAL(set1->ctx, LY_VLOG_LYD, set1->cur_node, LY_VCODE_XP_INOP_2, "union", print_set_type(set1), print_set_type(set2));
Michal Vasko03ff5a72019-09-11 13:49:33 +02005987 return LY_EVALID;
5988 }
5989
5990 /* set2 is empty or both set1 and set2 */
Michal Vaskod3678892020-05-21 10:06:58 +02005991 if (!set2->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005992 return LY_SUCCESS;
5993 }
5994
Michal Vaskod3678892020-05-21 10:06:58 +02005995 if (!set1->used) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02005996 memcpy(set1, set2, sizeof *set1);
5997 /* dynamic memory belongs to set1 now, do not free */
Michal Vaskod3678892020-05-21 10:06:58 +02005998 memset(set2, 0, sizeof *set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02005999 return LY_SUCCESS;
6000 }
6001
6002 /* we assume sets are sorted */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006003 assert(!set_sort(set1) && !set_sort(set2));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006004
6005 /* sort, remove duplicates */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006006 rc = set_sorted_merge(set1, set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006007 LY_CHECK_RET(rc);
6008
6009 /* final set must be sorted */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006010 assert(!set_sort(set1));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006011
6012 return LY_SUCCESS;
6013}
6014
6015/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02006016 * @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 +02006017 * Context position aware.
6018 *
6019 * @param[in,out] set Set to use.
Michal Vaskod3678892020-05-21 10:06:58 +02006020 * @param[in] mod Matching metadata module, NULL for any.
6021 * @param[in] ncname Matching metadata name in the dictionary, NULL for any.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006022 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6023 */
6024static int
Michal Vaskod3678892020-05-21 10:06:58 +02006025moveto_attr_alldesc(struct lyxp_set *set, const struct lys_module *mod, const char *ncname)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006026{
Michal Vasko9f96a052020-03-10 09:41:45 +01006027 struct lyd_meta *sub;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006028 struct lyxp_set *set_all_desc = NULL;
6029 LY_ERR rc;
6030
Michal Vaskod3678892020-05-21 10:06:58 +02006031 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006032 return LY_SUCCESS;
6033 }
6034
6035 if (set->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006036 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006037 return LY_EVALID;
6038 }
6039
Michal Vasko03ff5a72019-09-11 13:49:33 +02006040 /* can be optimized similarly to moveto_node_alldesc() and save considerable amount of memory,
6041 * but it likely won't be used much, so it's a waste of time */
6042 /* copy the context */
6043 set_all_desc = set_copy(set);
6044 /* get all descendant nodes (the original context nodes are removed) */
Michal Vaskod3678892020-05-21 10:06:58 +02006045 rc = moveto_node_alldesc(set_all_desc, NULL, NULL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006046 if (rc != LY_SUCCESS) {
6047 lyxp_set_free(set_all_desc);
6048 return rc;
6049 }
6050 /* prepend the original context nodes */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006051 rc = moveto_union(set, set_all_desc);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006052 if (rc != LY_SUCCESS) {
6053 lyxp_set_free(set_all_desc);
6054 return rc;
6055 }
6056 lyxp_set_free(set_all_desc);
6057
Radek Krejci1deb5be2020-08-26 16:43:36 +02006058 for (uint32_t i = 0; i < set->used; ) {
Radek Krejci857189e2020-09-01 13:26:36 +02006059 ly_bool replaced = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006060
6061 /* only attributes of an elem can be in the result, skip all the rest,
6062 * we have all attributes qualified in lyd tree */
6063 if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko9f96a052020-03-10 09:41:45 +01006064 for (sub = set->val.nodes[i].node->meta; sub; sub = sub->next) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006065 /* check "namespace" */
Michal Vaskod3678892020-05-21 10:06:58 +02006066 if (mod && (sub->annotation->module != mod)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006067 continue;
6068 }
6069
Michal Vaskod3678892020-05-21 10:06:58 +02006070 if (!ncname || (sub->name == ncname)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006071 /* match */
6072 if (!replaced) {
Michal Vasko9f96a052020-03-10 09:41:45 +01006073 set->val.meta[i].meta = sub;
6074 set->val.meta[i].type = LYXP_NODE_META;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006075 /* pos does not change */
6076 replaced = 1;
6077 } else {
Michal Vasko9f96a052020-03-10 09:41:45 +01006078 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 +02006079 }
6080 ++i;
6081 }
6082 }
6083 }
6084
6085 if (!replaced) {
6086 /* no match */
6087 set_remove_node(set, i);
6088 }
6089 }
6090
6091 return LY_SUCCESS;
6092}
6093
6094/**
Michal Vasko61ac2f62020-05-25 12:39:51 +02006095 * @brief Move context @p set to self and al chilren, recursively. Handles '/' or '//' and '.'. Result is LYXP_SET_NODE_SET.
6096 * Context position aware.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006097 *
6098 * @param[in] parent Current parent.
6099 * @param[in] parent_pos Position of @p parent.
6100 * @param[in] parent_type Node type of @p parent.
6101 * @param[in,out] to_set Set to use.
6102 * @param[in] dup_check_set Set for checking duplicities.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006103 * @param[in] options XPath options.
6104 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6105 */
6106static LY_ERR
6107moveto_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 +02006108 struct lyxp_set *to_set, const struct lyxp_set *dup_check_set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006109{
Michal Vasko61ac2f62020-05-25 12:39:51 +02006110 const struct lyd_node *iter, *first;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006111 LY_ERR rc;
6112
6113 switch (parent_type) {
6114 case LYXP_NODE_ROOT:
6115 case LYXP_NODE_ROOT_CONFIG:
Michal Vasko61ac2f62020-05-25 12:39:51 +02006116 assert(!parent);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006117
Michal Vasko61ac2f62020-05-25 12:39:51 +02006118 /* add all top-level nodes as elements */
6119 first = to_set->tree;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006120 break;
6121 case LYXP_NODE_ELEM:
Michal Vasko61ac2f62020-05-25 12:39:51 +02006122 /* add just the text node of this term element node */
6123 if (parent->schema->nodetype & (LYD_NODE_TERM | LYD_NODE_ANY)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006124 if (!set_dup_node_check(dup_check_set, parent, LYXP_NODE_TEXT, -1)) {
6125 set_insert_node(to_set, parent, parent_pos, LYXP_NODE_TEXT, to_set->used);
6126 }
Michal Vasko61ac2f62020-05-25 12:39:51 +02006127 return LY_SUCCESS;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006128 }
Michal Vasko61ac2f62020-05-25 12:39:51 +02006129
6130 /* add all the children of this node */
Radek Krejcia1c1e542020-09-29 16:06:52 +02006131 first = lyd_child(parent);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006132 break;
6133 default:
6134 LOGINT_RET(parent->schema->module->ctx);
6135 }
6136
Michal Vasko61ac2f62020-05-25 12:39:51 +02006137 /* add all top-level nodes as elements */
6138 LY_LIST_FOR(first, iter) {
6139 /* context check */
6140 if ((parent_type == LYXP_NODE_ROOT_CONFIG) && (iter->schema->flags & LYS_CONFIG_R)) {
6141 continue;
6142 }
6143
6144 /* when check */
6145 if (moveto_when_check(iter)) {
6146 return LY_EINCOMPLETE;
6147 }
6148
6149 if (!set_dup_node_check(dup_check_set, iter, LYXP_NODE_ELEM, -1)) {
6150 set_insert_node(to_set, iter, 0, LYXP_NODE_ELEM, to_set->used);
6151
6152 /* also add all the children of this node, recursively */
6153 rc = moveto_self_add_children_r(iter, 0, LYXP_NODE_ELEM, to_set, dup_check_set, options);
6154 LY_CHECK_RET(rc);
6155 }
6156 }
6157
Michal Vasko03ff5a72019-09-11 13:49:33 +02006158 return LY_SUCCESS;
6159}
6160
6161/**
6162 * @brief Move context @p set to self. Handles '/' or '//' and '.'. Result is LYXP_SET_NODE_SET
6163 * (or LYXP_SET_EMPTY). Context position aware.
6164 *
6165 * @param[in,out] set Set to use.
6166 * @param[in] all_desc Whether to go to all descendants ('//') or not ('/').
6167 * @param[in] options XPath options.
6168 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6169 */
6170static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02006171moveto_self(struct lyxp_set *set, ly_bool all_desc, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006172{
Michal Vasko03ff5a72019-09-11 13:49:33 +02006173 struct lyxp_set ret_set;
6174 LY_ERR rc;
6175
Michal Vaskod3678892020-05-21 10:06:58 +02006176 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006177 return LY_SUCCESS;
6178 }
6179
6180 if (set->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006181 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006182 return LY_EVALID;
6183 }
6184
6185 /* nothing to do */
6186 if (!all_desc) {
6187 return LY_SUCCESS;
6188 }
6189
Michal Vasko03ff5a72019-09-11 13:49:33 +02006190 /* add all the children, they get added recursively */
6191 set_init(&ret_set, set);
Radek Krejci1deb5be2020-08-26 16:43:36 +02006192 for (uint32_t i = 0; i < set->used; ++i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006193 /* copy the current node to tmp */
6194 set_insert_node(&ret_set, set->val.nodes[i].node, set->val.nodes[i].pos, set->val.nodes[i].type, ret_set.used);
6195
6196 /* do not touch attributes and text nodes */
Michal Vasko9f96a052020-03-10 09:41:45 +01006197 if ((set->val.nodes[i].type == LYXP_NODE_TEXT) || (set->val.nodes[i].type == LYXP_NODE_META)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006198 continue;
6199 }
6200
Michal Vasko03ff5a72019-09-11 13:49:33 +02006201 /* add all the children */
6202 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 +02006203 set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006204 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02006205 lyxp_set_free_content(&ret_set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006206 return rc;
6207 }
6208 }
6209
6210 /* use the temporary set as the current one */
6211 ret_set.ctx_pos = set->ctx_pos;
6212 ret_set.ctx_size = set->ctx_size;
Michal Vaskod3678892020-05-21 10:06:58 +02006213 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006214 memcpy(set, &ret_set, sizeof *set);
6215
6216 return LY_SUCCESS;
6217}
6218
6219/**
6220 * @brief Move context schema @p set to self. Handles '/' or '//' and '.'. Result is LYXP_SET_SCNODE_SET
6221 * (or LYXP_SET_EMPTY).
6222 *
6223 * @param[in,out] set Set to use.
6224 * @param[in] all_desc Whether to go to all descendants ('//') or not ('/').
6225 * @param[in] options XPath options.
6226 * @return LY_ERR
6227 */
6228static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02006229moveto_scnode_self(struct lyxp_set *set, ly_bool all_desc, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006230{
Radek Krejci1deb5be2020-08-26 16:43:36 +02006231 uint32_t getnext_opts;
6232 uint32_t mod_idx;
Michal Vasko519fd602020-05-26 12:17:39 +02006233 const struct lysc_node *iter, *start_parent;
6234 const struct lys_module *mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006235
Michal Vaskod3678892020-05-21 10:06:58 +02006236 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006237 return LY_SUCCESS;
6238 }
6239
6240 if (set->type != LYXP_SET_SCNODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006241 LOGVAL(set->ctx, LY_VLOG_LYSC, set->cur_scnode, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006242 return LY_EVALID;
6243 }
6244
6245 /* nothing to do */
6246 if (!all_desc) {
6247 return LY_SUCCESS;
6248 }
6249
Michal Vasko519fd602020-05-26 12:17:39 +02006250 /* getnext opts */
6251 getnext_opts = LYS_GETNEXT_NOSTATECHECK;
6252 if (options & LYXP_SCNODE_OUTPUT) {
6253 getnext_opts |= LYS_GETNEXT_OUTPUT;
6254 }
6255
6256 /* add all the children, recursively as they are being added into the same set */
Radek Krejci1deb5be2020-08-26 16:43:36 +02006257 for (uint32_t i = 0; i < set->used; ++i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006258 if (set->val.scnodes[i].in_ctx != 1) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01006259 if (set->val.scnodes[i].in_ctx != -2) {
6260 continue;
6261 }
6262
Michal Vasko519fd602020-05-26 12:17:39 +02006263 /* remember context node */
6264 set->val.scnodes[i].in_ctx = -1;
6265 } else {
6266 set->val.scnodes[i].in_ctx = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006267 }
6268
Michal Vasko519fd602020-05-26 12:17:39 +02006269 start_parent = set->val.scnodes[i].scnode;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006270
Michal Vasko519fd602020-05-26 12:17:39 +02006271 if ((set->val.scnodes[i].type == LYXP_NODE_ROOT_CONFIG) || (set->val.scnodes[i].type == LYXP_NODE_ROOT)) {
6272 /* it can actually be in any module, it's all <running> */
6273 mod_idx = 0;
6274 while ((mod = (struct lys_module *)ly_ctx_get_module_iter(set->ctx, &mod_idx))) {
6275 iter = NULL;
6276 /* module may not be implemented */
6277 while (mod->implemented && (iter = lys_getnext(iter, NULL, mod->compiled, getnext_opts))) {
6278 /* context check */
6279 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (iter->flags & LYS_CONFIG_R)) {
6280 continue;
6281 }
6282
Radek Krejciaa6b53f2020-08-27 15:19:03 +02006283 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, iter, LYXP_NODE_ELEM, NULL));
Michal Vasko519fd602020-05-26 12:17:39 +02006284 /* throw away the insert index, we want to consider that node again, recursively */
6285 }
6286 }
6287
6288 } else if (set->val.scnodes[i].type == LYXP_NODE_ELEM) {
6289 iter = NULL;
6290 while ((iter = lys_getnext(iter, start_parent, NULL, getnext_opts))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006291 /* context check */
Michal Vasko519fd602020-05-26 12:17:39 +02006292 if ((set->root_type == LYXP_NODE_ROOT_CONFIG) && (iter->flags & LYS_CONFIG_R)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006293 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 Vasko03ff5a72019-09-11 13:49:33 +02006297 }
6298 }
6299 }
6300
6301 return LY_SUCCESS;
6302}
6303
6304/**
6305 * @brief Move context @p set to parent. Handles '/' or '//' and '..'. Result is LYXP_SET_NODE_SET
6306 * (or LYXP_SET_EMPTY). Context position aware.
6307 *
6308 * @param[in] set Set to use.
6309 * @param[in] all_desc Whether to go to all descendants ('//') or not ('/').
6310 * @param[in] options XPath options.
6311 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6312 */
6313static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02006314moveto_parent(struct lyxp_set *set, ly_bool all_desc, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006315{
6316 LY_ERR rc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006317 struct lyd_node *node, *new_node;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006318 enum lyxp_node_type new_type;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006319
Michal Vaskod3678892020-05-21 10:06:58 +02006320 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006321 return LY_SUCCESS;
6322 }
6323
6324 if (set->type != LYXP_SET_NODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006325 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006326 return LY_EVALID;
6327 }
6328
6329 if (all_desc) {
6330 /* <path>//.. == <path>//./.. */
6331 rc = moveto_self(set, 1, options);
6332 LY_CHECK_RET(rc);
6333 }
6334
Radek Krejci1deb5be2020-08-26 16:43:36 +02006335 for (uint32_t i = 0; i < set->used; ++i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006336 node = set->val.nodes[i].node;
6337
6338 if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
6339 new_node = (struct lyd_node *)node->parent;
6340 } else if (set->val.nodes[i].type == LYXP_NODE_TEXT) {
6341 new_node = node;
Michal Vasko9f96a052020-03-10 09:41:45 +01006342 } else if (set->val.nodes[i].type == LYXP_NODE_META) {
6343 new_node = set->val.meta[i].meta->parent;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006344 if (!new_node) {
6345 LOGINT_RET(set->ctx);
6346 }
6347 } else {
6348 /* root does not have a parent */
Michal Vasko2caefc12019-11-14 16:07:56 +01006349 set_remove_node_none(set, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006350 continue;
6351 }
6352
Michal Vaskoa1424542019-11-14 16:08:52 +01006353 /* when check */
6354 if (moveto_when_check(new_node)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006355 return LY_EINCOMPLETE;
Michal Vaskoa1424542019-11-14 16:08:52 +01006356 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006357
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006358 if (!new_node) {
Radek Krejcif6a11002020-08-21 13:29:07 +02006359 /* node already there can also be the root */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006360 new_type = set->root_type;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006361
Michal Vasko03ff5a72019-09-11 13:49:33 +02006362 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02006363 /* 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 +02006364 new_type = LYXP_NODE_ELEM;
6365 }
6366
Michal Vasko03ff5a72019-09-11 13:49:33 +02006367 if (set_dup_node_check(set, new_node, new_type, -1)) {
Michal Vasko2caefc12019-11-14 16:07:56 +01006368 set_remove_node_none(set, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006369 } else {
6370 set_replace_node(set, new_node, 0, new_type, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006371 }
6372 }
6373
Michal Vasko2caefc12019-11-14 16:07:56 +01006374 set_remove_nodes_none(set);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006375 assert(!set_sort(set) && !set_sorted_dup_node_clean(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006376
6377 return LY_SUCCESS;
6378}
6379
6380/**
6381 * @brief Move context schema @p set to parent. Handles '/' or '//' and '..'. Result is LYXP_SET_SCNODE_SET
6382 * (or LYXP_SET_EMPTY).
6383 *
6384 * @param[in] set Set to use.
6385 * @param[in] all_desc Whether to go to all descendants ('//') or not ('/').
6386 * @param[in] options XPath options.
6387 * @return LY_ERR
6388 */
6389static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02006390moveto_scnode_parent(struct lyxp_set *set, ly_bool all_desc, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006391{
Radek Krejciaa6b53f2020-08-27 15:19:03 +02006392 uint32_t i, orig_used, idx;
Radek Krejci857189e2020-09-01 13:26:36 +02006393 ly_bool temp_ctx = 0;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006394 const struct lysc_node *node, *new_node;
6395 enum lyxp_node_type new_type;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006396
Michal Vaskod3678892020-05-21 10:06:58 +02006397 if (!set) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006398 return LY_SUCCESS;
6399 }
6400
6401 if (set->type != LYXP_SET_SCNODE_SET) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006402 LOGVAL(set->ctx, LY_VLOG_LYSC, set->cur_scnode, LY_VCODE_XP_INOP_1, "path operator", print_set_type(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006403 return LY_EVALID;
6404 }
6405
6406 if (all_desc) {
6407 /* <path>//.. == <path>//./.. */
Radek Krejci1deb5be2020-08-26 16:43:36 +02006408 LY_CHECK_RET(moveto_scnode_self(set, 1, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006409 }
6410
Michal Vasko03ff5a72019-09-11 13:49:33 +02006411 orig_used = set->used;
6412 for (i = 0; i < orig_used; ++i) {
6413 if (set->val.scnodes[i].in_ctx != 1) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01006414 if (set->val.scnodes[i].in_ctx != -2) {
6415 continue;
6416 }
6417
6418 /* remember context node */
6419 set->val.scnodes[i].in_ctx = -1;
Michal Vaskoec4df482019-12-16 10:02:18 +01006420 } else {
6421 set->val.scnodes[i].in_ctx = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006422 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02006423
6424 node = set->val.scnodes[i].scnode;
6425
6426 if (set->val.scnodes[i].type == LYXP_NODE_ELEM) {
Michal Vaskod3678892020-05-21 10:06:58 +02006427 new_node = lysc_data_parent(node);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006428 } else {
6429 /* root does not have a parent */
6430 continue;
6431 }
6432
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006433 if (!new_node) {
Radek Krejcif6a11002020-08-21 13:29:07 +02006434 /* node has no parent */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006435 new_type = set->root_type;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006436
Michal Vasko03ff5a72019-09-11 13:49:33 +02006437 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02006438 /* 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 +02006439 new_type = LYXP_NODE_ELEM;
6440 }
6441
Radek Krejciaa6b53f2020-08-27 15:19:03 +02006442 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, new_node, new_type, &idx));
6443 if ((idx < orig_used) && (idx > i)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006444 set->val.scnodes[idx].in_ctx = 2;
6445 temp_ctx = 1;
6446 }
6447 }
6448
6449 if (temp_ctx) {
6450 for (i = 0; i < orig_used; ++i) {
6451 if (set->val.scnodes[i].in_ctx == 2) {
6452 set->val.scnodes[i].in_ctx = 1;
6453 }
6454 }
6455 }
6456
6457 return LY_SUCCESS;
6458}
6459
6460/**
6461 * @brief Move context @p set to the result of a comparison. Handles '=', '!=', '<=', '<', '>=', or '>'.
6462 * Result is LYXP_SET_BOOLEAN. Indirectly context position aware.
6463 *
6464 * @param[in,out] set1 Set to use for the result.
6465 * @param[in] set2 Set acting as the second operand for @p op.
6466 * @param[in] op Comparison operator to process.
6467 * @param[in] options XPath options.
6468 * @return LY_ERR
6469 */
6470static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02006471moveto_op_comp(struct lyxp_set *set1, struct lyxp_set *set2, const char *op, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006472{
6473 /*
6474 * NODE SET + NODE SET = NODE SET + STRING /(1 NODE SET) 2 STRING
6475 * NODE SET + STRING = STRING + STRING /1 STRING (2 STRING)
6476 * NODE SET + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
6477 * NODE SET + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
6478 * STRING + NODE SET = STRING + STRING /(1 STRING) 2 STRING
6479 * NUMBER + NODE SET = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6480 * BOOLEAN + NODE SET = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
6481 *
6482 * '=' or '!='
6483 * BOOLEAN + BOOLEAN
6484 * BOOLEAN + STRING = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
6485 * BOOLEAN + NUMBER = BOOLEAN + BOOLEAN /(1 BOOLEAN) 2 BOOLEAN
6486 * STRING + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
6487 * NUMBER + BOOLEAN = BOOLEAN + BOOLEAN /1 BOOLEAN (2 BOOLEAN)
6488 * NUMBER + NUMBER
6489 * NUMBER + STRING = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6490 * STRING + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
6491 * STRING + STRING
6492 *
6493 * '<=', '<', '>=', '>'
6494 * NUMBER + NUMBER
6495 * BOOLEAN + BOOLEAN = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
6496 * BOOLEAN + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
6497 * BOOLEAN + STRING = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
6498 * NUMBER + STRING = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6499 * STRING + STRING = NUMBER + NUMBER /1 NUMBER, 2 NUMBER
6500 * STRING + NUMBER = NUMBER + NUMBER /1 NUMBER (2 NUMBER)
6501 * NUMBER + BOOLEAN = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6502 * STRING + BOOLEAN = NUMBER + NUMBER /(1 NUMBER) 2 NUMBER
6503 */
6504 struct lyxp_set iter1, iter2;
6505 int result;
6506 int64_t i;
6507 LY_ERR rc;
6508
Michal Vasko004d3152020-06-11 19:59:22 +02006509 memset(&iter1, 0, sizeof iter1);
6510 memset(&iter2, 0, sizeof iter2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006511
6512 /* iterative evaluation with node-sets */
6513 if ((set1->type == LYXP_SET_NODE_SET) || (set2->type == LYXP_SET_NODE_SET)) {
6514 if (set1->type == LYXP_SET_NODE_SET) {
6515 for (i = 0; i < set1->used; ++i) {
Michal Vasko4c7763f2020-07-27 17:40:37 +02006516 /* cast set1 */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006517 switch (set2->type) {
6518 case LYXP_SET_NUMBER:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006519 rc = set_comp_cast(&iter1, set1, LYXP_SET_NUMBER, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006520 break;
6521 case LYXP_SET_BOOLEAN:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006522 rc = set_comp_cast(&iter1, set1, LYXP_SET_BOOLEAN, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006523 break;
6524 default:
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006525 rc = set_comp_cast(&iter1, set1, LYXP_SET_STRING, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006526 break;
6527 }
6528 LY_CHECK_RET(rc);
6529
Michal Vasko4c7763f2020-07-27 17:40:37 +02006530 /* canonize set2 */
6531 LY_CHECK_ERR_RET(rc = set_comp_canonize(&iter2, set2, &set1->val.nodes[i]), lyxp_set_free_content(&iter1), rc);
6532
6533 /* compare recursively */
6534 rc = moveto_op_comp(&iter1, &iter2, op, options);
6535 lyxp_set_free_content(&iter2);
6536 LY_CHECK_ERR_RET(rc, lyxp_set_free_content(&iter1), rc);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006537
6538 /* lazy evaluation until true */
Michal Vasko004d3152020-06-11 19:59:22 +02006539 if (iter1.val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006540 set_fill_boolean(set1, 1);
6541 return LY_SUCCESS;
6542 }
6543 }
6544 } else {
6545 for (i = 0; i < set2->used; ++i) {
Michal Vasko4c7763f2020-07-27 17:40:37 +02006546 /* set set2 */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006547 switch (set1->type) {
Michal Vasko4c7763f2020-07-27 17:40:37 +02006548 case LYXP_SET_NUMBER:
6549 rc = set_comp_cast(&iter2, set2, LYXP_SET_NUMBER, i);
6550 break;
6551 case LYXP_SET_BOOLEAN:
6552 rc = set_comp_cast(&iter2, set2, LYXP_SET_BOOLEAN, i);
6553 break;
6554 default:
6555 rc = set_comp_cast(&iter2, set2, LYXP_SET_STRING, i);
6556 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006557 }
6558 LY_CHECK_RET(rc);
6559
Michal Vasko4c7763f2020-07-27 17:40:37 +02006560 /* canonize set1 */
6561 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 +02006562
Michal Vasko4c7763f2020-07-27 17:40:37 +02006563 /* compare recursively */
Michal Vasko03ff5a72019-09-11 13:49:33 +02006564 rc = moveto_op_comp(&iter1, &iter2, op, options);
Michal Vaskod3678892020-05-21 10:06:58 +02006565 lyxp_set_free_content(&iter2);
Michal Vasko4c7763f2020-07-27 17:40:37 +02006566 LY_CHECK_ERR_RET(rc, lyxp_set_free_content(&iter1), rc);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006567
6568 /* lazy evaluation until true */
Michal Vasko004d3152020-06-11 19:59:22 +02006569 if (iter1.val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006570 set_fill_boolean(set1, 1);
6571 return LY_SUCCESS;
6572 }
6573 }
6574 }
6575
6576 /* false for all nodes */
6577 set_fill_boolean(set1, 0);
6578 return LY_SUCCESS;
6579 }
6580
6581 /* first convert properly */
6582 if ((op[0] == '=') || (op[0] == '!')) {
6583 if ((set1->type == LYXP_SET_BOOLEAN) || (set2->type == LYXP_SET_BOOLEAN)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006584 lyxp_set_cast(set1, LYXP_SET_BOOLEAN);
6585 lyxp_set_cast(set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006586 } else if ((set1->type == LYXP_SET_NUMBER) || (set2->type == LYXP_SET_NUMBER)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006587 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006588 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006589 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006590 LY_CHECK_RET(rc);
6591 } /* else we have 2 strings */
6592 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006593 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006594 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006595 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006596 LY_CHECK_RET(rc);
6597 }
6598
6599 assert(set1->type == set2->type);
6600
6601 /* compute result */
6602 if (op[0] == '=') {
6603 if (set1->type == LYXP_SET_BOOLEAN) {
Michal Vasko004d3152020-06-11 19:59:22 +02006604 result = (set1->val.bln == set2->val.bln);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006605 } else if (set1->type == LYXP_SET_NUMBER) {
6606 result = (set1->val.num == set2->val.num);
6607 } else {
6608 assert(set1->type == LYXP_SET_STRING);
Michal Vaskoac6c72f2019-11-14 16:09:34 +01006609 result = !strcmp(set1->val.str, set2->val.str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006610 }
6611 } else if (op[0] == '!') {
6612 if (set1->type == LYXP_SET_BOOLEAN) {
Michal Vasko004d3152020-06-11 19:59:22 +02006613 result = (set1->val.bln != set2->val.bln);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006614 } else if (set1->type == LYXP_SET_NUMBER) {
6615 result = (set1->val.num != set2->val.num);
6616 } else {
6617 assert(set1->type == LYXP_SET_STRING);
Michal Vaskoac6c72f2019-11-14 16:09:34 +01006618 result = !strcmp(set1->val.str, set2->val.str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006619 }
6620 } else {
6621 assert(set1->type == LYXP_SET_NUMBER);
6622 if (op[0] == '<') {
6623 if (op[1] == '=') {
6624 result = (set1->val.num <= set2->val.num);
6625 } else {
6626 result = (set1->val.num < set2->val.num);
6627 }
6628 } else {
6629 if (op[1] == '=') {
6630 result = (set1->val.num >= set2->val.num);
6631 } else {
6632 result = (set1->val.num > set2->val.num);
6633 }
6634 }
6635 }
6636
6637 /* assign result */
6638 if (result) {
6639 set_fill_boolean(set1, 1);
6640 } else {
6641 set_fill_boolean(set1, 0);
6642 }
6643
6644 return LY_SUCCESS;
6645}
6646
6647/**
6648 * @brief Move context @p set to the result of a basic operation. Handles '+', '-', unary '-', '*', 'div',
6649 * or 'mod'. Result is LYXP_SET_NUMBER. Indirectly context position aware.
6650 *
6651 * @param[in,out] set1 Set to use for the result.
6652 * @param[in] set2 Set acting as the second operand for @p op.
6653 * @param[in] op Operator to process.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006654 * @return LY_ERR
6655 */
6656static LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006657moveto_op_math(struct lyxp_set *set1, struct lyxp_set *set2, const char *op)
Michal Vasko03ff5a72019-09-11 13:49:33 +02006658{
6659 LY_ERR rc;
6660
6661 /* unary '-' */
6662 if (!set2 && (op[0] == '-')) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006663 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006664 LY_CHECK_RET(rc);
6665 set1->val.num *= -1;
6666 lyxp_set_free(set2);
6667 return LY_SUCCESS;
6668 }
6669
6670 assert(set1 && set2);
6671
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006672 rc = lyxp_set_cast(set1, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006673 LY_CHECK_RET(rc);
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006674 rc = lyxp_set_cast(set2, LYXP_SET_NUMBER);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006675 LY_CHECK_RET(rc);
6676
6677 switch (op[0]) {
6678 /* '+' */
6679 case '+':
6680 set1->val.num += set2->val.num;
6681 break;
6682
6683 /* '-' */
6684 case '-':
6685 set1->val.num -= set2->val.num;
6686 break;
6687
6688 /* '*' */
6689 case '*':
6690 set1->val.num *= set2->val.num;
6691 break;
6692
6693 /* 'div' */
6694 case 'd':
6695 set1->val.num /= set2->val.num;
6696 break;
6697
6698 /* 'mod' */
6699 case 'm':
6700 set1->val.num = ((long long)set1->val.num) % ((long long)set2->val.num);
6701 break;
6702
6703 default:
6704 LOGINT_RET(set1->ctx);
6705 }
6706
6707 return LY_SUCCESS;
6708}
6709
6710/*
6711 * eval functions
6712 *
6713 * They execute a parsed XPath expression on some data subtree.
6714 */
6715
6716/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02006717 * @brief Evaluate Predicate. Logs directly on error.
6718 *
Michal Vaskod3678892020-05-21 10:06:58 +02006719 * [9] Predicate ::= '[' Expr ']'
Michal Vasko03ff5a72019-09-11 13:49:33 +02006720 *
6721 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02006722 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02006723 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
6724 * @param[in] options XPath options.
6725 * @param[in] parent_pos_pred Whether parent predicate was a positional one.
6726 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
6727 */
6728static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02006729eval_predicate(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 +02006730{
6731 LY_ERR rc;
Michal Vasko57eab132019-09-24 11:46:26 +02006732 uint16_t i, orig_exp;
Michal Vasko5c4e5892019-11-14 12:31:38 +01006733 uint32_t orig_pos, orig_size;
6734 int32_t pred_in_ctx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006735 struct lyxp_set set2;
6736 struct lyd_node *orig_parent;
6737
6738 /* '[' */
6739 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02006740 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02006741 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006742
6743 if (!set) {
6744only_parse:
Michal Vasko004d3152020-06-11 19:59:22 +02006745 rc = eval_expr_select(exp, tok_idx, 0, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006746 LY_CHECK_RET(rc);
6747 } else if (set->type == LYXP_SET_NODE_SET) {
6748 /* 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 +01006749 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02006750
6751 /* empty set, nothing to evaluate */
6752 if (!set->used) {
6753 goto only_parse;
6754 }
6755
Michal Vasko004d3152020-06-11 19:59:22 +02006756 orig_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006757 orig_pos = 0;
6758 orig_size = set->used;
6759 orig_parent = NULL;
Michal Vasko39dbf352020-05-21 10:08:59 +02006760 for (i = 0; i < set->used; ++i) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02006761 set_init(&set2, set);
6762 set_insert_node(&set2, set->val.nodes[i].node, set->val.nodes[i].pos, set->val.nodes[i].type, 0);
6763 /* remember the node context position for position() and context size for last(),
6764 * predicates should always be evaluated with respect to the child axis (since we do
6765 * not support explicit axes) so we assign positions based on their parents */
6766 if (parent_pos_pred && ((struct lyd_node *)set->val.nodes[i].node->parent != orig_parent)) {
6767 orig_parent = (struct lyd_node *)set->val.nodes[i].node->parent;
6768 orig_pos = 1;
6769 } else {
6770 ++orig_pos;
6771 }
6772
6773 set2.ctx_pos = orig_pos;
6774 set2.ctx_size = orig_size;
Michal Vasko004d3152020-06-11 19:59:22 +02006775 *tok_idx = orig_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006776
Michal Vasko004d3152020-06-11 19:59:22 +02006777 rc = eval_expr_select(exp, tok_idx, 0, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006778 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02006779 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006780 return rc;
6781 }
6782
6783 /* number is a position */
6784 if (set2.type == LYXP_SET_NUMBER) {
6785 if ((long long)set2.val.num == orig_pos) {
6786 set2.val.num = 1;
6787 } else {
6788 set2.val.num = 0;
6789 }
6790 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006791 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006792
6793 /* predicate satisfied or not? */
Michal Vasko004d3152020-06-11 19:59:22 +02006794 if (!set2.val.bln) {
Michal Vasko2caefc12019-11-14 16:07:56 +01006795 set_remove_node_none(set, i);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006796 }
6797 }
Michal Vasko2caefc12019-11-14 16:07:56 +01006798 set_remove_nodes_none(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006799
6800 } else if (set->type == LYXP_SET_SCNODE_SET) {
6801 for (i = 0; i < set->used; ++i) {
6802 if (set->val.scnodes[i].in_ctx == 1) {
6803 /* there is a currently-valid node */
6804 break;
6805 }
6806 }
6807 /* empty set, nothing to evaluate */
6808 if (i == set->used) {
6809 goto only_parse;
6810 }
6811
Michal Vasko004d3152020-06-11 19:59:22 +02006812 orig_exp = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006813
Michal Vasko03ff5a72019-09-11 13:49:33 +02006814 /* set special in_ctx to all the valid snodes */
6815 pred_in_ctx = set_scnode_new_in_ctx(set);
6816
6817 /* use the valid snodes one-by-one */
6818 for (i = 0; i < set->used; ++i) {
6819 if (set->val.scnodes[i].in_ctx != pred_in_ctx) {
6820 continue;
6821 }
6822 set->val.scnodes[i].in_ctx = 1;
6823
Michal Vasko004d3152020-06-11 19:59:22 +02006824 *tok_idx = orig_exp;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006825
Michal Vasko004d3152020-06-11 19:59:22 +02006826 rc = eval_expr_select(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006827 LY_CHECK_RET(rc);
6828
6829 set->val.scnodes[i].in_ctx = pred_in_ctx;
6830 }
6831
6832 /* restore the state as it was before the predicate */
6833 for (i = 0; i < set->used; ++i) {
6834 if (set->val.scnodes[i].in_ctx == 1) {
6835 set->val.scnodes[i].in_ctx = 0;
6836 } else if (set->val.scnodes[i].in_ctx == pred_in_ctx) {
6837 set->val.scnodes[i].in_ctx = 1;
6838 }
6839 }
6840
6841 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02006842 set2.type = LYXP_SET_NODE_SET;
Michal Vasko03ff5a72019-09-11 13:49:33 +02006843 set_fill_set(&set2, set);
6844
Michal Vasko004d3152020-06-11 19:59:22 +02006845 rc = eval_expr_select(exp, tok_idx, 0, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006846 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02006847 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006848 return rc;
6849 }
6850
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01006851 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko004d3152020-06-11 19:59:22 +02006852 if (!set2.val.bln) {
Michal Vaskod3678892020-05-21 10:06:58 +02006853 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006854 }
Michal Vaskod3678892020-05-21 10:06:58 +02006855 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006856 }
6857
6858 /* ']' */
Michal Vasko004d3152020-06-11 19:59:22 +02006859 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006860 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02006861 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02006862 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02006863
6864 return LY_SUCCESS;
6865}
6866
6867/**
Michal Vaskod3678892020-05-21 10:06:58 +02006868 * @brief Evaluate Literal. Logs directly on error.
6869 *
6870 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02006871 * @param[in] tok_idx Position in the expression @p exp.
Michal Vaskod3678892020-05-21 10:06:58 +02006872 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
6873 */
6874static void
Michal Vasko004d3152020-06-11 19:59:22 +02006875eval_literal(struct lyxp_expr *exp, uint16_t *tok_idx, struct lyxp_set *set)
Michal Vaskod3678892020-05-21 10:06:58 +02006876{
6877 if (set) {
Michal Vasko004d3152020-06-11 19:59:22 +02006878 if (exp->tok_len[*tok_idx] == 2) {
Michal Vaskod3678892020-05-21 10:06:58 +02006879 set_fill_string(set, "", 0);
6880 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02006881 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 +02006882 }
6883 }
6884 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02006885 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02006886 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02006887}
6888
6889/**
Michal Vasko004d3152020-06-11 19:59:22 +02006890 * @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 +02006891 *
Michal Vasko004d3152020-06-11 19:59:22 +02006892 * @param[in] exp Full parsed XPath expression.
6893 * @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 +02006894 * @param[in] ctx_node Found schema node as the context for the predicate.
6895 * @param[in] cur_mod Current module for the expression.
6896 * @param[in] cur_node Current (original context) node.
Michal Vasko004d3152020-06-11 19:59:22 +02006897 * @param[in] format Format of any prefixes in key names/values.
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006898 * @param[in] prefix_data Format-specific prefix data (see ::ly_resolve_prefix).
Michal Vasko004d3152020-06-11 19:59:22 +02006899 * @param[out] predicates Parsed predicates.
6900 * @param[out] pred_type Type of @p predicates.
6901 * @return LY_SUCCESS on success,
6902 * @return LY_ERR on any error.
Michal Vaskod3678892020-05-21 10:06:58 +02006903 */
6904static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006905eval_name_test_try_compile_predicates(struct lyxp_expr *exp, uint16_t *tok_idx, const struct lysc_node *ctx_node,
6906 const struct lys_module *cur_mod, const struct lysc_node *cur_node, LY_PREFIX_FORMAT format, void *prefix_data,
6907 struct ly_path_predicate **predicates, enum ly_path_pred_type *pred_type)
Michal Vaskod3678892020-05-21 10:06:58 +02006908{
Michal Vasko004d3152020-06-11 19:59:22 +02006909 LY_ERR ret = LY_SUCCESS;
6910 uint16_t key_count, e_idx, pred_idx = 0;
Michal Vaskod3678892020-05-21 10:06:58 +02006911 const struct lysc_node *key;
Michal Vasko004d3152020-06-11 19:59:22 +02006912 size_t pred_len;
Radek Krejci1deb5be2020-08-26 16:43:36 +02006913 uint32_t prev_lo;
Michal Vasko004d3152020-06-11 19:59:22 +02006914 struct lyxp_expr *exp2 = NULL;
Michal Vaskod3678892020-05-21 10:06:58 +02006915
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006916 assert(ctx_node->nodetype & (LYS_LIST | LYS_LEAFLIST));
Michal Vaskod3678892020-05-21 10:06:58 +02006917
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006918 if (ctx_node->nodetype == LYS_LIST) {
Michal Vasko004d3152020-06-11 19:59:22 +02006919 /* get key count */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006920 if (ctx_node->flags & LYS_KEYLESS) {
Michal Vasko004d3152020-06-11 19:59:22 +02006921 return LY_EINVAL;
6922 }
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006923 for (key_count = 0, key = lysc_node_children(ctx_node, 0); key && (key->flags & LYS_KEY); key = key->next, ++key_count) {}
Michal Vasko004d3152020-06-11 19:59:22 +02006924 assert(key_count);
Michal Vaskod3678892020-05-21 10:06:58 +02006925
Michal Vasko004d3152020-06-11 19:59:22 +02006926 /* learn where the predicates end */
6927 e_idx = *tok_idx;
6928 while (key_count) {
6929 /* '[' */
6930 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
6931 return LY_EINVAL;
6932 }
6933 ++e_idx;
6934
6935 /* ']' */
6936 while (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK2)) {
6937 ++e_idx;
6938 }
6939 ++e_idx;
6940
6941 /* another presumably key predicate parsed */
6942 --key_count;
6943 }
Michal Vasko004d3152020-06-11 19:59:22 +02006944 } else {
6945 /* learn just where this single predicate ends */
6946 e_idx = *tok_idx;
6947
Michal Vaskod3678892020-05-21 10:06:58 +02006948 /* '[' */
Michal Vasko004d3152020-06-11 19:59:22 +02006949 if (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK1)) {
6950 return LY_EINVAL;
6951 }
6952 ++e_idx;
Michal Vaskod3678892020-05-21 10:06:58 +02006953
6954 /* ']' */
Michal Vasko004d3152020-06-11 19:59:22 +02006955 while (lyxp_check_token(NULL, exp, e_idx, LYXP_TOKEN_BRACK2)) {
6956 ++e_idx;
6957 }
6958 ++e_idx;
Michal Vaskod3678892020-05-21 10:06:58 +02006959 }
6960
Michal Vasko004d3152020-06-11 19:59:22 +02006961 /* get the joined length of all the keys predicates/of the single leaf-list predicate */
6962 pred_len = (exp->tok_pos[e_idx - 1] + exp->tok_len[e_idx - 1]) - exp->tok_pos[*tok_idx];
6963
6964 /* turn logging off */
6965 prev_lo = ly_log_options(0);
6966
6967 /* parse the predicate(s) */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006968 LY_CHECK_GOTO(ret = ly_path_parse_predicate(ctx_node->module->ctx, ctx_node, exp->expr + exp->tok_pos[*tok_idx],
6969 pred_len, LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &exp2), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +02006970
6971 /* compile */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006972 ret = ly_path_compile_predicate(ctx_node->module->ctx, cur_node, cur_mod, ctx_node, exp2, &pred_idx, format,
6973 prefix_data, predicates, pred_type);
Michal Vasko004d3152020-06-11 19:59:22 +02006974 LY_CHECK_GOTO(ret, cleanup);
6975
6976 /* success, the predicate must include all the needed information for hash-based search */
6977 *tok_idx = e_idx;
6978
6979cleanup:
6980 ly_log_options(prev_lo);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006981 lyxp_expr_free(ctx_node->module->ctx, exp2);
Michal Vasko004d3152020-06-11 19:59:22 +02006982 return ret;
Michal Vaskod3678892020-05-21 10:06:58 +02006983}
6984
6985/**
Michal Vasko5d24f6c2020-10-13 13:49:06 +02006986 * @brief Search for/check the next schema node that could be the only matching schema node meaning the
6987 * data node(s) could be found using a single hash-based search.
6988 *
6989 * @param[in] node Next context node to check.
6990 * @param[in] name Expected node name.
6991 * @param[in] name_len Length of @p name.
6992 * @param[in] moveto_mod Expected node module.
6993 * @param[in] root_type XPath root type.
6994 * @param[in] no_prefix Whether the node name was unprefixed.
6995 * @param[in] format Prefix format.
6996 * @param[in,out] found Previously found node, is updated.
6997 * @return LY_SUCCESS on success,
6998 * @return LY_ENOT if the whole check failed and hashes cannot be used.
6999 */
7000static LY_ERR
7001eval_name_test_with_predicate_get_scnode(const struct lyd_node *node, const char *name, uint16_t name_len,
7002 const struct lys_module *moveto_mod, enum lyxp_node_type root_type, ly_bool no_prefix, LY_PREFIX_FORMAT format,
7003 const struct lysc_node **found)
7004{
7005 const struct lysc_node *scnode;
7006 const struct lys_module *mod;
7007 uint32_t idx = 0;
7008
7009continue_search:
Michal Vasko7d1d0912020-10-16 08:38:30 +02007010 scnode = NULL;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007011 if (!node) {
7012 if (no_prefix && (format == LY_PREF_JSON)) {
7013 /* search all modules for a single match */
7014 while ((mod = ly_ctx_get_module_iter(moveto_mod->ctx, &idx))) {
7015 scnode = lys_find_child(NULL, mod, name, name_len, 0, 0);
7016 if (scnode) {
7017 /* we have found a match */
7018 break;
7019 }
7020 }
7021
Michal Vasko7d1d0912020-10-16 08:38:30 +02007022 if (!scnode) {
7023 /* all modules searched */
7024 idx = 0;
7025 }
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007026 } else {
7027 /* search in top-level */
7028 scnode = lys_find_child(NULL, moveto_mod, name, name_len, 0, 0);
7029 }
7030 } else if (!*found || (lysc_data_parent(*found) != node->schema)) {
7031 if (no_prefix && (format == LY_PREF_JSON)) {
7032 /* we must adjust the module to inherit the one from the context node */
7033 moveto_mod = node->schema->module;
7034 }
7035
7036 /* search in children, do not repeat the same search */
7037 scnode = lys_find_child(node->schema, moveto_mod, name, name_len, 0, 0);
Michal Vasko7d1d0912020-10-16 08:38:30 +02007038 } /* else skip redundant search */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007039
7040 /* additional context check */
7041 if (scnode && (root_type == LYXP_NODE_ROOT_CONFIG) && (scnode->flags & LYS_CONFIG_R)) {
7042 scnode = NULL;
7043 }
7044
7045 if (scnode) {
7046 if (*found) {
7047 /* we found a schema node with the same name but at different level, give up, too complicated
7048 * (more hash-based searches would be required, not supported) */
7049 return LY_ENOT;
7050 } else {
7051 /* remember the found schema node and continue to make sure it can be used */
7052 *found = scnode;
7053 }
7054 }
7055
7056 if (idx) {
7057 /* continue searching all the following models */
7058 goto continue_search;
7059 }
7060
7061 return LY_SUCCESS;
7062}
7063
7064/**
Michal Vaskod3678892020-05-21 10:06:58 +02007065 * @brief Evaluate NameTest and any following Predicates. Logs directly on error.
7066 *
7067 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
7068 * [6] NodeTest ::= NameTest | NodeType '(' ')'
7069 * [7] NameTest ::= '*' | NCName ':' '*' | QName
7070 *
7071 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007072 * @param[in] tok_idx Position in the expression @p exp.
Michal Vaskod3678892020-05-21 10:06:58 +02007073 * @param[in] attr_axis Whether to search attributes or standard nodes.
7074 * @param[in] all_desc Whether to search all the descendants or children only.
7075 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7076 * @param[in] options XPath options.
7077 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7078 */
7079static LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007080eval_name_test_with_predicate(struct lyxp_expr *exp, uint16_t *tok_idx, ly_bool attr_axis, ly_bool all_desc,
7081 struct lyxp_set *set, uint32_t options)
Michal Vaskod3678892020-05-21 10:06:58 +02007082{
Michal Vaskod3678892020-05-21 10:06:58 +02007083 char *path;
Michal Vasko004d3152020-06-11 19:59:22 +02007084 const char *ncname, *ncname_dict = NULL;
7085 uint16_t ncname_len;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007086 const struct lys_module *moveto_mod = NULL;
7087 const struct lysc_node *scnode = NULL, *ctx_scnode;
Michal Vasko004d3152020-06-11 19:59:22 +02007088 struct ly_path_predicate *predicates = NULL;
7089 enum ly_path_pred_type pred_type = 0;
Michal Vaskod3678892020-05-21 10:06:58 +02007090 LY_ERR rc = LY_SUCCESS;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007091 ly_bool no_prefix;
Michal Vaskod3678892020-05-21 10:06:58 +02007092
7093 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007094 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007095 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007096
7097 if (!set) {
7098 goto moveto;
7099 }
7100
Michal Vasko004d3152020-06-11 19:59:22 +02007101 ncname = &exp->expr[exp->tok_pos[*tok_idx - 1]];
7102 ncname_len = exp->tok_len[*tok_idx - 1];
Michal Vaskod3678892020-05-21 10:06:58 +02007103
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007104 /* get the first schema context node */
7105 if (set->used) {
7106 if (set->type == LYXP_SET_NODE_SET) {
7107 ctx_scnode = set->val.nodes[0].node ? set->val.nodes[0].node->schema : NULL;
7108 } else {
7109 ctx_scnode = set->val.scnodes[0].scnode;
7110 }
7111 } else {
7112 ctx_scnode = NULL;
7113 }
7114
7115 /* parse (and skip) module name, use any context node (if available) just so we get some moveto_mod if there
7116 * is no prefix for ::LY_PREF_JSON */
7117 rc = moveto_resolve_model(&ncname, &ncname_len, set, ctx_scnode, &moveto_mod);
Michal Vaskod3678892020-05-21 10:06:58 +02007118 LY_CHECK_GOTO(rc, cleanup);
7119
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007120 if (ncname_len == exp->tok_len[*tok_idx - 1]) {
7121 /* remember that there is no prefix */
7122 no_prefix = 1;
7123 } else {
7124 no_prefix = 0;
7125 }
7126
Michal Vaskod3678892020-05-21 10:06:58 +02007127 if (moveto_mod && !attr_axis && !all_desc && (set->type == LYXP_SET_NODE_SET)) {
7128 /* find the matching schema node in some parent in the context */
Radek Krejci1deb5be2020-08-26 16:43:36 +02007129 for (uint32_t i = 0; i < set->used; ++i) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007130 if (eval_name_test_with_predicate_get_scnode(set->val.nodes[i].node, ncname, ncname_len, moveto_mod,
7131 set->root_type, no_prefix, set->format, &scnode)) {
7132 /* check failed */
7133 scnode = NULL;
7134 break;
Michal Vaskod3678892020-05-21 10:06:58 +02007135 }
7136 }
7137
Michal Vasko004d3152020-06-11 19:59:22 +02007138 if (scnode && (scnode->nodetype & (LYS_LIST | LYS_LEAFLIST))) {
7139 /* try to create the predicates */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007140 if (eval_name_test_try_compile_predicates(exp, tok_idx, scnode, set->cur_mod, set->cur_node ?
7141 set->cur_node->schema : NULL, set->format, set->prefix_data, &predicates, &pred_type)) {
Michal Vasko004d3152020-06-11 19:59:22 +02007142 /* hashes cannot be used */
Michal Vaskod3678892020-05-21 10:06:58 +02007143 scnode = NULL;
7144 }
7145 }
7146 }
7147
Michal Vasko004d3152020-06-11 19:59:22 +02007148 if (!scnode && moveto_mod) {
7149 /* we are not able to match based on a schema node and not all the modules match,
7150 * use dictionary for efficient comparison */
Radek Krejci011e4aa2020-09-04 15:22:31 +02007151 LY_CHECK_GOTO(rc = lydict_insert(set->ctx, ncname, ncname_len, &ncname_dict), cleanup);
Michal Vaskod3678892020-05-21 10:06:58 +02007152 }
7153
7154moveto:
7155 /* move to the attribute(s), data node(s), or schema node(s) */
7156 if (attr_axis) {
7157 if (set && (options & LYXP_SCNODE_ALL)) {
7158 set_scnode_clear_ctx(set);
7159 } else {
7160 if (all_desc) {
Michal Vasko004d3152020-06-11 19:59:22 +02007161 rc = moveto_attr_alldesc(set, moveto_mod, ncname_dict);
Michal Vaskod3678892020-05-21 10:06:58 +02007162 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007163 rc = moveto_attr(set, moveto_mod, ncname_dict);
Michal Vaskod3678892020-05-21 10:06:58 +02007164 }
7165 LY_CHECK_GOTO(rc, cleanup);
7166 }
7167 } else {
7168 if (set && (options & LYXP_SCNODE_ALL)) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02007169 int64_t i;
7170
Michal Vaskod3678892020-05-21 10:06:58 +02007171 if (all_desc) {
Michal Vasko004d3152020-06-11 19:59:22 +02007172 rc = moveto_scnode_alldesc(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007173 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007174 rc = moveto_scnode(set, moveto_mod, ncname_dict, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007175 }
7176 LY_CHECK_GOTO(rc, cleanup);
7177
7178 for (i = set->used - 1; i > -1; --i) {
7179 if (set->val.scnodes[i].in_ctx > 0) {
7180 break;
7181 }
7182 }
7183 if (i == -1) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007184 path = lysc_path(set->cur_scnode, LYSC_PATH_LOG, NULL, 0);
Michal Vaskod3678892020-05-21 10:06:58 +02007185 LOGWRN(set->ctx, "Schema node \"%.*s\" not found (%.*s) with context node \"%s\".",
Michal Vasko69730152020-10-09 16:30:07 +02007186 ncname_len, ncname, ncname - exp->expr, exp->expr, path);
Michal Vaskod3678892020-05-21 10:06:58 +02007187 free(path);
7188 }
7189 } else {
7190 if (all_desc) {
Michal Vasko004d3152020-06-11 19:59:22 +02007191 rc = moveto_node_alldesc(set, moveto_mod, ncname_dict);
Michal Vaskod3678892020-05-21 10:06:58 +02007192 } else {
7193 if (scnode) {
7194 /* we can find the nodes using hashes */
Michal Vasko004d3152020-06-11 19:59:22 +02007195 rc = moveto_node_hash(set, scnode, predicates);
Michal Vaskod3678892020-05-21 10:06:58 +02007196 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007197 rc = moveto_node(set, moveto_mod, ncname_dict);
Michal Vaskod3678892020-05-21 10:06:58 +02007198 }
7199 }
7200 LY_CHECK_GOTO(rc, cleanup);
7201 }
7202 }
7203
7204 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02007205 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
7206 rc = eval_predicate(exp, tok_idx, set, options, 1);
Michal Vaskod3678892020-05-21 10:06:58 +02007207 LY_CHECK_RET(rc);
7208 }
7209
7210cleanup:
Michal Vaskodb51a8d2020-05-27 15:22:29 +02007211 if (set) {
Michal Vasko004d3152020-06-11 19:59:22 +02007212 lydict_remove(set->ctx, ncname_dict);
7213 ly_path_predicates_free(set->ctx, pred_type, scnode, predicates);
Michal Vaskodb51a8d2020-05-27 15:22:29 +02007214 }
Michal Vaskod3678892020-05-21 10:06:58 +02007215 return rc;
7216}
7217
7218/**
7219 * @brief Evaluate NodeType and any following Predicates. Logs directly on error.
7220 *
7221 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
7222 * [6] NodeTest ::= NameTest | NodeType '(' ')'
7223 * [8] NodeType ::= 'text' | 'node'
7224 *
7225 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007226 * @param[in] tok_idx Position in the expression @p exp.
Michal Vaskod3678892020-05-21 10:06:58 +02007227 * @param[in] attr_axis Whether to search attributes or standard nodes.
7228 * @param[in] all_desc Whether to search all the descendants or children only.
7229 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7230 * @param[in] options XPath options.
7231 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7232 */
7233static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02007234eval_node_type_with_predicate(struct lyxp_expr *exp, uint16_t *tok_idx, ly_bool attr_axis, ly_bool all_desc,
Radek Krejci1deb5be2020-08-26 16:43:36 +02007235 struct lyxp_set *set, uint32_t options)
Michal Vaskod3678892020-05-21 10:06:58 +02007236{
7237 LY_ERR rc;
7238
7239 /* TODO */
7240 (void)attr_axis;
7241 (void)all_desc;
7242
7243 if (set) {
Michal Vasko004d3152020-06-11 19:59:22 +02007244 assert(exp->tok_len[*tok_idx] == 4);
Michal Vaskod3678892020-05-21 10:06:58 +02007245 if (set->type == LYXP_SET_SCNODE_SET) {
7246 set_scnode_clear_ctx(set);
7247 /* just for the debug message below */
7248 set = NULL;
7249 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007250 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "node", 4)) {
Michal Vaskod3678892020-05-21 10:06:58 +02007251 rc = xpath_node(NULL, 0, set, options);
7252 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007253 assert(!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "text", 4));
Michal Vaskod3678892020-05-21 10:06:58 +02007254 rc = xpath_text(NULL, 0, set, options);
7255 }
7256 LY_CHECK_RET(rc);
7257 }
7258 }
7259 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007260 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007261 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007262
7263 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02007264 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
Michal Vaskod3678892020-05-21 10:06:58 +02007265 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007266 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007267 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007268
7269 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02007270 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
Michal Vaskod3678892020-05-21 10:06:58 +02007271 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007272 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007273 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007274
7275 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02007276 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
7277 rc = eval_predicate(exp, tok_idx, set, options, 1);
Michal Vaskod3678892020-05-21 10:06:58 +02007278 LY_CHECK_RET(rc);
7279 }
7280
7281 return LY_SUCCESS;
7282}
7283
7284/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02007285 * @brief Evaluate RelativeLocationPath. Logs directly on error.
7286 *
7287 * [4] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
7288 * [5] Step ::= '@'? NodeTest Predicate* | '.' | '..'
Michal Vaskod3678892020-05-21 10:06:58 +02007289 * [6] NodeTest ::= NameTest | NodeType '(' ')'
Michal Vasko03ff5a72019-09-11 13:49:33 +02007290 *
7291 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007292 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007293 * @param[in] all_desc Whether to search all the descendants or children only.
7294 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7295 * @param[in] options XPath options.
7296 * @return LY_ERR (YL_EINCOMPLETE on unresolved when)
7297 */
7298static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02007299eval_relative_location_path(struct lyxp_expr *exp, uint16_t *tok_idx, ly_bool all_desc, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007300{
Radek Krejci857189e2020-09-01 13:26:36 +02007301 ly_bool attr_axis;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007302 LY_ERR rc;
7303
7304 goto step;
7305 do {
7306 /* evaluate '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02007307 if (exp->tok_len[*tok_idx] == 1) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007308 all_desc = 0;
7309 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007310 assert(exp->tok_len[*tok_idx] == 2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007311 all_desc = 1;
7312 }
7313 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007314 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007315 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007316
7317step:
Michal Vaskod3678892020-05-21 10:06:58 +02007318 /* evaluate abbreviated axis '@'? if any */
Michal Vasko004d3152020-06-11 19:59:22 +02007319 if (exp->tokens[*tok_idx] == LYXP_TOKEN_AT) {
Michal Vaskod3678892020-05-21 10:06:58 +02007320 attr_axis = 1;
7321
7322 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007323 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007324 ++(*tok_idx);
Michal Vaskod3678892020-05-21 10:06:58 +02007325 } else {
7326 attr_axis = 0;
7327 }
7328
Michal Vasko03ff5a72019-09-11 13:49:33 +02007329 /* Step */
Michal Vasko004d3152020-06-11 19:59:22 +02007330 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007331 case LYXP_TOKEN_DOT:
7332 /* evaluate '.' */
7333 if (set && (options & LYXP_SCNODE_ALL)) {
7334 rc = moveto_scnode_self(set, all_desc, options);
7335 } else {
7336 rc = moveto_self(set, all_desc, options);
7337 }
7338 LY_CHECK_RET(rc);
7339 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007340 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007341 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007342 break;
7343
7344 case LYXP_TOKEN_DDOT:
7345 /* evaluate '..' */
7346 if (set && (options & LYXP_SCNODE_ALL)) {
7347 rc = moveto_scnode_parent(set, all_desc, options);
7348 } else {
7349 rc = moveto_parent(set, all_desc, options);
7350 }
7351 LY_CHECK_RET(rc);
7352 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007353 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007354 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007355 break;
7356
Michal Vasko03ff5a72019-09-11 13:49:33 +02007357 case LYXP_TOKEN_NAMETEST:
Michal Vaskod3678892020-05-21 10:06:58 +02007358 /* evaluate NameTest Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02007359 rc = eval_name_test_with_predicate(exp, tok_idx, attr_axis, all_desc, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007360 LY_CHECK_RET(rc);
Michal Vaskod3678892020-05-21 10:06:58 +02007361 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007362
Michal Vaskod3678892020-05-21 10:06:58 +02007363 case LYXP_TOKEN_NODETYPE:
7364 /* evaluate NodeType Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02007365 rc = eval_node_type_with_predicate(exp, tok_idx, attr_axis, all_desc, set, options);
Michal Vaskod3678892020-05-21 10:06:58 +02007366 LY_CHECK_RET(rc);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007367 break;
7368
7369 default:
Michal Vasko02a77382019-09-12 11:47:35 +02007370 LOGINT_RET(set ? set->ctx : NULL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007371 }
Michal Vasko004d3152020-06-11 19:59:22 +02007372 } while (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007373
7374 return LY_SUCCESS;
7375}
7376
7377/**
7378 * @brief Evaluate AbsoluteLocationPath. Logs directly on error.
7379 *
7380 * [3] AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
7381 *
7382 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007383 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007384 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7385 * @param[in] options XPath options.
7386 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7387 */
7388static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02007389eval_absolute_location_path(struct lyxp_expr *exp, uint16_t *tok_idx, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007390{
Radek Krejci857189e2020-09-01 13:26:36 +02007391 ly_bool all_desc;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007392
7393 if (set) {
7394 /* no matter what tokens follow, we need to be at the root */
Michal Vaskob0099a92020-08-31 14:55:23 +02007395 LY_CHECK_RET(moveto_root(set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007396 }
7397
7398 /* '/' RelativeLocationPath? */
Michal Vasko004d3152020-06-11 19:59:22 +02007399 if (exp->tok_len[*tok_idx] == 1) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007400 /* evaluate '/' - deferred */
7401 all_desc = 0;
7402 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007403 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007404 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007405
Michal Vasko004d3152020-06-11 19:59:22 +02007406 if (lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NONE)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007407 return LY_SUCCESS;
7408 }
Michal Vasko004d3152020-06-11 19:59:22 +02007409 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007410 case LYXP_TOKEN_DOT:
7411 case LYXP_TOKEN_DDOT:
7412 case LYXP_TOKEN_AT:
7413 case LYXP_TOKEN_NAMETEST:
7414 case LYXP_TOKEN_NODETYPE:
Michal Vaskob0099a92020-08-31 14:55:23 +02007415 LY_CHECK_RET(eval_relative_location_path(exp, tok_idx, all_desc, set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007416 break;
7417 default:
7418 break;
7419 }
7420
Michal Vasko03ff5a72019-09-11 13:49:33 +02007421 } else {
Radek Krejcif6a11002020-08-21 13:29:07 +02007422 /* '//' RelativeLocationPath */
Michal Vasko03ff5a72019-09-11 13:49:33 +02007423 /* evaluate '//' - deferred so as not to waste memory by remembering all the nodes */
7424 all_desc = 1;
7425 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007426 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007427 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007428
Michal Vaskob0099a92020-08-31 14:55:23 +02007429 LY_CHECK_RET(eval_relative_location_path(exp, tok_idx, all_desc, set, options));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007430 }
7431
7432 return LY_SUCCESS;
7433}
7434
7435/**
7436 * @brief Evaluate FunctionCall. Logs directly on error.
7437 *
Michal Vaskod3678892020-05-21 10:06:58 +02007438 * [11] FunctionCall ::= FunctionName '(' ( Expr ( ',' Expr )* )? ')'
Michal Vasko03ff5a72019-09-11 13:49:33 +02007439 *
7440 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007441 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007442 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7443 * @param[in] options XPath options.
7444 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7445 */
7446static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02007447eval_function_call(struct lyxp_expr *exp, uint16_t *tok_idx, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007448{
7449 LY_ERR rc;
Michal Vasko69730152020-10-09 16:30:07 +02007450
Radek Krejci1deb5be2020-08-26 16:43:36 +02007451 LY_ERR (*xpath_func)(struct lyxp_set **, uint16_t, struct lyxp_set *, uint32_t) = NULL;
Michal Vasko0cbf54f2019-12-16 10:01:06 +01007452 uint16_t arg_count = 0, i;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007453 struct lyxp_set **args = NULL, **args_aux;
7454
7455 if (set) {
7456 /* FunctionName */
Michal Vasko004d3152020-06-11 19:59:22 +02007457 switch (exp->tok_len[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007458 case 3:
Michal Vasko004d3152020-06-11 19:59:22 +02007459 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "not", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007460 xpath_func = &xpath_not;
Michal Vasko004d3152020-06-11 19:59:22 +02007461 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "sum", 3)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007462 xpath_func = &xpath_sum;
7463 }
7464 break;
7465 case 4:
Michal Vasko004d3152020-06-11 19:59:22 +02007466 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "lang", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007467 xpath_func = &xpath_lang;
Michal Vasko004d3152020-06-11 19:59:22 +02007468 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "last", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007469 xpath_func = &xpath_last;
Michal Vasko004d3152020-06-11 19:59:22 +02007470 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "name", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007471 xpath_func = &xpath_name;
Michal Vasko004d3152020-06-11 19:59:22 +02007472 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "true", 4)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007473 xpath_func = &xpath_true;
7474 }
7475 break;
7476 case 5:
Michal Vasko004d3152020-06-11 19:59:22 +02007477 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "count", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007478 xpath_func = &xpath_count;
Michal Vasko004d3152020-06-11 19:59:22 +02007479 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "false", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007480 xpath_func = &xpath_false;
Michal Vasko004d3152020-06-11 19:59:22 +02007481 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "floor", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007482 xpath_func = &xpath_floor;
Michal Vasko004d3152020-06-11 19:59:22 +02007483 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "round", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007484 xpath_func = &xpath_round;
Michal Vasko004d3152020-06-11 19:59:22 +02007485 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "deref", 5)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007486 xpath_func = &xpath_deref;
7487 }
7488 break;
7489 case 6:
Michal Vasko004d3152020-06-11 19:59:22 +02007490 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "concat", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007491 xpath_func = &xpath_concat;
Michal Vasko004d3152020-06-11 19:59:22 +02007492 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "number", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007493 xpath_func = &xpath_number;
Michal Vasko004d3152020-06-11 19:59:22 +02007494 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string", 6)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007495 xpath_func = &xpath_string;
7496 }
7497 break;
7498 case 7:
Michal Vasko004d3152020-06-11 19:59:22 +02007499 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "boolean", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007500 xpath_func = &xpath_boolean;
Michal Vasko004d3152020-06-11 19:59:22 +02007501 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "ceiling", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007502 xpath_func = &xpath_ceiling;
Michal Vasko004d3152020-06-11 19:59:22 +02007503 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "current", 7)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007504 xpath_func = &xpath_current;
7505 }
7506 break;
7507 case 8:
Michal Vasko004d3152020-06-11 19:59:22 +02007508 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "contains", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007509 xpath_func = &xpath_contains;
Michal Vasko004d3152020-06-11 19:59:22 +02007510 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "position", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007511 xpath_func = &xpath_position;
Michal Vasko004d3152020-06-11 19:59:22 +02007512 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "re-match", 8)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007513 xpath_func = &xpath_re_match;
7514 }
7515 break;
7516 case 9:
Michal Vasko004d3152020-06-11 19:59:22 +02007517 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007518 xpath_func = &xpath_substring;
Michal Vasko004d3152020-06-11 19:59:22 +02007519 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "translate", 9)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007520 xpath_func = &xpath_translate;
7521 }
7522 break;
7523 case 10:
Michal Vasko004d3152020-06-11 19:59:22 +02007524 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "local-name", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007525 xpath_func = &xpath_local_name;
Michal Vasko004d3152020-06-11 19:59:22 +02007526 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "enum-value", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007527 xpath_func = &xpath_enum_value;
Michal Vasko004d3152020-06-11 19:59:22 +02007528 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "bit-is-set", 10)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007529 xpath_func = &xpath_bit_is_set;
7530 }
7531 break;
7532 case 11:
Michal Vasko004d3152020-06-11 19:59:22 +02007533 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "starts-with", 11)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007534 xpath_func = &xpath_starts_with;
7535 }
7536 break;
7537 case 12:
Michal Vasko004d3152020-06-11 19:59:22 +02007538 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from", 12)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007539 xpath_func = &xpath_derived_from;
7540 }
7541 break;
7542 case 13:
Michal Vasko004d3152020-06-11 19:59:22 +02007543 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "namespace-uri", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007544 xpath_func = &xpath_namespace_uri;
Michal Vasko004d3152020-06-11 19:59:22 +02007545 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "string-length", 13)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007546 xpath_func = &xpath_string_length;
7547 }
7548 break;
7549 case 15:
Michal Vasko004d3152020-06-11 19:59:22 +02007550 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "normalize-space", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007551 xpath_func = &xpath_normalize_space;
Michal Vasko004d3152020-06-11 19:59:22 +02007552 } else if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-after", 15)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007553 xpath_func = &xpath_substring_after;
7554 }
7555 break;
7556 case 16:
Michal Vasko004d3152020-06-11 19:59:22 +02007557 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "substring-before", 16)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007558 xpath_func = &xpath_substring_before;
7559 }
7560 break;
7561 case 20:
Michal Vasko004d3152020-06-11 19:59:22 +02007562 if (!strncmp(&exp->expr[exp->tok_pos[*tok_idx]], "derived-from-or-self", 20)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007563 xpath_func = &xpath_derived_from_or_self;
7564 }
7565 break;
7566 }
7567
7568 if (!xpath_func) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007569 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INFUNC, exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007570 return LY_EVALID;
7571 }
7572 }
7573
7574 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007575 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007576 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007577
7578 /* '(' */
Michal Vasko004d3152020-06-11 19:59:22 +02007579 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007580 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007581 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007582 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007583
7584 /* ( Expr ( ',' Expr )* )? */
Michal Vasko004d3152020-06-11 19:59:22 +02007585 if (exp->tokens[*tok_idx] != LYXP_TOKEN_PAR2) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007586 if (set) {
7587 args = malloc(sizeof *args);
7588 LY_CHECK_ERR_GOTO(!args, LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
7589 arg_count = 1;
7590 args[0] = set_copy(set);
7591 if (!args[0]) {
7592 rc = LY_EMEM;
7593 goto cleanup;
7594 }
7595
Michal Vasko004d3152020-06-11 19:59:22 +02007596 rc = eval_expr_select(exp, tok_idx, 0, args[0], options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007597 LY_CHECK_GOTO(rc, cleanup);
7598 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007599 rc = eval_expr_select(exp, tok_idx, 0, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007600 LY_CHECK_GOTO(rc, cleanup);
7601 }
7602 }
Michal Vasko004d3152020-06-11 19:59:22 +02007603 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_COMMA)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007604 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007605 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007606 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007607
7608 if (set) {
7609 ++arg_count;
7610 args_aux = realloc(args, arg_count * sizeof *args);
7611 LY_CHECK_ERR_GOTO(!args_aux, arg_count--; LOGMEM(set->ctx); rc = LY_EMEM, cleanup);
7612 args = args_aux;
7613 args[arg_count - 1] = set_copy(set);
7614 if (!args[arg_count - 1]) {
7615 rc = LY_EMEM;
7616 goto cleanup;
7617 }
7618
Michal Vasko004d3152020-06-11 19:59:22 +02007619 rc = eval_expr_select(exp, tok_idx, 0, args[arg_count - 1], options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007620 LY_CHECK_GOTO(rc, cleanup);
7621 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007622 rc = eval_expr_select(exp, tok_idx, 0, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007623 LY_CHECK_GOTO(rc, cleanup);
7624 }
7625 }
7626
7627 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02007628 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007629 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007630 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007631 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007632
7633 if (set) {
7634 /* evaluate function */
7635 rc = xpath_func(args, arg_count, set, options);
7636
7637 if (options & LYXP_SCNODE_ALL) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007638 /* merge all nodes from arg evaluations */
7639 for (i = 0; i < arg_count; ++i) {
7640 set_scnode_clear_ctx(args[i]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01007641 lyxp_set_scnode_merge(set, args[i]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007642 }
7643 }
7644 } else {
7645 rc = LY_SUCCESS;
7646 }
7647
7648cleanup:
7649 for (i = 0; i < arg_count; ++i) {
7650 lyxp_set_free(args[i]);
7651 }
7652 free(args);
7653
7654 return rc;
7655}
7656
7657/**
7658 * @brief Evaluate Number. Logs directly on error.
7659 *
7660 * @param[in] ctx Context for errors.
7661 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007662 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007663 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7664 * @return LY_ERR
7665 */
7666static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02007667eval_number(struct ly_ctx *ctx, struct lyxp_expr *exp, uint16_t *tok_idx, struct lyxp_set *set)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007668{
7669 long double num;
7670 char *endptr;
7671
7672 if (set) {
7673 errno = 0;
Michal Vasko004d3152020-06-11 19:59:22 +02007674 num = strtold(&exp->expr[exp->tok_pos[*tok_idx]], &endptr);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007675 if (errno) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007676 LOGVAL(ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INTOK, "Unknown", &exp->expr[exp->tok_pos[*tok_idx]]);
7677 LOGVAL(ctx, LY_VLOG_LYD, set->cur_node, LYVE_XPATH, "Failed to convert \"%.*s\" into a long double (%s).",
Michal Vasko69730152020-10-09 16:30:07 +02007678 exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]], strerror(errno));
Michal Vasko03ff5a72019-09-11 13:49:33 +02007679 return LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +02007680 } else if (endptr - &exp->expr[exp->tok_pos[*tok_idx]] != exp->tok_len[*tok_idx]) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007681 LOGVAL(ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INTOK, "Unknown", &exp->expr[exp->tok_pos[*tok_idx]]);
7682 LOGVAL(ctx, LY_VLOG_LYD, set->cur_node, LYVE_XPATH, "Failed to convert \"%.*s\" into a long double.",
Michal Vasko69730152020-10-09 16:30:07 +02007683 exp->tok_len[*tok_idx], &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007684 return LY_EVALID;
7685 }
7686
7687 set_fill_number(set, num);
7688 }
7689
7690 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007691 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007692 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007693 return LY_SUCCESS;
7694}
7695
7696/**
7697 * @brief Evaluate PathExpr. Logs directly on error.
7698 *
Michal Vaskod3678892020-05-21 10:06:58 +02007699 * [12] PathExpr ::= LocationPath | PrimaryExpr Predicate*
Michal Vasko03ff5a72019-09-11 13:49:33 +02007700 * | PrimaryExpr Predicate* '/' RelativeLocationPath
7701 * | PrimaryExpr Predicate* '//' RelativeLocationPath
7702 * [2] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
Michal Vaskod3678892020-05-21 10:06:58 +02007703 * [10] PrimaryExpr ::= '(' Expr ')' | Literal | Number | FunctionCall
Michal Vasko03ff5a72019-09-11 13:49:33 +02007704 *
7705 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007706 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007707 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7708 * @param[in] options XPath options.
7709 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7710 */
7711static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02007712eval_path_expr(struct lyxp_expr *exp, uint16_t *tok_idx, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02007713{
Radek Krejci857189e2020-09-01 13:26:36 +02007714 ly_bool all_desc, parent_pos_pred;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007715 LY_ERR rc;
7716
Michal Vasko004d3152020-06-11 19:59:22 +02007717 switch (exp->tokens[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007718 case LYXP_TOKEN_PAR1:
7719 /* '(' Expr ')' */
7720
7721 /* '(' */
7722 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007723 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007724 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007725
7726 /* Expr */
Michal Vasko004d3152020-06-11 19:59:22 +02007727 rc = eval_expr_select(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007728 LY_CHECK_RET(rc);
7729
7730 /* ')' */
Michal Vasko004d3152020-06-11 19:59:22 +02007731 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007732 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 parent_pos_pred = 0;
7737 goto predicate;
7738
7739 case LYXP_TOKEN_DOT:
7740 case LYXP_TOKEN_DDOT:
7741 case LYXP_TOKEN_AT:
7742 case LYXP_TOKEN_NAMETEST:
7743 case LYXP_TOKEN_NODETYPE:
7744 /* RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02007745 rc = eval_relative_location_path(exp, tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007746 LY_CHECK_RET(rc);
7747 break;
7748
7749 case LYXP_TOKEN_FUNCNAME:
7750 /* FunctionCall */
7751 if (!set) {
Michal Vasko004d3152020-06-11 19:59:22 +02007752 rc = eval_function_call(exp, tok_idx, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007753 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007754 rc = eval_function_call(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007755 }
7756 LY_CHECK_RET(rc);
7757
7758 parent_pos_pred = 1;
7759 goto predicate;
7760
Michal Vasko3e48bf32020-06-01 08:39:07 +02007761 case LYXP_TOKEN_OPER_PATH:
7762 case LYXP_TOKEN_OPER_RPATH:
Michal Vasko03ff5a72019-09-11 13:49:33 +02007763 /* AbsoluteLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02007764 rc = eval_absolute_location_path(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007765 LY_CHECK_RET(rc);
7766 break;
7767
7768 case LYXP_TOKEN_LITERAL:
7769 /* Literal */
7770 if (!set || (options & LYXP_SCNODE_ALL)) {
7771 if (set) {
7772 set_scnode_clear_ctx(set);
7773 }
Michal Vasko004d3152020-06-11 19:59:22 +02007774 eval_literal(exp, tok_idx, NULL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007775 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007776 eval_literal(exp, tok_idx, set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007777 }
7778
7779 parent_pos_pred = 1;
7780 goto predicate;
7781
7782 case LYXP_TOKEN_NUMBER:
7783 /* Number */
7784 if (!set || (options & LYXP_SCNODE_ALL)) {
7785 if (set) {
7786 set_scnode_clear_ctx(set);
7787 }
Michal Vasko004d3152020-06-11 19:59:22 +02007788 rc = eval_number(NULL, exp, tok_idx, NULL);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007789 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02007790 rc = eval_number(set->ctx, exp, tok_idx, set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007791 }
7792 LY_CHECK_RET(rc);
7793
7794 parent_pos_pred = 1;
7795 goto predicate;
7796
7797 default:
Michal Vasko5d24f6c2020-10-13 13:49:06 +02007798 LOGVAL(set->ctx, LY_VLOG_LYD, set->cur_node, LY_VCODE_XP_INTOK, lyxp_print_token(exp->tokens[*tok_idx]),
Michal Vasko69730152020-10-09 16:30:07 +02007799 &exp->expr[exp->tok_pos[*tok_idx]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007800 return LY_EVALID;
7801 }
7802
7803 return LY_SUCCESS;
7804
7805predicate:
7806 /* Predicate* */
Michal Vasko004d3152020-06-11 19:59:22 +02007807 while (!lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_BRACK1)) {
7808 rc = eval_predicate(exp, tok_idx, set, options, parent_pos_pred);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007809 LY_CHECK_RET(rc);
7810 }
7811
7812 /* ('/' or '//') RelativeLocationPath */
Michal Vasko004d3152020-06-11 19:59:22 +02007813 if (!exp_check_token2(NULL, exp, *tok_idx, LYXP_TOKEN_OPER_PATH, LYXP_TOKEN_OPER_RPATH)) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007814
7815 /* evaluate '/' or '//' */
Michal Vasko004d3152020-06-11 19:59:22 +02007816 if (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007817 all_desc = 0;
7818 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02007819 all_desc = 1;
7820 }
7821
7822 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007823 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007824 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007825
Michal Vasko004d3152020-06-11 19:59:22 +02007826 rc = eval_relative_location_path(exp, tok_idx, all_desc, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007827 LY_CHECK_RET(rc);
7828 }
7829
7830 return LY_SUCCESS;
7831}
7832
7833/**
7834 * @brief Evaluate UnionExpr. Logs directly on error.
7835 *
Michal Vaskod3678892020-05-21 10:06:58 +02007836 * [20] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02007837 *
7838 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007839 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007840 * @param[in] repeat How many times this expression is repeated.
7841 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7842 * @param[in] options XPath options.
7843 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7844 */
7845static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02007846eval_union_expr(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 +02007847{
7848 LY_ERR rc = LY_SUCCESS;
7849 struct lyxp_set orig_set, set2;
7850 uint16_t i;
7851
7852 assert(repeat);
7853
7854 set_init(&orig_set, set);
7855 set_init(&set2, set);
7856
7857 set_fill_set(&orig_set, set);
7858
Michal Vasko004d3152020-06-11 19:59:22 +02007859 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007860 LY_CHECK_GOTO(rc, cleanup);
7861
7862 /* ('|' PathExpr)* */
7863 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02007864 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_UNI);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007865 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007866 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007867 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007868
7869 if (!set) {
Michal Vasko004d3152020-06-11 19:59:22 +02007870 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007871 LY_CHECK_GOTO(rc, cleanup);
7872 continue;
7873 }
7874
7875 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02007876 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNION, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007877 LY_CHECK_GOTO(rc, cleanup);
7878
7879 /* eval */
7880 if (options & LYXP_SCNODE_ALL) {
Michal Vaskoecd62de2019-11-13 12:35:11 +01007881 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007882 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007883 rc = moveto_union(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007884 LY_CHECK_GOTO(rc, cleanup);
7885 }
7886 }
7887
7888cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02007889 lyxp_set_free_content(&orig_set);
7890 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007891 return rc;
7892}
7893
7894/**
7895 * @brief Evaluate UnaryExpr. Logs directly on error.
7896 *
Michal Vaskod3678892020-05-21 10:06:58 +02007897 * [19] UnaryExpr ::= UnionExpr | '-' UnaryExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02007898 *
7899 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007900 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007901 * @param[in] repeat How many times this expression is repeated.
7902 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7903 * @param[in] options XPath options.
7904 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7905 */
7906static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02007907eval_unary_expr(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 +02007908{
7909 LY_ERR rc;
7910 uint16_t this_op, i;
7911
7912 assert(repeat);
7913
7914 /* ('-')+ */
Michal Vasko004d3152020-06-11 19:59:22 +02007915 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007916 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02007917 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 +02007918
7919 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007920 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007921 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007922 }
7923
Michal Vasko004d3152020-06-11 19:59:22 +02007924 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_UNARY, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007925 LY_CHECK_RET(rc);
7926
7927 if (set && (repeat % 2)) {
7928 if (options & LYXP_SCNODE_ALL) {
7929 warn_operands(set->ctx, set, NULL, 1, exp->expr, exp->tok_pos[this_op]);
7930 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007931 rc = moveto_op_math(set, NULL, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007932 LY_CHECK_RET(rc);
7933 }
7934 }
7935
7936 return LY_SUCCESS;
7937}
7938
7939/**
7940 * @brief Evaluate MultiplicativeExpr. Logs directly on error.
7941 *
Michal Vaskod3678892020-05-21 10:06:58 +02007942 * [18] MultiplicativeExpr ::= UnaryExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02007943 * | MultiplicativeExpr '*' UnaryExpr
7944 * | MultiplicativeExpr 'div' UnaryExpr
7945 * | MultiplicativeExpr 'mod' UnaryExpr
7946 *
7947 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02007948 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02007949 * @param[in] repeat How many times this expression is repeated.
7950 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
7951 * @param[in] options XPath options.
7952 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
7953 */
7954static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02007955eval_multiplicative_expr(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 +02007956{
7957 LY_ERR rc;
7958 uint16_t this_op;
7959 struct lyxp_set orig_set, set2;
7960 uint16_t i;
7961
7962 assert(repeat);
7963
7964 set_init(&orig_set, set);
7965 set_init(&set2, set);
7966
7967 set_fill_set(&orig_set, set);
7968
Michal Vasko004d3152020-06-11 19:59:22 +02007969 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007970 LY_CHECK_GOTO(rc, cleanup);
7971
7972 /* ('*' / 'div' / 'mod' UnaryExpr)* */
7973 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02007974 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02007975
Michal Vasko004d3152020-06-11 19:59:22 +02007976 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_MATH);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007977 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02007978 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02007979 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007980
7981 if (!set) {
Michal Vasko004d3152020-06-11 19:59:22 +02007982 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007983 LY_CHECK_GOTO(rc, cleanup);
7984 continue;
7985 }
7986
7987 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02007988 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_MULTIPLICATIVE, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007989 LY_CHECK_GOTO(rc, cleanup);
7990
7991 /* eval */
7992 if (options & LYXP_SCNODE_ALL) {
7993 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01007994 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007995 set_scnode_clear_ctx(set);
7996 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01007997 rc = moveto_op_math(set, &set2, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02007998 LY_CHECK_GOTO(rc, cleanup);
7999 }
8000 }
8001
8002cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008003 lyxp_set_free_content(&orig_set);
8004 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008005 return rc;
8006}
8007
8008/**
8009 * @brief Evaluate AdditiveExpr. Logs directly on error.
8010 *
Michal Vaskod3678892020-05-21 10:06:58 +02008011 * [17] AdditiveExpr ::= MultiplicativeExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008012 * | AdditiveExpr '+' MultiplicativeExpr
8013 * | AdditiveExpr '-' MultiplicativeExpr
8014 *
8015 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008016 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008017 * @param[in] repeat How many times this expression is repeated.
8018 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
8019 * @param[in] options XPath options.
8020 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8021 */
8022static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02008023eval_additive_expr(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 +02008024{
8025 LY_ERR rc;
8026 uint16_t this_op;
8027 struct lyxp_set orig_set, set2;
8028 uint16_t i;
8029
8030 assert(repeat);
8031
8032 set_init(&orig_set, set);
8033 set_init(&set2, set);
8034
8035 set_fill_set(&orig_set, set);
8036
Michal Vasko004d3152020-06-11 19:59:22 +02008037 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008038 LY_CHECK_GOTO(rc, cleanup);
8039
8040 /* ('+' / '-' MultiplicativeExpr)* */
8041 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008042 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008043
Michal Vasko004d3152020-06-11 19:59:22 +02008044 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_MATH);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008045 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02008046 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008047 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008048
8049 if (!set) {
Michal Vasko004d3152020-06-11 19:59:22 +02008050 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008051 LY_CHECK_GOTO(rc, cleanup);
8052 continue;
8053 }
8054
8055 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008056 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_ADDITIVE, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008057 LY_CHECK_GOTO(rc, cleanup);
8058
8059 /* eval */
8060 if (options & LYXP_SCNODE_ALL) {
8061 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008062 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008063 set_scnode_clear_ctx(set);
8064 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008065 rc = moveto_op_math(set, &set2, &exp->expr[exp->tok_pos[this_op]]);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008066 LY_CHECK_GOTO(rc, cleanup);
8067 }
8068 }
8069
8070cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008071 lyxp_set_free_content(&orig_set);
8072 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008073 return rc;
8074}
8075
8076/**
8077 * @brief Evaluate RelationalExpr. Logs directly on error.
8078 *
Michal Vaskod3678892020-05-21 10:06:58 +02008079 * [16] RelationalExpr ::= AdditiveExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008080 * | RelationalExpr '<' AdditiveExpr
8081 * | RelationalExpr '>' AdditiveExpr
8082 * | RelationalExpr '<=' AdditiveExpr
8083 * | RelationalExpr '>=' AdditiveExpr
8084 *
8085 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008086 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008087 * @param[in] repeat How many times this expression is repeated.
8088 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
8089 * @param[in] options XPath options.
8090 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8091 */
8092static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02008093eval_relational_expr(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 +02008094{
8095 LY_ERR rc;
8096 uint16_t this_op;
8097 struct lyxp_set orig_set, set2;
8098 uint16_t i;
8099
8100 assert(repeat);
8101
8102 set_init(&orig_set, set);
8103 set_init(&set2, set);
8104
8105 set_fill_set(&orig_set, set);
8106
Michal Vasko004d3152020-06-11 19:59:22 +02008107 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008108 LY_CHECK_GOTO(rc, cleanup);
8109
8110 /* ('<' / '>' / '<=' / '>=' AdditiveExpr)* */
8111 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008112 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008113
Michal Vasko004d3152020-06-11 19:59:22 +02008114 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_COMP);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008115 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02008116 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008117 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008118
8119 if (!set) {
Michal Vasko004d3152020-06-11 19:59:22 +02008120 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008121 LY_CHECK_GOTO(rc, cleanup);
8122 continue;
8123 }
8124
8125 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008126 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_RELATIONAL, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008127 LY_CHECK_GOTO(rc, cleanup);
8128
8129 /* eval */
8130 if (options & LYXP_SCNODE_ALL) {
8131 warn_operands(set->ctx, set, &set2, 1, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008132 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008133 set_scnode_clear_ctx(set);
8134 } else {
8135 rc = moveto_op_comp(set, &set2, &exp->expr[exp->tok_pos[this_op]], options);
8136 LY_CHECK_GOTO(rc, cleanup);
8137 }
8138 }
8139
8140cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008141 lyxp_set_free_content(&orig_set);
8142 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008143 return rc;
8144}
8145
8146/**
8147 * @brief Evaluate EqualityExpr. Logs directly on error.
8148 *
Michal Vaskod3678892020-05-21 10:06:58 +02008149 * [15] EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008150 * | EqualityExpr '!=' RelationalExpr
8151 *
8152 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008153 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008154 * @param[in] repeat How many times this expression is repeated.
8155 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
8156 * @param[in] options XPath options.
8157 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8158 */
8159static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02008160eval_equality_expr(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 +02008161{
8162 LY_ERR rc;
8163 uint16_t this_op;
8164 struct lyxp_set orig_set, set2;
8165 uint16_t i;
8166
8167 assert(repeat);
8168
8169 set_init(&orig_set, set);
8170 set_init(&set2, set);
8171
8172 set_fill_set(&orig_set, set);
8173
Michal Vasko004d3152020-06-11 19:59:22 +02008174 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008175 LY_CHECK_GOTO(rc, cleanup);
8176
8177 /* ('=' / '!=' RelationalExpr)* */
8178 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008179 this_op = *tok_idx;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008180
Michal Vasko004d3152020-06-11 19:59:22 +02008181 assert((exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL) || (exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_NEQUAL));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008182 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (set ? "parsed" : "skipped"),
Michal Vasko69730152020-10-09 16:30:07 +02008183 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008184 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008185
8186 if (!set) {
Michal Vasko004d3152020-06-11 19:59:22 +02008187 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008188 LY_CHECK_GOTO(rc, cleanup);
8189 continue;
8190 }
8191
8192 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008193 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_EQUALITY, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008194 LY_CHECK_GOTO(rc, cleanup);
8195
8196 /* eval */
8197 if (options & LYXP_SCNODE_ALL) {
8198 warn_operands(set->ctx, set, &set2, 0, exp->expr, exp->tok_pos[this_op - 1]);
Michal Vasko004d3152020-06-11 19:59:22 +02008199 warn_equality_value(exp, set, *tok_idx - 1, this_op - 1, *tok_idx - 1);
8200 warn_equality_value(exp, &set2, this_op - 1, this_op - 1, *tok_idx - 1);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008201 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008202 set_scnode_clear_ctx(set);
8203 } else {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008204 rc = moveto_op_comp(set, &set2, &exp->expr[exp->tok_pos[this_op]], options);
8205 LY_CHECK_GOTO(rc, cleanup);
8206 }
8207 }
8208
8209cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008210 lyxp_set_free_content(&orig_set);
8211 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008212 return rc;
8213}
8214
8215/**
8216 * @brief Evaluate AndExpr. Logs directly on error.
8217 *
Michal Vaskod3678892020-05-21 10:06:58 +02008218 * [14] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008219 *
8220 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008221 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008222 * @param[in] repeat How many times this expression is repeated.
8223 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
8224 * @param[in] options XPath options.
8225 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8226 */
8227static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02008228eval_and_expr(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 +02008229{
8230 LY_ERR rc;
8231 struct lyxp_set orig_set, set2;
8232 uint16_t i;
8233
8234 assert(repeat);
8235
8236 set_init(&orig_set, set);
8237 set_init(&set2, set);
8238
8239 set_fill_set(&orig_set, set);
8240
Michal Vasko004d3152020-06-11 19:59:22 +02008241 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008242 LY_CHECK_GOTO(rc, cleanup);
8243
8244 /* cast to boolean, we know that will be the final result */
8245 if (set && (options & LYXP_SCNODE_ALL)) {
8246 set_scnode_clear_ctx(set);
8247 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008248 lyxp_set_cast(set, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008249 }
8250
8251 /* ('and' EqualityExpr)* */
8252 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008253 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_LOG);
8254 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (!set || !set->val.bln ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02008255 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008256 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008257
8258 /* lazy evaluation */
Michal Vasko004d3152020-06-11 19:59:22 +02008259 if (!set || ((set->type == LYXP_SET_BOOLEAN) && !set->val.bln)) {
8260 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008261 LY_CHECK_GOTO(rc, cleanup);
8262 continue;
8263 }
8264
8265 set_fill_set(&set2, &orig_set);
Michal Vasko004d3152020-06-11 19:59:22 +02008266 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_AND, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008267 LY_CHECK_GOTO(rc, cleanup);
8268
8269 /* eval - just get boolean value actually */
8270 if (set->type == LYXP_SET_SCNODE_SET) {
8271 set_scnode_clear_ctx(&set2);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008272 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008273 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008274 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008275 set_fill_set(set, &set2);
8276 }
8277 }
8278
8279cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008280 lyxp_set_free_content(&orig_set);
8281 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008282 return rc;
8283}
8284
8285/**
8286 * @brief Evaluate OrExpr. Logs directly on error.
8287 *
Michal Vaskod3678892020-05-21 10:06:58 +02008288 * [13] OrExpr ::= AndExpr | OrExpr 'or' AndExpr
Michal Vasko03ff5a72019-09-11 13:49:33 +02008289 *
8290 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008291 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008292 * @param[in] repeat How many times this expression is repeated.
8293 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
8294 * @param[in] options XPath options.
8295 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8296 */
8297static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02008298eval_or_expr(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 +02008299{
8300 LY_ERR rc;
8301 struct lyxp_set orig_set, set2;
8302 uint16_t i;
8303
8304 assert(repeat);
8305
8306 set_init(&orig_set, set);
8307 set_init(&set2, set);
8308
8309 set_fill_set(&orig_set, set);
8310
Michal Vasko004d3152020-06-11 19:59:22 +02008311 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008312 LY_CHECK_GOTO(rc, cleanup);
8313
8314 /* cast to boolean, we know that will be the final result */
8315 if (set && (options & LYXP_SCNODE_ALL)) {
8316 set_scnode_clear_ctx(set);
8317 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008318 lyxp_set_cast(set, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008319 }
8320
8321 /* ('or' AndExpr)* */
8322 for (i = 0; i < repeat; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008323 assert(exp->tokens[*tok_idx] == LYXP_TOKEN_OPER_LOG);
8324 LOGDBG(LY_LDGXPATH, "%-27s %s %s[%u]", __func__, (!set || set->val.bln ? "skipped" : "parsed"),
Michal Vasko69730152020-10-09 16:30:07 +02008325 lyxp_print_token(exp->tokens[*tok_idx]), exp->tok_pos[*tok_idx]);
Michal Vasko004d3152020-06-11 19:59:22 +02008326 ++(*tok_idx);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008327
8328 /* lazy evaluation */
Michal Vasko004d3152020-06-11 19:59:22 +02008329 if (!set || ((set->type == LYXP_SET_BOOLEAN) && set->val.bln)) {
8330 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, NULL, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008331 LY_CHECK_GOTO(rc, cleanup);
8332 continue;
8333 }
8334
8335 set_fill_set(&set2, &orig_set);
8336 /* expr_type cound have been LYXP_EXPR_NONE in all these later calls (except for the first one),
8337 * but it does not matter */
Michal Vasko004d3152020-06-11 19:59:22 +02008338 rc = eval_expr_select(exp, tok_idx, LYXP_EXPR_OR, &set2, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008339 LY_CHECK_GOTO(rc, cleanup);
8340
8341 /* eval - just get boolean value actually */
8342 if (set->type == LYXP_SET_SCNODE_SET) {
8343 set_scnode_clear_ctx(&set2);
Michal Vaskoecd62de2019-11-13 12:35:11 +01008344 lyxp_set_scnode_merge(set, &set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008345 } else {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008346 lyxp_set_cast(&set2, LYXP_SET_BOOLEAN);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008347 set_fill_set(set, &set2);
8348 }
8349 }
8350
8351cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02008352 lyxp_set_free_content(&orig_set);
8353 lyxp_set_free_content(&set2);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008354 return rc;
8355}
8356
8357/**
Michal Vasko004d3152020-06-11 19:59:22 +02008358 * @brief Decide what expression is at the pointer @p tok_idx and evaluate it accordingly.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008359 *
8360 * @param[in] exp Parsed XPath expression.
Michal Vasko004d3152020-06-11 19:59:22 +02008361 * @param[in] tok_idx Position in the expression @p exp.
Michal Vasko03ff5a72019-09-11 13:49:33 +02008362 * @param[in] etype Expression type to evaluate.
8363 * @param[in,out] set Context and result set. On NULL the rule is only parsed.
8364 * @param[in] options XPath options.
8365 * @return LY_ERR (LY_EINCOMPLETE on unresolved when)
8366 */
8367static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02008368eval_expr_select(struct lyxp_expr *exp, uint16_t *tok_idx, enum lyxp_expr_type etype, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008369{
8370 uint16_t i, count;
8371 enum lyxp_expr_type next_etype;
8372 LY_ERR rc;
8373
8374 /* process operator repeats */
Michal Vasko004d3152020-06-11 19:59:22 +02008375 if (!exp->repeat[*tok_idx]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008376 next_etype = LYXP_EXPR_NONE;
8377 } else {
8378 /* find etype repeat */
Radek Krejci1e008d22020-08-17 11:37:37 +02008379 for (i = 0; exp->repeat[*tok_idx][i] > etype; ++i) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02008380
8381 /* select one-priority lower because etype expression called us */
8382 if (i) {
Michal Vasko004d3152020-06-11 19:59:22 +02008383 next_etype = exp->repeat[*tok_idx][i - 1];
Michal Vasko03ff5a72019-09-11 13:49:33 +02008384 /* count repeats for that expression */
Radek Krejci1e008d22020-08-17 11:37:37 +02008385 for (count = 0; i && exp->repeat[*tok_idx][i - 1] == next_etype; ++count, --i) {}
Michal Vasko03ff5a72019-09-11 13:49:33 +02008386 } else {
8387 next_etype = LYXP_EXPR_NONE;
8388 }
8389 }
8390
8391 /* decide what expression are we parsing based on the repeat */
8392 switch (next_etype) {
8393 case LYXP_EXPR_OR:
Michal Vasko004d3152020-06-11 19:59:22 +02008394 rc = eval_or_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008395 break;
8396 case LYXP_EXPR_AND:
Michal Vasko004d3152020-06-11 19:59:22 +02008397 rc = eval_and_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008398 break;
8399 case LYXP_EXPR_EQUALITY:
Michal Vasko004d3152020-06-11 19:59:22 +02008400 rc = eval_equality_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008401 break;
8402 case LYXP_EXPR_RELATIONAL:
Michal Vasko004d3152020-06-11 19:59:22 +02008403 rc = eval_relational_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008404 break;
8405 case LYXP_EXPR_ADDITIVE:
Michal Vasko004d3152020-06-11 19:59:22 +02008406 rc = eval_additive_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008407 break;
8408 case LYXP_EXPR_MULTIPLICATIVE:
Michal Vasko004d3152020-06-11 19:59:22 +02008409 rc = eval_multiplicative_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008410 break;
8411 case LYXP_EXPR_UNARY:
Michal Vasko004d3152020-06-11 19:59:22 +02008412 rc = eval_unary_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008413 break;
8414 case LYXP_EXPR_UNION:
Michal Vasko004d3152020-06-11 19:59:22 +02008415 rc = eval_union_expr(exp, tok_idx, count, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008416 break;
8417 case LYXP_EXPR_NONE:
Michal Vasko004d3152020-06-11 19:59:22 +02008418 rc = eval_path_expr(exp, tok_idx, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008419 break;
8420 default:
8421 LOGINT_RET(set->ctx);
8422 }
8423
8424 return rc;
8425}
8426
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008427/**
8428 * @brief Get root type.
8429 *
8430 * @param[in] ctx_node Context node.
8431 * @param[in] ctx_scnode Schema context node.
8432 * @param[in] options XPath options.
8433 * @return Root type.
8434 */
8435static enum lyxp_node_type
Radek Krejci1deb5be2020-08-26 16:43:36 +02008436lyxp_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 +01008437{
Michal Vasko6b26e742020-07-17 15:02:10 +02008438 const struct lysc_node *op;
8439
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008440 if (options & LYXP_SCNODE_ALL) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008441 /* schema */
Radek Krejci1e008d22020-08-17 11:37:37 +02008442 for (op = ctx_scnode; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
Michal Vasko6b26e742020-07-17 15:02:10 +02008443
8444 if (op || (options & LYXP_SCNODE)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008445 /* general root that can access everything */
8446 return LYXP_NODE_ROOT;
8447 } else if (!ctx_scnode || (ctx_scnode->flags & LYS_CONFIG_W)) {
8448 /* root context node can access only config data (because we said so, it is unspecified) */
8449 return LYXP_NODE_ROOT_CONFIG;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008450 }
Michal Vasko6b26e742020-07-17 15:02:10 +02008451 return LYXP_NODE_ROOT;
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008452 }
8453
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008454 /* data */
Michal Vasko6b26e742020-07-17 15:02:10 +02008455 op = ctx_node ? ctx_node->schema : NULL;
Michal Vaskod989ba02020-08-24 10:59:24 +02008456 for ( ; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
Michal Vasko6b26e742020-07-17 15:02:10 +02008457
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008458 if (op || !(options & LYXP_SCHEMA)) {
8459 /* general root that can access everything */
8460 return LYXP_NODE_ROOT;
8461 } else if (!ctx_node || (ctx_node->schema->flags & LYS_CONFIG_W)) {
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008462 /* root context node can access only config data (because we said so, it is unspecified) */
8463 return LYXP_NODE_ROOT_CONFIG;
8464 }
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008465 return LYXP_NODE_ROOT;
8466}
8467
Michal Vasko03ff5a72019-09-11 13:49:33 +02008468LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008469lyxp_eval(struct lyxp_expr *exp, const struct lys_module *cur_mod, LY_PREFIX_FORMAT format, void *prefix_data,
8470 const struct lyd_node *ctx_node, const struct lyd_node *tree, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008471{
Michal Vasko004d3152020-06-11 19:59:22 +02008472 uint16_t tok_idx = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008473 LY_ERR rc;
8474
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008475 LY_CHECK_ARG_RET(NULL, exp, set, LY_EINVAL);
8476 if (!cur_mod && ((format == LY_PREF_SCHEMA) || (format == LY_PREF_SCHEMA_RESOLVED))) {
8477 LOGARG(NULL, "Current module must be set if schema format is used.");
8478 return LY_EINVAL;
Michal Vasko004d3152020-06-11 19:59:22 +02008479 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02008480
8481 /* prepare set for evaluation */
Michal Vasko03ff5a72019-09-11 13:49:33 +02008482 memset(set, 0, sizeof *set);
Michal Vaskod3678892020-05-21 10:06:58 +02008483 set->type = LYXP_SET_NODE_SET;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008484 set->root_type = lyxp_get_root_type(ctx_node, NULL, options);
8485 set_insert_node(set, (struct lyd_node *)ctx_node, 0, ctx_node ? LYXP_NODE_ELEM : set->root_type, 0);
8486
8487 set->ctx = (struct ly_ctx *)(cur_mod ? cur_mod->ctx : (ctx_node ? LYD_CTX(ctx_node) : (tree ? LYD_CTX(tree) : NULL)));
8488 set->cur_node = ctx_node;
8489 for (set->context_op = ctx_node ? ctx_node->schema : NULL;
Radek Krejci0f969882020-08-21 16:56:47 +02008490 set->context_op && !(set->context_op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF));
8491 set->context_op = set->context_op->parent) {}
Michal Vaskof03ed032020-03-04 13:31:44 +01008492 set->tree = tree;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008493 set->cur_mod = cur_mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008494 set->format = format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008495 set->prefix_data = prefix_data;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008496
8497 /* evaluate */
Michal Vasko004d3152020-06-11 19:59:22 +02008498 rc = eval_expr_select(exp, &tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008499 if (rc != LY_SUCCESS) {
Michal Vaskod3678892020-05-21 10:06:58 +02008500 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008501 }
8502
Michal Vasko03ff5a72019-09-11 13:49:33 +02008503 return rc;
8504}
8505
8506#if 0
8507
8508/* full xml printing of set elements, not used currently */
8509
8510void
8511lyxp_set_print_xml(FILE *f, struct lyxp_set *set)
8512{
8513 uint32_t i;
8514 char *str_num;
8515 struct lyout out;
8516
8517 memset(&out, 0, sizeof out);
8518
8519 out.type = LYOUT_STREAM;
8520 out.method.f = f;
8521
8522 switch (set->type) {
8523 case LYXP_SET_EMPTY:
Michal Vasko5233e962020-08-14 14:26:20 +02008524 ly_print_(&out, "Empty XPath set\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008525 break;
8526 case LYXP_SET_BOOLEAN:
Michal Vasko5233e962020-08-14 14:26:20 +02008527 ly_print_(&out, "Boolean XPath set:\n");
8528 ly_print_(&out, "%s\n\n", set->value.bool ? "true" : "false");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008529 break;
8530 case LYXP_SET_STRING:
Michal Vasko5233e962020-08-14 14:26:20 +02008531 ly_print_(&out, "String XPath set:\n");
8532 ly_print_(&out, "\"%s\"\n\n", set->value.str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008533 break;
8534 case LYXP_SET_NUMBER:
Michal Vasko5233e962020-08-14 14:26:20 +02008535 ly_print_(&out, "Number XPath set:\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008536
8537 if (isnan(set->value.num)) {
8538 str_num = strdup("NaN");
8539 } else if ((set->value.num == 0) || (set->value.num == -0.0f)) {
8540 str_num = strdup("0");
8541 } else if (isinf(set->value.num) && !signbit(set->value.num)) {
8542 str_num = strdup("Infinity");
8543 } else if (isinf(set->value.num) && signbit(set->value.num)) {
8544 str_num = strdup("-Infinity");
8545 } else if ((long long)set->value.num == set->value.num) {
8546 if (asprintf(&str_num, "%lld", (long long)set->value.num) == -1) {
8547 str_num = NULL;
8548 }
8549 } else {
8550 if (asprintf(&str_num, "%03.1Lf", set->value.num) == -1) {
8551 str_num = NULL;
8552 }
8553 }
8554 if (!str_num) {
8555 LOGMEM;
8556 return;
8557 }
Michal Vasko5233e962020-08-14 14:26:20 +02008558 ly_print_(&out, "%s\n\n", str_num);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008559 free(str_num);
8560 break;
8561 case LYXP_SET_NODE_SET:
Michal Vasko5233e962020-08-14 14:26:20 +02008562 ly_print_(&out, "Node XPath set:\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008563
8564 for (i = 0; i < set->used; ++i) {
Michal Vasko5233e962020-08-14 14:26:20 +02008565 ly_print_(&out, "%d. ", i + 1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008566 switch (set->node_type[i]) {
8567 case LYXP_NODE_ROOT_ALL:
Michal Vasko5233e962020-08-14 14:26:20 +02008568 ly_print_(&out, "ROOT all\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008569 break;
8570 case LYXP_NODE_ROOT_CONFIG:
Michal Vasko5233e962020-08-14 14:26:20 +02008571 ly_print_(&out, "ROOT config\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008572 break;
8573 case LYXP_NODE_ROOT_STATE:
Michal Vasko5233e962020-08-14 14:26:20 +02008574 ly_print_(&out, "ROOT state\n\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008575 break;
8576 case LYXP_NODE_ROOT_NOTIF:
Michal Vasko5233e962020-08-14 14:26:20 +02008577 ly_print_(&out, "ROOT notification \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008578 break;
8579 case LYXP_NODE_ROOT_RPC:
Michal Vasko5233e962020-08-14 14:26:20 +02008580 ly_print_(&out, "ROOT rpc \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008581 break;
8582 case LYXP_NODE_ROOT_OUTPUT:
Michal Vasko5233e962020-08-14 14:26:20 +02008583 ly_print_(&out, "ROOT output \"%s\"\n\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008584 break;
8585 case LYXP_NODE_ELEM:
Michal Vasko5233e962020-08-14 14:26:20 +02008586 ly_print_(&out, "ELEM \"%s\"\n", set->value.nodes[i]->schema->name);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008587 xml_print_node(&out, 1, set->value.nodes[i], 1, LYP_FORMAT);
Michal Vasko5233e962020-08-14 14:26:20 +02008588 ly_print_(&out, "\n");
Michal Vasko03ff5a72019-09-11 13:49:33 +02008589 break;
8590 case LYXP_NODE_TEXT:
Michal Vasko5233e962020-08-14 14:26:20 +02008591 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 +02008592 break;
8593 case LYXP_NODE_ATTR:
Michal Vasko5233e962020-08-14 14:26:20 +02008594 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 +02008595 break;
8596 }
8597 }
8598 break;
8599 }
8600}
8601
8602#endif
8603
8604LY_ERR
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008605lyxp_set_cast(struct lyxp_set *set, enum lyxp_set_type target)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008606{
8607 long double num;
8608 char *str;
8609 LY_ERR rc;
8610
8611 if (!set || (set->type == target)) {
8612 return LY_SUCCESS;
8613 }
8614
8615 /* it's not possible to convert anything into a node set */
Michal Vaskod3678892020-05-21 10:06:58 +02008616 assert(target != LYXP_SET_NODE_SET);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008617
8618 if (set->type == LYXP_SET_SCNODE_SET) {
Michal Vaskod3678892020-05-21 10:06:58 +02008619 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008620 return LY_EINVAL;
8621 }
8622
8623 /* to STRING */
Michal Vaskod3678892020-05-21 10:06:58 +02008624 if ((target == LYXP_SET_STRING) || ((target == LYXP_SET_NUMBER) && (set->type == LYXP_SET_NODE_SET))) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008625 switch (set->type) {
8626 case LYXP_SET_NUMBER:
8627 if (isnan(set->val.num)) {
8628 set->val.str = strdup("NaN");
8629 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
8630 } else if ((set->val.num == 0) || (set->val.num == -0.0f)) {
8631 set->val.str = strdup("0");
8632 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
8633 } else if (isinf(set->val.num) && !signbit(set->val.num)) {
8634 set->val.str = strdup("Infinity");
8635 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
8636 } else if (isinf(set->val.num) && signbit(set->val.num)) {
8637 set->val.str = strdup("-Infinity");
8638 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), -1);
8639 } else if ((long long)set->val.num == set->val.num) {
8640 if (asprintf(&str, "%lld", (long long)set->val.num) == -1) {
8641 LOGMEM_RET(set->ctx);
8642 }
8643 set->val.str = str;
8644 } else {
8645 if (asprintf(&str, "%03.1Lf", set->val.num) == -1) {
8646 LOGMEM_RET(set->ctx);
8647 }
8648 set->val.str = str;
8649 }
8650 break;
8651 case LYXP_SET_BOOLEAN:
Michal Vasko004d3152020-06-11 19:59:22 +02008652 if (set->val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008653 set->val.str = strdup("true");
8654 } else {
8655 set->val.str = strdup("false");
8656 }
8657 LY_CHECK_ERR_RET(!set->val.str, LOGMEM(set->ctx), LY_EMEM);
8658 break;
8659 case LYXP_SET_NODE_SET:
8660 assert(set->used);
8661
8662 /* we need the set sorted, it affects the result */
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008663 assert(!set_sort(set));
Michal Vasko03ff5a72019-09-11 13:49:33 +02008664
Michal Vasko5e0e6eb2019-11-06 15:47:50 +01008665 rc = cast_node_set_to_string(set, &str);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008666 LY_CHECK_RET(rc);
Michal Vaskod3678892020-05-21 10:06:58 +02008667 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008668 set->val.str = str;
8669 break;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008670 default:
8671 LOGINT_RET(set->ctx);
8672 }
8673 set->type = LYXP_SET_STRING;
8674 }
8675
8676 /* to NUMBER */
8677 if (target == LYXP_SET_NUMBER) {
8678 switch (set->type) {
8679 case LYXP_SET_STRING:
8680 num = cast_string_to_number(set->val.str);
Michal Vaskod3678892020-05-21 10:06:58 +02008681 lyxp_set_free_content(set);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008682 set->val.num = num;
8683 break;
8684 case LYXP_SET_BOOLEAN:
Michal Vasko004d3152020-06-11 19:59:22 +02008685 if (set->val.bln) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02008686 set->val.num = 1;
8687 } else {
8688 set->val.num = 0;
8689 }
8690 break;
8691 default:
8692 LOGINT_RET(set->ctx);
8693 }
8694 set->type = LYXP_SET_NUMBER;
8695 }
8696
8697 /* to BOOLEAN */
8698 if (target == LYXP_SET_BOOLEAN) {
8699 switch (set->type) {
8700 case LYXP_SET_NUMBER:
8701 if ((set->val.num == 0) || (set->val.num == -0.0f) || isnan(set->val.num)) {
Michal Vasko004d3152020-06-11 19:59:22 +02008702 set->val.bln = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008703 } else {
Michal Vasko004d3152020-06-11 19:59:22 +02008704 set->val.bln = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008705 }
8706 break;
8707 case LYXP_SET_STRING:
8708 if (set->val.str[0]) {
Michal Vaskod3678892020-05-21 10:06:58 +02008709 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02008710 set->val.bln = 1;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008711 } else {
Michal Vaskod3678892020-05-21 10:06:58 +02008712 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02008713 set->val.bln = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008714 }
8715 break;
8716 case LYXP_SET_NODE_SET:
Michal Vaskod3678892020-05-21 10:06:58 +02008717 if (set->used) {
8718 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02008719 set->val.bln = 1;
Michal Vaskod3678892020-05-21 10:06:58 +02008720 } else {
8721 lyxp_set_free_content(set);
Michal Vasko004d3152020-06-11 19:59:22 +02008722 set->val.bln = 0;
Michal Vaskod3678892020-05-21 10:06:58 +02008723 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02008724 break;
8725 default:
8726 LOGINT_RET(set->ctx);
8727 }
8728 set->type = LYXP_SET_BOOLEAN;
8729 }
8730
Michal Vasko03ff5a72019-09-11 13:49:33 +02008731 return LY_SUCCESS;
8732}
8733
8734LY_ERR
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008735lyxp_atomize(struct lyxp_expr *exp, const struct lys_module *cur_mod, LY_PREFIX_FORMAT format, void *prefix_data,
8736 const struct lysc_node *ctx_scnode, struct lyxp_set *set, uint32_t options)
Michal Vasko03ff5a72019-09-11 13:49:33 +02008737{
Michal Vasko004d3152020-06-11 19:59:22 +02008738 uint16_t tok_idx = 0;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008739
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008740 LY_CHECK_ARG_RET(NULL, exp, set, LY_EINVAL);
8741 if (!cur_mod && ((format == LY_PREF_SCHEMA) || (format == LY_PREF_SCHEMA_RESOLVED))) {
8742 LOGARG(NULL, "Current module must be set if schema format is used.");
8743 return LY_EINVAL;
Michal Vasko004d3152020-06-11 19:59:22 +02008744 }
Michal Vasko03ff5a72019-09-11 13:49:33 +02008745
8746 /* prepare set for evaluation */
Michal Vasko03ff5a72019-09-11 13:49:33 +02008747 memset(set, 0, sizeof *set);
8748 set->type = LYXP_SET_SCNODE_SET;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008749 set->root_type = lyxp_get_root_type(NULL, ctx_scnode, options);
8750 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, ctx_scnode, ctx_scnode ? LYXP_NODE_ELEM : set->root_type, NULL));
Michal Vasko5c4e5892019-11-14 12:31:38 +01008751 set->val.scnodes[0].in_ctx = -2;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008752
8753 set->ctx = cur_mod ? cur_mod->ctx : (ctx_scnode ? ctx_scnode->module->ctx : NULL);
8754 set->cur_scnode = ctx_scnode;
Michal Vasko6b26e742020-07-17 15:02:10 +02008755 for (set->context_op = ctx_scnode;
Radek Krejci0f969882020-08-21 16:56:47 +02008756 set->context_op && !(set->context_op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF));
8757 set->context_op = set->context_op->parent) {}
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008758 set->cur_mod = cur_mod;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008759 set->format = format;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02008760 set->prefix_data = prefix_data;
Michal Vasko03ff5a72019-09-11 13:49:33 +02008761
8762 /* evaluate */
Michal Vasko004d3152020-06-11 19:59:22 +02008763 return eval_expr_select(exp, &tok_idx, 0, set, options);
Michal Vasko03ff5a72019-09-11 13:49:33 +02008764}
Michal Vaskod43d71a2020-08-07 14:54:58 +02008765
8766API const char *
8767lyxp_get_expr(const struct lyxp_expr *path)
8768{
8769 if (!path) {
8770 return NULL;
8771 }
8772
8773 return path->expr;
8774}