blob: d454a2aa2db5002dd3f6c2b359f28691bdeec772 [file] [log] [blame]
Radek Krejci19a96102018-11-15 13:38:09 +01001/**
2 * @file tree_schema.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief Schema tree implementation
5 *
6 * Copyright (c) 2015 - 2018 CESNET, z.s.p.o.
7 *
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 */
14
Radek Krejci535ea9f2020-05-29 16:01:05 +020015#define _GNU_SOURCE
Radek Krejci19a96102018-11-15 13:38:09 +010016
Radek Krejcie7b95092019-05-15 11:03:07 +020017#include <assert.h>
Radek Krejci19a96102018-11-15 13:38:09 +010018#include <ctype.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020019#include <stddef.h>
20#include <stdint.h>
Radek Krejci19a96102018-11-15 13:38:09 +010021#include <stdio.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020022#include <stdlib.h>
23#include <string.h>
Radek Krejci19a96102018-11-15 13:38:09 +010024
Radek Krejci535ea9f2020-05-29 16:01:05 +020025#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020026#include "compat.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020027#include "context.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020028#include "dict.h"
29#include "log.h"
Michal Vasko004d3152020-06-11 19:59:22 +020030#include "path.h"
Radek Krejcif0e1ba52020-05-22 15:14:35 +020031#include "parser.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020032#include "parser_schema.h"
Radek Krejci0935f412019-08-20 16:15:18 +020033#include "plugins_exts.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020034#include "plugins_types.h"
Radek Krejci0935f412019-08-20 16:15:18 +020035#include "plugins_exts_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020036#include "set.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020037#include "tree.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020038#include "tree_data.h"
Michal Vasko7c8439f2020-08-05 13:25:19 +020039#include "tree_data_internal.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020040#include "tree_schema.h"
Radek Krejci19a96102018-11-15 13:38:09 +010041#include "tree_schema_internal.h"
42#include "xpath.h"
43
Michal Vasko5fe75f12020-03-02 13:52:37 +010044static LY_ERR lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext,
45 void *parent, LYEXT_PARENT parent_type, const struct lys_module *ext_mod);
46
Radek Krejci19a96102018-11-15 13:38:09 +010047/**
48 * @brief Duplicate string into dictionary
49 * @param[in] CTX libyang context of the dictionary.
50 * @param[in] ORIG String to duplicate.
51 * @param[out] DUP Where to store the result.
52 */
53#define DUP_STRING(CTX, ORIG, DUP) if (ORIG) {DUP = lydict_insert(CTX, ORIG, 0);}
54
Radek Krejciec4da802019-05-02 13:02:41 +020055#define COMPILE_ARRAY_GOTO(CTX, ARRAY_P, ARRAY_C, ITER, FUNC, RET, GOTO) \
Radek Krejci19a96102018-11-15 13:38:09 +010056 if (ARRAY_P) { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +020057 LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, LY_ARRAY_COUNT(ARRAY_P), RET, GOTO); \
58 LY_ARRAY_COUNT_TYPE __array_offset = LY_ARRAY_COUNT(ARRAY_C); \
59 for (ITER = 0; ITER < LY_ARRAY_COUNT(ARRAY_P); ++ITER) { \
Radek Krejci19a96102018-11-15 13:38:09 +010060 LY_ARRAY_INCREMENT(ARRAY_C); \
Radek Krejciec4da802019-05-02 13:02:41 +020061 RET = FUNC(CTX, &(ARRAY_P)[ITER], &(ARRAY_C)[ITER + __array_offset]); \
Radek Krejcid05cbd92018-12-05 14:26:40 +010062 LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
63 } \
64 }
65
Radek Krejciec4da802019-05-02 13:02:41 +020066#define COMPILE_ARRAY1_GOTO(CTX, ARRAY_P, ARRAY_C, PARENT, ITER, FUNC, USES_STATUS, RET, GOTO) \
Radek Krejci6eeb58f2019-02-22 16:29:37 +010067 if (ARRAY_P) { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +020068 LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, LY_ARRAY_COUNT(ARRAY_P), RET, GOTO); \
69 LY_ARRAY_COUNT_TYPE __array_offset = LY_ARRAY_COUNT(ARRAY_C); \
70 for (ITER = 0; ITER < LY_ARRAY_COUNT(ARRAY_P); ++ITER) { \
Radek Krejci6eeb58f2019-02-22 16:29:37 +010071 LY_ARRAY_INCREMENT(ARRAY_C); \
Radek Krejciec4da802019-05-02 13:02:41 +020072 RET = FUNC(CTX, &(ARRAY_P)[ITER], PARENT, &(ARRAY_C)[ITER + __array_offset], USES_STATUS); \
Radek Krejci6eeb58f2019-02-22 16:29:37 +010073 LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
74 } \
75 }
76
Radek Krejci0935f412019-08-20 16:15:18 +020077#define COMPILE_EXTS_GOTO(CTX, EXTS_P, EXT_C, PARENT, PARENT_TYPE, RET, GOTO) \
78 if (EXTS_P) { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +020079 LY_ARRAY_CREATE_GOTO((CTX)->ctx, EXT_C, LY_ARRAY_COUNT(EXTS_P), RET, GOTO); \
80 for (LY_ARRAY_COUNT_TYPE __exts_iter = 0, __array_offset = LY_ARRAY_COUNT(EXT_C); __exts_iter < LY_ARRAY_COUNT(EXTS_P); ++__exts_iter) { \
Radek Krejci0935f412019-08-20 16:15:18 +020081 LY_ARRAY_INCREMENT(EXT_C); \
Michal Vasko8d544252020-03-02 10:19:52 +010082 RET = lys_compile_ext(CTX, &(EXTS_P)[__exts_iter], &(EXT_C)[__exts_iter + __array_offset], PARENT, PARENT_TYPE, NULL); \
Radek Krejci0935f412019-08-20 16:15:18 +020083 LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
84 } \
85 }
86
Radek Krejciec4da802019-05-02 13:02:41 +020087#define COMPILE_ARRAY_UNIQUE_GOTO(CTX, ARRAY_P, ARRAY_C, ITER, FUNC, RET, GOTO) \
Radek Krejcid05cbd92018-12-05 14:26:40 +010088 if (ARRAY_P) { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +020089 LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, LY_ARRAY_COUNT(ARRAY_P), RET, GOTO); \
90 LY_ARRAY_COUNT_TYPE __array_offset = LY_ARRAY_COUNT(ARRAY_C); \
91 for (ITER = 0; ITER < LY_ARRAY_COUNT(ARRAY_P); ++ITER) { \
Radek Krejcid05cbd92018-12-05 14:26:40 +010092 LY_ARRAY_INCREMENT(ARRAY_C); \
Radek Krejciec4da802019-05-02 13:02:41 +020093 RET = FUNC(CTX, &(ARRAY_P)[ITER], ARRAY_C, &(ARRAY_C)[ITER + __array_offset]); \
Radek Krejci19a96102018-11-15 13:38:09 +010094 LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
95 } \
96 }
97
Radek Krejciec4da802019-05-02 13:02:41 +020098#define COMPILE_MEMBER_GOTO(CTX, MEMBER_P, MEMBER_C, FUNC, RET, GOTO) \
Radek Krejci19a96102018-11-15 13:38:09 +010099 if (MEMBER_P) { \
100 MEMBER_C = calloc(1, sizeof *(MEMBER_C)); \
101 LY_CHECK_ERR_GOTO(!(MEMBER_C), LOGMEM((CTX)->ctx); RET = LY_EMEM, GOTO); \
Radek Krejciec4da802019-05-02 13:02:41 +0200102 RET = FUNC(CTX, MEMBER_P, MEMBER_C); \
Radek Krejci19a96102018-11-15 13:38:09 +0100103 LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
104 }
105
Radek Krejciec4da802019-05-02 13:02:41 +0200106#define COMPILE_MEMBER_ARRAY_GOTO(CTX, MEMBER_P, ARRAY_C, FUNC, RET, GOTO) \
Radek Krejci00b874b2019-02-12 10:54:50 +0100107 if (MEMBER_P) { \
108 LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, 1, RET, GOTO); \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200109 LY_ARRAY_COUNT_TYPE __array_offset = LY_ARRAY_COUNT(ARRAY_C); \
Radek Krejci00b874b2019-02-12 10:54:50 +0100110 LY_ARRAY_INCREMENT(ARRAY_C); \
Radek Krejciec4da802019-05-02 13:02:41 +0200111 RET = FUNC(CTX, MEMBER_P, &(ARRAY_C)[__array_offset]); \
Radek Krejci00b874b2019-02-12 10:54:50 +0100112 LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
113 }
114
Michal Vasko6f4cbb62020-02-28 11:15:47 +0100115#define COMPILE_CHECK_UNIQUENESS_ARRAY(CTX, ARRAY, MEMBER, EXCL, STMT, IDENT) \
Radek Krejcid05cbd92018-12-05 14:26:40 +0100116 if (ARRAY) { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200117 for (LY_ARRAY_COUNT_TYPE u__ = 0; u__ < LY_ARRAY_COUNT(ARRAY); ++u__) { \
Radek Krejci0af46292019-01-11 16:02:31 +0100118 if (&(ARRAY)[u__] != EXCL && (void*)((ARRAY)[u__].MEMBER) == (void*)(IDENT)) { \
Radek Krejcid05cbd92018-12-05 14:26:40 +0100119 LOGVAL((CTX)->ctx, LY_VLOG_STR, (CTX)->path, LY_VCODE_DUPIDENT, IDENT, STMT); \
120 return LY_EVALID; \
121 } \
122 } \
123 }
124
Michal Vasko6f4cbb62020-02-28 11:15:47 +0100125#define COMPILE_CHECK_UNIQUENESS_PARRAY(CTX, ARRAY, MEMBER, EXCL, STMT, IDENT) \
126 if (ARRAY) { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200127 for (LY_ARRAY_COUNT_TYPE u__ = 0; u__ < LY_ARRAY_COUNT(ARRAY); ++u__) { \
Michal Vasko6f4cbb62020-02-28 11:15:47 +0100128 if (&(ARRAY)[u__] != EXCL && (void*)((ARRAY)[u__]->MEMBER) == (void*)(IDENT)) { \
129 LOGVAL((CTX)->ctx, LY_VLOG_STR, (CTX)->path, LY_VCODE_DUPIDENT, IDENT, STMT); \
130 return LY_EVALID; \
131 } \
132 } \
133 }
134
135struct lysc_ext *
136lysc_ext_dup(struct lysc_ext *orig)
137{
138 ++orig->refcount;
139 return orig;
140}
141
Radek Krejci19a96102018-11-15 13:38:09 +0100142static struct lysc_ext_instance *
143lysc_ext_instance_dup(struct ly_ctx *ctx, struct lysc_ext_instance *orig)
144{
Michal Vasko6f4cbb62020-02-28 11:15:47 +0100145 /* TODO - extensions, increase refcount */
Radek Krejci19a96102018-11-15 13:38:09 +0100146 (void) ctx;
147 (void) orig;
148 return NULL;
149}
150
Radek Krejcib56c7502019-02-13 14:19:54 +0100151/**
Radek Krejci474f9b82019-07-24 11:36:37 +0200152 * @brief Add record into the compile context's list of incomplete default values.
153 * @param[in] ctx Compile context with the incomplete default values list.
154 * @param[in] context_node Context schema node to store in the record.
155 * @param[in] dflt Incomplete default value to store in the record.
156 * @param[in] dflt_mod Module of the default value definition to store in the record.
157 * @return LY_EMEM in case of memory allocation failure.
158 * @return LY_SUCCESS
159 */
160static LY_ERR
161lysc_incomplete_dflts_add(struct lysc_ctx *ctx, struct lysc_node *context_node, struct lyd_value *dflt, struct lys_module *dflt_mod)
162{
163 struct lysc_incomplete_dflt *r;
164 r = malloc(sizeof *r);
165 LY_CHECK_ERR_RET(!r, LOGMEM(ctx->ctx), LY_EMEM);
166 r->context_node = context_node;
167 r->dflt = dflt;
168 r->dflt_mod = dflt_mod;
169 ly_set_add(&ctx->dflts, r, LY_SET_OPT_USEASLIST);
170
171 return LY_SUCCESS;
172}
173
174/**
175 * @brief Remove record of the given default value from the compile context's list of incomplete default values.
176 * @param[in] ctx Compile context with the incomplete default values list.
177 * @param[in] dflt Incomplete default values identifying the record to remove.
178 */
179static void
180lysc_incomplete_dflts_remove(struct lysc_ctx *ctx, struct lyd_value *dflt)
181{
182 unsigned int u;
183 struct lysc_incomplete_dflt *r;
184
185 for (u = 0; u < ctx->dflts.count; ++u) {
186 r = (struct lysc_incomplete_dflt*)ctx->dflts.objs[u];
187 if (r->dflt == dflt) {
188 free(ctx->dflts.objs[u]);
189 memmove(&ctx->dflts.objs[u], &ctx->dflts.objs[u + 1], (ctx->dflts.count - (u + 1)) * sizeof *ctx->dflts.objs);
190 --ctx->dflts.count;
191 return;
192 }
193 }
194}
195
Radek Krejci0e59c312019-08-15 15:34:15 +0200196void
Radek Krejci327de162019-06-14 12:52:07 +0200197lysc_update_path(struct lysc_ctx *ctx, struct lysc_node *parent, const char *name)
198{
199 int len;
200 int nextlevel = 0; /* 0 - no starttag, 1 - '/' starttag, 2 - '=' starttag + '}' endtag */
201
202 if (!name) {
203 /* removing last path segment */
204 if (ctx->path[ctx->path_len - 1] == '}') {
205 for (; ctx->path[ctx->path_len] != '=' && ctx->path[ctx->path_len] != '{'; --ctx->path_len);
206 if (ctx->path[ctx->path_len] == '=') {
207 ctx->path[ctx->path_len++] = '}';
208 } else {
209 /* not a top-level special tag, remove also preceiding '/' */
210 goto remove_nodelevel;
211 }
212 } else {
213remove_nodelevel:
214 for (; ctx->path[ctx->path_len] != '/' ; --ctx->path_len);
215 if (ctx->path_len == 0) {
216 /* top-level (last segment) */
Radek Krejciacc79042019-07-25 14:14:57 +0200217 ctx->path_len = 1;
Radek Krejci327de162019-06-14 12:52:07 +0200218 }
219 }
220 /* set new terminating NULL-byte */
221 ctx->path[ctx->path_len] = '\0';
222 } else {
223 if (ctx->path_len > 1) {
224 if (!parent && ctx->path[ctx->path_len - 1] == '}' && ctx->path[ctx->path_len - 2] != '\'') {
225 /* extension of the special tag */
226 nextlevel = 2;
227 --ctx->path_len;
228 } else {
229 /* there is already some path, so add next level */
230 nextlevel = 1;
231 }
232 } /* else the path is just initiated with '/', so do not add additional slash in case of top-level nodes */
233
234 if (nextlevel != 2) {
235 if ((parent && parent->module == ctx->mod) || (!parent && ctx->path_len > 1 && name[0] == '{')) {
236 /* module not changed, print the name unprefixed */
Radek Krejci70ee9152019-07-25 11:27:27 +0200237 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s", nextlevel ? "/" : "", name);
Radek Krejci327de162019-06-14 12:52:07 +0200238 } else {
Radek Krejci70ee9152019-07-25 11:27:27 +0200239 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s:%s", nextlevel ? "/" : "", ctx->mod->name, name);
Radek Krejci327de162019-06-14 12:52:07 +0200240 }
241 } else {
Radek Krejci70ee9152019-07-25 11:27:27 +0200242 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "='%s'}", name);
Radek Krejci327de162019-06-14 12:52:07 +0200243 }
Radek Krejciacc79042019-07-25 14:14:57 +0200244 if (len >= LYSC_CTX_BUFSIZE - ctx->path_len) {
245 /* output truncated */
246 ctx->path_len = LYSC_CTX_BUFSIZE - 1;
247 } else {
248 ctx->path_len += len;
249 }
Radek Krejci327de162019-06-14 12:52:07 +0200250 }
251}
252
253/**
Radek Krejcib56c7502019-02-13 14:19:54 +0100254 * @brief Duplicate the compiled pattern structure.
255 *
256 * Instead of duplicating memory, the reference counter in the @p orig is increased.
257 *
258 * @param[in] orig The pattern structure to duplicate.
259 * @return The duplicated structure to use.
260 */
Radek Krejci19a96102018-11-15 13:38:09 +0100261static struct lysc_pattern*
262lysc_pattern_dup(struct lysc_pattern *orig)
263{
264 ++orig->refcount;
265 return orig;
266}
267
Radek Krejcib56c7502019-02-13 14:19:54 +0100268/**
269 * @brief Duplicate the array of compiled patterns.
270 *
271 * The sized array itself is duplicated, but the pattern structures are just shadowed by increasing their reference counter.
272 *
273 * @param[in] ctx Libyang context for logging.
274 * @param[in] orig The patterns sized array to duplicate.
275 * @return New sized array as a copy of @p orig.
276 * @return NULL in case of memory allocation error.
277 */
Radek Krejci19a96102018-11-15 13:38:09 +0100278static struct lysc_pattern**
279lysc_patterns_dup(struct ly_ctx *ctx, struct lysc_pattern **orig)
280{
Radek Krejcid05cbd92018-12-05 14:26:40 +0100281 struct lysc_pattern **dup = NULL;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200282 LY_ARRAY_COUNT_TYPE u;
Radek Krejci19a96102018-11-15 13:38:09 +0100283
Radek Krejcib56c7502019-02-13 14:19:54 +0100284 assert(orig);
285
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200286 LY_ARRAY_CREATE_RET(ctx, dup, LY_ARRAY_COUNT(orig), NULL);
Radek Krejci19a96102018-11-15 13:38:09 +0100287 LY_ARRAY_FOR(orig, u) {
288 dup[u] = lysc_pattern_dup(orig[u]);
289 LY_ARRAY_INCREMENT(dup);
290 }
291 return dup;
292}
293
Radek Krejcib56c7502019-02-13 14:19:54 +0100294/**
295 * @brief Duplicate compiled range structure.
296 *
297 * @param[in] ctx Libyang context for logging.
298 * @param[in] orig The range structure to be duplicated.
299 * @return New compiled range structure as a copy of @p orig.
300 * @return NULL in case of memory allocation error.
301 */
Radek Krejci19a96102018-11-15 13:38:09 +0100302struct lysc_range*
303lysc_range_dup(struct ly_ctx *ctx, const struct lysc_range *orig)
304{
305 struct lysc_range *dup;
306 LY_ERR ret;
307
Radek Krejcib56c7502019-02-13 14:19:54 +0100308 assert(orig);
309
Radek Krejci19a96102018-11-15 13:38:09 +0100310 dup = calloc(1, sizeof *dup);
311 LY_CHECK_ERR_RET(!dup, LOGMEM(ctx), NULL);
312 if (orig->parts) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200313 LY_ARRAY_CREATE_GOTO(ctx, dup->parts, LY_ARRAY_COUNT(orig->parts), ret, cleanup);
314 LY_ARRAY_COUNT(dup->parts) = LY_ARRAY_COUNT(orig->parts);
315 memcpy(dup->parts, orig->parts, LY_ARRAY_COUNT(dup->parts) * sizeof *dup->parts);
Radek Krejci19a96102018-11-15 13:38:09 +0100316 }
317 DUP_STRING(ctx, orig->eapptag, dup->eapptag);
318 DUP_STRING(ctx, orig->emsg, dup->emsg);
319 dup->exts = lysc_ext_instance_dup(ctx, orig->exts);
320
321 return dup;
322cleanup:
323 free(dup);
324 (void) ret; /* set but not used due to the return type */
325 return NULL;
326}
327
Radek Krejcib56c7502019-02-13 14:19:54 +0100328/**
329 * @brief Stack for processing if-feature expressions.
330 */
Radek Krejci19a96102018-11-15 13:38:09 +0100331struct iff_stack {
Radek Krejcib56c7502019-02-13 14:19:54 +0100332 int size; /**< number of items in the stack */
333 int index; /**< first empty item */
334 uint8_t *stack;/**< stack - array of @ref ifftokens to create the if-feature expression in prefix format */
Radek Krejci19a96102018-11-15 13:38:09 +0100335};
336
Radek Krejcib56c7502019-02-13 14:19:54 +0100337/**
338 * @brief Add @ref ifftokens into the stack.
339 * @param[in] stack The if-feature stack to use.
340 * @param[in] value One of the @ref ifftokens to store in the stack.
341 * @return LY_EMEM in case of memory allocation error
342 * @return LY_ESUCCESS if the value successfully stored.
343 */
Radek Krejci19a96102018-11-15 13:38:09 +0100344static LY_ERR
345iff_stack_push(struct iff_stack *stack, uint8_t value)
346{
347 if (stack->index == stack->size) {
348 stack->size += 4;
349 stack->stack = ly_realloc(stack->stack, stack->size * sizeof *stack->stack);
350 LY_CHECK_ERR_RET(!stack->stack, LOGMEM(NULL); stack->size = 0, LY_EMEM);
351 }
352 stack->stack[stack->index++] = value;
353 return LY_SUCCESS;
354}
355
Radek Krejcib56c7502019-02-13 14:19:54 +0100356/**
357 * @brief Get (and remove) the last item form the stack.
358 * @param[in] stack The if-feature stack to use.
359 * @return The value from the top of the stack.
360 */
Radek Krejci19a96102018-11-15 13:38:09 +0100361static uint8_t
362iff_stack_pop(struct iff_stack *stack)
363{
Radek Krejcib56c7502019-02-13 14:19:54 +0100364 assert(stack && stack->index);
365
Radek Krejci19a96102018-11-15 13:38:09 +0100366 stack->index--;
367 return stack->stack[stack->index];
368}
369
Radek Krejcib56c7502019-02-13 14:19:54 +0100370/**
371 * @brief Clean up the stack.
372 * @param[in] stack The if-feature stack to use.
373 */
Radek Krejci19a96102018-11-15 13:38:09 +0100374static void
375iff_stack_clean(struct iff_stack *stack)
376{
377 stack->size = 0;
378 free(stack->stack);
379}
380
Radek Krejcib56c7502019-02-13 14:19:54 +0100381/**
382 * @brief Store the @ref ifftokens (@p op) on the given position in the 2bits array
383 * (libyang format of the if-feature expression).
384 * @param[in,out] list The 2bits array to modify.
385 * @param[in] op The operand (@ref ifftokens) to store.
386 * @param[in] pos Position (0-based) where to store the given @p op.
387 */
Radek Krejci19a96102018-11-15 13:38:09 +0100388static void
389iff_setop(uint8_t *list, uint8_t op, int pos)
390{
391 uint8_t *item;
392 uint8_t mask = 3;
393
394 assert(pos >= 0);
395 assert(op <= 3); /* max 2 bits */
396
397 item = &list[pos / 4];
398 mask = mask << 2 * (pos % 4);
399 *item = (*item) & ~mask;
400 *item = (*item) | (op << 2 * (pos % 4));
401}
402
Radek Krejcib56c7502019-02-13 14:19:54 +0100403#define LYS_IFF_LP 0x04 /**< Additional, temporary, value of @ref ifftokens: ( */
404#define LYS_IFF_RP 0x08 /**< Additional, temporary, value of @ref ifftokens: ) */
Radek Krejci19a96102018-11-15 13:38:09 +0100405
Radek Krejci0af46292019-01-11 16:02:31 +0100406/**
407 * @brief Find a feature of the given name and referenced in the given module.
408 *
409 * If the compiled schema is available (the schema is implemented), the feature from the compiled schema is
410 * returned. Otherwise, the special array of pre-compiled features is used to search for the feature. Such
411 * features are always disabled (feature from not implemented schema cannot be enabled), but in case the schema
412 * will be made implemented in future (no matter if implicitly via augmenting/deviating it or explicitly via
413 * ly_ctx_module_implement()), the compilation of these feature structure is finished, but the pointers
414 * assigned till that time will be still valid.
415 *
416 * @param[in] mod Module where the feature was referenced (used to resolve prefix of the feature).
417 * @param[in] name Name of the feature including possible prefix.
418 * @param[in] len Length of the string representing the feature identifier in the name variable (mandatory!).
419 * @return Pointer to the feature structure if found, NULL otherwise.
420 */
Radek Krejci19a96102018-11-15 13:38:09 +0100421static struct lysc_feature *
Radek Krejci0af46292019-01-11 16:02:31 +0100422lys_feature_find(struct lys_module *mod, const char *name, size_t len)
Radek Krejci19a96102018-11-15 13:38:09 +0100423{
424 size_t i;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200425 LY_ARRAY_COUNT_TYPE u;
Radek Krejci0af46292019-01-11 16:02:31 +0100426 struct lysc_feature *f, *flist;
Radek Krejci19a96102018-11-15 13:38:09 +0100427
Radek Krejci120d8542020-08-12 09:29:16 +0200428 assert(mod);
429
Radek Krejci19a96102018-11-15 13:38:09 +0100430 for (i = 0; i < len; ++i) {
431 if (name[i] == ':') {
432 /* we have a prefixed feature */
Radek Krejci0af46292019-01-11 16:02:31 +0100433 mod = lys_module_find_prefix(mod, name, i);
Radek Krejci19a96102018-11-15 13:38:09 +0100434 LY_CHECK_RET(!mod, NULL);
435
436 name = &name[i + 1];
437 len = len - i - 1;
438 }
439 }
440
441 /* we have the correct module, get the feature */
Radek Krejci0af46292019-01-11 16:02:31 +0100442 if (mod->implemented) {
443 /* module is implemented so there is already the compiled schema */
444 flist = mod->compiled->features;
445 } else {
Michal Vasko33ff9422020-07-03 09:50:39 +0200446 flist = mod->dis_features;
Radek Krejci0af46292019-01-11 16:02:31 +0100447 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200448 LY_ARRAY_FOR(flist, u) {
449 f = &flist[u];
Radek Krejci7f9b6512019-09-18 13:11:09 +0200450 if (!ly_strncmp(f->name, name, len)) {
Radek Krejci19a96102018-11-15 13:38:09 +0100451 return f;
452 }
453 }
454
455 return NULL;
456}
457
Michal Vasko8d544252020-03-02 10:19:52 +0100458/**
Michal Vasko5fe75f12020-03-02 13:52:37 +0100459 * @brief Fill in the prepared compiled extensions definition structure according to the parsed extension definition.
460 */
461static LY_ERR
462lys_compile_extension(struct lysc_ctx *ctx, const struct lys_module *ext_mod, struct lysp_ext *ext_p, struct lysc_ext **ext)
463{
464 LY_ERR ret = LY_SUCCESS;
465
466 if (!ext_p->compiled) {
467 lysc_update_path(ctx, NULL, "{extension}");
468 lysc_update_path(ctx, NULL, ext_p->name);
469
470 /* compile the extension definition */
471 ext_p->compiled = calloc(1, sizeof **ext);
472 ext_p->compiled->refcount = 1;
473 DUP_STRING(ctx->ctx, ext_p->name, ext_p->compiled->name);
474 DUP_STRING(ctx->ctx, ext_p->argument, ext_p->compiled->argument);
475 ext_p->compiled->module = (struct lys_module *)ext_mod;
476 COMPILE_EXTS_GOTO(ctx, ext_p->exts, ext_p->compiled->exts, *ext, LYEXT_PAR_EXT, ret, done);
477
478 lysc_update_path(ctx, NULL, NULL);
479 lysc_update_path(ctx, NULL, NULL);
480
481 /* find extension definition plugin */
482 ext_p->compiled->plugin = lyext_get_plugin(ext_p->compiled);
483 }
484
485 *ext = lysc_ext_dup(ext_p->compiled);
486
487done:
488 return ret;
489}
490
491/**
Michal Vasko8d544252020-03-02 10:19:52 +0100492 * @brief Fill in the prepared compiled extension instance structure according to the parsed extension instance.
493 *
494 * @param[in] ctx Compilation context.
495 * @param[in] ext_p Parsed extension instance.
496 * @param[in,out] ext Prepared compiled extension instance.
497 * @param[in] parent Extension instance parent.
498 * @param[in] parent_type Extension instance parent type.
499 * @param[in] ext_mod Optional module with the extension instance extension definition, set only for internal annotations.
500 */
Radek Krejci19a96102018-11-15 13:38:09 +0100501static LY_ERR
Michal Vasko8d544252020-03-02 10:19:52 +0100502lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext, void *parent,
503 LYEXT_PARENT parent_type, const struct lys_module *ext_mod)
Radek Krejci19a96102018-11-15 13:38:09 +0100504{
Radek Krejci7c960162019-09-18 14:16:12 +0200505 LY_ERR ret = LY_EVALID;
Radek Krejci19a96102018-11-15 13:38:09 +0100506 const char *name;
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200507 size_t u;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200508 LY_ARRAY_COUNT_TYPE v;
Radek Krejci7c960162019-09-18 14:16:12 +0200509 const char *prefixed_name = NULL;
Radek Krejci19a96102018-11-15 13:38:09 +0100510
511 DUP_STRING(ctx->ctx, ext_p->argument, ext->argument);
512 ext->insubstmt = ext_p->insubstmt;
513 ext->insubstmt_index = ext_p->insubstmt_index;
Radek Krejci28681fa2019-09-06 13:08:45 +0200514 ext->module = ctx->mod_def;
Radek Krejci0935f412019-08-20 16:15:18 +0200515 ext->parent = parent;
516 ext->parent_type = parent_type;
Radek Krejci19a96102018-11-15 13:38:09 +0100517
Radek Krejcif56e2a42019-09-09 14:15:25 +0200518 lysc_update_path(ctx, ext->parent_type == LYEXT_PAR_NODE ? (struct lysc_node*)ext->parent : NULL, "{extension}");
Radek Krejcif56e2a42019-09-09 14:15:25 +0200519
Radek Krejci19a96102018-11-15 13:38:09 +0100520 /* get module where the extension definition should be placed */
Radek Krejci7c960162019-09-18 14:16:12 +0200521 for (u = strlen(ext_p->name); u && ext_p->name[u - 1] != ':'; --u);
522 if (ext_p->yin) {
523 /* YIN parser has to replace prefixes by the namespace - XML namespace/prefix pairs may differs form the YANG schema's
524 * namespace/prefix pair. YIN parser does not have the imports available, so mapping from XML namespace to the
525 * YANG (import) prefix must be done here. */
526 if (!ly_strncmp(ctx->mod_def->ns, ext_p->name, u - 1)) {
527 prefixed_name = lydict_insert(ctx->ctx, &ext_p->name[u], 0);
528 u = 0;
Michal Vasko7c8439f2020-08-05 13:25:19 +0200529 } else {
530 assert(ctx->mod_def->parsed);
531 LY_ARRAY_FOR(ctx->mod_def->parsed->imports, v) {
532 if (!ly_strncmp(ctx->mod_def->parsed->imports[v].module->ns, ext_p->name, u - 1)) {
Radek Krejci7c960162019-09-18 14:16:12 +0200533 char *s;
Michal Vasko7c8439f2020-08-05 13:25:19 +0200534 LY_CHECK_ERR_GOTO(asprintf(&s, "%s:%s", ctx->mod_def->parsed->imports[v].prefix, &ext_p->name[u]) == -1,
Radek Krejci200f1062020-07-11 22:51:03 +0200535 ret = LY_EMEM, cleanup);
Radek Krejci7c960162019-09-18 14:16:12 +0200536 prefixed_name = lydict_insert_zc(ctx->ctx, s);
Michal Vasko7c8439f2020-08-05 13:25:19 +0200537 u = strlen(ctx->mod_def->parsed->imports[v].prefix) + 1; /* add semicolon */
Radek Krejci7c960162019-09-18 14:16:12 +0200538 break;
539 }
540 }
541 }
542 if (!prefixed_name) {
543 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
544 "Invalid XML prefix of \"%.*s\" namespace used for extension instance identifier.", u, ext_p->name);
545 goto cleanup;
546 }
547 } else {
548 prefixed_name = ext_p->name;
549 }
550 lysc_update_path(ctx, NULL, prefixed_name);
551
Michal Vasko8d544252020-03-02 10:19:52 +0100552 if (!ext_mod) {
Radek Krejci63f55512020-05-20 14:37:18 +0200553 ext_mod = u ? lys_module_find_prefix(ctx->mod_def, prefixed_name, u - 1) : ctx->mod_def;
Michal Vasko8d544252020-03-02 10:19:52 +0100554 if (!ext_mod) {
555 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
556 "Invalid prefix \"%.*s\" used for extension instance identifier.", u, prefixed_name);
557 goto cleanup;
558 } else if (!ext_mod->parsed->extensions) {
559 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
560 "Extension instance \"%s\" refers \"%s\" module that does not contain extension definitions.",
561 prefixed_name, ext_mod->name);
562 goto cleanup;
563 }
Radek Krejci7c960162019-09-18 14:16:12 +0200564 }
565 name = &prefixed_name[u];
Radek Krejci0935f412019-08-20 16:15:18 +0200566
Michal Vasko5fe75f12020-03-02 13:52:37 +0100567 /* find the parsed extension definition there */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200568 LY_ARRAY_FOR(ext_mod->parsed->extensions, v) {
569 if (!strcmp(name, ext_mod->parsed->extensions[v].name)) {
Michal Vasko5fe75f12020-03-02 13:52:37 +0100570 /* compile extension definition and assign it */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200571 LY_CHECK_RET(lys_compile_extension(ctx, ext_mod, &ext_mod->parsed->extensions[v], &ext->def));
Radek Krejci19a96102018-11-15 13:38:09 +0100572 break;
573 }
574 }
Radek Krejci7c960162019-09-18 14:16:12 +0200575 if (!ext->def) {
576 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
577 "Extension definition of extension instance \"%s\" not found.", prefixed_name);
578 goto cleanup;
579 }
Radek Krejci0935f412019-08-20 16:15:18 +0200580
Radek Krejcif56e2a42019-09-09 14:15:25 +0200581 /* unify the parsed extension from YIN and YANG sources. Without extension definition, it is not possible
582 * to get extension's argument from YIN source, so it is stored as one of the substatements. Here we have
583 * to find it, mark it with LYS_YIN_ARGUMENT and store it in the compiled structure. */
Radek Krejci7c960162019-09-18 14:16:12 +0200584 if (ext_p->yin && ext->def->argument && !ext->argument) {
Radek Krejcif56e2a42019-09-09 14:15:25 +0200585 /* Schema was parsed from YIN and an argument is expected, ... */
586 struct lysp_stmt *stmt = NULL;
587
588 if (ext->def->flags & LYS_YINELEM_TRUE) {
589 /* ... argument was the first XML child element */
590 if (ext_p->child && !(ext_p->child->flags & LYS_YIN_ATTR)) {
591 /* TODO check namespace of the statement */
592 if (!strcmp(ext_p->child->stmt, ext->def->argument)) {
593 stmt = ext_p->child;
594 }
595 }
596 } else {
597 /* ... argument was one of the XML attributes which are represented as child stmt
598 * with LYS_YIN_ATTR flag */
599 for (stmt = ext_p->child; stmt && (stmt->flags & LYS_YIN_ATTR); stmt = stmt->next) {
600 if (!strcmp(stmt->stmt, ext->def->argument)) {
601 /* this is the extension's argument */
Radek Krejcif56e2a42019-09-09 14:15:25 +0200602 break;
603 }
604 }
605 }
606 if (!stmt) {
607 /* missing extension's argument */
608 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci7c960162019-09-18 14:16:12 +0200609 "Extension instance \"%s\" misses argument \"%s\".", prefixed_name, ext->def->argument);
610 goto cleanup;
Radek Krejcif56e2a42019-09-09 14:15:25 +0200611
612 }
613 ext->argument = lydict_insert(ctx->ctx, stmt->arg, 0);
614 stmt->flags |= LYS_YIN_ARGUMENT;
615 }
Radek Krejci7c960162019-09-18 14:16:12 +0200616 if (prefixed_name != ext_p->name) {
617 lydict_remove(ctx->ctx, ext_p->name);
618 ext_p->name = prefixed_name;
619 if (!ext_p->argument && ext->argument) {
620 ext_p->argument = lydict_insert(ctx->ctx, ext->argument, 0);
621 }
622 }
Radek Krejcif56e2a42019-09-09 14:15:25 +0200623
Radek Krejci0935f412019-08-20 16:15:18 +0200624 if (ext->def->plugin && ext->def->plugin->compile) {
Radek Krejciad5963b2019-09-06 16:03:05 +0200625 if (ext->argument) {
626 lysc_update_path(ctx, (struct lysc_node*)ext, ext->argument);
627 }
Radek Krejci7c960162019-09-18 14:16:12 +0200628 LY_CHECK_GOTO(ext->def->plugin->compile(ctx, ext_p, ext), cleanup);
Radek Krejciad5963b2019-09-06 16:03:05 +0200629 if (ext->argument) {
630 lysc_update_path(ctx, NULL, NULL);
631 }
Radek Krejci0935f412019-08-20 16:15:18 +0200632 }
Radek Krejcif56e2a42019-09-09 14:15:25 +0200633 ext_p->compiled = ext;
634
Radek Krejci7c960162019-09-18 14:16:12 +0200635 ret = LY_SUCCESS;
636cleanup:
637 if (prefixed_name && prefixed_name != ext_p->name) {
638 lydict_remove(ctx->ctx, prefixed_name);
639 }
640
Radek Krejcif56e2a42019-09-09 14:15:25 +0200641 lysc_update_path(ctx, NULL, NULL);
642 lysc_update_path(ctx, NULL, NULL);
Radek Krejci0935f412019-08-20 16:15:18 +0200643
Radek Krejci7c960162019-09-18 14:16:12 +0200644 return ret;
Radek Krejci0935f412019-08-20 16:15:18 +0200645}
646
647/**
Radek Krejcib56c7502019-02-13 14:19:54 +0100648 * @brief Compile information from the if-feature statement
649 * @param[in] ctx Compile context.
650 * @param[in] value The if-feature argument to process. It is pointer-to-pointer-to-char just to unify the compile functions.
Radek Krejcib56c7502019-02-13 14:19:54 +0100651 * @param[in,out] iff Prepared (empty) compiled if-feature structure to fill.
652 * @return LY_ERR value.
653 */
Radek Krejci19a96102018-11-15 13:38:09 +0100654static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +0200655lys_compile_iffeature(struct lysc_ctx *ctx, const char **value, struct lysc_iffeature *iff)
Radek Krejci19a96102018-11-15 13:38:09 +0100656{
657 const char *c = *value;
658 int r, rc = EXIT_FAILURE;
659 int i, j, last_not, checkversion = 0;
660 unsigned int f_size = 0, expr_size = 0, f_exp = 1;
661 uint8_t op;
662 struct iff_stack stack = {0, 0, NULL};
663 struct lysc_feature *f;
664
665 assert(c);
666
667 /* pre-parse the expression to get sizes for arrays, also do some syntax checks of the expression */
668 for (i = j = last_not = 0; c[i]; i++) {
669 if (c[i] == '(') {
670 j++;
671 checkversion = 1;
672 continue;
673 } else if (c[i] == ')') {
674 j--;
675 continue;
676 } else if (isspace(c[i])) {
677 checkversion = 1;
678 continue;
679 }
680
681 if (!strncmp(&c[i], "not", r = 3) || !strncmp(&c[i], "and", r = 3) || !strncmp(&c[i], "or", r = 2)) {
Radek Krejci6788abc2019-06-14 13:56:49 +0200682 int sp;
683 for(sp = 0; c[i + r + sp] && isspace(c[i + r + sp]); sp++);
684 if (c[i + r + sp] == '\0') {
Radek Krejci19a96102018-11-15 13:38:09 +0100685 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
686 "Invalid value \"%s\" of if-feature - unexpected end of expression.", *value);
687 return LY_EVALID;
688 } else if (!isspace(c[i + r])) {
689 /* feature name starting with the not/and/or */
690 last_not = 0;
691 f_size++;
692 } else if (c[i] == 'n') { /* not operation */
693 if (last_not) {
694 /* double not */
695 expr_size = expr_size - 2;
696 last_not = 0;
697 } else {
698 last_not = 1;
699 }
700 } else { /* and, or */
Radek Krejci6788abc2019-06-14 13:56:49 +0200701 if (f_exp != f_size) {
702 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
703 "Invalid value \"%s\" of if-feature - missing feature/expression before \"%.*s\" operation.", *value, r, &c[i]);
704 return LY_EVALID;
705 }
Radek Krejci19a96102018-11-15 13:38:09 +0100706 f_exp++;
Radek Krejci6788abc2019-06-14 13:56:49 +0200707
Radek Krejci19a96102018-11-15 13:38:09 +0100708 /* not a not operation */
709 last_not = 0;
710 }
711 i += r;
712 } else {
713 f_size++;
714 last_not = 0;
715 }
716 expr_size++;
717
718 while (!isspace(c[i])) {
Radek Krejci6788abc2019-06-14 13:56:49 +0200719 if (!c[i] || c[i] == ')' || c[i] == '(') {
Radek Krejci19a96102018-11-15 13:38:09 +0100720 i--;
721 break;
722 }
723 i++;
724 }
725 }
Radek Krejci6788abc2019-06-14 13:56:49 +0200726 if (j) {
Radek Krejci19a96102018-11-15 13:38:09 +0100727 /* not matching count of ( and ) */
728 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
729 "Invalid value \"%s\" of if-feature - non-matching opening and closing parentheses.", *value);
730 return LY_EVALID;
731 }
Radek Krejci6788abc2019-06-14 13:56:49 +0200732 if (f_exp != f_size) {
733 /* features do not match the needed arguments for the logical operations */
734 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
735 "Invalid value \"%s\" of if-feature - number of features in expression does not match "
736 "the required number of operands for the operations.", *value);
737 return LY_EVALID;
738 }
Radek Krejci19a96102018-11-15 13:38:09 +0100739
740 if (checkversion || expr_size > 1) {
741 /* check that we have 1.1 module */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100742 if (ctx->mod_def->version != LYS_VERSION_1_1) {
Radek Krejci19a96102018-11-15 13:38:09 +0100743 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
744 "Invalid value \"%s\" of if-feature - YANG 1.1 expression in YANG 1.0 module.", *value);
745 return LY_EVALID;
746 }
747 }
748
749 /* allocate the memory */
750 LY_ARRAY_CREATE_RET(ctx->ctx, iff->features, f_size, LY_EMEM);
751 iff->expr = calloc((j = (expr_size / 4) + ((expr_size % 4) ? 1 : 0)), sizeof *iff->expr);
752 stack.stack = malloc(expr_size * sizeof *stack.stack);
753 LY_CHECK_ERR_GOTO(!stack.stack || !iff->expr, LOGMEM(ctx->ctx), error);
754
755 stack.size = expr_size;
756 f_size--; expr_size--; /* used as indexes from now */
757
758 for (i--; i >= 0; i--) {
759 if (c[i] == ')') {
760 /* push it on stack */
761 iff_stack_push(&stack, LYS_IFF_RP);
762 continue;
763 } else if (c[i] == '(') {
764 /* pop from the stack into result all operators until ) */
765 while((op = iff_stack_pop(&stack)) != LYS_IFF_RP) {
766 iff_setop(iff->expr, op, expr_size--);
767 }
768 continue;
769 } else if (isspace(c[i])) {
770 continue;
771 }
772
773 /* end of operator or operand -> find beginning and get what is it */
774 j = i + 1;
775 while (i >= 0 && !isspace(c[i]) && c[i] != '(') {
776 i--;
777 }
778 i++; /* go back by one step */
779
780 if (!strncmp(&c[i], "not", 3) && isspace(c[i + 3])) {
781 if (stack.index && stack.stack[stack.index - 1] == LYS_IFF_NOT) {
782 /* double not */
783 iff_stack_pop(&stack);
784 } else {
785 /* not has the highest priority, so do not pop from the stack
786 * as in case of AND and OR */
787 iff_stack_push(&stack, LYS_IFF_NOT);
788 }
789 } else if (!strncmp(&c[i], "and", 3) && isspace(c[i + 3])) {
790 /* as for OR - pop from the stack all operators with the same or higher
791 * priority and store them to the result, then push the AND to the stack */
792 while (stack.index && stack.stack[stack.index - 1] <= LYS_IFF_AND) {
793 op = iff_stack_pop(&stack);
794 iff_setop(iff->expr, op, expr_size--);
795 }
796 iff_stack_push(&stack, LYS_IFF_AND);
797 } else if (!strncmp(&c[i], "or", 2) && isspace(c[i + 2])) {
798 while (stack.index && stack.stack[stack.index - 1] <= LYS_IFF_OR) {
799 op = iff_stack_pop(&stack);
800 iff_setop(iff->expr, op, expr_size--);
801 }
802 iff_stack_push(&stack, LYS_IFF_OR);
803 } else {
804 /* feature name, length is j - i */
805
806 /* add it to the expression */
807 iff_setop(iff->expr, LYS_IFF_F, expr_size--);
808
809 /* now get the link to the feature definition */
Radek Krejci0af46292019-01-11 16:02:31 +0100810 f = lys_feature_find(ctx->mod_def, &c[i], j - i);
811 LY_CHECK_ERR_GOTO(!f, LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
812 "Invalid value \"%s\" of if-feature - unable to find feature \"%.*s\".", *value, j - i, &c[i]);
813 rc = LY_EVALID, error)
Radek Krejci19a96102018-11-15 13:38:09 +0100814 iff->features[f_size] = f;
815 LY_ARRAY_INCREMENT(iff->features);
816 f_size--;
817 }
818 }
819 while (stack.index) {
820 op = iff_stack_pop(&stack);
821 iff_setop(iff->expr, op, expr_size--);
822 }
823
824 if (++expr_size || ++f_size) {
825 /* not all expected operators and operands found */
826 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
827 "Invalid value \"%s\" of if-feature - processing error.", *value);
828 rc = LY_EINT;
829 } else {
830 rc = LY_SUCCESS;
831 }
832
833error:
834 /* cleanup */
835 iff_stack_clean(&stack);
836
837 return rc;
838}
839
Radek Krejcib56c7502019-02-13 14:19:54 +0100840/**
Michal Vasko175012e2019-11-06 15:49:14 +0100841 * @brief Get the XPath context node for the given schema node.
842 * @param[in] start The schema node where the XPath expression appears.
843 * @return The context node to evaluate XPath expression in given schema node.
844 * @return NULL in case the context node is the root node.
845 */
846static struct lysc_node *
847lysc_xpath_context(struct lysc_node *start)
848{
Michal Vasko1bf09392020-03-27 12:38:10 +0100849 for (; start && !(start->nodetype & (LYS_CONTAINER | LYS_LEAF | LYS_LEAFLIST | LYS_LIST | LYS_ANYDATA | LYS_RPC | LYS_ACTION | LYS_NOTIF));
Michal Vasko175012e2019-11-06 15:49:14 +0100850 start = start->parent);
851 return start;
852}
853
854/**
Radek Krejcib56c7502019-02-13 14:19:54 +0100855 * @brief Compile information from the when statement
856 * @param[in] ctx Compile context.
857 * @param[in] when_p The parsed when statement structure.
Michal Vasko175012e2019-11-06 15:49:14 +0100858 * @param[in] flags Flags of the node with the "when" defiition.
859 * @param[in] node Node that inherited the "when" definition, must be connected to parents.
Radek Krejcib56c7502019-02-13 14:19:54 +0100860 * @param[out] when Pointer where to store pointer to the created compiled when structure.
861 * @return LY_ERR value.
862 */
Radek Krejci19a96102018-11-15 13:38:09 +0100863static LY_ERR
Michal Vasko175012e2019-11-06 15:49:14 +0100864lys_compile_when(struct lysc_ctx *ctx, struct lysp_when *when_p, uint16_t flags, struct lysc_node *node, struct lysc_when **when)
Radek Krejci19a96102018-11-15 13:38:09 +0100865{
Radek Krejci19a96102018-11-15 13:38:09 +0100866 LY_ERR ret = LY_SUCCESS;
867
Radek Krejci00b874b2019-02-12 10:54:50 +0100868 *when = calloc(1, sizeof **when);
869 (*when)->refcount = 1;
Michal Vasko004d3152020-06-11 19:59:22 +0200870 (*when)->cond = lyxp_expr_parse(ctx->ctx, when_p->cond, 0, 1);
Radek Krejcia0f704a2019-09-09 16:12:23 +0200871 (*when)->module = ctx->mod_def;
Michal Vasko175012e2019-11-06 15:49:14 +0100872 (*when)->context = lysc_xpath_context(node);
Radek Krejci00b874b2019-02-12 10:54:50 +0100873 DUP_STRING(ctx->ctx, when_p->dsc, (*when)->dsc);
874 DUP_STRING(ctx->ctx, when_p->ref, (*when)->ref);
875 LY_CHECK_ERR_GOTO(!(*when)->cond, ret = ly_errcode(ctx->ctx), done);
Radek Krejci0935f412019-08-20 16:15:18 +0200876 COMPILE_EXTS_GOTO(ctx, when_p->exts, (*when)->exts, (*when), LYEXT_PAR_WHEN, ret, done);
Michal Vasko175012e2019-11-06 15:49:14 +0100877 (*when)->flags = flags & LYS_STATUS_MASK;
Radek Krejci19a96102018-11-15 13:38:09 +0100878
879done:
880 return ret;
881}
882
Radek Krejcib56c7502019-02-13 14:19:54 +0100883/**
884 * @brief Compile information from the must statement
885 * @param[in] ctx Compile context.
886 * @param[in] must_p The parsed must statement structure.
Radek Krejcib56c7502019-02-13 14:19:54 +0100887 * @param[in,out] must Prepared (empty) compiled must structure to fill.
888 * @return LY_ERR value.
889 */
Radek Krejci19a96102018-11-15 13:38:09 +0100890static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +0200891lys_compile_must(struct lysc_ctx *ctx, struct lysp_restr *must_p, struct lysc_must *must)
Radek Krejci19a96102018-11-15 13:38:09 +0100892{
Radek Krejci19a96102018-11-15 13:38:09 +0100893 LY_ERR ret = LY_SUCCESS;
894
Michal Vasko004d3152020-06-11 19:59:22 +0200895 must->cond = lyxp_expr_parse(ctx->ctx, must_p->arg, 0, 1);
Radek Krejci19a96102018-11-15 13:38:09 +0100896 LY_CHECK_ERR_GOTO(!must->cond, ret = ly_errcode(ctx->ctx), done);
Radek Krejci462cf252019-07-24 09:49:08 +0200897 must->module = ctx->mod_def;
Radek Krejci19a96102018-11-15 13:38:09 +0100898 DUP_STRING(ctx->ctx, must_p->eapptag, must->eapptag);
899 DUP_STRING(ctx->ctx, must_p->emsg, must->emsg);
Radek Krejcic8b31002019-01-08 10:24:45 +0100900 DUP_STRING(ctx->ctx, must_p->dsc, must->dsc);
901 DUP_STRING(ctx->ctx, must_p->ref, must->ref);
Radek Krejci0935f412019-08-20 16:15:18 +0200902 COMPILE_EXTS_GOTO(ctx, must_p->exts, must->exts, must, LYEXT_PAR_MUST, ret, done);
Radek Krejci19a96102018-11-15 13:38:09 +0100903
904done:
905 return ret;
906}
907
Radek Krejcib56c7502019-02-13 14:19:54 +0100908/**
Michal Vasko7c8439f2020-08-05 13:25:19 +0200909 * @brief Compile information in the import statement - make sure there is the target module
Radek Krejcib56c7502019-02-13 14:19:54 +0100910 * @param[in] ctx Compile context.
Michal Vasko7c8439f2020-08-05 13:25:19 +0200911 * @param[in] imp_p The parsed import statement structure to fill the module to.
Radek Krejcib56c7502019-02-13 14:19:54 +0100912 * @return LY_ERR value.
913 */
Radek Krejci19a96102018-11-15 13:38:09 +0100914static LY_ERR
Michal Vasko7c8439f2020-08-05 13:25:19 +0200915lys_compile_import(struct lysc_ctx *ctx, struct lysp_import *imp_p)
Radek Krejci19a96102018-11-15 13:38:09 +0100916{
Michal Vasko3a41dff2020-07-15 14:30:28 +0200917 const struct lys_module *mod = NULL;
Radek Krejci19a96102018-11-15 13:38:09 +0100918 LY_ERR ret = LY_SUCCESS;
919
Radek Krejci7f2a5362018-11-28 13:05:37 +0100920 /* make sure that we have the parsed version (lysp_) of the imported module to import groupings or typedefs.
921 * The compiled version is needed only for augments, deviates and leafrefs, so they are checked (and added,
Radek Krejci0e5d8382018-11-28 16:37:53 +0100922 * if needed) when these nodes are finally being instantiated and validated at the end of schema compilation. */
Michal Vasko7c8439f2020-08-05 13:25:19 +0200923 if (!imp_p->module->parsed) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100924 /* try to use filepath if present */
Michal Vasko7c8439f2020-08-05 13:25:19 +0200925 if (imp_p->module->filepath) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200926 struct ly_in *in;
Michal Vasko7c8439f2020-08-05 13:25:19 +0200927 if (ly_in_new_filepath(imp_p->module->filepath, 0, &in)) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200928 LOGINT(ctx->ctx);
929 } else {
Michal Vasko7c8439f2020-08-05 13:25:19 +0200930 LY_CHECK_RET(lys_parse(ctx->ctx, in, !strcmp(&imp_p->module->filepath[strlen(imp_p->module->filepath - 4)],
Michal Vasko3a41dff2020-07-15 14:30:28 +0200931 ".yin") ? LYS_IN_YIN : LYS_IN_YANG, &mod));
Michal Vasko7c8439f2020-08-05 13:25:19 +0200932 if (mod != imp_p->module) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200933 LOGERR(ctx->ctx, LY_EINT, "Filepath \"%s\" of the module \"%s\" does not match.",
Michal Vasko7c8439f2020-08-05 13:25:19 +0200934 imp_p->module->filepath, imp_p->module->name);
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200935 mod = NULL;
936 }
Radek Krejci19a96102018-11-15 13:38:09 +0100937 }
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200938 ly_in_free(in, 1);
Radek Krejci19a96102018-11-15 13:38:09 +0100939 }
940 if (!mod) {
Michal Vasko7c8439f2020-08-05 13:25:19 +0200941 if (lysp_load_module(ctx->ctx, imp_p->module->name, imp_p->module->revision, 0, 1, (struct lys_module **)&mod)) {
Radek Krejci19a96102018-11-15 13:38:09 +0100942 LOGERR(ctx->ctx, LY_ENOTFOUND, "Unable to reload \"%s\" module to import it into \"%s\", source data not found.",
Michal Vasko7c8439f2020-08-05 13:25:19 +0200943 imp_p->module->name, ctx->mod->name);
Radek Krejci19a96102018-11-15 13:38:09 +0100944 return LY_ENOTFOUND;
945 }
946 }
Radek Krejci19a96102018-11-15 13:38:09 +0100947 }
948
Radek Krejci19a96102018-11-15 13:38:09 +0100949 return ret;
950}
951
Michal Vasko33ff9422020-07-03 09:50:39 +0200952LY_ERR
953lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lys_module *module,
954 struct lysp_ident *identities_p, struct lysc_ident **identities)
Radek Krejci19a96102018-11-15 13:38:09 +0100955{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200956 LY_ARRAY_COUNT_TYPE offset = 0, u, v;
Michal Vasko33ff9422020-07-03 09:50:39 +0200957 struct lysc_ctx context = {0};
Radek Krejci19a96102018-11-15 13:38:09 +0100958 LY_ERR ret = LY_SUCCESS;
959
Michal Vasko33ff9422020-07-03 09:50:39 +0200960 assert(ctx_sc || ctx);
Radek Krejci327de162019-06-14 12:52:07 +0200961
Michal Vasko33ff9422020-07-03 09:50:39 +0200962 if (!ctx_sc) {
963 context.ctx = ctx;
964 context.mod = module;
Radek Krejci120d8542020-08-12 09:29:16 +0200965 context.mod_def = module;
Michal Vasko33ff9422020-07-03 09:50:39 +0200966 context.path_len = 1;
967 context.path[0] = '/';
968 ctx_sc = &context;
969 }
Radek Krejci19a96102018-11-15 13:38:09 +0100970
Michal Vasko33ff9422020-07-03 09:50:39 +0200971 if (!identities_p) {
972 return LY_SUCCESS;
973 }
974 if (*identities) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200975 offset = LY_ARRAY_COUNT(*identities);
Michal Vasko33ff9422020-07-03 09:50:39 +0200976 }
977
978 lysc_update_path(ctx_sc, NULL, "{identity}");
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200979 LY_ARRAY_CREATE_RET(ctx_sc->ctx, *identities, LY_ARRAY_COUNT(identities_p), LY_EMEM);
Michal Vasko33ff9422020-07-03 09:50:39 +0200980 LY_ARRAY_FOR(identities_p, u) {
981 lysc_update_path(ctx_sc, NULL, identities_p[u].name);
982
983 LY_ARRAY_INCREMENT(*identities);
984 COMPILE_CHECK_UNIQUENESS_ARRAY(ctx_sc, *identities, name, &(*identities)[offset + u], "identity", identities_p[u].name);
985 DUP_STRING(ctx_sc->ctx, identities_p[u].name, (*identities)[offset + u].name);
986 DUP_STRING(ctx_sc->ctx, identities_p[u].dsc, (*identities)[offset + u].dsc);
987 DUP_STRING(ctx_sc->ctx, identities_p[u].ref, (*identities)[offset + u].ref);
988 (*identities)[offset + u].module = ctx_sc->mod;
989 COMPILE_ARRAY_GOTO(ctx_sc, identities_p[u].iffeatures, (*identities)[offset + u].iffeatures, v,
990 lys_compile_iffeature, ret, done);
991 /* backlinks (derived) can be added no sooner than when all the identities in the current module are present */
992 COMPILE_EXTS_GOTO(ctx_sc, identities_p[u].exts, (*identities)[offset + u].exts, &(*identities)[offset + u],
993 LYEXT_PAR_IDENT, ret, done);
994 (*identities)[offset + u].flags = identities_p[u].flags;
995
996 lysc_update_path(ctx_sc, NULL, NULL);
997 }
998 lysc_update_path(ctx_sc, NULL, NULL);
Radek Krejci19a96102018-11-15 13:38:09 +0100999done:
1000 return ret;
1001}
1002
Radek Krejcib56c7502019-02-13 14:19:54 +01001003/**
1004 * @brief Check circular dependency of identities - identity MUST NOT reference itself (via their base statement).
1005 *
1006 * The function works in the same way as lys_compile_feature_circular_check() with different structures and error messages.
1007 *
1008 * @param[in] ctx Compile context for logging.
1009 * @param[in] ident The base identity (its derived list is being extended by the identity being currently processed).
1010 * @param[in] derived The list of derived identities of the identity being currently processed (not the one provided as @p ident)
1011 * @return LY_SUCCESS if everything is ok.
1012 * @return LY_EVALID if the identity is derived from itself.
1013 */
Radek Krejci38222632019-02-12 16:55:05 +01001014static LY_ERR
1015lys_compile_identity_circular_check(struct lysc_ctx *ctx, struct lysc_ident *ident, struct lysc_ident **derived)
1016{
1017 LY_ERR ret = LY_EVALID;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001018 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejci38222632019-02-12 16:55:05 +01001019 struct ly_set recursion = {0};
1020 struct lysc_ident *drv;
1021
1022 if (!derived) {
1023 return LY_SUCCESS;
1024 }
1025
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001026 for (u = 0; u < LY_ARRAY_COUNT(derived); ++u) {
Radek Krejci38222632019-02-12 16:55:05 +01001027 if (ident == derived[u]) {
1028 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
1029 "Identity \"%s\" is indirectly derived from itself.", ident->name);
1030 goto cleanup;
1031 }
1032 ly_set_add(&recursion, derived[u], 0);
1033 }
1034
1035 for (v = 0; v < recursion.count; ++v) {
1036 drv = recursion.objs[v];
1037 if (!drv->derived) {
1038 continue;
1039 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001040 for (u = 0; u < LY_ARRAY_COUNT(drv->derived); ++u) {
Radek Krejci38222632019-02-12 16:55:05 +01001041 if (ident == drv->derived[u]) {
1042 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
1043 "Identity \"%s\" is indirectly derived from itself.", ident->name);
1044 goto cleanup;
1045 }
1046 ly_set_add(&recursion, drv->derived[u], 0);
1047 }
1048 }
1049 ret = LY_SUCCESS;
1050
1051cleanup:
1052 ly_set_erase(&recursion, NULL);
1053 return ret;
1054}
1055
Radek Krejcia3045382018-11-22 14:30:31 +01001056/**
1057 * @brief Find and process the referenced base identities from another identity or identityref
1058 *
Radek Krejciaca74032019-06-04 08:53:06 +02001059 * For bases in identity set backlinks to them from the base identities. For identityref, store
Radek Krejcia3045382018-11-22 14:30:31 +01001060 * the array of pointers to the base identities. So one of the ident or bases parameter must be set
1061 * to distinguish these two use cases.
1062 *
1063 * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
1064 * @param[in] bases_p Array of names (including prefix if necessary) of base identities.
Michal Vasko33ff9422020-07-03 09:50:39 +02001065 * @param[in] ident Referencing identity to work with, NULL for identityref.
Radek Krejcia3045382018-11-22 14:30:31 +01001066 * @param[in] bases Array of bases of identityref to fill in.
1067 * @return LY_ERR value.
1068 */
Radek Krejci19a96102018-11-15 13:38:09 +01001069static LY_ERR
Michal Vasko33ff9422020-07-03 09:50:39 +02001070lys_compile_identity_bases(struct lysc_ctx *ctx, struct lys_module *context_module, const char **bases_p,
1071 struct lysc_ident *ident, struct lysc_ident ***bases)
Radek Krejci19a96102018-11-15 13:38:09 +01001072{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001073 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejci19a96102018-11-15 13:38:09 +01001074 const char *s, *name;
Radek Krejcie86bf772018-12-14 11:39:53 +01001075 struct lys_module *mod;
Michal Vasko33ff9422020-07-03 09:50:39 +02001076 struct lysc_ident **idref, *identities;
Radek Krejci555cb5b2018-11-16 14:54:33 +01001077
1078 assert(ident || bases);
1079
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001080 if (LY_ARRAY_COUNT(bases_p) > 1 && ctx->mod_def->version < 2) {
Radek Krejci555cb5b2018-11-16 14:54:33 +01001081 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1082 "Multiple bases in %s are allowed only in YANG 1.1 modules.", ident ? "identity" : "identityref type");
1083 return LY_EVALID;
1084 }
1085
Michal Vasko33ff9422020-07-03 09:50:39 +02001086 LY_ARRAY_FOR(bases_p, u) {
Radek Krejci555cb5b2018-11-16 14:54:33 +01001087 s = strchr(bases_p[u], ':');
1088 if (s) {
1089 /* prefixed identity */
1090 name = &s[1];
Radek Krejci0a33b042020-05-27 10:05:06 +02001091 mod = lys_module_find_prefix(context_module, bases_p[u], s - bases_p[u]);
Radek Krejci555cb5b2018-11-16 14:54:33 +01001092 } else {
1093 name = bases_p[u];
Radek Krejci0a33b042020-05-27 10:05:06 +02001094 mod = context_module;
Radek Krejci555cb5b2018-11-16 14:54:33 +01001095 }
1096 if (!mod) {
1097 if (ident) {
1098 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1099 "Invalid prefix used for base (%s) of identity \"%s\".", bases_p[u], ident->name);
1100 } else {
1101 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1102 "Invalid prefix used for base (%s) of identityref.", bases_p[u]);
1103 }
1104 return LY_EVALID;
1105 }
Michal Vasko33ff9422020-07-03 09:50:39 +02001106
Radek Krejci555cb5b2018-11-16 14:54:33 +01001107 idref = NULL;
Michal Vasko33ff9422020-07-03 09:50:39 +02001108 if (mod->compiled) {
1109 identities = mod->compiled->identities;
1110 } else {
1111 identities = mod->dis_identities;
1112 }
1113 LY_ARRAY_FOR(identities, v) {
1114 if (!strcmp(name, identities[v].name)) {
1115 if (ident) {
1116 if (ident == &identities[v]) {
1117 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
1118 "Identity \"%s\" is derived from itself.", ident->name);
1119 return LY_EVALID;
Radek Krejci555cb5b2018-11-16 14:54:33 +01001120 }
Michal Vasko33ff9422020-07-03 09:50:39 +02001121 LY_CHECK_RET(lys_compile_identity_circular_check(ctx, &identities[v], ident->derived));
1122 /* we have match! store the backlink */
1123 LY_ARRAY_NEW_RET(ctx->ctx, identities[v].derived, idref, LY_EMEM);
1124 *idref = ident;
1125 } else {
1126 /* we have match! store the found identity */
1127 LY_ARRAY_NEW_RET(ctx->ctx, *bases, idref, LY_EMEM);
1128 *idref = &identities[v];
Radek Krejci555cb5b2018-11-16 14:54:33 +01001129 }
Michal Vasko33ff9422020-07-03 09:50:39 +02001130 break;
Radek Krejci555cb5b2018-11-16 14:54:33 +01001131 }
1132 }
1133 if (!idref || !(*idref)) {
1134 if (ident) {
1135 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1136 "Unable to find base (%s) of identity \"%s\".", bases_p[u], ident->name);
1137 } else {
1138 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1139 "Unable to find base (%s) of identityref.", bases_p[u]);
1140 }
1141 return LY_EVALID;
1142 }
1143 }
1144 return LY_SUCCESS;
1145}
1146
Radek Krejcia3045382018-11-22 14:30:31 +01001147/**
1148 * @brief For the given array of identities, set the backlinks from all their base identities.
1149 * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
1150 * @param[in] idents_p Array of identities definitions from the parsed schema structure.
1151 * @param[in] idents Array of referencing identities to which the backlinks are supposed to be set.
1152 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
1153 */
Radek Krejci555cb5b2018-11-16 14:54:33 +01001154static LY_ERR
1155lys_compile_identities_derived(struct lysc_ctx *ctx, struct lysp_ident *idents_p, struct lysc_ident *idents)
1156{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001157 LY_ARRAY_COUNT_TYPE u;
Radek Krejci19a96102018-11-15 13:38:09 +01001158
Michal Vasko33ff9422020-07-03 09:50:39 +02001159 lysc_update_path(ctx, NULL, "{identity}");
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001160 for (u = 0; u < LY_ARRAY_COUNT(idents_p); ++u) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001161 if (!idents_p[u].bases) {
Radek Krejci19a96102018-11-15 13:38:09 +01001162 continue;
1163 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001164 lysc_update_path(ctx, NULL, idents[u].name);
Radek Krejci0a33b042020-05-27 10:05:06 +02001165 LY_CHECK_RET(lys_compile_identity_bases(ctx, idents[u].module, idents_p[u].bases, &idents[u], NULL));
Radek Krejci327de162019-06-14 12:52:07 +02001166 lysc_update_path(ctx, NULL, NULL);
Radek Krejci19a96102018-11-15 13:38:09 +01001167 }
Michal Vasko33ff9422020-07-03 09:50:39 +02001168 lysc_update_path(ctx, NULL, NULL);
Radek Krejci19a96102018-11-15 13:38:09 +01001169 return LY_SUCCESS;
1170}
1171
Radek Krejci0af46292019-01-11 16:02:31 +01001172LY_ERR
Michal Vasko33ff9422020-07-03 09:50:39 +02001173lys_feature_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lys_module *module,
1174 struct lysp_feature *features_p, struct lysc_feature **features)
Radek Krejci0af46292019-01-11 16:02:31 +01001175{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001176 LY_ARRAY_COUNT_TYPE offset = 0, u;
Radek Krejci0af46292019-01-11 16:02:31 +01001177 struct lysc_ctx context = {0};
1178
Radek Krejci327de162019-06-14 12:52:07 +02001179 assert(ctx_sc || ctx);
1180
1181 if (!ctx_sc) {
1182 context.ctx = ctx;
1183 context.mod = module;
1184 context.path_len = 1;
1185 context.path[0] = '/';
1186 ctx_sc = &context;
1187 }
Radek Krejci0af46292019-01-11 16:02:31 +01001188
1189 if (!features_p) {
1190 return LY_SUCCESS;
1191 }
1192 if (*features) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001193 offset = LY_ARRAY_COUNT(*features);
Radek Krejci0af46292019-01-11 16:02:31 +01001194 }
1195
Radek Krejci327de162019-06-14 12:52:07 +02001196 lysc_update_path(ctx_sc, NULL, "{feature}");
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001197 LY_ARRAY_CREATE_RET(ctx_sc->ctx, *features, LY_ARRAY_COUNT(features_p), LY_EMEM);
Radek Krejci0af46292019-01-11 16:02:31 +01001198 LY_ARRAY_FOR(features_p, u) {
Radek Krejci327de162019-06-14 12:52:07 +02001199 lysc_update_path(ctx_sc, NULL, features_p[u].name);
1200
Radek Krejci0af46292019-01-11 16:02:31 +01001201 LY_ARRAY_INCREMENT(*features);
Michal Vasko6f4cbb62020-02-28 11:15:47 +01001202 COMPILE_CHECK_UNIQUENESS_ARRAY(ctx_sc, *features, name, &(*features)[offset + u], "feature", features_p[u].name);
Radek Krejci327de162019-06-14 12:52:07 +02001203 DUP_STRING(ctx_sc->ctx, features_p[u].name, (*features)[offset + u].name);
1204 DUP_STRING(ctx_sc->ctx, features_p[u].dsc, (*features)[offset + u].dsc);
1205 DUP_STRING(ctx_sc->ctx, features_p[u].ref, (*features)[offset + u].ref);
Radek Krejci0af46292019-01-11 16:02:31 +01001206 (*features)[offset + u].flags = features_p[u].flags;
Radek Krejci327de162019-06-14 12:52:07 +02001207 (*features)[offset + u].module = ctx_sc->mod;
1208
1209 lysc_update_path(ctx_sc, NULL, NULL);
Radek Krejci0af46292019-01-11 16:02:31 +01001210 }
Radek Krejci327de162019-06-14 12:52:07 +02001211 lysc_update_path(ctx_sc, NULL, NULL);
Radek Krejci0af46292019-01-11 16:02:31 +01001212
1213 return LY_SUCCESS;
1214}
1215
Radek Krejcia3045382018-11-22 14:30:31 +01001216/**
Radek Krejci09a1fc52019-02-13 10:55:17 +01001217 * @brief Check circular dependency of features - feature MUST NOT reference itself (via their if-feature statement).
Radek Krejcib56c7502019-02-13 14:19:54 +01001218 *
1219 * The function works in the same way as lys_compile_identity_circular_check() with different structures and error messages.
1220 *
Radek Krejci09a1fc52019-02-13 10:55:17 +01001221 * @param[in] ctx Compile context for logging.
Radek Krejcib56c7502019-02-13 14:19:54 +01001222 * @param[in] feature The feature referenced in if-feature statement (its depfeatures list is being extended by the feature
1223 * being currently processed).
1224 * @param[in] depfeatures The list of depending features of the feature being currently processed (not the one provided as @p feature)
Radek Krejci09a1fc52019-02-13 10:55:17 +01001225 * @return LY_SUCCESS if everything is ok.
1226 * @return LY_EVALID if the feature references indirectly itself.
1227 */
1228static LY_ERR
1229lys_compile_feature_circular_check(struct lysc_ctx *ctx, struct lysc_feature *feature, struct lysc_feature **depfeatures)
1230{
1231 LY_ERR ret = LY_EVALID;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001232 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejci09a1fc52019-02-13 10:55:17 +01001233 struct ly_set recursion = {0};
1234 struct lysc_feature *drv;
1235
1236 if (!depfeatures) {
1237 return LY_SUCCESS;
1238 }
1239
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001240 for (u = 0; u < LY_ARRAY_COUNT(depfeatures); ++u) {
Radek Krejci09a1fc52019-02-13 10:55:17 +01001241 if (feature == depfeatures[u]) {
1242 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
1243 "Feature \"%s\" is indirectly referenced from itself.", feature->name);
1244 goto cleanup;
1245 }
1246 ly_set_add(&recursion, depfeatures[u], 0);
1247 }
1248
1249 for (v = 0; v < recursion.count; ++v) {
1250 drv = recursion.objs[v];
1251 if (!drv->depfeatures) {
1252 continue;
1253 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001254 for (u = 0; u < LY_ARRAY_COUNT(drv->depfeatures); ++u) {
Radek Krejci09a1fc52019-02-13 10:55:17 +01001255 if (feature == drv->depfeatures[u]) {
1256 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
1257 "Feature \"%s\" is indirectly referenced from itself.", feature->name);
1258 goto cleanup;
1259 }
1260 ly_set_add(&recursion, drv->depfeatures[u], 0);
1261 }
1262 }
1263 ret = LY_SUCCESS;
1264
1265cleanup:
1266 ly_set_erase(&recursion, NULL);
1267 return ret;
1268}
1269
1270/**
Radek Krejci0af46292019-01-11 16:02:31 +01001271 * @brief Create pre-compiled features array.
1272 *
1273 * See lys_feature_precompile() for more details.
1274 *
Radek Krejcia3045382018-11-22 14:30:31 +01001275 * @param[in] ctx Compile context.
1276 * @param[in] feature_p Parsed feature definition to compile.
Radek Krejci0af46292019-01-11 16:02:31 +01001277 * @param[in,out] features List of already (pre)compiled features to find the corresponding precompiled feature structure.
Radek Krejcia3045382018-11-22 14:30:31 +01001278 * @return LY_ERR value.
1279 */
Radek Krejci19a96102018-11-15 13:38:09 +01001280static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02001281lys_feature_precompile_finish(struct lysc_ctx *ctx, struct lysp_feature *feature_p, struct lysc_feature *features)
Radek Krejci19a96102018-11-15 13:38:09 +01001282{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001283 LY_ARRAY_COUNT_TYPE u, v, x;
Radek Krejci0af46292019-01-11 16:02:31 +01001284 struct lysc_feature *feature, **df;
Radek Krejci19a96102018-11-15 13:38:09 +01001285 LY_ERR ret = LY_SUCCESS;
Radek Krejci19a96102018-11-15 13:38:09 +01001286
Radek Krejci327de162019-06-14 12:52:07 +02001287
Radek Krejci0af46292019-01-11 16:02:31 +01001288 /* find the preprecompiled feature */
1289 LY_ARRAY_FOR(features, x) {
1290 if (strcmp(features[x].name, feature_p->name)) {
1291 continue;
1292 }
1293 feature = &features[x];
Radek Krejci327de162019-06-14 12:52:07 +02001294 lysc_update_path(ctx, NULL, "{feature}");
1295 lysc_update_path(ctx, NULL, feature_p->name);
Radek Krejci19a96102018-11-15 13:38:09 +01001296
Radek Krejci0af46292019-01-11 16:02:31 +01001297 /* finish compilation started in lys_feature_precompile() */
Radek Krejci0935f412019-08-20 16:15:18 +02001298 COMPILE_EXTS_GOTO(ctx, feature_p->exts, feature->exts, feature, LYEXT_PAR_FEATURE, ret, done);
Radek Krejciec4da802019-05-02 13:02:41 +02001299 COMPILE_ARRAY_GOTO(ctx, feature_p->iffeatures, feature->iffeatures, u, lys_compile_iffeature, ret, done);
Radek Krejci0af46292019-01-11 16:02:31 +01001300 if (feature->iffeatures) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001301 for (u = 0; u < LY_ARRAY_COUNT(feature->iffeatures); ++u) {
Radek Krejci0af46292019-01-11 16:02:31 +01001302 if (feature->iffeatures[u].features) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001303 for (v = 0; v < LY_ARRAY_COUNT(feature->iffeatures[u].features); ++v) {
Radek Krejci09a1fc52019-02-13 10:55:17 +01001304 /* check for circular dependency - direct reference first,... */
1305 if (feature == feature->iffeatures[u].features[v]) {
1306 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
1307 "Feature \"%s\" is referenced from itself.", feature->name);
1308 return LY_EVALID;
1309 }
1310 /* ... and indirect circular reference */
1311 LY_CHECK_RET(lys_compile_feature_circular_check(ctx, feature->iffeatures[u].features[v], feature->depfeatures));
1312
Radek Krejci0af46292019-01-11 16:02:31 +01001313 /* add itself into the dependants list */
1314 LY_ARRAY_NEW_RET(ctx->ctx, feature->iffeatures[u].features[v]->depfeatures, df, LY_EMEM);
1315 *df = feature;
1316 }
Radek Krejci19a96102018-11-15 13:38:09 +01001317 }
Radek Krejci19a96102018-11-15 13:38:09 +01001318 }
1319 }
Radek Krejci327de162019-06-14 12:52:07 +02001320 lysc_update_path(ctx, NULL, NULL);
1321 lysc_update_path(ctx, NULL, NULL);
Radek Krejci0af46292019-01-11 16:02:31 +01001322 done:
1323 return ret;
Radek Krejci19a96102018-11-15 13:38:09 +01001324 }
Radek Krejci0af46292019-01-11 16:02:31 +01001325
1326 LOGINT(ctx->ctx);
1327 return LY_EINT;
Radek Krejci19a96102018-11-15 13:38:09 +01001328}
1329
Radek Krejcib56c7502019-02-13 14:19:54 +01001330/**
1331 * @brief Revert compiled list of features back to the precompiled state.
1332 *
1333 * Function is needed in case the compilation failed and the schema is expected to revert back to the non-compiled status.
Michal Vasko33ff9422020-07-03 09:50:39 +02001334 * The features are supposed to be stored again as dis_features in ::lys_module structure.
Radek Krejcib56c7502019-02-13 14:19:54 +01001335 *
1336 * @param[in] ctx Compilation context.
1337 * @param[in] mod The module structure still holding the compiled (but possibly not finished, only the list of compiled features is taken) schema
Michal Vasko33ff9422020-07-03 09:50:39 +02001338 * and supposed to hold the dis_features list.
Radek Krejcib56c7502019-02-13 14:19:54 +01001339 */
Radek Krejci95710c92019-02-11 15:49:55 +01001340static void
1341lys_feature_precompile_revert(struct lysc_ctx *ctx, struct lys_module *mod)
1342{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001343 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejci95710c92019-02-11 15:49:55 +01001344
Radek Krejcia46012b2020-08-12 15:41:04 +02001345 if (mod->compiled) {
1346 /* keep the dis_features list until the complete lys_module is freed */
1347 mod->dis_features = mod->compiled->features;
1348 mod->compiled->features = NULL;
1349 }
Radek Krejci95710c92019-02-11 15:49:55 +01001350
Michal Vasko33ff9422020-07-03 09:50:39 +02001351 /* in the dis_features list, remove all the parts (from finished compiling process)
Radek Krejci95710c92019-02-11 15:49:55 +01001352 * which may points into the data being freed here */
Michal Vasko33ff9422020-07-03 09:50:39 +02001353 LY_ARRAY_FOR(mod->dis_features, u) {
1354 LY_ARRAY_FOR(mod->dis_features[u].iffeatures, v) {
1355 lysc_iffeature_free(ctx->ctx, &mod->dis_features[u].iffeatures[v]);
Radek Krejci95710c92019-02-11 15:49:55 +01001356 }
Michal Vasko33ff9422020-07-03 09:50:39 +02001357 LY_ARRAY_FREE(mod->dis_features[u].iffeatures);
1358 mod->dis_features[u].iffeatures = NULL;
Radek Krejci95710c92019-02-11 15:49:55 +01001359
Michal Vasko33ff9422020-07-03 09:50:39 +02001360 LY_ARRAY_FOR(mod->dis_features[u].exts, v) {
1361 lysc_ext_instance_free(ctx->ctx, &(mod->dis_features[u].exts)[v]);
Radek Krejci95710c92019-02-11 15:49:55 +01001362 }
Michal Vasko33ff9422020-07-03 09:50:39 +02001363 LY_ARRAY_FREE(mod->dis_features[u].exts);
1364 mod->dis_features[u].exts = NULL;
Radek Krejci95710c92019-02-11 15:49:55 +01001365 }
1366}
1367
Radek Krejcia3045382018-11-22 14:30:31 +01001368/**
1369 * @brief Validate and normalize numeric value from a range definition.
1370 * @param[in] ctx Compile context.
1371 * @param[in] basetype Base YANG built-in type of the node connected with the range restriction. Actually only LY_TYPE_DEC64 is important to
1372 * allow processing of the fractions. The fraction point is extracted from the value which is then normalize according to given frdigits into
1373 * valcopy to allow easy parsing and storing of the value. libyang stores decimal number without the decimal point which is always recovered from
1374 * the known fraction-digits value. So, with fraction-digits 2, number 3.14 is stored as 314 and number 1 is stored as 100.
1375 * @param[in] frdigits The fraction-digits of the type in case of LY_TYPE_DEC64.
1376 * @param[in] value String value of the range boundary.
1377 * @param[out] len Number of the processed bytes from the value. Processing stops on the first character which is not part of the number boundary.
1378 * @param[out] valcopy NULL-terminated string with the numeric value to parse and store.
1379 * @return LY_ERR value - LY_SUCCESS, LY_EMEM, LY_EVALID (no number) or LY_EINVAL (decimal64 not matching fraction-digits value).
1380 */
Radek Krejcie88beef2019-05-30 15:47:19 +02001381LY_ERR
Radek Krejci6cba4292018-11-15 17:33:29 +01001382range_part_check_value_syntax(struct lysc_ctx *ctx, LY_DATA_TYPE basetype, uint8_t frdigits, const char *value, size_t *len, char **valcopy)
Radek Krejci19a96102018-11-15 13:38:09 +01001383{
Radek Krejci6cba4292018-11-15 17:33:29 +01001384 size_t fraction = 0, size;
1385
Radek Krejci19a96102018-11-15 13:38:09 +01001386 *len = 0;
1387
1388 assert(value);
1389 /* parse value */
1390 if (!isdigit(value[*len]) && (value[*len] != '-') && (value[*len] != '+')) {
1391 return LY_EVALID;
1392 }
1393
1394 if ((value[*len] == '-') || (value[*len] == '+')) {
1395 ++(*len);
1396 }
1397
1398 while (isdigit(value[*len])) {
1399 ++(*len);
1400 }
1401
1402 if ((basetype != LY_TYPE_DEC64) || (value[*len] != '.') || !isdigit(value[*len + 1])) {
Radek Krejci6cba4292018-11-15 17:33:29 +01001403 if (basetype == LY_TYPE_DEC64) {
1404 goto decimal;
1405 } else {
1406 *valcopy = strndup(value, *len);
1407 return LY_SUCCESS;
1408 }
Radek Krejci19a96102018-11-15 13:38:09 +01001409 }
1410 fraction = *len;
1411
1412 ++(*len);
1413 while (isdigit(value[*len])) {
1414 ++(*len);
1415 }
1416
Radek Krejci6cba4292018-11-15 17:33:29 +01001417 if (basetype == LY_TYPE_DEC64) {
1418decimal:
1419 assert(frdigits);
Radek Krejci943177f2019-06-14 16:32:43 +02001420 if (fraction && (*len - 1 - fraction > frdigits)) {
Radek Krejci6cba4292018-11-15 17:33:29 +01001421 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1422 "Range boundary \"%.*s\" of decimal64 type exceeds defined number (%u) of fraction digits.",
1423 *len, value, frdigits);
1424 return LY_EINVAL;
1425 }
1426 if (fraction) {
1427 size = (*len) + (frdigits - ((*len) - 1 - fraction));
1428 } else {
1429 size = (*len) + frdigits + 1;
1430 }
1431 *valcopy = malloc(size * sizeof **valcopy);
Radek Krejci19a96102018-11-15 13:38:09 +01001432 LY_CHECK_ERR_RET(!(*valcopy), LOGMEM(ctx->ctx), LY_EMEM);
1433
Radek Krejci6cba4292018-11-15 17:33:29 +01001434 (*valcopy)[size - 1] = '\0';
1435 if (fraction) {
1436 memcpy(&(*valcopy)[0], &value[0], fraction);
1437 memcpy(&(*valcopy)[fraction], &value[fraction + 1], (*len) - 1 - (fraction));
1438 memset(&(*valcopy)[(*len) - 1], '0', frdigits - ((*len) - 1 - fraction));
1439 } else {
1440 memcpy(&(*valcopy)[0], &value[0], *len);
1441 memset(&(*valcopy)[*len], '0', frdigits);
1442 }
Radek Krejci19a96102018-11-15 13:38:09 +01001443 }
1444 return LY_SUCCESS;
1445}
1446
Radek Krejcia3045382018-11-22 14:30:31 +01001447/**
1448 * @brief Check that values in range are in ascendant order.
1449 * @param[in] unsigned_value Flag to note that we are working with unsigned values.
Radek Krejci5969f272018-11-23 10:03:58 +01001450 * @param[in] max Flag to distinguish if checking min or max value. min value must be strictly higher than previous,
1451 * max can be also equal.
Radek Krejcia3045382018-11-22 14:30:31 +01001452 * @param[in] value Current value to check.
1453 * @param[in] prev_value The last seen value.
1454 * @return LY_SUCCESS or LY_EEXIST for invalid order.
1455 */
Radek Krejci19a96102018-11-15 13:38:09 +01001456static LY_ERR
Radek Krejci5969f272018-11-23 10:03:58 +01001457range_part_check_ascendancy(int unsigned_value, int max, int64_t value, int64_t prev_value)
Radek Krejci19a96102018-11-15 13:38:09 +01001458{
1459 if (unsigned_value) {
Radek Krejci5969f272018-11-23 10:03:58 +01001460 if ((max && (uint64_t)prev_value > (uint64_t)value) || (!max && (uint64_t)prev_value >= (uint64_t)value)) {
Radek Krejci19a96102018-11-15 13:38:09 +01001461 return LY_EEXIST;
1462 }
1463 } else {
Radek Krejci5969f272018-11-23 10:03:58 +01001464 if ((max && prev_value > value) || (!max && prev_value >= value)) {
Radek Krejci19a96102018-11-15 13:38:09 +01001465 return LY_EEXIST;
1466 }
1467 }
1468 return LY_SUCCESS;
1469}
1470
Radek Krejcia3045382018-11-22 14:30:31 +01001471/**
1472 * @brief Set min/max value of the range part.
1473 * @param[in] ctx Compile context.
1474 * @param[in] part Range part structure to fill.
1475 * @param[in] max Flag to distinguish if storing min or max value.
1476 * @param[in] prev The last seen value to check that all values in range are specified in ascendant order.
1477 * @param[in] basetype Type of the value to get know implicit min/max values and other checking rules.
1478 * @param[in] first Flag for the first value of the range to avoid ascendancy order.
1479 * @param[in] length_restr Flag to distinguish between range and length restrictions. Only for logging.
1480 * @param[in] frdigits The fraction-digits value in case of LY_TYPE_DEC64 basetype.
Radek Krejci5969f272018-11-23 10:03:58 +01001481 * @param[in] base_range Range from the type from which the current type is derived (if not built-in) to get type's min and max values.
Radek Krejcia3045382018-11-22 14:30:31 +01001482 * @param[in,out] value Numeric range value to be stored, if not provided the type's min/max value is set.
1483 * @return LY_ERR value - LY_SUCCESS, LY_EDENIED (value brokes type's boundaries), LY_EVALID (not a number),
1484 * LY_EEXIST (value is smaller than the previous one), LY_EINVAL (decimal64 value does not corresponds with the
1485 * frdigits value), LY_EMEM.
1486 */
Radek Krejci19a96102018-11-15 13:38:09 +01001487static LY_ERR
Michal Vaskoba417ac2020-08-06 14:48:20 +02001488range_part_minmax(struct lysc_ctx *ctx, struct lysc_range_part *part, int max, int64_t prev, LY_DATA_TYPE basetype,
1489 int first, int length_restr, uint8_t frdigits, struct lysc_range *base_range, const char **value)
Radek Krejci19a96102018-11-15 13:38:09 +01001490{
1491 LY_ERR ret = LY_SUCCESS;
1492 char *valcopy = NULL;
1493 size_t len;
1494
1495 if (value) {
Radek Krejci6cba4292018-11-15 17:33:29 +01001496 ret = range_part_check_value_syntax(ctx, basetype, frdigits, *value, &len, &valcopy);
Radek Krejci5969f272018-11-23 10:03:58 +01001497 LY_CHECK_GOTO(ret, finalize);
1498 }
1499 if (!valcopy && base_range) {
1500 if (max) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001501 part->max_64 = base_range->parts[LY_ARRAY_COUNT(base_range->parts) - 1].max_64;
Radek Krejci5969f272018-11-23 10:03:58 +01001502 } else {
1503 part->min_64 = base_range->parts[0].min_64;
1504 }
1505 if (!first) {
1506 ret = range_part_check_ascendancy(basetype <= LY_TYPE_STRING ? 1 : 0, max, max ? part->max_64 : part->min_64, prev);
1507 }
1508 goto finalize;
Radek Krejci19a96102018-11-15 13:38:09 +01001509 }
1510
1511 switch (basetype) {
Radek Krejci19a96102018-11-15 13:38:09 +01001512 case LY_TYPE_INT8: /* range */
1513 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001514 ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-128), INT64_C(127), 10, max ? &part->max_64 : &part->min_64);
Radek Krejci19a96102018-11-15 13:38:09 +01001515 } else if (max) {
1516 part->max_64 = INT64_C(127);
1517 } else {
1518 part->min_64 = INT64_C(-128);
1519 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001520 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001521 ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001522 }
1523 break;
1524 case LY_TYPE_INT16: /* range */
1525 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001526 ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-32768), INT64_C(32767), 10, max ? &part->max_64 : &part->min_64);
Radek Krejci19a96102018-11-15 13:38:09 +01001527 } else if (max) {
1528 part->max_64 = INT64_C(32767);
1529 } else {
1530 part->min_64 = INT64_C(-32768);
1531 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001532 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001533 ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001534 }
1535 break;
1536 case LY_TYPE_INT32: /* range */
1537 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001538 ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-2147483648), INT64_C(2147483647), 10, max ? &part->max_64 : &part->min_64);
Radek Krejci19a96102018-11-15 13:38:09 +01001539 } else if (max) {
1540 part->max_64 = INT64_C(2147483647);
1541 } else {
1542 part->min_64 = INT64_C(-2147483648);
1543 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001544 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001545 ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001546 }
1547 break;
1548 case LY_TYPE_INT64: /* range */
Radek Krejci25cfef72018-11-23 14:15:52 +01001549 case LY_TYPE_DEC64: /* range */
Radek Krejci19a96102018-11-15 13:38:09 +01001550 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001551 ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-9223372036854775807) - INT64_C(1), INT64_C(9223372036854775807), 10,
Radek Krejci19a96102018-11-15 13:38:09 +01001552 max ? &part->max_64 : &part->min_64);
1553 } else if (max) {
1554 part->max_64 = INT64_C(9223372036854775807);
1555 } else {
1556 part->min_64 = INT64_C(-9223372036854775807) - INT64_C(1);
1557 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001558 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001559 ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001560 }
1561 break;
1562 case LY_TYPE_UINT8: /* range */
1563 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001564 ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(255), 10, max ? &part->max_u64 : &part->min_u64);
Radek Krejci19a96102018-11-15 13:38:09 +01001565 } else if (max) {
1566 part->max_u64 = UINT64_C(255);
1567 } else {
1568 part->min_u64 = UINT64_C(0);
1569 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001570 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001571 ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001572 }
1573 break;
1574 case LY_TYPE_UINT16: /* range */
1575 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001576 ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(65535), 10, max ? &part->max_u64 : &part->min_u64);
Radek Krejci19a96102018-11-15 13:38:09 +01001577 } else if (max) {
1578 part->max_u64 = UINT64_C(65535);
1579 } else {
1580 part->min_u64 = UINT64_C(0);
1581 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001582 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001583 ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001584 }
1585 break;
1586 case LY_TYPE_UINT32: /* range */
1587 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001588 ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(4294967295), 10, max ? &part->max_u64 : &part->min_u64);
Radek Krejci19a96102018-11-15 13:38:09 +01001589 } else if (max) {
1590 part->max_u64 = UINT64_C(4294967295);
1591 } else {
1592 part->min_u64 = UINT64_C(0);
1593 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001594 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001595 ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001596 }
1597 break;
1598 case LY_TYPE_UINT64: /* range */
Radek Krejci19a96102018-11-15 13:38:09 +01001599 case LY_TYPE_STRING: /* length */
Radek Krejci25cfef72018-11-23 14:15:52 +01001600 case LY_TYPE_BINARY: /* length */
Radek Krejci19a96102018-11-15 13:38:09 +01001601 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001602 ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(18446744073709551615), 10, max ? &part->max_u64 : &part->min_u64);
Radek Krejci19a96102018-11-15 13:38:09 +01001603 } else if (max) {
1604 part->max_u64 = UINT64_C(18446744073709551615);
1605 } else {
1606 part->min_u64 = UINT64_C(0);
1607 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001608 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001609 ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001610 }
1611 break;
1612 default:
1613 LOGINT(ctx->ctx);
1614 ret = LY_EINT;
1615 }
1616
Radek Krejci5969f272018-11-23 10:03:58 +01001617finalize:
Radek Krejci19a96102018-11-15 13:38:09 +01001618 if (ret == LY_EDENIED) {
1619 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1620 "Invalid %s restriction - value \"%s\" does not fit the type limitations.",
1621 length_restr ? "length" : "range", valcopy ? valcopy : *value);
1622 } else if (ret == LY_EVALID) {
1623 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1624 "Invalid %s restriction - invalid value \"%s\".",
1625 length_restr ? "length" : "range", valcopy ? valcopy : *value);
1626 } else if (ret == LY_EEXIST) {
1627 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1628 "Invalid %s restriction - values are not in ascending order (%s).",
Radek Krejci6cba4292018-11-15 17:33:29 +01001629 length_restr ? "length" : "range",
Radek Krejci5969f272018-11-23 10:03:58 +01001630 (valcopy && basetype != LY_TYPE_DEC64) ? valcopy : value ? *value : max ? "max" : "min");
Radek Krejci19a96102018-11-15 13:38:09 +01001631 } else if (!ret && value) {
1632 *value = *value + len;
1633 }
1634 free(valcopy);
1635 return ret;
1636}
1637
Radek Krejcia3045382018-11-22 14:30:31 +01001638/**
1639 * @brief Compile the parsed range restriction.
1640 * @param[in] ctx Compile context.
1641 * @param[in] range_p Parsed range structure to compile.
1642 * @param[in] basetype Base YANG built-in type of the node with the range restriction.
1643 * @param[in] length_restr Flag to distinguish between range and length restrictions. Only for logging.
1644 * @param[in] frdigits The fraction-digits value in case of LY_TYPE_DEC64 basetype.
1645 * @param[in] base_range Range restriction of the type from which the current type is derived. The current
1646 * range restriction must be more restrictive than the base_range.
1647 * @param[in,out] range Pointer to the created current range structure.
1648 * @return LY_ERR value.
1649 */
Radek Krejci19a96102018-11-15 13:38:09 +01001650static LY_ERR
Michal Vaskoba417ac2020-08-06 14:48:20 +02001651lys_compile_type_range(struct lysc_ctx *ctx, struct lysp_restr *range_p, LY_DATA_TYPE basetype, int length_restr,
1652 uint8_t frdigits, struct lysc_range *base_range, struct lysc_range **range)
Radek Krejci19a96102018-11-15 13:38:09 +01001653{
1654 LY_ERR ret = LY_EVALID;
1655 const char *expr;
1656 struct lysc_range_part *parts = NULL, *part;
1657 int range_expected = 0, uns;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001658 LY_ARRAY_COUNT_TYPE parts_done = 0, u, v;
Radek Krejci19a96102018-11-15 13:38:09 +01001659
1660 assert(range);
1661 assert(range_p);
1662
1663 expr = range_p->arg;
1664 while(1) {
1665 if (isspace(*expr)) {
1666 ++expr;
1667 } else if (*expr == '\0') {
1668 if (range_expected) {
1669 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1670 "Invalid %s restriction - unexpected end of the expression after \"..\" (%s).",
1671 length_restr ? "length" : "range", range_p->arg);
1672 goto cleanup;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001673 } else if (!parts || parts_done == LY_ARRAY_COUNT(parts)) {
Radek Krejci19a96102018-11-15 13:38:09 +01001674 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1675 "Invalid %s restriction - unexpected end of the expression (%s).",
1676 length_restr ? "length" : "range", range_p->arg);
1677 goto cleanup;
1678 }
1679 parts_done++;
1680 break;
1681 } else if (!strncmp(expr, "min", 3)) {
1682 if (parts) {
1683 /* min cannot be used elsewhere than in the first part */
1684 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1685 "Invalid %s restriction - unexpected data before min keyword (%.*s).", length_restr ? "length" : "range",
1686 expr - range_p->arg, range_p->arg);
1687 goto cleanup;
1688 }
1689 expr += 3;
1690
1691 LY_ARRAY_NEW_GOTO(ctx->ctx, parts, part, ret, cleanup);
Radek Krejci5969f272018-11-23 10:03:58 +01001692 LY_CHECK_GOTO(range_part_minmax(ctx, part, 0, 0, basetype, 1, length_restr, frdigits, base_range, NULL), cleanup);
Radek Krejci19a96102018-11-15 13:38:09 +01001693 part->max_64 = part->min_64;
1694 } else if (*expr == '|') {
1695 if (!parts || range_expected) {
1696 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1697 "Invalid %s restriction - unexpected beginning of the expression (%s).", length_restr ? "length" : "range", expr);
1698 goto cleanup;
1699 }
1700 expr++;
1701 parts_done++;
1702 /* process next part of the expression */
1703 } else if (!strncmp(expr, "..", 2)) {
1704 expr += 2;
1705 while (isspace(*expr)) {
1706 expr++;
1707 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001708 if (!parts || LY_ARRAY_COUNT(parts) == parts_done) {
Radek Krejci19a96102018-11-15 13:38:09 +01001709 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1710 "Invalid %s restriction - unexpected \"..\" without a lower bound.", length_restr ? "length" : "range");
1711 goto cleanup;
1712 }
1713 /* continue expecting the upper boundary */
1714 range_expected = 1;
1715 } else if (isdigit(*expr) || (*expr == '-') || (*expr == '+')) {
1716 /* number */
1717 if (range_expected) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001718 part = &parts[LY_ARRAY_COUNT(parts) - 1];
Radek Krejci5969f272018-11-23 10:03:58 +01001719 LY_CHECK_GOTO(range_part_minmax(ctx, part, 1, part->min_64, basetype, 0, length_restr, frdigits, NULL, &expr), cleanup);
Radek Krejci19a96102018-11-15 13:38:09 +01001720 range_expected = 0;
1721 } else {
1722 LY_ARRAY_NEW_GOTO(ctx->ctx, parts, part, ret, cleanup);
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001723 LY_CHECK_GOTO(range_part_minmax(ctx, part, 0, parts_done ? parts[LY_ARRAY_COUNT(parts) - 2].max_64 : 0,
Radek Krejci5969f272018-11-23 10:03:58 +01001724 basetype, parts_done ? 0 : 1, length_restr, frdigits, NULL, &expr), cleanup);
Radek Krejci19a96102018-11-15 13:38:09 +01001725 part->max_64 = part->min_64;
1726 }
1727
1728 /* continue with possible another expression part */
1729 } else if (!strncmp(expr, "max", 3)) {
1730 expr += 3;
1731 while (isspace(*expr)) {
1732 expr++;
1733 }
1734 if (*expr != '\0') {
1735 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid %s restriction - unexpected data after max keyword (%s).",
1736 length_restr ? "length" : "range", expr);
1737 goto cleanup;
1738 }
1739 if (range_expected) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001740 part = &parts[LY_ARRAY_COUNT(parts) - 1];
Radek Krejci5969f272018-11-23 10:03:58 +01001741 LY_CHECK_GOTO(range_part_minmax(ctx, part, 1, part->min_64, basetype, 0, length_restr, frdigits, base_range, NULL), cleanup);
Radek Krejci19a96102018-11-15 13:38:09 +01001742 range_expected = 0;
1743 } else {
1744 LY_ARRAY_NEW_GOTO(ctx->ctx, parts, part, ret, cleanup);
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001745 LY_CHECK_GOTO(range_part_minmax(ctx, part, 1, parts_done ? parts[LY_ARRAY_COUNT(parts) - 2].max_64 : 0,
Radek Krejci5969f272018-11-23 10:03:58 +01001746 basetype, parts_done ? 0 : 1, length_restr, frdigits, base_range, NULL), cleanup);
Radek Krejci19a96102018-11-15 13:38:09 +01001747 part->min_64 = part->max_64;
1748 }
1749 } else {
1750 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid %s restriction - unexpected data (%s).",
1751 length_restr ? "length" : "range", expr);
1752 goto cleanup;
1753 }
1754 }
1755
1756 /* check with the previous range/length restriction */
1757 if (base_range) {
1758 switch (basetype) {
1759 case LY_TYPE_BINARY:
1760 case LY_TYPE_UINT8:
1761 case LY_TYPE_UINT16:
1762 case LY_TYPE_UINT32:
1763 case LY_TYPE_UINT64:
1764 case LY_TYPE_STRING:
1765 uns = 1;
1766 break;
1767 case LY_TYPE_DEC64:
1768 case LY_TYPE_INT8:
1769 case LY_TYPE_INT16:
1770 case LY_TYPE_INT32:
1771 case LY_TYPE_INT64:
1772 uns = 0;
1773 break;
1774 default:
1775 LOGINT(ctx->ctx);
1776 ret = LY_EINT;
1777 goto cleanup;
1778 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001779 for (u = v = 0; u < parts_done && v < LY_ARRAY_COUNT(base_range->parts); ++u) {
Radek Krejci19a96102018-11-15 13:38:09 +01001780 if ((uns && parts[u].min_u64 < base_range->parts[v].min_u64) || (!uns && parts[u].min_64 < base_range->parts[v].min_64)) {
1781 goto baseerror;
1782 }
1783 /* current lower bound is not lower than the base */
1784 if (base_range->parts[v].min_64 == base_range->parts[v].max_64) {
1785 /* base has single value */
1786 if (base_range->parts[v].min_64 == parts[u].min_64) {
1787 /* both lower bounds are the same */
1788 if (parts[u].min_64 != parts[u].max_64) {
1789 /* current continues with a range */
1790 goto baseerror;
1791 } else {
1792 /* equal single values, move both forward */
1793 ++v;
1794 continue;
1795 }
1796 } else {
1797 /* base is single value lower than current range, so the
1798 * value from base range is removed in the current,
1799 * move only base and repeat checking */
1800 ++v;
1801 --u;
1802 continue;
1803 }
1804 } else {
1805 /* base is the range */
1806 if (parts[u].min_64 == parts[u].max_64) {
1807 /* current is a single value */
1808 if ((uns && parts[u].max_u64 > base_range->parts[v].max_u64) || (!uns && parts[u].max_64 > base_range->parts[v].max_64)) {
1809 /* current is behind the base range, so base range is omitted,
1810 * move the base and keep the current for further check */
1811 ++v;
1812 --u;
1813 } /* else it is within the base range, so move the current, but keep the base */
1814 continue;
1815 } else {
1816 /* both are ranges - check the higher bound, the lower was already checked */
1817 if ((uns && parts[u].max_u64 > base_range->parts[v].max_u64) || (!uns && parts[u].max_64 > base_range->parts[v].max_64)) {
1818 /* higher bound is higher than the current higher bound */
1819 if ((uns && parts[u].min_u64 > base_range->parts[v].max_u64) || (!uns && parts[u].min_64 > base_range->parts[v].max_64)) {
1820 /* but the current lower bound is also higher, so the base range is omitted,
1821 * continue with the same current, but move the base */
1822 --u;
1823 ++v;
1824 continue;
1825 }
1826 /* current range starts within the base range but end behind it */
1827 goto baseerror;
1828 } else {
1829 /* current range is smaller than the base,
1830 * move current, but stay with the base */
1831 continue;
1832 }
1833 }
1834 }
1835 }
1836 if (u != parts_done) {
1837baseerror:
1838 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1839 "Invalid %s restriction - the derived restriction (%s) is not equally or more limiting.",
1840 length_restr ? "length" : "range", range_p->arg);
1841 goto cleanup;
1842 }
1843 }
1844
1845 if (!(*range)) {
1846 *range = calloc(1, sizeof **range);
1847 LY_CHECK_ERR_RET(!(*range), LOGMEM(ctx->ctx), LY_EMEM);
1848 }
1849
Radek Krejcic8b31002019-01-08 10:24:45 +01001850 /* we rewrite the following values as the types chain is being processed */
Radek Krejci19a96102018-11-15 13:38:09 +01001851 if (range_p->eapptag) {
1852 lydict_remove(ctx->ctx, (*range)->eapptag);
1853 (*range)->eapptag = lydict_insert(ctx->ctx, range_p->eapptag, 0);
1854 }
1855 if (range_p->emsg) {
1856 lydict_remove(ctx->ctx, (*range)->emsg);
1857 (*range)->emsg = lydict_insert(ctx->ctx, range_p->emsg, 0);
1858 }
Radek Krejcic8b31002019-01-08 10:24:45 +01001859 if (range_p->dsc) {
1860 lydict_remove(ctx->ctx, (*range)->dsc);
1861 (*range)->dsc = lydict_insert(ctx->ctx, range_p->dsc, 0);
1862 }
1863 if (range_p->ref) {
1864 lydict_remove(ctx->ctx, (*range)->ref);
1865 (*range)->ref = lydict_insert(ctx->ctx, range_p->ref, 0);
1866 }
Radek Krejci19a96102018-11-15 13:38:09 +01001867 /* extensions are taken only from the last range by the caller */
1868
1869 (*range)->parts = parts;
1870 parts = NULL;
1871 ret = LY_SUCCESS;
1872cleanup:
Radek Krejci19a96102018-11-15 13:38:09 +01001873 LY_ARRAY_FREE(parts);
1874
1875 return ret;
1876}
1877
1878/**
1879 * @brief Checks pattern syntax.
1880 *
Michal Vasko03ff5a72019-09-11 13:49:33 +02001881 * @param[in] ctx Context.
1882 * @param[in] log_path Path for logging errors.
Radek Krejci19a96102018-11-15 13:38:09 +01001883 * @param[in] pattern Pattern to check.
Radek Krejci54579462019-04-30 12:47:06 +02001884 * @param[in,out] pcre2_code Compiled PCRE2 pattern. If NULL, the compiled information used to validate pattern are freed.
Radek Krejcia3045382018-11-22 14:30:31 +01001885 * @return LY_ERR value - LY_SUCCESS, LY_EMEM, LY_EVALID.
Radek Krejci19a96102018-11-15 13:38:09 +01001886 */
Michal Vasko03ff5a72019-09-11 13:49:33 +02001887LY_ERR
1888lys_compile_type_pattern_check(struct ly_ctx *ctx, const char *log_path, const char *pattern, pcre2_code **code)
Radek Krejci19a96102018-11-15 13:38:09 +01001889{
Michal Vasko40a00082020-05-27 15:20:01 +02001890 int idx, idx2, start, end, size, brack;
Radek Krejci19a96102018-11-15 13:38:09 +01001891 char *perl_regex, *ptr;
Radek Krejci54579462019-04-30 12:47:06 +02001892 int err_code;
1893 const char *orig_ptr;
1894 PCRE2_SIZE err_offset;
1895 pcre2_code *code_local;
Radek Krejci19a96102018-11-15 13:38:09 +01001896#define URANGE_LEN 19
1897 char *ublock2urange[][2] = {
1898 {"BasicLatin", "[\\x{0000}-\\x{007F}]"},
1899 {"Latin-1Supplement", "[\\x{0080}-\\x{00FF}]"},
1900 {"LatinExtended-A", "[\\x{0100}-\\x{017F}]"},
1901 {"LatinExtended-B", "[\\x{0180}-\\x{024F}]"},
1902 {"IPAExtensions", "[\\x{0250}-\\x{02AF}]"},
1903 {"SpacingModifierLetters", "[\\x{02B0}-\\x{02FF}]"},
1904 {"CombiningDiacriticalMarks", "[\\x{0300}-\\x{036F}]"},
1905 {"Greek", "[\\x{0370}-\\x{03FF}]"},
1906 {"Cyrillic", "[\\x{0400}-\\x{04FF}]"},
1907 {"Armenian", "[\\x{0530}-\\x{058F}]"},
1908 {"Hebrew", "[\\x{0590}-\\x{05FF}]"},
1909 {"Arabic", "[\\x{0600}-\\x{06FF}]"},
1910 {"Syriac", "[\\x{0700}-\\x{074F}]"},
1911 {"Thaana", "[\\x{0780}-\\x{07BF}]"},
1912 {"Devanagari", "[\\x{0900}-\\x{097F}]"},
1913 {"Bengali", "[\\x{0980}-\\x{09FF}]"},
1914 {"Gurmukhi", "[\\x{0A00}-\\x{0A7F}]"},
1915 {"Gujarati", "[\\x{0A80}-\\x{0AFF}]"},
1916 {"Oriya", "[\\x{0B00}-\\x{0B7F}]"},
1917 {"Tamil", "[\\x{0B80}-\\x{0BFF}]"},
1918 {"Telugu", "[\\x{0C00}-\\x{0C7F}]"},
1919 {"Kannada", "[\\x{0C80}-\\x{0CFF}]"},
1920 {"Malayalam", "[\\x{0D00}-\\x{0D7F}]"},
1921 {"Sinhala", "[\\x{0D80}-\\x{0DFF}]"},
1922 {"Thai", "[\\x{0E00}-\\x{0E7F}]"},
1923 {"Lao", "[\\x{0E80}-\\x{0EFF}]"},
1924 {"Tibetan", "[\\x{0F00}-\\x{0FFF}]"},
1925 {"Myanmar", "[\\x{1000}-\\x{109F}]"},
1926 {"Georgian", "[\\x{10A0}-\\x{10FF}]"},
1927 {"HangulJamo", "[\\x{1100}-\\x{11FF}]"},
1928 {"Ethiopic", "[\\x{1200}-\\x{137F}]"},
1929 {"Cherokee", "[\\x{13A0}-\\x{13FF}]"},
1930 {"UnifiedCanadianAboriginalSyllabics", "[\\x{1400}-\\x{167F}]"},
1931 {"Ogham", "[\\x{1680}-\\x{169F}]"},
1932 {"Runic", "[\\x{16A0}-\\x{16FF}]"},
1933 {"Khmer", "[\\x{1780}-\\x{17FF}]"},
1934 {"Mongolian", "[\\x{1800}-\\x{18AF}]"},
1935 {"LatinExtendedAdditional", "[\\x{1E00}-\\x{1EFF}]"},
1936 {"GreekExtended", "[\\x{1F00}-\\x{1FFF}]"},
1937 {"GeneralPunctuation", "[\\x{2000}-\\x{206F}]"},
1938 {"SuperscriptsandSubscripts", "[\\x{2070}-\\x{209F}]"},
1939 {"CurrencySymbols", "[\\x{20A0}-\\x{20CF}]"},
1940 {"CombiningMarksforSymbols", "[\\x{20D0}-\\x{20FF}]"},
1941 {"LetterlikeSymbols", "[\\x{2100}-\\x{214F}]"},
1942 {"NumberForms", "[\\x{2150}-\\x{218F}]"},
1943 {"Arrows", "[\\x{2190}-\\x{21FF}]"},
1944 {"MathematicalOperators", "[\\x{2200}-\\x{22FF}]"},
1945 {"MiscellaneousTechnical", "[\\x{2300}-\\x{23FF}]"},
1946 {"ControlPictures", "[\\x{2400}-\\x{243F}]"},
1947 {"OpticalCharacterRecognition", "[\\x{2440}-\\x{245F}]"},
1948 {"EnclosedAlphanumerics", "[\\x{2460}-\\x{24FF}]"},
1949 {"BoxDrawing", "[\\x{2500}-\\x{257F}]"},
1950 {"BlockElements", "[\\x{2580}-\\x{259F}]"},
1951 {"GeometricShapes", "[\\x{25A0}-\\x{25FF}]"},
1952 {"MiscellaneousSymbols", "[\\x{2600}-\\x{26FF}]"},
1953 {"Dingbats", "[\\x{2700}-\\x{27BF}]"},
1954 {"BraillePatterns", "[\\x{2800}-\\x{28FF}]"},
1955 {"CJKRadicalsSupplement", "[\\x{2E80}-\\x{2EFF}]"},
1956 {"KangxiRadicals", "[\\x{2F00}-\\x{2FDF}]"},
1957 {"IdeographicDescriptionCharacters", "[\\x{2FF0}-\\x{2FFF}]"},
1958 {"CJKSymbolsandPunctuation", "[\\x{3000}-\\x{303F}]"},
1959 {"Hiragana", "[\\x{3040}-\\x{309F}]"},
1960 {"Katakana", "[\\x{30A0}-\\x{30FF}]"},
1961 {"Bopomofo", "[\\x{3100}-\\x{312F}]"},
1962 {"HangulCompatibilityJamo", "[\\x{3130}-\\x{318F}]"},
1963 {"Kanbun", "[\\x{3190}-\\x{319F}]"},
1964 {"BopomofoExtended", "[\\x{31A0}-\\x{31BF}]"},
1965 {"EnclosedCJKLettersandMonths", "[\\x{3200}-\\x{32FF}]"},
1966 {"CJKCompatibility", "[\\x{3300}-\\x{33FF}]"},
1967 {"CJKUnifiedIdeographsExtensionA", "[\\x{3400}-\\x{4DB5}]"},
1968 {"CJKUnifiedIdeographs", "[\\x{4E00}-\\x{9FFF}]"},
1969 {"YiSyllables", "[\\x{A000}-\\x{A48F}]"},
1970 {"YiRadicals", "[\\x{A490}-\\x{A4CF}]"},
1971 {"HangulSyllables", "[\\x{AC00}-\\x{D7A3}]"},
1972 {"PrivateUse", "[\\x{E000}-\\x{F8FF}]"},
1973 {"CJKCompatibilityIdeographs", "[\\x{F900}-\\x{FAFF}]"},
1974 {"AlphabeticPresentationForms", "[\\x{FB00}-\\x{FB4F}]"},
1975 {"ArabicPresentationForms-A", "[\\x{FB50}-\\x{FDFF}]"},
1976 {"CombiningHalfMarks", "[\\x{FE20}-\\x{FE2F}]"},
1977 {"CJKCompatibilityForms", "[\\x{FE30}-\\x{FE4F}]"},
1978 {"SmallFormVariants", "[\\x{FE50}-\\x{FE6F}]"},
1979 {"ArabicPresentationForms-B", "[\\x{FE70}-\\x{FEFE}]"},
1980 {"HalfwidthandFullwidthForms", "[\\x{FF00}-\\x{FFEF}]"},
1981 {NULL, NULL}
1982 };
1983
1984 /* adjust the expression to a Perl equivalent
1985 * http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#regexs */
1986
Michal Vasko40a00082020-05-27 15:20:01 +02001987 /* allocate space for the transformed pattern */
1988 size = strlen(pattern) + 1;
1989 perl_regex = malloc(size);
Michal Vasko03ff5a72019-09-11 13:49:33 +02001990 LY_CHECK_ERR_RET(!perl_regex, LOGMEM(ctx), LY_EMEM);
Radek Krejci19a96102018-11-15 13:38:09 +01001991 perl_regex[0] = '\0';
1992
Michal Vasko40a00082020-05-27 15:20:01 +02001993 /* we need to replace all "$" and "^" (that are not in "[]") with "\$" and "\^" */
1994 brack = 0;
1995 idx = 0;
1996 orig_ptr = pattern;
1997 while (orig_ptr[0]) {
1998 switch (orig_ptr[0]) {
1999 case '$':
2000 case '^':
2001 if (!brack) {
2002 /* make space for the extra character */
2003 ++size;
2004 perl_regex = ly_realloc(perl_regex, size);
2005 LY_CHECK_ERR_RET(!perl_regex, LOGMEM(ctx), LY_EMEM);
Radek Krejci19a96102018-11-15 13:38:09 +01002006
Michal Vasko40a00082020-05-27 15:20:01 +02002007 /* print escape slash */
2008 perl_regex[idx] = '\\';
2009 ++idx;
2010 }
2011 break;
2012 case '[':
2013 /* must not be escaped */
2014 if ((orig_ptr == pattern) || (orig_ptr[-1] != '\\')) {
2015 ++brack;
2016 }
2017 break;
2018 case ']':
2019 if ((orig_ptr == pattern) || (orig_ptr[-1] != '\\')) {
2020 /* pattern was checked and compiled already */
2021 assert(brack);
2022 --brack;
2023 }
2024 break;
2025 default:
2026 break;
Radek Krejci19a96102018-11-15 13:38:09 +01002027 }
Michal Vasko40a00082020-05-27 15:20:01 +02002028
2029 /* copy char */
2030 perl_regex[idx] = orig_ptr[0];
2031
2032 ++idx;
2033 ++orig_ptr;
Radek Krejci19a96102018-11-15 13:38:09 +01002034 }
Michal Vasko40a00082020-05-27 15:20:01 +02002035 perl_regex[idx] = '\0';
Radek Krejci19a96102018-11-15 13:38:09 +01002036
2037 /* substitute Unicode Character Blocks with exact Character Ranges */
2038 while ((ptr = strstr(perl_regex, "\\p{Is"))) {
2039 start = ptr - perl_regex;
2040
2041 ptr = strchr(ptr, '}');
2042 if (!ptr) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002043 LOGVAL(ctx, LY_VLOG_STR, log_path, LY_VCODE_INREGEXP,
Radek Krejci19a96102018-11-15 13:38:09 +01002044 pattern, perl_regex + start + 2, "unterminated character property");
2045 free(perl_regex);
2046 return LY_EVALID;
2047 }
2048 end = (ptr - perl_regex) + 1;
2049
2050 /* need more space */
2051 if (end - start < URANGE_LEN) {
2052 perl_regex = ly_realloc(perl_regex, strlen(perl_regex) + (URANGE_LEN - (end - start)) + 1);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002053 LY_CHECK_ERR_RET(!perl_regex, LOGMEM(ctx); free(perl_regex), LY_EMEM);
Radek Krejci19a96102018-11-15 13:38:09 +01002054 }
2055
2056 /* find our range */
2057 for (idx = 0; ublock2urange[idx][0]; ++idx) {
2058 if (!strncmp(perl_regex + start + 5, ublock2urange[idx][0], strlen(ublock2urange[idx][0]))) {
2059 break;
2060 }
2061 }
2062 if (!ublock2urange[idx][0]) {
Michal Vasko03ff5a72019-09-11 13:49:33 +02002063 LOGVAL(ctx, LY_VLOG_STR, log_path, LY_VCODE_INREGEXP,
Radek Krejci19a96102018-11-15 13:38:09 +01002064 pattern, perl_regex + start + 5, "unknown block name");
2065 free(perl_regex);
2066 return LY_EVALID;
2067 }
2068
2069 /* make the space in the string and replace the block (but we cannot include brackets if it was already enclosed in them) */
Michal Vasko40a00082020-05-27 15:20:01 +02002070 for (idx2 = 0, idx = 0; idx2 < start; ++idx2) {
Radek Krejci19a96102018-11-15 13:38:09 +01002071 if ((perl_regex[idx2] == '[') && (!idx2 || (perl_regex[idx2 - 1] != '\\'))) {
Michal Vasko40a00082020-05-27 15:20:01 +02002072 ++idx;
Radek Krejci19a96102018-11-15 13:38:09 +01002073 }
2074 if ((perl_regex[idx2] == ']') && (!idx2 || (perl_regex[idx2 - 1] != '\\'))) {
Michal Vasko40a00082020-05-27 15:20:01 +02002075 --idx;
Radek Krejci19a96102018-11-15 13:38:09 +01002076 }
2077 }
Michal Vasko40a00082020-05-27 15:20:01 +02002078 if (idx) {
Radek Krejci19a96102018-11-15 13:38:09 +01002079 /* skip brackets */
2080 memmove(perl_regex + start + (URANGE_LEN - 2), perl_regex + end, strlen(perl_regex + end) + 1);
2081 memcpy(perl_regex + start, ublock2urange[idx][1] + 1, URANGE_LEN - 2);
2082 } else {
2083 memmove(perl_regex + start + URANGE_LEN, perl_regex + end, strlen(perl_regex + end) + 1);
2084 memcpy(perl_regex + start, ublock2urange[idx][1], URANGE_LEN);
2085 }
2086 }
2087
2088 /* must return 0, already checked during parsing */
Radek Krejci5819f7c2019-05-31 14:53:29 +02002089 code_local = pcre2_compile((PCRE2_SPTR)perl_regex, PCRE2_ZERO_TERMINATED,
2090 PCRE2_UTF | PCRE2_ANCHORED | PCRE2_ENDANCHORED | PCRE2_DOLLAR_ENDONLY | PCRE2_NO_AUTO_CAPTURE,
Radek Krejci54579462019-04-30 12:47:06 +02002091 &err_code, &err_offset, NULL);
2092 if (!code_local) {
2093 PCRE2_UCHAR err_msg[256] = {0};
2094 pcre2_get_error_message(err_code, err_msg, 256);
Michal Vasko03ff5a72019-09-11 13:49:33 +02002095 LOGVAL(ctx, LY_VLOG_STR, log_path, LY_VCODE_INREGEXP, pattern, perl_regex + err_offset, err_msg);
Radek Krejci19a96102018-11-15 13:38:09 +01002096 free(perl_regex);
2097 return LY_EVALID;
2098 }
2099 free(perl_regex);
2100
Radek Krejci54579462019-04-30 12:47:06 +02002101 if (code) {
2102 *code = code_local;
Radek Krejci19a96102018-11-15 13:38:09 +01002103 } else {
Radek Krejci54579462019-04-30 12:47:06 +02002104 free(code_local);
Radek Krejci19a96102018-11-15 13:38:09 +01002105 }
2106
2107 return LY_SUCCESS;
2108
2109#undef URANGE_LEN
2110}
2111
Radek Krejcia3045382018-11-22 14:30:31 +01002112/**
2113 * @brief Compile parsed pattern restriction in conjunction with the patterns from base type.
2114 * @param[in] ctx Compile context.
2115 * @param[in] patterns_p Array of parsed patterns from the current type to compile.
Radek Krejcia3045382018-11-22 14:30:31 +01002116 * @param[in] base_patterns Compiled patterns from the type from which the current type is derived.
2117 * Patterns from the base type are inherited to have all the patterns that have to match at one place.
2118 * @param[out] patterns Pointer to the storage for the patterns of the current type.
2119 * @return LY_ERR LY_SUCCESS, LY_EMEM, LY_EVALID.
2120 */
Radek Krejci19a96102018-11-15 13:38:09 +01002121static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02002122lys_compile_type_patterns(struct lysc_ctx *ctx, struct lysp_restr *patterns_p,
Radek Krejci19a96102018-11-15 13:38:09 +01002123 struct lysc_pattern **base_patterns, struct lysc_pattern ***patterns)
2124{
2125 struct lysc_pattern **pattern;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002126 LY_ARRAY_COUNT_TYPE u;
Radek Krejci19a96102018-11-15 13:38:09 +01002127 LY_ERR ret = LY_SUCCESS;
2128
2129 /* first, copy the patterns from the base type */
2130 if (base_patterns) {
2131 *patterns = lysc_patterns_dup(ctx->ctx, base_patterns);
2132 LY_CHECK_ERR_RET(!(*patterns), LOGMEM(ctx->ctx), LY_EMEM);
2133 }
2134
2135 LY_ARRAY_FOR(patterns_p, u) {
2136 LY_ARRAY_NEW_RET(ctx->ctx, (*patterns), pattern, LY_EMEM);
2137 *pattern = calloc(1, sizeof **pattern);
2138 ++(*pattern)->refcount;
2139
Michal Vasko03ff5a72019-09-11 13:49:33 +02002140 ret = lys_compile_type_pattern_check(ctx->ctx, ctx->path, &patterns_p[u].arg[1], &(*pattern)->code);
Radek Krejci19a96102018-11-15 13:38:09 +01002141 LY_CHECK_RET(ret);
Radek Krejci19a96102018-11-15 13:38:09 +01002142
2143 if (patterns_p[u].arg[0] == 0x15) {
2144 (*pattern)->inverted = 1;
2145 }
Radek Krejci54579462019-04-30 12:47:06 +02002146 DUP_STRING(ctx->ctx, &patterns_p[u].arg[1], (*pattern)->expr);
Radek Krejci19a96102018-11-15 13:38:09 +01002147 DUP_STRING(ctx->ctx, patterns_p[u].eapptag, (*pattern)->eapptag);
2148 DUP_STRING(ctx->ctx, patterns_p[u].emsg, (*pattern)->emsg);
Radek Krejcic8b31002019-01-08 10:24:45 +01002149 DUP_STRING(ctx->ctx, patterns_p[u].dsc, (*pattern)->dsc);
2150 DUP_STRING(ctx->ctx, patterns_p[u].ref, (*pattern)->ref);
Radek Krejci0935f412019-08-20 16:15:18 +02002151 COMPILE_EXTS_GOTO(ctx, patterns_p[u].exts, (*pattern)->exts, (*pattern), LYEXT_PAR_PATTERN, ret, done);
Radek Krejci19a96102018-11-15 13:38:09 +01002152 }
2153done:
2154 return ret;
2155}
2156
Radek Krejcia3045382018-11-22 14:30:31 +01002157/**
2158 * @brief map of the possible restrictions combination for the specific built-in type.
2159 */
Radek Krejci19a96102018-11-15 13:38:09 +01002160static uint16_t type_substmt_map[LY_DATA_TYPE_COUNT] = {
2161 0 /* LY_TYPE_UNKNOWN */,
2162 LYS_SET_LENGTH /* LY_TYPE_BINARY */,
Radek Krejci5969f272018-11-23 10:03:58 +01002163 LYS_SET_RANGE /* LY_TYPE_UINT8 */,
2164 LYS_SET_RANGE /* LY_TYPE_UINT16 */,
2165 LYS_SET_RANGE /* LY_TYPE_UINT32 */,
2166 LYS_SET_RANGE /* LY_TYPE_UINT64 */,
2167 LYS_SET_LENGTH | LYS_SET_PATTERN /* LY_TYPE_STRING */,
Radek Krejci19a96102018-11-15 13:38:09 +01002168 LYS_SET_BIT /* LY_TYPE_BITS */,
2169 0 /* LY_TYPE_BOOL */,
2170 LYS_SET_FRDIGITS | LYS_SET_RANGE /* LY_TYPE_DEC64 */,
2171 0 /* LY_TYPE_EMPTY */,
2172 LYS_SET_ENUM /* LY_TYPE_ENUM */,
2173 LYS_SET_BASE /* LY_TYPE_IDENT */,
2174 LYS_SET_REQINST /* LY_TYPE_INST */,
2175 LYS_SET_REQINST | LYS_SET_PATH /* LY_TYPE_LEAFREF */,
Radek Krejci19a96102018-11-15 13:38:09 +01002176 LYS_SET_TYPE /* LY_TYPE_UNION */,
2177 LYS_SET_RANGE /* LY_TYPE_INT8 */,
Radek Krejci19a96102018-11-15 13:38:09 +01002178 LYS_SET_RANGE /* LY_TYPE_INT16 */,
Radek Krejci19a96102018-11-15 13:38:09 +01002179 LYS_SET_RANGE /* LY_TYPE_INT32 */,
Radek Krejci5969f272018-11-23 10:03:58 +01002180 LYS_SET_RANGE /* LY_TYPE_INT64 */
2181};
2182
2183/**
2184 * @brief stringification of the YANG built-in data types
2185 */
2186const char* ly_data_type2str[LY_DATA_TYPE_COUNT] = {"unknown", "binary", "8bit unsigned integer", "16bit unsigned integer",
2187 "32bit unsigned integer", "64bit unsigned integer", "string", "bits", "boolean", "decimal64", "empty", "enumeration",
2188 "identityref", "instance-identifier", "leafref", "union", "8bit integer", "16bit integer", "32bit integer", "64bit integer"
Radek Krejci19a96102018-11-15 13:38:09 +01002189};
2190
Radek Krejcia3045382018-11-22 14:30:31 +01002191/**
2192 * @brief Compile parsed type's enum structures (for enumeration and bits types).
2193 * @param[in] ctx Compile context.
2194 * @param[in] enums_p Array of the parsed enum structures to compile.
2195 * @param[in] basetype Base YANG built-in type from which the current type is derived. Only LY_TYPE_ENUM and LY_TYPE_BITS are expected.
Radek Krejcia3045382018-11-22 14:30:31 +01002196 * @param[in] base_enums Array of the compiled enums information from the (latest) base type to check if the current enums are compatible.
2197 * @param[out] enums Newly created array of the compiled enums information for the current type.
2198 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
2199 */
Radek Krejci19a96102018-11-15 13:38:09 +01002200static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02002201lys_compile_type_enums(struct lysc_ctx *ctx, struct lysp_type_enum *enums_p, LY_DATA_TYPE basetype,
Radek Krejci693262f2019-04-29 15:23:20 +02002202 struct lysc_type_bitenum_item *base_enums, struct lysc_type_bitenum_item **enums)
Radek Krejci19a96102018-11-15 13:38:09 +01002203{
2204 LY_ERR ret = LY_SUCCESS;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002205 LY_ARRAY_COUNT_TYPE u, v, match = 0;
Radek Krejci19a96102018-11-15 13:38:09 +01002206 int32_t value = 0;
2207 uint32_t position = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02002208 struct lysc_type_bitenum_item *e, storage;
Radek Krejci19a96102018-11-15 13:38:09 +01002209
Radek Krejci0bcdaed2019-01-10 10:21:34 +01002210 if (base_enums && ctx->mod_def->version < 2) {
Radek Krejci19a96102018-11-15 13:38:09 +01002211 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "%s type can be subtyped only in YANG 1.1 modules.",
2212 basetype == LY_TYPE_ENUM ? "Enumeration" : "Bits");
2213 return LY_EVALID;
2214 }
2215
2216 LY_ARRAY_FOR(enums_p, u) {
2217 LY_ARRAY_NEW_RET(ctx->ctx, *enums, e, LY_EMEM);
2218 DUP_STRING(ctx->ctx, enums_p[u].name, e->name);
Radek Krejcic8b31002019-01-08 10:24:45 +01002219 DUP_STRING(ctx->ctx, enums_p[u].ref, e->dsc);
2220 DUP_STRING(ctx->ctx, enums_p[u].ref, e->ref);
Radek Krejci693262f2019-04-29 15:23:20 +02002221 e->flags = enums_p[u].flags & LYS_FLAGS_COMPILED_MASK;
Radek Krejci19a96102018-11-15 13:38:09 +01002222 if (base_enums) {
2223 /* check the enum/bit presence in the base type - the set of enums/bits in the derived type must be a subset */
2224 LY_ARRAY_FOR(base_enums, v) {
2225 if (!strcmp(e->name, base_enums[v].name)) {
2226 break;
2227 }
2228 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002229 if (v == LY_ARRAY_COUNT(base_enums)) {
Radek Krejci19a96102018-11-15 13:38:09 +01002230 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2231 "Invalid %s - derived type adds new item \"%s\".",
2232 basetype == LY_TYPE_ENUM ? "enumeration" : "bits", e->name);
2233 return LY_EVALID;
2234 }
2235 match = v;
2236 }
2237
2238 if (basetype == LY_TYPE_ENUM) {
Radek Krejci693262f2019-04-29 15:23:20 +02002239 e->flags |= LYS_ISENUM;
Radek Krejci19a96102018-11-15 13:38:09 +01002240 if (enums_p[u].flags & LYS_SET_VALUE) {
2241 e->value = (int32_t)enums_p[u].value;
2242 if (!u || e->value >= value) {
2243 value = e->value + 1;
2244 }
2245 /* check collision with other values */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002246 for (v = 0; v < LY_ARRAY_COUNT(*enums) - 1; ++v) {
Radek Krejci19a96102018-11-15 13:38:09 +01002247 if (e->value == (*enums)[v].value) {
2248 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2249 "Invalid enumeration - value %d collide in items \"%s\" and \"%s\".",
2250 e->value, e->name, (*enums)[v].name);
2251 return LY_EVALID;
2252 }
2253 }
2254 } else if (base_enums) {
2255 /* inherit the assigned value */
2256 e->value = base_enums[match].value;
2257 if (!u || e->value >= value) {
2258 value = e->value + 1;
2259 }
2260 } else {
2261 /* assign value automatically */
2262 if (u && value == INT32_MIN) {
2263 /* counter overflow */
2264 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2265 "Invalid enumeration - it is not possible to auto-assign enum value for "
2266 "\"%s\" since the highest value is already 2147483647.", e->name);
2267 return LY_EVALID;
2268 }
2269 e->value = value++;
2270 }
2271 } else { /* LY_TYPE_BITS */
2272 if (enums_p[u].flags & LYS_SET_VALUE) {
2273 e->value = (int32_t)enums_p[u].value;
2274 if (!u || (uint32_t)e->value >= position) {
2275 position = (uint32_t)e->value + 1;
2276 }
2277 /* check collision with other values */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002278 for (v = 0; v < LY_ARRAY_COUNT(*enums) - 1; ++v) {
Radek Krejci19a96102018-11-15 13:38:09 +01002279 if (e->value == (*enums)[v].value) {
2280 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2281 "Invalid bits - position %u collide in items \"%s\" and \"%s\".",
2282 (uint32_t)e->value, e->name, (*enums)[v].name);
2283 return LY_EVALID;
2284 }
2285 }
2286 } else if (base_enums) {
2287 /* inherit the assigned value */
2288 e->value = base_enums[match].value;
2289 if (!u || (uint32_t)e->value >= position) {
2290 position = (uint32_t)e->value + 1;
2291 }
2292 } else {
2293 /* assign value automatically */
2294 if (u && position == 0) {
2295 /* counter overflow */
2296 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2297 "Invalid bits - it is not possible to auto-assign bit position for "
2298 "\"%s\" since the highest value is already 4294967295.", e->name);
2299 return LY_EVALID;
2300 }
2301 e->value = position++;
2302 }
2303 }
2304
2305 if (base_enums) {
2306 /* the assigned values must not change from the derived type */
2307 if (e->value != base_enums[match].value) {
2308 if (basetype == LY_TYPE_ENUM) {
2309 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2310 "Invalid enumeration - value of the item \"%s\" has changed from %d to %d in the derived type.",
2311 e->name, base_enums[match].value, e->value);
2312 } else {
2313 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2314 "Invalid bits - position of the item \"%s\" has changed from %u to %u in the derived type.",
2315 e->name, (uint32_t)base_enums[match].value, (uint32_t)e->value);
2316 }
2317 return LY_EVALID;
2318 }
2319 }
2320
Radek Krejciec4da802019-05-02 13:02:41 +02002321 COMPILE_ARRAY_GOTO(ctx, enums_p[u].iffeatures, e->iffeatures, v, lys_compile_iffeature, ret, done);
Radek Krejci0935f412019-08-20 16:15:18 +02002322 COMPILE_EXTS_GOTO(ctx, enums_p[u].exts, e->exts, e, basetype == LY_TYPE_ENUM ? LYEXT_PAR_TYPE_ENUM : LYEXT_PAR_TYPE_BIT, ret, done);
Radek Krejci19a96102018-11-15 13:38:09 +01002323
2324 if (basetype == LY_TYPE_BITS) {
2325 /* keep bits ordered by position */
2326 for (v = u; v && (*enums)[v - 1].value > e->value; --v);
2327 if (v != u) {
2328 memcpy(&storage, e, sizeof *e);
2329 memmove(&(*enums)[v + 1], &(*enums)[v], (u - v) * sizeof **enums);
2330 memcpy(&(*enums)[v], &storage, sizeof storage);
2331 }
2332 }
2333 }
2334
2335done:
2336 return ret;
2337}
2338
Radek Krejcia3045382018-11-22 14:30:31 +01002339/**
2340 * @brief Parse path-arg (leafref). Get tokens of the path by repetitive calls of the function.
2341 *
2342 * path-arg = absolute-path / relative-path
2343 * absolute-path = 1*("/" (node-identifier *path-predicate))
2344 * relative-path = 1*(".." "/") descendant-path
2345 *
2346 * @param[in,out] path Path to parse.
2347 * @param[out] prefix Prefix of the token, NULL if there is not any.
2348 * @param[out] pref_len Length of the prefix, 0 if there is not any.
2349 * @param[out] name Name of the token.
2350 * @param[out] nam_len Length of the name.
2351 * @param[out] parent_times Number of leading ".." in the path. Must be 0 on the first call,
2352 * must not be changed between consecutive calls. -1 if the
2353 * path is absolute.
2354 * @param[out] has_predicate Flag to mark whether there is a predicate specified.
2355 * @return LY_ERR value: LY_SUCCESS or LY_EINVAL in case of invalid character in the path.
2356 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02002357LY_ERR
Radek Krejcia3045382018-11-22 14:30:31 +01002358lys_path_token(const char **path, const char **prefix, size_t *prefix_len, const char **name, size_t *name_len,
2359 int *parent_times, int *has_predicate)
2360{
2361 int par_times = 0;
2362
2363 assert(path && *path);
2364 assert(parent_times);
2365 assert(prefix);
2366 assert(prefix_len);
2367 assert(name);
2368 assert(name_len);
2369 assert(has_predicate);
2370
2371 *prefix = NULL;
2372 *prefix_len = 0;
2373 *name = NULL;
2374 *name_len = 0;
2375 *has_predicate = 0;
2376
2377 if (!*parent_times) {
2378 if (!strncmp(*path, "..", 2)) {
2379 *path += 2;
2380 ++par_times;
2381 while (!strncmp(*path, "/..", 3)) {
2382 *path += 3;
2383 ++par_times;
2384 }
2385 }
2386 if (par_times) {
2387 *parent_times = par_times;
2388 } else {
2389 *parent_times = -1;
2390 }
2391 }
2392
2393 if (**path != '/') {
2394 return LY_EINVAL;
2395 }
2396 /* skip '/' */
2397 ++(*path);
2398
2399 /* node-identifier ([prefix:]name) */
Radek Krejcib4a4a272019-06-10 12:44:52 +02002400 LY_CHECK_RET(ly_parse_nodeid(path, prefix, prefix_len, name, name_len));
Radek Krejcia3045382018-11-22 14:30:31 +01002401
2402 if ((**path == '/' && (*path)[1]) || !**path) {
2403 /* path continues by another token or this is the last token */
2404 return LY_SUCCESS;
2405 } else if ((*path)[0] != '[') {
2406 /* unexpected character */
2407 return LY_EINVAL;
2408 } else {
2409 /* predicate starting with [ */
2410 *has_predicate = 1;
2411 return LY_SUCCESS;
2412 }
2413}
2414
2415/**
Radek Krejci58d171e2018-11-23 13:50:55 +01002416 * @brief Check the features used in if-feature statements applicable to the leafref and its target.
2417 *
2418 * The set of features used for target must be a subset of features used for the leafref.
2419 * This is not a perfect, we should compare the truth tables but it could require too much resources
2420 * and RFC 7950 does not require it explicitely, so we simplify that.
2421 *
2422 * @param[in] refnode The leafref node.
2423 * @param[in] target Tha target node of the leafref.
2424 * @return LY_SUCCESS or LY_EVALID;
2425 */
2426static LY_ERR
2427lys_compile_leafref_features_validate(const struct lysc_node *refnode, const struct lysc_node *target)
2428{
2429 LY_ERR ret = LY_EVALID;
2430 const struct lysc_node *iter;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002431 LY_ARRAY_COUNT_TYPE u, v, count;
Radek Krejci58d171e2018-11-23 13:50:55 +01002432 struct ly_set features = {0};
2433
2434 for (iter = refnode; iter; iter = iter->parent) {
Radek Krejci056d0a82018-12-06 16:57:25 +01002435 if (iter->iffeatures) {
2436 LY_ARRAY_FOR(iter->iffeatures, u) {
2437 LY_ARRAY_FOR(iter->iffeatures[u].features, v) {
2438 LY_CHECK_GOTO(ly_set_add(&features, iter->iffeatures[u].features[v], 0) == -1, cleanup);
Radek Krejci58d171e2018-11-23 13:50:55 +01002439 }
2440 }
2441 }
2442 }
2443
2444 /* we should have, in features set, a superset of features applicable to the target node.
2445 * So when adding features applicable to the target into the features set, we should not be
2446 * able to actually add any new feature, otherwise it is not a subset of features applicable
2447 * to the leafref itself. */
2448 count = features.count;
2449 for (iter = target; iter; iter = iter->parent) {
Radek Krejci056d0a82018-12-06 16:57:25 +01002450 if (iter->iffeatures) {
2451 LY_ARRAY_FOR(iter->iffeatures, u) {
2452 LY_ARRAY_FOR(iter->iffeatures[u].features, v) {
2453 if ((unsigned int)ly_set_add(&features, iter->iffeatures[u].features[v], 0) >= count) {
Radek Krejci58d171e2018-11-23 13:50:55 +01002454 /* new feature was added (or LY_EMEM) */
2455 goto cleanup;
2456 }
2457 }
2458 }
2459 }
2460 }
2461 ret = LY_SUCCESS;
2462
2463cleanup:
2464 ly_set_erase(&features, NULL);
2465 return ret;
2466}
2467
Michal Vasko004d3152020-06-11 19:59:22 +02002468static LY_ERR lys_compile_type(struct lysc_ctx *ctx, struct lysp_node *context_node_p, uint16_t context_flags,
2469 struct lysp_module *context_mod, const char *context_name, struct lysp_type *type_p,
2470 struct lysc_type **type, const char **units);
Radek Krejcia3045382018-11-22 14:30:31 +01002471
Radek Krejcia3045382018-11-22 14:30:31 +01002472/**
2473 * @brief The core of the lys_compile_type() - compile information about the given type (from typedef or leaf/leaf-list).
2474 * @param[in] ctx Compile context.
Radek Krejcicdfecd92018-11-26 11:27:32 +01002475 * @param[in] context_node_p Schema node where the type/typedef is placed to correctly find the base types.
2476 * @param[in] context_flags Flags of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
2477 * @param[in] context_mod Module of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
2478 * @param[in] context_name Name of the context node or referencing typedef for logging.
Radek Krejcia3045382018-11-22 14:30:31 +01002479 * @param[in] type_p Parsed type to compile.
Radek Krejci0a33b042020-05-27 10:05:06 +02002480 * @param[in] module Context module for the leafref path and identityref (to correctly resolve prefixes)
Radek Krejcia3045382018-11-22 14:30:31 +01002481 * @param[in] basetype Base YANG built-in type of the type to compile.
Radek Krejcia3045382018-11-22 14:30:31 +01002482 * @param[in] tpdfname Name of the type's typedef, serves as a flag - if it is leaf/leaf-list's type, it is NULL.
2483 * @param[in] base The latest base (compiled) type from which the current type is being derived.
2484 * @param[out] type Newly created type structure with the filled information about the type.
2485 * @return LY_ERR value.
2486 */
Radek Krejci19a96102018-11-15 13:38:09 +01002487static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002488lys_compile_type_(struct lysc_ctx *ctx, struct lysp_node *context_node_p, uint16_t context_flags,
2489 struct lysp_module *context_mod, const char *context_name, struct lysp_type *type_p,
2490 struct lys_module *module, LY_DATA_TYPE basetype, const char *tpdfname, struct lysc_type *base,
2491 struct lysc_type **type)
Radek Krejcic5c27e52018-11-15 14:38:11 +01002492{
2493 LY_ERR ret = LY_SUCCESS;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002494 struct lysc_type_bin *bin;
2495 struct lysc_type_num *num;
2496 struct lysc_type_str *str;
2497 struct lysc_type_bits *bits;
2498 struct lysc_type_enum *enumeration;
Radek Krejci6cba4292018-11-15 17:33:29 +01002499 struct lysc_type_dec *dec;
Radek Krejci555cb5b2018-11-16 14:54:33 +01002500 struct lysc_type_identityref *idref;
Michal Vasko004d3152020-06-11 19:59:22 +02002501 struct lysc_type_leafref *lref;
Radek Krejcicdfecd92018-11-26 11:27:32 +01002502 struct lysc_type_union *un, *un_aux;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002503
2504 switch (basetype) {
2505 case LY_TYPE_BINARY:
Radek Krejcic5c27e52018-11-15 14:38:11 +01002506 bin = (struct lysc_type_bin*)(*type);
Radek Krejci555cb5b2018-11-16 14:54:33 +01002507
2508 /* RFC 7950 9.8.1, 9.4.4 - length, number of octets it contains */
Radek Krejcic5c27e52018-11-15 14:38:11 +01002509 if (type_p->length) {
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002510 LY_CHECK_RET(lys_compile_type_range(ctx, type_p->length, basetype, 1, 0,
2511 base ? ((struct lysc_type_bin*)base)->length : NULL, &bin->length));
Radek Krejcic5c27e52018-11-15 14:38:11 +01002512 if (!tpdfname) {
Radek Krejci0935f412019-08-20 16:15:18 +02002513 COMPILE_EXTS_GOTO(ctx, type_p->length->exts, bin->length->exts, bin->length, LYEXT_PAR_LENGTH, ret, done);
Radek Krejcic5c27e52018-11-15 14:38:11 +01002514 }
2515 }
2516
2517 if (tpdfname) {
2518 type_p->compiled = *type;
2519 *type = calloc(1, sizeof(struct lysc_type_bin));
2520 }
2521 break;
2522 case LY_TYPE_BITS:
2523 /* RFC 7950 9.7 - bits */
2524 bits = (struct lysc_type_bits*)(*type);
2525 if (type_p->bits) {
Radek Krejciec4da802019-05-02 13:02:41 +02002526 LY_CHECK_RET(lys_compile_type_enums(ctx, type_p->bits, basetype,
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002527 base ? (struct lysc_type_bitenum_item*)((struct lysc_type_bits*)base)->bits : NULL,
2528 (struct lysc_type_bitenum_item**)&bits->bits));
Radek Krejcic5c27e52018-11-15 14:38:11 +01002529 }
2530
Radek Krejci555cb5b2018-11-16 14:54:33 +01002531 if (!base && !type_p->flags) {
Radek Krejcic5c27e52018-11-15 14:38:11 +01002532 /* type derived from bits built-in type must contain at least one bit */
Radek Krejci6cba4292018-11-15 17:33:29 +01002533 if (tpdfname) {
Radek Krejci555cb5b2018-11-16 14:54:33 +01002534 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "bit", "bits type ", tpdfname);
Radek Krejci6cba4292018-11-15 17:33:29 +01002535 } else {
Radek Krejci555cb5b2018-11-16 14:54:33 +01002536 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "bit", "bits type", "");
Radek Krejci6cba4292018-11-15 17:33:29 +01002537 free(*type);
2538 *type = NULL;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002539 }
Radek Krejci6cba4292018-11-15 17:33:29 +01002540 return LY_EVALID;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002541 }
2542
2543 if (tpdfname) {
2544 type_p->compiled = *type;
2545 *type = calloc(1, sizeof(struct lysc_type_bits));
2546 }
2547 break;
Radek Krejci6cba4292018-11-15 17:33:29 +01002548 case LY_TYPE_DEC64:
2549 dec = (struct lysc_type_dec*)(*type);
2550
2551 /* RFC 7950 9.3.4 - fraction-digits */
Radek Krejci555cb5b2018-11-16 14:54:33 +01002552 if (!base) {
Radek Krejci643c8242018-11-15 17:51:11 +01002553 if (!type_p->fraction_digits) {
2554 if (tpdfname) {
Radek Krejci555cb5b2018-11-16 14:54:33 +01002555 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "fraction-digits", "decimal64 type ", tpdfname);
Radek Krejci643c8242018-11-15 17:51:11 +01002556 } else {
Radek Krejci555cb5b2018-11-16 14:54:33 +01002557 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "fraction-digits", "decimal64 type", "");
Radek Krejci643c8242018-11-15 17:51:11 +01002558 free(*type);
2559 *type = NULL;
2560 }
2561 return LY_EVALID;
2562 }
2563 } else if (type_p->fraction_digits) {
2564 /* fraction digits is prohibited in types not directly derived from built-in decimal64 */
Radek Krejci6cba4292018-11-15 17:33:29 +01002565 if (tpdfname) {
Radek Krejci643c8242018-11-15 17:51:11 +01002566 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2567 "Invalid fraction-digits substatement for type \"%s\" not directly derived from decimal64 built-in type.",
Radek Krejci6cba4292018-11-15 17:33:29 +01002568 tpdfname);
2569 } else {
Radek Krejci643c8242018-11-15 17:51:11 +01002570 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2571 "Invalid fraction-digits substatement for type not directly derived from decimal64 built-in type.");
Radek Krejci6cba4292018-11-15 17:33:29 +01002572 free(*type);
2573 *type = NULL;
2574 }
2575 return LY_EVALID;
2576 }
2577 dec->fraction_digits = type_p->fraction_digits;
2578
2579 /* RFC 7950 9.2.4 - range */
2580 if (type_p->range) {
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002581 LY_CHECK_RET(lys_compile_type_range(ctx, type_p->range, basetype, 0, dec->fraction_digits,
2582 base ? ((struct lysc_type_dec*)base)->range : NULL, &dec->range));
Radek Krejci6cba4292018-11-15 17:33:29 +01002583 if (!tpdfname) {
Radek Krejci0935f412019-08-20 16:15:18 +02002584 COMPILE_EXTS_GOTO(ctx, type_p->range->exts, dec->range->exts, dec->range, LYEXT_PAR_RANGE, ret, done);
Radek Krejci6cba4292018-11-15 17:33:29 +01002585 }
Radek Krejci6cba4292018-11-15 17:33:29 +01002586 }
2587
2588 if (tpdfname) {
2589 type_p->compiled = *type;
2590 *type = calloc(1, sizeof(struct lysc_type_dec));
2591 }
2592 break;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002593 case LY_TYPE_STRING:
Radek Krejcic5c27e52018-11-15 14:38:11 +01002594 str = (struct lysc_type_str*)(*type);
Radek Krejci555cb5b2018-11-16 14:54:33 +01002595
2596 /* RFC 7950 9.4.4 - length */
Radek Krejcic5c27e52018-11-15 14:38:11 +01002597 if (type_p->length) {
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002598 LY_CHECK_RET(lys_compile_type_range(ctx, type_p->length, basetype, 1, 0,
2599 base ? ((struct lysc_type_str*)base)->length : NULL, &str->length));
Radek Krejcic5c27e52018-11-15 14:38:11 +01002600 if (!tpdfname) {
Radek Krejci0935f412019-08-20 16:15:18 +02002601 COMPILE_EXTS_GOTO(ctx, type_p->length->exts, str->length->exts, str->length, LYEXT_PAR_LENGTH, ret, done);
Radek Krejcic5c27e52018-11-15 14:38:11 +01002602 }
2603 } else if (base && ((struct lysc_type_str*)base)->length) {
2604 str->length = lysc_range_dup(ctx->ctx, ((struct lysc_type_str*)base)->length);
2605 }
2606
2607 /* RFC 7950 9.4.5 - pattern */
2608 if (type_p->patterns) {
Radek Krejciec4da802019-05-02 13:02:41 +02002609 LY_CHECK_RET(lys_compile_type_patterns(ctx, type_p->patterns,
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002610 base ? ((struct lysc_type_str*)base)->patterns : NULL, &str->patterns));
Radek Krejcic5c27e52018-11-15 14:38:11 +01002611 } else if (base && ((struct lysc_type_str*)base)->patterns) {
2612 str->patterns = lysc_patterns_dup(ctx->ctx, ((struct lysc_type_str*)base)->patterns);
2613 }
2614
2615 if (tpdfname) {
2616 type_p->compiled = *type;
2617 *type = calloc(1, sizeof(struct lysc_type_str));
2618 }
2619 break;
2620 case LY_TYPE_ENUM:
Radek Krejcic5c27e52018-11-15 14:38:11 +01002621 enumeration = (struct lysc_type_enum*)(*type);
Radek Krejci555cb5b2018-11-16 14:54:33 +01002622
2623 /* RFC 7950 9.6 - enum */
Radek Krejcic5c27e52018-11-15 14:38:11 +01002624 if (type_p->enums) {
Radek Krejciec4da802019-05-02 13:02:41 +02002625 LY_CHECK_RET(lys_compile_type_enums(ctx, type_p->enums, basetype,
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002626 base ? ((struct lysc_type_enum*)base)->enums : NULL, &enumeration->enums));
Radek Krejcic5c27e52018-11-15 14:38:11 +01002627 }
2628
Radek Krejci555cb5b2018-11-16 14:54:33 +01002629 if (!base && !type_p->flags) {
Radek Krejcic5c27e52018-11-15 14:38:11 +01002630 /* type derived from enumerations built-in type must contain at least one enum */
Radek Krejci6cba4292018-11-15 17:33:29 +01002631 if (tpdfname) {
Radek Krejci555cb5b2018-11-16 14:54:33 +01002632 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "enum", "enumeration type ", tpdfname);
Radek Krejci6cba4292018-11-15 17:33:29 +01002633 } else {
Radek Krejci555cb5b2018-11-16 14:54:33 +01002634 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "enum", "enumeration type", "");
Radek Krejci6cba4292018-11-15 17:33:29 +01002635 free(*type);
2636 *type = NULL;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002637 }
Radek Krejci6cba4292018-11-15 17:33:29 +01002638 return LY_EVALID;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002639 }
2640
2641 if (tpdfname) {
2642 type_p->compiled = *type;
2643 *type = calloc(1, sizeof(struct lysc_type_enum));
2644 }
2645 break;
2646 case LY_TYPE_INT8:
2647 case LY_TYPE_UINT8:
2648 case LY_TYPE_INT16:
2649 case LY_TYPE_UINT16:
2650 case LY_TYPE_INT32:
2651 case LY_TYPE_UINT32:
2652 case LY_TYPE_INT64:
2653 case LY_TYPE_UINT64:
Radek Krejcic5c27e52018-11-15 14:38:11 +01002654 num = (struct lysc_type_num*)(*type);
Radek Krejci555cb5b2018-11-16 14:54:33 +01002655
2656 /* RFC 6020 9.2.4 - range */
Radek Krejcic5c27e52018-11-15 14:38:11 +01002657 if (type_p->range) {
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002658 LY_CHECK_RET(lys_compile_type_range(ctx, type_p->range, basetype, 0, 0,
2659 base ? ((struct lysc_type_num*)base)->range : NULL, &num->range));
Radek Krejcic5c27e52018-11-15 14:38:11 +01002660 if (!tpdfname) {
Radek Krejci0935f412019-08-20 16:15:18 +02002661 COMPILE_EXTS_GOTO(ctx, type_p->range->exts, num->range->exts, num->range, LYEXT_PAR_RANGE, ret, done);
Radek Krejcic5c27e52018-11-15 14:38:11 +01002662 }
2663 }
2664
2665 if (tpdfname) {
2666 type_p->compiled = *type;
2667 *type = calloc(1, sizeof(struct lysc_type_num));
2668 }
2669 break;
Radek Krejci555cb5b2018-11-16 14:54:33 +01002670 case LY_TYPE_IDENT:
2671 idref = (struct lysc_type_identityref*)(*type);
2672
2673 /* RFC 7950 9.10.2 - base */
2674 if (type_p->bases) {
2675 if (base) {
2676 /* only the directly derived identityrefs can contain base specification */
2677 if (tpdfname) {
2678 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
Radek Krejcicdfecd92018-11-26 11:27:32 +01002679 "Invalid base substatement for the type \"%s\" not directly derived from identityref built-in type.",
Radek Krejci555cb5b2018-11-16 14:54:33 +01002680 tpdfname);
2681 } else {
2682 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
Radek Krejcicdfecd92018-11-26 11:27:32 +01002683 "Invalid base substatement for the type not directly derived from identityref built-in type.");
Radek Krejci555cb5b2018-11-16 14:54:33 +01002684 free(*type);
2685 *type = NULL;
2686 }
2687 return LY_EVALID;
2688 }
Radek Krejci0a33b042020-05-27 10:05:06 +02002689 LY_CHECK_RET(lys_compile_identity_bases(ctx, module, type_p->bases, NULL, &idref->bases));
Radek Krejci555cb5b2018-11-16 14:54:33 +01002690 }
2691
2692 if (!base && !type_p->flags) {
2693 /* type derived from identityref built-in type must contain at least one base */
2694 if (tpdfname) {
2695 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "base", "identityref type ", tpdfname);
2696 } else {
2697 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "base", "identityref type", "");
2698 free(*type);
2699 *type = NULL;
2700 }
2701 return LY_EVALID;
2702 }
2703
2704 if (tpdfname) {
2705 type_p->compiled = *type;
2706 *type = calloc(1, sizeof(struct lysc_type_identityref));
2707 }
2708 break;
Radek Krejcia3045382018-11-22 14:30:31 +01002709 case LY_TYPE_LEAFREF:
Michal Vasko004d3152020-06-11 19:59:22 +02002710 lref = (struct lysc_type_leafref*)*type;
2711
Radek Krejcia3045382018-11-22 14:30:31 +01002712 /* RFC 7950 9.9.3 - require-instance */
2713 if (type_p->flags & LYS_SET_REQINST) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +01002714 if (context_mod->mod->version < LYS_VERSION_1_1) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +01002715 if (tpdfname) {
2716 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
2717 "Leafref type \"%s\" can be restricted by require-instance statement only in YANG 1.1 modules.", tpdfname);
2718 } else {
2719 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
2720 "Leafref type can be restricted by require-instance statement only in YANG 1.1 modules.");
2721 free(*type);
2722 *type = NULL;
2723 }
2724 return LY_EVALID;
2725 }
Michal Vasko004d3152020-06-11 19:59:22 +02002726 lref->require_instance = type_p->require_instance;
Radek Krejci412ddfa2018-11-23 11:44:11 +01002727 } else if (base) {
2728 /* inherit */
Michal Vasko004d3152020-06-11 19:59:22 +02002729 lref->require_instance = ((struct lysc_type_leafref *)base)->require_instance;
Radek Krejcia3045382018-11-22 14:30:31 +01002730 } else {
2731 /* default is true */
Michal Vasko004d3152020-06-11 19:59:22 +02002732 lref->require_instance = 1;
Radek Krejcia3045382018-11-22 14:30:31 +01002733 }
2734 if (type_p->path) {
Michal Vasko004d3152020-06-11 19:59:22 +02002735 lref->path = lyxp_expr_dup(ctx->ctx, type_p->path);
2736 lref->path_context = module;
Radek Krejcia3045382018-11-22 14:30:31 +01002737 } else if (base) {
Michal Vasko004d3152020-06-11 19:59:22 +02002738 lref->path = lyxp_expr_dup(ctx->ctx, ((struct lysc_type_leafref*)base)->path);
2739 lref->path_context = ((struct lysc_type_leafref*)base)->path_context;
Radek Krejcia3045382018-11-22 14:30:31 +01002740 } else if (tpdfname) {
2741 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "path", "leafref type ", tpdfname);
2742 return LY_EVALID;
2743 } else {
2744 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "path", "leafref type", "");
2745 free(*type);
2746 *type = NULL;
2747 return LY_EVALID;
2748 }
2749 if (tpdfname) {
2750 type_p->compiled = *type;
2751 *type = calloc(1, sizeof(struct lysc_type_leafref));
2752 }
2753 break;
Radek Krejci16c0f822018-11-16 10:46:10 +01002754 case LY_TYPE_INST:
2755 /* RFC 7950 9.9.3 - require-instance */
2756 if (type_p->flags & LYS_SET_REQINST) {
2757 ((struct lysc_type_instanceid*)(*type))->require_instance = type_p->require_instance;
2758 } else {
2759 /* default is true */
2760 ((struct lysc_type_instanceid*)(*type))->require_instance = 1;
2761 }
2762
2763 if (tpdfname) {
2764 type_p->compiled = *type;
2765 *type = calloc(1, sizeof(struct lysc_type_instanceid));
2766 }
2767 break;
Radek Krejcicdfecd92018-11-26 11:27:32 +01002768 case LY_TYPE_UNION:
2769 un = (struct lysc_type_union*)(*type);
2770
2771 /* RFC 7950 7.4 - type */
2772 if (type_p->types) {
2773 if (base) {
2774 /* only the directly derived union can contain types specification */
2775 if (tpdfname) {
2776 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2777 "Invalid type substatement for the type \"%s\" not directly derived from union built-in type.",
2778 tpdfname);
2779 } else {
2780 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2781 "Invalid type substatement for the type not directly derived from union built-in type.");
2782 free(*type);
2783 *type = NULL;
2784 }
2785 return LY_EVALID;
2786 }
2787 /* compile the type */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002788 LY_ARRAY_CREATE_RET(ctx->ctx, un->types, LY_ARRAY_COUNT(type_p->types), LY_EVALID);
2789 for (LY_ARRAY_COUNT_TYPE u = 0, additional = 0; u < LY_ARRAY_COUNT(type_p->types); ++u) {
Michal Vasko004d3152020-06-11 19:59:22 +02002790 LY_CHECK_RET(lys_compile_type(ctx, context_node_p, context_flags, context_mod, context_name,
2791 &type_p->types[u], &un->types[u + additional], NULL));
Radek Krejcicdfecd92018-11-26 11:27:32 +01002792 if (un->types[u + additional]->basetype == LY_TYPE_UNION) {
2793 /* add space for additional types from the union subtype */
2794 un_aux = (struct lysc_type_union *)un->types[u + additional];
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002795 LY_ARRAY_RESIZE_ERR_RET(ctx->ctx, un->types, (*((uint64_t*)(type_p->types) - 1)) + additional + LY_ARRAY_COUNT(un_aux->types) - 1,
Radek Krejcic4fa0292020-05-14 10:54:49 +02002796 lysc_type_free(ctx->ctx, (struct lysc_type*)un_aux), LY_EMEM);
Radek Krejcicdfecd92018-11-26 11:27:32 +01002797
2798 /* copy subtypes of the subtype union */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002799 for (LY_ARRAY_COUNT_TYPE v = 0; v < LY_ARRAY_COUNT(un_aux->types); ++v) {
Radek Krejcicdfecd92018-11-26 11:27:32 +01002800 if (un_aux->types[v]->basetype == LY_TYPE_LEAFREF) {
2801 /* duplicate the whole structure because of the instance-specific path resolving for realtype */
2802 un->types[u + additional] = calloc(1, sizeof(struct lysc_type_leafref));
2803 LY_CHECK_ERR_RET(!un->types[u + additional], LOGMEM(ctx->ctx);lysc_type_free(ctx->ctx, (struct lysc_type*)un_aux), LY_EMEM);
Michal Vasko004d3152020-06-11 19:59:22 +02002804 lref = (struct lysc_type_leafref *)un->types[u + additional];
2805
2806 lref->basetype = LY_TYPE_LEAFREF;
2807 lref->path = lyxp_expr_dup(ctx->ctx, ((struct lysc_type_leafref*)un_aux->types[v])->path);
2808 lref->refcount = 1;
2809 lref->require_instance = ((struct lysc_type_leafref*)un_aux->types[v])->require_instance;
2810 lref->path_context = ((struct lysc_type_leafref*)un_aux->types[v])->path_context;
Radek Krejcicdfecd92018-11-26 11:27:32 +01002811 /* TODO extensions */
2812
2813 } else {
2814 un->types[u + additional] = un_aux->types[v];
2815 ++un_aux->types[v]->refcount;
2816 }
2817 ++additional;
2818 LY_ARRAY_INCREMENT(un->types);
2819 }
2820 /* compensate u increment in main loop */
2821 --additional;
2822
2823 /* free the replaced union subtype */
2824 lysc_type_free(ctx->ctx, (struct lysc_type*)un_aux);
2825 } else {
2826 LY_ARRAY_INCREMENT(un->types);
2827 }
Radek Krejcicdfecd92018-11-26 11:27:32 +01002828 }
2829 }
2830
2831 if (!base && !type_p->flags) {
2832 /* type derived from union built-in type must contain at least one type */
2833 if (tpdfname) {
2834 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "type", "union type ", tpdfname);
2835 } else {
2836 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "type", "union type", "");
2837 free(*type);
2838 *type = NULL;
2839 }
2840 return LY_EVALID;
2841 }
2842
2843 if (tpdfname) {
2844 type_p->compiled = *type;
2845 *type = calloc(1, sizeof(struct lysc_type_union));
2846 }
2847 break;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002848 case LY_TYPE_BOOL:
2849 case LY_TYPE_EMPTY:
2850 case LY_TYPE_UNKNOWN: /* just to complete switch */
2851 break;
2852 }
2853 LY_CHECK_ERR_RET(!(*type), LOGMEM(ctx->ctx), LY_EMEM);
2854done:
2855 return ret;
2856}
2857
Radek Krejcia3045382018-11-22 14:30:31 +01002858/**
2859 * @brief Compile information about the leaf/leaf-list's type.
2860 * @param[in] ctx Compile context.
Radek Krejcicdfecd92018-11-26 11:27:32 +01002861 * @param[in] context_node_p Schema node where the type/typedef is placed to correctly find the base types.
2862 * @param[in] context_flags Flags of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
2863 * @param[in] context_mod Module of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
2864 * @param[in] context_name Name of the context node or referencing typedef for logging.
2865 * @param[in] type_p Parsed type to compile.
Radek Krejcia3045382018-11-22 14:30:31 +01002866 * @param[out] type Newly created (or reused with increased refcount) type structure with the filled information about the type.
Radek Krejcicdfecd92018-11-26 11:27:32 +01002867 * @param[out] units Storage for inheriting units value from the typedefs the current type derives from.
Radek Krejcia3045382018-11-22 14:30:31 +01002868 * @return LY_ERR value.
2869 */
Radek Krejcic5c27e52018-11-15 14:38:11 +01002870static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02002871lys_compile_type(struct lysc_ctx *ctx, struct lysp_node *context_node_p, uint16_t context_flags,
2872 struct lysp_module *context_mod, const char *context_name, struct lysp_type *type_p,
2873 struct lysc_type **type, const char **units)
Radek Krejci19a96102018-11-15 13:38:09 +01002874{
2875 LY_ERR ret = LY_SUCCESS;
2876 unsigned int u;
Radek Krejcicdfecd92018-11-26 11:27:32 +01002877 int dummyloops = 0;
Radek Krejci19a96102018-11-15 13:38:09 +01002878 struct type_context {
2879 const struct lysp_tpdf *tpdf;
2880 struct lysp_node *node;
2881 struct lysp_module *mod;
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002882 } *tctx, *tctx_prev = NULL, *tctx_iter;
Radek Krejci19a96102018-11-15 13:38:09 +01002883 LY_DATA_TYPE basetype = LY_TYPE_UNKNOWN;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002884 struct lysc_type *base = NULL, *prev_type;
Radek Krejci19a96102018-11-15 13:38:09 +01002885 struct ly_set tpdf_chain = {0};
Radek Krejci01342af2019-01-03 15:18:08 +01002886 const char *dflt = NULL;
Radek Krejcia1911222019-07-22 17:24:50 +02002887 struct lys_module *dflt_mod = NULL;
Radek Krejci19a96102018-11-15 13:38:09 +01002888
2889 (*type) = NULL;
2890
2891 tctx = calloc(1, sizeof *tctx);
2892 LY_CHECK_ERR_RET(!tctx, LOGMEM(ctx->ctx), LY_EMEM);
Radek Krejcie86bf772018-12-14 11:39:53 +01002893 for (ret = lysp_type_find(type_p->name, context_node_p, ctx->mod_def->parsed,
Radek Krejci19a96102018-11-15 13:38:09 +01002894 &basetype, &tctx->tpdf, &tctx->node, &tctx->mod);
2895 ret == LY_SUCCESS;
2896 ret = lysp_type_find(tctx_prev->tpdf->type.name, tctx_prev->node, tctx_prev->mod,
2897 &basetype, &tctx->tpdf, &tctx->node, &tctx->mod)) {
2898 if (basetype) {
2899 break;
2900 }
2901
2902 /* check status */
Radek Krejcicdfecd92018-11-26 11:27:32 +01002903 ret = lysc_check_status(ctx, context_flags, context_mod, context_name,
2904 tctx->tpdf->flags, tctx->mod, tctx->node ? tctx->node->name : tctx->tpdf->name);
Radek Krejci19a96102018-11-15 13:38:09 +01002905 LY_CHECK_ERR_GOTO(ret, free(tctx), cleanup);
2906
Radek Krejcicdfecd92018-11-26 11:27:32 +01002907 if (units && !*units) {
2908 /* inherit units */
2909 DUP_STRING(ctx->ctx, tctx->tpdf->units, *units);
2910 }
Radek Krejci01342af2019-01-03 15:18:08 +01002911 if (!dflt) {
Radek Krejcicdfecd92018-11-26 11:27:32 +01002912 /* inherit default */
Radek Krejci01342af2019-01-03 15:18:08 +01002913 dflt = tctx->tpdf->dflt;
Radek Krejcia1911222019-07-22 17:24:50 +02002914 dflt_mod = tctx->mod->mod;
Radek Krejcicdfecd92018-11-26 11:27:32 +01002915 }
Radek Krejci01342af2019-01-03 15:18:08 +01002916 if (dummyloops && (!units || *units) && dflt) {
Radek Krejcicdfecd92018-11-26 11:27:32 +01002917 basetype = ((struct type_context*)tpdf_chain.objs[tpdf_chain.count - 1])->tpdf->type.compiled->basetype;
2918 break;
2919 }
2920
Radek Krejci19a96102018-11-15 13:38:09 +01002921 if (tctx->tpdf->type.compiled) {
Radek Krejcicdfecd92018-11-26 11:27:32 +01002922 /* it is not necessary to continue, the rest of the chain was already compiled,
2923 * but we still may need to inherit default and units values, so start dummy loops */
Radek Krejci19a96102018-11-15 13:38:09 +01002924 basetype = tctx->tpdf->type.compiled->basetype;
2925 ly_set_add(&tpdf_chain, tctx, LY_SET_OPT_USEASLIST);
Radek Krejci01342af2019-01-03 15:18:08 +01002926 if ((units && !*units) || !dflt) {
Radek Krejcicdfecd92018-11-26 11:27:32 +01002927 dummyloops = 1;
2928 goto preparenext;
2929 } else {
2930 tctx = NULL;
2931 break;
2932 }
Radek Krejci19a96102018-11-15 13:38:09 +01002933 }
2934
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002935 /* circular typedef reference detection */
2936 for (u = 0; u < tpdf_chain.count; u++) {
2937 /* local part */
2938 tctx_iter = (struct type_context*)tpdf_chain.objs[u];
2939 if (tctx_iter->mod == tctx->mod && tctx_iter->node == tctx->node && tctx_iter->tpdf == tctx->tpdf) {
2940 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
2941 "Invalid \"%s\" type reference - circular chain of types detected.", tctx->tpdf->name);
2942 free(tctx);
2943 ret = LY_EVALID;
2944 goto cleanup;
2945 }
2946 }
2947 for (u = 0; u < ctx->tpdf_chain.count; u++) {
2948 /* global part for unions corner case */
2949 tctx_iter = (struct type_context*)ctx->tpdf_chain.objs[u];
2950 if (tctx_iter->mod == tctx->mod && tctx_iter->node == tctx->node && tctx_iter->tpdf == tctx->tpdf) {
2951 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
2952 "Invalid \"%s\" type reference - circular chain of types detected.", tctx->tpdf->name);
2953 free(tctx);
2954 ret = LY_EVALID;
2955 goto cleanup;
2956 }
2957 }
2958
Radek Krejci19a96102018-11-15 13:38:09 +01002959 /* store information for the following processing */
2960 ly_set_add(&tpdf_chain, tctx, LY_SET_OPT_USEASLIST);
2961
Radek Krejcicdfecd92018-11-26 11:27:32 +01002962preparenext:
Radek Krejci19a96102018-11-15 13:38:09 +01002963 /* prepare next loop */
2964 tctx_prev = tctx;
2965 tctx = calloc(1, sizeof *tctx);
2966 LY_CHECK_ERR_RET(!tctx, LOGMEM(ctx->ctx), LY_EMEM);
2967 }
2968 free(tctx);
2969
2970 /* allocate type according to the basetype */
2971 switch (basetype) {
2972 case LY_TYPE_BINARY:
2973 *type = calloc(1, sizeof(struct lysc_type_bin));
Radek Krejci19a96102018-11-15 13:38:09 +01002974 break;
2975 case LY_TYPE_BITS:
2976 *type = calloc(1, sizeof(struct lysc_type_bits));
Radek Krejci19a96102018-11-15 13:38:09 +01002977 break;
2978 case LY_TYPE_BOOL:
2979 case LY_TYPE_EMPTY:
2980 *type = calloc(1, sizeof(struct lysc_type));
2981 break;
2982 case LY_TYPE_DEC64:
2983 *type = calloc(1, sizeof(struct lysc_type_dec));
2984 break;
2985 case LY_TYPE_ENUM:
2986 *type = calloc(1, sizeof(struct lysc_type_enum));
Radek Krejci19a96102018-11-15 13:38:09 +01002987 break;
2988 case LY_TYPE_IDENT:
2989 *type = calloc(1, sizeof(struct lysc_type_identityref));
2990 break;
2991 case LY_TYPE_INST:
2992 *type = calloc(1, sizeof(struct lysc_type_instanceid));
2993 break;
2994 case LY_TYPE_LEAFREF:
2995 *type = calloc(1, sizeof(struct lysc_type_leafref));
2996 break;
2997 case LY_TYPE_STRING:
2998 *type = calloc(1, sizeof(struct lysc_type_str));
Radek Krejci19a96102018-11-15 13:38:09 +01002999 break;
3000 case LY_TYPE_UNION:
3001 *type = calloc(1, sizeof(struct lysc_type_union));
3002 break;
3003 case LY_TYPE_INT8:
3004 case LY_TYPE_UINT8:
3005 case LY_TYPE_INT16:
3006 case LY_TYPE_UINT16:
3007 case LY_TYPE_INT32:
3008 case LY_TYPE_UINT32:
3009 case LY_TYPE_INT64:
3010 case LY_TYPE_UINT64:
3011 *type = calloc(1, sizeof(struct lysc_type_num));
Radek Krejci19a96102018-11-15 13:38:09 +01003012 break;
3013 case LY_TYPE_UNKNOWN:
3014 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
3015 "Referenced type \"%s\" not found.", tctx_prev ? tctx_prev->tpdf->type.name : type_p->name);
3016 ret = LY_EVALID;
3017 goto cleanup;
3018 }
3019 LY_CHECK_ERR_GOTO(!(*type), LOGMEM(ctx->ctx), cleanup);
Radek Krejcicdfecd92018-11-26 11:27:32 +01003020 if (~type_substmt_map[basetype] & type_p->flags) {
Radek Krejci19a96102018-11-15 13:38:09 +01003021 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid type restrictions for %s type.",
3022 ly_data_type2str[basetype]);
3023 free(*type);
3024 (*type) = NULL;
3025 ret = LY_EVALID;
3026 goto cleanup;
3027 }
3028
3029 /* get restrictions from the referred typedefs */
3030 for (u = tpdf_chain.count - 1; u + 1 > 0; --u) {
3031 tctx = (struct type_context*)tpdf_chain.objs[u];
Radek Krejci99b5b2a2019-04-30 16:57:04 +02003032
3033 /* remember the typedef context for circular check */
3034 ly_set_add(&ctx->tpdf_chain, tctx, LY_SET_OPT_USEASLIST);
3035
Radek Krejci43699232018-11-23 14:59:46 +01003036 if (tctx->tpdf->type.compiled) {
Radek Krejci19a96102018-11-15 13:38:09 +01003037 base = tctx->tpdf->type.compiled;
3038 continue;
Radek Krejci43699232018-11-23 14:59:46 +01003039 } else if (basetype != LY_TYPE_LEAFREF && (u != tpdf_chain.count - 1) && !(tctx->tpdf->type.flags)) {
Radek Krejci19a96102018-11-15 13:38:09 +01003040 /* no change, just use the type information from the base */
3041 base = ((struct lysp_tpdf*)tctx->tpdf)->type.compiled = ((struct type_context*)tpdf_chain.objs[u + 1])->tpdf->type.compiled;
3042 ++base->refcount;
3043 continue;
3044 }
3045
3046 ++(*type)->refcount;
Radek Krejci43699232018-11-23 14:59:46 +01003047 if (~type_substmt_map[basetype] & tctx->tpdf->type.flags) {
3048 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid type \"%s\" restriction(s) for %s type.",
3049 tctx->tpdf->name, ly_data_type2str[basetype]);
3050 ret = LY_EVALID;
3051 goto cleanup;
3052 } else if (basetype == LY_TYPE_EMPTY && tctx->tpdf->dflt) {
3053 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3054 "Invalid type \"%s\" - \"empty\" type must not have a default value (%s).",
3055 tctx->tpdf->name, tctx->tpdf->dflt);
3056 ret = LY_EVALID;
3057 goto cleanup;
3058 }
3059
Radek Krejci19a96102018-11-15 13:38:09 +01003060 (*type)->basetype = basetype;
Radek Krejcie7b95092019-05-15 11:03:07 +02003061 /* TODO user type plugins */
3062 (*type)->plugin = &ly_builtin_type_plugins[basetype];
Radek Krejcic5c27e52018-11-15 14:38:11 +01003063 prev_type = *type;
Radek Krejcicdfecd92018-11-26 11:27:32 +01003064 ret = lys_compile_type_(ctx, tctx->node, tctx->tpdf->flags, tctx->mod, tctx->tpdf->name, &((struct lysp_tpdf*)tctx->tpdf)->type,
Radek Krejci96a0bfd2018-11-22 15:25:06 +01003065 basetype & (LY_TYPE_LEAFREF | LY_TYPE_UNION) ? lysp_find_module(ctx->ctx, tctx->mod) : NULL,
Radek Krejciec4da802019-05-02 13:02:41 +02003066 basetype, tctx->tpdf->name, base, type);
Radek Krejcic5c27e52018-11-15 14:38:11 +01003067 LY_CHECK_GOTO(ret, cleanup);
3068 base = prev_type;
Radek Krejci19a96102018-11-15 13:38:09 +01003069 }
Radek Krejci99b5b2a2019-04-30 16:57:04 +02003070 /* remove the processed typedef contexts from the stack for circular check */
3071 ctx->tpdf_chain.count = ctx->tpdf_chain.count - tpdf_chain.count;
Radek Krejci19a96102018-11-15 13:38:09 +01003072
Radek Krejcic5c27e52018-11-15 14:38:11 +01003073 /* process the type definition in leaf */
Radek Krejcicdfecd92018-11-26 11:27:32 +01003074 if (type_p->flags || !base || basetype == LY_TYPE_LEAFREF) {
Radek Krejcia3045382018-11-22 14:30:31 +01003075 /* get restrictions from the node itself */
Radek Krejci19a96102018-11-15 13:38:09 +01003076 (*type)->basetype = basetype;
Radek Krejcie7b95092019-05-15 11:03:07 +02003077 /* TODO user type plugins */
3078 (*type)->plugin = &ly_builtin_type_plugins[basetype];
Radek Krejci19a96102018-11-15 13:38:09 +01003079 ++(*type)->refcount;
Radek Krejciec4da802019-05-02 13:02:41 +02003080 ret = lys_compile_type_(ctx, context_node_p, context_flags, context_mod, context_name, type_p, ctx->mod_def, basetype, NULL, base, type);
Radek Krejcic5c27e52018-11-15 14:38:11 +01003081 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci90b148f2020-05-06 17:49:40 +02003082 } else if (basetype != LY_TYPE_BOOL && basetype != LY_TYPE_EMPTY) {
Radek Krejci19a96102018-11-15 13:38:09 +01003083 /* no specific restriction in leaf's type definition, copy from the base */
3084 free(*type);
3085 (*type) = base;
3086 ++(*type)->refcount;
Radek Krejci19a96102018-11-15 13:38:09 +01003087 }
Radek Krejcia1911222019-07-22 17:24:50 +02003088 if (dflt && !(*type)->dflt) {
3089 struct ly_err_item *err = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003090 (*type)->dflt_mod = dflt_mod;
Radek Krejcia1911222019-07-22 17:24:50 +02003091 (*type)->dflt = calloc(1, sizeof *(*type)->dflt);
3092 (*type)->dflt->realtype = (*type);
3093 ret = (*type)->plugin->store(ctx->ctx, (*type), dflt, strlen(dflt),
3094 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003095 lys_resolve_prefix, (void*)(*type)->dflt_mod, LYD_XML, NULL, NULL, (*type)->dflt, NULL, &err);
Radek Krejcia1911222019-07-22 17:24:50 +02003096 if (err) {
3097 ly_err_print(err);
3098 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3099 "Invalid type's default value \"%s\" which does not fit the type (%s).", dflt, err->msg);
3100 ly_err_free(err);
3101 }
Radek Krejci1c0c3442019-07-23 16:08:47 +02003102 if (ret == LY_EINCOMPLETE) {
3103 /* postpone default compilation when the tree is complete */
Radek Krejci474f9b82019-07-24 11:36:37 +02003104 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, NULL, (*type)->dflt, (*type)->dflt_mod), cleanup);
Radek Krejci1c0c3442019-07-23 16:08:47 +02003105
3106 /* but in general result is so far ok */
3107 ret = LY_SUCCESS;
3108 }
Radek Krejcia1911222019-07-22 17:24:50 +02003109 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci01342af2019-01-03 15:18:08 +01003110 }
Radek Krejci19a96102018-11-15 13:38:09 +01003111
Radek Krejci0935f412019-08-20 16:15:18 +02003112 COMPILE_EXTS_GOTO(ctx, type_p->exts, (*type)->exts, (*type), LYEXT_PAR_TYPE, ret, cleanup);
Radek Krejci19a96102018-11-15 13:38:09 +01003113
3114cleanup:
3115 ly_set_erase(&tpdf_chain, free);
3116 return ret;
3117}
3118
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003119/**
3120 * @brief Compile status information of the given node.
3121 *
3122 * To simplify getting status of the node, the flags are set following inheritance rules, so all the nodes
3123 * has the status correctly set during the compilation.
3124 *
3125 * @param[in] ctx Compile context
3126 * @param[in,out] node_flags Flags of the compiled node which status is supposed to be resolved.
3127 * If the status was set explicitly on the node, it is already set in the flags value and we just check
3128 * the compatibility with the parent's status value.
3129 * @param[in] parent_flags Flags of the parent node to check/inherit the status value.
3130 * @return LY_ERR value.
3131 */
3132static LY_ERR
3133lys_compile_status(struct lysc_ctx *ctx, uint16_t *node_flags, uint16_t parent_flags)
3134{
3135 /* status - it is not inherited by specification, but it does not make sense to have
3136 * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
3137 if (!((*node_flags) & LYS_STATUS_MASK)) {
3138 if (parent_flags & (LYS_STATUS_DEPRC | LYS_STATUS_OBSLT)) {
3139 if ((parent_flags & 0x3) != 0x3) {
3140 /* do not print the warning when inheriting status from uses - the uses_status value has a special
3141 * combination of bits (0x3) which marks the uses_status value */
3142 LOGWRN(ctx->ctx, "Missing explicit \"%s\" status that was already specified in parent, inheriting.",
3143 (parent_flags & LYS_STATUS_DEPRC) ? "deprecated" : "obsolete");
3144 }
3145 (*node_flags) |= parent_flags & LYS_STATUS_MASK;
3146 } else {
3147 (*node_flags) |= LYS_STATUS_CURR;
3148 }
3149 } else if (parent_flags & LYS_STATUS_MASK) {
3150 /* check status compatibility with the parent */
3151 if ((parent_flags & LYS_STATUS_MASK) > ((*node_flags) & LYS_STATUS_MASK)) {
3152 if ((*node_flags) & LYS_STATUS_CURR) {
3153 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3154 "A \"current\" status is in conflict with the parent's \"%s\" status.",
3155 (parent_flags & LYS_STATUS_DEPRC) ? "deprecated" : "obsolete");
3156 } else { /* LYS_STATUS_DEPRC */
3157 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3158 "A \"deprecated\" status is in conflict with the parent's \"obsolete\" status.");
3159 }
3160 return LY_EVALID;
3161 }
3162 }
3163 return LY_SUCCESS;
3164}
3165
Radek Krejci8cce8532019-03-05 11:27:45 +01003166/**
3167 * @brief Check uniqness of the node/action/notification name.
3168 *
3169 * Data nodes, actions/RPCs and Notifications are stored separately (in distinguish lists) in the schema
3170 * structures, but they share the namespace so we need to check their name collisions.
3171 *
3172 * @param[in] ctx Compile context.
3173 * @param[in] children List (linked list) of data nodes to go through.
3174 * @param[in] actions List (sized array) of actions or RPCs to go through.
3175 * @param[in] notifs List (sized array) of Notifications to go through.
3176 * @param[in] name Name of the item to find in the given lists.
3177 * @param[in] exclude Pointer to an object to exclude from the name checking - for the case that the object
3178 * with the @p name being checked is already inserted into one of the list so we need to skip it when searching for duplicity.
3179 * @return LY_SUCCESS in case of unique name, LY_EEXIST otherwise.
3180 */
3181static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02003182lys_compile_node_uniqness(struct lysc_ctx *ctx, const struct lysc_node *children, const struct lysc_action *actions,
3183 const struct lysc_notif *notifs, const char *name, void *exclude)
Radek Krejci8cce8532019-03-05 11:27:45 +01003184{
3185 const struct lysc_node *iter;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003186 LY_ARRAY_COUNT_TYPE u;
Radek Krejci8cce8532019-03-05 11:27:45 +01003187
3188 LY_LIST_FOR(children, iter) {
3189 if (iter != exclude && iter->module == ctx->mod && !strcmp(name, iter->name)) {
3190 goto error;
3191 }
3192 }
3193 LY_ARRAY_FOR(actions, u) {
3194 if (&actions[u] != exclude && actions[u].module == ctx->mod && !strcmp(name, actions[u].name)) {
3195 goto error;
3196 }
3197 }
3198 LY_ARRAY_FOR(notifs, u) {
3199 if (&notifs[u] != exclude && notifs[u].module == ctx->mod && !strcmp(name, notifs[u].name)) {
3200 goto error;
3201 }
3202 }
3203 return LY_SUCCESS;
3204error:
Michal Vaskoa3881362020-01-21 15:57:35 +01003205 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPIDENT, name, "data definition/RPC/action/notification");
Radek Krejci8cce8532019-03-05 11:27:45 +01003206 return LY_EEXIST;
3207}
3208
Radek Krejciec4da802019-05-02 13:02:41 +02003209static LY_ERR lys_compile_node(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *parent, uint16_t uses_status);
Radek Krejci19a96102018-11-15 13:38:09 +01003210
Radek Krejcia3045382018-11-22 14:30:31 +01003211/**
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003212 * @brief Compile parsed RPC/action schema node information.
3213 * @param[in] ctx Compile context
Radek Krejci43981a32019-04-12 09:44:11 +02003214 * @param[in] action_p Parsed RPC/action schema node.
Radek Krejci43981a32019-04-12 09:44:11 +02003215 * @param[in] parent Parent node of the action, NULL in case of RPC (top-level action)
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003216 * @param[in,out] action Prepared (empty) compiled action structure to fill.
3217 * @param[in] uses_status If the RPC/action is being placed instead of uses, here we have the uses's status value (as node's flags).
3218 * Zero means no uses, non-zero value with no status bit set mean the default status.
3219 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
3220 */
3221static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02003222lys_compile_action(struct lysc_ctx *ctx, struct lysp_action *action_p,
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003223 struct lysc_node *parent, struct lysc_action *action, uint16_t uses_status)
3224{
3225 LY_ERR ret = LY_SUCCESS;
3226 struct lysp_node *child_p;
3227 unsigned int u;
Radek Krejciec4da802019-05-02 13:02:41 +02003228 int opt_prev = ctx->options;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003229
Radek Krejci327de162019-06-14 12:52:07 +02003230 lysc_update_path(ctx, parent, action_p->name);
3231
Radek Krejci8cce8532019-03-05 11:27:45 +01003232 if (lys_compile_node_uniqness(ctx, parent ? lysc_node_children(parent, 0) : ctx->mod->compiled->data,
3233 parent ? lysc_node_actions(parent) : ctx->mod->compiled->rpcs,
3234 parent ? lysc_node_notifs(parent) : ctx->mod->compiled->notifs,
3235 action_p->name, action)) {
3236 return LY_EVALID;
3237 }
3238
Radek Krejciec4da802019-05-02 13:02:41 +02003239 if (ctx->options & (LYSC_OPT_RPC_MASK | LYSC_OPT_NOTIFICATION)) {
Radek Krejci05b774b2019-02-25 13:26:18 +01003240 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejcifc11bd72019-04-11 16:00:05 +02003241 "Action \"%s\" is placed inside %s.", action_p->name,
Michal Vaskoa3881362020-01-21 15:57:35 +01003242 ctx->options & LYSC_OPT_RPC_MASK ? "another RPC/action" : "notification");
Radek Krejci05b774b2019-02-25 13:26:18 +01003243 return LY_EVALID;
3244 }
3245
Michal Vasko1bf09392020-03-27 12:38:10 +01003246 action->nodetype = parent ? LYS_ACTION : LYS_RPC;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003247 action->module = ctx->mod;
3248 action->parent = parent;
Radek Krejciec4da802019-05-02 13:02:41 +02003249 if (!(ctx->options & LYSC_OPT_FREE_SP)) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003250 action->sp = action_p;
3251 }
3252 action->flags = action_p->flags & LYS_FLAGS_COMPILED_MASK;
3253
3254 /* status - it is not inherited by specification, but it does not make sense to have
3255 * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
Michal Vaskocc048b22020-03-27 15:52:38 +01003256 LY_CHECK_RET(lys_compile_status(ctx, &action->flags, uses_status ? uses_status : (parent ? parent->flags : 0)));
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003257
3258 DUP_STRING(ctx->ctx, action_p->name, action->name);
3259 DUP_STRING(ctx->ctx, action_p->dsc, action->dsc);
3260 DUP_STRING(ctx->ctx, action_p->ref, action->ref);
Radek Krejciec4da802019-05-02 13:02:41 +02003261 COMPILE_ARRAY_GOTO(ctx, action_p->iffeatures, action->iffeatures, u, lys_compile_iffeature, ret, cleanup);
Radek Krejci0935f412019-08-20 16:15:18 +02003262 COMPILE_EXTS_GOTO(ctx, action_p->exts, action->exts, action, LYEXT_PAR_NODE, ret, cleanup);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003263
3264 /* input */
Radek Krejci327de162019-06-14 12:52:07 +02003265 lysc_update_path(ctx, (struct lysc_node*)action, "input");
Radek Krejcic71ac5b2019-09-10 15:34:22 +02003266 COMPILE_ARRAY_GOTO(ctx, action_p->input.musts, action->input.musts, u, lys_compile_must, ret, cleanup);
Radek Krejci0935f412019-08-20 16:15:18 +02003267 COMPILE_EXTS_GOTO(ctx, action_p->input.exts, action->input_exts, &action->input, LYEXT_PAR_INPUT, ret, cleanup);
Radek Krejciec4da802019-05-02 13:02:41 +02003268 ctx->options |= LYSC_OPT_RPC_INPUT;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003269 LY_LIST_FOR(action_p->input.data, child_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02003270 LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node*)action, uses_status));
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003271 }
Radek Krejci327de162019-06-14 12:52:07 +02003272 lysc_update_path(ctx, NULL, NULL);
Radek Krejciec4da802019-05-02 13:02:41 +02003273 ctx->options = opt_prev;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003274
3275 /* output */
Radek Krejci327de162019-06-14 12:52:07 +02003276 lysc_update_path(ctx, (struct lysc_node*)action, "output");
Radek Krejcic71ac5b2019-09-10 15:34:22 +02003277 COMPILE_ARRAY_GOTO(ctx, action_p->output.musts, action->output.musts, u, lys_compile_must, ret, cleanup);
Radek Krejci0935f412019-08-20 16:15:18 +02003278 COMPILE_EXTS_GOTO(ctx, action_p->output.exts, action->output_exts, &action->output, LYEXT_PAR_OUTPUT, ret, cleanup);
Radek Krejciec4da802019-05-02 13:02:41 +02003279 ctx->options |= LYSC_OPT_RPC_OUTPUT;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003280 LY_LIST_FOR(action_p->output.data, child_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02003281 LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node*)action, uses_status));
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003282 }
Radek Krejci327de162019-06-14 12:52:07 +02003283 lysc_update_path(ctx, NULL, NULL);
Radek Krejci327de162019-06-14 12:52:07 +02003284 lysc_update_path(ctx, NULL, NULL);
Michal Vasko5d8756a2019-11-07 15:21:00 +01003285
3286 if ((action_p->input.musts || action_p->output.musts) && !(ctx->options & LYSC_OPT_GROUPING)) {
3287 /* do not check "must" semantics in a grouping */
Michal Vasko004d3152020-06-11 19:59:22 +02003288 ly_set_add(&ctx->xpath, action, 0);
Michal Vasko5d8756a2019-11-07 15:21:00 +01003289 }
3290
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003291cleanup:
Radek Krejciec4da802019-05-02 13:02:41 +02003292 ctx->options = opt_prev;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003293 return ret;
3294}
3295
3296/**
Radek Krejci43981a32019-04-12 09:44:11 +02003297 * @brief Compile parsed Notification schema node information.
Radek Krejcifc11bd72019-04-11 16:00:05 +02003298 * @param[in] ctx Compile context
Radek Krejci43981a32019-04-12 09:44:11 +02003299 * @param[in] notif_p Parsed Notification schema node.
Radek Krejci43981a32019-04-12 09:44:11 +02003300 * @param[in] parent Parent node of the Notification, NULL in case of top-level Notification
3301 * @param[in,out] notif Prepared (empty) compiled notification structure to fill.
3302 * @param[in] uses_status If the Notification is being placed instead of uses, here we have the uses's status value (as node's flags).
Radek Krejcifc11bd72019-04-11 16:00:05 +02003303 * Zero means no uses, non-zero value with no status bit set mean the default status.
3304 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
3305 */
3306static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02003307lys_compile_notif(struct lysc_ctx *ctx, struct lysp_notif *notif_p,
Radek Krejcifc11bd72019-04-11 16:00:05 +02003308 struct lysc_node *parent, struct lysc_notif *notif, uint16_t uses_status)
3309{
3310 LY_ERR ret = LY_SUCCESS;
3311 struct lysp_node *child_p;
3312 unsigned int u;
Radek Krejciec4da802019-05-02 13:02:41 +02003313 int opt_prev = ctx->options;
Radek Krejcifc11bd72019-04-11 16:00:05 +02003314
Radek Krejci327de162019-06-14 12:52:07 +02003315 lysc_update_path(ctx, parent, notif_p->name);
3316
Radek Krejcifc11bd72019-04-11 16:00:05 +02003317 if (lys_compile_node_uniqness(ctx, parent ? lysc_node_children(parent, 0) : ctx->mod->compiled->data,
3318 parent ? lysc_node_actions(parent) : ctx->mod->compiled->rpcs,
3319 parent ? lysc_node_notifs(parent) : ctx->mod->compiled->notifs,
3320 notif_p->name, notif)) {
3321 return LY_EVALID;
3322 }
3323
Radek Krejciec4da802019-05-02 13:02:41 +02003324 if (ctx->options & (LYSC_OPT_RPC_MASK | LYSC_OPT_NOTIFICATION)) {
Radek Krejcifc11bd72019-04-11 16:00:05 +02003325 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3326 "Notification \"%s\" is placed inside %s.", notif_p->name,
Michal Vaskoa3881362020-01-21 15:57:35 +01003327 ctx->options & LYSC_OPT_RPC_MASK ? "RPC/action" : "another notification");
Radek Krejcifc11bd72019-04-11 16:00:05 +02003328 return LY_EVALID;
3329 }
3330
3331 notif->nodetype = LYS_NOTIF;
3332 notif->module = ctx->mod;
3333 notif->parent = parent;
Radek Krejciec4da802019-05-02 13:02:41 +02003334 if (!(ctx->options & LYSC_OPT_FREE_SP)) {
Radek Krejcifc11bd72019-04-11 16:00:05 +02003335 notif->sp = notif_p;
3336 }
3337 notif->flags = notif_p->flags & LYS_FLAGS_COMPILED_MASK;
3338
3339 /* status - it is not inherited by specification, but it does not make sense to have
3340 * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
3341 LY_CHECK_RET(lys_compile_status(ctx, &notif->flags, uses_status ? uses_status : (parent ? parent->flags : 0)));
3342
3343 DUP_STRING(ctx->ctx, notif_p->name, notif->name);
3344 DUP_STRING(ctx->ctx, notif_p->dsc, notif->dsc);
3345 DUP_STRING(ctx->ctx, notif_p->ref, notif->ref);
Radek Krejciec4da802019-05-02 13:02:41 +02003346 COMPILE_ARRAY_GOTO(ctx, notif_p->iffeatures, notif->iffeatures, u, lys_compile_iffeature, ret, cleanup);
Radek Krejcic71ac5b2019-09-10 15:34:22 +02003347 COMPILE_ARRAY_GOTO(ctx, notif_p->musts, notif->musts, u, lys_compile_must, ret, cleanup);
Michal Vasko5d8756a2019-11-07 15:21:00 +01003348 if (notif_p->musts && !(ctx->options & LYSC_OPT_GROUPING)) {
3349 /* do not check "must" semantics in a grouping */
Michal Vasko004d3152020-06-11 19:59:22 +02003350 ly_set_add(&ctx->xpath, notif, 0);
Michal Vasko5d8756a2019-11-07 15:21:00 +01003351 }
Radek Krejci0935f412019-08-20 16:15:18 +02003352 COMPILE_EXTS_GOTO(ctx, notif_p->exts, notif->exts, notif, LYEXT_PAR_NODE, ret, cleanup);
Radek Krejcifc11bd72019-04-11 16:00:05 +02003353
Radek Krejciec4da802019-05-02 13:02:41 +02003354 ctx->options |= LYSC_OPT_NOTIFICATION;
Radek Krejcifc11bd72019-04-11 16:00:05 +02003355 LY_LIST_FOR(notif_p->data, child_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02003356 LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node*)notif, uses_status));
Radek Krejcifc11bd72019-04-11 16:00:05 +02003357 }
3358
Radek Krejci327de162019-06-14 12:52:07 +02003359 lysc_update_path(ctx, NULL, NULL);
Radek Krejcifc11bd72019-04-11 16:00:05 +02003360cleanup:
Radek Krejciec4da802019-05-02 13:02:41 +02003361 ctx->options = opt_prev;
Radek Krejcifc11bd72019-04-11 16:00:05 +02003362 return ret;
3363}
3364
3365/**
Radek Krejcia3045382018-11-22 14:30:31 +01003366 * @brief Compile parsed container node information.
3367 * @param[in] ctx Compile context
3368 * @param[in] node_p Parsed container node.
Radek Krejcia3045382018-11-22 14:30:31 +01003369 * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
3370 * is enriched with the container-specific information.
3371 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
3372 */
Radek Krejci19a96102018-11-15 13:38:09 +01003373static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02003374lys_compile_node_container(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
Radek Krejci19a96102018-11-15 13:38:09 +01003375{
3376 struct lysp_node_container *cont_p = (struct lysp_node_container*)node_p;
3377 struct lysc_node_container *cont = (struct lysc_node_container*)node;
3378 struct lysp_node *child_p;
Michal Vaskoba417ac2020-08-06 14:48:20 +02003379 LY_ARRAY_COUNT_TYPE u;
Radek Krejci19a96102018-11-15 13:38:09 +01003380 LY_ERR ret = LY_SUCCESS;
3381
Radek Krejcife909632019-02-12 15:34:42 +01003382 if (cont_p->presence) {
Michal Vaskoba417ac2020-08-06 14:48:20 +02003383 /* explicit presence */
Radek Krejcife909632019-02-12 15:34:42 +01003384 cont->flags |= LYS_PRESENCE;
Michal Vaskoba417ac2020-08-06 14:48:20 +02003385 } else if (cont_p->musts) {
3386 /* container with a must condition */
3387 LOGWRN(ctx->ctx, "Container \"%s\" changed to presence because it has a \"must\" condition.", cont_p->name);
3388 cont->flags |= LYS_PRESENCE;
3389 } else if (cont_p->parent) {
3390 if (cont_p->parent->nodetype == LYS_CHOICE) {
3391 /* container is an implicit case, so its existence decides the existence of the whole case */
3392 LOGWRN(ctx->ctx, "Container \"%s\" changed to presence because it is an implicit case of choice \"%s\".",
3393 cont_p->name, cont_p->parent->name);
3394 cont->flags |= LYS_PRESENCE;
3395 } else if ((cont_p->parent->nodetype == LYS_CASE)
3396 && (((struct lysp_node_case *)cont_p->parent)->child == node_p) && !cont_p->next) {
3397 /* container is the only node in a case, so its existence decides the existence of the whole case */
3398 LOGWRN(ctx->ctx, "Container \"%s\" changed to presence because it is the only data node of case \"%s\".",
3399 cont_p->name, cont_p->parent->name);
3400 cont->flags |= LYS_PRESENCE;
3401 }
Radek Krejcife909632019-02-12 15:34:42 +01003402 }
3403
Michal Vaskoba417ac2020-08-06 14:48:20 +02003404 /* more cases when the container has meaning but is kept NP for convenience:
3405 * - when condition
3406 * - direct child action/notification
3407 */
3408
Radek Krejci19a96102018-11-15 13:38:09 +01003409 LY_LIST_FOR(cont_p->child, child_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02003410 LY_CHECK_RET(lys_compile_node(ctx, child_p, node, 0));
Radek Krejci19a96102018-11-15 13:38:09 +01003411 }
3412
Radek Krejcic71ac5b2019-09-10 15:34:22 +02003413 COMPILE_ARRAY_GOTO(ctx, cont_p->musts, cont->musts, u, lys_compile_must, ret, done);
Michal Vasko5d8756a2019-11-07 15:21:00 +01003414 if (cont_p->musts && !(ctx->options & LYSC_OPT_GROUPING)) {
3415 /* do not check "must" semantics in a grouping */
Michal Vasko004d3152020-06-11 19:59:22 +02003416 ly_set_add(&ctx->xpath, cont, 0);
Michal Vasko5d8756a2019-11-07 15:21:00 +01003417 }
Radek Krejciec4da802019-05-02 13:02:41 +02003418 COMPILE_ARRAY1_GOTO(ctx, cont_p->actions, cont->actions, node, u, lys_compile_action, 0, ret, done);
3419 COMPILE_ARRAY1_GOTO(ctx, cont_p->notifs, cont->notifs, node, u, lys_compile_notif, 0, ret, done);
Radek Krejci19a96102018-11-15 13:38:09 +01003420
3421done:
3422 return ret;
3423}
3424
Radek Krejci33f72892019-02-21 10:36:58 +01003425/*
3426 * @brief Compile type in leaf/leaf-list node and do all the necessary checks.
3427 * @param[in] ctx Compile context.
3428 * @param[in] context_node Schema node where the type/typedef is placed to correctly find the base types.
3429 * @param[in] type_p Parsed type to compile.
Radek Krejci33f72892019-02-21 10:36:58 +01003430 * @param[in,out] leaf Compiled leaf structure (possibly cast leaf-list) to provide node information and to store the compiled type information.
3431 * @return LY_ERR value.
3432 */
3433static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02003434lys_compile_node_type(struct lysc_ctx *ctx, struct lysp_node *context_node, struct lysp_type *type_p, struct lysc_node_leaf *leaf)
Radek Krejci33f72892019-02-21 10:36:58 +01003435{
Radek Krejci33f72892019-02-21 10:36:58 +01003436 struct lysc_node_leaflist *llist = (struct lysc_node_leaflist*)leaf;
3437
Radek Krejciec4da802019-05-02 13:02:41 +02003438 LY_CHECK_RET(lys_compile_type(ctx, context_node, leaf->flags, ctx->mod_def->parsed, leaf->name, type_p, &leaf->type,
Radek Krejci33f72892019-02-21 10:36:58 +01003439 leaf->units ? NULL : &leaf->units));
3440 if (leaf->nodetype == LYS_LEAFLIST) {
3441 if (llist->type->dflt && !llist->dflts && !llist->min) {
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003442 LY_ARRAY_CREATE_RET(ctx->ctx, llist->dflts_mods, 1, LY_EMEM);
3443 llist->dflts_mods[0] = llist->type->dflt_mod;
Radek Krejci33f72892019-02-21 10:36:58 +01003444 LY_ARRAY_CREATE_RET(ctx->ctx, llist->dflts, 1, LY_EMEM);
Radek Krejcia1911222019-07-22 17:24:50 +02003445 llist->dflts[0] = calloc(1, sizeof *llist->dflts[0]);
3446 llist->dflts[0]->realtype = llist->type->dflt->realtype;
3447 llist->dflts[0]->realtype->plugin->duplicate(ctx->ctx, llist->type->dflt, llist->dflts[0]);
3448 llist->dflts[0]->realtype->refcount++;
Radek Krejci33f72892019-02-21 10:36:58 +01003449 LY_ARRAY_INCREMENT(llist->dflts);
3450 }
3451 } else {
3452 if (leaf->type->dflt && !leaf->dflt && !(leaf->flags & LYS_MAND_TRUE)) {
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003453 leaf->dflt_mod = leaf->type->dflt_mod;
Radek Krejcia1911222019-07-22 17:24:50 +02003454 leaf->dflt = calloc(1, sizeof *leaf->dflt);
3455 leaf->dflt->realtype = leaf->type->dflt->realtype;
3456 leaf->dflt->realtype->plugin->duplicate(ctx->ctx, leaf->type->dflt, leaf->dflt);
3457 leaf->dflt->realtype->refcount++;
Radek Krejci33f72892019-02-21 10:36:58 +01003458 }
3459 }
3460 if (leaf->type->basetype == LY_TYPE_LEAFREF) {
3461 /* store to validate the path in the current context at the end of schema compiling when all the nodes are present */
Michal Vasko004d3152020-06-11 19:59:22 +02003462 ly_set_add(&ctx->leafrefs, leaf, 0);
Radek Krejci33f72892019-02-21 10:36:58 +01003463 } else if (leaf->type->basetype == LY_TYPE_UNION) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003464 LY_ARRAY_COUNT_TYPE u;
Radek Krejci33f72892019-02-21 10:36:58 +01003465 LY_ARRAY_FOR(((struct lysc_type_union*)leaf->type)->types, u) {
3466 if (((struct lysc_type_union*)leaf->type)->types[u]->basetype == LY_TYPE_LEAFREF) {
3467 /* store to validate the path in the current context at the end of schema compiling when all the nodes are present */
Michal Vasko004d3152020-06-11 19:59:22 +02003468 ly_set_add(&ctx->leafrefs, leaf, 0);
Radek Krejci33f72892019-02-21 10:36:58 +01003469 }
3470 }
3471 } else if (leaf->type->basetype == LY_TYPE_EMPTY) {
Radek Krejci33f72892019-02-21 10:36:58 +01003472 if (leaf->nodetype == LYS_LEAFLIST && ctx->mod_def->version < LYS_VERSION_1_1) {
3473 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3474 "Leaf-list of type \"empty\" is allowed only in YANG 1.1 modules.");
3475 return LY_EVALID;
3476 }
3477 }
3478
Radek Krejci33f72892019-02-21 10:36:58 +01003479 return LY_SUCCESS;
3480}
3481
Radek Krejcia3045382018-11-22 14:30:31 +01003482/**
3483 * @brief Compile parsed leaf node information.
3484 * @param[in] ctx Compile context
3485 * @param[in] node_p Parsed leaf node.
Radek Krejcia3045382018-11-22 14:30:31 +01003486 * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
3487 * is enriched with the leaf-specific information.
3488 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
3489 */
Radek Krejci19a96102018-11-15 13:38:09 +01003490static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02003491lys_compile_node_leaf(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
Radek Krejci19a96102018-11-15 13:38:09 +01003492{
3493 struct lysp_node_leaf *leaf_p = (struct lysp_node_leaf*)node_p;
3494 struct lysc_node_leaf *leaf = (struct lysc_node_leaf*)node;
Michal Vasko7c8439f2020-08-05 13:25:19 +02003495 LY_ARRAY_COUNT_TYPE u;
Radek Krejci19a96102018-11-15 13:38:09 +01003496 LY_ERR ret = LY_SUCCESS;
3497
Radek Krejcic71ac5b2019-09-10 15:34:22 +02003498 COMPILE_ARRAY_GOTO(ctx, leaf_p->musts, leaf->musts, u, lys_compile_must, ret, done);
Michal Vasko5d8756a2019-11-07 15:21:00 +01003499 if (leaf_p->musts && !(ctx->options & LYSC_OPT_GROUPING)) {
3500 /* do not check "must" semantics in a grouping */
Michal Vasko004d3152020-06-11 19:59:22 +02003501 ly_set_add(&ctx->xpath, leaf, 0);
Michal Vasko5d8756a2019-11-07 15:21:00 +01003502 }
Radek Krejciccd20f12019-02-15 14:12:27 +01003503 if (leaf_p->units) {
3504 leaf->units = lydict_insert(ctx->ctx, leaf_p->units, 0);
3505 leaf->flags |= LYS_SET_UNITS;
3506 }
Radek Krejcia1911222019-07-22 17:24:50 +02003507
3508 /* the dflt member is just filled to avoid getting the default value from the type */
3509 leaf->dflt = (void*)leaf_p->dflt;
3510 ret = lys_compile_node_type(ctx, node_p, &leaf_p->type, leaf);
Radek Krejci812a5bf2019-09-09 09:18:05 +02003511 if (ret) {
3512 leaf->dflt = NULL;
3513 return ret;
3514 }
Radek Krejcia1911222019-07-22 17:24:50 +02003515
Radek Krejciccd20f12019-02-15 14:12:27 +01003516 if (leaf_p->dflt) {
Radek Krejcia1911222019-07-22 17:24:50 +02003517 struct ly_err_item *err = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003518 leaf->dflt_mod = ctx->mod_def;
Radek Krejcia1911222019-07-22 17:24:50 +02003519 leaf->dflt = calloc(1, sizeof *leaf->dflt);
3520 leaf->dflt->realtype = leaf->type;
3521 ret = leaf->type->plugin->store(ctx->ctx, leaf->type, leaf_p->dflt, strlen(leaf_p->dflt),
3522 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
Radek Krejci1c0c3442019-07-23 16:08:47 +02003523 lys_resolve_prefix, (void*)leaf->dflt_mod, LYD_XML, node, NULL, leaf->dflt, NULL, &err);
Radek Krejcia1911222019-07-22 17:24:50 +02003524 leaf->dflt->realtype->refcount++;
3525 if (err) {
3526 ly_err_print(err);
3527 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3528 "Invalid leaf's default value \"%s\" which does not fit the type (%s).", leaf_p->dflt, err->msg);
3529 ly_err_free(err);
3530 }
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003531 if (ret == LY_EINCOMPLETE) {
Radek Krejci1c0c3442019-07-23 16:08:47 +02003532 /* postpone default compilation when the tree is complete */
Radek Krejcib5bc93e2019-09-09 09:11:23 +02003533 LY_CHECK_RET(lysc_incomplete_dflts_add(ctx, node, leaf->dflt, leaf->dflt_mod));
Radek Krejci1c0c3442019-07-23 16:08:47 +02003534
3535 /* but in general result is so far ok */
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003536 ret = LY_SUCCESS;
3537 }
Radek Krejcib5bc93e2019-09-09 09:11:23 +02003538 LY_CHECK_RET(ret);
Radek Krejci76b3e962018-12-14 17:01:25 +01003539 leaf->flags |= LYS_SET_DFLT;
3540 }
Radek Krejci43699232018-11-23 14:59:46 +01003541
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01003542
Radek Krejci19a96102018-11-15 13:38:09 +01003543done:
3544 return ret;
3545}
3546
Radek Krejcia3045382018-11-22 14:30:31 +01003547/**
Radek Krejci0e5d8382018-11-28 16:37:53 +01003548 * @brief Compile parsed leaf-list node information.
3549 * @param[in] ctx Compile context
3550 * @param[in] node_p Parsed leaf-list node.
Radek Krejci0e5d8382018-11-28 16:37:53 +01003551 * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
3552 * is enriched with the leaf-list-specific information.
3553 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
3554 */
3555static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02003556lys_compile_node_leaflist(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
Radek Krejci0e5d8382018-11-28 16:37:53 +01003557{
3558 struct lysp_node_leaflist *llist_p = (struct lysp_node_leaflist*)node_p;
3559 struct lysc_node_leaflist *llist = (struct lysc_node_leaflist*)node;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003560 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejci0e5d8382018-11-28 16:37:53 +01003561 LY_ERR ret = LY_SUCCESS;
3562
Radek Krejcic71ac5b2019-09-10 15:34:22 +02003563 COMPILE_ARRAY_GOTO(ctx, llist_p->musts, llist->musts, u, lys_compile_must, ret, done);
Michal Vasko5d8756a2019-11-07 15:21:00 +01003564 if (llist_p->musts && !(ctx->options & LYSC_OPT_GROUPING)) {
3565 /* do not check "must" semantics in a grouping */
Michal Vasko004d3152020-06-11 19:59:22 +02003566 ly_set_add(&ctx->xpath, llist, 0);
Michal Vasko5d8756a2019-11-07 15:21:00 +01003567 }
Radek Krejciccd20f12019-02-15 14:12:27 +01003568 if (llist_p->units) {
3569 llist->units = lydict_insert(ctx->ctx, llist_p->units, 0);
3570 llist->flags |= LYS_SET_UNITS;
3571 }
Radek Krejci0e5d8382018-11-28 16:37:53 +01003572
Radek Krejcia1911222019-07-22 17:24:50 +02003573 /* the dflts member is just filled to avoid getting the default value from the type */
3574 llist->dflts = (void*)llist_p->dflts;
3575 ret = lys_compile_node_type(ctx, node_p, &llist_p->type, (struct lysc_node_leaf*)llist);
Michal Vasko6a044b22020-01-15 12:25:39 +01003576 if (ret != LY_SUCCESS) {
3577 /* make sure the defaults are freed correctly */
3578 if (llist_p->dflts) {
3579 llist->dflts = NULL;
3580 }
3581 return ret;
3582 }
3583
Radek Krejci0e5d8382018-11-28 16:37:53 +01003584 if (llist_p->dflts) {
Radek Krejcia1911222019-07-22 17:24:50 +02003585 llist->dflts = NULL; /* reset the temporary llist_p->dflts */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003586 LY_ARRAY_CREATE_GOTO(ctx->ctx, llist->dflts_mods, LY_ARRAY_COUNT(llist_p->dflts), ret, done);
3587 LY_ARRAY_CREATE_GOTO(ctx->ctx, llist->dflts, LY_ARRAY_COUNT(llist_p->dflts), ret, done);
Radek Krejci0e5d8382018-11-28 16:37:53 +01003588 LY_ARRAY_FOR(llist_p->dflts, u) {
Radek Krejcia1911222019-07-22 17:24:50 +02003589 struct ly_err_item *err = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003590 LY_ARRAY_INCREMENT(llist->dflts_mods);
3591 llist->dflts_mods[u] = ctx->mod_def;
Radek Krejci0e5d8382018-11-28 16:37:53 +01003592 LY_ARRAY_INCREMENT(llist->dflts);
Radek Krejcia1911222019-07-22 17:24:50 +02003593 llist->dflts[u] = calloc(1, sizeof *llist->dflts[u]);
3594 llist->dflts[u]->realtype = llist->type;
3595 ret = llist->type->plugin->store(ctx->ctx, llist->type, llist_p->dflts[u], strlen(llist_p->dflts[u]),
3596 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
Radek Krejci1c0c3442019-07-23 16:08:47 +02003597 lys_resolve_prefix, (void*)llist->dflts_mods[u], LYD_XML, node, NULL, llist->dflts[u], NULL, &err);
Radek Krejcia1911222019-07-22 17:24:50 +02003598 llist->dflts[u]->realtype->refcount++;
3599 if (err) {
3600 ly_err_print(err);
3601 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3602 "Invalid leaf-lists's default value \"%s\" which does not fit the type (%s).", llist_p->dflts[u], err->msg);
3603 ly_err_free(err);
3604 }
Radek Krejci1c0c3442019-07-23 16:08:47 +02003605 if (ret == LY_EINCOMPLETE) {
3606 /* postpone default compilation when the tree is complete */
Radek Krejci474f9b82019-07-24 11:36:37 +02003607 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, node, llist->dflts[u], llist->dflts_mods[u]), done);
Radek Krejci1c0c3442019-07-23 16:08:47 +02003608
3609 /* but in general result is so far ok */
3610 ret = LY_SUCCESS;
3611 }
Radek Krejcia1911222019-07-22 17:24:50 +02003612 LY_CHECK_GOTO(ret, done);
Radek Krejci0e5d8382018-11-28 16:37:53 +01003613 }
Radek Krejciccd20f12019-02-15 14:12:27 +01003614 llist->flags |= LYS_SET_DFLT;
Radek Krejci0e5d8382018-11-28 16:37:53 +01003615 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003616 if ((llist->flags & LYS_CONFIG_W) && llist->dflts && LY_ARRAY_COUNT(llist->dflts)) {
Radek Krejcia1911222019-07-22 17:24:50 +02003617 /* configuration data values must be unique - so check the default values */
3618 LY_ARRAY_FOR(llist->dflts, u) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003619 for (v = u + 1; v < LY_ARRAY_COUNT(llist->dflts); ++v) {
Radek Krejcia1911222019-07-22 17:24:50 +02003620 if (!llist->type->plugin->compare(llist->dflts[u], llist->dflts[v])) {
3621 int dynamic = 0;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003622 const char *val = llist->type->plugin->print(llist->dflts[v], LYD_XML, lys_get_prefix, llist->dflts_mods[v], &dynamic);
Radek Krejcia1911222019-07-22 17:24:50 +02003623 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3624 "Configuration leaf-list has multiple defaults of the same value \"%s\".", val);
3625 if (dynamic) {
3626 free((char*)val);
3627 }
3628 return LY_EVALID;
3629 }
3630 }
3631 }
3632 }
3633
3634 /* TODO validate default value according to the type, possibly postpone the check when the leafref target is known */
Radek Krejci0e5d8382018-11-28 16:37:53 +01003635
3636 llist->min = llist_p->min;
Radek Krejcife909632019-02-12 15:34:42 +01003637 if (llist->min) {
3638 llist->flags |= LYS_MAND_TRUE;
3639 }
Radek Krejcib7408632018-11-28 17:12:11 +01003640 llist->max = llist_p->max ? llist_p->max : (uint32_t)-1;
Radek Krejci0e5d8382018-11-28 16:37:53 +01003641
Radek Krejci0e5d8382018-11-28 16:37:53 +01003642done:
3643 return ret;
3644}
3645
3646/**
Radek Krejci7af64242019-02-18 13:07:53 +01003647 * @brief Compile information about list's uniques.
3648 * @param[in] ctx Compile context.
3649 * @param[in] context_module Module where the prefixes are going to be resolved.
3650 * @param[in] uniques Sized array list of unique statements.
3651 * @param[in] list Compiled list where the uniques are supposed to be resolved and stored.
3652 * @return LY_ERR value.
3653 */
3654static LY_ERR
3655lys_compile_node_list_unique(struct lysc_ctx *ctx, struct lys_module *context_module, const char **uniques, struct lysc_node_list *list)
3656{
3657 LY_ERR ret = LY_SUCCESS;
3658 struct lysc_node_leaf **key, ***unique;
Michal Vasko14654712020-02-06 08:35:21 +01003659 struct lysc_node *parent;
Radek Krejci7af64242019-02-18 13:07:53 +01003660 const char *keystr, *delim;
3661 size_t len;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003662 LY_ARRAY_COUNT_TYPE v;
Radek Krejci7af64242019-02-18 13:07:53 +01003663 int config;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003664 uint16_t flags;
Radek Krejci7af64242019-02-18 13:07:53 +01003665
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003666 for (v = 0; v < LY_ARRAY_COUNT(uniques); ++v) {
Radek Krejci7af64242019-02-18 13:07:53 +01003667 config = -1;
3668 LY_ARRAY_NEW_RET(ctx->ctx, list->uniques, unique, LY_EMEM);
3669 keystr = uniques[v];
3670 while (keystr) {
3671 delim = strpbrk(keystr, " \t\n");
3672 if (delim) {
3673 len = delim - keystr;
3674 while (isspace(*delim)) {
3675 ++delim;
3676 }
3677 } else {
3678 len = strlen(keystr);
3679 }
3680
3681 /* unique node must be present */
3682 LY_ARRAY_NEW_RET(ctx->ctx, *unique, key, LY_EMEM);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003683 ret = lys_resolve_schema_nodeid(ctx, keystr, len, (struct lysc_node*)list, context_module, LYS_LEAF, 0,
3684 (const struct lysc_node**)key, &flags);
Radek Krejci7af64242019-02-18 13:07:53 +01003685 if (ret != LY_SUCCESS) {
3686 if (ret == LY_EDENIED) {
3687 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003688 "Unique's descendant-schema-nodeid \"%.*s\" refers to %s node instead of a leaf.",
Radek Krejci7af64242019-02-18 13:07:53 +01003689 len, keystr, lys_nodetype2str((*key)->nodetype));
3690 }
3691 return LY_EVALID;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003692 } else if (flags) {
3693 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
3694 "Unique's descendant-schema-nodeid \"%.*s\" refers into %s node.",
Michal Vaskoa3881362020-01-21 15:57:35 +01003695 len, keystr, flags & LYSC_OPT_NOTIFICATION ? "notification" : "RPC/action");
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003696 return LY_EVALID;
Radek Krejci7af64242019-02-18 13:07:53 +01003697 }
3698
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003699
Radek Krejci7af64242019-02-18 13:07:53 +01003700 /* all referenced leafs must be of the same config type */
3701 if (config != -1 && ((((*key)->flags & LYS_CONFIG_W) && config == 0) || (((*key)->flags & LYS_CONFIG_R) && config == 1))) {
3702 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Michal Vasko14654712020-02-06 08:35:21 +01003703 "Unique statement \"%s\" refers to leaves with different config type.", uniques[v]);
Radek Krejci7af64242019-02-18 13:07:53 +01003704 return LY_EVALID;
3705 } else if ((*key)->flags & LYS_CONFIG_W) {
3706 config = 1;
3707 } else { /* LYS_CONFIG_R */
3708 config = 0;
3709 }
3710
Michal Vasko14654712020-02-06 08:35:21 +01003711 /* we forbid referencing nested lists because it is unspecified what instance of such a list to use */
3712 for (parent = (*key)->parent; parent != (struct lysc_node *)list; parent = parent->parent) {
3713 if (parent->nodetype == LYS_LIST) {
3714 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3715 "Unique statement \"%s\" refers to a leaf in nested list \"%s\".", uniques[v], parent->name);
3716 return LY_EVALID;
3717 }
3718 }
3719
Radek Krejci7af64242019-02-18 13:07:53 +01003720 /* check status */
3721 LY_CHECK_RET(lysc_check_status(ctx, list->flags, list->module, list->name,
3722 (*key)->flags, (*key)->module, (*key)->name));
3723
3724 /* mark leaf as unique */
3725 (*key)->flags |= LYS_UNIQUE;
3726
3727 /* next unique value in line */
3728 keystr = delim;
3729 }
3730 /* next unique definition */
3731 }
3732
3733 return LY_SUCCESS;
3734}
3735
3736/**
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003737 * @brief Compile parsed list node information.
3738 * @param[in] ctx Compile context
3739 * @param[in] node_p Parsed list node.
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003740 * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
3741 * is enriched with the list-specific information.
3742 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
3743 */
3744static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02003745lys_compile_node_list(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003746{
3747 struct lysp_node_list *list_p = (struct lysp_node_list*)node_p;
3748 struct lysc_node_list *list = (struct lysc_node_list*)node;
3749 struct lysp_node *child_p;
Radek Krejci0fe9b512019-07-26 17:51:05 +02003750 struct lysc_node_leaf *key, *prev_key = NULL;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003751 size_t len;
Radek Krejci7af64242019-02-18 13:07:53 +01003752 unsigned int u;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003753 const char *keystr, *delim;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003754 LY_ERR ret = LY_SUCCESS;
3755
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003756 list->min = list_p->min;
Radek Krejcife909632019-02-12 15:34:42 +01003757 if (list->min) {
3758 list->flags |= LYS_MAND_TRUE;
3759 }
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003760 list->max = list_p->max ? list_p->max : (uint32_t)-1;
3761
3762 LY_LIST_FOR(list_p->child, child_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02003763 LY_CHECK_RET(lys_compile_node(ctx, child_p, node, 0));
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003764 }
3765
Radek Krejcic71ac5b2019-09-10 15:34:22 +02003766 COMPILE_ARRAY_GOTO(ctx, list_p->musts, list->musts, u, lys_compile_must, ret, done);
Michal Vasko5d8756a2019-11-07 15:21:00 +01003767 if (list_p->musts && !(ctx->options & LYSC_OPT_GROUPING)) {
3768 /* do not check "must" semantics in a grouping */
Michal Vasko004d3152020-06-11 19:59:22 +02003769 ly_set_add(&ctx->xpath, list, 0);
Michal Vasko5d8756a2019-11-07 15:21:00 +01003770 }
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003771
3772 /* keys */
3773 if ((list->flags & LYS_CONFIG_W) && (!list_p->key || !list_p->key[0])) {
3774 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Missing key in list representing configuration data.");
3775 return LY_EVALID;
3776 }
3777
3778 /* find all the keys (must be direct children) */
3779 keystr = list_p->key;
Radek Krejci0fe9b512019-07-26 17:51:05 +02003780 if (!keystr) {
3781 /* keyless list */
3782 list->flags |= LYS_KEYLESS;
3783 }
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003784 while (keystr) {
3785 delim = strpbrk(keystr, " \t\n");
3786 if (delim) {
3787 len = delim - keystr;
3788 while (isspace(*delim)) {
3789 ++delim;
3790 }
3791 } else {
3792 len = strlen(keystr);
3793 }
3794
3795 /* key node must be present */
Michal Vaskoe444f752020-02-10 12:20:06 +01003796 key = (struct lysc_node_leaf*)lys_find_child(node, node->module, keystr, len, LYS_LEAF, LYS_GETNEXT_NOCHOICE | LYS_GETNEXT_NOSTATECHECK);
Radek Krejci0fe9b512019-07-26 17:51:05 +02003797 if (!(key)) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003798 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
3799 "The list's key \"%.*s\" not found.", len, keystr);
3800 return LY_EVALID;
3801 }
3802 /* keys must be unique */
Radek Krejci0fe9b512019-07-26 17:51:05 +02003803 if (key->flags & LYS_KEY) {
3804 /* the node was already marked as a key */
3805 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3806 "Duplicated key identifier \"%.*s\".", len, keystr);
3807 return LY_EVALID;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003808 }
Radek Krejci0fe9b512019-07-26 17:51:05 +02003809
3810 lysc_update_path(ctx, (struct lysc_node*)list, key->name);
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003811 /* key must have the same config flag as the list itself */
Radek Krejci0fe9b512019-07-26 17:51:05 +02003812 if ((list->flags & LYS_CONFIG_MASK) != (key->flags & LYS_CONFIG_MASK)) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003813 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Key of the configuration list must not be status leaf.");
3814 return LY_EVALID;
3815 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +01003816 if (ctx->mod_def->version < LYS_VERSION_1_1) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003817 /* YANG 1.0 denies key to be of empty type */
Radek Krejci0fe9b512019-07-26 17:51:05 +02003818 if (key->type->basetype == LY_TYPE_EMPTY) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003819 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02003820 "List's key cannot be of \"empty\" type until it is in YANG 1.1 module.");
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003821 return LY_EVALID;
3822 }
3823 } else {
3824 /* when and if-feature are illegal on list keys */
Radek Krejci0fe9b512019-07-26 17:51:05 +02003825 if (key->when) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003826 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02003827 "List's key must not have any \"when\" statement.");
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003828 return LY_EVALID;
3829 }
Radek Krejci0fe9b512019-07-26 17:51:05 +02003830 if (key->iffeatures) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003831 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02003832 "List's key must not have any \"if-feature\" statement.");
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003833 return LY_EVALID;
3834 }
3835 }
Radek Krejci76b3e962018-12-14 17:01:25 +01003836
3837 /* check status */
3838 LY_CHECK_RET(lysc_check_status(ctx, list->flags, list->module, list->name,
Radek Krejci0fe9b512019-07-26 17:51:05 +02003839 key->flags, key->module, key->name));
Radek Krejci76b3e962018-12-14 17:01:25 +01003840
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003841 /* ignore default values of the key */
Radek Krejci0fe9b512019-07-26 17:51:05 +02003842 if (key->dflt) {
3843 key->dflt->realtype->plugin->free(ctx->ctx, key->dflt);
3844 lysc_type_free(ctx->ctx, key->dflt->realtype);
3845 free(key->dflt);
3846 key->dflt = NULL;
3847 key->dflt_mod = NULL;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003848 }
3849 /* mark leaf as key */
Radek Krejci0fe9b512019-07-26 17:51:05 +02003850 key->flags |= LYS_KEY;
3851
3852 /* move it to the correct position */
3853 if ((prev_key && (struct lysc_node*)prev_key != key->prev) || (!prev_key && key->prev->next)) {
3854 /* fix links in closest previous siblings of the key */
3855 if (key->next) {
3856 key->next->prev = key->prev;
3857 } else {
3858 /* last child */
3859 list->child->prev = key->prev;
3860 }
3861 if (key->prev->next) {
3862 key->prev->next = key->next;
3863 }
3864 /* fix links in the key */
3865 if (prev_key) {
3866 key->prev = (struct lysc_node*)prev_key;
3867 key->next = prev_key->next;
3868 } else {
3869 key->prev = list->child->prev;
3870 key->next = list->child;
3871 }
3872 /* fix links in closes future siblings of the key */
3873 if (prev_key) {
3874 if (prev_key->next) {
3875 prev_key->next->prev = (struct lysc_node*)key;
3876 } else {
3877 list->child->prev = (struct lysc_node*)key;
3878 }
3879 prev_key->next = (struct lysc_node*)key;
3880 } else {
3881 list->child->prev = (struct lysc_node*)key;
3882 }
3883 /* fix links in parent */
3884 if (!key->prev->next) {
3885 list->child = (struct lysc_node*)key;
3886 }
3887 }
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003888
3889 /* next key value */
Radek Krejci0fe9b512019-07-26 17:51:05 +02003890 prev_key = key;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003891 keystr = delim;
Radek Krejci327de162019-06-14 12:52:07 +02003892 lysc_update_path(ctx, NULL, NULL);
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003893 }
3894
3895 /* uniques */
3896 if (list_p->uniques) {
Radek Krejci7af64242019-02-18 13:07:53 +01003897 LY_CHECK_RET(lys_compile_node_list_unique(ctx, list->module, list_p->uniques, list));
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003898 }
3899
Radek Krejciec4da802019-05-02 13:02:41 +02003900 COMPILE_ARRAY1_GOTO(ctx, list_p->actions, list->actions, node, u, lys_compile_action, 0, ret, done);
3901 COMPILE_ARRAY1_GOTO(ctx, list_p->notifs, list->notifs, node, u, lys_compile_notif, 0, ret, done);
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003902
3903done:
3904 return ret;
3905}
3906
Radek Krejcib56c7502019-02-13 14:19:54 +01003907/**
3908 * @brief Do some checks and set the default choice's case.
3909 *
3910 * Selects (and stores into ::lysc_node_choice#dflt) the default case and set LYS_SET_DFLT flag on it.
3911 *
3912 * @param[in] ctx Compile context.
3913 * @param[in] dflt Name of the default branch. Can contain even the prefix, but it make sense only in case it is the prefix of the module itself,
3914 * not the reference to the imported module.
3915 * @param[in,out] ch The compiled choice node, its dflt member is filled to point to the default case node of the choice.
3916 * @return LY_ERR value.
3917 */
Radek Krejci76b3e962018-12-14 17:01:25 +01003918static LY_ERR
3919lys_compile_node_choice_dflt(struct lysc_ctx *ctx, const char *dflt, struct lysc_node_choice *ch)
3920{
3921 struct lysc_node *iter, *node = (struct lysc_node*)ch;
3922 const char *prefix = NULL, *name;
3923 size_t prefix_len = 0;
3924
3925 /* could use lys_parse_nodeid(), but it checks syntax which is already done in this case by the parsers */
3926 name = strchr(dflt, ':');
3927 if (name) {
3928 prefix = dflt;
3929 prefix_len = name - prefix;
3930 ++name;
3931 } else {
3932 name = dflt;
3933 }
Radek Krejci7f9b6512019-09-18 13:11:09 +02003934 if (prefix && ly_strncmp(node->module->prefix, prefix, prefix_len)) {
Radek Krejci76b3e962018-12-14 17:01:25 +01003935 /* prefixed default case make sense only for the prefix of the schema itself */
3936 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
3937 "Invalid default case referencing a case from different YANG module (by prefix \"%.*s\").",
3938 prefix_len, prefix);
3939 return LY_EVALID;
3940 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003941 ch->dflt = (struct lysc_node_case*)lys_find_child(node, node->module, name, 0, LYS_CASE, LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCASE);
Radek Krejci76b3e962018-12-14 17:01:25 +01003942 if (!ch->dflt) {
3943 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3944 "Default case \"%s\" not found.", dflt);
3945 return LY_EVALID;
3946 }
3947 /* no mandatory nodes directly under the default case */
3948 LY_LIST_FOR(ch->dflt->child, iter) {
Radek Krejcife13da42019-02-15 14:51:01 +01003949 if (iter->parent != (struct lysc_node*)ch->dflt) {
3950 break;
3951 }
Radek Krejci76b3e962018-12-14 17:01:25 +01003952 if (iter->flags & LYS_MAND_TRUE) {
3953 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3954 "Mandatory node \"%s\" under the default case \"%s\".", iter->name, dflt);
3955 return LY_EVALID;
3956 }
3957 }
Radek Krejci01342af2019-01-03 15:18:08 +01003958 ch->dflt->flags |= LYS_SET_DFLT;
Radek Krejci76b3e962018-12-14 17:01:25 +01003959 return LY_SUCCESS;
3960}
3961
Radek Krejciccd20f12019-02-15 14:12:27 +01003962static LY_ERR
Radek Krejci327de162019-06-14 12:52:07 +02003963lys_compile_deviation_set_choice_dflt(struct lysc_ctx *ctx, const char *dflt, struct lysc_node_choice *ch)
Radek Krejciccd20f12019-02-15 14:12:27 +01003964{
3965 struct lys_module *mod;
3966 const char *prefix = NULL, *name;
3967 size_t prefix_len = 0;
3968 struct lysc_node_case *cs;
3969 struct lysc_node *node;
3970
3971 /* could use lys_parse_nodeid(), but it checks syntax which is already done in this case by the parsers */
3972 name = strchr(dflt, ':');
3973 if (name) {
3974 prefix = dflt;
3975 prefix_len = name - prefix;
3976 ++name;
3977 } else {
3978 name = dflt;
3979 }
3980 /* this code is for deviation, so we allow as the default case even the cases from other modules than the choice (augments) */
3981 if (prefix) {
3982 if (!(mod = lys_module_find_prefix(ctx->mod, prefix, prefix_len))) {
3983 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02003984 "Invalid deviation adding \"default\" property \"%s\" of choice. "
3985 "The prefix does not match any imported module of the deviation module.", dflt);
Radek Krejciccd20f12019-02-15 14:12:27 +01003986 return LY_EVALID;
3987 }
3988 } else {
3989 mod = ctx->mod;
3990 }
3991 /* get the default case */
Michal Vaskoe444f752020-02-10 12:20:06 +01003992 cs = (struct lysc_node_case*)lys_find_child((struct lysc_node*)ch, mod, name, 0, LYS_CASE, LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCASE);
Radek Krejciccd20f12019-02-15 14:12:27 +01003993 if (!cs) {
3994 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02003995 "Invalid deviation adding \"default\" property \"%s\" of choice - the specified case does not exists.", dflt);
Radek Krejciccd20f12019-02-15 14:12:27 +01003996 return LY_EVALID;
3997 }
3998
3999 /* check that there is no mandatory node */
4000 LY_LIST_FOR(cs->child, node) {
Radek Krejcife13da42019-02-15 14:51:01 +01004001 if (node->parent != (struct lysc_node*)cs) {
4002 break;
4003 }
Radek Krejciccd20f12019-02-15 14:12:27 +01004004 if (node->flags & LYS_MAND_TRUE) {
4005 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004006 "Invalid deviation adding \"default\" property \"%s\" of choice - "
4007 "mandatory node \"%s\" under the default case.", dflt, node->name);
Radek Krejciccd20f12019-02-15 14:12:27 +01004008 return LY_EVALID;
4009 }
4010 }
4011
4012 /* set the default case in choice */
4013 ch->dflt = cs;
4014 cs->flags |= LYS_SET_DFLT;
4015
4016 return LY_SUCCESS;
4017}
4018
Radek Krejci9bb94eb2018-12-04 16:48:35 +01004019/**
Radek Krejci056d0a82018-12-06 16:57:25 +01004020 * @brief Compile parsed choice node information.
4021 * @param[in] ctx Compile context
4022 * @param[in] node_p Parsed choice node.
Radek Krejci056d0a82018-12-06 16:57:25 +01004023 * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
Radek Krejci76b3e962018-12-14 17:01:25 +01004024 * is enriched with the choice-specific information.
Radek Krejci056d0a82018-12-06 16:57:25 +01004025 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
4026 */
4027static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02004028lys_compile_node_choice(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
Radek Krejci056d0a82018-12-06 16:57:25 +01004029{
4030 struct lysp_node_choice *ch_p = (struct lysp_node_choice*)node_p;
4031 struct lysc_node_choice *ch = (struct lysc_node_choice*)node;
4032 struct lysp_node *child_p, *case_child_p;
Radek Krejci056d0a82018-12-06 16:57:25 +01004033 LY_ERR ret = LY_SUCCESS;
4034
Radek Krejci056d0a82018-12-06 16:57:25 +01004035 LY_LIST_FOR(ch_p->child, child_p) {
4036 if (child_p->nodetype == LYS_CASE) {
4037 LY_LIST_FOR(((struct lysp_node_case*)child_p)->child, case_child_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02004038 LY_CHECK_RET(lys_compile_node(ctx, case_child_p, node, 0));
Radek Krejci056d0a82018-12-06 16:57:25 +01004039 }
4040 } else {
Radek Krejciec4da802019-05-02 13:02:41 +02004041 LY_CHECK_RET(lys_compile_node(ctx, child_p, node, 0));
Radek Krejci056d0a82018-12-06 16:57:25 +01004042 }
4043 }
4044
4045 /* default branch */
Radek Krejcia9026eb2018-12-12 16:04:47 +01004046 if (ch_p->dflt) {
Radek Krejci76b3e962018-12-14 17:01:25 +01004047 LY_CHECK_RET(lys_compile_node_choice_dflt(ctx, ch_p->dflt, ch));
Radek Krejcia9026eb2018-12-12 16:04:47 +01004048 }
Radek Krejci056d0a82018-12-06 16:57:25 +01004049
Radek Krejci9800fb82018-12-13 14:26:23 +01004050 return ret;
4051}
4052
4053/**
4054 * @brief Compile parsed anydata or anyxml node information.
4055 * @param[in] ctx Compile context
4056 * @param[in] node_p Parsed anydata or anyxml node.
Radek Krejci9800fb82018-12-13 14:26:23 +01004057 * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
4058 * is enriched with the any-specific information.
4059 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
4060 */
4061static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02004062lys_compile_node_any(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
Radek Krejci9800fb82018-12-13 14:26:23 +01004063{
4064 struct lysp_node_anydata *any_p = (struct lysp_node_anydata*)node_p;
4065 struct lysc_node_anydata *any = (struct lysc_node_anydata*)node;
4066 unsigned int u;
4067 LY_ERR ret = LY_SUCCESS;
4068
Radek Krejcic71ac5b2019-09-10 15:34:22 +02004069 COMPILE_ARRAY_GOTO(ctx, any_p->musts, any->musts, u, lys_compile_must, ret, done);
Michal Vasko5d8756a2019-11-07 15:21:00 +01004070 if (any_p->musts && !(ctx->options & LYSC_OPT_GROUPING)) {
4071 /* do not check "must" semantics in a grouping */
Michal Vasko004d3152020-06-11 19:59:22 +02004072 ly_set_add(&ctx->xpath, any, 0);
Michal Vasko5d8756a2019-11-07 15:21:00 +01004073 }
Radek Krejci9800fb82018-12-13 14:26:23 +01004074
4075 if (any->flags & LYS_CONFIG_W) {
Radek Krejci5c4ed7b2020-08-12 11:29:44 +02004076 LOGWRN(ctx->ctx, "Use of %s to define configuration data is not recommended. %s",
4077 ly_stmt2str(any->nodetype == LYS_ANYDATA ? LY_STMT_ANYDATA : LY_STMT_ANYXML), ctx->path);
Radek Krejci9800fb82018-12-13 14:26:23 +01004078 }
Radek Krejci056d0a82018-12-06 16:57:25 +01004079done:
4080 return ret;
4081}
4082
Radek Krejcib56c7502019-02-13 14:19:54 +01004083/**
Michal Vasko795b3752020-07-13 15:24:27 +02004084 * @brief Connect the node into the siblings list and check its name uniqueness. Also,
4085 * keep specific order of augments targetting the same node.
Radek Krejci056d0a82018-12-06 16:57:25 +01004086 *
4087 * @param[in] ctx Compile context
4088 * @param[in] parent Parent node holding the children list, in case of node from a choice's case,
4089 * the choice itself is expected instead of a specific case node.
4090 * @param[in] node Schema node to connect into the list.
4091 * @return LY_ERR value - LY_SUCCESS or LY_EEXIST.
Radek Krejci1c54f462020-05-12 17:25:34 +02004092 * In case of LY_EEXIST, the node is actually kept in the tree, so do not free it directly.
Radek Krejci056d0a82018-12-06 16:57:25 +01004093 */
4094static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02004095lys_compile_node_connect(struct lysc_ctx *ctx, struct lysc_node *parent, struct lysc_node *node)
Radek Krejci056d0a82018-12-06 16:57:25 +01004096{
Michal Vasko795b3752020-07-13 15:24:27 +02004097 struct lysc_node **children, *start, *end;
4098 const struct lys_module *mod;
Radek Krejci056d0a82018-12-06 16:57:25 +01004099
4100 if (node->nodetype == LYS_CASE) {
4101 children = (struct lysc_node**)&((struct lysc_node_choice*)parent)->cases;
4102 } else {
Radek Krejciec4da802019-05-02 13:02:41 +02004103 children = lysc_node_children_p(parent, ctx->options);
Radek Krejci056d0a82018-12-06 16:57:25 +01004104 }
4105 if (children) {
4106 if (!(*children)) {
4107 /* first child */
4108 *children = node;
4109 } else if (*children != node) {
4110 /* by the condition in previous branch we cover the choice/case children
4111 * - the children list is shared by the choice and the the first case, in addition
4112 * the first child of each case must be referenced from the case node. So the node is
4113 * actually always already inserted in case it is the first children - so here such
4114 * a situation actually corresponds to the first branch */
Michal Vasko795b3752020-07-13 15:24:27 +02004115 if (((*children)->prev->module != (*children)->module) && (node->module != (*children)->module)
4116 && (strcmp((*children)->prev->module->name, node->module->name) > 0)) {
4117 /* some augments are already connected and we are connecting new ones,
4118 * keep module name order and insert the node into the children list */
4119 end = (*children);
4120 do {
4121 end = end->prev;
4122 mod = end->module;
4123 while (end->prev->module == mod) {
4124 end = end->prev;
4125 }
4126 } while ((end->prev->module != (*children)->module) && (end->prev->module != node->module)
4127 && (strcmp(mod->name, node->module->name) > 0));
4128
4129 /* we have the last existing node after our node, easily get the first before and connect it */
4130 start = end->prev;
4131 start->next = node;
4132 node->next = end;
4133 end->prev = node;
4134 node->prev = start;
4135 } else {
4136 /* insert at the end of the parent's children list */
4137 (*children)->prev->next = node;
4138 node->prev = (*children)->prev;
4139 (*children)->prev = node;
4140 }
Radek Krejci056d0a82018-12-06 16:57:25 +01004141
4142 /* check the name uniqueness */
4143 if (lys_compile_node_uniqness(ctx, *children, lysc_node_actions(parent),
4144 lysc_node_notifs(parent), node->name, node)) {
4145 return LY_EEXIST;
4146 }
4147 }
4148 }
4149 return LY_SUCCESS;
4150}
4151
Radek Krejci95710c92019-02-11 15:49:55 +01004152/**
Radek Krejcib56c7502019-02-13 14:19:54 +01004153 * @brief Prepare the case structure in choice node for the new data node.
4154 *
4155 * It is able to handle implicit as well as explicit cases and the situation when the case has multiple data nodes and the case was already
4156 * created in the choice when the first child was processed.
4157 *
4158 * @param[in] ctx Compile context.
Radek Krejci95710c92019-02-11 15:49:55 +01004159 * @param[in] node_p Node image from the parsed tree. If the case is explicit, it is the LYS_CASE node, but in case of implicit case,
Radek Krejci39424802020-08-12 09:31:00 +02004160 * it is the LYS_CHOICE, LYS_AUGMENT or LYS_GROUPING node.
Radek Krejcib56c7502019-02-13 14:19:54 +01004161 * @param[in] ch The compiled choice structure where the new case structures are created (if needed).
4162 * @param[in] child The new data node being part of a case (no matter if explicit or implicit).
4163 * @return The case structure where the child node belongs to, NULL in case of error. Note that the child is not connected into the siblings list,
4164 * it is linked from the case structure only in case it is its first child.
Radek Krejci95710c92019-02-11 15:49:55 +01004165 */
Radek Krejci056d0a82018-12-06 16:57:25 +01004166static struct lysc_node_case*
Radek Krejciec4da802019-05-02 13:02:41 +02004167lys_compile_node_case(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node_choice *ch, struct lysc_node *child)
Radek Krejci056d0a82018-12-06 16:57:25 +01004168{
4169 struct lysc_node *iter;
Radek Krejci98b1a662019-04-23 10:25:50 +02004170 struct lysc_node_case *cs = NULL;
Radek Krejci00b874b2019-02-12 10:54:50 +01004171 struct lysc_when **when;
Radek Krejci056d0a82018-12-06 16:57:25 +01004172 unsigned int u;
4173 LY_ERR ret;
4174
Radek Krejci95710c92019-02-11 15:49:55 +01004175#define UNIQUE_CHECK(NAME, MOD) \
Radek Krejci056d0a82018-12-06 16:57:25 +01004176 LY_LIST_FOR((struct lysc_node*)ch->cases, iter) { \
Radek Krejci95710c92019-02-11 15:49:55 +01004177 if (iter->module == MOD && !strcmp(iter->name, NAME)) { \
Radek Krejci056d0a82018-12-06 16:57:25 +01004178 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPIDENT, NAME, "case"); \
4179 return NULL; \
4180 } \
4181 }
4182
Radek Krejci39424802020-08-12 09:31:00 +02004183 if (node_p->nodetype & (LYS_CHOICE | LYS_AUGMENT | LYS_GROUPING)) {
Radek Krejci95710c92019-02-11 15:49:55 +01004184 UNIQUE_CHECK(child->name, ctx->mod);
Radek Krejci056d0a82018-12-06 16:57:25 +01004185
4186 /* we have to add an implicit case node into the parent choice */
4187 cs = calloc(1, sizeof(struct lysc_node_case));
4188 DUP_STRING(ctx->ctx, child->name, cs->name);
Michal Vasko175012e2019-11-06 15:49:14 +01004189 cs->parent = (struct lysc_node*)ch;
Radek Krejci056d0a82018-12-06 16:57:25 +01004190 cs->flags = ch->flags & LYS_STATUS_MASK;
Radek Krejci95710c92019-02-11 15:49:55 +01004191 } else if (node_p->nodetype == LYS_CASE) {
Radek Krejci056d0a82018-12-06 16:57:25 +01004192 if (ch->cases && (node_p == ch->cases->prev->sp)) {
4193 /* the case is already present since the child is not its first children */
4194 return (struct lysc_node_case*)ch->cases->prev;
4195 }
Radek Krejci95710c92019-02-11 15:49:55 +01004196 UNIQUE_CHECK(node_p->name, ctx->mod);
Radek Krejci056d0a82018-12-06 16:57:25 +01004197
4198 /* explicit parent case is not present (this is its first child) */
4199 cs = calloc(1, sizeof(struct lysc_node_case));
4200 DUP_STRING(ctx->ctx, node_p->name, cs->name);
Michal Vasko175012e2019-11-06 15:49:14 +01004201 cs->parent = (struct lysc_node*)ch;
Radek Krejci056d0a82018-12-06 16:57:25 +01004202 cs->flags = LYS_STATUS_MASK & node_p->flags;
4203 cs->sp = node_p;
4204
Radek Krejcib1b59152019-01-07 13:21:56 +01004205 /* check the case's status (don't need to solve uses_status since case statement cannot be directly in grouping statement */
Radek Krejcibae745f2019-04-09 16:28:00 +02004206 LY_CHECK_GOTO(lys_compile_status(ctx, &cs->flags, ch->flags), error);
Radek Krejci00b874b2019-02-12 10:54:50 +01004207
4208 if (node_p->when) {
4209 LY_ARRAY_NEW_GOTO(ctx->ctx, cs->when, when, ret, error);
Michal Vasko175012e2019-11-06 15:49:14 +01004210 ret = lys_compile_when(ctx, node_p->when, node_p->flags, (struct lysc_node *)cs, when);
Radek Krejci00b874b2019-02-12 10:54:50 +01004211 LY_CHECK_GOTO(ret, error);
Michal Vasko175012e2019-11-06 15:49:14 +01004212
4213 if (!(ctx->options & LYSC_OPT_GROUPING)) {
4214 /* do not check "when" semantics in a grouping */
Michal Vasko004d3152020-06-11 19:59:22 +02004215 ly_set_add(&ctx->xpath, cs, 0);
Michal Vasko175012e2019-11-06 15:49:14 +01004216 }
Radek Krejci00b874b2019-02-12 10:54:50 +01004217 }
Radek Krejciec4da802019-05-02 13:02:41 +02004218 COMPILE_ARRAY_GOTO(ctx, node_p->iffeatures, cs->iffeatures, u, lys_compile_iffeature, ret, error);
Radek Krejci95710c92019-02-11 15:49:55 +01004219 } else {
4220 LOGINT(ctx->ctx);
4221 goto error;
Radek Krejci056d0a82018-12-06 16:57:25 +01004222 }
4223 cs->module = ctx->mod;
4224 cs->prev = (struct lysc_node*)cs;
4225 cs->nodetype = LYS_CASE;
Radek Krejciec4da802019-05-02 13:02:41 +02004226 lys_compile_node_connect(ctx, (struct lysc_node*)ch, (struct lysc_node*)cs);
Radek Krejci056d0a82018-12-06 16:57:25 +01004227 cs->child = child;
4228
4229 return cs;
4230error:
Radek Krejci1b1e9252019-04-24 08:45:50 +02004231 if (cs) {
4232 lysc_node_free(ctx->ctx, (struct lysc_node*)cs);
4233 }
Radek Krejci056d0a82018-12-06 16:57:25 +01004234 return NULL;
4235
4236#undef UNIQUE_CHECK
4237}
4238
Radek Krejcib56c7502019-02-13 14:19:54 +01004239/**
Radek Krejci93dcc392019-02-19 10:43:38 +01004240 * @brief Apply refined or deviated config to the target node.
Radek Krejcib56c7502019-02-13 14:19:54 +01004241 *
4242 * @param[in] ctx Compile context.
Radek Krejci93dcc392019-02-19 10:43:38 +01004243 * @param[in] node Target node where the config is supposed to be changed.
4244 * @param[in] config_flag Node's config flag to be applied to the @p node.
Radek Krejcib56c7502019-02-13 14:19:54 +01004245 * @param[in] inheriting Flag (inverted) to check the refined config compatibility with the node's parent. This is
4246 * done only on the node for which the refine was created. The function applies also recursively to apply the config change
Radek Krejci93dcc392019-02-19 10:43:38 +01004247 * to the complete subtree (except the subnodes with explicit config set) and the test is not needed for the subnodes.
4248 * @param[in] refine_flag Flag to distinguish if the change is caused by refine (flag set) or deviation (for logging).
Radek Krejcib56c7502019-02-13 14:19:54 +01004249 * @return LY_ERR value.
4250 */
Radek Krejci76b3e962018-12-14 17:01:25 +01004251static LY_ERR
Radek Krejci93dcc392019-02-19 10:43:38 +01004252lys_compile_change_config(struct lysc_ctx *ctx, struct lysc_node *node, uint16_t config_flag,
Radek Krejci327de162019-06-14 12:52:07 +02004253 int inheriting, int refine_flag)
Radek Krejci76b3e962018-12-14 17:01:25 +01004254{
4255 struct lysc_node *child;
Radek Krejci93dcc392019-02-19 10:43:38 +01004256 uint16_t config = config_flag & LYS_CONFIG_MASK;
Radek Krejci76b3e962018-12-14 17:01:25 +01004257
4258 if (config == (node->flags & LYS_CONFIG_MASK)) {
4259 /* nothing to do */
4260 return LY_SUCCESS;
4261 }
4262
4263 if (!inheriting) {
Radek Krejci93dcc392019-02-19 10:43:38 +01004264 /* explicit change */
Radek Krejci76b3e962018-12-14 17:01:25 +01004265 if (config == LYS_CONFIG_W && node->parent && (node->parent->flags & LYS_CONFIG_R)) {
4266 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004267 "Invalid %s of config - configuration node cannot be child of any state data node.",
4268 refine_flag ? "refine" : "deviation");
Radek Krejci76b3e962018-12-14 17:01:25 +01004269 return LY_EVALID;
4270 }
Radek Krejci93dcc392019-02-19 10:43:38 +01004271 node->flags |= LYS_SET_CONFIG;
4272 } else {
4273 if (node->flags & LYS_SET_CONFIG) {
4274 if ((node->flags & LYS_CONFIG_W) && (config == LYS_CONFIG_R)) {
4275 /* setting config flags, but have node with explicit config true */
4276 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004277 "Invalid %s of config - configuration node cannot be child of any state data node.",
4278 refine_flag ? "refine" : "deviation");
Radek Krejci93dcc392019-02-19 10:43:38 +01004279 return LY_EVALID;
4280 }
4281 /* do not change config on nodes where the config is explicitely set, this does not apply to
4282 * nodes, which are being changed explicitly (targets of refine or deviation) */
4283 return LY_SUCCESS;
4284 }
Radek Krejci76b3e962018-12-14 17:01:25 +01004285 }
4286 node->flags &= ~LYS_CONFIG_MASK;
4287 node->flags |= config;
4288
4289 /* inherit the change into the children */
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004290 LY_LIST_FOR((struct lysc_node*)lysc_node_children(node, 0), child) {
Radek Krejci327de162019-06-14 12:52:07 +02004291 LY_CHECK_RET(lys_compile_change_config(ctx, child, config_flag, 1, refine_flag));
Radek Krejci76b3e962018-12-14 17:01:25 +01004292 }
4293
Radek Krejci76b3e962018-12-14 17:01:25 +01004294 return LY_SUCCESS;
4295}
4296
Radek Krejcib56c7502019-02-13 14:19:54 +01004297/**
4298 * @brief Set LYS_MAND_TRUE flag for the non-presence container parents.
4299 *
4300 * A non-presence container is mandatory in case it has at least one mandatory children. This function propagate
4301 * the flag to such parents from a mandatory children.
4302 *
4303 * @param[in] parent A schema node to be examined if the mandatory child make it also mandatory.
4304 * @param[in] add Flag to distinguish adding the mandatory flag (new mandatory children appeared) or removing the flag
4305 * (mandatory children was removed).
4306 */
Radek Krejcife909632019-02-12 15:34:42 +01004307void
4308lys_compile_mandatory_parents(struct lysc_node *parent, int add)
4309{
4310 struct lysc_node *iter;
4311
4312 if (add) { /* set flag */
4313 for (; parent && parent->nodetype == LYS_CONTAINER && !(parent->flags & LYS_MAND_TRUE) && !(parent->flags & LYS_PRESENCE);
4314 parent = parent->parent) {
4315 parent->flags |= LYS_MAND_TRUE;
4316 }
4317 } else { /* unset flag */
4318 for (; parent && parent->nodetype == LYS_CONTAINER && (parent->flags & LYS_MAND_TRUE); parent = parent->parent) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004319 for (iter = (struct lysc_node*)lysc_node_children(parent, 0); iter; iter = iter->next) {
Radek Krejcif1421c22019-02-19 13:05:20 +01004320 if (iter->flags & LYS_MAND_TRUE) {
Radek Krejcife909632019-02-12 15:34:42 +01004321 /* there is another mandatory node */
4322 return;
4323 }
4324 }
4325 /* unset mandatory flag - there is no mandatory children in the non-presence container */
4326 parent->flags &= ~LYS_MAND_TRUE;
4327 }
4328 }
4329}
4330
Radek Krejci056d0a82018-12-06 16:57:25 +01004331/**
Radek Krejci3641f562019-02-13 15:38:40 +01004332 * @brief Internal sorting process for the lys_compile_augment_sort().
4333 * @param[in] aug_p The parsed augment structure to insert into the sorter sized array @p result.
4334 * @param[in,out] result Sized array to store the sorted list of augments. The array is expected
4335 * to be allocated to hold the complete list, its size is just incremented by adding another item.
4336 */
4337static void
4338lys_compile_augment_sort_(struct lysp_augment *aug_p, struct lysp_augment **result)
4339{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004340 LY_ARRAY_COUNT_TYPE v;
Radek Krejci3641f562019-02-13 15:38:40 +01004341 size_t len;
4342
4343 len = strlen(aug_p->nodeid);
4344 LY_ARRAY_FOR(result, v) {
4345 if (strlen(result[v]->nodeid) <= len) {
4346 continue;
4347 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004348 if (v < LY_ARRAY_COUNT(result)) {
Radek Krejci3641f562019-02-13 15:38:40 +01004349 /* move the rest of array */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004350 memmove(&result[v + 1], &result[v], (LY_ARRAY_COUNT(result) - v) * sizeof *result);
Radek Krejci3641f562019-02-13 15:38:40 +01004351 break;
4352 }
4353 }
4354 result[v] = aug_p;
4355 LY_ARRAY_INCREMENT(result);
4356}
4357
4358/**
4359 * @brief Sort augments to apply /a/b before /a/b/c (where the /a/b/c was added by the first augment).
4360 *
4361 * The sorting is based only on the length of the augment's path since it guarantee the correct order
4362 * (it doesn't matter the /a/x is done before /a/b/c from the example above).
4363 *
4364 * @param[in] ctx Compile context.
4365 * @param[in] mod_p Parsed module with the global augments (also augments from the submodules are taken).
4366 * @param[in] aug_p Parsed sized array of augments to sort (no matter if global or uses's)
4367 * @param[in] inc_p In case of global augments, sized array of module includes (submodules) to get global augments from submodules.
4368 * @param[out] augments Resulting sorted sized array of pointers to the augments.
4369 * @return LY_ERR value.
4370 */
4371LY_ERR
4372lys_compile_augment_sort(struct lysc_ctx *ctx, struct lysp_augment *aug_p, struct lysp_include *inc_p, struct lysp_augment ***augments)
4373{
4374 struct lysp_augment **result = NULL;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004375 LY_ARRAY_COUNT_TYPE u, v, count = 0;
Radek Krejci3641f562019-02-13 15:38:40 +01004376
4377 assert(augments);
4378
4379 /* get count of the augments in module and all its submodules */
4380 if (aug_p) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004381 count += LY_ARRAY_COUNT(aug_p);
Radek Krejci3641f562019-02-13 15:38:40 +01004382 }
4383 LY_ARRAY_FOR(inc_p, u) {
4384 if (inc_p[u].submodule->augments) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004385 count += LY_ARRAY_COUNT(inc_p[u].submodule->augments);
Radek Krejci3641f562019-02-13 15:38:40 +01004386 }
4387 }
4388
4389 if (!count) {
4390 *augments = NULL;
4391 return LY_SUCCESS;
4392 }
4393 LY_ARRAY_CREATE_RET(ctx->ctx, result, count, LY_EMEM);
4394
4395 /* sort by the length of schema-nodeid - we need to solve /x before /x/xy. It is not necessary to group them
4396 * together, so there can be even /z/y betwwen them. */
4397 LY_ARRAY_FOR(aug_p, u) {
4398 lys_compile_augment_sort_(&aug_p[u], result);
4399 }
4400 LY_ARRAY_FOR(inc_p, u) {
4401 LY_ARRAY_FOR(inc_p[u].submodule->augments, v) {
4402 lys_compile_augment_sort_(&inc_p[u].submodule->augments[v], result);
4403 }
4404 }
4405
4406 *augments = result;
4407 return LY_SUCCESS;
4408}
4409
4410/**
4411 * @brief Compile the parsed augment connecting it into its target.
4412 *
4413 * It is expected that all the data referenced in path are present - augments are ordered so that augment B
4414 * targeting data from augment A is being compiled after augment A. Also the modules referenced in the path
4415 * are already implemented and compiled.
4416 *
4417 * @param[in] ctx Compile context.
4418 * @param[in] aug_p Parsed augment to compile.
Radek Krejci3641f562019-02-13 15:38:40 +01004419 * @param[in] parent Parent node to provide the augment's context. It is NULL for the top level augments and a node holding uses's
4420 * children in case of the augmenting uses data.
4421 * @return LY_SUCCESS on success.
4422 * @return LY_EVALID on failure.
4423 */
4424LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02004425lys_compile_augment(struct lysc_ctx *ctx, struct lysp_augment *aug_p, const struct lysc_node *parent)
Radek Krejci3641f562019-02-13 15:38:40 +01004426{
Michal Vaskoe6143202020-07-03 13:02:08 +02004427 LY_ERR ret = LY_SUCCESS, rc;
Radek Krejci3641f562019-02-13 15:38:40 +01004428 struct lysp_node *node_p, *case_node_p;
4429 struct lysc_node *target; /* target target of the augment */
4430 struct lysc_node *node;
Radek Krejci3641f562019-02-13 15:38:40 +01004431 struct lysc_when **when, *when_shared;
Michal Vaskoa3af5982020-06-29 11:51:37 +02004432 struct lys_module **aug_mod;
Radek Krejci3641f562019-02-13 15:38:40 +01004433 int allow_mandatory = 0;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004434 uint16_t flags = 0;
Michal Vaskoe6143202020-07-03 13:02:08 +02004435 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejciec4da802019-05-02 13:02:41 +02004436 int opt_prev = ctx->options;
Radek Krejci3641f562019-02-13 15:38:40 +01004437
Radek Krejci327de162019-06-14 12:52:07 +02004438 lysc_update_path(ctx, NULL, "{augment}");
4439 lysc_update_path(ctx, NULL, aug_p->nodeid);
4440
Radek Krejci7af64242019-02-18 13:07:53 +01004441 ret = lys_resolve_schema_nodeid(ctx, aug_p->nodeid, 0, parent, parent ? parent->module : ctx->mod_def,
Radek Krejci3641f562019-02-13 15:38:40 +01004442 LYS_CONTAINER | LYS_LIST | LYS_CHOICE | LYS_CASE | LYS_INOUT | LYS_NOTIF,
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004443 1, (const struct lysc_node**)&target, &flags);
Radek Krejci3641f562019-02-13 15:38:40 +01004444 if (ret != LY_SUCCESS) {
4445 if (ret == LY_EDENIED) {
4446 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
4447 "Augment's %s-schema-nodeid \"%s\" refers to a %s node which is not an allowed augment's target.",
4448 parent ? "descendant" : "absolute", aug_p->nodeid, lys_nodetype2str(target->nodetype));
4449 }
4450 return LY_EVALID;
4451 }
4452
4453 /* check for mandatory nodes
4454 * - new cases augmenting some choice can have mandatory nodes
4455 * - mandatory nodes are allowed only in case the augmentation is made conditional with a when statement
4456 */
Radek Krejci733988a2019-02-15 15:12:44 +01004457 if (aug_p->when || target->nodetype == LYS_CHOICE || ctx->mod == target->module) {
Radek Krejci3641f562019-02-13 15:38:40 +01004458 allow_mandatory = 1;
4459 }
4460
4461 when_shared = NULL;
4462 LY_LIST_FOR(aug_p->child, node_p) {
4463 /* check if the subnode can be connected to the found target (e.g. case cannot be inserted into container) */
4464 if (!(target->nodetype == LYS_CHOICE && node_p->nodetype == LYS_CASE)
Michal Vasko1bf09392020-03-27 12:38:10 +01004465 && !((target->nodetype & (LYS_CONTAINER | LYS_LIST)) && (node_p->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)))
Radek Krejci2d56a892019-02-19 09:05:26 +01004466 && !(target->nodetype != LYS_CHOICE && node_p->nodetype == LYS_USES)
4467 && !(node_p->nodetype & (LYS_ANYDATA | LYS_CONTAINER | LYS_CHOICE | LYS_LEAF | LYS_LIST | LYS_LEAFLIST))) {
Radek Krejci3641f562019-02-13 15:38:40 +01004468 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02004469 "Invalid augment of %s node which is not allowed to contain %s node \"%s\".",
4470 lys_nodetype2str(target->nodetype), lys_nodetype2str(node_p->nodetype), node_p->name);
Radek Krejci3641f562019-02-13 15:38:40 +01004471 return LY_EVALID;
4472 }
4473
4474 /* compile the children */
Radek Krejciec4da802019-05-02 13:02:41 +02004475 ctx->options |= flags;
Radek Krejci3641f562019-02-13 15:38:40 +01004476 if (node_p->nodetype != LYS_CASE) {
Radek Krejciec4da802019-05-02 13:02:41 +02004477 LY_CHECK_RET(lys_compile_node(ctx, node_p, target, 0));
Radek Krejci3641f562019-02-13 15:38:40 +01004478 } else {
4479 LY_LIST_FOR(((struct lysp_node_case *)node_p)->child, case_node_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02004480 LY_CHECK_RET(lys_compile_node(ctx, case_node_p, target, 0));
Radek Krejci3641f562019-02-13 15:38:40 +01004481 }
4482 }
Radek Krejciec4da802019-05-02 13:02:41 +02004483 ctx->options = opt_prev;
Radek Krejci3641f562019-02-13 15:38:40 +01004484
Radek Krejcife13da42019-02-15 14:51:01 +01004485 /* since the augment node is not present in the compiled tree, we need to pass some of its statements to all its children,
4486 * here we gets the last created node as last children of our parent */
Radek Krejci3641f562019-02-13 15:38:40 +01004487 if (target->nodetype == LYS_CASE) {
Radek Krejcife13da42019-02-15 14:51:01 +01004488 /* the compiled node is the last child of the target (but it is a case, so we have to be careful and stop) */
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004489 for (node = (struct lysc_node*)lysc_node_children(target, flags); node->next && node->next->parent == node->parent; node = node->next);
Radek Krejci3641f562019-02-13 15:38:40 +01004490 } else if (target->nodetype == LYS_CHOICE) {
4491 /* to pass when statement, we need the last case no matter if it is explicit or implicit case */
4492 node = ((struct lysc_node_choice*)target)->cases->prev;
4493 } else {
4494 /* the compiled node is the last child of the target */
Radek Krejci7c7783d2020-04-08 15:34:39 +02004495 node = (struct lysc_node*)lysc_node_children(target, flags);
4496 if (!node) {
4497 /* there is no data children (compiled nodes is e.g. notification or action or nothing) */
4498 break;
4499 }
4500 node = node->prev;
Radek Krejci3641f562019-02-13 15:38:40 +01004501 }
4502
Radek Krejci733988a2019-02-15 15:12:44 +01004503 if (!allow_mandatory && (node->flags & LYS_CONFIG_W) && (node->flags & LYS_MAND_TRUE)) {
Radek Krejci3641f562019-02-13 15:38:40 +01004504 node->flags &= ~LYS_MAND_TRUE;
4505 lys_compile_mandatory_parents(target, 0);
4506 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004507 "Invalid augment adding mandatory node \"%s\" without making it conditional via when statement.", node->name);
Radek Krejci3641f562019-02-13 15:38:40 +01004508 return LY_EVALID;
4509 }
4510
4511 /* pass augment's when to all the children */
4512 if (aug_p->when) {
4513 LY_ARRAY_NEW_GOTO(ctx->ctx, node->when, when, ret, error);
4514 if (!when_shared) {
Michal Vasko175012e2019-11-06 15:49:14 +01004515 ret = lys_compile_when(ctx, aug_p->when, aug_p->flags, target, when);
Radek Krejci3641f562019-02-13 15:38:40 +01004516 LY_CHECK_GOTO(ret, error);
Michal Vasko175012e2019-11-06 15:49:14 +01004517
4518 if (!(ctx->options & LYSC_OPT_GROUPING)) {
4519 /* do not check "when" semantics in a grouping */
Michal Vasko004d3152020-06-11 19:59:22 +02004520 ly_set_add(&ctx->xpath, node, 0);
Michal Vasko175012e2019-11-06 15:49:14 +01004521 }
4522
Radek Krejci3641f562019-02-13 15:38:40 +01004523 when_shared = *when;
4524 } else {
4525 ++when_shared->refcount;
4526 (*when) = when_shared;
Michal Vasko5c4e5892019-11-14 12:31:38 +01004527
4528 if (!(ctx->options & LYSC_OPT_GROUPING)) {
4529 /* in this case check "when" again for all children because of dummy node check */
Michal Vasko004d3152020-06-11 19:59:22 +02004530 ly_set_add(&ctx->xpath, node, 0);
Michal Vasko5c4e5892019-11-14 12:31:38 +01004531 }
Radek Krejci3641f562019-02-13 15:38:40 +01004532 }
4533 }
4534 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004535
Radek Krejciec4da802019-05-02 13:02:41 +02004536 ctx->options |= flags;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004537 switch (target->nodetype) {
4538 case LYS_CONTAINER:
Radek Krejci05b774b2019-02-25 13:26:18 +01004539 COMPILE_ARRAY1_GOTO(ctx, aug_p->actions, ((struct lysc_node_container*)target)->actions, target,
Radek Krejciec4da802019-05-02 13:02:41 +02004540 u, lys_compile_action, 0, ret, error);
Radek Krejcifc11bd72019-04-11 16:00:05 +02004541 COMPILE_ARRAY1_GOTO(ctx, aug_p->notifs, ((struct lysc_node_container*)target)->notifs, target,
Radek Krejciec4da802019-05-02 13:02:41 +02004542 u, lys_compile_notif, 0, ret, error);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004543 break;
4544 case LYS_LIST:
Radek Krejci05b774b2019-02-25 13:26:18 +01004545 COMPILE_ARRAY1_GOTO(ctx, aug_p->actions, ((struct lysc_node_list*)target)->actions, target,
Radek Krejciec4da802019-05-02 13:02:41 +02004546 u, lys_compile_action, 0, ret, error);
Radek Krejcifc11bd72019-04-11 16:00:05 +02004547 COMPILE_ARRAY1_GOTO(ctx, aug_p->notifs, ((struct lysc_node_list*)target)->notifs, target,
Radek Krejciec4da802019-05-02 13:02:41 +02004548 u, lys_compile_notif, 0, ret, error);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004549 break;
4550 default:
Radek Krejciec4da802019-05-02 13:02:41 +02004551 ctx->options = opt_prev;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004552 if (aug_p->actions) {
4553 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02004554 "Invalid augment of %s node which is not allowed to contain RPC/action node \"%s\".",
4555 lys_nodetype2str(target->nodetype), aug_p->actions[0].name);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004556 return LY_EVALID;
4557 }
4558 if (aug_p->notifs) {
4559 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Michal Vaskoa3881362020-01-21 15:57:35 +01004560 "Invalid augment of %s node which is not allowed to contain notification node \"%s\".",
Radek Krejci327de162019-06-14 12:52:07 +02004561 lys_nodetype2str(target->nodetype), aug_p->notifs[0].name);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004562 return LY_EVALID;
4563 }
4564 }
Radek Krejci3641f562019-02-13 15:38:40 +01004565
Michal Vaskoe6143202020-07-03 13:02:08 +02004566 /* add this module into the target module augmented_by, if not there already */
4567 rc = LY_SUCCESS;
4568 LY_ARRAY_FOR(target->module->compiled->augmented_by, v) {
4569 if (target->module->compiled->augmented_by[v] == ctx->mod) {
4570 rc = LY_EEXIST;
4571 break;
4572 }
4573 }
4574 if (!rc) {
4575 LY_ARRAY_NEW_GOTO(ctx->ctx, target->module->compiled->augmented_by, aug_mod, ret, error);
4576 *aug_mod = ctx->mod;
4577 }
Michal Vaskoa3af5982020-06-29 11:51:37 +02004578
Radek Krejci327de162019-06-14 12:52:07 +02004579 lysc_update_path(ctx, NULL, NULL);
4580 lysc_update_path(ctx, NULL, NULL);
Michal Vaskoa3af5982020-06-29 11:51:37 +02004581
Radek Krejci3641f562019-02-13 15:38:40 +01004582error:
Radek Krejciec4da802019-05-02 13:02:41 +02004583 ctx->options = opt_prev;
Radek Krejci3641f562019-02-13 15:38:40 +01004584 return ret;
4585}
4586
4587/**
Radek Krejcif1421c22019-02-19 13:05:20 +01004588 * @brief Apply refined or deviated mandatory flag to the target node.
4589 *
4590 * @param[in] ctx Compile context.
4591 * @param[in] node Target node where the mandatory property is supposed to be changed.
4592 * @param[in] mandatory_flag Node's mandatory flag to be applied to the @p node.
Radek Krejcif1421c22019-02-19 13:05:20 +01004593 * @param[in] refine_flag Flag to distinguish if the change is caused by refine (flag set) or deviation (for logging).
Radek Krejci551b12c2019-02-19 16:11:21 +01004594 * @param[in] It is also used as a flag for testing for compatibility with default statement. In case of deviations,
4595 * there can be some other deviations of the default properties that we are testing here. To avoid false positive failure,
4596 * the tests are skipped here, but they are supposed to be performed after all the deviations are applied.
Radek Krejcif1421c22019-02-19 13:05:20 +01004597 * @return LY_ERR value.
4598 */
4599static LY_ERR
Radek Krejci327de162019-06-14 12:52:07 +02004600lys_compile_change_mandatory(struct lysc_ctx *ctx, struct lysc_node *node, uint16_t mandatory_flag, int refine_flag)
Radek Krejcif1421c22019-02-19 13:05:20 +01004601{
4602 if (!(node->nodetype & (LYS_LEAF | LYS_ANYDATA | LYS_ANYXML | LYS_CHOICE))) {
4603 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004604 "Invalid %s of mandatory - %s cannot hold mandatory statement.",
4605 refine_flag ? "refine" : "deviation", lys_nodetype2str(node->nodetype));
Radek Krejcif1421c22019-02-19 13:05:20 +01004606 return LY_EVALID;
4607 }
4608
4609 if (mandatory_flag & LYS_MAND_TRUE) {
4610 /* check if node has default value */
4611 if (node->nodetype & LYS_LEAF) {
4612 if (node->flags & LYS_SET_DFLT) {
Radek Krejci551b12c2019-02-19 16:11:21 +01004613 if (refine_flag) {
4614 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004615 "Invalid refine of mandatory - leaf already has \"default\" statement.");
Radek Krejci551b12c2019-02-19 16:11:21 +01004616 return LY_EVALID;
4617 }
Radek Krejcia1911222019-07-22 17:24:50 +02004618 } else if (((struct lysc_node_leaf*)node)->dflt) {
Radek Krejcif1421c22019-02-19 13:05:20 +01004619 /* remove the default value taken from the leaf's type */
Radek Krejcia1911222019-07-22 17:24:50 +02004620 struct lysc_node_leaf *leaf = (struct lysc_node_leaf*)node;
Radek Krejci474f9b82019-07-24 11:36:37 +02004621
4622 /* update the list of incomplete default values if needed */
4623 lysc_incomplete_dflts_remove(ctx, leaf->dflt);
4624
Radek Krejcia1911222019-07-22 17:24:50 +02004625 leaf->dflt->realtype->plugin->free(ctx->ctx, leaf->dflt);
4626 lysc_type_free(ctx->ctx, leaf->dflt->realtype);
4627 free(leaf->dflt);
4628 leaf->dflt = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02004629 leaf->dflt_mod = NULL;
Radek Krejcif1421c22019-02-19 13:05:20 +01004630 }
4631 } else if ((node->nodetype & LYS_CHOICE) && ((struct lysc_node_choice*)node)->dflt) {
Radek Krejci551b12c2019-02-19 16:11:21 +01004632 if (refine_flag) {
4633 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004634 "Invalid refine of mandatory - choice already has \"default\" statement.");
Radek Krejci551b12c2019-02-19 16:11:21 +01004635 return LY_EVALID;
4636 }
Radek Krejcif1421c22019-02-19 13:05:20 +01004637 }
Radek Krejci551b12c2019-02-19 16:11:21 +01004638 if (refine_flag && node->parent && (node->parent->flags & LYS_SET_DFLT)) {
Radek Krejci327de162019-06-14 12:52:07 +02004639 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Invalid refine of mandatory under the default case.");
Radek Krejcif1421c22019-02-19 13:05:20 +01004640 return LY_EVALID;
4641 }
4642
4643 node->flags &= ~LYS_MAND_FALSE;
4644 node->flags |= LYS_MAND_TRUE;
4645 lys_compile_mandatory_parents(node->parent, 1);
4646 } else {
4647 /* make mandatory false */
4648 node->flags &= ~LYS_MAND_TRUE;
4649 node->flags |= LYS_MAND_FALSE;
4650 lys_compile_mandatory_parents(node->parent, 0);
Radek Krejcia1911222019-07-22 17:24:50 +02004651 if ((node->nodetype & LYS_LEAF) && !((struct lysc_node_leaf*)node)->dflt && ((struct lysc_node_leaf*)node)->type->dflt) {
Radek Krejcif1421c22019-02-19 13:05:20 +01004652 /* get the type's default value if any */
Radek Krejcia1911222019-07-22 17:24:50 +02004653 struct lysc_node_leaf *leaf = (struct lysc_node_leaf*)node;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02004654 leaf->dflt_mod = leaf->type->dflt_mod;
Radek Krejcia1911222019-07-22 17:24:50 +02004655 leaf->dflt = calloc(1, sizeof *leaf->dflt);
4656 leaf->dflt->realtype = leaf->type->dflt->realtype;
4657 leaf->dflt->realtype->plugin->duplicate(ctx->ctx, leaf->type->dflt, leaf->dflt);
4658 leaf->dflt->realtype->refcount++;
Radek Krejcif1421c22019-02-19 13:05:20 +01004659 }
4660 }
4661 return LY_SUCCESS;
4662}
4663
4664/**
Radek Krejcie86bf772018-12-14 11:39:53 +01004665 * @brief Compile parsed uses statement - resolve target grouping and connect its content into parent.
4666 * If present, also apply uses's modificators.
4667 *
4668 * @param[in] ctx Compile context
4669 * @param[in] uses_p Parsed uses schema node.
Radek Krejcie86bf772018-12-14 11:39:53 +01004670 * @param[in] parent Compiled parent node where the content of the referenced grouping is supposed to be connected. It is
4671 * NULL for top-level nodes, in such a case the module where the node will be connected is taken from
4672 * the compile context.
4673 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
4674 */
4675static LY_ERR
Radek Krejcic6b4f442020-08-12 14:45:18 +02004676lys_compile_uses(struct lysc_ctx *ctx, struct lysp_node_uses *uses_p, struct lysc_node *parent, struct lysc_node **first_p)
Radek Krejcie86bf772018-12-14 11:39:53 +01004677{
4678 struct lysp_node *node_p;
Radek Krejcic6b4f442020-08-12 14:45:18 +02004679 struct lysc_node *node, *child, *iter;
Radek Krejci12fb9142019-01-08 09:45:30 +01004680 /* context_node_fake allows us to temporarily isolate the nodes inserted from the grouping instead of uses */
Radek Krejci01342af2019-01-03 15:18:08 +01004681 struct lysc_node_container context_node_fake =
4682 {.nodetype = LYS_CONTAINER,
4683 .module = ctx->mod,
4684 .flags = parent ? parent->flags : 0,
4685 .child = NULL, .next = NULL,
Radek Krejcifc11bd72019-04-11 16:00:05 +02004686 .prev = (struct lysc_node*)&context_node_fake,
4687 .actions = NULL, .notifs = NULL};
Radek Krejciec4da802019-05-02 13:02:41 +02004688 struct lysp_grp *grp = NULL;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004689 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02004690 uint32_t grp_stack_count;
Radek Krejcie86bf772018-12-14 11:39:53 +01004691 int found;
4692 const char *id, *name, *prefix;
4693 size_t prefix_len, name_len;
4694 struct lys_module *mod, *mod_old;
Radek Krejci76b3e962018-12-14 17:01:25 +01004695 struct lysp_refine *rfn;
Radek Krejcia1911222019-07-22 17:24:50 +02004696 LY_ERR ret = LY_EVALID, rc;
Radek Krejcif2271f12019-01-07 16:42:23 +01004697 uint32_t min, max;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004698 uint16_t flags;
Radek Krejcif2271f12019-01-07 16:42:23 +01004699 struct ly_set refined = {0};
Radek Krejci00b874b2019-02-12 10:54:50 +01004700 struct lysc_when **when, *when_shared;
Radek Krejci3641f562019-02-13 15:38:40 +01004701 struct lysp_augment **augments = NULL;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004702 LY_ARRAY_COUNT_TYPE actions_index = 0, notifs_index = 0;
Radek Krejcifc11bd72019-04-11 16:00:05 +02004703 struct lysc_notif **notifs = NULL;
4704 struct lysc_action **actions = NULL;
Radek Krejcie86bf772018-12-14 11:39:53 +01004705
4706 /* search for the grouping definition */
4707 found = 0;
4708 id = uses_p->name;
Radek Krejcib4a4a272019-06-10 12:44:52 +02004709 LY_CHECK_RET(ly_parse_nodeid(&id, &prefix, &prefix_len, &name, &name_len), LY_EVALID);
Radek Krejcie86bf772018-12-14 11:39:53 +01004710 if (prefix) {
4711 mod = lys_module_find_prefix(ctx->mod_def, prefix, prefix_len);
4712 if (!mod) {
4713 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02004714 "Invalid prefix used for grouping reference.", uses_p->name);
Radek Krejcie86bf772018-12-14 11:39:53 +01004715 return LY_EVALID;
4716 }
4717 } else {
4718 mod = ctx->mod_def;
4719 }
4720 if (mod == ctx->mod_def) {
4721 for (node_p = uses_p->parent; !found && node_p; node_p = node_p->parent) {
Radek Krejciec4da802019-05-02 13:02:41 +02004722 grp = (struct lysp_grp*)lysp_node_groupings(node_p);
Radek Krejcie86bf772018-12-14 11:39:53 +01004723 LY_ARRAY_FOR(grp, u) {
4724 if (!strcmp(grp[u].name, name)) {
4725 grp = &grp[u];
4726 found = 1;
4727 break;
4728 }
4729 }
4730 }
4731 }
4732 if (!found) {
Radek Krejci76b3e962018-12-14 17:01:25 +01004733 /* search in top-level groupings of the main module ... */
Radek Krejcie86bf772018-12-14 11:39:53 +01004734 grp = mod->parsed->groupings;
Radek Krejci76b3e962018-12-14 17:01:25 +01004735 if (grp) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004736 for (u = 0; !found && u < LY_ARRAY_COUNT(grp); ++u) {
Radek Krejci76b3e962018-12-14 17:01:25 +01004737 if (!strcmp(grp[u].name, name)) {
4738 grp = &grp[u];
4739 found = 1;
4740 }
4741 }
4742 }
4743 if (!found && mod->parsed->includes) {
4744 /* ... and all the submodules */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004745 for (u = 0; !found && u < LY_ARRAY_COUNT(mod->parsed->includes); ++u) {
Radek Krejci76b3e962018-12-14 17:01:25 +01004746 grp = mod->parsed->includes[u].submodule->groupings;
4747 if (grp) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004748 for (v = 0; !found && v < LY_ARRAY_COUNT(grp); ++v) {
Radek Krejci76b3e962018-12-14 17:01:25 +01004749 if (!strcmp(grp[v].name, name)) {
4750 grp = &grp[v];
4751 found = 1;
4752 }
4753 }
4754 }
Radek Krejcie86bf772018-12-14 11:39:53 +01004755 }
4756 }
4757 }
4758 if (!found) {
4759 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
4760 "Grouping \"%s\" referenced by a uses statement not found.", uses_p->name);
4761 return LY_EVALID;
4762 }
4763
4764 /* grouping must not reference themselves - stack in ctx maintains list of groupings currently being applied */
4765 grp_stack_count = ctx->groupings.count;
4766 ly_set_add(&ctx->groupings, (void*)grp, 0);
4767 if (grp_stack_count == ctx->groupings.count) {
4768 /* the target grouping is already in the stack, so we are already inside it -> circular dependency */
4769 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
4770 "Grouping \"%s\" references itself through a uses statement.", grp->name);
4771 return LY_EVALID;
4772 }
Radek Krejcif2de0ed2019-05-02 14:13:18 +02004773 if (!(ctx->options & LYSC_OPT_GROUPING)) {
4774 /* remember that the grouping is instantiated to avoid its standalone validation */
4775 grp->flags |= LYS_USED_GRP;
4776 }
Radek Krejcie86bf772018-12-14 11:39:53 +01004777
4778 /* switch context's mod_def */
4779 mod_old = ctx->mod_def;
4780 ctx->mod_def = mod;
4781
4782 /* check status */
Radek Krejcifc11bd72019-04-11 16:00:05 +02004783 LY_CHECK_GOTO(lysc_check_status(ctx, uses_p->flags, mod_old, uses_p->name, grp->flags, mod, grp->name), cleanup);
Radek Krejcie86bf772018-12-14 11:39:53 +01004784
Radek Krejcic6b4f442020-08-12 14:45:18 +02004785 /* remember the currently last child before processing the uses - it is needed to split the siblings to corretly
4786 * applu refine and augment only to the nodes from the uses */
4787 if (parent) {
4788 if (parent->nodetype == LYS_CASE) {
4789 child = (struct lysc_node*)lysc_node_children(parent->parent, ctx->options & LYSC_OPT_RPC_MASK);
4790 } else {
4791 child = (struct lysc_node*)lysc_node_children(parent, ctx->options & LYSC_OPT_RPC_MASK);
4792 }
4793 } else if (ctx->mod->compiled->data) {
4794 child = ctx->mod->compiled->data;
4795 } else {
4796 child = NULL;
4797 }
4798 /* remember the last child */
4799 if (child) {
4800 child = child->prev;
4801 }
4802
Radek Krejcifc11bd72019-04-11 16:00:05 +02004803 /* compile data nodes */
Radek Krejcie86bf772018-12-14 11:39:53 +01004804 LY_LIST_FOR(grp->data, node_p) {
Radek Krejcib1b59152019-01-07 13:21:56 +01004805 /* 0x3 in uses_status is a special bits combination to be able to detect status flags from uses */
Radek Krejciec4da802019-05-02 13:02:41 +02004806 LY_CHECK_GOTO(lys_compile_node(ctx, node_p, parent, (uses_p->flags & LYS_STATUS_MASK) | 0x3), cleanup);
Radek Krejci01342af2019-01-03 15:18:08 +01004807 }
Radek Krejcic6b4f442020-08-12 14:45:18 +02004808
4809 /* split the children and add the uses's data into the fake context node */
4810 if (child) {
4811 context_node_fake.child = child->next;
4812 } else if (parent) {
4813 context_node_fake.child = (struct lysc_node*)lysc_node_children(parent, ctx->options & LYSC_OPT_RPC_MASK);
4814 } else if (ctx->mod->compiled->data) {
4815 context_node_fake.child = ctx->mod->compiled->data;
4816 }
4817 if (context_node_fake.child) {
4818 /* remember child as the last data node added by grouping to fix the list later */
4819 child = context_node_fake.child->prev;
4820 context_node_fake.child->prev = NULL;
4821 }
4822
Radek Krejci00b874b2019-02-12 10:54:50 +01004823 when_shared = NULL;
Radek Krejcic6b4f442020-08-12 14:45:18 +02004824 LY_LIST_FOR(context_node_fake.child, iter) {
4825 iter->parent = (struct lysc_node*)&context_node_fake;
Radek Krejci00b874b2019-02-12 10:54:50 +01004826
Radek Krejcifc11bd72019-04-11 16:00:05 +02004827 /* pass uses's when to all the data children, actions and notifications are ignored */
Radek Krejci00b874b2019-02-12 10:54:50 +01004828 if (uses_p->when) {
Radek Krejcic6b4f442020-08-12 14:45:18 +02004829 LY_ARRAY_NEW_GOTO(ctx->ctx, iter->when, when, ret, cleanup);
Radek Krejci00b874b2019-02-12 10:54:50 +01004830 if (!when_shared) {
Michal Vasko175012e2019-11-06 15:49:14 +01004831 LY_CHECK_GOTO(lys_compile_when(ctx, uses_p->when, uses_p->flags, parent, when), cleanup);
4832
4833 if (!(ctx->options & LYSC_OPT_GROUPING)) {
4834 /* do not check "when" semantics in a grouping */
Radek Krejcic6b4f442020-08-12 14:45:18 +02004835 ly_set_add(&ctx->xpath, iter, 0);
Michal Vasko175012e2019-11-06 15:49:14 +01004836 }
4837
Radek Krejci00b874b2019-02-12 10:54:50 +01004838 when_shared = *when;
4839 } else {
4840 ++when_shared->refcount;
4841 (*when) = when_shared;
Michal Vasko5c4e5892019-11-14 12:31:38 +01004842
4843 if (!(ctx->options & LYSC_OPT_GROUPING)) {
4844 /* in this case check "when" again for all children because of dummy node check */
Radek Krejcic6b4f442020-08-12 14:45:18 +02004845 ly_set_add(&ctx->xpath, iter, 0);
Michal Vasko5c4e5892019-11-14 12:31:38 +01004846 }
Radek Krejci00b874b2019-02-12 10:54:50 +01004847 }
4848 }
Radek Krejci01342af2019-01-03 15:18:08 +01004849 }
Radek Krejci76b3e962018-12-14 17:01:25 +01004850
Radek Krejcifc11bd72019-04-11 16:00:05 +02004851 /* compile actions */
4852 actions = parent ? lysc_node_actions_p(parent) : &ctx->mod->compiled->rpcs;
4853 if (actions) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004854 actions_index = *actions ? LY_ARRAY_COUNT(*actions) : 0;
Radek Krejciec4da802019-05-02 13:02:41 +02004855 COMPILE_ARRAY1_GOTO(ctx, grp->actions, *actions, parent, u, lys_compile_action, 0, ret, cleanup);
Radek Krejcifc11bd72019-04-11 16:00:05 +02004856 if (*actions && (uses_p->augments || uses_p->refines)) {
4857 /* but for augment and refine, we need to separate the compiled grouping's actions to avoid modification of others */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004858 LY_ARRAY_CREATE_GOTO(ctx->ctx, context_node_fake.actions, LY_ARRAY_COUNT(*actions) - actions_index, ret, cleanup);
4859 LY_ARRAY_COUNT(context_node_fake.actions) = LY_ARRAY_COUNT(*actions) - actions_index;
4860 memcpy(context_node_fake.actions, &(*actions)[actions_index], LY_ARRAY_COUNT(context_node_fake.actions) * sizeof **actions);
Radek Krejcifc11bd72019-04-11 16:00:05 +02004861 }
4862 }
4863
4864 /* compile notifications */
4865 notifs = parent ? lysc_node_notifs_p(parent) : &ctx->mod->compiled->notifs;
4866 if (notifs) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004867 notifs_index = *notifs ? LY_ARRAY_COUNT(*notifs) : 0;
Radek Krejciec4da802019-05-02 13:02:41 +02004868 COMPILE_ARRAY1_GOTO(ctx, grp->notifs, *notifs, parent, u, lys_compile_notif, 0, ret, cleanup);
Radek Krejcifc11bd72019-04-11 16:00:05 +02004869 if (*notifs && (uses_p->augments || uses_p->refines)) {
4870 /* but for augment and refine, we need to separate the compiled grouping's notification to avoid modification of others */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004871 LY_ARRAY_CREATE_GOTO(ctx->ctx, context_node_fake.notifs, LY_ARRAY_COUNT(*notifs) - notifs_index, ret, cleanup);
4872 LY_ARRAY_COUNT(context_node_fake.notifs) = LY_ARRAY_COUNT(*notifs) - notifs_index;
4873 memcpy(context_node_fake.notifs, &(*notifs)[notifs_index], LY_ARRAY_COUNT(context_node_fake.notifs) * sizeof **notifs);
Radek Krejcifc11bd72019-04-11 16:00:05 +02004874 }
4875 }
4876
4877
Radek Krejci3641f562019-02-13 15:38:40 +01004878 /* sort and apply augments */
Radek Krejcifc11bd72019-04-11 16:00:05 +02004879 LY_CHECK_GOTO(lys_compile_augment_sort(ctx, uses_p->augments, NULL, &augments), cleanup);
Radek Krejci3641f562019-02-13 15:38:40 +01004880 LY_ARRAY_FOR(augments, u) {
Radek Krejciec4da802019-05-02 13:02:41 +02004881 LY_CHECK_GOTO(lys_compile_augment(ctx, augments[u], (struct lysc_node*)&context_node_fake), cleanup);
Radek Krejci3641f562019-02-13 15:38:40 +01004882 }
Radek Krejci12fb9142019-01-08 09:45:30 +01004883
Radek Krejcif0089082019-01-07 16:42:01 +01004884 /* reload previous context's mod_def */
4885 ctx->mod_def = mod_old;
Radek Krejci327de162019-06-14 12:52:07 +02004886 lysc_update_path(ctx, NULL, "{refine}");
Radek Krejcif0089082019-01-07 16:42:01 +01004887
Radek Krejci76b3e962018-12-14 17:01:25 +01004888 /* apply refine */
4889 LY_ARRAY_FOR(uses_p->refines, struct lysp_refine, rfn) {
Radek Krejci327de162019-06-14 12:52:07 +02004890 lysc_update_path(ctx, NULL, rfn->nodeid);
4891
Radek Krejci7af64242019-02-18 13:07:53 +01004892 LY_CHECK_GOTO(lys_resolve_schema_nodeid(ctx, rfn->nodeid, 0, (struct lysc_node*)&context_node_fake, ctx->mod,
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004893 0, 0, (const struct lysc_node**)&node, &flags),
Radek Krejcifc11bd72019-04-11 16:00:05 +02004894 cleanup);
Radek Krejcif2271f12019-01-07 16:42:23 +01004895 ly_set_add(&refined, node, LY_SET_OPT_USEASLIST);
Radek Krejci76b3e962018-12-14 17:01:25 +01004896
4897 /* default value */
4898 if (rfn->dflts) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004899 if ((node->nodetype != LYS_LEAFLIST) && LY_ARRAY_COUNT(rfn->dflts) > 1) {
Radek Krejci76b3e962018-12-14 17:01:25 +01004900 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004901 "Invalid refine of default - %s cannot hold %"LY_PRI_ARRAY_COUNT_TYPE" default values.",
4902 lys_nodetype2str(node->nodetype), LY_ARRAY_COUNT(rfn->dflts));
Radek Krejcifc11bd72019-04-11 16:00:05 +02004903 goto cleanup;
Radek Krejci76b3e962018-12-14 17:01:25 +01004904 }
4905 if (!(node->nodetype & (LYS_LEAF | LYS_LEAFLIST | LYS_CHOICE))) {
4906 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004907 "Invalid refine of default - %s cannot hold default value(s).",
4908 lys_nodetype2str(node->nodetype));
Radek Krejcifc11bd72019-04-11 16:00:05 +02004909 goto cleanup;
Radek Krejci76b3e962018-12-14 17:01:25 +01004910 }
4911 if (node->nodetype == LYS_LEAF) {
Radek Krejcia1911222019-07-22 17:24:50 +02004912 struct ly_err_item *err = NULL;
4913 struct lysc_node_leaf *leaf = (struct lysc_node_leaf*)node;
4914 if (leaf->dflt) {
4915 /* remove the previous default value */
Radek Krejci474f9b82019-07-24 11:36:37 +02004916 lysc_incomplete_dflts_remove(ctx, leaf->dflt);
Radek Krejcia1911222019-07-22 17:24:50 +02004917 leaf->dflt->realtype->plugin->free(ctx->ctx, leaf->dflt);
4918 lysc_type_free(ctx->ctx, leaf->dflt->realtype);
4919 } else {
4920 /* prepare a new one */
4921 leaf->dflt = calloc(1, sizeof *leaf->dflt);
4922 leaf->dflt->realtype = leaf->type;
4923 }
4924 /* parse the new one */
Radek Krejcid0ef1af2019-07-23 12:22:05 +02004925 leaf->dflt_mod = ctx->mod_def;
Radek Krejcia1911222019-07-22 17:24:50 +02004926 rc = leaf->type->plugin->store(ctx->ctx, leaf->type, rfn->dflts[0], strlen(rfn->dflts[0]),
4927 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
Radek Krejci1c0c3442019-07-23 16:08:47 +02004928 lys_resolve_prefix, (void*)leaf->dflt_mod, LYD_XML, node, NULL, leaf->dflt, NULL, &err);
Radek Krejcia1911222019-07-22 17:24:50 +02004929 leaf->dflt->realtype->refcount++;
4930 if (err) {
4931 ly_err_print(err);
4932 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
4933 "Invalid refine of default - value \"%s\" does not fit the type (%s).", rfn->dflts[0], err->msg);
4934 ly_err_free(err);
4935 }
Radek Krejci1c0c3442019-07-23 16:08:47 +02004936 if (rc == LY_EINCOMPLETE) {
4937 /* postpone default compilation when the tree is complete */
Radek Krejci474f9b82019-07-24 11:36:37 +02004938 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, node, leaf->dflt, leaf->dflt_mod), cleanup);
Radek Krejci1c0c3442019-07-23 16:08:47 +02004939
4940 /* but in general result is so far ok */
4941 rc = LY_SUCCESS;
4942 }
Radek Krejcia1911222019-07-22 17:24:50 +02004943 LY_CHECK_GOTO(rc, cleanup);
4944 leaf->flags |= LYS_SET_DFLT;
Radek Krejci76b3e962018-12-14 17:01:25 +01004945 } else if (node->nodetype == LYS_LEAFLIST) {
Radek Krejcia1911222019-07-22 17:24:50 +02004946 struct lysc_node_leaflist *llist = (struct lysc_node_leaflist*)node;
4947
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004948 if (ctx->mod->version < 2) {
Radek Krejci01342af2019-01-03 15:18:08 +01004949 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
4950 "Invalid refine of default in leaf-list - the default statement is allowed only in YANG 1.1 modules.");
Radek Krejcifc11bd72019-04-11 16:00:05 +02004951 goto cleanup;
Radek Krejci01342af2019-01-03 15:18:08 +01004952 }
Radek Krejcia1911222019-07-22 17:24:50 +02004953
4954 /* remove previous set of default values */
4955 LY_ARRAY_FOR(llist->dflts, u) {
Radek Krejci474f9b82019-07-24 11:36:37 +02004956 lysc_incomplete_dflts_remove(ctx, llist->dflts[u]);
Radek Krejcia1911222019-07-22 17:24:50 +02004957 llist->dflts[u]->realtype->plugin->free(ctx->ctx, llist->dflts[u]);
4958 lysc_type_free(ctx->ctx, llist->dflts[u]->realtype);
4959 free(llist->dflts[u]);
Radek Krejci76b3e962018-12-14 17:01:25 +01004960 }
Radek Krejcia1911222019-07-22 17:24:50 +02004961 LY_ARRAY_FREE(llist->dflts);
4962 llist->dflts = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02004963 LY_ARRAY_FREE(llist->dflts_mods);
4964 llist->dflts_mods = NULL;
Radek Krejcia1911222019-07-22 17:24:50 +02004965
4966 /* create the new set of the default values */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02004967 LY_ARRAY_CREATE_GOTO(ctx->ctx, llist->dflts_mods, LY_ARRAY_COUNT(rfn->dflts), ret, cleanup);
4968 LY_ARRAY_CREATE_GOTO(ctx->ctx, llist->dflts, LY_ARRAY_COUNT(rfn->dflts), ret, cleanup);
Radek Krejci76b3e962018-12-14 17:01:25 +01004969 LY_ARRAY_FOR(rfn->dflts, u) {
Radek Krejcia1911222019-07-22 17:24:50 +02004970 struct ly_err_item *err = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02004971 LY_ARRAY_INCREMENT(llist->dflts_mods);
4972 llist->dflts_mods[u] = ctx->mod_def;
Radek Krejcia1911222019-07-22 17:24:50 +02004973 LY_ARRAY_INCREMENT(llist->dflts);
4974 llist->dflts[u] = calloc(1, sizeof *llist->dflts[u]);
4975 llist->dflts[u]->realtype = llist->type;
Radek Krejci1c0c3442019-07-23 16:08:47 +02004976 rc = llist->type->plugin->store(ctx->ctx, llist->type, rfn->dflts[u], strlen(rfn->dflts[u]),
Radek Krejcia1911222019-07-22 17:24:50 +02004977 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
Radek Krejci1c0c3442019-07-23 16:08:47 +02004978 lys_resolve_prefix, (void*)llist->dflts_mods[u], LYD_XML, node, NULL, llist->dflts[u], NULL, &err);
Radek Krejcia1911222019-07-22 17:24:50 +02004979 llist->dflts[u]->realtype->refcount++;
4980 if (err) {
4981 ly_err_print(err);
4982 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
4983 "Invalid refine of default in leaf-lists - value \"%s\" does not fit the type (%s).", rfn->dflts[u], err->msg);
4984 ly_err_free(err);
4985 }
Radek Krejci1c0c3442019-07-23 16:08:47 +02004986 if (rc == LY_EINCOMPLETE) {
4987 /* postpone default compilation when the tree is complete */
Radek Krejci474f9b82019-07-24 11:36:37 +02004988 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, node, llist->dflts[u], llist->dflts_mods[u]), cleanup);
Radek Krejci1c0c3442019-07-23 16:08:47 +02004989
4990 /* but in general result is so far ok */
4991 rc = LY_SUCCESS;
4992 }
4993 LY_CHECK_GOTO(rc, cleanup);
Radek Krejci76b3e962018-12-14 17:01:25 +01004994 }
Radek Krejcia1911222019-07-22 17:24:50 +02004995 llist->flags |= LYS_SET_DFLT;
Radek Krejci76b3e962018-12-14 17:01:25 +01004996 } else if (node->nodetype == LYS_CHOICE) {
Radek Krejci01342af2019-01-03 15:18:08 +01004997 if (((struct lysc_node_choice*)node)->dflt) {
4998 /* unset LYS_SET_DFLT from the current default case */
4999 ((struct lysc_node_choice*)node)->dflt->flags &= ~LYS_SET_DFLT;
5000 }
Radek Krejcifc11bd72019-04-11 16:00:05 +02005001 LY_CHECK_GOTO(lys_compile_node_choice_dflt(ctx, rfn->dflts[0], (struct lysc_node_choice*)node), cleanup);
Radek Krejci76b3e962018-12-14 17:01:25 +01005002 }
5003 }
5004
Radek Krejci12fb9142019-01-08 09:45:30 +01005005 /* description */
5006 if (rfn->dsc) {
5007 FREE_STRING(ctx->ctx, node->dsc);
5008 node->dsc = lydict_insert(ctx->ctx, rfn->dsc, 0);
5009 }
5010
5011 /* reference */
5012 if (rfn->ref) {
5013 FREE_STRING(ctx->ctx, node->ref);
5014 node->ref = lydict_insert(ctx->ctx, rfn->ref, 0);
5015 }
Radek Krejci76b3e962018-12-14 17:01:25 +01005016
5017 /* config */
5018 if (rfn->flags & LYS_CONFIG_MASK) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005019 if (!flags) {
Radek Krejci327de162019-06-14 12:52:07 +02005020 LY_CHECK_GOTO(lys_compile_change_config(ctx, node, rfn->flags, 0, 1), cleanup);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005021 } else {
5022 LOGWRN(ctx->ctx, "Refining config inside %s has no effect (%s).",
Michal Vaskoa3881362020-01-21 15:57:35 +01005023 flags & LYSC_OPT_NOTIFICATION ? "notification" : "RPC/action", ctx->path);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005024 }
Radek Krejci76b3e962018-12-14 17:01:25 +01005025 }
5026
5027 /* mandatory */
5028 if (rfn->flags & LYS_MAND_MASK) {
Radek Krejci327de162019-06-14 12:52:07 +02005029 LY_CHECK_GOTO(lys_compile_change_mandatory(ctx, node, rfn->flags, 1), cleanup);
Radek Krejci76b3e962018-12-14 17:01:25 +01005030 }
Radek Krejci9a54f1f2019-01-07 13:47:55 +01005031
5032 /* presence */
5033 if (rfn->presence) {
5034 if (node->nodetype != LYS_CONTAINER) {
5035 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02005036 "Invalid refine of presence statement - %s cannot hold the presence statement.",
5037 lys_nodetype2str(node->nodetype));
Radek Krejcifc11bd72019-04-11 16:00:05 +02005038 goto cleanup;
Radek Krejci9a54f1f2019-01-07 13:47:55 +01005039 }
5040 node->flags |= LYS_PRESENCE;
5041 }
Radek Krejci9a564c92019-01-07 14:53:57 +01005042
5043 /* must */
5044 if (rfn->musts) {
5045 switch (node->nodetype) {
5046 case LYS_LEAF:
Radek Krejcic71ac5b2019-09-10 15:34:22 +02005047 COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_leaf*)node)->musts, u, lys_compile_must, ret, cleanup);
Radek Krejci9a564c92019-01-07 14:53:57 +01005048 break;
5049 case LYS_LEAFLIST:
Radek Krejcic71ac5b2019-09-10 15:34:22 +02005050 COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_leaflist*)node)->musts, u, lys_compile_must, ret, cleanup);
Radek Krejci9a564c92019-01-07 14:53:57 +01005051 break;
5052 case LYS_LIST:
Radek Krejcic71ac5b2019-09-10 15:34:22 +02005053 COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_list*)node)->musts, u, lys_compile_must, ret, cleanup);
Radek Krejci9a564c92019-01-07 14:53:57 +01005054 break;
5055 case LYS_CONTAINER:
Radek Krejcic71ac5b2019-09-10 15:34:22 +02005056 COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_container*)node)->musts, u, lys_compile_must, ret, cleanup);
Radek Krejci9a564c92019-01-07 14:53:57 +01005057 break;
5058 case LYS_ANYXML:
5059 case LYS_ANYDATA:
Radek Krejcic71ac5b2019-09-10 15:34:22 +02005060 COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_anydata*)node)->musts, u, lys_compile_must, ret, cleanup);
Radek Krejci9a564c92019-01-07 14:53:57 +01005061 break;
5062 default:
5063 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02005064 "Invalid refine of must statement - %s cannot hold any must statement.",
5065 lys_nodetype2str(node->nodetype));
Radek Krejcifc11bd72019-04-11 16:00:05 +02005066 goto cleanup;
Radek Krejci9a564c92019-01-07 14:53:57 +01005067 }
Michal Vasko004d3152020-06-11 19:59:22 +02005068 ly_set_add(&ctx->xpath, node, 0);
Radek Krejci9a564c92019-01-07 14:53:57 +01005069 }
Radek Krejci6b22ab72019-01-07 15:39:20 +01005070
5071 /* min/max-elements */
5072 if (rfn->flags & (LYS_SET_MAX | LYS_SET_MIN)) {
5073 switch (node->nodetype) {
5074 case LYS_LEAFLIST:
5075 if (rfn->flags & LYS_SET_MAX) {
5076 ((struct lysc_node_leaflist*)node)->max = rfn->max ? rfn->max : (uint32_t)-1;
5077 }
5078 if (rfn->flags & LYS_SET_MIN) {
5079 ((struct lysc_node_leaflist*)node)->min = rfn->min;
Radek Krejcife909632019-02-12 15:34:42 +01005080 if (rfn->min) {
5081 node->flags |= LYS_MAND_TRUE;
5082 lys_compile_mandatory_parents(node->parent, 1);
5083 } else {
5084 node->flags &= ~LYS_MAND_TRUE;
5085 lys_compile_mandatory_parents(node->parent, 0);
5086 }
Radek Krejci6b22ab72019-01-07 15:39:20 +01005087 }
5088 break;
5089 case LYS_LIST:
5090 if (rfn->flags & LYS_SET_MAX) {
5091 ((struct lysc_node_list*)node)->max = rfn->max ? rfn->max : (uint32_t)-1;
5092 }
5093 if (rfn->flags & LYS_SET_MIN) {
5094 ((struct lysc_node_list*)node)->min = rfn->min;
Radek Krejcife909632019-02-12 15:34:42 +01005095 if (rfn->min) {
5096 node->flags |= LYS_MAND_TRUE;
5097 lys_compile_mandatory_parents(node->parent, 1);
5098 } else {
5099 node->flags &= ~LYS_MAND_TRUE;
5100 lys_compile_mandatory_parents(node->parent, 0);
5101 }
Radek Krejci6b22ab72019-01-07 15:39:20 +01005102 }
5103 break;
5104 default:
5105 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02005106 "Invalid refine of %s statement - %s cannot hold this statement.",
5107 (rfn->flags & LYS_SET_MAX) ? "max-elements" : "min-elements", lys_nodetype2str(node->nodetype));
Radek Krejcifc11bd72019-04-11 16:00:05 +02005108 goto cleanup;
Radek Krejci6b22ab72019-01-07 15:39:20 +01005109 }
5110 }
Radek Krejcif0089082019-01-07 16:42:01 +01005111
5112 /* if-feature */
5113 if (rfn->iffeatures) {
5114 /* any node in compiled tree can get additional if-feature, so do not check nodetype */
Radek Krejciec4da802019-05-02 13:02:41 +02005115 COMPILE_ARRAY_GOTO(ctx, rfn->iffeatures, node->iffeatures, u, lys_compile_iffeature, ret, cleanup);
Radek Krejcif0089082019-01-07 16:42:01 +01005116 }
Radek Krejci327de162019-06-14 12:52:07 +02005117
5118 lysc_update_path(ctx, NULL, NULL);
Radek Krejci01342af2019-01-03 15:18:08 +01005119 }
Radek Krejcie86bf772018-12-14 11:39:53 +01005120
Radek Krejcif2271f12019-01-07 16:42:23 +01005121 /* do some additional checks of the changed nodes when all the refines are applied */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02005122 for (uint32_t i = 0; i < refined.count; ++i) {
5123 node = (struct lysc_node*)refined.objs[i];
5124 rfn = &uses_p->refines[i];
Radek Krejci327de162019-06-14 12:52:07 +02005125 lysc_update_path(ctx, NULL, rfn->nodeid);
Radek Krejcif2271f12019-01-07 16:42:23 +01005126
5127 /* check possible conflict with default value (default added, mandatory left true) */
5128 if ((node->flags & LYS_MAND_TRUE) &&
5129 (((node->nodetype & LYS_CHOICE) && ((struct lysc_node_choice*)node)->dflt) ||
5130 ((node->nodetype & LYS_LEAF) && (node->flags & LYS_SET_DFLT)))) {
5131 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02005132 "Invalid refine of default - the node is mandatory.");
Radek Krejcifc11bd72019-04-11 16:00:05 +02005133 goto cleanup;
Radek Krejcif2271f12019-01-07 16:42:23 +01005134 }
5135
5136 if (rfn->flags & (LYS_SET_MAX | LYS_SET_MIN)) {
5137 if (node->nodetype == LYS_LIST) {
5138 min = ((struct lysc_node_list*)node)->min;
5139 max = ((struct lysc_node_list*)node)->max;
5140 } else {
5141 min = ((struct lysc_node_leaflist*)node)->min;
5142 max = ((struct lysc_node_leaflist*)node)->max;
5143 }
5144 if (min > max) {
5145 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02005146 "Invalid refine of %s statement - \"min-elements\" is bigger than \"max-elements\".",
5147 (rfn->flags & LYS_SET_MAX) ? "max-elements" : "min-elements");
Radek Krejcifc11bd72019-04-11 16:00:05 +02005148 goto cleanup;
Radek Krejcif2271f12019-01-07 16:42:23 +01005149 }
5150 }
5151 }
5152
Radek Krejcic6b4f442020-08-12 14:45:18 +02005153 if (first_p) {
5154 *first_p = context_node_fake.child;
5155 }
Radek Krejci327de162019-06-14 12:52:07 +02005156 lysc_update_path(ctx, NULL, NULL);
Radek Krejcie86bf772018-12-14 11:39:53 +01005157 ret = LY_SUCCESS;
Radek Krejcifc11bd72019-04-11 16:00:05 +02005158
5159cleanup:
5160 /* fix connection of the children nodes from fake context node back into the parent */
5161 if (context_node_fake.child) {
5162 context_node_fake.child->prev = child;
5163 }
5164 LY_LIST_FOR(context_node_fake.child, child) {
5165 child->parent = parent;
5166 }
5167
5168 if (uses_p->augments || uses_p->refines) {
5169 /* return back actions and notifications in case they were separated for augment/refine processing */
Radek Krejci65e20e22019-04-12 09:44:37 +02005170 if (context_node_fake.actions) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02005171 memcpy(&(*actions)[actions_index], context_node_fake.actions, LY_ARRAY_COUNT(context_node_fake.actions) * sizeof **actions);
Radek Krejcifc11bd72019-04-11 16:00:05 +02005172 LY_ARRAY_FREE(context_node_fake.actions);
5173 }
Radek Krejci65e20e22019-04-12 09:44:37 +02005174 if (context_node_fake.notifs) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02005175 memcpy(&(*notifs)[notifs_index], context_node_fake.notifs, LY_ARRAY_COUNT(context_node_fake.notifs) * sizeof **notifs);
Radek Krejcifc11bd72019-04-11 16:00:05 +02005176 LY_ARRAY_FREE(context_node_fake.notifs);
5177 }
5178 }
5179
Radek Krejcie86bf772018-12-14 11:39:53 +01005180 /* reload previous context's mod_def */
5181 ctx->mod_def = mod_old;
5182 /* remove the grouping from the stack for circular groupings dependency check */
5183 ly_set_rm_index(&ctx->groupings, ctx->groupings.count - 1, NULL);
5184 assert(ctx->groupings.count == grp_stack_count);
Radek Krejcif2271f12019-01-07 16:42:23 +01005185 ly_set_erase(&refined, NULL);
Radek Krejci3641f562019-02-13 15:38:40 +01005186 LY_ARRAY_FREE(augments);
Radek Krejcie86bf772018-12-14 11:39:53 +01005187
5188 return ret;
5189}
5190
Radek Krejci327de162019-06-14 12:52:07 +02005191static int
5192lys_compile_grouping_pathlog(struct lysc_ctx *ctx, struct lysp_node *node, char **path)
5193{
5194 struct lysp_node *iter;
5195 int len = 0;
5196
5197 *path = NULL;
5198 for (iter = node; iter && len >= 0; iter = iter->parent) {
5199 char *s = *path;
5200 char *id;
5201
5202 switch (iter->nodetype) {
5203 case LYS_USES:
Radek Krejci200f1062020-07-11 22:51:03 +02005204 LY_CHECK_RET(asprintf(&id, "{uses='%s'}", iter->name) == -1, -1);
Radek Krejci327de162019-06-14 12:52:07 +02005205 break;
5206 case LYS_GROUPING:
Radek Krejci200f1062020-07-11 22:51:03 +02005207 LY_CHECK_RET(asprintf(&id, "{grouping='%s'}", iter->name) == -1, -1);
Radek Krejci327de162019-06-14 12:52:07 +02005208 break;
5209 case LYS_AUGMENT:
Radek Krejci200f1062020-07-11 22:51:03 +02005210 LY_CHECK_RET(asprintf(&id, "{augment='%s'}", iter->name) == -1, -1);
Radek Krejci327de162019-06-14 12:52:07 +02005211 break;
5212 default:
5213 id = strdup(iter->name);
5214 break;
5215 }
5216
5217 if (!iter->parent) {
5218 /* print prefix */
5219 len = asprintf(path, "/%s:%s%s", ctx->mod->name, id, s ? s : "");
5220 } else {
5221 /* prefix is the same as in parent */
5222 len = asprintf(path, "/%s%s", id, s ? s : "");
5223 }
5224 free(s);
5225 free(id);
5226 }
5227
5228 if (len < 0) {
5229 free(*path);
5230 *path = NULL;
5231 } else if (len == 0) {
5232 *path = strdup("/");
5233 len = 1;
5234 }
5235 return len;
5236}
5237
Radek Krejcif2de0ed2019-05-02 14:13:18 +02005238/**
5239 * @brief Validate groupings that were defined but not directly used in the schema itself.
5240 *
5241 * The grouping does not need to be compiled (and it is compiled here, but the result is forgotten immediately),
5242 * but to have the complete result of the schema validity, even such groupings are supposed to be checked.
5243 */
5244static LY_ERR
5245lys_compile_grouping(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysp_grp *grp)
5246{
5247 LY_ERR ret;
Radek Krejci327de162019-06-14 12:52:07 +02005248 char *path;
5249 int len;
5250
Radek Krejcif2de0ed2019-05-02 14:13:18 +02005251 struct lysp_node_uses fake_uses = {
5252 .parent = node_p,
5253 .nodetype = LYS_USES,
5254 .flags = 0, .next = NULL,
5255 .name = grp->name,
5256 .dsc = NULL, .ref = NULL, .when = NULL, .iffeatures = NULL, .exts = NULL,
5257 .refines = NULL, .augments = NULL
5258 };
5259 struct lysc_node_container fake_container = {
5260 .nodetype = LYS_CONTAINER,
5261 .flags = node_p ? (node_p->flags & LYS_FLAGS_COMPILED_MASK) : 0,
5262 .module = ctx->mod,
5263 .sp = NULL, .parent = NULL, .next = NULL,
5264 .prev = (struct lysc_node*)&fake_container,
5265 .name = "fake",
5266 .dsc = NULL, .ref = NULL, .exts = NULL, .iffeatures = NULL, .when = NULL,
5267 .child = NULL, .musts = NULL, .actions = NULL, .notifs = NULL
5268 };
5269
5270 if (grp->parent) {
5271 LOGWRN(ctx->ctx, "Locally scoped grouping \"%s\" not used.", grp->name);
5272 }
Radek Krejci327de162019-06-14 12:52:07 +02005273
5274 len = lys_compile_grouping_pathlog(ctx, grp->parent, &path);
5275 if (len < 0) {
5276 LOGMEM(ctx->ctx);
5277 return LY_EMEM;
5278 }
5279 strncpy(ctx->path, path, LYSC_CTX_BUFSIZE - 1);
5280 ctx->path_len = (uint16_t)len;
5281 free(path);
5282
5283 lysc_update_path(ctx, NULL, "{grouping}");
5284 lysc_update_path(ctx, NULL, grp->name);
Radek Krejcic6b4f442020-08-12 14:45:18 +02005285 ret = lys_compile_uses(ctx, &fake_uses, (struct lysc_node*)&fake_container, NULL);
Radek Krejci327de162019-06-14 12:52:07 +02005286 lysc_update_path(ctx, NULL, NULL);
5287 lysc_update_path(ctx, NULL, NULL);
5288
5289 ctx->path_len = 1;
5290 ctx->path[1] = '\0';
Radek Krejcif2de0ed2019-05-02 14:13:18 +02005291
5292 /* cleanup */
5293 lysc_node_container_free(ctx->ctx, &fake_container);
5294
5295 return ret;
5296}
Radek Krejcife909632019-02-12 15:34:42 +01005297
Radek Krejcie86bf772018-12-14 11:39:53 +01005298/**
Radek Krejcia3045382018-11-22 14:30:31 +01005299 * @brief Compile parsed schema node information.
5300 * @param[in] ctx Compile context
5301 * @param[in] node_p Parsed schema node.
Radek Krejcia3045382018-11-22 14:30:31 +01005302 * @param[in] parent Compiled parent node where the current node is supposed to be connected. It is
5303 * NULL for top-level nodes, in such a case the module where the node will be connected is taken from
5304 * the compile context.
Radek Krejcib1b59152019-01-07 13:21:56 +01005305 * @param[in] uses_status If the node is being placed instead of uses, here we have the uses's status value (as node's flags).
5306 * Zero means no uses, non-zero value with no status bit set mean the default status.
Radek Krejcia3045382018-11-22 14:30:31 +01005307 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
5308 */
Radek Krejci19a96102018-11-15 13:38:09 +01005309static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02005310lys_compile_node(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *parent, uint16_t uses_status)
Radek Krejci19a96102018-11-15 13:38:09 +01005311{
Radek Krejci1c54f462020-05-12 17:25:34 +02005312 LY_ERR ret = LY_SUCCESS;
Radek Krejcic6b4f442020-08-12 14:45:18 +02005313 struct lysc_node *node = NULL;
5314 struct lysc_node_case *cs = NULL;
Radek Krejci00b874b2019-02-12 10:54:50 +01005315 struct lysc_when **when;
Radek Krejci19a96102018-11-15 13:38:09 +01005316 unsigned int u;
Radek Krejciec4da802019-05-02 13:02:41 +02005317 LY_ERR (*node_compile_spec)(struct lysc_ctx*, struct lysp_node*, struct lysc_node*);
Radek Krejci19a96102018-11-15 13:38:09 +01005318
Radek Krejci327de162019-06-14 12:52:07 +02005319 if (node_p->nodetype != LYS_USES) {
5320 lysc_update_path(ctx, parent, node_p->name);
5321 } else {
5322 lysc_update_path(ctx, NULL, "{uses}");
5323 lysc_update_path(ctx, NULL, node_p->name);
5324 }
5325
Radek Krejci19a96102018-11-15 13:38:09 +01005326 switch (node_p->nodetype) {
5327 case LYS_CONTAINER:
5328 node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_container));
5329 node_compile_spec = lys_compile_node_container;
5330 break;
5331 case LYS_LEAF:
5332 node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_leaf));
5333 node_compile_spec = lys_compile_node_leaf;
5334 break;
5335 case LYS_LIST:
5336 node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_list));
Radek Krejci9bb94eb2018-12-04 16:48:35 +01005337 node_compile_spec = lys_compile_node_list;
Radek Krejci19a96102018-11-15 13:38:09 +01005338 break;
5339 case LYS_LEAFLIST:
5340 node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_leaflist));
Radek Krejci0e5d8382018-11-28 16:37:53 +01005341 node_compile_spec = lys_compile_node_leaflist;
Radek Krejci19a96102018-11-15 13:38:09 +01005342 break;
Radek Krejci19a96102018-11-15 13:38:09 +01005343 case LYS_CHOICE:
5344 node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_choice));
Radek Krejci056d0a82018-12-06 16:57:25 +01005345 node_compile_spec = lys_compile_node_choice;
Radek Krejci19a96102018-11-15 13:38:09 +01005346 break;
Radek Krejci19a96102018-11-15 13:38:09 +01005347 case LYS_ANYXML:
5348 case LYS_ANYDATA:
5349 node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_anydata));
Radek Krejci9800fb82018-12-13 14:26:23 +01005350 node_compile_spec = lys_compile_node_any;
Radek Krejci19a96102018-11-15 13:38:09 +01005351 break;
Radek Krejcie86bf772018-12-14 11:39:53 +01005352 case LYS_USES:
Radek Krejcic6b4f442020-08-12 14:45:18 +02005353 if (parent && parent->nodetype == LYS_CHOICE) {
5354 assert(node_p->parent->nodetype == LYS_CASE);
5355 lysc_update_path(ctx, parent, node_p->parent->name);
5356 cs = lys_compile_node_case(ctx, node_p->parent, (struct lysc_node_choice*)parent, NULL);
5357 LY_CHECK_ERR_GOTO(!cs, ret = LY_EVALID, error);
5358 }
5359
5360 ret = lys_compile_uses(ctx, (struct lysp_node_uses*)node_p, cs ? (struct lysc_node*)cs : parent, &node);
5361 if (cs) {
5362 cs->child = node;
5363 lysc_update_path(ctx, NULL, NULL);
5364 }
Radek Krejci327de162019-06-14 12:52:07 +02005365 lysc_update_path(ctx, NULL, NULL);
5366 lysc_update_path(ctx, NULL, NULL);
5367 return ret;
Radek Krejci19a96102018-11-15 13:38:09 +01005368 default:
5369 LOGINT(ctx->ctx);
5370 return LY_EINT;
5371 }
5372 LY_CHECK_ERR_RET(!node, LOGMEM(ctx->ctx), LY_EMEM);
5373 node->nodetype = node_p->nodetype;
5374 node->module = ctx->mod;
5375 node->prev = node;
Radek Krejci0e5d8382018-11-28 16:37:53 +01005376 node->flags = node_p->flags & LYS_FLAGS_COMPILED_MASK;
Radek Krejci19a96102018-11-15 13:38:09 +01005377
5378 /* config */
Radek Krejciec4da802019-05-02 13:02:41 +02005379 if (ctx->options & (LYSC_OPT_RPC_INPUT | LYSC_OPT_RPC_OUTPUT)) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005380 /* ignore config statements inside RPC/action data */
Radek Krejcifc11bd72019-04-11 16:00:05 +02005381 node->flags &= ~LYS_CONFIG_MASK;
Radek Krejciec4da802019-05-02 13:02:41 +02005382 node->flags |= (ctx->options & LYSC_OPT_RPC_INPUT) ? LYS_CONFIG_W : LYS_CONFIG_R;
5383 } else if (ctx->options & LYSC_OPT_NOTIFICATION) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005384 /* ignore config statements inside Notification data */
Radek Krejcifc11bd72019-04-11 16:00:05 +02005385 node->flags &= ~LYS_CONFIG_MASK;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005386 node->flags |= LYS_CONFIG_R;
5387 } else if (!(node->flags & LYS_CONFIG_MASK)) {
Radek Krejci19a96102018-11-15 13:38:09 +01005388 /* config not explicitely set, inherit it from parent */
5389 if (parent) {
5390 node->flags |= parent->flags & LYS_CONFIG_MASK;
5391 } else {
5392 /* default is config true */
5393 node->flags |= LYS_CONFIG_W;
5394 }
Radek Krejci93dcc392019-02-19 10:43:38 +01005395 } else {
5396 /* config set explicitely */
5397 node->flags |= LYS_SET_CONFIG;
Radek Krejci19a96102018-11-15 13:38:09 +01005398 }
Radek Krejci9bb94eb2018-12-04 16:48:35 +01005399 if (parent && (parent->flags & LYS_CONFIG_R) && (node->flags & LYS_CONFIG_W)) {
5400 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
5401 "Configuration node cannot be child of any state data node.");
Radek Krejci1c54f462020-05-12 17:25:34 +02005402 ret = LY_EVALID;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01005403 goto error;
5404 }
Radek Krejci19a96102018-11-15 13:38:09 +01005405
Radek Krejcia6d57732018-11-29 13:40:37 +01005406 /* *list ordering */
5407 if (node->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
5408 if ((node->flags & LYS_CONFIG_R) && (node->flags & LYS_ORDBY_MASK)) {
Radek Krejcifc11bd72019-04-11 16:00:05 +02005409 LOGWRN(ctx->ctx, "The ordered-by statement is ignored in lists representing %s (%s).",
Radek Krejciec4da802019-05-02 13:02:41 +02005410 (ctx->options & LYSC_OPT_RPC_OUTPUT) ? "RPC/action output parameters" :
5411 (ctx->options & LYSC_OPT_NOTIFICATION) ? "notification content" : "state data", ctx->path);
Radek Krejcia6d57732018-11-29 13:40:37 +01005412 node->flags &= ~LYS_ORDBY_MASK;
5413 node->flags |= LYS_ORDBY_SYSTEM;
5414 } else if (!(node->flags & LYS_ORDBY_MASK)) {
5415 /* default ordering is system */
5416 node->flags |= LYS_ORDBY_SYSTEM;
5417 }
5418 }
5419
Radek Krejci19a96102018-11-15 13:38:09 +01005420 /* status - it is not inherited by specification, but it does not make sense to have
5421 * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
Radek Krejci056d0a82018-12-06 16:57:25 +01005422 if (!parent || parent->nodetype != LYS_CHOICE) {
5423 /* in case of choice/case's children, postpone the check to the moment we know if
5424 * the parent is choice (parent here) or some case (so we have to get its flags to check) */
Radek Krejci1c54f462020-05-12 17:25:34 +02005425 LY_CHECK_GOTO(ret = lys_compile_status(ctx, &node->flags, uses_status ? uses_status : (parent ? parent->flags : 0)), error);
Radek Krejci19a96102018-11-15 13:38:09 +01005426 }
5427
Radek Krejciec4da802019-05-02 13:02:41 +02005428 if (!(ctx->options & LYSC_OPT_FREE_SP)) {
Radek Krejci19a96102018-11-15 13:38:09 +01005429 node->sp = node_p;
5430 }
5431 DUP_STRING(ctx->ctx, node_p->name, node->name);
Radek Krejci12fb9142019-01-08 09:45:30 +01005432 DUP_STRING(ctx->ctx, node_p->dsc, node->dsc);
5433 DUP_STRING(ctx->ctx, node_p->ref, node->ref);
Radek Krejci00b874b2019-02-12 10:54:50 +01005434 if (node_p->when) {
5435 LY_ARRAY_NEW_GOTO(ctx->ctx, node->when, when, ret, error);
Radek Krejci1c54f462020-05-12 17:25:34 +02005436 LY_CHECK_GOTO(ret = lys_compile_when(ctx, node_p->when, node_p->flags, node, when), error);
Michal Vasko175012e2019-11-06 15:49:14 +01005437
5438 if (!(ctx->options & LYSC_OPT_GROUPING)) {
5439 /* do not check "when" semantics in a grouping */
Michal Vasko004d3152020-06-11 19:59:22 +02005440 ly_set_add(&ctx->xpath, node, 0);
Michal Vasko175012e2019-11-06 15:49:14 +01005441 }
Radek Krejci00b874b2019-02-12 10:54:50 +01005442 }
Radek Krejciec4da802019-05-02 13:02:41 +02005443 COMPILE_ARRAY_GOTO(ctx, node_p->iffeatures, node->iffeatures, u, lys_compile_iffeature, ret, error);
Radek Krejci19a96102018-11-15 13:38:09 +01005444
5445 /* nodetype-specific part */
Radek Krejci1c54f462020-05-12 17:25:34 +02005446 LY_CHECK_GOTO(ret = node_compile_spec(ctx, node_p, node), error);
Radek Krejci19a96102018-11-15 13:38:09 +01005447
Radek Krejci0935f412019-08-20 16:15:18 +02005448 COMPILE_EXTS_GOTO(ctx, node_p->exts, node->exts, node, LYEXT_PAR_NODE, ret, error);
5449
Radek Krejcife909632019-02-12 15:34:42 +01005450 /* inherit LYS_MAND_TRUE in parent containers */
5451 if (node->flags & LYS_MAND_TRUE) {
5452 lys_compile_mandatory_parents(parent, 1);
5453 }
5454
Radek Krejci327de162019-06-14 12:52:07 +02005455 lysc_update_path(ctx, NULL, NULL);
5456
Radek Krejci19a96102018-11-15 13:38:09 +01005457 /* insert into parent's children */
Radek Krejcia3045382018-11-22 14:30:31 +01005458 if (parent) {
5459 if (parent->nodetype == LYS_CHOICE) {
Radek Krejci327de162019-06-14 12:52:07 +02005460 if (node_p->parent->nodetype == LYS_CASE) {
5461 lysc_update_path(ctx, parent, node_p->parent->name);
5462 } else {
5463 lysc_update_path(ctx, parent, node->name);
5464 }
Radek Krejciec4da802019-05-02 13:02:41 +02005465 cs = lys_compile_node_case(ctx, node_p->parent, (struct lysc_node_choice*)parent, node);
Radek Krejci056d0a82018-12-06 16:57:25 +01005466 LY_CHECK_ERR_GOTO(!cs, ret = LY_EVALID, error);
Radek Krejcib1b59152019-01-07 13:21:56 +01005467 if (uses_status) {
5468
5469 }
Radek Krejci056d0a82018-12-06 16:57:25 +01005470 /* the postponed status check of the node and its real parent - in case of implicit case,
Radek Krejcib1b59152019-01-07 13:21:56 +01005471 * it directly gets the same status flags as the choice;
5472 * uses_status cannot be applied here since uses cannot be child statement of choice */
Radek Krejci1c54f462020-05-12 17:25:34 +02005473 LY_CHECK_GOTO(ret = lys_compile_status(ctx, &node->flags, cs->flags), error);
Radek Krejci056d0a82018-12-06 16:57:25 +01005474 node->parent = (struct lysc_node*)cs;
Radek Krejci327de162019-06-14 12:52:07 +02005475 lysc_update_path(ctx, parent, node->name);
Radek Krejci056d0a82018-12-06 16:57:25 +01005476 } else { /* other than choice */
Radek Krejci327de162019-06-14 12:52:07 +02005477 lysc_update_path(ctx, parent, node->name);
Radek Krejci056d0a82018-12-06 16:57:25 +01005478 node->parent = parent;
Radek Krejci19a96102018-11-15 13:38:09 +01005479 }
Radek Krejciec4da802019-05-02 13:02:41 +02005480 LY_CHECK_RET(lys_compile_node_connect(ctx, parent->nodetype == LYS_CASE ? parent->parent : parent, node), LY_EVALID);
Radek Krejci327de162019-06-14 12:52:07 +02005481
5482 if (parent->nodetype == LYS_CHOICE) {
5483 lysc_update_path(ctx, NULL, NULL);
5484 }
Radek Krejci19a96102018-11-15 13:38:09 +01005485 } else {
5486 /* top-level element */
5487 if (!ctx->mod->compiled->data) {
5488 ctx->mod->compiled->data = node;
5489 } else {
5490 /* insert at the end of the module's top-level nodes list */
5491 ctx->mod->compiled->data->prev->next = node;
5492 node->prev = ctx->mod->compiled->data->prev;
5493 ctx->mod->compiled->data->prev = node;
5494 }
Radek Krejci327de162019-06-14 12:52:07 +02005495 lysc_update_path(ctx, parent, node->name);
Radek Krejci76b3e962018-12-14 17:01:25 +01005496 if (lys_compile_node_uniqness(ctx, ctx->mod->compiled->data, ctx->mod->compiled->rpcs,
5497 ctx->mod->compiled->notifs, node->name, node)) {
5498 return LY_EVALID;
5499 }
Radek Krejci19a96102018-11-15 13:38:09 +01005500 }
Radek Krejci327de162019-06-14 12:52:07 +02005501 lysc_update_path(ctx, NULL, NULL);
Radek Krejci19a96102018-11-15 13:38:09 +01005502
5503 return LY_SUCCESS;
5504
5505error:
5506 lysc_node_free(ctx->ctx, node);
5507 return ret;
5508}
5509
Radek Krejciccd20f12019-02-15 14:12:27 +01005510static void
5511lysc_disconnect(struct lysc_node *node)
5512{
Radek Krejci0a048dd2019-02-18 16:01:43 +01005513 struct lysc_node *parent, *child, *prev = NULL, *next;
5514 struct lysc_node_case *cs = NULL;
Radek Krejciccd20f12019-02-15 14:12:27 +01005515 int remove_cs = 0;
5516
5517 parent = node->parent;
5518
5519 /* parent's first child */
5520 if (!parent) {
5521 return;
5522 }
5523 if (parent->nodetype == LYS_CHOICE) {
Radek Krejci0a048dd2019-02-18 16:01:43 +01005524 cs = (struct lysc_node_case*)node;
5525 } else if (parent->nodetype == LYS_CASE) {
5526 /* disconnecting some node in a case */
5527 cs = (struct lysc_node_case*)parent;
5528 parent = cs->parent;
5529 for (child = cs->child; child && child->parent == (struct lysc_node*)cs; child = child->next) {
5530 if (child == node) {
5531 if (cs->child == child) {
5532 if (!child->next || child->next->parent != (struct lysc_node*)cs) {
5533 /* case with a single child -> remove also the case */
5534 child->parent = NULL;
5535 remove_cs = 1;
5536 } else {
5537 cs->child = child->next;
Radek Krejciccd20f12019-02-15 14:12:27 +01005538 }
5539 }
Radek Krejci0a048dd2019-02-18 16:01:43 +01005540 break;
Radek Krejciccd20f12019-02-15 14:12:27 +01005541 }
5542 }
Radek Krejci0a048dd2019-02-18 16:01:43 +01005543 if (!remove_cs) {
5544 cs = NULL;
5545 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005546 } else if (lysc_node_children(parent, node->flags) == node) {
5547 *lysc_node_children_p(parent, node->flags) = node->next;
Radek Krejci0a048dd2019-02-18 16:01:43 +01005548 }
5549
5550 if (cs) {
5551 if (remove_cs) {
5552 /* cs has only one child which is being also removed */
5553 lysc_disconnect((struct lysc_node*)cs);
5554 lysc_node_free(cs->module->ctx, (struct lysc_node*)cs);
5555 } else {
Radek Krejciccd20f12019-02-15 14:12:27 +01005556 if (((struct lysc_node_choice*)parent)->dflt == cs) {
5557 /* default case removed */
5558 ((struct lysc_node_choice*)parent)->dflt = NULL;
5559 }
5560 if (((struct lysc_node_choice*)parent)->cases == cs) {
5561 /* first case removed */
5562 ((struct lysc_node_choice*)parent)->cases = (struct lysc_node_case*)cs->next;
5563 }
Radek Krejci0a048dd2019-02-18 16:01:43 +01005564 if (cs->child) {
5565 /* cs will be removed and disconnected from its siblings, but we have to take care also about its children */
5566 if (cs->child->prev->parent != (struct lysc_node*)cs) {
5567 prev = cs->child->prev;
5568 } /* else all the children are under a single case */
5569 LY_LIST_FOR_SAFE(cs->child, next, child) {
5570 if (child->parent != (struct lysc_node*)cs) {
5571 break;
5572 }
5573 lysc_node_free(node->module->ctx, child);
5574 }
5575 if (prev) {
5576 if (prev->next) {
5577 prev->next = child;
5578 }
5579 if (child) {
5580 child->prev = prev;
5581 } else {
5582 /* link from the first child under the cases */
5583 ((struct lysc_node_choice*)cs->parent)->cases->child->prev = prev;
5584 }
5585 }
Radek Krejciccd20f12019-02-15 14:12:27 +01005586 }
5587 }
Radek Krejciccd20f12019-02-15 14:12:27 +01005588 }
5589
5590 /* siblings */
Radek Krejci0a048dd2019-02-18 16:01:43 +01005591 if (node->prev->next) {
5592 node->prev->next = node->next;
5593 }
Radek Krejciccd20f12019-02-15 14:12:27 +01005594 if (node->next) {
5595 node->next->prev = node->prev;
Radek Krejci0a048dd2019-02-18 16:01:43 +01005596 } else if (node->nodetype != LYS_CASE) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005597 child = (struct lysc_node*)lysc_node_children(parent, node->flags);
Radek Krejci0a048dd2019-02-18 16:01:43 +01005598 if (child) {
5599 child->prev = node->prev;
5600 }
5601 } else if (((struct lysc_node_choice*)parent)->cases) {
5602 ((struct lysc_node_choice*)parent)->cases->prev = node->prev;
Radek Krejciccd20f12019-02-15 14:12:27 +01005603 }
5604}
5605
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02005606struct lysc_deviation {
5607 const char *nodeid;
5608 struct lysc_node *target; /* target node of the deviation */
5609 struct lysp_deviate** deviates;/* sized array of pointers to parsed deviate statements to apply on target */
5610 uint16_t flags; /* target's flags from lys_resolve_schema_nodeid() */
5611 uint8_t not_supported; /* flag if deviates contains not-supported deviate */
5612};
5613
Michal Vaskoccc062a2020-08-13 08:34:50 +02005614/* MACROS for deviates checking */
5615#define DEV_CHECK_NODETYPE(NODETYPES, DEVTYPE, PROPERTY) \
5616 if (!(target->nodetype & (NODETYPES))) { \
5617 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE, lys_nodetype2str(target->nodetype), DEVTYPE, PROPERTY);\
5618 goto cleanup; \
5619 }
5620
5621#define DEV_CHECK_CARDINALITY(ARRAY, MAX, PROPERTY) \
5622 if (LY_ARRAY_COUNT(ARRAY) > MAX) { \
5623 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Invalid deviation of %s with too many (%"LY_PRI_ARRAY_COUNT_TYPE") %s properties.", \
5624 lys_nodetype2str(target->nodetype), LY_ARRAY_COUNT(ARRAY), PROPERTY); \
5625 goto cleanup; \
5626 }
5627
5628#define DEV_CHECK_PRESENCE(TYPE, COND, MEMBER, DEVTYPE, PROPERTY, VALUE) \
5629 if (!((TYPE)target)->MEMBER || COND) { \
5630 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NOT_PRESENT, DEVTYPE, PROPERTY, VALUE); \
5631 goto cleanup; \
5632 }
5633
5634/**
5635 * @brief Apply deviate add.
5636 *
5637 * @param[in] ctx Compile context.
5638 * @param[in] target Deviation target.
5639 * @param[in] dev_flags Internal deviation flags.
5640 * @param[in] d Deviate add to apply.
5641 * @param[out] dflt Added default value.
5642 * @return LY_ERR value.
5643 */
5644static LY_ERR
5645lys_apply_deviate_add(struct lysc_ctx *ctx, struct lysc_node *target, int dev_flags, struct lysp_deviate_add *d,
5646 const char **dflt)
5647{
5648 LY_ERR ret = LY_EVALID, rc;
5649 struct lysc_node_leaf *leaf = (struct lysc_node_leaf *)target;
5650 struct lysc_node_leaflist *llist = (struct lysc_node_leaflist *)target;
5651 struct ly_err_item *err = NULL;
5652 LY_ARRAY_COUNT_TYPE x, y;
5653
5654#define DEV_CHECK_NONPRESENCE_UINT(TYPE, COND, MEMBER, PROPERTY) \
5655 if (((TYPE)target)->MEMBER COND) { \
5656 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
5657 "Invalid deviation adding \"%s\" property which already exists (with value \"%u\").", \
5658 PROPERTY, ((TYPE)target)->MEMBER); \
5659 goto cleanup; \
5660 }
5661
5662#define DEV_CHECK_NONPRESENCE_VALUE(TYPE, COND, MEMBER, PROPERTY, VALUEMEMBER, VALUEMODMEMBER) \
5663 if (((TYPE)target)->MEMBER && (COND)) { \
5664 int dynamic_ = 0; const char *val_; \
5665 val_ = ((TYPE)target)->VALUEMEMBER->realtype->plugin->print(((TYPE)target)->VALUEMEMBER, LYD_XML, \
5666 lys_get_prefix, ((TYPE)target)->VALUEMODMEMBER, &dynamic_); \
5667 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
5668 "Invalid deviation adding \"%s\" property which already exists (with value \"%s\").", PROPERTY, val_); \
5669 if (dynamic_) {free((void*)val_);} \
5670 goto cleanup; \
5671 }
5672
5673#define DEV_CHECK_NONPRESENCE(TYPE, COND, MEMBER, PROPERTY, VALUEMEMBER) \
5674 if (((TYPE)target)->MEMBER && (COND)) { \
5675 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
5676 "Invalid deviation adding \"%s\" property which already exists (with value \"%s\").", \
5677 PROPERTY, ((TYPE)target)->VALUEMEMBER); \
5678 goto cleanup; \
5679 }
5680
5681 /* [units-stmt] */
5682 if (d->units) {
5683 DEV_CHECK_NODETYPE(LYS_LEAF | LYS_LEAFLIST, "add", "units");
5684 DEV_CHECK_NONPRESENCE(struct lysc_node_leaf *, (target->flags & LYS_SET_UNITS), units, "units", units);
5685
5686 FREE_STRING(ctx->ctx, ((struct lysc_node_leaf *)target)->units);
5687 DUP_STRING(ctx->ctx, d->units, ((struct lysc_node_leaf *)target)->units);
5688 }
5689
5690 /* *must-stmt */
5691 if (d->musts) {
5692 switch (target->nodetype) {
5693 case LYS_CONTAINER:
5694 case LYS_LIST:
5695 COMPILE_ARRAY_GOTO(ctx, d->musts, ((struct lysc_node_container *)target)->musts,
5696 x, lys_compile_must, ret, cleanup);
5697 break;
5698 case LYS_LEAF:
5699 case LYS_LEAFLIST:
5700 case LYS_ANYDATA:
5701 COMPILE_ARRAY_GOTO(ctx, d->musts, ((struct lysc_node_leaf *)target)->musts,
5702 x, lys_compile_must, ret, cleanup);
5703 break;
5704 case LYS_NOTIF:
5705 COMPILE_ARRAY_GOTO(ctx, d->musts, ((struct lysc_notif *)target)->musts,
5706 x, lys_compile_must, ret, cleanup);
5707 break;
5708 case LYS_RPC:
5709 case LYS_ACTION:
5710 if (dev_flags & LYSC_OPT_RPC_INPUT) {
5711 COMPILE_ARRAY_GOTO(ctx, d->musts, ((struct lysc_action *)target)->input.musts,
5712 x, lys_compile_must, ret, cleanup);
5713 break;
5714 } else if (dev_flags & LYSC_OPT_RPC_OUTPUT) {
5715 COMPILE_ARRAY_GOTO(ctx, d->musts, ((struct lysc_action *)target)->output.musts,
5716 x, lys_compile_must, ret, cleanup);
5717 break;
5718 }
5719 /* fall through */
5720 default:
5721 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
5722 lys_nodetype2str(target->nodetype), "add", "must");
5723 goto cleanup;
5724 }
5725 ly_set_add(&ctx->xpath, target, 0);
5726 }
5727
5728 /* *unique-stmt */
5729 if (d->uniques) {
5730 DEV_CHECK_NODETYPE(LYS_LIST, "add", "unique");
5731 LY_CHECK_GOTO(lys_compile_node_list_unique(ctx, ctx->mod, d->uniques, (struct lysc_node_list *)target), cleanup);
5732 }
5733
5734 /* *default-stmt */
5735 if (d->dflts) {
5736 switch (target->nodetype) {
5737 case LYS_LEAF:
5738 DEV_CHECK_CARDINALITY(d->dflts, 1, "default");
5739 DEV_CHECK_NONPRESENCE_VALUE(struct lysc_node_leaf *, (target->flags & LYS_SET_DFLT), dflt, "default", dflt, dflt_mod);
5740 if (leaf->dflt) {
5741 /* first, remove the default value taken from the type */
5742 lysc_incomplete_dflts_remove(ctx, leaf->dflt);
5743 leaf->dflt->realtype->plugin->free(ctx->ctx, leaf->dflt);
5744 lysc_type_free(ctx->ctx, leaf->dflt->realtype);
5745 } else {
5746 /* prepare new default value storage */
5747 leaf->dflt = calloc(1, sizeof *leaf->dflt);
5748 }
5749 *dflt = d->dflts[0];
5750 /* parsing is done at the end after possible replace of the leaf's type */
5751
5752 /* mark the new default values as leaf's own */
5753 target->flags |= LYS_SET_DFLT;
5754 break;
5755 case LYS_LEAFLIST:
5756 if (llist->dflts && !(target->flags & LYS_SET_DFLT)) {
5757 /* first, remove the default value taken from the type */
5758 LY_ARRAY_FOR(llist->dflts, x) {
5759 lysc_incomplete_dflts_remove(ctx, llist->dflts[x]);
5760 llist->dflts[x]->realtype->plugin->free(ctx->ctx, llist->dflts[x]);
5761 lysc_type_free(ctx->ctx, llist->dflts[x]->realtype);
5762 free(llist->dflts[x]);
5763 }
5764 LY_ARRAY_FREE(llist->dflts);
5765 llist->dflts = NULL;
5766 LY_ARRAY_FREE(llist->dflts_mods);
5767 llist->dflts_mods = NULL;
5768 }
5769 /* add new default value(s) */
5770 LY_ARRAY_CREATE_GOTO(ctx->ctx, llist->dflts_mods, LY_ARRAY_COUNT(d->dflts), ret, cleanup);
5771 LY_ARRAY_CREATE_GOTO(ctx->ctx, llist->dflts, LY_ARRAY_COUNT(d->dflts), ret, cleanup);
5772 for (x = y = LY_ARRAY_COUNT(llist->dflts);
5773 x < LY_ARRAY_COUNT(d->dflts) + y; ++x) {
5774 LY_ARRAY_INCREMENT(llist->dflts_mods);
5775 llist->dflts_mods[x] = ctx->mod_def;
5776 LY_ARRAY_INCREMENT(llist->dflts);
5777 llist->dflts[x] = calloc(1, sizeof *llist->dflts[x]);
5778 llist->dflts[x]->realtype = llist->type;
5779 rc = llist->type->plugin->store(ctx->ctx, llist->type, d->dflts[x - y], strlen(d->dflts[x - y]),
5780 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE, lys_resolve_prefix,
5781 (void*)llist->dflts_mods[x], LYD_XML, target, NULL, llist->dflts[x], NULL, &err);
5782 llist->dflts[x]->realtype->refcount++;
5783 if (err) {
5784 ly_err_print(err);
5785 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
5786 "Invalid deviation adding \"default\" property \"%s\" which does not fit the type (%s).",
5787 d->dflts[x - y], err->msg);
5788 ly_err_free(err);
5789 }
5790 if (rc == LY_EINCOMPLETE) {
5791 /* postpone default compilation when the tree is complete */
5792 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, target, llist->dflts[x], llist->dflts_mods[x]), cleanup);
5793
5794 /* but in general result is so far ok */
5795 rc = LY_SUCCESS;
5796 }
5797 LY_CHECK_GOTO(rc, cleanup);
5798 }
5799 /* mark the new default values as leaf-list's own */
5800 target->flags |= LYS_SET_DFLT;
5801 break;
5802 case LYS_CHOICE:
5803 DEV_CHECK_CARDINALITY(d->dflts, 1, "default");
5804 DEV_CHECK_NONPRESENCE(struct lysc_node_choice *, 1, dflt, "default", dflt->name);
5805 /* in contrast to delete, here we strictly resolve the prefix in the module of the deviation
5806 * to allow making the default case even the augmented case from the deviating module */
5807 if (lys_compile_deviation_set_choice_dflt(ctx, d->dflts[0], (struct lysc_node_choice *)target)) {
5808 goto cleanup;
5809 }
5810 break;
5811 default:
5812 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
5813 lys_nodetype2str(target->nodetype), "add", "default");
5814 goto cleanup;
5815 }
5816 }
5817
5818 /* [config-stmt] */
5819 if (d->flags & LYS_CONFIG_MASK) {
5820 if (target->nodetype & (LYS_CASE | LYS_INOUT | LYS_RPC | LYS_ACTION | LYS_NOTIF)) {
5821 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
5822 lys_nodetype2str(target->nodetype), "add", "config");
5823 goto cleanup;
5824 }
5825 if (dev_flags) {
5826 LOGWRN(ctx->ctx, "Deviating config inside %s has no effect.",
5827 dev_flags & LYSC_OPT_NOTIFICATION ? "notification" : "RPC/action");
5828 }
5829 if (target->flags & LYS_SET_CONFIG) {
5830 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
5831 "Invalid deviation adding \"config\" property which already exists (with value \"config %s\").",
5832 target->flags & LYS_CONFIG_W ? "true" : "false");
5833 goto cleanup;
5834 }
5835 LY_CHECK_GOTO(lys_compile_change_config(ctx, target, d->flags, 0, 0), cleanup);
5836 }
5837
5838 /* [mandatory-stmt] */
5839 if (d->flags & LYS_MAND_MASK) {
5840 if (target->flags & LYS_MAND_MASK) {
5841 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
5842 "Invalid deviation adding \"mandatory\" property which already exists (with value \"mandatory %s\").",
5843 target->flags & LYS_MAND_TRUE ? "true" : "false");
5844 goto cleanup;
5845 }
5846 LY_CHECK_GOTO(lys_compile_change_mandatory(ctx, target, d->flags, 0), cleanup);
5847 }
5848
5849 /* [min-elements-stmt] */
5850 if (d->flags & LYS_SET_MIN) {
5851 if (target->nodetype == LYS_LEAFLIST) {
5852 DEV_CHECK_NONPRESENCE_UINT(struct lysc_node_leaflist *, > 0, min, "min-elements");
5853 /* change value */
5854 ((struct lysc_node_leaflist*)target)->min = d->min;
5855 } else if (target->nodetype == LYS_LIST) {
5856 DEV_CHECK_NONPRESENCE_UINT(struct lysc_node_list *, > 0, min, "min-elements");
5857 /* change value */
5858 ((struct lysc_node_list*)target)->min = d->min;
5859 } else {
5860 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
5861 lys_nodetype2str(target->nodetype), "add", "min-elements");
5862 goto cleanup;
5863 }
5864 if (d->min) {
5865 target->flags |= LYS_MAND_TRUE;
5866 }
5867 }
5868
5869 /* [max-elements-stmt] */
5870 if (d->flags & LYS_SET_MAX) {
5871 if (target->nodetype == LYS_LEAFLIST) {
5872 DEV_CHECK_NONPRESENCE_UINT(struct lysc_node_leaflist *, < (uint32_t)-1, max, "max-elements");
5873 /* change value */
5874 ((struct lysc_node_leaflist*)target)->max = d->max ? d->max : (uint32_t)-1;
5875 } else if (target->nodetype == LYS_LIST) {
5876 DEV_CHECK_NONPRESENCE_UINT(struct lysc_node_list *, < (uint32_t)-1, max, "max-elements");
5877 /* change value */
5878 ((struct lysc_node_list*)target)->max = d->max ? d->max : (uint32_t)-1;
5879 } else {
5880 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
5881 lys_nodetype2str(target->nodetype), "add", "max-elements");
5882 goto cleanup;
5883 }
5884 }
5885
5886 ret = LY_SUCCESS;
5887
5888cleanup:
5889 return ret;
5890}
5891
5892/**
5893 * @brief Apply deviate delete.
5894 *
5895 * @param[in] ctx Compile context.
5896 * @param[in] target Deviation target.
5897 * @param[in] dev_flags Internal deviation flags.
5898 * @param[in] d Deviate delete to apply.
5899 * @return LY_ERR value.
5900 */
5901static LY_ERR
5902lys_apply_deviate_delete(struct lysc_ctx *ctx, struct lysc_node *target, int dev_flags, struct lysp_deviate_del *d)
5903{
5904 LY_ERR ret = LY_EVALID;
5905 struct lysc_node_leaf *leaf = (struct lysc_node_leaf *)target;
5906 struct lysc_node_leaflist *llist = (struct lysc_node_leaflist *)target;
5907 struct lysc_node_list *list = (struct lysc_node_list *)target;
5908 LY_ARRAY_COUNT_TYPE x, y, z;
5909 int i;
5910 size_t prefix_len, name_len;
5911 const char *prefix, *name, *nodeid, *dflt;
5912 struct lys_module *mod;
5913
5914#define DEV_DEL_ARRAY(TYPE, ARRAY_TRG, ARRAY_DEV, VALMEMBER, VALMEMBER_CMP, DELFUNC_DEREF, DELFUNC, PROPERTY) \
5915 DEV_CHECK_PRESENCE(TYPE, 0, ARRAY_TRG, "deleting", PROPERTY, d->ARRAY_DEV[0]VALMEMBER); \
5916 LY_ARRAY_FOR(d->ARRAY_DEV, x) { \
5917 LY_ARRAY_FOR(((TYPE)target)->ARRAY_TRG, y) { \
5918 if (!strcmp(((TYPE)target)->ARRAY_TRG[y]VALMEMBER_CMP, d->ARRAY_DEV[x]VALMEMBER)) { break; } \
5919 } \
5920 if (y == LY_ARRAY_COUNT(((TYPE)target)->ARRAY_TRG)) { \
5921 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
5922 "Invalid deviation deleting \"%s\" property \"%s\" which does not match any of the target's property values.", \
5923 PROPERTY, d->ARRAY_DEV[x]VALMEMBER); \
5924 goto cleanup; \
5925 } \
5926 LY_ARRAY_DECREMENT(((TYPE)target)->ARRAY_TRG); \
5927 DELFUNC(ctx->ctx, DELFUNC_DEREF((TYPE)target)->ARRAY_TRG[y]); \
5928 memmove(&((TYPE)target)->ARRAY_TRG[y], \
5929 &((TYPE)target)->ARRAY_TRG[y + 1], \
5930 (LY_ARRAY_COUNT(((TYPE)target)->ARRAY_TRG) - y) * (sizeof *((TYPE)target)->ARRAY_TRG)); \
5931 } \
5932 if (!LY_ARRAY_COUNT(((TYPE)target)->ARRAY_TRG)) { \
5933 LY_ARRAY_FREE(((TYPE)target)->ARRAY_TRG); \
5934 ((TYPE)target)->ARRAY_TRG = NULL; \
5935 }
5936
5937 /* [units-stmt] */
5938 if (d->units) {
5939 DEV_CHECK_NODETYPE(LYS_LEAF | LYS_LEAFLIST, "delete", "units");
5940 DEV_CHECK_PRESENCE(struct lysc_node_leaf*, 0, units, "deleting", "units", d->units);
5941 if (strcmp(((struct lysc_node_leaf*)target)->units, d->units)) {
5942 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
5943 "Invalid deviation deleting \"units\" property \"%s\" which does not match the target's property value \"%s\".",
5944 d->units, ((struct lysc_node_leaf*)target)->units);
5945 goto cleanup;
5946 }
5947 lydict_remove(ctx->ctx, ((struct lysc_node_leaf*)target)->units);
5948 ((struct lysc_node_leaf*)target)->units = NULL;
5949 }
5950
5951 /* *must-stmt */
5952 if (d->musts) {
5953 switch (target->nodetype) {
5954 case LYS_CONTAINER:
5955 case LYS_LIST:
5956 DEV_DEL_ARRAY(struct lysc_node_container*, musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
5957 break;
5958 case LYS_LEAF:
5959 case LYS_LEAFLIST:
5960 case LYS_ANYDATA:
5961 DEV_DEL_ARRAY(struct lysc_node_leaf*, musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
5962 break;
5963 case LYS_NOTIF:
5964 DEV_DEL_ARRAY(struct lysc_notif*, musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
5965 break;
5966 case LYS_RPC:
5967 case LYS_ACTION:
5968 if (dev_flags & LYSC_OPT_RPC_INPUT) {
5969 DEV_DEL_ARRAY(struct lysc_action*, input.musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
5970 break;
5971 } else if (dev_flags & LYSC_OPT_RPC_OUTPUT) {
5972 DEV_DEL_ARRAY(struct lysc_action*, output.musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
5973 break;
5974 }
5975 /* fall through */
5976 default:
5977 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
5978 lys_nodetype2str(target->nodetype), "delete", "must");
5979 goto cleanup;
5980 }
5981 }
5982
5983 /* *unique-stmt */
5984 if (d->uniques) {
5985 DEV_CHECK_NODETYPE(LYS_LIST, "delete", "unique");
5986 LY_ARRAY_FOR(d->uniques, x) {
5987 LY_ARRAY_FOR(list->uniques, z) {
5988 for (name = d->uniques[x], y = 0; name; name = nodeid, ++y) {
5989 nodeid = strpbrk(name, " \t\n");
5990 if (nodeid) {
5991 if (ly_strncmp(list->uniques[z][y]->name, name, nodeid - name)) {
5992 break;
5993 }
5994 while (isspace(*nodeid)) {
5995 ++nodeid;
5996 }
5997 } else {
5998 if (strcmp(name, list->uniques[z][y]->name)) {
5999 break;
6000 }
6001 }
6002 }
6003 if (!name) {
6004 /* complete match - remove the unique */
6005 LY_ARRAY_DECREMENT(list->uniques);
6006 LY_ARRAY_FREE(list->uniques[z]);
6007 memmove(&list->uniques[z], &list->uniques[z + 1], (LY_ARRAY_COUNT(list->uniques) - z) * (sizeof *list->uniques));
6008 --z;
6009 break;
6010 }
6011 }
6012 if (!list->uniques || z == LY_ARRAY_COUNT(list->uniques)) {
6013 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
6014 "Invalid deviation deleting \"unique\" property \"%s\" which does not match any of the target's property values.",
6015 d->uniques[x]);
6016 goto cleanup;
6017 }
6018 }
6019 if (!LY_ARRAY_COUNT(list->uniques)) {
6020 LY_ARRAY_FREE(list->uniques);
6021 list->uniques = NULL;
6022 }
6023 }
6024
6025 /* *default-stmt */
6026 if (d->dflts) {
6027 switch (target->nodetype) {
6028 case LYS_LEAF:
6029 DEV_CHECK_CARDINALITY(d->dflts, 1, "default");
6030 DEV_CHECK_PRESENCE(struct lysc_node_leaf*, !(target->flags & LYS_SET_DFLT),
6031 dflt, "deleting", "default", d->dflts[0]);
6032
6033 /* check that the values matches */
6034 dflt = leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, lys_get_prefix, leaf->dflt_mod, &i);
6035 if (strcmp(dflt, d->dflts[0])) {
6036 if (i) {
6037 free((char*)dflt);
6038 }
6039 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
6040 "Invalid deviation deleting \"default\" property \"%s\" which does not match the target's property value \"%s\".",
6041 d->dflts[0], dflt);
6042 goto cleanup;
6043 }
6044 if (i) {
6045 free((char*)dflt);
6046 }
6047
6048 /* update the list of incomplete default values if needed */
6049 lysc_incomplete_dflts_remove(ctx, leaf->dflt);
6050
6051 /* remove the default specification */
6052 leaf->dflt->realtype->plugin->free(ctx->ctx, leaf->dflt);
6053 lysc_type_free(ctx->ctx, leaf->dflt->realtype);
6054 free(leaf->dflt);
6055 leaf->dflt = NULL;
6056 leaf->dflt_mod = NULL;
6057 target->flags &= ~LYS_SET_DFLT;
6058 break;
6059 case LYS_LEAFLIST:
6060 DEV_CHECK_PRESENCE(struct lysc_node_leaflist*, 0, dflts, "deleting", "default", d->dflts[0]);
6061 LY_ARRAY_FOR(d->dflts, x) {
6062 LY_ARRAY_FOR(llist->dflts, y) {
6063 dflt = llist->type->plugin->print(llist->dflts[y], LYD_XML, lys_get_prefix, llist->dflts_mods[y], &i);
6064 if (!strcmp(dflt, d->dflts[x])) {
6065 if (i) {
6066 free((char*)dflt);
6067 }
6068 break;
6069 }
6070 if (i) {
6071 free((char*)dflt);
6072 }
6073 }
6074 if (y == LY_ARRAY_COUNT(llist->dflts)) {
6075 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Invalid deviation deleting \"default\" property \"%s\" "
6076 "which does not match any of the target's property values.", d->dflts[x]);
6077 goto cleanup;
6078 }
6079
6080 /* update the list of incomplete default values if needed */
6081 lysc_incomplete_dflts_remove(ctx, llist->dflts[y]);
6082
6083 LY_ARRAY_DECREMENT(llist->dflts_mods);
6084 LY_ARRAY_DECREMENT(llist->dflts);
6085 llist->dflts[y]->realtype->plugin->free(ctx->ctx, llist->dflts[y]);
6086 lysc_type_free(ctx->ctx, llist->dflts[y]->realtype);
6087 free(llist->dflts[y]);
6088 memmove(&llist->dflts[y], &llist->dflts[y + 1], (LY_ARRAY_COUNT(llist->dflts) - y) * (sizeof *llist->dflts));
6089 memmove(&llist->dflts_mods[y], &llist->dflts_mods[y + 1], (LY_ARRAY_COUNT(llist->dflts_mods) - y) * (sizeof *llist->dflts_mods));
6090 }
6091 if (!LY_ARRAY_COUNT(llist->dflts)) {
6092 LY_ARRAY_FREE(llist->dflts_mods);
6093 llist->dflts_mods = NULL;
6094 LY_ARRAY_FREE(llist->dflts);
6095 llist->dflts = NULL;
6096 llist->flags &= ~LYS_SET_DFLT;
6097 }
6098 break;
6099 case LYS_CHOICE:
6100 DEV_CHECK_CARDINALITY(d->dflts, 1, "default");
6101 DEV_CHECK_PRESENCE(struct lysc_node_choice*, 0, dflt, "deleting", "default", d->dflts[0]);
6102 nodeid = d->dflts[0];
6103 LY_CHECK_GOTO(ly_parse_nodeid(&nodeid, &prefix, &prefix_len, &name, &name_len), cleanup);
6104 if (prefix) {
6105 /* use module prefixes from the deviation module to match the module of the default case */
6106 if (!(mod = lys_module_find_prefix(ctx->mod, prefix, prefix_len))) {
6107 LOGVAL(ctx->ctx,LY_VLOG_STR,ctx->path,LYVE_REFERENCE,
6108 "Invalid deviation deleting \"default\" property \"%s\" of choice. "
6109 "The prefix does not match any imported module of the deviation module.", d->dflts[0]);
6110 goto cleanup;
6111 }
6112 if (mod != ((struct lysc_node_choice*)target)->dflt->module) {
6113 LOGVAL(ctx->ctx,LY_VLOG_STR,ctx->path,LYVE_REFERENCE,
6114 "Invalid deviation deleting \"default\" property \"%s\" of choice. "
6115 "The prefix does not match the default case's module.", d->dflts[0]);
6116 goto cleanup;
6117 }
6118 }
6119 /* else {
6120 * strictly, the default prefix would point to the deviation module, but the value should actually
6121 * match the default string in the original module (usually unprefixed), so in this case we do not check
6122 * the module of the default case, just matching its name */
6123 if (strcmp(name, ((struct lysc_node_choice*)target)->dflt->name)) {
6124 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
6125 "Invalid deviation deleting \"default\" property \"%s\" of choice does not match the default case name \"%s\".",
6126 d->dflts[0], ((struct lysc_node_choice*)target)->dflt->name);
6127 goto cleanup;
6128 }
6129 ((struct lysc_node_choice*)target)->dflt->flags &= ~LYS_SET_DFLT;
6130 ((struct lysc_node_choice*)target)->dflt = NULL;
6131 break;
6132 default:
6133 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
6134 lys_nodetype2str(target->nodetype), "delete", "default");
6135 goto cleanup;
6136 }
6137 }
6138
6139 ret = LY_SUCCESS;
6140
6141cleanup:
6142 return ret;
6143}
6144
6145/**
6146 * @brief Apply deviate replace.
6147 *
6148 * @param[in] ctx Compile context.
6149 * @param[in] target Deviation target.
6150 * @param[in] d Deviate replace to apply.
6151 * @param[out] dflt Added default value.
6152 * @param[out] changed_type Whether the target type was changed.
6153 * @return LY_ERR value.
6154 */
6155static LY_ERR
6156lys_apply_deviate_replace(struct lysc_ctx *ctx, struct lysc_node *target, struct lysp_deviate_rpl *d, const char **dflt,
6157 int *changed_type)
6158{
6159 LY_ERR ret = LY_EVALID;
6160 struct lysc_node_leaf *leaf = (struct lysc_node_leaf *)target;
6161 struct lysc_node_leaflist *llist = (struct lysc_node_leaflist *)target;
6162 LY_ARRAY_COUNT_TYPE x;
6163
6164#define DEV_CHECK_PRESENCE_UINT(TYPE, COND, MEMBER, PROPERTY) \
6165 if (!(((TYPE)target)->MEMBER COND)) { \
6166 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
6167 "Invalid deviation replacing with \"%s\" property \"%u\" which is not present.", PROPERTY, d->MEMBER); \
6168 goto cleanup; \
6169 }
6170
6171 /* [type-stmt] */
6172 if (d->type) {
6173 DEV_CHECK_NODETYPE(LYS_LEAF | LYS_LEAFLIST, "replace", "type");
6174 /* type is mandatory, so checking for its presence is not necessary */
6175 lysc_type_free(ctx->ctx, ((struct lysc_node_leaf *)target)->type);
6176
6177 if (leaf->dflt && !(target->flags & LYS_SET_DFLT)) {
6178 /* the target has default from the previous type - remove it */
6179 if (target->nodetype == LYS_LEAF) {
6180 /* update the list of incomplete default values if needed */
6181 lysc_incomplete_dflts_remove(ctx, leaf->dflt);
6182
6183 leaf->dflt->realtype->plugin->free(ctx->ctx, leaf->dflt);
6184 lysc_type_free(ctx->ctx, leaf->dflt->realtype);
6185 free(leaf->dflt);
6186 leaf->dflt = NULL;
6187 leaf->dflt_mod = NULL;
6188 } else { /* LYS_LEAFLIST */
6189 LY_ARRAY_FOR(llist->dflts, x) {
6190 lysc_incomplete_dflts_remove(ctx, llist->dflts[x]);
6191 llist->dflts[x]->realtype->plugin->free(ctx->ctx, llist->dflts[x]);
6192 lysc_type_free(ctx->ctx, llist->dflts[x]->realtype);
6193 free(llist->dflts[x]);
6194 }
6195 LY_ARRAY_FREE(llist->dflts);
6196 llist->dflts = NULL;
6197 LY_ARRAY_FREE(llist->dflts_mods);
6198 llist->dflts_mods = NULL;
6199 }
6200 }
6201 if (!leaf->dflt) {
6202 /* there is no default value, do not set changed_type after type compilation
6203 * which is used to recompile the default value */
6204 *changed_type = -1;
6205 }
6206 LY_CHECK_GOTO(lys_compile_node_type(ctx, NULL, d->type, leaf), cleanup);
6207 (*changed_type)++;
6208 }
6209
6210 /* [units-stmt] */
6211 if (d->units) {
6212 DEV_CHECK_NODETYPE(LYS_LEAF | LYS_LEAFLIST, "replace", "units");
6213 DEV_CHECK_PRESENCE(struct lysc_node_leaf *, !(target->flags & LYS_SET_UNITS),
6214 units, "replacing", "units", d->units);
6215
6216 lydict_remove(ctx->ctx, leaf->units);
6217 DUP_STRING(ctx->ctx, d->units, leaf->units);
6218 }
6219
6220 /* [default-stmt] */
6221 if (d->dflt) {
6222 switch (target->nodetype) {
6223 case LYS_LEAF:
6224 DEV_CHECK_PRESENCE(struct lysc_node_leaf *, !(target->flags & LYS_SET_DFLT),
6225 dflt, "replacing", "default", d->dflt);
6226 /* first, remove the default value taken from the type */
6227 lysc_incomplete_dflts_remove(ctx, leaf->dflt);
6228 leaf->dflt->realtype->plugin->free(ctx->ctx, leaf->dflt);
6229 lysc_type_free(ctx->ctx, leaf->dflt->realtype);
6230 *dflt = d->dflt;
6231 /* parsing is done at the end after possible replace of the leaf's type */
6232 break;
6233 case LYS_CHOICE:
6234 DEV_CHECK_PRESENCE(struct lysc_node_choice *, 0, dflt, "replacing", "default", d->dflt);
6235 if (lys_compile_deviation_set_choice_dflt(ctx, d->dflt, (struct lysc_node_choice *)target)) {
6236 goto cleanup;
6237 }
6238 break;
6239 default:
6240 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
6241 lys_nodetype2str(target->nodetype), "replace", "default");
6242 goto cleanup;
6243 }
6244 }
6245
6246 /* [config-stmt] */
6247 if (d->flags & LYS_CONFIG_MASK) {
6248 if (target->nodetype & (LYS_CASE | LYS_INOUT | LYS_RPC | LYS_ACTION | LYS_NOTIF)) {
6249 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
6250 lys_nodetype2str(target->nodetype), "replace", "config");
6251 goto cleanup;
6252 }
6253 if (!(target->flags & LYS_SET_CONFIG)) {
6254 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NOT_PRESENT,
6255 "replacing", "config", d->flags & LYS_CONFIG_W ? "config true" : "config false");
6256 goto cleanup;
6257 }
6258 LY_CHECK_GOTO(lys_compile_change_config(ctx, target, d->flags, 0, 0), cleanup);
6259 }
6260
6261 /* [mandatory-stmt] */
6262 if (d->flags & LYS_MAND_MASK) {
6263 if (!(target->flags & LYS_MAND_MASK)) {
6264 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NOT_PRESENT,
6265 "replacing", "mandatory", d->flags & LYS_MAND_TRUE ? "mandatory true" : "mandatory false");
6266 goto cleanup;
6267 }
6268 LY_CHECK_GOTO(lys_compile_change_mandatory(ctx, target, d->flags, 0), cleanup);
6269 }
6270
6271 /* [min-elements-stmt] */
6272 if (d->flags & LYS_SET_MIN) {
6273 if (target->nodetype == LYS_LEAFLIST) {
6274 DEV_CHECK_PRESENCE_UINT(struct lysc_node_leaflist *, > 0, min, "min-elements");
6275 /* change value */
6276 ((struct lysc_node_leaflist *)target)->min = d->min;
6277 } else if (target->nodetype == LYS_LIST) {
6278 DEV_CHECK_PRESENCE_UINT(struct lysc_node_list *, > 0, min, "min-elements");
6279 /* change value */
6280 ((struct lysc_node_list *)target)->min = d->min;
6281 } else {
6282 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
6283 lys_nodetype2str(target->nodetype), "replace", "min-elements");
6284 goto cleanup;
6285 }
6286 if (d->min) {
6287 target->flags |= LYS_MAND_TRUE;
6288 }
6289 }
6290
6291 /* [max-elements-stmt] */
6292 if (d->flags & LYS_SET_MAX) {
6293 if (target->nodetype == LYS_LEAFLIST) {
6294 DEV_CHECK_PRESENCE_UINT(struct lysc_node_leaflist *, < (uint32_t)-1, max, "max-elements");
6295 /* change value */
6296 ((struct lysc_node_leaflist *)target)->max = d->max ? d->max : (uint32_t)-1;
6297 } else if (target->nodetype == LYS_LIST) {
6298 DEV_CHECK_PRESENCE_UINT(struct lysc_node_list *, < (uint32_t)-1, max, "max-elements");
6299 /* change value */
6300 ((struct lysc_node_list *)target)->max = d->max ? d->max : (uint32_t)-1;
6301 } else {
6302 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
6303 lys_nodetype2str(target->nodetype), "replace", "max-elements");
6304 goto cleanup;
6305 }
6306 }
6307
6308 ret = LY_SUCCESS;
6309
6310cleanup:
6311 return ret;
6312}
6313
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006314/**
6315 * @brief Apply all deviations of one target node.
6316 *
6317 * @param[in] ctx Compile context.
6318 * @param[in] dev Deviation structure to apply.
6319 * @return LY_ERR value.
6320 */
6321static LY_ERR
6322lys_apply_deviation(struct lysc_ctx *ctx, struct lysc_deviation *dev)
Radek Krejciccd20f12019-02-15 14:12:27 +01006323{
Radek Krejcia1911222019-07-22 17:24:50 +02006324 LY_ERR ret = LY_EVALID, rc;
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006325 struct lysc_node *target = dev->target;
6326 struct lysc_node_leaf *leaf = (struct lysc_node_leaf *)target;
6327 struct lysc_node_leaflist *llist = (struct lysc_node_leaflist *)target;
6328 struct ly_err_item *err = NULL;
Radek Krejcifc11bd72019-04-11 16:00:05 +02006329 struct lysc_action *rpcs;
6330 struct lysc_notif *notifs;
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006331 struct lysp_deviate *d;
Michal Vaskoccc062a2020-08-13 08:34:50 +02006332 LY_ARRAY_COUNT_TYPE v, x;
6333 int changed_type = 0;
6334 const char *dflt = NULL;
Radek Krejci551b12c2019-02-19 16:11:21 +01006335 uint32_t min, max;
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006336
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006337 lysc_update_path(ctx, NULL, dev->nodeid);
6338
6339 /* not-supported */
6340 if (dev->not_supported) {
6341 if (LY_ARRAY_COUNT(dev->deviates) > 1) {
6342 LOGWRN(ctx->ctx, "Useless multiple (%"LY_PRI_ARRAY_COUNT_TYPE") deviates on node \"%s\" since the node is not-supported.",
6343 LY_ARRAY_COUNT(dev->deviates), dev->nodeid);
6344 }
6345
6346#define REMOVE_NONDATA(ARRAY, TYPE, GETFUNC, FREEFUNC) \
6347 if (target->parent) { \
6348 ARRAY = (TYPE*)GETFUNC(target->parent); \
6349 } else { \
6350 ARRAY = target->module->compiled->ARRAY; \
6351 } \
6352 LY_ARRAY_FOR(ARRAY, x) { \
6353 if (&ARRAY[x] == (TYPE*)target) { break; } \
6354 } \
6355 if (x < LY_ARRAY_COUNT(ARRAY)) { \
6356 FREEFUNC(ctx->ctx, &ARRAY[x]); \
6357 memmove(&ARRAY[x], &ARRAY[x + 1], (LY_ARRAY_COUNT(ARRAY) - (x + 1)) * sizeof *ARRAY); \
6358 LY_ARRAY_DECREMENT(ARRAY); \
6359 }
6360
6361 if (target->nodetype & (LYS_RPC | LYS_ACTION)) {
6362 if (dev->flags & LYSC_OPT_RPC_INPUT) {
6363 /* remove RPC's/action's input */
6364 lysc_action_inout_free(ctx->ctx, &((struct lysc_action*)target)->input);
6365 memset(&((struct lysc_action*)target)->input, 0, sizeof ((struct lysc_action*)target)->input);
6366 FREE_ARRAY(ctx->ctx, ((struct lysc_action*)target)->input_exts, lysc_ext_instance_free);
6367 ((struct lysc_action*)target)->input_exts = NULL;
6368 } else if (dev->flags & LYSC_OPT_RPC_OUTPUT) {
6369 /* remove RPC's/action's output */
6370 lysc_action_inout_free(ctx->ctx, &((struct lysc_action*)target)->output);
6371 memset(&((struct lysc_action*)target)->output, 0, sizeof ((struct lysc_action*)target)->output);
6372 FREE_ARRAY(ctx->ctx, ((struct lysc_action*)target)->output_exts, lysc_ext_instance_free);
6373 ((struct lysc_action*)target)->output_exts = NULL;
6374 } else {
6375 /* remove RPC/action */
6376 REMOVE_NONDATA(rpcs, struct lysc_action, lysc_node_actions, lysc_action_free);
6377 }
6378 } else if (target->nodetype == LYS_NOTIF) {
6379 /* remove Notification */
6380 REMOVE_NONDATA(notifs, struct lysc_notif, lysc_node_notifs, lysc_notif_free);
6381 } else {
6382 /* remove the target node */
6383 lysc_disconnect(target);
6384 lysc_node_free(ctx->ctx, target);
6385 }
6386
6387 /* mark the context for later re-compilation of objects that could reference the curently removed node */
6388 ctx->ctx->flags |= LY_CTX_CHANGED_TREE;
6389 return LY_SUCCESS;
6390 }
6391
6392 /* list of deviates (not-supported is not present in the list) */
6393 LY_ARRAY_FOR(dev->deviates, v) {
6394 d = dev->deviates[v];
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006395 switch (d->mod) {
6396 case LYS_DEV_ADD:
Michal Vaskoccc062a2020-08-13 08:34:50 +02006397 LY_CHECK_GOTO(lys_apply_deviate_add(ctx, target, dev->flags, (struct lysp_deviate_add *)d, &dflt), cleanup);
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006398 break;
6399 case LYS_DEV_DELETE:
Michal Vaskoccc062a2020-08-13 08:34:50 +02006400 LY_CHECK_GOTO(lys_apply_deviate_delete(ctx, target, dev->flags, (struct lysp_deviate_del *)d), cleanup);
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006401 break;
6402 case LYS_DEV_REPLACE:
Michal Vaskoccc062a2020-08-13 08:34:50 +02006403 LY_CHECK_GOTO(lys_apply_deviate_replace(ctx, target, (struct lysp_deviate_rpl *)d, &dflt, &changed_type), cleanup);
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006404 break;
6405 default:
6406 LOGINT(ctx->ctx);
6407 goto cleanup;
6408 }
6409 }
6410
6411 /* final check when all deviations of a single target node are applied */
6412
6413 /* check min-max compatibility */
6414 if (target->nodetype == LYS_LEAFLIST) {
6415 min = ((struct lysc_node_leaflist*)target)->min;
6416 max = ((struct lysc_node_leaflist*)target)->max;
6417 } else if (target->nodetype == LYS_LIST) {
6418 min = ((struct lysc_node_list*)target)->min;
6419 max = ((struct lysc_node_list*)target)->max;
6420 } else {
6421 min = max = 0;
6422 }
6423 if (min > max) {
6424 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Invalid combination of min-elements and max-elements "
6425 "after deviation: min value %u is bigger than max value %u.", min, max);
6426 goto cleanup;
6427 }
6428
6429 if (dflt) {
6430 /* parse added/changed default value after possible change of the type */
6431 leaf->dflt_mod = ctx->mod_def;
6432 leaf->dflt->realtype = leaf->type;
6433 rc = leaf->type->plugin->store(ctx->ctx, leaf->type, dflt, strlen(dflt),
6434 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
6435 lys_resolve_prefix, (void*)leaf->dflt_mod, LYD_XML, target, NULL, leaf->dflt, NULL, &err);
6436 leaf->dflt->realtype->refcount++;
6437 if (err) {
6438 ly_err_print(err);
6439 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
6440 "Invalid deviation setting \"default\" property \"%s\" which does not fit the type (%s).", dflt, err->msg);
6441 ly_err_free(err);
6442 }
6443 if (rc == LY_EINCOMPLETE) {
6444 /* postpone default compilation when the tree is complete */
6445 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, target, leaf->dflt, leaf->dflt_mod), cleanup);
6446
6447 /* but in general result is so far ok */
6448 rc = LY_SUCCESS;
6449 }
6450 LY_CHECK_GOTO(rc, cleanup);
6451 } else if (changed_type) {
6452 /* the leaf/leaf-list's type has changed, but there is still a default value for the previous type */
6453 int dynamic;
6454 if (target->nodetype == LYS_LEAF) {
6455 dflt = leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, lys_get_prefix, leaf->dflt_mod, &dynamic);
6456
6457 /* update the list of incomplete default values if needed */
6458 lysc_incomplete_dflts_remove(ctx, leaf->dflt);
6459
6460 /* remove the previous default */
6461 leaf->dflt->realtype->plugin->free(ctx->ctx, leaf->dflt);
6462 lysc_type_free(ctx->ctx, leaf->dflt->realtype);
6463 leaf->dflt->realtype = leaf->type;
6464 rc = leaf->type->plugin->store(ctx->ctx, leaf->type, dflt, strlen(dflt),
6465 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
6466 lys_resolve_prefix, (void*)leaf->dflt_mod, LYD_XML, target, NULL, leaf->dflt, NULL, &err);
6467 leaf->dflt->realtype->refcount++;
6468 if (err) {
6469 ly_err_print(err);
6470 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
6471 "Invalid deviation replacing leaf's type - the leaf's default value \"%s\" does not match the type (%s).", dflt, err->msg);
6472 ly_err_free(err);
6473 }
6474 if (dynamic) {
6475 free((void*)dflt);
6476 }
6477 dflt = NULL;
6478 if (rc == LY_EINCOMPLETE) {
6479 /* postpone default compilation when the tree is complete */
6480 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, target, leaf->dflt, leaf->dflt_mod), cleanup);
6481
6482 /* but in general result is so far ok */
6483 rc = LY_SUCCESS;
6484 }
6485 LY_CHECK_GOTO(rc, cleanup);
6486 } else { /* LYS_LEAFLIST */
6487 LY_ARRAY_FOR(llist->dflts, x) {
6488 dflt = llist->dflts[x]->realtype->plugin->print(llist->dflts[x], LYD_XML, lys_get_prefix, llist->dflts_mods[x], &dynamic);
6489 llist->dflts[x]->realtype->plugin->free(ctx->ctx, llist->dflts[x]);
6490 lysc_type_free(ctx->ctx, llist->dflts[x]->realtype);
6491 llist->dflts[x]->realtype = llist->type;
6492 rc = llist->type->plugin->store(ctx->ctx, llist->type, dflt, strlen(dflt),
6493 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
6494 lys_resolve_prefix, (void*)llist->dflts_mods[x], LYD_XML, target, NULL,
6495 llist->dflts[x], NULL, &err);
6496 llist->dflts[x]->realtype->refcount++;
6497 if (err) {
6498 ly_err_print(err);
6499 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
6500 "Invalid deviation replacing leaf-list's type - the leaf-list's default value \"%s\" does not match the type (%s).",
6501 dflt, err->msg);
6502 ly_err_free(err);
6503 }
6504 if (dynamic) {
6505 free((void*)dflt);
6506 }
6507 dflt = NULL;
6508 if (rc == LY_EINCOMPLETE) {
6509 /* postpone default compilation when the tree is complete */
6510 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, target, llist->dflts[x], llist->dflts_mods[x]), cleanup);
6511
6512 /* but in general result is so far ok */
6513 rc = LY_SUCCESS;
6514 }
6515 LY_CHECK_GOTO(rc, cleanup);
6516 }
6517 }
6518 }
6519
6520 /* check mandatory - default compatibility */
6521 if ((target->nodetype & (LYS_LEAF | LYS_LEAFLIST)) && (target->flags & LYS_SET_DFLT)
6522 && (target->flags & LYS_MAND_TRUE)) {
6523 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
6524 "Invalid deviation combining default value and mandatory %s.", lys_nodetype2str(target->nodetype));
6525 goto cleanup;
6526 } else if ((target->nodetype & LYS_CHOICE) && ((struct lysc_node_choice*)target)->dflt
6527 && (target->flags & LYS_MAND_TRUE)) {
6528 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Invalid deviation combining default case and mandatory choice.");
6529 goto cleanup;
6530 }
6531 if (target->parent && (target->parent->flags & LYS_SET_DFLT) && (target->flags & LYS_MAND_TRUE)) {
6532 /* mandatory node under a default case */
6533 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
6534 "Invalid deviation combining mandatory %s \"%s\" in a default choice's case \"%s\".",
6535 lys_nodetype2str(target->nodetype), target->name, target->parent->name);
6536 goto cleanup;
6537 }
6538
6539 /* success */
6540 ret = LY_SUCCESS;
6541
6542cleanup:
6543 lysc_update_path(ctx, NULL, NULL);
6544 return ret;
6545}
6546
6547LY_ERR
6548lys_compile_deviations(struct lysc_ctx *ctx, struct lysp_module *mod_p)
6549{
6550 LY_ERR ret = LY_EVALID;
6551 struct ly_set devs_p = {0};
6552 struct ly_set targets = {0};
6553 struct lysc_node *target; /* target target of the deviation */
6554 struct lysp_deviation *dev;
6555 struct lysp_deviate *d, **dp_new;
6556 LY_ARRAY_COUNT_TYPE u, v;
6557 struct lysc_deviation **devs = NULL;
6558 struct lys_module *target_mod, **dev_mod;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01006559 uint16_t flags;
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006560 int i;
Radek Krejciccd20f12019-02-15 14:12:27 +01006561
6562 /* get all deviations from the module and all its submodules ... */
6563 LY_ARRAY_FOR(mod_p->deviations, u) {
6564 ly_set_add(&devs_p, &mod_p->deviations[u], LY_SET_OPT_USEASLIST);
6565 }
6566 LY_ARRAY_FOR(mod_p->includes, v) {
6567 LY_ARRAY_FOR(mod_p->includes[v].submodule->deviations, u) {
6568 ly_set_add(&devs_p, &mod_p->includes[v].submodule->deviations[u], LY_SET_OPT_USEASLIST);
6569 }
6570 }
6571 if (!devs_p.count) {
6572 /* nothing to do */
6573 return LY_SUCCESS;
6574 }
6575
Radek Krejci327de162019-06-14 12:52:07 +02006576 lysc_update_path(ctx, NULL, "{deviation}");
6577
Radek Krejciccd20f12019-02-15 14:12:27 +01006578 /* ... and group them by the target node */
6579 devs = calloc(devs_p.count, sizeof *devs);
6580 for (u = 0; u < devs_p.count; ++u) {
6581 dev = devs_p.objs[u];
Radek Krejci327de162019-06-14 12:52:07 +02006582 lysc_update_path(ctx, NULL, dev->nodeid);
Radek Krejciccd20f12019-02-15 14:12:27 +01006583
6584 /* resolve the target */
Radek Krejci6eeb58f2019-02-22 16:29:37 +01006585 LY_CHECK_GOTO(lys_resolve_schema_nodeid(ctx, dev->nodeid, 0, NULL, ctx->mod, 0, 1,
6586 (const struct lysc_node**)&target, &flags), cleanup);
Michal Vasko1bf09392020-03-27 12:38:10 +01006587 if (target->nodetype & (LYS_RPC | LYS_ACTION)) {
Radek Krejcif538ce52019-03-05 10:46:14 +01006588 /* move the target pointer to input/output to make them different from the action and
6589 * between them. Before the devs[] item is being processed, the target pointer must be fixed
6590 * back to the RPC/action node due to a better compatibility and decision code in this function.
6591 * The LYSC_OPT_INTERNAL is used as a flag to this change. */
6592 if (flags & LYSC_OPT_RPC_INPUT) {
6593 target = (struct lysc_node*)&((struct lysc_action*)target)->input;
6594 flags |= LYSC_OPT_INTERNAL;
6595 } else if (flags & LYSC_OPT_RPC_OUTPUT) {
6596 target = (struct lysc_node*)&((struct lysc_action*)target)->output;
6597 flags |= LYSC_OPT_INTERNAL;
6598 }
6599 }
Radek Krejciccd20f12019-02-15 14:12:27 +01006600 /* insert into the set of targets with duplicity detection */
6601 i = ly_set_add(&targets, target, 0);
6602 if (!devs[i]) {
6603 /* new record */
6604 devs[i] = calloc(1, sizeof **devs);
6605 devs[i]->target = target;
6606 devs[i]->nodeid = dev->nodeid;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01006607 devs[i]->flags = flags;
Radek Krejciccd20f12019-02-15 14:12:27 +01006608 }
6609 /* add deviates into the deviation's list of deviates */
6610 for (d = dev->deviates; d; d = d->next) {
6611 LY_ARRAY_NEW_GOTO(ctx->ctx, devs[i]->deviates, dp_new, ret, cleanup);
6612 *dp_new = d;
6613 if (d->mod == LYS_DEV_NOT_SUPPORTED) {
6614 devs[i]->not_supported = 1;
6615 }
6616 }
Radek Krejci327de162019-06-14 12:52:07 +02006617
6618 lysc_update_path(ctx, NULL, NULL);
Radek Krejciccd20f12019-02-15 14:12:27 +01006619 }
6620
Radek Krejciccd20f12019-02-15 14:12:27 +01006621 /* apply deviations */
6622 for (u = 0; u < devs_p.count && devs[u]; ++u) {
Radek Krejcif538ce52019-03-05 10:46:14 +01006623 if (devs[u]->flags & LYSC_OPT_INTERNAL) {
6624 /* fix the target pointer in case of RPC's/action's input/output */
6625 if (devs[u]->flags & LYSC_OPT_RPC_INPUT) {
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006626 devs[u]->target = (struct lysc_node *)((char *)devs[u]->target - offsetof(struct lysc_action, input));
Radek Krejcif538ce52019-03-05 10:46:14 +01006627 } else if (devs[u]->flags & LYSC_OPT_RPC_OUTPUT) {
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006628 devs[u]->target = (struct lysc_node *)((char *)devs[u]->target - offsetof(struct lysc_action, output));
Radek Krejcif538ce52019-03-05 10:46:14 +01006629 }
6630 }
6631
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006632 /* remember target module (the target node may be removed) */
6633 target_mod = devs[u]->target->module;
Radek Krejcifc11bd72019-04-11 16:00:05 +02006634
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006635 /* apply the deviation */
6636 LY_CHECK_GOTO(ret = lys_apply_deviation(ctx, devs[u]), cleanup);
Radek Krejci33f72892019-02-21 10:36:58 +01006637
Michal Vaskoe6143202020-07-03 13:02:08 +02006638 /* add this module into the target module deviated_by, if not there already */
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006639 i = 0;
6640 LY_ARRAY_FOR(target_mod->compiled->deviated_by, v) {
6641 if (target_mod->compiled->deviated_by[v] == mod_p->mod) {
6642 i = 1;
Michal Vaskoe6143202020-07-03 13:02:08 +02006643 break;
6644 }
6645 }
Michal Vasko1a3dc3b2020-08-12 15:47:42 +02006646 if (!i) {
6647 LY_ARRAY_NEW_GOTO(ctx->ctx, target_mod->compiled->deviated_by, dev_mod, ret, cleanup);
Michal Vaskoe6143202020-07-03 13:02:08 +02006648 *dev_mod = mod_p->mod;
6649 }
Radek Krejciccd20f12019-02-15 14:12:27 +01006650 }
6651
Radek Krejci327de162019-06-14 12:52:07 +02006652 lysc_update_path(ctx, NULL, NULL);
Radek Krejciccd20f12019-02-15 14:12:27 +01006653 ret = LY_SUCCESS;
6654
6655cleanup:
6656 for (u = 0; u < devs_p.count && devs[u]; ++u) {
6657 LY_ARRAY_FREE(devs[u]->deviates);
6658 free(devs[u]);
6659 }
6660 free(devs);
6661 ly_set_erase(&targets, NULL);
6662 ly_set_erase(&devs_p, NULL);
6663
6664 return ret;
6665}
6666
Radek Krejcib56c7502019-02-13 14:19:54 +01006667/**
Radek Krejcid05cbd92018-12-05 14:26:40 +01006668 * @brief Compile the given YANG submodule into the main module.
6669 * @param[in] ctx Compile context
6670 * @param[in] inc Include structure from the main module defining the submodule.
Radek Krejcid05cbd92018-12-05 14:26:40 +01006671 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
6672 */
6673LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02006674lys_compile_submodule(struct lysc_ctx *ctx, struct lysp_include *inc)
Radek Krejcid05cbd92018-12-05 14:26:40 +01006675{
6676 unsigned int u;
6677 LY_ERR ret = LY_SUCCESS;
6678 /* shortcuts */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01006679 struct lysp_submodule *submod = inc->submodule;
Radek Krejcid05cbd92018-12-05 14:26:40 +01006680 struct lysc_module *mainmod = ctx->mod->compiled;
Radek Krejci474f9b82019-07-24 11:36:37 +02006681 struct lysp_node *node_p;
Radek Krejcid05cbd92018-12-05 14:26:40 +01006682
Michal Vasko33ff9422020-07-03 09:50:39 +02006683 if (!mainmod->mod->dis_features) {
Radek Krejci0af46292019-01-11 16:02:31 +01006684 /* features are compiled directly into the compiled module structure,
6685 * but it must be done in two steps to allow forward references (via if-feature) between the features themselves.
6686 * The features compilation is finished in the main module (lys_compile()). */
Radek Krejci0935f412019-08-20 16:15:18 +02006687 ret = lys_feature_precompile(ctx, NULL, NULL, submod->features, &mainmod->features);
6688 LY_CHECK_GOTO(ret, error);
6689 }
Radek Krejci0af46292019-01-11 16:02:31 +01006690
Michal Vasko33ff9422020-07-03 09:50:39 +02006691 if (!mainmod->mod->dis_identities) {
6692 ret = lys_identity_precompile(ctx, NULL, NULL, submod->identities, &mainmod->identities);
6693 LY_CHECK_GOTO(ret, error);
6694 }
Radek Krejcid05cbd92018-12-05 14:26:40 +01006695
Radek Krejci474f9b82019-07-24 11:36:37 +02006696 /* data nodes */
6697 LY_LIST_FOR(submod->data, node_p) {
6698 ret = lys_compile_node(ctx, node_p, NULL, 0);
6699 LY_CHECK_GOTO(ret, error);
6700 }
Radek Krejci8cce8532019-03-05 11:27:45 +01006701
Radek Krejciec4da802019-05-02 13:02:41 +02006702 COMPILE_ARRAY1_GOTO(ctx, submod->rpcs, mainmod->rpcs, NULL, u, lys_compile_action, 0, ret, error);
6703 COMPILE_ARRAY1_GOTO(ctx, submod->notifs, mainmod->notifs, NULL, u, lys_compile_notif, 0, ret, error);
Radek Krejci8cce8532019-03-05 11:27:45 +01006704
Radek Krejcid05cbd92018-12-05 14:26:40 +01006705error:
6706 return ret;
6707}
6708
Radek Krejci335332a2019-09-05 13:03:35 +02006709static void *
6710lys_compile_extension_instance_storage(enum ly_stmt stmt, struct lysc_ext_substmt *substmts)
6711{
6712 for (unsigned int u = 0; substmts[u].stmt; ++u) {
6713 if (substmts[u].stmt == stmt) {
6714 return substmts[u].storage;
6715 }
6716 }
6717 return NULL;
6718}
6719
6720LY_ERR
6721lys_compile_extension_instance(struct lysc_ctx *ctx, const struct lysp_ext_instance *ext, struct lysc_ext_substmt *substmts)
6722{
6723 LY_ERR ret = LY_EVALID, r;
6724 unsigned int u;
6725 struct lysp_stmt *stmt;
6726 void *parsed = NULL, **compiled = NULL;
Radek Krejci335332a2019-09-05 13:03:35 +02006727
6728 /* check for invalid substatements */
6729 for (stmt = ext->child; stmt; stmt = stmt->next) {
Radek Krejcif56e2a42019-09-09 14:15:25 +02006730 if (stmt->flags & (LYS_YIN_ATTR | LYS_YIN_ARGUMENT)) {
6731 continue;
6732 }
Radek Krejci335332a2019-09-05 13:03:35 +02006733 for (u = 0; substmts[u].stmt; ++u) {
6734 if (substmts[u].stmt == stmt->kw) {
6735 break;
6736 }
6737 }
6738 if (!substmts[u].stmt) {
Radek Krejciad5963b2019-09-06 16:03:05 +02006739 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid keyword \"%s\" as a child of \"%s%s%s\" extension instance.",
6740 stmt->stmt, ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
Radek Krejci335332a2019-09-05 13:03:35 +02006741 goto cleanup;
6742 }
Radek Krejci335332a2019-09-05 13:03:35 +02006743 }
6744
Radek Krejciad5963b2019-09-06 16:03:05 +02006745 /* TODO store inherited data, e.g. status first, but mark them somehow to allow to overwrite them and not detect duplicity */
6746
Radek Krejci335332a2019-09-05 13:03:35 +02006747 /* keep order of the processing the same as the order in the defined substmts,
6748 * the order is important for some of the statements depending on others (e.g. type needs status and units) */
6749 for (u = 0; substmts[u].stmt; ++u) {
Radek Krejciad5963b2019-09-06 16:03:05 +02006750 int stmt_present = 0;
6751
Radek Krejci335332a2019-09-05 13:03:35 +02006752 for (stmt = ext->child; stmt; stmt = stmt->next) {
6753 if (substmts[u].stmt != stmt->kw) {
6754 continue;
6755 }
6756
Radek Krejciad5963b2019-09-06 16:03:05 +02006757 stmt_present = 1;
Radek Krejci335332a2019-09-05 13:03:35 +02006758 if (substmts[u].storage) {
6759 switch (stmt->kw) {
Radek Krejciad5963b2019-09-06 16:03:05 +02006760 case LY_STMT_STATUS:
6761 assert(substmts[u].cardinality < LY_STMT_CARD_SOME);
6762 LY_CHECK_ERR_GOTO(r = lysp_stmt_parse(ctx, stmt, stmt->kw, &substmts[u].storage, /* TODO */ NULL), ret = r, cleanup);
6763 break;
6764 case LY_STMT_UNITS: {
6765 const char **units;
6766
6767 if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
6768 /* single item */
6769 if (*((const char **)substmts[u].storage)) {
6770 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPSTMT, stmt->stmt);
6771 goto cleanup;
6772 }
6773 units = (const char **)substmts[u].storage;
6774 } else {
6775 /* sized array */
6776 const char ***units_array = (const char ***)substmts[u].storage;
6777 LY_ARRAY_NEW_GOTO(ctx->ctx, *units_array, units, ret, cleanup);
6778 }
6779 *units = lydict_insert(ctx->ctx, stmt->arg, 0);
6780 break;
6781 }
Radek Krejci335332a2019-09-05 13:03:35 +02006782 case LY_STMT_TYPE: {
6783 uint16_t *flags = lys_compile_extension_instance_storage(LY_STMT_STATUS, substmts);
6784 const char **units = lys_compile_extension_instance_storage(LY_STMT_UNITS, substmts);
6785
6786 if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
6787 /* single item */
Radek Krejciad5963b2019-09-06 16:03:05 +02006788 if (*(struct lysc_type**)substmts[u].storage) {
Radek Krejci335332a2019-09-05 13:03:35 +02006789 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPSTMT, stmt->stmt);
6790 goto cleanup;
6791 }
6792 compiled = substmts[u].storage;
6793 } else {
6794 /* sized array */
6795 struct lysc_type ***types = (struct lysc_type***)substmts[u].storage, **type = NULL;
6796 LY_ARRAY_NEW_GOTO(ctx->ctx, *types, type, ret, cleanup);
6797 compiled = (void*)type;
6798 }
6799
Radek Krejciad5963b2019-09-06 16:03:05 +02006800 LY_CHECK_ERR_GOTO(r = lysp_stmt_parse(ctx, stmt, stmt->kw, &parsed, NULL), ret = r, cleanup);
Radek Krejci335332a2019-09-05 13:03:35 +02006801 LY_CHECK_ERR_GOTO(r = lys_compile_type(ctx, ext->parent_type == LYEXT_PAR_NODE ? ((struct lysc_node*)ext->parent)->sp : NULL,
6802 flags ? *flags : 0, ctx->mod_def->parsed, ext->name, parsed, (struct lysc_type**)compiled,
Radek Krejci38d85362019-09-05 16:26:38 +02006803 units && !*units ? units : NULL), lysp_type_free(ctx->ctx, parsed); free(parsed); ret = r, cleanup);
6804 lysp_type_free(ctx->ctx, parsed);
6805 free(parsed);
Radek Krejci335332a2019-09-05 13:03:35 +02006806 break;
6807 }
Radek Krejciad5963b2019-09-06 16:03:05 +02006808 case LY_STMT_IF_FEATURE: {
6809 struct lysc_iffeature *iff = NULL;
6810
6811 if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
6812 /* single item */
6813 if (((struct lysc_iffeature*)substmts[u].storage)->features) {
6814 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPSTMT, stmt->stmt);
6815 goto cleanup;
6816 }
6817 iff = (struct lysc_iffeature*)substmts[u].storage;
6818 } else {
6819 /* sized array */
6820 struct lysc_iffeature **iffs = (struct lysc_iffeature**)substmts[u].storage;
6821 LY_ARRAY_NEW_GOTO(ctx->ctx, *iffs, iff, ret, cleanup);
6822 }
6823 LY_CHECK_ERR_GOTO(r = lys_compile_iffeature(ctx, &stmt->arg, iff), ret = r, cleanup);
6824 break;
6825 }
6826 /* TODO support other substatements (parse stmt to lysp and then compile lysp to lysc),
6827 * also note that in many statements their extensions are not taken into account */
Radek Krejci335332a2019-09-05 13:03:35 +02006828 default:
Radek Krejciad5963b2019-09-06 16:03:05 +02006829 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Statement \"%s\" is not supported as an extension (found in \"%s%s%s\") substatement.",
6830 stmt->stmt, ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
Radek Krejci335332a2019-09-05 13:03:35 +02006831 goto cleanup;
6832 }
6833 }
Radek Krejci335332a2019-09-05 13:03:35 +02006834 }
Radek Krejci335332a2019-09-05 13:03:35 +02006835
Radek Krejciad5963b2019-09-06 16:03:05 +02006836 if ((substmts[u].cardinality == LY_STMT_CARD_MAND || substmts[u].cardinality == LY_STMT_CARD_SOME) && !stmt_present) {
6837 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Missing mandatory keyword \"%s\" as a child of \"%s%s%s\".",
6838 ly_stmt2str(substmts[u].stmt), ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
6839 goto cleanup;
6840 }
Radek Krejci335332a2019-09-05 13:03:35 +02006841 }
6842
6843 ret = LY_SUCCESS;
6844
6845cleanup:
Radek Krejci335332a2019-09-05 13:03:35 +02006846 return ret;
6847}
6848
Michal Vasko175012e2019-11-06 15:49:14 +01006849/**
Michal Vaskoecd62de2019-11-13 12:35:11 +01006850 * @brief Check when for cyclic dependencies.
6851 * @param[in] set Set with all the referenced nodes.
6852 * @param[in] node Node whose "when" referenced nodes are in @p set.
6853 * @return LY_ERR value
6854 */
6855static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02006856lys_compile_unres_when_cyclic(struct lyxp_set *set, const struct lysc_node *node)
Michal Vaskoecd62de2019-11-13 12:35:11 +01006857{
6858 struct lyxp_set tmp_set;
6859 struct lyxp_set_scnode *xp_scnode;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02006860 uint32_t i, j;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02006861 LY_ARRAY_COUNT_TYPE u;
Michal Vaskoecd62de2019-11-13 12:35:11 +01006862 int idx;
6863 struct lysc_when *when;
6864 LY_ERR ret = LY_SUCCESS;
6865
6866 memset(&tmp_set, 0, sizeof tmp_set);
6867
6868 /* prepare in_ctx of the set */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02006869 for ( i = 0; i < set->used; ++i) {
Michal Vaskoecd62de2019-11-13 12:35:11 +01006870 xp_scnode = &set->val.scnodes[i];
6871
Michal Vasko5c4e5892019-11-14 12:31:38 +01006872 if (xp_scnode->in_ctx != -1) {
6873 /* check node when, skip the context node (it was just checked) */
Michal Vaskoecd62de2019-11-13 12:35:11 +01006874 xp_scnode->in_ctx = 1;
6875 }
6876 }
6877
6878 for (i = 0; i < set->used; ++i) {
6879 xp_scnode = &set->val.scnodes[i];
6880 if (xp_scnode->in_ctx != 1) {
6881 /* already checked */
6882 continue;
6883 }
6884
Michal Vasko1bf09392020-03-27 12:38:10 +01006885 if ((xp_scnode->type != LYXP_NODE_ELEM) || (xp_scnode->scnode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF))
Michal Vasko2ff7efe2019-12-10 14:50:59 +01006886 || !xp_scnode->scnode->when) {
Michal Vaskoecd62de2019-11-13 12:35:11 +01006887 /* no when to check */
6888 xp_scnode->in_ctx = 0;
6889 continue;
6890 }
6891
6892 node = xp_scnode->scnode;
6893 do {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02006894 LY_ARRAY_FOR(node->when, u) {
6895 when = node->when[u];
Michal Vasko52927e22020-03-16 17:26:14 +01006896 ret = lyxp_atomize(when->cond, LYD_SCHEMA, when->module, when->context,
Michal Vaskoecd62de2019-11-13 12:35:11 +01006897 when->context ? LYXP_NODE_ELEM : LYXP_NODE_ROOT_CONFIG, &tmp_set, LYXP_SCNODE_SCHEMA);
6898 if (ret != LY_SUCCESS) {
Michal Vaskof6e51882019-12-16 09:59:45 +01006899 LOGVAL(set->ctx, LY_VLOG_LYSC, node, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when->cond->expr);
Michal Vaskoecd62de2019-11-13 12:35:11 +01006900 goto cleanup;
6901 }
6902
Radek Krejci7eb54ba2020-05-18 16:30:04 +02006903 for (j = 0; j < tmp_set.used; ++j) {
Michal Vaskoecd62de2019-11-13 12:35:11 +01006904 /* skip roots'n'stuff */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02006905 if (tmp_set.val.scnodes[j].type == LYXP_NODE_ELEM) {
Michal Vaskoecd62de2019-11-13 12:35:11 +01006906 /* try to find this node in our set */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02006907 idx = lyxp_set_scnode_dup_node_check(set, tmp_set.val.scnodes[j].scnode, LYXP_NODE_ELEM, -1);
Michal Vasko5c4e5892019-11-14 12:31:38 +01006908 if ((idx > -1) && (set->val.scnodes[idx].in_ctx == -1)) {
Michal Vaskof6e51882019-12-16 09:59:45 +01006909 LOGVAL(set->ctx, LY_VLOG_LYSC, node, LY_VCODE_CIRC_WHEN, node->name, set->val.scnodes[idx].scnode->name);
Michal Vaskoecd62de2019-11-13 12:35:11 +01006910 ret = LY_EVALID;
6911 goto cleanup;
6912 }
6913
6914 /* needs to be checked, if in both sets, will be ignored */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02006915 tmp_set.val.scnodes[j].in_ctx = 1;
Michal Vaskoecd62de2019-11-13 12:35:11 +01006916 } else {
6917 /* no when, nothing to check */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02006918 tmp_set.val.scnodes[j].in_ctx = 0;
Michal Vaskoecd62de2019-11-13 12:35:11 +01006919 }
6920 }
6921
6922 /* merge this set into the global when set */
6923 lyxp_set_scnode_merge(set, &tmp_set);
6924 }
6925
6926 /* check when of non-data parents as well */
6927 node = node->parent;
6928 } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE)));
6929
Michal Vasko251f56e2019-11-14 16:06:47 +01006930 /* this node when was checked (xp_scnode could have been reallocd) */
6931 set->val.scnodes[i].in_ctx = -1;
Michal Vaskoecd62de2019-11-13 12:35:11 +01006932 }
6933
6934cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02006935 lyxp_set_free_content(&tmp_set);
Michal Vaskoecd62de2019-11-13 12:35:11 +01006936 return ret;
6937}
6938
6939/**
Michal Vasko175012e2019-11-06 15:49:14 +01006940 * @brief Check when/must expressions of a node on a compiled schema tree.
6941 * @param[in] ctx Compile context.
6942 * @param[in] node Node to check.
6943 * @return LY_ERR value
6944 */
6945static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02006946lys_compile_unres_xpath(struct lysc_ctx *ctx, const struct lysc_node *node)
Michal Vasko175012e2019-11-06 15:49:14 +01006947{
Michal Vasko175012e2019-11-06 15:49:14 +01006948 struct lyxp_set tmp_set;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02006949 uint32_t i;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02006950 LY_ARRAY_COUNT_TYPE u;
Michal Vasko5d8756a2019-11-07 15:21:00 +01006951 int opts, input_done = 0;
Michal Vasko175012e2019-11-06 15:49:14 +01006952 struct lysc_when **when = NULL;
6953 struct lysc_must *musts = NULL;
6954 LY_ERR ret = LY_SUCCESS;
Michal Vasko6b26e742020-07-17 15:02:10 +02006955 const struct lysc_node *op;
Michal Vasko175012e2019-11-06 15:49:14 +01006956
6957 memset(&tmp_set, 0, sizeof tmp_set);
Michal Vasko5d8756a2019-11-07 15:21:00 +01006958 opts = LYXP_SCNODE_SCHEMA;
Michal Vasko6b26e742020-07-17 15:02:10 +02006959 if (node->flags & LYS_CONFIG_R) {
6960 for (op = node->parent; op && !(op->nodetype & (LYS_RPC | LYS_ACTION)); op = op->parent);
6961 if (op) {
6962 /* we are actually in output */
6963 opts = LYXP_SCNODE_OUTPUT;
6964 }
6965 }
Michal Vasko175012e2019-11-06 15:49:14 +01006966
6967 switch (node->nodetype) {
6968 case LYS_CONTAINER:
6969 when = ((struct lysc_node_container *)node)->when;
6970 musts = ((struct lysc_node_container *)node)->musts;
6971 break;
6972 case LYS_CHOICE:
6973 when = ((struct lysc_node_choice *)node)->when;
6974 break;
6975 case LYS_LEAF:
6976 when = ((struct lysc_node_leaf *)node)->when;
6977 musts = ((struct lysc_node_leaf *)node)->musts;
6978 break;
6979 case LYS_LEAFLIST:
6980 when = ((struct lysc_node_leaflist *)node)->when;
6981 musts = ((struct lysc_node_leaflist *)node)->musts;
6982 break;
6983 case LYS_LIST:
6984 when = ((struct lysc_node_list *)node)->when;
6985 musts = ((struct lysc_node_list *)node)->musts;
6986 break;
6987 case LYS_ANYXML:
6988 case LYS_ANYDATA:
6989 when = ((struct lysc_node_anydata *)node)->when;
6990 musts = ((struct lysc_node_anydata *)node)->musts;
6991 break;
6992 case LYS_CASE:
6993 when = ((struct lysc_node_case *)node)->when;
6994 break;
6995 case LYS_NOTIF:
6996 musts = ((struct lysc_notif *)node)->musts;
6997 break;
Michal Vasko1bf09392020-03-27 12:38:10 +01006998 case LYS_RPC:
Michal Vasko5d8756a2019-11-07 15:21:00 +01006999 case LYS_ACTION:
7000 /* first process input musts */
7001 musts = ((struct lysc_action *)node)->input.musts;
7002 break;
Michal Vasko175012e2019-11-06 15:49:14 +01007003 default:
7004 /* nothing to check */
7005 break;
7006 }
7007
Michal Vasko175012e2019-11-06 15:49:14 +01007008 /* check "when" */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02007009 LY_ARRAY_FOR(when, u) {
Michal Vasko004d3152020-06-11 19:59:22 +02007010 ret = lyxp_atomize(when[u]->cond, LYD_SCHEMA, when[u]->module, when[u]->context ? when[u]->context : node,
Radek Krejci7eb54ba2020-05-18 16:30:04 +02007011 when[u]->context ? LYXP_NODE_ELEM : LYXP_NODE_ROOT_CONFIG, &tmp_set, opts);
Michal Vasko175012e2019-11-06 15:49:14 +01007012 if (ret != LY_SUCCESS) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02007013 LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when[u]->cond->expr);
Michal Vasko175012e2019-11-06 15:49:14 +01007014 goto cleanup;
7015 }
7016
Michal Vaskodc052f32019-11-07 11:11:38 +01007017 ctx->path[0] = '\0';
7018 lysc_path((struct lysc_node *)node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02007019 for (i = 0; i < tmp_set.used; ++i) {
Michal Vasko5c4e5892019-11-14 12:31:38 +01007020 /* skip roots'n'stuff */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02007021 if ((tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (tmp_set.val.scnodes[i].in_ctx != -1)) {
7022 struct lysc_node *schema = tmp_set.val.scnodes[i].scnode;
Michal Vasko175012e2019-11-06 15:49:14 +01007023
Michal Vaskoecd62de2019-11-13 12:35:11 +01007024 /* XPath expression cannot reference "lower" status than the node that has the definition */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02007025 ret = lysc_check_status(ctx, when[u]->flags, when[u]->module, node->name, schema->flags, schema->module,
Michal Vaskoecd62de2019-11-13 12:35:11 +01007026 schema->name);
7027 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko5c4e5892019-11-14 12:31:38 +01007028
7029 /* check dummy node accessing */
7030 if (schema == node) {
Michal Vaskof6e51882019-12-16 09:59:45 +01007031 LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LY_VCODE_DUMMY_WHEN, node->name);
Michal Vasko5c4e5892019-11-14 12:31:38 +01007032 ret = LY_EVALID;
7033 goto cleanup;
7034 }
Michal Vasko175012e2019-11-06 15:49:14 +01007035 }
7036 }
7037
Michal Vaskoecd62de2019-11-13 12:35:11 +01007038 /* check cyclic dependencies */
Michal Vasko004d3152020-06-11 19:59:22 +02007039 ret = lys_compile_unres_when_cyclic(&tmp_set, node);
Michal Vaskoecd62de2019-11-13 12:35:11 +01007040 LY_CHECK_GOTO(ret, cleanup);
7041
Michal Vaskod3678892020-05-21 10:06:58 +02007042 lyxp_set_free_content(&tmp_set);
Michal Vasko175012e2019-11-06 15:49:14 +01007043 }
7044
Michal Vasko5d8756a2019-11-07 15:21:00 +01007045check_musts:
Michal Vasko175012e2019-11-06 15:49:14 +01007046 /* check "must" */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02007047 LY_ARRAY_FOR(musts, u) {
7048 ret = lyxp_atomize(musts[u].cond, LYD_SCHEMA, musts[u].module, node, LYXP_NODE_ELEM, &tmp_set, opts);
Michal Vasko175012e2019-11-06 15:49:14 +01007049 if (ret != LY_SUCCESS) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02007050 LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_SEMANTICS, "Invalid must restriction \"%s\".", musts[u].cond->expr);
Michal Vasko175012e2019-11-06 15:49:14 +01007051 goto cleanup;
7052 }
7053
Michal Vaskodc052f32019-11-07 11:11:38 +01007054 ctx->path[0] = '\0';
7055 lysc_path((struct lysc_node *)node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02007056 for (i = 0; i < tmp_set.used; ++i) {
Michal Vasko175012e2019-11-06 15:49:14 +01007057 /* skip roots'n'stuff */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02007058 if (tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko175012e2019-11-06 15:49:14 +01007059 /* XPath expression cannot reference "lower" status than the node that has the definition */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02007060 ret = lysc_check_status(ctx, node->flags, musts[u].module, node->name, tmp_set.val.scnodes[i].scnode->flags,
7061 tmp_set.val.scnodes[i].scnode->module, tmp_set.val.scnodes[i].scnode->name);
Michal Vasko175012e2019-11-06 15:49:14 +01007062 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko175012e2019-11-06 15:49:14 +01007063 }
7064 }
7065
Michal Vaskod3678892020-05-21 10:06:58 +02007066 lyxp_set_free_content(&tmp_set);
Michal Vasko175012e2019-11-06 15:49:14 +01007067 }
7068
Michal Vasko1bf09392020-03-27 12:38:10 +01007069 if ((node->nodetype & (LYS_RPC | LYS_ACTION)) && !input_done) {
Michal Vasko5d8756a2019-11-07 15:21:00 +01007070 /* now check output musts */
7071 input_done = 1;
7072 musts = ((struct lysc_action *)node)->output.musts;
7073 opts = LYXP_SCNODE_OUTPUT;
7074 goto check_musts;
7075 }
7076
Michal Vasko175012e2019-11-06 15:49:14 +01007077cleanup:
Michal Vaskod3678892020-05-21 10:06:58 +02007078 lyxp_set_free_content(&tmp_set);
Michal Vasko175012e2019-11-06 15:49:14 +01007079 return ret;
7080}
7081
Michal Vasko8d544252020-03-02 10:19:52 +01007082static LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +02007083lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, struct lysc_type_leafref *lref)
7084{
Michal Vasko6b26e742020-07-17 15:02:10 +02007085 const struct lysc_node *target = NULL, *siter;
Michal Vasko004d3152020-06-11 19:59:22 +02007086 struct ly_path *p;
7087 struct lysc_type *type;
7088
7089 assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
7090
7091 /* try to find the target */
Michal Vasko00cbf532020-06-15 13:58:47 +02007092 LY_CHECK_RET(ly_path_compile(ctx->ctx, node->module, node, lref->path, LY_PATH_LREF_TRUE,
7093 lysc_is_output(node) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
7094 lys_resolve_prefix, lref->path_context, LYD_SCHEMA, &p));
Michal Vasko004d3152020-06-11 19:59:22 +02007095
7096 /* get the target node */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02007097 target = p[LY_ARRAY_COUNT(p) - 1].node;
Michal Vasko004d3152020-06-11 19:59:22 +02007098 ly_path_free(node->module->ctx, p);
7099
7100 if (!(target->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
7101 LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_REFERENCE,
7102 "Invalid leafref path \"%s\" - target node is %s instead of leaf or leaf-list.",
7103 lref->path->expr, lys_nodetype2str(target->nodetype));
7104 return LY_EVALID;
7105 }
7106
7107 /* check status */
7108 ctx->path[0] = '\0';
7109 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
7110 ctx->path_len = strlen(ctx->path);
7111 if (lysc_check_status(ctx, node->flags, node->module, node->name, target->flags, target->module, target->name)) {
7112 return LY_EVALID;
7113 }
7114 ctx->path_len = 1;
7115 ctx->path[1] = '\0';
7116
7117 /* check config */
Michal Vasko6b26e742020-07-17 15:02:10 +02007118 if (lref->require_instance) {
7119 for (siter = node->parent; siter && !(siter->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); siter = siter->parent);
7120 if (!siter && (node->flags & LYS_CONFIG_W) && (target->flags & LYS_CONFIG_R)) {
Michal Vasko004d3152020-06-11 19:59:22 +02007121 LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target is supposed"
7122 " to represent configuration data (as the leafref does), but it does not.", lref->path->expr);
7123 return LY_EVALID;
7124 }
7125 }
7126
7127 /* store the target's type and check for circular chain of leafrefs */
7128 lref->realtype = ((struct lysc_node_leaf *)target)->type;
7129 for (type = lref->realtype; type && type->basetype == LY_TYPE_LEAFREF; type = ((struct lysc_type_leafref *)type)->realtype) {
7130 if (type == (struct lysc_type *)lref) {
7131 /* circular chain detected */
7132 LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_REFERENCE,
7133 "Invalid leafref path \"%s\" - circular chain of leafrefs detected.", lref->path->expr);
7134 return LY_EVALID;
7135 }
7136 }
7137
7138 /* check if leafref and its target are under common if-features */
7139 if (lys_compile_leafref_features_validate(node, target)) {
7140 LOGVAL(ctx->ctx, LY_VLOG_LYSC, node, LYVE_REFERENCE,
7141 "Invalid leafref path \"%s\" - set of features applicable to the leafref target is not a subset of"
7142 " features applicable to the leafref itself.", lref->path->expr);
7143 return LY_EVALID;
7144 }
7145
7146 return LY_SUCCESS;
7147}
7148
7149static LY_ERR
Michal Vasko8d544252020-03-02 10:19:52 +01007150lys_compile_ietf_netconf_wd_annotation(struct lysc_ctx *ctx, struct lys_module *mod)
7151{
7152 struct lysc_ext_instance *ext;
7153 struct lysp_ext_instance *ext_p = NULL;
7154 struct lysp_stmt *stmt;
7155 const struct lys_module *ext_mod;
7156 LY_ERR ret = LY_SUCCESS;
7157
7158 /* create the parsed extension instance manually */
7159 ext_p = calloc(1, sizeof *ext_p);
7160 LY_CHECK_ERR_GOTO(!ext_p, LOGMEM(ctx->ctx); ret = LY_EMEM, cleanup);
7161 ext_p->name = lydict_insert(ctx->ctx, "md:annotation", 0);
7162 ext_p->argument = lydict_insert(ctx->ctx, "default", 0);
7163 ext_p->insubstmt = LYEXT_SUBSTMT_SELF;
7164 ext_p->insubstmt_index = 0;
7165
7166 stmt = calloc(1, sizeof *ext_p->child);
7167 stmt->stmt = lydict_insert(ctx->ctx, "type", 0);
7168 stmt->arg = lydict_insert(ctx->ctx, "boolean", 0);
7169 stmt->kw = LY_STMT_TYPE;
7170 ext_p->child = stmt;
7171
7172 /* allocate new extension instance */
7173 LY_ARRAY_NEW_GOTO(mod->ctx, mod->compiled->exts, ext, ret, cleanup);
7174
7175 /* manually get extension definition module */
7176 ext_mod = ly_ctx_get_module_latest(ctx->ctx, "ietf-yang-metadata");
7177
7178 /* compile the extension instance */
7179 LY_CHECK_GOTO(ret = lys_compile_ext(ctx, ext_p, ext, mod->compiled, LYEXT_PAR_MODULE, ext_mod), cleanup);
7180
7181cleanup:
7182 lysp_ext_instance_free(ctx->ctx, ext_p);
7183 free(ext_p);
7184 return ret;
7185}
7186
Michal Vasko004d3152020-06-11 19:59:22 +02007187static LY_ERR
7188lys_compile_unres(struct lysc_ctx *ctx)
7189{
7190 struct lysc_node *node;
7191 struct lysc_type *type, *typeiter;
7192 struct lysc_type_leafref *lref;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02007193 LY_ARRAY_COUNT_TYPE v;
Michal Vasko004d3152020-06-11 19:59:22 +02007194 uint32_t i;
7195
7196 /* for leafref, we need 2 rounds - first detects circular chain by storing the first referred type (which
7197 * can be also leafref, in case it is already resolved, go through the chain and check that it does not
7198 * point to the starting leafref type). The second round stores the first non-leafref type for later data validation. */
7199 for (i = 0; i < ctx->leafrefs.count; ++i) {
7200 node = ctx->leafrefs.objs[i];
7201 assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
7202 type = ((struct lysc_node_leaf *)node)->type;
7203 if (type->basetype == LY_TYPE_LEAFREF) {
7204 LY_CHECK_RET(lys_compile_unres_leafref(ctx, node, (struct lysc_type_leafref *)type));
7205 } else if (type->basetype == LY_TYPE_UNION) {
7206 LY_ARRAY_FOR(((struct lysc_type_union *)type)->types, v) {
7207 if (((struct lysc_type_union *)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
7208 lref = (struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v];
7209 LY_CHECK_RET(lys_compile_unres_leafref(ctx, node, lref));
7210 }
7211 }
7212 }
7213 }
7214 for (i = 0; i < ctx->leafrefs.count; ++i) {
7215 /* store pointer to the real type */
7216 type = ((struct lysc_node_leaf *)ctx->leafrefs.objs[i])->type;
7217 if (type->basetype == LY_TYPE_LEAFREF) {
7218 for (typeiter = ((struct lysc_type_leafref*)type)->realtype;
7219 typeiter->basetype == LY_TYPE_LEAFREF;
7220 typeiter = ((struct lysc_type_leafref*)typeiter)->realtype);
7221 ((struct lysc_type_leafref*)type)->realtype = typeiter;
7222 } else if (type->basetype == LY_TYPE_UNION) {
7223 LY_ARRAY_FOR(((struct lysc_type_union*)type)->types, v) {
7224 if (((struct lysc_type_union*)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
7225 for (typeiter = ((struct lysc_type_leafref*)((struct lysc_type_union*)type)->types[v])->realtype;
7226 typeiter->basetype == LY_TYPE_LEAFREF;
7227 typeiter = ((struct lysc_type_leafref*)typeiter)->realtype);
7228 ((struct lysc_type_leafref*)((struct lysc_type_union*)type)->types[v])->realtype = typeiter;
7229 }
7230 }
7231 }
7232 }
7233
7234 /* check xpath */
7235 for (i = 0; i < ctx->xpath.count; ++i) {
7236 LY_CHECK_RET(lys_compile_unres_xpath(ctx, ctx->xpath.objs[i]));
7237 }
7238
7239 /* finish incomplete default values compilation */
7240 for (i = 0; i < ctx->dflts.count; ++i) {
7241 struct ly_err_item *err = NULL;
7242 struct lysc_incomplete_dflt *r = ctx->dflts.objs[i];
7243 LY_ERR ret;
7244 ret = r->dflt->realtype->plugin->store(ctx->ctx, r->dflt->realtype, r->dflt->original, strlen(r->dflt->original),
7245 LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE | LY_TYPE_OPTS_SECOND_CALL, lys_resolve_prefix,
7246 (void*)r->dflt_mod, LYD_XML, r->context_node, NULL, r->dflt, NULL, &err);
7247 if (err) {
7248 ly_err_print(err);
7249 ctx->path[0] = '\0';
7250 lysc_path(r->context_node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
7251 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
7252 "Invalid default - value does not fit the type (%s).", err->msg);
7253 ly_err_free(err);
7254 }
7255 LY_CHECK_RET(ret);
7256 }
7257
7258 return LY_SUCCESS;
7259}
7260
Radek Krejci19a96102018-11-15 13:38:09 +01007261LY_ERR
Radek Krejcif0e1ba52020-05-22 15:14:35 +02007262lys_compile(struct lys_module **mod, int options)
Radek Krejci19a96102018-11-15 13:38:09 +01007263{
7264 struct lysc_ctx ctx = {0};
7265 struct lysc_module *mod_c;
7266 struct lysp_module *sp;
7267 struct lysp_node *node_p;
Radek Krejci95710c92019-02-11 15:49:55 +01007268 struct lysp_augment **augments = NULL;
Radek Krejcif2de0ed2019-05-02 14:13:18 +02007269 struct lysp_grp *grps;
Radek Krejci95710c92019-02-11 15:49:55 +01007270 struct lys_module *m;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02007271 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02007272 uint32_t i;
Radek Krejcia46012b2020-08-12 15:41:04 +02007273 uint16_t compile_id;
Radek Krejcid05cbd92018-12-05 14:26:40 +01007274 LY_ERR ret = LY_SUCCESS;
Radek Krejci19a96102018-11-15 13:38:09 +01007275
Radek Krejcif0e1ba52020-05-22 15:14:35 +02007276 LY_CHECK_ARG_RET(NULL, mod, *mod, (*mod)->parsed, (*mod)->ctx, LY_EINVAL);
Radek Krejci096235c2019-01-11 11:12:19 +01007277
Radek Krejcif0e1ba52020-05-22 15:14:35 +02007278 if (!(*mod)->implemented) {
Radek Krejci096235c2019-01-11 11:12:19 +01007279 /* just imported modules are not compiled */
7280 return LY_SUCCESS;
7281 }
7282
Radek Krejcia46012b2020-08-12 15:41:04 +02007283 compile_id = ++(*mod)->ctx->module_set_id;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02007284 sp = (*mod)->parsed;
Radek Krejci19a96102018-11-15 13:38:09 +01007285
Radek Krejcif0e1ba52020-05-22 15:14:35 +02007286 ctx.ctx = (*mod)->ctx;
7287 ctx.mod = *mod;
7288 ctx.mod_def = *mod;
Radek Krejciec4da802019-05-02 13:02:41 +02007289 ctx.options = options;
Radek Krejci327de162019-06-14 12:52:07 +02007290 ctx.path_len = 1;
7291 ctx.path[0] = '/';
Radek Krejci19a96102018-11-15 13:38:09 +01007292
Radek Krejcif0e1ba52020-05-22 15:14:35 +02007293 (*mod)->compiled = mod_c = calloc(1, sizeof *mod_c);
7294 LY_CHECK_ERR_RET(!mod_c, LOGMEM((*mod)->ctx), LY_EMEM);
7295 mod_c->mod = *mod;
Radek Krejci19a96102018-11-15 13:38:09 +01007296
Michal Vasko7c8439f2020-08-05 13:25:19 +02007297 LY_ARRAY_FOR(sp->imports, u) {
7298 LY_CHECK_GOTO(ret = lys_compile_import(&ctx, &sp->imports[u]), error);
7299 }
Radek Krejcid05cbd92018-12-05 14:26:40 +01007300 LY_ARRAY_FOR(sp->includes, u) {
Michal Vasko7c8439f2020-08-05 13:25:19 +02007301 LY_CHECK_GOTO(ret = lys_compile_submodule(&ctx, &sp->includes[u]), error);
Radek Krejcid05cbd92018-12-05 14:26:40 +01007302 }
Radek Krejci0935f412019-08-20 16:15:18 +02007303
7304 /* features */
Michal Vasko33ff9422020-07-03 09:50:39 +02007305 if ((*mod)->dis_features) {
Radek Krejci0af46292019-01-11 16:02:31 +01007306 /* there is already precompiled array of features */
Michal Vasko33ff9422020-07-03 09:50:39 +02007307 mod_c->features = (*mod)->dis_features;
7308 (*mod)->dis_features = NULL;
Radek Krejci0af46292019-01-11 16:02:31 +01007309 } else {
7310 /* features are compiled directly into the compiled module structure,
7311 * but it must be done in two steps to allow forward references (via if-feature) between the features themselves */
Radek Krejci327de162019-06-14 12:52:07 +02007312 ret = lys_feature_precompile(&ctx, NULL, NULL, sp->features, &mod_c->features);
Radek Krejci0af46292019-01-11 16:02:31 +01007313 LY_CHECK_GOTO(ret, error);
7314 }
Michal Vasko33ff9422020-07-03 09:50:39 +02007315
Radek Krejci0af46292019-01-11 16:02:31 +01007316 /* finish feature compilation, not only for the main module, but also for the submodules.
7317 * Due to possible forward references, it must be done when all the features (including submodules)
7318 * are present. */
7319 LY_ARRAY_FOR(sp->features, u) {
Radek Krejciec4da802019-05-02 13:02:41 +02007320 ret = lys_feature_precompile_finish(&ctx, &sp->features[u], mod_c->features);
Radek Krejci0af46292019-01-11 16:02:31 +01007321 LY_CHECK_GOTO(ret != LY_SUCCESS, error);
7322 }
Radek Krejci327de162019-06-14 12:52:07 +02007323 lysc_update_path(&ctx, NULL, "{submodule}");
Radek Krejci0af46292019-01-11 16:02:31 +01007324 LY_ARRAY_FOR(sp->includes, v) {
Radek Krejci327de162019-06-14 12:52:07 +02007325 lysc_update_path(&ctx, NULL, sp->includes[v].name);
Radek Krejci0af46292019-01-11 16:02:31 +01007326 LY_ARRAY_FOR(sp->includes[v].submodule->features, u) {
Radek Krejciec4da802019-05-02 13:02:41 +02007327 ret = lys_feature_precompile_finish(&ctx, &sp->includes[v].submodule->features[u], mod_c->features);
Radek Krejci0af46292019-01-11 16:02:31 +01007328 LY_CHECK_GOTO(ret != LY_SUCCESS, error);
7329 }
Radek Krejci327de162019-06-14 12:52:07 +02007330 lysc_update_path(&ctx, NULL, NULL);
Radek Krejci0af46292019-01-11 16:02:31 +01007331 }
Radek Krejci327de162019-06-14 12:52:07 +02007332 lysc_update_path(&ctx, NULL, NULL);
Radek Krejci0af46292019-01-11 16:02:31 +01007333
Michal Vasko33ff9422020-07-03 09:50:39 +02007334 /* identities, work similarly to features with the precompilation */
7335 if ((*mod)->dis_identities) {
7336 mod_c->identities = (*mod)->dis_identities;
7337 (*mod)->dis_identities = NULL;
7338 } else {
7339 ret = lys_identity_precompile(&ctx, NULL, NULL, sp->identities, &mod_c->identities);
7340 LY_CHECK_GOTO(ret, error);
7341 }
Radek Krejci19a96102018-11-15 13:38:09 +01007342 if (sp->identities) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02007343 LY_CHECK_GOTO(ret = lys_compile_identities_derived(&ctx, sp->identities, mod_c->identities), error);
Radek Krejci19a96102018-11-15 13:38:09 +01007344 }
Michal Vasko33ff9422020-07-03 09:50:39 +02007345 lysc_update_path(&ctx, NULL, "{submodule}");
7346 LY_ARRAY_FOR(sp->includes, v) {
7347 if (sp->includes[v].submodule->identities) {
7348 lysc_update_path(&ctx, NULL, sp->includes[v].name);
7349 ret = lys_compile_identities_derived(&ctx, sp->includes[v].submodule->identities, mod_c->identities);
7350 LY_CHECK_GOTO(ret, error);
7351 lysc_update_path(&ctx, NULL, NULL);
7352 }
7353 }
Radek Krejci327de162019-06-14 12:52:07 +02007354 lysc_update_path(&ctx, NULL, NULL);
Radek Krejci19a96102018-11-15 13:38:09 +01007355
Radek Krejci95710c92019-02-11 15:49:55 +01007356 /* data nodes */
Radek Krejci19a96102018-11-15 13:38:09 +01007357 LY_LIST_FOR(sp->data, node_p) {
Radek Krejcid3acfce2019-09-09 14:48:50 +02007358 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, node_p, NULL, 0), error);
Radek Krejci19a96102018-11-15 13:38:09 +01007359 }
Radek Krejci95710c92019-02-11 15:49:55 +01007360
Radek Krejciec4da802019-05-02 13:02:41 +02007361 COMPILE_ARRAY1_GOTO(&ctx, sp->rpcs, mod_c->rpcs, NULL, u, lys_compile_action, 0, ret, error);
7362 COMPILE_ARRAY1_GOTO(&ctx, sp->notifs, mod_c->notifs, NULL, u, lys_compile_notif, 0, ret, error);
Radek Krejciccd20f12019-02-15 14:12:27 +01007363
Radek Krejci95710c92019-02-11 15:49:55 +01007364 /* augments - sort first to cover augments augmenting other augments */
Radek Krejcid3acfce2019-09-09 14:48:50 +02007365 LY_CHECK_GOTO(ret = lys_compile_augment_sort(&ctx, sp->augments, sp->includes, &augments), error);
Radek Krejci95710c92019-02-11 15:49:55 +01007366 LY_ARRAY_FOR(augments, u) {
Radek Krejcid3acfce2019-09-09 14:48:50 +02007367 LY_CHECK_GOTO(ret = lys_compile_augment(&ctx, augments[u], NULL), error);
Radek Krejci95710c92019-02-11 15:49:55 +01007368 }
Radek Krejciccd20f12019-02-15 14:12:27 +01007369
Radek Krejci474f9b82019-07-24 11:36:37 +02007370 /* deviations TODO cover deviations from submodules */
Radek Krejcid3acfce2019-09-09 14:48:50 +02007371 LY_CHECK_GOTO(ret = lys_compile_deviations(&ctx, sp), error);
Radek Krejci19a96102018-11-15 13:38:09 +01007372
Radek Krejci0935f412019-08-20 16:15:18 +02007373 /* extension instances TODO cover extension instances from submodules */
7374 COMPILE_EXTS_GOTO(&ctx, sp->exts, mod_c->exts, mod_c, LYEXT_PAR_MODULE, ret, error);
Radek Krejci19a96102018-11-15 13:38:09 +01007375
Michal Vasko004d3152020-06-11 19:59:22 +02007376 /* finish compilation for all unresolved items in the context */
7377 LY_CHECK_GOTO(ret = lys_compile_unres(&ctx), error);
Radek Krejci474f9b82019-07-24 11:36:37 +02007378
Radek Krejcif2de0ed2019-05-02 14:13:18 +02007379 /* validate non-instantiated groupings from the parsed schema,
7380 * without it we would accept even the schemas with invalid grouping specification */
7381 ctx.options |= LYSC_OPT_GROUPING;
7382 LY_ARRAY_FOR(sp->groupings, u) {
7383 if (!(sp->groupings[u].flags & LYS_USED_GRP)) {
Radek Krejcid3acfce2019-09-09 14:48:50 +02007384 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, node_p, &sp->groupings[u]), error);
Radek Krejcif2de0ed2019-05-02 14:13:18 +02007385 }
7386 }
7387 LY_LIST_FOR(sp->data, node_p) {
7388 grps = (struct lysp_grp*)lysp_node_groupings(node_p);
7389 LY_ARRAY_FOR(grps, u) {
7390 if (!(grps[u].flags & LYS_USED_GRP)) {
Radek Krejcid3acfce2019-09-09 14:48:50 +02007391 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, node_p, &grps[u]), error);
Radek Krejcif2de0ed2019-05-02 14:13:18 +02007392 }
7393 }
7394 }
7395
Radek Krejci474f9b82019-07-24 11:36:37 +02007396 if (ctx.ctx->flags & LY_CTX_CHANGED_TREE) {
7397 /* TODO Deviation has changed tree of a module(s) in the context (by deviate-not-supported), it is necessary to recompile
7398 leafref paths, default values and must/when expressions in all schemas of the context to check that they are still valid */
7399 }
7400
Michal Vasko8d544252020-03-02 10:19:52 +01007401#if 0
7402 /* hack for NETCONF's edit-config's operation attribute. It is not defined in the schema, but since libyang
7403 * implements YANG metadata (annotations), we need its definition. Because the ietf-netconf schema is not the
7404 * internal part of libyang, we cannot add the annotation into the schema source, but we do it here to have
7405 * the anotation definitions available in the internal schema structure. */
7406 if (ly_strequal(mod->name, "ietf-netconf", 0)) {
7407 if (lyp_add_ietf_netconf_annotations(mod)) {
7408 lys_free(mod, NULL, 1, 1);
7409 return NULL;
7410 }
7411 }
7412#endif
7413
7414 /* add ietf-netconf-with-defaults "default" metadata to the compiled module */
Radek Krejcif0e1ba52020-05-22 15:14:35 +02007415 if (!strcmp((*mod)->name, "ietf-netconf-with-defaults")) {
7416 LY_CHECK_GOTO(ret = lys_compile_ietf_netconf_wd_annotation(&ctx, *mod), error);
Michal Vasko8d544252020-03-02 10:19:52 +01007417 }
7418
Radek Krejci1c0c3442019-07-23 16:08:47 +02007419 ly_set_erase(&ctx.dflts, free);
Michal Vasko004d3152020-06-11 19:59:22 +02007420 ly_set_erase(&ctx.xpath, NULL);
7421 ly_set_erase(&ctx.leafrefs, NULL);
Radek Krejcie86bf772018-12-14 11:39:53 +01007422 ly_set_erase(&ctx.groupings, NULL);
Radek Krejci99b5b2a2019-04-30 16:57:04 +02007423 ly_set_erase(&ctx.tpdf_chain, NULL);
Radek Krejci95710c92019-02-11 15:49:55 +01007424 LY_ARRAY_FREE(augments);
Radek Krejcia3045382018-11-22 14:30:31 +01007425
Radek Krejciec4da802019-05-02 13:02:41 +02007426 if (ctx.options & LYSC_OPT_FREE_SP) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02007427 lysp_module_free((*mod)->parsed);
7428 (*mod)->parsed = NULL;
Radek Krejci19a96102018-11-15 13:38:09 +01007429 }
7430
Radek Krejciec4da802019-05-02 13:02:41 +02007431 if (!(ctx.options & LYSC_OPT_INTERNAL)) {
Radek Krejci95710c92019-02-11 15:49:55 +01007432 /* remove flag of the modules implemented by dependency */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02007433 for (i = 0; i < ctx.ctx->list.count; ++i) {
7434 m = ctx.ctx->list.objs[i];
Radek Krejcia46012b2020-08-12 15:41:04 +02007435 if (m->implemented > 1) {
Radek Krejci95710c92019-02-11 15:49:55 +01007436 m->implemented = 1;
7437 }
7438 }
7439 }
7440
Radek Krejci19a96102018-11-15 13:38:09 +01007441 return LY_SUCCESS;
7442
7443error:
Radek Krejcif0e1ba52020-05-22 15:14:35 +02007444 lys_feature_precompile_revert(&ctx, *mod);
Radek Krejci1c0c3442019-07-23 16:08:47 +02007445 ly_set_erase(&ctx.dflts, free);
Michal Vasko004d3152020-06-11 19:59:22 +02007446 ly_set_erase(&ctx.xpath, NULL);
7447 ly_set_erase(&ctx.leafrefs, NULL);
Radek Krejcie86bf772018-12-14 11:39:53 +01007448 ly_set_erase(&ctx.groupings, NULL);
Radek Krejci99b5b2a2019-04-30 16:57:04 +02007449 ly_set_erase(&ctx.tpdf_chain, NULL);
Radek Krejci95710c92019-02-11 15:49:55 +01007450 LY_ARRAY_FREE(augments);
Radek Krejci19a96102018-11-15 13:38:09 +01007451 lysc_module_free(mod_c, NULL);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02007452 (*mod)->compiled = NULL;
Radek Krejci95710c92019-02-11 15:49:55 +01007453
Radek Krejcia46012b2020-08-12 15:41:04 +02007454 /* revert compilation of modules implemented by dependency, but only by (directly or indirectly) by dependency
7455 * of this module, since this module can be also compiled from dependency, there can be some other modules being
7456 * processed and we are going to get back to them via stack, so freeing them is not a good idea. */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02007457 for (i = 0; i < ctx.ctx->list.count; ++i) {
7458 m = ctx.ctx->list.objs[i];
Radek Krejcia46012b2020-08-12 15:41:04 +02007459 if ((m->implemented >= compile_id) && m->compiled) {
Radek Krejci95710c92019-02-11 15:49:55 +01007460 /* revert features list to the precompiled state */
7461 lys_feature_precompile_revert(&ctx, m);
7462 /* mark module as imported-only / not-implemented */
7463 m->implemented = 0;
7464 /* free the compiled version of the module */
7465 lysc_module_free(m->compiled, NULL);
7466 m->compiled = NULL;
7467 }
7468 }
7469
Radek Krejcif0e1ba52020-05-22 15:14:35 +02007470 /* remove the module itself from the context and free it */
7471 ly_set_rm(&ctx.ctx->list, *mod, NULL);
7472 lys_module_free(*mod, NULL);
7473 *mod = NULL;
7474
Radek Krejci19a96102018-11-15 13:38:09 +01007475 return ret;
7476}