blob: fc957ba07e75c0d8723d4bbe84c321914f205973 [file] [log] [blame]
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001/**
2 * @file schema_compile.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief Schema compilation.
5 *
6 * Copyright (c) 2015 - 2020 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
15#define _GNU_SOURCE
16
17#include "schema_compile.h"
18
19#include <assert.h>
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020020#include <stddef.h>
21#include <stdint.h>
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
25
26#include "common.h"
27#include "compat.h"
28#include "context.h"
29#include "dict.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020030#include "in.h"
Radek Krejci47fab892020-11-05 17:02:41 +010031#include "log.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020032#include "parser_schema.h"
33#include "path.h"
34#include "plugins_exts.h"
35#include "plugins_exts_internal.h"
36#include "plugins_types.h"
37#include "schema_compile_amend.h"
38#include "schema_compile_node.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010039#include "schema_features.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020040#include "set.h"
41#include "tree.h"
42#include "tree_data.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020043#include "tree_schema.h"
44#include "tree_schema_internal.h"
45#include "xpath.h"
46
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020047/**
48 * @brief Fill in the prepared compiled extensions definition structure according to the parsed extension definition.
49 */
50static LY_ERR
51lys_compile_extension(struct lysc_ctx *ctx, const struct lys_module *ext_mod, struct lysp_ext *ext_p, struct lysc_ext **ext)
52{
53 LY_ERR ret = LY_SUCCESS;
54
55 if (!ext_p->compiled) {
56 lysc_update_path(ctx, NULL, "{extension}");
57 lysc_update_path(ctx, NULL, ext_p->name);
58
59 /* compile the extension definition */
60 ext_p->compiled = calloc(1, sizeof **ext);
61 ext_p->compiled->refcount = 1;
62 DUP_STRING_GOTO(ctx->ctx, ext_p->name, ext_p->compiled->name, ret, done);
63 DUP_STRING_GOTO(ctx->ctx, ext_p->argument, ext_p->compiled->argument, ret, done);
64 ext_p->compiled->module = (struct lys_module *)ext_mod;
65 COMPILE_EXTS_GOTO(ctx, ext_p->exts, ext_p->compiled->exts, *ext, LYEXT_PAR_EXT, ret, done);
66
67 lysc_update_path(ctx, NULL, NULL);
68 lysc_update_path(ctx, NULL, NULL);
69
70 /* find extension definition plugin */
71 ext_p->compiled->plugin = lyext_get_plugin(ext_p->compiled);
72 }
73
74 *ext = lysc_ext_dup(ext_p->compiled);
75
76done:
Radek Krejci2efc45b2020-12-22 16:25:44 +010077 if (ret) {
78 lysc_update_path(ctx, NULL, NULL);
79 lysc_update_path(ctx, NULL, NULL);
80 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020081 return ret;
82}
83
84LY_ERR
85lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext, void *parent,
86 LYEXT_PARENT parent_type, const struct lys_module *ext_mod)
87{
Michal Vaskofc2cd072021-02-24 13:17:17 +010088 LY_ERR r, ret = LY_SUCCESS;
89 const char *tmp, *name, *prefix;
90 size_t pref_len, name_len;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020091 LY_ARRAY_COUNT_TYPE v;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020092
93 DUP_STRING(ctx->ctx, ext_p->argument, ext->argument, ret);
94 LY_CHECK_RET(ret);
95
96 ext->insubstmt = ext_p->insubstmt;
97 ext->insubstmt_index = ext_p->insubstmt_index;
98 ext->module = ctx->cur_mod;
99 ext->parent = parent;
100 ext->parent_type = parent_type;
101
102 lysc_update_path(ctx, ext->parent_type == LYEXT_PAR_NODE ? (struct lysc_node *)ext->parent : NULL, "{extension}");
Michal Vaskofc2cd072021-02-24 13:17:17 +0100103 lysc_update_path(ctx, NULL, ext_p->name);
104
105 /* parse the prefix */
106 tmp = ext_p->name;
107 r = ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len);
108 /* it was parsed already */
109 assert(!r && !tmp[0]);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200110
111 /* get module where the extension definition should be placed */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200112 if (!ext_mod) {
Michal Vaskofc2cd072021-02-24 13:17:17 +0100113 ext_mod = ly_resolve_prefix(ctx->ctx, prefix, pref_len, ext_p->format, ext_p->prefix_data);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200114 if (!ext_mod) {
Michal Vaskofc2cd072021-02-24 13:17:17 +0100115 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid prefix \"%.*s\" used for extension instance identifier.",
116 pref_len, prefix);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200117 ret = LY_EVALID;
118 goto cleanup;
119 } else if (!ext_mod->parsed->extensions) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100120 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200121 "Extension instance \"%s\" refers \"%s\" module that does not contain extension definitions.",
Michal Vaskofc2cd072021-02-24 13:17:17 +0100122 ext_p->name, ext_mod->name);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200123 ret = LY_EVALID;
124 goto cleanup;
125 }
126 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200127
128 /* find the parsed extension definition there */
129 LY_ARRAY_FOR(ext_mod->parsed->extensions, v) {
130 if (!strcmp(name, ext_mod->parsed->extensions[v].name)) {
131 /* compile extension definition and assign it */
132 LY_CHECK_GOTO(ret = lys_compile_extension(ctx, ext_mod, &ext_mod->parsed->extensions[v], &ext->def), cleanup);
133 break;
134 }
135 }
136 if (!ext->def) {
Michal Vaskofc2cd072021-02-24 13:17:17 +0100137 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Extension definition of extension instance \"%s\" not found.", ext_p->name);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200138 ret = LY_EVALID;
139 goto cleanup;
140 }
141
142 /* unify the parsed extension from YIN and YANG sources. Without extension definition, it is not possible
143 * to get extension's argument from YIN source, so it is stored as one of the substatements. Here we have
144 * to find it, mark it with LYS_YIN_ARGUMENT and store it in the compiled structure. */
Michal Vaskofc2cd072021-02-24 13:17:17 +0100145 if ((ext_p->format == LY_PREF_XML) && ext->def->argument && !ext->argument) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200146 /* Schema was parsed from YIN and an argument is expected, ... */
147 struct lysp_stmt *stmt = NULL;
148
149 if (ext->def->flags & LYS_YINELEM_TRUE) {
150 /* ... argument was the first XML child element */
151 if (ext_p->child && !(ext_p->child->flags & LYS_YIN_ATTR)) {
152 /* TODO check namespace of the statement */
153 if (!strcmp(ext_p->child->stmt, ext->def->argument)) {
154 stmt = ext_p->child;
155 }
156 }
157 } else {
158 /* ... argument was one of the XML attributes which are represented as child stmt
159 * with LYS_YIN_ATTR flag */
160 for (stmt = ext_p->child; stmt && (stmt->flags & LYS_YIN_ATTR); stmt = stmt->next) {
161 if (!strcmp(stmt->stmt, ext->def->argument)) {
162 /* this is the extension's argument */
163 break;
164 }
165 }
166 }
167 if (!stmt) {
168 /* missing extension's argument */
Michal Vaskofc2cd072021-02-24 13:17:17 +0100169 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Extension instance \"%s\" misses argument \"%s\".",
170 ext_p->name, ext->def->argument);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200171 ret = LY_EVALID;
172 goto cleanup;
173
174 }
175 LY_CHECK_GOTO(ret = lydict_insert(ctx->ctx, stmt->arg, 0, &ext->argument), cleanup);
176 stmt->flags |= LYS_YIN_ARGUMENT;
177 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200178
179 if (ext->def->plugin && ext->def->plugin->compile) {
180 if (ext->argument) {
181 lysc_update_path(ctx, (struct lysc_node *)ext, ext->argument);
182 }
Michal Vaskofc2cd072021-02-24 13:17:17 +0100183 ret = ext->def->plugin->compile(ctx, ext_p, ext);
Radek Krejcicc21a4f2021-02-09 15:23:31 +0100184 if (ret == LY_ENOT) {
185 lysc_ext_instance_free(ctx->ctx, ext);
186 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200187 if (ext->argument) {
188 lysc_update_path(ctx, NULL, NULL);
189 }
Michal Vaskofc2cd072021-02-24 13:17:17 +0100190 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200191 }
192 ext_p->compiled = ext;
193
194cleanup:
Radek Krejci2efc45b2020-12-22 16:25:44 +0100195 lysc_update_path(ctx, NULL, NULL);
Michal Vaskofc2cd072021-02-24 13:17:17 +0100196 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200197
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200198 return ret;
199}
200
201struct lysc_ext *
202lysc_ext_dup(struct lysc_ext *orig)
203{
204 ++orig->refcount;
205 return orig;
206}
207
208static void
209lysc_unres_dflt_free(const struct ly_ctx *ctx, struct lysc_unres_dflt *r)
210{
211 assert(!r->dflt || !r->dflts);
212 if (r->dflt) {
213 lysp_qname_free((struct ly_ctx *)ctx, r->dflt);
214 free(r->dflt);
215 } else {
216 FREE_ARRAY((struct ly_ctx *)ctx, r->dflts, lysp_qname_free);
217 }
218 free(r);
219}
220
221void
222lysc_update_path(struct lysc_ctx *ctx, struct lysc_node *parent, const char *name)
223{
224 int len;
225 uint8_t nextlevel = 0; /* 0 - no starttag, 1 - '/' starttag, 2 - '=' starttag + '}' endtag */
226
227 if (!name) {
228 /* removing last path segment */
229 if (ctx->path[ctx->path_len - 1] == '}') {
230 for ( ; ctx->path[ctx->path_len] != '=' && ctx->path[ctx->path_len] != '{'; --ctx->path_len) {}
231 if (ctx->path[ctx->path_len] == '=') {
232 ctx->path[ctx->path_len++] = '}';
233 } else {
234 /* not a top-level special tag, remove also preceiding '/' */
235 goto remove_nodelevel;
236 }
237 } else {
238remove_nodelevel:
239 for ( ; ctx->path[ctx->path_len] != '/'; --ctx->path_len) {}
240 if (ctx->path_len == 0) {
241 /* top-level (last segment) */
242 ctx->path_len = 1;
243 }
244 }
245 /* set new terminating NULL-byte */
246 ctx->path[ctx->path_len] = '\0';
247 } else {
248 if (ctx->path_len > 1) {
249 if (!parent && (ctx->path[ctx->path_len - 1] == '}') && (ctx->path[ctx->path_len - 2] != '\'')) {
250 /* extension of the special tag */
251 nextlevel = 2;
252 --ctx->path_len;
253 } else {
254 /* there is already some path, so add next level */
255 nextlevel = 1;
256 }
257 } /* else the path is just initiated with '/', so do not add additional slash in case of top-level nodes */
258
259 if (nextlevel != 2) {
260 if ((parent && (parent->module == ctx->cur_mod)) || (!parent && (ctx->path_len > 1) && (name[0] == '{'))) {
261 /* module not changed, print the name unprefixed */
262 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s", nextlevel ? "/" : "", name);
263 } else {
264 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s:%s", nextlevel ? "/" : "", ctx->cur_mod->name, name);
265 }
266 } else {
267 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "='%s'}", name);
268 }
269 if (len >= LYSC_CTX_BUFSIZE - (int)ctx->path_len) {
270 /* output truncated */
271 ctx->path_len = LYSC_CTX_BUFSIZE - 1;
272 } else {
273 ctx->path_len += len;
274 }
275 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100276
Radek Krejciddace2c2021-01-08 11:30:56 +0100277 LOG_LOCBACK(0, 0, 1, 0);
278 LOG_LOCSET(NULL, NULL, ctx->path, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200279}
280
281/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200282 * @brief Compile information in the import statement - make sure there is the target module
283 * @param[in] ctx Compile context.
284 * @param[in] imp_p The parsed import statement structure to fill the module to.
285 * @return LY_ERR value.
286 */
287static LY_ERR
288lys_compile_import(struct lysc_ctx *ctx, struct lysp_import *imp_p)
289{
290 const struct lys_module *mod = NULL;
291 LY_ERR ret = LY_SUCCESS;
292
293 /* make sure that we have the parsed version (lysp_) of the imported module to import groupings or typedefs.
294 * The compiled version is needed only for augments, deviates and leafrefs, so they are checked (and added,
295 * if needed) when these nodes are finally being instantiated and validated at the end of schema compilation. */
296 if (!imp_p->module->parsed) {
297 /* try to use filepath if present */
298 if (imp_p->module->filepath) {
299 struct ly_in *in;
300 if (ly_in_new_filepath(imp_p->module->filepath, 0, &in)) {
301 LOGINT(ctx->ctx);
302 } else {
303 LY_CHECK_RET(lys_parse(ctx->ctx, in, !strcmp(&imp_p->module->filepath[strlen(imp_p->module->filepath - 4)],
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100304 ".yin") ? LYS_IN_YIN : LYS_IN_YANG, NULL, &mod));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200305 if (mod != imp_p->module) {
306 LOGERR(ctx->ctx, LY_EINT, "Filepath \"%s\" of the module \"%s\" does not match.",
307 imp_p->module->filepath, imp_p->module->name);
308 mod = NULL;
309 }
310 }
311 ly_in_free(in, 1);
312 }
313 if (!mod) {
Michal Vasko405cc9e2020-12-01 12:01:27 +0100314 if (lysp_load_module(ctx->ctx, imp_p->module->name, imp_p->module->revision, 0, NULL, ctx->unres,
315 (struct lys_module **)&mod)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200316 LOGERR(ctx->ctx, LY_ENOTFOUND, "Unable to reload \"%s\" module to import it into \"%s\", source data not found.",
317 imp_p->module->name, ctx->cur_mod->name);
318 return LY_ENOTFOUND;
319 }
320 }
321 }
322
323 return ret;
324}
325
326LY_ERR
327lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
328 struct lysp_ident *identities_p, struct lysc_ident **identities)
329{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100330 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200331 struct lysc_ctx context = {0};
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100332 struct lysc_ident *ident;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200333 LY_ERR ret = LY_SUCCESS;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100334 ly_bool enabled;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200335
336 assert(ctx_sc || ctx);
337
338 if (!ctx_sc) {
339 context.ctx = ctx;
Radek Krejci3aac9a72020-12-01 12:24:26 +0100340 context.cur_mod = parsed_mod ? parsed_mod->mod : NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200341 context.pmod = parsed_mod;
342 context.path_len = 1;
343 context.path[0] = '/';
344 ctx_sc = &context;
345 }
346
347 if (!identities_p) {
348 return LY_SUCCESS;
349 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200350
351 lysc_update_path(ctx_sc, NULL, "{identity}");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200352 LY_ARRAY_FOR(identities_p, u) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100353 /* evaluate if-features */
354 LY_CHECK_RET(lys_eval_iffeatures(ctx, identities_p[u].iffeatures, &enabled));
355 if (!enabled) {
356 continue;
357 }
358
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200359 lysc_update_path(ctx_sc, NULL, identities_p[u].name);
360
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100361 /* add new compiled identity */
362 LY_ARRAY_NEW_RET(ctx_sc->ctx, *identities, ident, LY_EMEM);
363
364 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].name, ident->name, ret, done);
365 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].dsc, ident->dsc, ret, done);
366 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].ref, ident->ref, ret, done);
367 ident->module = ctx_sc->cur_mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200368 /* backlinks (derived) can be added no sooner than when all the identities in the current module are present */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100369 COMPILE_EXTS_GOTO(ctx_sc, identities_p[u].exts, ident->exts, ident, LYEXT_PAR_IDENT, ret, done);
370 ident->flags = identities_p[u].flags;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200371
372 lysc_update_path(ctx_sc, NULL, NULL);
373 }
374 lysc_update_path(ctx_sc, NULL, NULL);
375done:
376 return ret;
377}
378
379/**
380 * @brief Check circular dependency of identities - identity MUST NOT reference itself (via their base statement).
381 *
382 * The function works in the same way as lys_compile_feature_circular_check() with different structures and error messages.
383 *
384 * @param[in] ctx Compile context for logging.
385 * @param[in] ident The base identity (its derived list is being extended by the identity being currently processed).
386 * @param[in] derived The list of derived identities of the identity being currently processed (not the one provided as @p ident)
387 * @return LY_SUCCESS if everything is ok.
388 * @return LY_EVALID if the identity is derived from itself.
389 */
390static LY_ERR
391lys_compile_identity_circular_check(struct lysc_ctx *ctx, struct lysc_ident *ident, struct lysc_ident **derived)
392{
393 LY_ERR ret = LY_SUCCESS;
394 LY_ARRAY_COUNT_TYPE u, v;
395 struct ly_set recursion = {0};
396 struct lysc_ident *drv;
397
398 if (!derived) {
399 return LY_SUCCESS;
400 }
401
402 for (u = 0; u < LY_ARRAY_COUNT(derived); ++u) {
403 if (ident == derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100404 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200405 "Identity \"%s\" is indirectly derived from itself.", ident->name);
406 ret = LY_EVALID;
407 goto cleanup;
408 }
409 ret = ly_set_add(&recursion, derived[u], 0, NULL);
410 LY_CHECK_GOTO(ret, cleanup);
411 }
412
413 for (v = 0; v < recursion.count; ++v) {
414 drv = recursion.objs[v];
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200415 for (u = 0; u < LY_ARRAY_COUNT(drv->derived); ++u) {
416 if (ident == drv->derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100417 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200418 "Identity \"%s\" is indirectly derived from itself.", ident->name);
419 ret = LY_EVALID;
420 goto cleanup;
421 }
422 ret = ly_set_add(&recursion, drv->derived[u], 0, NULL);
423 LY_CHECK_GOTO(ret, cleanup);
424 }
425 }
426
427cleanup:
428 ly_set_erase(&recursion, NULL);
429 return ret;
430}
431
432LY_ERR
433lys_compile_identity_bases(struct lysc_ctx *ctx, const struct lysp_module *base_pmod, const char **bases_p,
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100434 struct lysc_ident *ident, struct lysc_ident ***bases, ly_bool *enabled)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200435{
436 LY_ARRAY_COUNT_TYPE u, v;
437 const char *s, *name;
438 const struct lys_module *mod;
439 struct lysc_ident **idref;
440
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100441 assert((ident && enabled) || bases);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200442
443 if ((LY_ARRAY_COUNT(bases_p) > 1) && (ctx->pmod->version < LYS_VERSION_1_1)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100444 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200445 "Multiple bases in %s are allowed only in YANG 1.1 modules.", ident ? "identity" : "identityref type");
446 return LY_EVALID;
447 }
448
449 LY_ARRAY_FOR(bases_p, u) {
450 s = strchr(bases_p[u], ':');
451 if (s) {
452 /* prefixed identity */
453 name = &s[1];
Michal Vaskob2d55bf2020-11-02 15:42:43 +0100454 mod = ly_resolve_prefix(ctx->ctx, bases_p[u], s - bases_p[u], LY_PREF_SCHEMA, (void *)base_pmod);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200455 } else {
456 name = bases_p[u];
457 mod = base_pmod->mod;
458 }
459 if (!mod) {
460 if (ident) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100461 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200462 "Invalid prefix used for base (%s) of identity \"%s\".", bases_p[u], ident->name);
463 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100464 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200465 "Invalid prefix used for base (%s) of identityref.", bases_p[u]);
466 }
467 return LY_EVALID;
468 }
469
470 idref = NULL;
471 LY_ARRAY_FOR(mod->identities, v) {
472 if (!strcmp(name, mod->identities[v].name)) {
473 if (ident) {
474 if (ident == &mod->identities[v]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100475 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200476 "Identity \"%s\" is derived from itself.", ident->name);
477 return LY_EVALID;
478 }
479 LY_CHECK_RET(lys_compile_identity_circular_check(ctx, &mod->identities[v], ident->derived));
480 /* we have match! store the backlink */
481 LY_ARRAY_NEW_RET(ctx->ctx, mod->identities[v].derived, idref, LY_EMEM);
482 *idref = ident;
483 } else {
484 /* we have match! store the found identity */
485 LY_ARRAY_NEW_RET(ctx->ctx, *bases, idref, LY_EMEM);
486 *idref = &mod->identities[v];
487 }
488 break;
489 }
490 }
491 if (!idref || !(*idref)) {
492 if (ident) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100493 /* look into the parsed module to check whether the identity is not merely disabled */
494 LY_ARRAY_FOR(mod->parsed->identities, v) {
495 if (!strcmp(mod->parsed->identities[v].name, name)) {
496 *enabled = 0;
497 return LY_SUCCESS;
498 }
499 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100500 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200501 "Unable to find base (%s) of identity \"%s\".", bases_p[u], ident->name);
502 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100503 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200504 "Unable to find base (%s) of identityref.", bases_p[u]);
505 }
506 return LY_EVALID;
507 }
508 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100509
510 if (ident) {
511 *enabled = 1;
512 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200513 return LY_SUCCESS;
514}
515
516/**
517 * @brief For the given array of identities, set the backlinks from all their base identities.
518 * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
519 * @param[in] idents_p Array of identities definitions from the parsed schema structure.
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100520 * @param[in,out] idents Array of referencing identities to which the backlinks are supposed to be set. Any
521 * identities with disabled bases are removed.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200522 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
523 */
524static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100525lys_compile_identities_derived(struct lysc_ctx *ctx, struct lysp_ident *idents_p, struct lysc_ident **idents)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200526{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100527 LY_ARRAY_COUNT_TYPE u, v;
528 ly_bool enabled;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200529
530 lysc_update_path(ctx, NULL, "{identity}");
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100531
532restart:
Radek Krejcic7d13e32020-12-09 12:32:24 +0100533 for (u = 0, v = 0; u < LY_ARRAY_COUNT(*idents); ++u) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100534 /* find matching parsed identity, the disabled ones are missing in the compiled array */
535 while (v < LY_ARRAY_COUNT(idents_p)) {
536 if (idents_p[v].name == (*idents)[u].name) {
537 break;
538 }
539 ++v;
540 }
541 assert(v < LY_ARRAY_COUNT(idents_p));
542
543 if (!idents_p[v].bases) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200544 continue;
545 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100546 lysc_update_path(ctx, NULL, (*idents)[u].name);
547 LY_CHECK_RET(lys_compile_identity_bases(ctx, (*idents)[u].module->parsed, idents_p[v].bases, &(*idents)[u], NULL,
548 &enabled));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200549 lysc_update_path(ctx, NULL, NULL);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100550
551 if (!enabled) {
552 /* remove the identity */
553 lysc_ident_free(ctx->ctx, &(*idents)[u]);
554 LY_ARRAY_DECREMENT(*idents);
555 if (u < LY_ARRAY_COUNT(*idents)) {
556 memmove(&(*idents)[u], &(*idents)[u + 1], (LY_ARRAY_COUNT(*idents) - u) * sizeof **idents);
557 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100558
559 /* revert compilation of all the previous identities */
560 for (v = 0; v < u; ++v) {
561 LY_ARRAY_FREE((*idents)[v].derived);
562 }
563
Michal Vasko74c82ae2020-11-03 17:36:53 +0100564 /* free the whole array if there are no identites left */
565 if (!LY_ARRAY_COUNT(*idents)) {
566 LY_ARRAY_FREE(*idents);
567 *idents = NULL;
568 }
569
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100570 /* restart the whole process without this identity */
571 goto restart;
572 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200573 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100574
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200575 lysc_update_path(ctx, NULL, NULL);
576 return LY_SUCCESS;
577}
578
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200579static void *
580lys_compile_extension_instance_storage(enum ly_stmt stmt, struct lysc_ext_substmt *substmts)
581{
582 for (LY_ARRAY_COUNT_TYPE u = 0; substmts[u].stmt; ++u) {
583 if (substmts[u].stmt == stmt) {
584 return substmts[u].storage;
585 }
586 }
587 return NULL;
588}
589
590LY_ERR
591lys_compile_extension_instance(struct lysc_ctx *ctx, const struct lysp_ext_instance *ext, struct lysc_ext_substmt *substmts)
592{
593 LY_ERR ret = LY_EVALID, r;
594 LY_ARRAY_COUNT_TYPE u;
595 struct lysp_stmt *stmt;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100596 struct lysp_qname *iffeatures, *iffeat;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200597 void *parsed = NULL, **compiled = NULL;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100598 ly_bool enabled;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200599
600 /* check for invalid substatements */
601 for (stmt = ext->child; stmt; stmt = stmt->next) {
602 if (stmt->flags & (LYS_YIN_ATTR | LYS_YIN_ARGUMENT)) {
603 continue;
604 }
605 for (u = 0; substmts[u].stmt; ++u) {
606 if (substmts[u].stmt == stmt->kw) {
607 break;
608 }
609 }
610 if (!substmts[u].stmt) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100611 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, "Invalid keyword \"%s\" as a child of \"%s%s%s\" extension instance.",
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200612 stmt->stmt, ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
613 goto cleanup;
614 }
615 }
616
617 /* TODO store inherited data, e.g. status first, but mark them somehow to allow to overwrite them and not detect duplicity */
618
619 /* keep order of the processing the same as the order in the defined substmts,
620 * the order is important for some of the statements depending on others (e.g. type needs status and units) */
621 for (u = 0; substmts[u].stmt; ++u) {
622 ly_bool stmt_present = 0;
623
624 for (stmt = ext->child; stmt; stmt = stmt->next) {
625 if (substmts[u].stmt != stmt->kw) {
626 continue;
627 }
628
629 stmt_present = 1;
630 if (substmts[u].storage) {
631 switch (stmt->kw) {
632 case LY_STMT_STATUS:
633 assert(substmts[u].cardinality < LY_STMT_CARD_SOME);
634 LY_CHECK_ERR_GOTO(r = lysp_stmt_parse(ctx, stmt, stmt->kw, &substmts[u].storage, /* TODO */ NULL), ret = r, cleanup);
635 break;
636 case LY_STMT_UNITS: {
637 const char **units;
638
639 if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
640 /* single item */
641 if (*((const char **)substmts[u].storage)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100642 LOGVAL(ctx->ctx, LY_VCODE_DUPSTMT, stmt->stmt);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200643 goto cleanup;
644 }
645 units = (const char **)substmts[u].storage;
646 } else {
647 /* sized array */
648 const char ***units_array = (const char ***)substmts[u].storage;
649 LY_ARRAY_NEW_GOTO(ctx->ctx, *units_array, units, ret, cleanup);
650 }
651 r = lydict_insert(ctx->ctx, stmt->arg, 0, units);
652 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
653 break;
654 }
655 case LY_STMT_TYPE: {
656 uint16_t *flags = lys_compile_extension_instance_storage(LY_STMT_STATUS, substmts);
657 const char **units = lys_compile_extension_instance_storage(LY_STMT_UNITS, substmts);
658
659 if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
660 /* single item */
661 if (*(struct lysc_type **)substmts[u].storage) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100662 LOGVAL(ctx->ctx, LY_VCODE_DUPSTMT, stmt->stmt);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200663 goto cleanup;
664 }
665 compiled = substmts[u].storage;
666 } else {
667 /* sized array */
668 struct lysc_type ***types = (struct lysc_type ***)substmts[u].storage, **type = NULL;
669 LY_ARRAY_NEW_GOTO(ctx->ctx, *types, type, ret, cleanup);
670 compiled = (void *)type;
671 }
672
673 r = lysp_stmt_parse(ctx, stmt, stmt->kw, &parsed, NULL);
674 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
Michal Vaskoa99b3572021-02-01 11:54:58 +0100675 r = lys_compile_type(ctx, NULL, flags ? *flags : 0, ext->name, parsed, (struct lysc_type **)compiled,
676 units && !*units ? units : NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200677 lysp_type_free(ctx->ctx, parsed);
678 free(parsed);
679 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
680 break;
681 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100682 case LY_STMT_IF_FEATURE:
683 iffeatures = NULL;
684 LY_ARRAY_NEW_GOTO(ctx->ctx, iffeatures, iffeat, ret, cleanup);
685 iffeat->str = stmt->arg;
686 iffeat->mod = ctx->pmod;
687 r = lys_eval_iffeatures(ctx->ctx, iffeatures, &enabled);
688 LY_ARRAY_FREE(iffeatures);
689 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
690 if (!enabled) {
691 /* it is disabled, remove the whole extension instance */
692 return LY_ENOT;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200693 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200694 break;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200695 /* TODO support other substatements (parse stmt to lysp and then compile lysp to lysc),
696 * also note that in many statements their extensions are not taken into account */
697 default:
Radek Krejci2efc45b2020-12-22 16:25:44 +0100698 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, "Statement \"%s\" is not supported as an extension (found in \"%s%s%s\") substatement.",
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200699 stmt->stmt, ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
700 goto cleanup;
701 }
702 }
703 }
704
705 if (((substmts[u].cardinality == LY_STMT_CARD_MAND) || (substmts[u].cardinality == LY_STMT_CARD_SOME)) && !stmt_present) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100706 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, "Missing mandatory keyword \"%s\" as a child of \"%s%s%s\".",
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200707 ly_stmt2str(substmts[u].stmt), ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
708 goto cleanup;
709 }
710 }
711
712 ret = LY_SUCCESS;
713
714cleanup:
715 return ret;
716}
717
718/**
719 * @brief Check when for cyclic dependencies.
720 *
721 * @param[in] set Set with all the referenced nodes.
722 * @param[in] node Node whose "when" referenced nodes are in @p set.
723 * @return LY_ERR value
724 */
725static LY_ERR
726lys_compile_unres_when_cyclic(struct lyxp_set *set, const struct lysc_node *node)
727{
728 struct lyxp_set tmp_set;
729 struct lyxp_set_scnode *xp_scnode;
730 uint32_t i, j;
731 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200732 LY_ERR ret = LY_SUCCESS;
733
734 memset(&tmp_set, 0, sizeof tmp_set);
735
736 /* prepare in_ctx of the set */
737 for (i = 0; i < set->used; ++i) {
738 xp_scnode = &set->val.scnodes[i];
739
Radek Krejcif13b87b2020-12-01 22:02:17 +0100740 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_START_USED) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200741 /* check node when, skip the context node (it was just checked) */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100742 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200743 }
744 }
745
746 for (i = 0; i < set->used; ++i) {
747 xp_scnode = &set->val.scnodes[i];
Radek Krejcif13b87b2020-12-01 22:02:17 +0100748 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200749 /* already checked */
750 continue;
751 }
752
753 if ((xp_scnode->type != LYXP_NODE_ELEM) || (xp_scnode->scnode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) ||
Radek Krejci9a3823e2021-01-27 20:26:46 +0100754 !lysc_node_when(xp_scnode->scnode)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200755 /* no when to check */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100756 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200757 continue;
758 }
759
760 node = xp_scnode->scnode;
761 do {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100762 struct lysc_when **when_list, *when;
763
Radek Krejciddace2c2021-01-08 11:30:56 +0100764 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci9a3823e2021-01-27 20:26:46 +0100765 when_list = lysc_node_when(node);
766 LY_ARRAY_FOR(when_list, u) {
767 when = when_list[u];
Michal Vasko400e9672021-01-11 13:39:17 +0100768 ret = lyxp_atomize(set->ctx, when->cond, node->module, LY_PREF_SCHEMA_RESOLVED, when->prefixes,
769 when->context, &tmp_set, LYXP_SCNODE_SCHEMA);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200770 if (ret != LY_SUCCESS) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100771 LOGVAL(set->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when->cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200772 goto cleanup;
773 }
774
775 for (j = 0; j < tmp_set.used; ++j) {
776 /* skip roots'n'stuff */
777 if (tmp_set.val.scnodes[j].type == LYXP_NODE_ELEM) {
778 /* try to find this node in our set */
779 uint32_t idx;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100780 if (lyxp_set_scnode_contains(set, tmp_set.val.scnodes[j].scnode, LYXP_NODE_ELEM, -1, &idx) &&
781 (set->val.scnodes[idx].in_ctx == LYXP_SET_SCNODE_START_USED)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100782 LOGVAL(set->ctx, LYVE_SEMANTICS, "When condition includes a self-reference.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200783 ret = LY_EVALID;
784 goto cleanup;
785 }
786
787 /* needs to be checked, if in both sets, will be ignored */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100788 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200789 } else {
790 /* no when, nothing to check */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100791 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200792 }
793 }
794
795 /* merge this set into the global when set */
796 lyxp_set_scnode_merge(set, &tmp_set);
797 }
798
799 /* check when of non-data parents as well */
800 node = node->parent;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100801
Radek Krejciddace2c2021-01-08 11:30:56 +0100802 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200803 } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE)));
804
805 /* this node when was checked (xp_scnode could have been reallocd) */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100806 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200807 }
808
809cleanup:
810 lyxp_set_free_content(&tmp_set);
811 return ret;
812}
813
814LY_ERR
815lysc_check_status(struct lysc_ctx *ctx, uint16_t flags1, void *mod1, const char *name1, uint16_t flags2, void *mod2,
816 const char *name2)
817{
818 uint16_t flg1, flg2;
819
820 flg1 = (flags1 & LYS_STATUS_MASK) ? (flags1 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
821 flg2 = (flags2 & LYS_STATUS_MASK) ? (flags2 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
822
823 if ((flg1 < flg2) && (mod1 == mod2)) {
824 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100825 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200826 "A %s definition \"%s\" is not allowed to reference %s definition \"%s\".",
827 flg1 == LYS_STATUS_CURR ? "current" : "deprecated", name1,
828 flg2 == LYS_STATUS_OBSLT ? "obsolete" : "deprecated", name2);
829 }
830 return LY_EVALID;
831 }
832
833 return LY_SUCCESS;
834}
835
Michal Vasko25d6ad02020-10-22 12:20:22 +0200836LY_ERR
837lys_compile_expr_implement(const struct ly_ctx *ctx, const struct lyxp_expr *expr, LY_PREFIX_FORMAT format,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100838 void *prefix_data, ly_bool implement, struct lys_glob_unres *unres, const struct lys_module **mod_p)
Michal Vaskocfaff232020-10-20 09:35:14 +0200839{
840 uint32_t i;
841 const char *ptr, *start;
842 const struct lys_module *mod;
843
Michal Vasko25d6ad02020-10-22 12:20:22 +0200844 assert(implement || mod_p);
845
Michal Vaskocfaff232020-10-20 09:35:14 +0200846 for (i = 0; i < expr->used; ++i) {
847 if ((expr->tokens[i] != LYXP_TOKEN_NAMETEST) && (expr->tokens[i] != LYXP_TOKEN_LITERAL)) {
848 /* token cannot have a prefix */
849 continue;
850 }
851
852 start = expr->expr + expr->tok_pos[i];
853 if (!(ptr = ly_strnchr(start, ':', expr->tok_len[i]))) {
854 /* token without a prefix */
855 continue;
856 }
857
858 if (!(mod = ly_resolve_prefix(ctx, start, ptr - start, format, prefix_data))) {
859 /* unknown prefix, do not care right now */
860 continue;
861 }
862
863 if (!mod->implemented) {
864 /* unimplemented module found */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200865 if (implement) {
Michal Vasko405cc9e2020-12-01 12:01:27 +0100866 LY_CHECK_RET(lys_set_implemented_r((struct lys_module *)mod, NULL, unres));
Michal Vasko25d6ad02020-10-22 12:20:22 +0200867 } else {
Michal Vaskocfaff232020-10-20 09:35:14 +0200868 *mod_p = mod;
Michal Vasko25d6ad02020-10-22 12:20:22 +0200869 break;
Michal Vaskocfaff232020-10-20 09:35:14 +0200870 }
Michal Vaskocfaff232020-10-20 09:35:14 +0200871 }
872 }
873
Michal Vasko25d6ad02020-10-22 12:20:22 +0200874 return LY_SUCCESS;
Michal Vaskocfaff232020-10-20 09:35:14 +0200875}
876
877/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200878 * @brief Check when/must expressions of a node on a complete compiled schema tree.
879 *
880 * @param[in] ctx Compile context.
881 * @param[in] node Node to check.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100882 * @param[in,out] unres Global unres structure.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200883 * @return LY_ERR value
884 */
885static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +0100886lys_compile_unres_xpath(struct lysc_ctx *ctx, const struct lysc_node *node, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200887{
888 struct lyxp_set tmp_set;
889 uint32_t i, opts;
890 LY_ARRAY_COUNT_TYPE u;
891 ly_bool input_done = 0;
Radek Krejci9a3823e2021-01-27 20:26:46 +0100892 struct lysc_when **whens = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200893 struct lysc_must *musts = NULL;
894 LY_ERR ret = LY_SUCCESS;
Michal Vaskocfaff232020-10-20 09:35:14 +0200895 const struct lys_module *mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200896
Radek Krejciddace2c2021-01-08 11:30:56 +0100897 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100898
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200899 memset(&tmp_set, 0, sizeof tmp_set);
Michal Vaskod1e53b92021-01-28 13:11:06 +0100900 opts = LYXP_SCNODE_SCHEMA | ((node->flags & LYS_IS_OUTPUT) ? LYXP_SCNODE_OUTPUT : 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200901
Radek Krejci9a3823e2021-01-27 20:26:46 +0100902 whens = lysc_node_when(node);
903 musts = lysc_node_musts(node);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200904
Radek Krejci9a3823e2021-01-27 20:26:46 +0100905 LY_ARRAY_FOR(whens, u) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200906 /* first check whether all the referenced modules are implemented */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200907 mod = NULL;
Radek Krejci9a3823e2021-01-27 20:26:46 +0100908 ret = lys_compile_expr_implement(ctx->ctx, whens[u]->cond, LY_PREF_SCHEMA_RESOLVED, whens[u]->prefixes,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100909 ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200910 if (ret) {
911 goto cleanup;
912 } else if (mod) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200913 LOGWRN(ctx->ctx, "When condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
Radek Krejci9a3823e2021-01-27 20:26:46 +0100914 whens[u]->cond->expr, mod->name);
Michal Vaskocfaff232020-10-20 09:35:14 +0200915 continue;
916 }
917
918 /* check "when" */
Radek Krejci9a3823e2021-01-27 20:26:46 +0100919 ret = lyxp_atomize(ctx->ctx, whens[u]->cond, node->module, LY_PREF_SCHEMA_RESOLVED, whens[u]->prefixes,
920 whens[u]->context, &tmp_set, opts);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200921 if (ret) {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100922 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", whens[u]->cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200923 goto cleanup;
924 }
925
926 ctx->path[0] = '\0';
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100927 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200928 for (i = 0; i < tmp_set.used; ++i) {
929 /* skip roots'n'stuff */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100930 if ((tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (tmp_set.val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START_USED)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200931 struct lysc_node *schema = tmp_set.val.scnodes[i].scnode;
932
933 /* XPath expression cannot reference "lower" status than the node that has the definition */
Radek Krejci9a3823e2021-01-27 20:26:46 +0100934 ret = lysc_check_status(ctx, whens[u]->flags, node->module, node->name, schema->flags, schema->module,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200935 schema->name);
936 LY_CHECK_GOTO(ret, cleanup);
937
938 /* check dummy node accessing */
939 if (schema == node) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100940 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200941 ret = LY_EVALID;
942 goto cleanup;
943 }
944 }
945 }
946
947 /* check cyclic dependencies */
948 ret = lys_compile_unres_when_cyclic(&tmp_set, node);
949 LY_CHECK_GOTO(ret, cleanup);
950
951 lyxp_set_free_content(&tmp_set);
952 }
953
954check_musts:
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200955 LY_ARRAY_FOR(musts, u) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200956 /* first check whether all the referenced modules are implemented */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200957 mod = NULL;
958 ret = lys_compile_expr_implement(ctx->ctx, musts[u].cond, LY_PREF_SCHEMA_RESOLVED, musts[u].prefixes,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100959 ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200960 if (ret) {
961 goto cleanup;
962 } else if (mod) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200963 LOGWRN(ctx->ctx, "Must condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
964 musts[u].cond->expr, mod->name);
965 continue;
966 }
967
968 /* check "must" */
Michal Vasko400e9672021-01-11 13:39:17 +0100969 ret = lyxp_atomize(ctx->ctx, musts[u].cond, node->module, LY_PREF_SCHEMA_RESOLVED, musts[u].prefixes, node,
970 &tmp_set, opts);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200971 if (ret) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100972 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid must restriction \"%s\".", musts[u].cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200973 goto cleanup;
974 }
975
976 ctx->path[0] = '\0';
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100977 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200978 for (i = 0; i < tmp_set.used; ++i) {
979 /* skip roots'n'stuff */
980 if (tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
981 /* XPath expression cannot reference "lower" status than the node that has the definition */
982 ret = lysc_check_status(ctx, node->flags, node->module, node->name, tmp_set.val.scnodes[i].scnode->flags,
983 tmp_set.val.scnodes[i].scnode->module, tmp_set.val.scnodes[i].scnode->name);
984 LY_CHECK_GOTO(ret, cleanup);
985 }
986 }
987
988 lyxp_set_free_content(&tmp_set);
989 }
990
991 if ((node->nodetype & (LYS_RPC | LYS_ACTION)) && !input_done) {
992 /* now check output musts */
993 input_done = 1;
Radek Krejci9a3823e2021-01-27 20:26:46 +0100994 whens = NULL;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100995 musts = ((struct lysc_node_action *)node)->output.musts;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200996 opts = LYXP_SCNODE_OUTPUT;
997 goto check_musts;
998 }
999
1000cleanup:
1001 lyxp_set_free_content(&tmp_set);
Radek Krejciddace2c2021-01-08 11:30:56 +01001002 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001003 return ret;
1004}
1005
1006/**
1007 * @brief Check leafref for its target existence on a complete compiled schema tree.
1008 *
1009 * @param[in] ctx Compile context.
1010 * @param[in] node Context node for the leafref.
1011 * @param[in] lref Leafref to check/resolve.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001012 * @param[in,out] unres Global unres structure.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001013 * @return LY_ERR value.
1014 */
1015static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001016lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, struct lysc_type_leafref *lref,
1017 struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001018{
Michal Vaskod1e53b92021-01-28 13:11:06 +01001019 const struct lysc_node *target = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001020 struct ly_path *p;
1021 struct lysc_type *type;
1022
1023 assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
1024
1025 /* try to find the target */
Michal Vaskod1e53b92021-01-28 13:11:06 +01001026 LY_CHECK_RET(ly_path_compile(ctx->ctx, lref->cur_mod, node, lref->path, LY_PATH_LREF_TRUE,
1027 (node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
1028 LY_PREF_SCHEMA_RESOLVED, lref->prefixes, unres, &p));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001029
1030 /* get the target node */
1031 target = p[LY_ARRAY_COUNT(p) - 1].node;
1032 ly_path_free(node->module->ctx, p);
1033
1034 if (!(target->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001035 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target node is %s instead of leaf or leaf-list.",
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001036 lref->path->expr, lys_nodetype2str(target->nodetype));
1037 return LY_EVALID;
1038 }
1039
1040 /* check status */
1041 ctx->path[0] = '\0';
1042 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
1043 ctx->path_len = strlen(ctx->path);
1044 if (lysc_check_status(ctx, node->flags, node->module, node->name, target->flags, target->module, target->name)) {
1045 return LY_EVALID;
1046 }
1047 ctx->path_len = 1;
1048 ctx->path[1] = '\0';
1049
1050 /* check config */
1051 if (lref->require_instance) {
Michal Vaskod1e53b92021-01-28 13:11:06 +01001052 if ((node->flags & LYS_CONFIG_W) && (target->flags & LYS_CONFIG_R)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001053 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target is supposed"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001054 " to represent configuration data (as the leafref does), but it does not.", lref->path->expr);
1055 return LY_EVALID;
1056 }
1057 }
1058
1059 /* store the target's type and check for circular chain of leafrefs */
1060 lref->realtype = ((struct lysc_node_leaf *)target)->type;
1061 for (type = lref->realtype; type && type->basetype == LY_TYPE_LEAFREF; type = ((struct lysc_type_leafref *)type)->realtype) {
1062 if (type == (struct lysc_type *)lref) {
1063 /* circular chain detected */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001064 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - circular chain of leafrefs detected.",
1065 lref->path->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001066 return LY_EVALID;
1067 }
1068 }
1069
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001070 /* TODO check if leafref and its target are under common if-features */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001071
1072 return LY_SUCCESS;
1073}
1074
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001075/**
1076 * @brief Compile default value(s) for leaf or leaf-list expecting a complete compiled schema tree.
1077 *
1078 * @param[in] ctx Compile context.
1079 * @param[in] node Leaf or leaf-list to compile the default value(s) for.
1080 * @param[in] type Type of the default value.
1081 * @param[in] dflt Default value.
1082 * @param[in] dflt_pmod Parsed module of the @p dflt to resolve possible prefixes.
1083 * @param[in,out] storage Storage for the compiled default value.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001084 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001085 * @return LY_ERR value.
1086 */
1087static LY_ERR
1088lys_compile_unres_dflt(struct lysc_ctx *ctx, struct lysc_node *node, struct lysc_type *type, const char *dflt,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001089 const struct lysp_module *dflt_pmod, struct lyd_value *storage, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001090{
1091 LY_ERR ret;
Michal Vasko25d6ad02020-10-22 12:20:22 +02001092 uint32_t options;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001093 struct ly_err_item *err = NULL;
1094
Michal Vasko25d6ad02020-10-22 12:20:22 +02001095 options = (ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED) ? LY_TYPE_STORE_IMPLEMENT : 0;
1096 ret = type->plugin->store(ctx->ctx, type, dflt, strlen(dflt), options, LY_PREF_SCHEMA, (void *)dflt_pmod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001097 LYD_HINT_SCHEMA, node, storage, unres, &err);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001098 if (ret == LY_EINCOMPLETE) {
1099 /* we have no data so we will not be resolving it */
1100 ret = LY_SUCCESS;
1101 }
1102
1103 if (ret) {
Radek Krejciddace2c2021-01-08 11:30:56 +01001104 LOG_LOCSET(node, NULL, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001105 if (err) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001106 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type (%s).", err->msg);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001107 ly_err_free(err);
1108 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001109 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001110 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001111 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001112 return ret;
1113 }
1114
1115 ++((struct lysc_type *)storage->realtype)->refcount;
1116 return LY_SUCCESS;
1117}
1118
1119/**
1120 * @brief Compile default value of a leaf expecting a complete compiled schema tree.
1121 *
1122 * @param[in] ctx Compile context.
1123 * @param[in] leaf Leaf that the default value is for.
1124 * @param[in] dflt Default value to compile.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001125 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001126 * @return LY_ERR value.
1127 */
1128static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001129lys_compile_unres_leaf_dlft(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf, struct lysp_qname *dflt,
1130 struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001131{
1132 LY_ERR ret;
1133
1134 assert(!leaf->dflt);
1135
1136 if (leaf->flags & (LYS_MAND_TRUE | LYS_KEY)) {
1137 /* ignore default values for keys and mandatory leaves */
1138 return LY_SUCCESS;
1139 }
1140
1141 /* allocate the default value */
1142 leaf->dflt = calloc(1, sizeof *leaf->dflt);
1143 LY_CHECK_ERR_RET(!leaf->dflt, LOGMEM(ctx->ctx), LY_EMEM);
1144
1145 /* store the default value */
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001146 ret = lys_compile_unres_dflt(ctx, &leaf->node, leaf->type, dflt->str, dflt->mod, leaf->dflt, unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001147 if (ret) {
1148 free(leaf->dflt);
1149 leaf->dflt = NULL;
1150 }
1151
1152 return ret;
1153}
1154
1155/**
1156 * @brief Compile default values of a leaf-list expecting a complete compiled schema tree.
1157 *
1158 * @param[in] ctx Compile context.
1159 * @param[in] llist Leaf-list that the default value(s) are for.
1160 * @param[in] dflt Default value to compile, in case of a single value.
1161 * @param[in] dflts Sized array of default values, in case of more values.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001162 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001163 * @return LY_ERR value.
1164 */
1165static LY_ERR
1166lys_compile_unres_llist_dflts(struct lysc_ctx *ctx, struct lysc_node_leaflist *llist, struct lysp_qname *dflt,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001167 struct lysp_qname *dflts, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001168{
1169 LY_ERR ret;
1170 LY_ARRAY_COUNT_TYPE orig_count, u, v;
1171
1172 assert(dflt || dflts);
1173
Radek Krejcic7d13e32020-12-09 12:32:24 +01001174 /* in case there were already some defaults and we are adding new by deviations */
1175 orig_count = LY_ARRAY_COUNT(llist->dflts);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001176
1177 /* allocate new items */
Radek Krejcic7d13e32020-12-09 12:32:24 +01001178 LY_ARRAY_CREATE_RET(ctx->ctx, llist->dflts, orig_count + (dflts ? LY_ARRAY_COUNT(dflts) : 1), LY_EMEM);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001179
1180 /* fill each new default value */
1181 if (dflts) {
1182 LY_ARRAY_FOR(dflts, u) {
1183 llist->dflts[orig_count + u] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001184 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflts[u].str, dflts[u].mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001185 llist->dflts[orig_count + u], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001186 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count + u]), ret);
1187 LY_ARRAY_INCREMENT(llist->dflts);
1188 }
1189 } else {
1190 llist->dflts[orig_count] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001191 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflt->str, dflt->mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001192 llist->dflts[orig_count], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001193 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count]), ret);
1194 LY_ARRAY_INCREMENT(llist->dflts);
1195 }
1196
1197 /* check default value uniqueness */
1198 if (llist->flags & LYS_CONFIG_W) {
1199 /* configuration data values must be unique - so check the default values */
1200 for (u = orig_count; u < LY_ARRAY_COUNT(llist->dflts); ++u) {
1201 for (v = 0; v < u; ++v) {
1202 if (!llist->dflts[u]->realtype->plugin->compare(llist->dflts[u], llist->dflts[v])) {
1203 lysc_update_path(ctx, llist->parent, llist->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001204 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Configuration leaf-list has multiple defaults of the same value \"%s\".",
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001205 llist->dflts[u]->canonical);
1206 lysc_update_path(ctx, NULL, NULL);
1207 return LY_EVALID;
1208 }
1209 }
1210 }
1211 }
1212
1213 return LY_SUCCESS;
1214}
1215
Michal Vasko405cc9e2020-12-01 12:01:27 +01001216LY_ERR
1217lys_compile_unres_glob(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1218{
Radek Krejci2efc45b2020-12-22 16:25:44 +01001219 LY_ERR ret;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001220 struct lysc_node *node;
1221 struct lysc_type *type, *typeiter;
1222 struct lysc_type_leafref *lref;
1223 struct lysc_ctx cctx = {0};
1224 LY_ARRAY_COUNT_TYPE v;
1225 uint32_t i;
1226
1227 if (unres->recompile) {
1228 /* recompile all the modules and resolve the new unres instead (during recompilation) */
1229 unres->recompile = 0;
1230 return lys_recompile(ctx, 1);
1231 }
1232
1233 /* fake compile context */
1234 cctx.ctx = ctx;
1235 cctx.path_len = 1;
1236 cctx.path[0] = '/';
1237
1238 /* for leafref, we need 2 rounds - first detects circular chain by storing the first referred type (which
1239 * can be also leafref, in case it is already resolved, go through the chain and check that it does not
1240 * point to the starting leafref type). The second round stores the first non-leafref type for later data validation. */
1241 for (i = 0; i < unres->leafrefs.count; ++i) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001242 LY_ERR ret = LY_SUCCESS;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001243 node = unres->leafrefs.objs[i];
1244 cctx.cur_mod = node->module;
1245 cctx.pmod = node->module->parsed;
1246
Radek Krejciddace2c2021-01-08 11:30:56 +01001247 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001248
Michal Vasko405cc9e2020-12-01 12:01:27 +01001249 assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
1250 type = ((struct lysc_node_leaf *)node)->type;
1251 if (type->basetype == LY_TYPE_LEAFREF) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001252 ret = lys_compile_unres_leafref(&cctx, node, (struct lysc_type_leafref *)type, unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001253 } else if (type->basetype == LY_TYPE_UNION) {
1254 LY_ARRAY_FOR(((struct lysc_type_union *)type)->types, v) {
1255 if (((struct lysc_type_union *)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
1256 lref = (struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001257 ret = lys_compile_unres_leafref(&cctx, node, lref, unres);
1258 if (ret) {
1259 break;
1260 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001261 }
1262 }
1263 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01001264
Radek Krejciddace2c2021-01-08 11:30:56 +01001265 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001266 if (ret) {
1267 return ret;
1268 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001269 }
1270 while (unres->leafrefs.count) {
1271 node = unres->leafrefs.objs[unres->leafrefs.count - 1];
1272 cctx.cur_mod = node->module;
1273 cctx.pmod = node->module->parsed;
1274
Radek Krejciddace2c2021-01-08 11:30:56 +01001275 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001276
Michal Vasko405cc9e2020-12-01 12:01:27 +01001277 /* store pointer to the real type */
1278 type = ((struct lysc_node_leaf *)node)->type;
1279 if (type->basetype == LY_TYPE_LEAFREF) {
1280 for (typeiter = ((struct lysc_type_leafref *)type)->realtype;
1281 typeiter->basetype == LY_TYPE_LEAFREF;
1282 typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
1283 ((struct lysc_type_leafref *)type)->realtype = typeiter;
1284 } else if (type->basetype == LY_TYPE_UNION) {
1285 LY_ARRAY_FOR(((struct lysc_type_union *)type)->types, v) {
1286 if (((struct lysc_type_union *)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
1287 for (typeiter = ((struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v])->realtype;
1288 typeiter->basetype == LY_TYPE_LEAFREF;
1289 typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
1290 ((struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v])->realtype = typeiter;
1291 }
1292 }
1293 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001294 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001295
1296 ly_set_rm_index(&unres->leafrefs, unres->leafrefs.count - 1, NULL);
1297 }
1298
1299 /* check xpath */
1300 while (unres->xpath.count) {
1301 node = unres->xpath.objs[unres->xpath.count - 1];
1302 cctx.cur_mod = node->module;
1303 cctx.pmod = node->module->parsed;
1304
Radek Krejciddace2c2021-01-08 11:30:56 +01001305 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001306
1307 ret = lys_compile_unres_xpath(&cctx, node, unres);
Radek Krejciddace2c2021-01-08 11:30:56 +01001308 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001309 LY_CHECK_RET(ret);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001310
1311 ly_set_rm_index(&unres->xpath, unres->xpath.count - 1, NULL);
1312 }
1313
1314 /* finish incomplete default values compilation */
1315 while (unres->dflts.count) {
1316 struct lysc_unres_dflt *r = unres->dflts.objs[unres->dflts.count - 1];
1317 cctx.cur_mod = r->leaf->module;
1318 cctx.pmod = r->leaf->module->parsed;
1319
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001320 LOG_LOCSET(&r->leaf->node, NULL, NULL, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001321
Radek Krejci2efc45b2020-12-22 16:25:44 +01001322 if (r->leaf->nodetype == LYS_LEAF) {
1323 ret = lys_compile_unres_leaf_dlft(&cctx, r->leaf, r->dflt, unres);
1324 } else {
1325 ret = lys_compile_unres_llist_dflts(&cctx, r->llist, r->dflt, r->dflts, unres);
1326 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001327 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001328 LY_CHECK_RET(ret);
1329
1330 lysc_unres_dflt_free(ctx, r);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001331 ly_set_rm_index(&unres->dflts, unres->dflts.count - 1, NULL);
1332 }
1333
1334 /* some unres items may have been added */
1335 if (unres->leafrefs.count || unres->xpath.count || unres->dflts.count) {
1336 return lys_compile_unres_glob(ctx, unres);
1337 }
1338
1339 return LY_SUCCESS;
1340}
1341
1342void
1343lys_compile_unres_glob_revert(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1344{
1345 uint32_t i;
1346 struct lys_module *m;
1347
1348 for (i = 0; i < unres->implementing.count; ++i) {
1349 m = unres->implementing.objs[i];
1350 assert(m->implemented);
1351
1352 /* make the module correctly non-implemented again */
1353 m->implemented = 0;
1354 lys_precompile_augments_deviations_revert(ctx, m);
1355 }
1356
1357 for (i = 0; i < unres->creating.count; ++i) {
1358 m = unres->creating.objs[i];
1359
1360 /* remove the module from the context and free it */
1361 ly_set_rm(&ctx->list, m, NULL);
1362 lys_module_free(m, NULL);
1363 }
1364
1365 if (unres->implementing.count) {
1366 /* recompile because some implemented modules are no longer implemented */
1367 lys_recompile(ctx, 0);
1368 }
1369}
1370
1371void
1372lys_compile_unres_glob_erase(const struct ly_ctx *ctx, struct lys_glob_unres *unres)
1373{
1374 uint32_t i;
1375
1376 ly_set_erase(&unres->implementing, NULL);
1377 ly_set_erase(&unres->creating, NULL);
1378 for (i = 0; i < unres->dflts.count; ++i) {
1379 lysc_unres_dflt_free(ctx, unres->dflts.objs[i]);
1380 }
1381 ly_set_erase(&unres->dflts, NULL);
1382 ly_set_erase(&unres->xpath, NULL);
1383 ly_set_erase(&unres->leafrefs, NULL);
1384}
1385
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001386/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001387 * @brief Finish compilation of all the module unres sets in a compile context.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001388 *
1389 * @param[in] ctx Compile context with unres sets.
1390 * @return LY_ERR value.
1391 */
1392static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001393lys_compile_unres_mod(struct lysc_ctx *ctx)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001394{
1395 struct lysc_node *node;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001396 struct lysc_augment *aug;
1397 struct lysc_deviation *dev;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001398 uint32_t i;
1399
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001400 /* remove all disabled nodes */
1401 for (i = 0; i < ctx->disabled.count; ++i) {
1402 node = ctx->disabled.snodes[i];
1403 if (node->flags & LYS_KEY) {
Radek Krejciddace2c2021-01-08 11:30:56 +01001404 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001405 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Key \"%s\" is disabled by its if-features.", node->name);
Radek Krejciddace2c2021-01-08 11:30:56 +01001406 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001407 return LY_EVALID;
1408 }
1409
Radek Krejci2a9fc652021-01-22 17:44:34 +01001410 lysc_node_free(ctx->ctx, node, 1);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001411 }
1412
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001413 /* check that all augments were applied */
1414 for (i = 0; i < ctx->augs.count; ++i) {
1415 aug = ctx->augs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001416 lysc_update_path(ctx, NULL, "{augment}");
1417 lysc_update_path(ctx, NULL, aug->nodeid->expr);
1418 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Augment target node \"%s\" from module \"%s\" was not found.",
1419 aug->nodeid->expr, LYSP_MODULE_NAME(aug->nodeid_pmod));
1420 lysc_update_path(ctx, NULL, NULL);
1421 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001422 }
1423 if (ctx->augs.count) {
1424 return LY_ENOTFOUND;
1425 }
1426
1427 /* check that all deviations were applied */
1428 for (i = 0; i < ctx->devs.count; ++i) {
1429 dev = ctx->devs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001430 lysc_update_path(ctx, NULL, "{deviation}");
1431 lysc_update_path(ctx, NULL, dev->nodeid->expr);
1432 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Deviation(s) target node \"%s\" from module \"%s\" was not found.",
1433 dev->nodeid->expr, LYSP_MODULE_NAME(dev->dev_pmods[0]));
1434 lysc_update_path(ctx, NULL, NULL);
1435 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001436 }
1437 if (ctx->devs.count) {
1438 return LY_ENOTFOUND;
1439 }
1440
1441 return LY_SUCCESS;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001442}
1443
1444/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001445 * @brief Erase all the module unres sets in a compile context.
1446 *
1447 * @param[in] ctx Compile context with unres sets.
1448 * @param[in] error Whether the compilation finished with an error or not.
1449 */
1450static void
1451lys_compile_unres_mod_erase(struct lysc_ctx *ctx, ly_bool error)
1452{
1453 uint32_t i;
1454
1455 ly_set_erase(&ctx->groupings, NULL);
1456 ly_set_erase(&ctx->tpdf_chain, NULL);
1457 ly_set_erase(&ctx->disabled, NULL);
1458
1459 if (!error) {
1460 /* there can be no leftover deviations or augments */
1461 LY_CHECK_ERR_RET(ctx->augs.count, LOGINT(ctx->ctx), );
1462 LY_CHECK_ERR_RET(ctx->devs.count, LOGINT(ctx->ctx), );
1463
1464 ly_set_erase(&ctx->augs, NULL);
1465 ly_set_erase(&ctx->devs, NULL);
1466 ly_set_erase(&ctx->uses_augs, NULL);
1467 ly_set_erase(&ctx->uses_rfns, NULL);
1468 } else {
1469 for (i = 0; i < ctx->augs.count; ++i) {
1470 lysc_augment_free(ctx->ctx, ctx->augs.objs[i]);
1471 }
1472 ly_set_erase(&ctx->augs, NULL);
1473 for (i = 0; i < ctx->devs.count; ++i) {
1474 lysc_deviation_free(ctx->ctx, ctx->devs.objs[i]);
1475 }
1476 ly_set_erase(&ctx->devs, NULL);
1477 for (i = 0; i < ctx->uses_augs.count; ++i) {
1478 lysc_augment_free(ctx->ctx, ctx->uses_augs.objs[i]);
1479 }
1480 ly_set_erase(&ctx->uses_augs, NULL);
1481 for (i = 0; i < ctx->uses_rfns.count; ++i) {
1482 lysc_refine_free(ctx->ctx, ctx->uses_rfns.objs[i]);
1483 }
1484 ly_set_erase(&ctx->uses_rfns, NULL);
1485 }
1486}
1487
1488/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001489 * @brief Compile identites in the current module and all its submodules.
1490 *
1491 * @param[in] ctx Compile context.
1492 * @return LY_ERR value.
1493 */
1494static LY_ERR
1495lys_compile_identities(struct lysc_ctx *ctx)
1496{
1497 struct lysp_submodule *submod;
1498 LY_ARRAY_COUNT_TYPE u;
1499
1500 if (!ctx->cur_mod->identities) {
1501 LY_CHECK_RET(lys_identity_precompile(ctx, NULL, NULL, ctx->cur_mod->parsed->identities, &ctx->cur_mod->identities));
1502 LY_ARRAY_FOR(ctx->cur_mod->parsed->includes, u) {
1503 submod = ctx->cur_mod->parsed->includes[u].submodule;
1504 LY_CHECK_RET(lys_identity_precompile(ctx, NULL, NULL, submod->identities, &ctx->cur_mod->identities));
1505 }
1506 }
1507
1508 if (ctx->cur_mod->parsed->identities) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001509 LY_CHECK_RET(lys_compile_identities_derived(ctx, ctx->cur_mod->parsed->identities, &ctx->cur_mod->identities));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001510 }
1511 lysc_update_path(ctx, NULL, "{submodule}");
1512 LY_ARRAY_FOR(ctx->cur_mod->parsed->includes, u) {
1513
1514 submod = ctx->cur_mod->parsed->includes[u].submodule;
1515 if (submod->identities) {
1516 lysc_update_path(ctx, NULL, submod->name);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001517 LY_CHECK_RET(lys_compile_identities_derived(ctx, submod->identities, &ctx->cur_mod->identities));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001518 lysc_update_path(ctx, NULL, NULL);
1519 }
1520 }
1521 lysc_update_path(ctx, NULL, NULL);
1522
1523 return LY_SUCCESS;
1524}
1525
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001526LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001527lys_recompile(struct ly_ctx *ctx, ly_bool log)
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001528{
1529 uint32_t idx;
1530 struct lys_module *mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001531 struct lys_glob_unres unres = {0};
1532 LY_ERR ret = LY_SUCCESS;
Radek Krejci430a5582020-12-01 13:35:18 +01001533 uint32_t prev_lo = 0;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001534
1535 if (!log) {
1536 /* recompile, must succeed because the modules were already compiled; hide messages because any
1537 * warnings were already printed, are not really relevant, and would hide the real error */
1538 prev_lo = ly_log_options(0);
1539 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001540
1541 /* free all the modules */
1542 for (idx = 0; idx < ctx->list.count; ++idx) {
1543 mod = ctx->list.objs[idx];
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001544 if (mod->compiled) {
1545 /* free the module */
1546 lysc_module_free(mod->compiled, NULL);
1547 mod->compiled = NULL;
1548 }
1549
1550 /* free precompiled iffeatures */
1551 lys_free_feature_iffeatures(mod->parsed);
1552 }
1553
1554 /* recompile all the modules */
1555 for (idx = 0; idx < ctx->list.count; ++idx) {
1556 mod = ctx->list.objs[idx];
Michal Vasko405cc9e2020-12-01 12:01:27 +01001557 if (!mod->implemented || mod->compiled) {
1558 /* nothing to do */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001559 continue;
1560 }
1561
Michal Vasko405cc9e2020-12-01 12:01:27 +01001562 /* recompile */
1563 ret = lys_compile(mod, 0, &unres);
1564 if (ret) {
1565 if (!log) {
1566 LOGERR(mod->ctx, ret, "Recompilation of module \"%s\" failed.", mod->name);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001567 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001568 goto cleanup;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001569 }
1570 }
1571
Michal Vasko405cc9e2020-12-01 12:01:27 +01001572 /* resolve global unres */
1573 LY_CHECK_GOTO(ret = lys_compile_unres_glob(ctx, &unres), cleanup);
1574
1575cleanup:
1576 if (!log) {
1577 ly_log_options(prev_lo);
1578 }
1579 lys_compile_unres_glob_erase(ctx, &unres);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001580 return ret;
1581}
1582
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001583LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001584lys_compile(struct lys_module *mod, uint32_t options, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001585{
1586 struct lysc_ctx ctx = {0};
1587 struct lysc_module *mod_c;
1588 struct lysp_module *sp;
1589 struct lysp_submodule *submod;
1590 struct lysp_node *pnode;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001591 struct lysp_node_grp *grp;
1592 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001593 LY_ERR ret = LY_SUCCESS;
1594
1595 LY_CHECK_ARG_RET(NULL, mod, mod->parsed, !mod->compiled, mod->ctx, LY_EINVAL);
1596
1597 if (!mod->implemented) {
1598 /* just imported modules are not compiled */
1599 return LY_SUCCESS;
1600 }
1601
1602 /* context will be changed */
1603 ++mod->ctx->module_set_id;
1604
1605 sp = mod->parsed;
1606
1607 ctx.ctx = mod->ctx;
1608 ctx.cur_mod = mod;
1609 ctx.pmod = sp;
1610 ctx.options = options;
1611 ctx.path_len = 1;
1612 ctx.path[0] = '/';
Michal Vasko405cc9e2020-12-01 12:01:27 +01001613 ctx.unres = unres;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001614
1615 mod->compiled = mod_c = calloc(1, sizeof *mod_c);
1616 LY_CHECK_ERR_RET(!mod_c, LOGMEM(mod->ctx), LY_EMEM);
1617 mod_c->mod = mod;
1618
1619 /* process imports */
1620 LY_ARRAY_FOR(sp->imports, u) {
1621 LY_CHECK_GOTO(ret = lys_compile_import(&ctx, &sp->imports[u]), error);
1622 }
1623
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001624 /* identities */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001625 LY_CHECK_GOTO(ret = lys_compile_identities(&ctx), error);
1626
1627 /* augments and deviations */
1628 LY_CHECK_GOTO(ret = lys_precompile_augments_deviations(&ctx), error);
1629
1630 /* compile augments and deviations of our module from other modules so they can be applied during compilation */
1631 LY_CHECK_GOTO(ret = lys_precompile_own_augments(&ctx), error);
1632 LY_CHECK_GOTO(ret = lys_precompile_own_deviations(&ctx), error);
1633
1634 /* data nodes */
1635 LY_LIST_FOR(sp->data, pnode) {
1636 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), error);
1637 }
1638
Radek Krejci2a9fc652021-01-22 17:44:34 +01001639 /* top-level RPCs */
1640 LY_LIST_FOR((struct lysp_node *)sp->rpcs, pnode) {
1641 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), error);
1642 }
1643
1644 /* top-level notifications */
1645 LY_LIST_FOR((struct lysp_node *)sp->notifs, pnode) {
1646 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), error);
1647 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001648
1649 /* extension instances */
1650 COMPILE_EXTS_GOTO(&ctx, sp->exts, mod_c->exts, mod_c, LYEXT_PAR_MODULE, ret, error);
1651
1652 /* the same for submodules */
1653 LY_ARRAY_FOR(sp->includes, u) {
1654 submod = sp->includes[u].submodule;
1655 ctx.pmod = (struct lysp_module *)submod;
1656
1657 LY_LIST_FOR(submod->data, pnode) {
1658 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
1659 LY_CHECK_GOTO(ret, error);
1660 }
1661
Radek Krejci2a9fc652021-01-22 17:44:34 +01001662 LY_LIST_FOR((struct lysp_node *)submod->rpcs, pnode) {
1663 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
1664 LY_CHECK_GOTO(ret, error);
1665 }
1666
1667 LY_LIST_FOR((struct lysp_node *)submod->notifs, pnode) {
1668 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
1669 LY_CHECK_GOTO(ret, error);
1670 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001671
1672 COMPILE_EXTS_GOTO(&ctx, submod->exts, mod_c->exts, mod_c, LYEXT_PAR_MODULE, ret, error);
1673 }
Michal Vasko12606ee2020-11-25 17:05:11 +01001674 ctx.pmod = sp;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001675
1676 /* validate non-instantiated groupings from the parsed schema,
1677 * without it we would accept even the schemas with invalid grouping specification */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001678 ctx.options |= LYS_COMPILE_GROUPING;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001679 LY_LIST_FOR(sp->groupings, grp) {
1680 if (!(grp->flags & LYS_USED_GRP)) {
1681 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), error);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001682 }
1683 }
1684 LY_LIST_FOR(sp->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001685 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1686 if (!(grp->flags & LYS_USED_GRP)) {
1687 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), error);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001688 }
1689 }
1690 }
1691 LY_ARRAY_FOR(sp->includes, u) {
1692 submod = sp->includes[u].submodule;
1693 ctx.pmod = (struct lysp_module *)submod;
1694
Radek Krejci2a9fc652021-01-22 17:44:34 +01001695 LY_LIST_FOR(submod->groupings, grp) {
1696 if (!(grp->flags & LYS_USED_GRP)) {
1697 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), error);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001698 }
1699 }
1700 LY_LIST_FOR(submod->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001701 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1702 if (!(grp->flags & LYS_USED_GRP)) {
1703 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), error);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001704 }
1705 }
1706 }
1707 }
1708 ctx.pmod = sp;
1709
Radek Krejciddace2c2021-01-08 11:30:56 +01001710 LOG_LOCBACK(0, 0, 1, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001711
Michal Vasko405cc9e2020-12-01 12:01:27 +01001712 /* finish compilation for all unresolved module items in the context */
1713 LY_CHECK_GOTO(ret = lys_compile_unres_mod(&ctx), error);
Michal Vasko12606ee2020-11-25 17:05:11 +01001714
Michal Vasko405cc9e2020-12-01 12:01:27 +01001715 lys_compile_unres_mod_erase(&ctx, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001716 return LY_SUCCESS;
1717
1718error:
Radek Krejciddace2c2021-01-08 11:30:56 +01001719 LOG_LOCBACK(0, 0, 1, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001720 lys_precompile_augments_deviations_revert(ctx.ctx, mod);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001721 lys_compile_unres_mod_erase(&ctx, 1);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001722 lysc_module_free(mod_c, NULL);
1723 mod->compiled = NULL;
1724
1725 return ret;
1726}