blob: 19e8a3a616bbc4452364a59bb86193536acc177c [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"
Radek Krejci77114102021-03-10 15:21:57 +010035#include "plugins_exts_compile.h"
Radek Krejci3e6632f2021-03-22 22:08:21 +010036#include "plugins_internal.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020037#include "plugins_types.h"
38#include "schema_compile_amend.h"
39#include "schema_compile_node.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010040#include "schema_features.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020041#include "set.h"
42#include "tree.h"
43#include "tree_data.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020044#include "tree_schema.h"
45#include "tree_schema_internal.h"
46#include "xpath.h"
47
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020048/**
49 * @brief Fill in the prepared compiled extensions definition structure according to the parsed extension definition.
50 */
51static LY_ERR
52lys_compile_extension(struct lysc_ctx *ctx, const struct lys_module *ext_mod, struct lysp_ext *ext_p, struct lysc_ext **ext)
53{
54 LY_ERR ret = LY_SUCCESS;
55
Radek Krejci720d2612021-03-03 19:44:22 +010056 if (ext_p->compiled && (ext_p->compiled->refcount == 1)) {
57 /* context recompilation - all the extension instances were previously freed (the last link to the compiled extension
58 * remains from the parsed extension definition) and now we are recompiling them again, to have the up-to-date
59 * extension definition, we have to recompile it as well now */
60 lysc_extension_free(ctx->ctx, &ext_p->compiled);
61 }
62
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020063 if (!ext_p->compiled) {
64 lysc_update_path(ctx, NULL, "{extension}");
65 lysc_update_path(ctx, NULL, ext_p->name);
66
67 /* compile the extension definition */
68 ext_p->compiled = calloc(1, sizeof **ext);
69 ext_p->compiled->refcount = 1;
70 DUP_STRING_GOTO(ctx->ctx, ext_p->name, ext_p->compiled->name, ret, done);
Radek Krejci9f87b0c2021-03-05 14:45:26 +010071 DUP_STRING_GOTO(ctx->ctx, ext_p->argname, ext_p->compiled->argname, ret, done);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020072 ext_p->compiled->module = (struct lys_module *)ext_mod;
Radek Krejciab430862021-03-02 20:13:40 +010073 COMPILE_EXTS_GOTO(ctx, ext_p->exts, ext_p->compiled->exts, *ext, ret, done);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020074
75 lysc_update_path(ctx, NULL, NULL);
76 lysc_update_path(ctx, NULL, NULL);
77
78 /* find extension definition plugin */
Radek Krejci3e6632f2021-03-22 22:08:21 +010079 ext_p->compiled->plugin = lyplg_find(LYPLG_EXTENSION, ext_p->compiled->module->name,
80 ext_p->compiled->module->revision, ext_p->compiled->name);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020081 }
82
83 *ext = lysc_ext_dup(ext_p->compiled);
84
85done:
Radek Krejci2efc45b2020-12-22 16:25:44 +010086 if (ret) {
87 lysc_update_path(ctx, NULL, NULL);
88 lysc_update_path(ctx, NULL, NULL);
89 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020090 return ret;
91}
92
93LY_ERR
94lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext, void *parent,
Radek Krejciab430862021-03-02 20:13:40 +010095 const struct lys_module *ext_mod)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020096{
Radek Krejci85ac8312021-03-03 20:21:33 +010097 LY_ERR ret = LY_SUCCESS;
98 struct lysp_ext *ext_def;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020099
Radek Krejciab430862021-03-02 20:13:40 +0100100 ext->parent_stmt = ext_p->parent_stmt;
101 ext->parent_stmt_index = ext_p->parent_stmt_index;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200102 ext->module = ctx->cur_mod;
103 ext->parent = parent;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200104
Radek Krejciab430862021-03-02 20:13:40 +0100105 lysc_update_path(ctx, LY_STMT_IS_NODE(ext->parent_stmt) ? ((struct lysc_node *)ext->parent)->module : NULL, "{extension}");
Michal Vaskofc2cd072021-02-24 13:17:17 +0100106 lysc_update_path(ctx, NULL, ext_p->name);
107
Radek Krejci85ac8312021-03-03 20:21:33 +0100108 LY_CHECK_GOTO(ret = lysp_ext_find_definition(ctx->ctx, ext_p, &ext_mod, &ext_def), cleanup);
109 LY_CHECK_GOTO(ret = lys_compile_extension(ctx, ext_mod, ext_def, &ext->def), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200110
Radek Krejci9f87b0c2021-03-05 14:45:26 +0100111 if (ext_def->argname) {
Radek Krejci85ac8312021-03-03 20:21:33 +0100112 LY_CHECK_GOTO(ret = lysp_ext_instance_resolve_argument(ctx->ctx, ext_p, ext_def), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200113 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200114
Radek Krejci85ac8312021-03-03 20:21:33 +0100115 DUP_STRING(ctx->ctx, ext_p->argument, ext->argument, ret);
116 LY_CHECK_RET(ret);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200117
118 if (ext->def->plugin && ext->def->plugin->compile) {
119 if (ext->argument) {
Radek Krejcia6016992021-03-03 10:13:41 +0100120 lysc_update_path(ctx, ext->module, ext->argument);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200121 }
Michal Vaskofc2cd072021-02-24 13:17:17 +0100122 ret = ext->def->plugin->compile(ctx, ext_p, ext);
Radek Krejcicc21a4f2021-02-09 15:23:31 +0100123 if (ret == LY_ENOT) {
124 lysc_ext_instance_free(ctx->ctx, ext);
125 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200126 if (ext->argument) {
127 lysc_update_path(ctx, NULL, NULL);
128 }
Michal Vaskofc2cd072021-02-24 13:17:17 +0100129 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200130 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200131
132cleanup:
Radek Krejci2efc45b2020-12-22 16:25:44 +0100133 lysc_update_path(ctx, NULL, NULL);
Michal Vaskofc2cd072021-02-24 13:17:17 +0100134 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200135
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200136 return ret;
137}
138
139struct lysc_ext *
140lysc_ext_dup(struct lysc_ext *orig)
141{
142 ++orig->refcount;
143 return orig;
144}
145
Radek Krejcidab4f0b2021-03-29 14:07:18 +0200146API LY_ERR
Radek Krejci1b2eef82021-02-17 11:17:27 +0100147lysc_ext_substmt(const struct lysc_ext_instance *ext, enum ly_stmt substmt, void **instance_p, enum ly_stmt_cardinality *cardinality_p)
148{
149 LY_ARRAY_COUNT_TYPE u;
150
151 LY_ARRAY_FOR(ext->substmts, u) {
Radek Krejci61837f72021-03-02 19:53:59 +0100152 if (LY_STMT_IS_DATA_NODE(substmt)) {
153 if (!LY_STMT_IS_DATA_NODE(ext->substmts[u].stmt)) {
Radek Krejci1b2eef82021-02-17 11:17:27 +0100154 continue;
155 }
156 } else if (LY_STMT_IS_OP(substmt)) {
157 if (!LY_STMT_IS_OP(ext->substmts[u].stmt)) {
158 continue;
159 }
160 } else if (ext->substmts[u].stmt != substmt) {
161 continue;
162 }
163
164 /* match */
165 if (cardinality_p) {
166 *cardinality_p = ext->substmts[u].cardinality;
167 }
168 if (instance_p) {
169 *instance_p = ext->substmts[u].storage;
170 }
171 return LY_SUCCESS;
172 }
173
174 return LY_ENOT;
175}
176
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200177static void
178lysc_unres_dflt_free(const struct ly_ctx *ctx, struct lysc_unres_dflt *r)
179{
180 assert(!r->dflt || !r->dflts);
181 if (r->dflt) {
182 lysp_qname_free((struct ly_ctx *)ctx, r->dflt);
183 free(r->dflt);
184 } else {
185 FREE_ARRAY((struct ly_ctx *)ctx, r->dflts, lysp_qname_free);
186 }
187 free(r);
188}
189
190void
Radek Krejcia6016992021-03-03 10:13:41 +0100191lysc_update_path(struct lysc_ctx *ctx, struct lys_module *parent_module, const char *name)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200192{
193 int len;
194 uint8_t nextlevel = 0; /* 0 - no starttag, 1 - '/' starttag, 2 - '=' starttag + '}' endtag */
195
196 if (!name) {
197 /* removing last path segment */
198 if (ctx->path[ctx->path_len - 1] == '}') {
199 for ( ; ctx->path[ctx->path_len] != '=' && ctx->path[ctx->path_len] != '{'; --ctx->path_len) {}
200 if (ctx->path[ctx->path_len] == '=') {
201 ctx->path[ctx->path_len++] = '}';
202 } else {
203 /* not a top-level special tag, remove also preceiding '/' */
204 goto remove_nodelevel;
205 }
206 } else {
207remove_nodelevel:
208 for ( ; ctx->path[ctx->path_len] != '/'; --ctx->path_len) {}
209 if (ctx->path_len == 0) {
210 /* top-level (last segment) */
211 ctx->path_len = 1;
212 }
213 }
214 /* set new terminating NULL-byte */
215 ctx->path[ctx->path_len] = '\0';
216 } else {
217 if (ctx->path_len > 1) {
Radek Krejcia6016992021-03-03 10:13:41 +0100218 if (!parent_module && (ctx->path[ctx->path_len - 1] == '}') && (ctx->path[ctx->path_len - 2] != '\'')) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200219 /* extension of the special tag */
220 nextlevel = 2;
221 --ctx->path_len;
222 } else {
223 /* there is already some path, so add next level */
224 nextlevel = 1;
225 }
226 } /* else the path is just initiated with '/', so do not add additional slash in case of top-level nodes */
227
228 if (nextlevel != 2) {
Radek Krejcia6016992021-03-03 10:13:41 +0100229 if ((parent_module && (parent_module == ctx->cur_mod)) || (!parent_module && (ctx->path_len > 1) && (name[0] == '{'))) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200230 /* module not changed, print the name unprefixed */
231 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s", nextlevel ? "/" : "", name);
232 } else {
233 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s:%s", nextlevel ? "/" : "", ctx->cur_mod->name, name);
234 }
235 } else {
236 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "='%s'}", name);
237 }
238 if (len >= LYSC_CTX_BUFSIZE - (int)ctx->path_len) {
239 /* output truncated */
240 ctx->path_len = LYSC_CTX_BUFSIZE - 1;
241 } else {
242 ctx->path_len += len;
243 }
244 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100245
Radek Krejciddace2c2021-01-08 11:30:56 +0100246 LOG_LOCBACK(0, 0, 1, 0);
247 LOG_LOCSET(NULL, NULL, ctx->path, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200248}
249
250/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200251 * @brief Compile information in the import statement - make sure there is the target module
252 * @param[in] ctx Compile context.
253 * @param[in] imp_p The parsed import statement structure to fill the module to.
254 * @return LY_ERR value.
255 */
256static LY_ERR
257lys_compile_import(struct lysc_ctx *ctx, struct lysp_import *imp_p)
258{
259 const struct lys_module *mod = NULL;
260 LY_ERR ret = LY_SUCCESS;
261
262 /* make sure that we have the parsed version (lysp_) of the imported module to import groupings or typedefs.
263 * The compiled version is needed only for augments, deviates and leafrefs, so they are checked (and added,
264 * if needed) when these nodes are finally being instantiated and validated at the end of schema compilation. */
265 if (!imp_p->module->parsed) {
266 /* try to use filepath if present */
267 if (imp_p->module->filepath) {
268 struct ly_in *in;
269 if (ly_in_new_filepath(imp_p->module->filepath, 0, &in)) {
270 LOGINT(ctx->ctx);
271 } else {
272 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 +0100273 ".yin") ? LYS_IN_YIN : LYS_IN_YANG, NULL, &mod));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200274 if (mod != imp_p->module) {
275 LOGERR(ctx->ctx, LY_EINT, "Filepath \"%s\" of the module \"%s\" does not match.",
276 imp_p->module->filepath, imp_p->module->name);
277 mod = NULL;
278 }
279 }
280 ly_in_free(in, 1);
281 }
282 if (!mod) {
Michal Vasko405cc9e2020-12-01 12:01:27 +0100283 if (lysp_load_module(ctx->ctx, imp_p->module->name, imp_p->module->revision, 0, NULL, ctx->unres,
284 (struct lys_module **)&mod)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200285 LOGERR(ctx->ctx, LY_ENOTFOUND, "Unable to reload \"%s\" module to import it into \"%s\", source data not found.",
286 imp_p->module->name, ctx->cur_mod->name);
287 return LY_ENOTFOUND;
288 }
289 }
290 }
291
292 return ret;
293}
294
295LY_ERR
296lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
297 struct lysp_ident *identities_p, struct lysc_ident **identities)
298{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100299 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200300 struct lysc_ctx context = {0};
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100301 struct lysc_ident *ident;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200302 LY_ERR ret = LY_SUCCESS;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100303 ly_bool enabled;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200304
305 assert(ctx_sc || ctx);
306
307 if (!ctx_sc) {
308 context.ctx = ctx;
Radek Krejci3aac9a72020-12-01 12:24:26 +0100309 context.cur_mod = parsed_mod ? parsed_mod->mod : NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200310 context.pmod = parsed_mod;
311 context.path_len = 1;
312 context.path[0] = '/';
313 ctx_sc = &context;
314 }
315
316 if (!identities_p) {
317 return LY_SUCCESS;
318 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200319
320 lysc_update_path(ctx_sc, NULL, "{identity}");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200321 LY_ARRAY_FOR(identities_p, u) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100322 /* evaluate if-features */
323 LY_CHECK_RET(lys_eval_iffeatures(ctx, identities_p[u].iffeatures, &enabled));
324 if (!enabled) {
325 continue;
326 }
327
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200328 lysc_update_path(ctx_sc, NULL, identities_p[u].name);
329
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100330 /* add new compiled identity */
331 LY_ARRAY_NEW_RET(ctx_sc->ctx, *identities, ident, LY_EMEM);
332
333 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].name, ident->name, ret, done);
334 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].dsc, ident->dsc, ret, done);
335 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].ref, ident->ref, ret, done);
336 ident->module = ctx_sc->cur_mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200337 /* backlinks (derived) can be added no sooner than when all the identities in the current module are present */
Radek Krejciab430862021-03-02 20:13:40 +0100338 COMPILE_EXTS_GOTO(ctx_sc, identities_p[u].exts, ident->exts, ident, ret, done);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100339 ident->flags = identities_p[u].flags;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200340
341 lysc_update_path(ctx_sc, NULL, NULL);
342 }
343 lysc_update_path(ctx_sc, NULL, NULL);
344done:
345 return ret;
346}
347
348/**
349 * @brief Check circular dependency of identities - identity MUST NOT reference itself (via their base statement).
350 *
351 * The function works in the same way as lys_compile_feature_circular_check() with different structures and error messages.
352 *
353 * @param[in] ctx Compile context for logging.
354 * @param[in] ident The base identity (its derived list is being extended by the identity being currently processed).
355 * @param[in] derived The list of derived identities of the identity being currently processed (not the one provided as @p ident)
356 * @return LY_SUCCESS if everything is ok.
357 * @return LY_EVALID if the identity is derived from itself.
358 */
359static LY_ERR
360lys_compile_identity_circular_check(struct lysc_ctx *ctx, struct lysc_ident *ident, struct lysc_ident **derived)
361{
362 LY_ERR ret = LY_SUCCESS;
363 LY_ARRAY_COUNT_TYPE u, v;
364 struct ly_set recursion = {0};
365 struct lysc_ident *drv;
366
367 if (!derived) {
368 return LY_SUCCESS;
369 }
370
371 for (u = 0; u < LY_ARRAY_COUNT(derived); ++u) {
372 if (ident == derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100373 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200374 "Identity \"%s\" is indirectly derived from itself.", ident->name);
375 ret = LY_EVALID;
376 goto cleanup;
377 }
378 ret = ly_set_add(&recursion, derived[u], 0, NULL);
379 LY_CHECK_GOTO(ret, cleanup);
380 }
381
382 for (v = 0; v < recursion.count; ++v) {
383 drv = recursion.objs[v];
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200384 for (u = 0; u < LY_ARRAY_COUNT(drv->derived); ++u) {
385 if (ident == drv->derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100386 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200387 "Identity \"%s\" is indirectly derived from itself.", ident->name);
388 ret = LY_EVALID;
389 goto cleanup;
390 }
391 ret = ly_set_add(&recursion, drv->derived[u], 0, NULL);
392 LY_CHECK_GOTO(ret, cleanup);
393 }
394 }
395
396cleanup:
397 ly_set_erase(&recursion, NULL);
398 return ret;
399}
400
401LY_ERR
402lys_compile_identity_bases(struct lysc_ctx *ctx, const struct lysp_module *base_pmod, const char **bases_p,
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100403 struct lysc_ident *ident, struct lysc_ident ***bases, ly_bool *enabled)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200404{
405 LY_ARRAY_COUNT_TYPE u, v;
406 const char *s, *name;
407 const struct lys_module *mod;
408 struct lysc_ident **idref;
409
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100410 assert((ident && enabled) || bases);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200411
412 if ((LY_ARRAY_COUNT(bases_p) > 1) && (ctx->pmod->version < LYS_VERSION_1_1)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100413 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200414 "Multiple bases in %s are allowed only in YANG 1.1 modules.", ident ? "identity" : "identityref type");
415 return LY_EVALID;
416 }
417
418 LY_ARRAY_FOR(bases_p, u) {
419 s = strchr(bases_p[u], ':');
420 if (s) {
421 /* prefixed identity */
422 name = &s[1];
Michal Vaskob2d55bf2020-11-02 15:42:43 +0100423 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 +0200424 } else {
425 name = bases_p[u];
426 mod = base_pmod->mod;
427 }
428 if (!mod) {
429 if (ident) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100430 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200431 "Invalid prefix used for base (%s) of identity \"%s\".", bases_p[u], ident->name);
432 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100433 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200434 "Invalid prefix used for base (%s) of identityref.", bases_p[u]);
435 }
436 return LY_EVALID;
437 }
438
439 idref = NULL;
440 LY_ARRAY_FOR(mod->identities, v) {
441 if (!strcmp(name, mod->identities[v].name)) {
442 if (ident) {
443 if (ident == &mod->identities[v]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100444 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200445 "Identity \"%s\" is derived from itself.", ident->name);
446 return LY_EVALID;
447 }
448 LY_CHECK_RET(lys_compile_identity_circular_check(ctx, &mod->identities[v], ident->derived));
449 /* we have match! store the backlink */
450 LY_ARRAY_NEW_RET(ctx->ctx, mod->identities[v].derived, idref, LY_EMEM);
451 *idref = ident;
452 } else {
453 /* we have match! store the found identity */
454 LY_ARRAY_NEW_RET(ctx->ctx, *bases, idref, LY_EMEM);
455 *idref = &mod->identities[v];
456 }
457 break;
458 }
459 }
460 if (!idref || !(*idref)) {
Radek Krejci10443f42021-03-28 17:40:35 +0200461 if (ident || (ctx->options & LYS_COMPILE_DISABLED)) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100462 /* look into the parsed module to check whether the identity is not merely disabled */
463 LY_ARRAY_FOR(mod->parsed->identities, v) {
464 if (!strcmp(mod->parsed->identities[v].name, name)) {
Radek Krejci10443f42021-03-28 17:40:35 +0200465 if (ident) {
466 *enabled = 0;
467 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100468 return LY_SUCCESS;
469 }
470 }
Radek Krejci10443f42021-03-28 17:40:35 +0200471 }
472 if (ident) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100473 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200474 "Unable to find base (%s) of identity \"%s\".", bases_p[u], ident->name);
475 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100476 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200477 "Unable to find base (%s) of identityref.", bases_p[u]);
478 }
479 return LY_EVALID;
480 }
481 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100482
483 if (ident) {
484 *enabled = 1;
485 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200486 return LY_SUCCESS;
487}
488
489/**
490 * @brief For the given array of identities, set the backlinks from all their base identities.
491 * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
492 * @param[in] idents_p Array of identities definitions from the parsed schema structure.
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100493 * @param[in,out] idents Array of referencing identities to which the backlinks are supposed to be set. Any
494 * identities with disabled bases are removed.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200495 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
496 */
497static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100498lys_compile_identities_derived(struct lysc_ctx *ctx, struct lysp_ident *idents_p, struct lysc_ident **idents)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200499{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100500 LY_ARRAY_COUNT_TYPE u, v;
501 ly_bool enabled;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200502
503 lysc_update_path(ctx, NULL, "{identity}");
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100504
505restart:
Radek Krejcic7d13e32020-12-09 12:32:24 +0100506 for (u = 0, v = 0; u < LY_ARRAY_COUNT(*idents); ++u) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100507 /* find matching parsed identity, the disabled ones are missing in the compiled array */
508 while (v < LY_ARRAY_COUNT(idents_p)) {
509 if (idents_p[v].name == (*idents)[u].name) {
510 break;
511 }
512 ++v;
513 }
514 assert(v < LY_ARRAY_COUNT(idents_p));
515
516 if (!idents_p[v].bases) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200517 continue;
518 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100519 lysc_update_path(ctx, NULL, (*idents)[u].name);
520 LY_CHECK_RET(lys_compile_identity_bases(ctx, (*idents)[u].module->parsed, idents_p[v].bases, &(*idents)[u], NULL,
521 &enabled));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200522 lysc_update_path(ctx, NULL, NULL);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100523
524 if (!enabled) {
525 /* remove the identity */
526 lysc_ident_free(ctx->ctx, &(*idents)[u]);
527 LY_ARRAY_DECREMENT(*idents);
528 if (u < LY_ARRAY_COUNT(*idents)) {
529 memmove(&(*idents)[u], &(*idents)[u + 1], (LY_ARRAY_COUNT(*idents) - u) * sizeof **idents);
530 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100531
532 /* revert compilation of all the previous identities */
533 for (v = 0; v < u; ++v) {
534 LY_ARRAY_FREE((*idents)[v].derived);
Radek Krejci454820e2021-03-28 17:57:45 +0200535 (*idents)[v].derived = NULL;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100536 }
537
Michal Vasko74c82ae2020-11-03 17:36:53 +0100538 /* free the whole array if there are no identites left */
539 if (!LY_ARRAY_COUNT(*idents)) {
540 LY_ARRAY_FREE(*idents);
541 *idents = NULL;
542 }
543
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100544 /* restart the whole process without this identity */
545 goto restart;
546 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200547 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100548
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200549 lysc_update_path(ctx, NULL, NULL);
550 return LY_SUCCESS;
551}
552
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200553static void *
554lys_compile_extension_instance_storage(enum ly_stmt stmt, struct lysc_ext_substmt *substmts)
555{
556 for (LY_ARRAY_COUNT_TYPE u = 0; substmts[u].stmt; ++u) {
557 if (substmts[u].stmt == stmt) {
558 return substmts[u].storage;
559 }
560 }
561 return NULL;
562}
563
564LY_ERR
Radek Krejci6b88a462021-02-17 12:39:34 +0100565lys_compile_extension_instance(struct lysc_ctx *ctx, const struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200566{
567 LY_ERR ret = LY_EVALID, r;
568 LY_ARRAY_COUNT_TYPE u;
569 struct lysp_stmt *stmt;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200570 void *parsed = NULL, **compiled = NULL;
571
572 /* check for invalid substatements */
Radek Krejci6b88a462021-02-17 12:39:34 +0100573 for (stmt = ext_p->child; stmt; stmt = stmt->next) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200574 if (stmt->flags & (LYS_YIN_ATTR | LYS_YIN_ARGUMENT)) {
575 continue;
576 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100577 LY_ARRAY_FOR(ext->substmts, u) {
578 if (ext->substmts[u].stmt == stmt->kw) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200579 break;
580 }
581 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100582 if (u == LY_ARRAY_COUNT(ext->substmts)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100583 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, "Invalid keyword \"%s\" as a child of \"%s%s%s\" extension instance.",
Radek Krejci6b88a462021-02-17 12:39:34 +0100584 stmt->stmt, ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200585 goto cleanup;
586 }
587 }
588
589 /* TODO store inherited data, e.g. status first, but mark them somehow to allow to overwrite them and not detect duplicity */
590
Radek Krejci6b88a462021-02-17 12:39:34 +0100591 /* note into the compile context that we are processing extension now */
592 ctx->ext = ext;
593
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200594 /* keep order of the processing the same as the order in the defined substmts,
595 * the order is important for some of the statements depending on others (e.g. type needs status and units) */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200596
Radek Krejci6b88a462021-02-17 12:39:34 +0100597 LY_ARRAY_FOR(ext->substmts, u) {
598 uint64_t stmt_counter = 0;
599
600 for (stmt = ext_p->child; stmt; stmt = stmt->next) {
601 if (ext->substmts[u].stmt != stmt->kw) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200602 continue;
603 }
604
Radek Krejci6b88a462021-02-17 12:39:34 +0100605 parsed = NULL;
606 stmt_counter++;
607 if (ext->substmts[u].storage) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200608 switch (stmt->kw) {
Radek Krejci6b88a462021-02-17 12:39:34 +0100609 case LY_STMT_ACTION:
610 case LY_STMT_ANYDATA:
611 case LY_STMT_ANYXML:
612 case LY_STMT_CONTAINER:
613 case LY_STMT_CHOICE:
614 case LY_STMT_LEAF:
615 case LY_STMT_LEAF_LIST:
616 case LY_STMT_LIST:
617 case LY_STMT_NOTIFICATION:
618 case LY_STMT_RPC:
619 case LY_STMT_USES:
620 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
621 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
622
623 /* set storage as an alternative document root in the compile context */
624 r = lys_compile_node(ctx, parsed, NULL, 0, NULL);
625 lysp_node_free(ctx->ctx, parsed);
626 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200627 break;
Radek Krejci1b2eef82021-02-17 11:17:27 +0100628 case LY_STMT_DESCRIPTION:
629 case LY_STMT_REFERENCE:
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200630 case LY_STMT_UNITS: {
Radek Krejci6b88a462021-02-17 12:39:34 +0100631 const char **str_p;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200632
Radek Krejci6b88a462021-02-17 12:39:34 +0100633 if (ext->substmts[u].cardinality < LY_STMT_CARD_SOME) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200634 /* single item */
Radek Krejci6b88a462021-02-17 12:39:34 +0100635 if (*((const char **)ext->substmts[u].storage)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100636 LOGVAL(ctx->ctx, LY_VCODE_DUPSTMT, stmt->stmt);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200637 goto cleanup;
638 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100639 str_p = (const char **)ext->substmts[u].storage;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200640 } else {
641 /* sized array */
Radek Krejci6b88a462021-02-17 12:39:34 +0100642 const char ***strings_array = (const char ***)ext->substmts[u].storage;
643 LY_ARRAY_NEW_GOTO(ctx->ctx, *strings_array, str_p, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200644 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100645 r = lydict_insert(ctx->ctx, stmt->arg, 0, str_p);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200646 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
647 break;
648 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100649 case LY_STMT_IF_FEATURE: {
650 ly_bool enabled;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200651
Radek Krejci76c8c4e2021-02-17 10:16:48 +0100652 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200653 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
Radek Krejci6b88a462021-02-17 12:39:34 +0100654
655 r = lys_eval_iffeatures(ctx->ctx, parsed, &enabled);
656 FREE_ARRAY(ctx->ctx, (struct lysp_qname *)parsed, lysp_qname_free);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100657 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
658 if (!enabled) {
659 /* it is disabled, remove the whole extension instance */
660 return LY_ENOT;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200661 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200662 break;
Radek Krejci6b88a462021-02-17 12:39:34 +0100663 }
664 case LY_STMT_STATUS:
665 assert(ext->substmts[u].cardinality < LY_STMT_CARD_SOME);
666 LY_CHECK_ERR_GOTO(r = lysp_stmt_parse(ctx, stmt, &ext->substmts[u].storage, /* TODO */ NULL), ret = r, cleanup);
667 break;
668 case LY_STMT_TYPE: {
669 uint16_t *flags = lys_compile_extension_instance_storage(LY_STMT_STATUS, ext->substmts);
670 const char **units = lys_compile_extension_instance_storage(LY_STMT_UNITS, ext->substmts);
671
672 if (ext->substmts[u].cardinality < LY_STMT_CARD_SOME) {
673 /* single item */
674 if (*(struct lysc_type **)ext->substmts[u].storage) {
675 LOGVAL(ctx->ctx, LY_VCODE_DUPSTMT, stmt->stmt);
676 goto cleanup;
677 }
678 compiled = ext->substmts[u].storage;
679 } else {
680 /* sized array */
681 struct lysc_type ***types = (struct lysc_type ***)ext->substmts[u].storage, **type = NULL;
682 LY_ARRAY_NEW_GOTO(ctx->ctx, *types, type, ret, cleanup);
683 compiled = (void *)type;
684 }
685
686 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
687 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
688 r = lys_compile_type(ctx, NULL, flags ? *flags : 0, ext_p->name, parsed, (struct lysc_type **)compiled,
689 units && !*units ? units : NULL, NULL);
690 lysp_type_free(ctx->ctx, parsed);
691 free(parsed);
692 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
693 break;
694 }
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.",
Radek Krejci6b88a462021-02-17 12:39:34 +0100699 stmt->stmt, ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200700 goto cleanup;
701 }
702 }
703 }
704
Radek Krejci6b88a462021-02-17 12:39:34 +0100705 if (((ext->substmts[u].cardinality == LY_STMT_CARD_MAND) || (ext->substmts[u].cardinality == LY_STMT_CARD_SOME)) && !stmt_counter) {
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\".",
Radek Krejci6b88a462021-02-17 12:39:34 +0100707 ly_stmt2str(ext->substmts[u].stmt), ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200708 goto cleanup;
709 }
710 }
711
712 ret = LY_SUCCESS;
713
714cleanup:
Radek Krejci6b88a462021-02-17 12:39:34 +0100715 ctx->ext = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200716 return ret;
717}
718
719/**
720 * @brief Check when for cyclic dependencies.
721 *
722 * @param[in] set Set with all the referenced nodes.
723 * @param[in] node Node whose "when" referenced nodes are in @p set.
724 * @return LY_ERR value
725 */
726static LY_ERR
727lys_compile_unres_when_cyclic(struct lyxp_set *set, const struct lysc_node *node)
728{
729 struct lyxp_set tmp_set;
730 struct lyxp_set_scnode *xp_scnode;
731 uint32_t i, j;
732 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200733 LY_ERR ret = LY_SUCCESS;
734
735 memset(&tmp_set, 0, sizeof tmp_set);
736
737 /* prepare in_ctx of the set */
738 for (i = 0; i < set->used; ++i) {
739 xp_scnode = &set->val.scnodes[i];
740
Radek Krejcif13b87b2020-12-01 22:02:17 +0100741 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_START_USED) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200742 /* check node when, skip the context node (it was just checked) */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100743 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200744 }
745 }
746
747 for (i = 0; i < set->used; ++i) {
748 xp_scnode = &set->val.scnodes[i];
Radek Krejcif13b87b2020-12-01 22:02:17 +0100749 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200750 /* already checked */
751 continue;
752 }
753
754 if ((xp_scnode->type != LYXP_NODE_ELEM) || (xp_scnode->scnode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) ||
Radek Krejci9a3823e2021-01-27 20:26:46 +0100755 !lysc_node_when(xp_scnode->scnode)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200756 /* no when to check */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100757 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200758 continue;
759 }
760
761 node = xp_scnode->scnode;
762 do {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100763 struct lysc_when **when_list, *when;
764
Radek Krejciddace2c2021-01-08 11:30:56 +0100765 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci9a3823e2021-01-27 20:26:46 +0100766 when_list = lysc_node_when(node);
767 LY_ARRAY_FOR(when_list, u) {
768 when = when_list[u];
Michal Vasko400e9672021-01-11 13:39:17 +0100769 ret = lyxp_atomize(set->ctx, when->cond, node->module, LY_PREF_SCHEMA_RESOLVED, when->prefixes,
770 when->context, &tmp_set, LYXP_SCNODE_SCHEMA);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200771 if (ret != LY_SUCCESS) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100772 LOGVAL(set->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when->cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200773 goto cleanup;
774 }
775
776 for (j = 0; j < tmp_set.used; ++j) {
777 /* skip roots'n'stuff */
778 if (tmp_set.val.scnodes[j].type == LYXP_NODE_ELEM) {
779 /* try to find this node in our set */
780 uint32_t idx;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100781 if (lyxp_set_scnode_contains(set, tmp_set.val.scnodes[j].scnode, LYXP_NODE_ELEM, -1, &idx) &&
782 (set->val.scnodes[idx].in_ctx == LYXP_SET_SCNODE_START_USED)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100783 LOGVAL(set->ctx, LYVE_SEMANTICS, "When condition includes a self-reference.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200784 ret = LY_EVALID;
785 goto cleanup;
786 }
787
788 /* needs to be checked, if in both sets, will be ignored */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100789 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200790 } else {
791 /* no when, nothing to check */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100792 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200793 }
794 }
795
796 /* merge this set into the global when set */
797 lyxp_set_scnode_merge(set, &tmp_set);
798 }
799
800 /* check when of non-data parents as well */
801 node = node->parent;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100802
Radek Krejciddace2c2021-01-08 11:30:56 +0100803 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200804 } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE)));
805
806 /* this node when was checked (xp_scnode could have been reallocd) */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100807 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200808 }
809
810cleanup:
811 lyxp_set_free_content(&tmp_set);
812 return ret;
813}
814
815LY_ERR
816lysc_check_status(struct lysc_ctx *ctx, uint16_t flags1, void *mod1, const char *name1, uint16_t flags2, void *mod2,
817 const char *name2)
818{
819 uint16_t flg1, flg2;
820
821 flg1 = (flags1 & LYS_STATUS_MASK) ? (flags1 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
822 flg2 = (flags2 & LYS_STATUS_MASK) ? (flags2 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
823
824 if ((flg1 < flg2) && (mod1 == mod2)) {
825 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100826 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200827 "A %s definition \"%s\" is not allowed to reference %s definition \"%s\".",
828 flg1 == LYS_STATUS_CURR ? "current" : "deprecated", name1,
829 flg2 == LYS_STATUS_OBSLT ? "obsolete" : "deprecated", name2);
830 }
831 return LY_EVALID;
832 }
833
834 return LY_SUCCESS;
835}
836
Michal Vasko25d6ad02020-10-22 12:20:22 +0200837LY_ERR
838lys_compile_expr_implement(const struct ly_ctx *ctx, const struct lyxp_expr *expr, LY_PREFIX_FORMAT format,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100839 void *prefix_data, ly_bool implement, struct lys_glob_unres *unres, const struct lys_module **mod_p)
Michal Vaskocfaff232020-10-20 09:35:14 +0200840{
841 uint32_t i;
842 const char *ptr, *start;
843 const struct lys_module *mod;
844
Michal Vasko25d6ad02020-10-22 12:20:22 +0200845 assert(implement || mod_p);
846
Michal Vaskocfaff232020-10-20 09:35:14 +0200847 for (i = 0; i < expr->used; ++i) {
848 if ((expr->tokens[i] != LYXP_TOKEN_NAMETEST) && (expr->tokens[i] != LYXP_TOKEN_LITERAL)) {
849 /* token cannot have a prefix */
850 continue;
851 }
852
853 start = expr->expr + expr->tok_pos[i];
854 if (!(ptr = ly_strnchr(start, ':', expr->tok_len[i]))) {
855 /* token without a prefix */
856 continue;
857 }
858
859 if (!(mod = ly_resolve_prefix(ctx, start, ptr - start, format, prefix_data))) {
860 /* unknown prefix, do not care right now */
861 continue;
862 }
863
864 if (!mod->implemented) {
865 /* unimplemented module found */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200866 if (implement) {
Michal Vasko405cc9e2020-12-01 12:01:27 +0100867 LY_CHECK_RET(lys_set_implemented_r((struct lys_module *)mod, NULL, unres));
Michal Vasko25d6ad02020-10-22 12:20:22 +0200868 } else {
Michal Vaskocfaff232020-10-20 09:35:14 +0200869 *mod_p = mod;
Michal Vasko25d6ad02020-10-22 12:20:22 +0200870 break;
Michal Vaskocfaff232020-10-20 09:35:14 +0200871 }
Michal Vaskocfaff232020-10-20 09:35:14 +0200872 }
873 }
874
Michal Vasko25d6ad02020-10-22 12:20:22 +0200875 return LY_SUCCESS;
Michal Vaskocfaff232020-10-20 09:35:14 +0200876}
877
878/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200879 * @brief Check when/must expressions of a node on a complete compiled schema tree.
880 *
881 * @param[in] ctx Compile context.
882 * @param[in] node Node to check.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100883 * @param[in,out] unres Global unres structure.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200884 * @return LY_ERR value
885 */
886static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +0100887lys_compile_unres_xpath(struct lysc_ctx *ctx, const struct lysc_node *node, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200888{
889 struct lyxp_set tmp_set;
890 uint32_t i, opts;
891 LY_ARRAY_COUNT_TYPE u;
892 ly_bool input_done = 0;
Radek Krejci9a3823e2021-01-27 20:26:46 +0100893 struct lysc_when **whens = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200894 struct lysc_must *musts = NULL;
895 LY_ERR ret = LY_SUCCESS;
Michal Vaskocfaff232020-10-20 09:35:14 +0200896 const struct lys_module *mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200897
Radek Krejciddace2c2021-01-08 11:30:56 +0100898 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100899
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200900 memset(&tmp_set, 0, sizeof tmp_set);
Michal Vaskod1e53b92021-01-28 13:11:06 +0100901 opts = LYXP_SCNODE_SCHEMA | ((node->flags & LYS_IS_OUTPUT) ? LYXP_SCNODE_OUTPUT : 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200902
Radek Krejci9a3823e2021-01-27 20:26:46 +0100903 whens = lysc_node_when(node);
904 musts = lysc_node_musts(node);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200905
Radek Krejci9a3823e2021-01-27 20:26:46 +0100906 LY_ARRAY_FOR(whens, u) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200907 /* first check whether all the referenced modules are implemented */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200908 mod = NULL;
Radek Krejci9a3823e2021-01-27 20:26:46 +0100909 ret = lys_compile_expr_implement(ctx->ctx, whens[u]->cond, LY_PREF_SCHEMA_RESOLVED, whens[u]->prefixes,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100910 ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200911 if (ret) {
912 goto cleanup;
913 } else if (mod) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200914 LOGWRN(ctx->ctx, "When condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
Radek Krejci9a3823e2021-01-27 20:26:46 +0100915 whens[u]->cond->expr, mod->name);
Michal Vaskocfaff232020-10-20 09:35:14 +0200916 continue;
917 }
918
919 /* check "when" */
Radek Krejci9a3823e2021-01-27 20:26:46 +0100920 ret = lyxp_atomize(ctx->ctx, whens[u]->cond, node->module, LY_PREF_SCHEMA_RESOLVED, whens[u]->prefixes,
921 whens[u]->context, &tmp_set, opts);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200922 if (ret) {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100923 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", whens[u]->cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200924 goto cleanup;
925 }
926
927 ctx->path[0] = '\0';
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100928 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200929 for (i = 0; i < tmp_set.used; ++i) {
930 /* skip roots'n'stuff */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100931 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 +0200932 struct lysc_node *schema = tmp_set.val.scnodes[i].scnode;
933
934 /* XPath expression cannot reference "lower" status than the node that has the definition */
Radek Krejci9a3823e2021-01-27 20:26:46 +0100935 ret = lysc_check_status(ctx, whens[u]->flags, node->module, node->name, schema->flags, schema->module,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200936 schema->name);
937 LY_CHECK_GOTO(ret, cleanup);
938
939 /* check dummy node accessing */
940 if (schema == node) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100941 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200942 ret = LY_EVALID;
943 goto cleanup;
944 }
945 }
946 }
947
948 /* check cyclic dependencies */
949 ret = lys_compile_unres_when_cyclic(&tmp_set, node);
950 LY_CHECK_GOTO(ret, cleanup);
951
952 lyxp_set_free_content(&tmp_set);
953 }
954
955check_musts:
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200956 LY_ARRAY_FOR(musts, u) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200957 /* first check whether all the referenced modules are implemented */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200958 mod = NULL;
959 ret = lys_compile_expr_implement(ctx->ctx, musts[u].cond, LY_PREF_SCHEMA_RESOLVED, musts[u].prefixes,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100960 ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200961 if (ret) {
962 goto cleanup;
963 } else if (mod) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200964 LOGWRN(ctx->ctx, "Must condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
965 musts[u].cond->expr, mod->name);
966 continue;
967 }
968
969 /* check "must" */
Michal Vasko400e9672021-01-11 13:39:17 +0100970 ret = lyxp_atomize(ctx->ctx, musts[u].cond, node->module, LY_PREF_SCHEMA_RESOLVED, musts[u].prefixes, node,
971 &tmp_set, opts);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200972 if (ret) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100973 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid must restriction \"%s\".", musts[u].cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200974 goto cleanup;
975 }
976
977 ctx->path[0] = '\0';
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100978 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200979 for (i = 0; i < tmp_set.used; ++i) {
980 /* skip roots'n'stuff */
981 if (tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
982 /* XPath expression cannot reference "lower" status than the node that has the definition */
983 ret = lysc_check_status(ctx, node->flags, node->module, node->name, tmp_set.val.scnodes[i].scnode->flags,
984 tmp_set.val.scnodes[i].scnode->module, tmp_set.val.scnodes[i].scnode->name);
985 LY_CHECK_GOTO(ret, cleanup);
986 }
987 }
988
989 lyxp_set_free_content(&tmp_set);
990 }
991
992 if ((node->nodetype & (LYS_RPC | LYS_ACTION)) && !input_done) {
993 /* now check output musts */
994 input_done = 1;
Radek Krejci9a3823e2021-01-27 20:26:46 +0100995 whens = NULL;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100996 musts = ((struct lysc_node_action *)node)->output.musts;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200997 opts = LYXP_SCNODE_OUTPUT;
998 goto check_musts;
999 }
1000
1001cleanup:
1002 lyxp_set_free_content(&tmp_set);
Radek Krejciddace2c2021-01-08 11:30:56 +01001003 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001004 return ret;
1005}
1006
1007/**
1008 * @brief Check leafref for its target existence on a complete compiled schema tree.
1009 *
1010 * @param[in] ctx Compile context.
1011 * @param[in] node Context node for the leafref.
1012 * @param[in] lref Leafref to check/resolve.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001013 * @param[in,out] unres Global unres structure.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001014 * @return LY_ERR value.
1015 */
1016static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001017lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, struct lysc_type_leafref *lref,
1018 struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001019{
Michal Vaskod1e53b92021-01-28 13:11:06 +01001020 const struct lysc_node *target = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001021 struct ly_path *p;
1022 struct lysc_type *type;
1023
1024 assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
1025
1026 /* try to find the target */
Radek Krejcid5d37432021-03-12 13:46:40 +01001027 LY_CHECK_RET(ly_path_compile(ctx->ctx, lref->cur_mod, node, NULL, lref->path, LY_PATH_LREF_TRUE,
Michal Vaskod1e53b92021-01-28 13:11:06 +01001028 (node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
1029 LY_PREF_SCHEMA_RESOLVED, lref->prefixes, unres, &p));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001030
1031 /* get the target node */
1032 target = p[LY_ARRAY_COUNT(p) - 1].node;
1033 ly_path_free(node->module->ctx, p);
1034
1035 if (!(target->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001036 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 +02001037 lref->path->expr, lys_nodetype2str(target->nodetype));
1038 return LY_EVALID;
1039 }
1040
1041 /* check status */
1042 ctx->path[0] = '\0';
1043 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
1044 ctx->path_len = strlen(ctx->path);
1045 if (lysc_check_status(ctx, node->flags, node->module, node->name, target->flags, target->module, target->name)) {
1046 return LY_EVALID;
1047 }
1048 ctx->path_len = 1;
1049 ctx->path[1] = '\0';
1050
1051 /* check config */
1052 if (lref->require_instance) {
Michal Vaskod1e53b92021-01-28 13:11:06 +01001053 if ((node->flags & LYS_CONFIG_W) && (target->flags & LYS_CONFIG_R)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001054 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target is supposed"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001055 " to represent configuration data (as the leafref does), but it does not.", lref->path->expr);
1056 return LY_EVALID;
1057 }
1058 }
1059
1060 /* store the target's type and check for circular chain of leafrefs */
1061 lref->realtype = ((struct lysc_node_leaf *)target)->type;
1062 for (type = lref->realtype; type && type->basetype == LY_TYPE_LEAFREF; type = ((struct lysc_type_leafref *)type)->realtype) {
1063 if (type == (struct lysc_type *)lref) {
1064 /* circular chain detected */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001065 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - circular chain of leafrefs detected.",
1066 lref->path->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001067 return LY_EVALID;
1068 }
1069 }
1070
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001071 /* TODO check if leafref and its target are under common if-features */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001072
1073 return LY_SUCCESS;
1074}
1075
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001076/**
1077 * @brief Compile default value(s) for leaf or leaf-list expecting a complete compiled schema tree.
1078 *
1079 * @param[in] ctx Compile context.
1080 * @param[in] node Leaf or leaf-list to compile the default value(s) for.
1081 * @param[in] type Type of the default value.
1082 * @param[in] dflt Default value.
1083 * @param[in] dflt_pmod Parsed module of the @p dflt to resolve possible prefixes.
1084 * @param[in,out] storage Storage for the compiled default value.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001085 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001086 * @return LY_ERR value.
1087 */
1088static LY_ERR
1089lys_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 +01001090 const struct lysp_module *dflt_pmod, struct lyd_value *storage, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001091{
1092 LY_ERR ret;
Michal Vasko25d6ad02020-10-22 12:20:22 +02001093 uint32_t options;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001094 struct ly_err_item *err = NULL;
1095
Radek Krejci0b013302021-03-29 15:22:32 +02001096 options = (ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED) ? LYPLG_TYPE_STORE_IMPLEMENT : 0;
Michal Vasko25d6ad02020-10-22 12:20:22 +02001097 ret = type->plugin->store(ctx->ctx, type, dflt, strlen(dflt), options, LY_PREF_SCHEMA, (void *)dflt_pmod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001098 LYD_HINT_SCHEMA, node, storage, unres, &err);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001099 if (ret == LY_EINCOMPLETE) {
1100 /* we have no data so we will not be resolving it */
1101 ret = LY_SUCCESS;
1102 }
1103
1104 if (ret) {
Radek Krejciddace2c2021-01-08 11:30:56 +01001105 LOG_LOCSET(node, NULL, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001106 if (err) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001107 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type (%s).", err->msg);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001108 ly_err_free(err);
1109 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001110 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001111 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001112 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001113 return ret;
1114 }
1115
1116 ++((struct lysc_type *)storage->realtype)->refcount;
1117 return LY_SUCCESS;
1118}
1119
1120/**
1121 * @brief Compile default value of a leaf expecting a complete compiled schema tree.
1122 *
1123 * @param[in] ctx Compile context.
1124 * @param[in] leaf Leaf that the default value is for.
1125 * @param[in] dflt Default value to compile.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001126 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001127 * @return LY_ERR value.
1128 */
1129static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001130lys_compile_unres_leaf_dlft(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf, struct lysp_qname *dflt,
1131 struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001132{
1133 LY_ERR ret;
1134
1135 assert(!leaf->dflt);
1136
1137 if (leaf->flags & (LYS_MAND_TRUE | LYS_KEY)) {
1138 /* ignore default values for keys and mandatory leaves */
1139 return LY_SUCCESS;
1140 }
1141
1142 /* allocate the default value */
1143 leaf->dflt = calloc(1, sizeof *leaf->dflt);
1144 LY_CHECK_ERR_RET(!leaf->dflt, LOGMEM(ctx->ctx), LY_EMEM);
1145
1146 /* store the default value */
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001147 ret = lys_compile_unres_dflt(ctx, &leaf->node, leaf->type, dflt->str, dflt->mod, leaf->dflt, unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001148 if (ret) {
1149 free(leaf->dflt);
1150 leaf->dflt = NULL;
1151 }
1152
1153 return ret;
1154}
1155
1156/**
1157 * @brief Compile default values of a leaf-list expecting a complete compiled schema tree.
1158 *
1159 * @param[in] ctx Compile context.
1160 * @param[in] llist Leaf-list that the default value(s) are for.
1161 * @param[in] dflt Default value to compile, in case of a single value.
1162 * @param[in] dflts Sized array of default values, in case of more values.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001163 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001164 * @return LY_ERR value.
1165 */
1166static LY_ERR
1167lys_compile_unres_llist_dflts(struct lysc_ctx *ctx, struct lysc_node_leaflist *llist, struct lysp_qname *dflt,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001168 struct lysp_qname *dflts, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001169{
1170 LY_ERR ret;
1171 LY_ARRAY_COUNT_TYPE orig_count, u, v;
1172
1173 assert(dflt || dflts);
1174
Radek Krejcic7d13e32020-12-09 12:32:24 +01001175 /* in case there were already some defaults and we are adding new by deviations */
1176 orig_count = LY_ARRAY_COUNT(llist->dflts);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001177
1178 /* allocate new items */
Radek Krejcic7d13e32020-12-09 12:32:24 +01001179 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 +02001180
1181 /* fill each new default value */
1182 if (dflts) {
1183 LY_ARRAY_FOR(dflts, u) {
1184 llist->dflts[orig_count + u] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001185 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflts[u].str, dflts[u].mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001186 llist->dflts[orig_count + u], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001187 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count + u]), ret);
1188 LY_ARRAY_INCREMENT(llist->dflts);
1189 }
1190 } else {
1191 llist->dflts[orig_count] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001192 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflt->str, dflt->mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001193 llist->dflts[orig_count], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001194 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count]), ret);
1195 LY_ARRAY_INCREMENT(llist->dflts);
1196 }
1197
1198 /* check default value uniqueness */
1199 if (llist->flags & LYS_CONFIG_W) {
1200 /* configuration data values must be unique - so check the default values */
1201 for (u = orig_count; u < LY_ARRAY_COUNT(llist->dflts); ++u) {
1202 for (v = 0; v < u; ++v) {
1203 if (!llist->dflts[u]->realtype->plugin->compare(llist->dflts[u], llist->dflts[v])) {
Radek Krejcia6016992021-03-03 10:13:41 +01001204 lysc_update_path(ctx, llist->parent ? llist->parent->module : NULL, llist->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001205 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Configuration leaf-list has multiple defaults of the same value \"%s\".",
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001206 llist->dflts[u]->canonical);
1207 lysc_update_path(ctx, NULL, NULL);
1208 return LY_EVALID;
1209 }
1210 }
1211 }
1212 }
1213
1214 return LY_SUCCESS;
1215}
1216
Michal Vasko405cc9e2020-12-01 12:01:27 +01001217LY_ERR
1218lys_compile_unres_glob(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1219{
Radek Krejci2efc45b2020-12-22 16:25:44 +01001220 LY_ERR ret;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001221 struct lysc_node *node;
1222 struct lysc_type *type, *typeiter;
1223 struct lysc_type_leafref *lref;
1224 struct lysc_ctx cctx = {0};
1225 LY_ARRAY_COUNT_TYPE v;
1226 uint32_t i;
1227
1228 if (unres->recompile) {
1229 /* recompile all the modules and resolve the new unres instead (during recompilation) */
1230 unres->recompile = 0;
1231 return lys_recompile(ctx, 1);
1232 }
1233
1234 /* fake compile context */
1235 cctx.ctx = ctx;
1236 cctx.path_len = 1;
1237 cctx.path[0] = '/';
1238
1239 /* for leafref, we need 2 rounds - first detects circular chain by storing the first referred type (which
1240 * can be also leafref, in case it is already resolved, go through the chain and check that it does not
1241 * point to the starting leafref type). The second round stores the first non-leafref type for later data validation. */
1242 for (i = 0; i < unres->leafrefs.count; ++i) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001243 LY_ERR ret = LY_SUCCESS;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001244 node = unres->leafrefs.objs[i];
1245 cctx.cur_mod = node->module;
1246 cctx.pmod = node->module->parsed;
1247
Radek Krejciddace2c2021-01-08 11:30:56 +01001248 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001249
Michal Vasko405cc9e2020-12-01 12:01:27 +01001250 assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
1251 type = ((struct lysc_node_leaf *)node)->type;
1252 if (type->basetype == LY_TYPE_LEAFREF) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001253 ret = lys_compile_unres_leafref(&cctx, node, (struct lysc_type_leafref *)type, unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001254 } else if (type->basetype == LY_TYPE_UNION) {
1255 LY_ARRAY_FOR(((struct lysc_type_union *)type)->types, v) {
1256 if (((struct lysc_type_union *)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
1257 lref = (struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001258 ret = lys_compile_unres_leafref(&cctx, node, lref, unres);
1259 if (ret) {
1260 break;
1261 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001262 }
1263 }
1264 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01001265
Radek Krejciddace2c2021-01-08 11:30:56 +01001266 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001267 if (ret) {
1268 return ret;
1269 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001270 }
1271 while (unres->leafrefs.count) {
1272 node = unres->leafrefs.objs[unres->leafrefs.count - 1];
1273 cctx.cur_mod = node->module;
1274 cctx.pmod = node->module->parsed;
1275
Radek Krejciddace2c2021-01-08 11:30:56 +01001276 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001277
Michal Vasko405cc9e2020-12-01 12:01:27 +01001278 /* store pointer to the real type */
1279 type = ((struct lysc_node_leaf *)node)->type;
1280 if (type->basetype == LY_TYPE_LEAFREF) {
1281 for (typeiter = ((struct lysc_type_leafref *)type)->realtype;
1282 typeiter->basetype == LY_TYPE_LEAFREF;
1283 typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
1284 ((struct lysc_type_leafref *)type)->realtype = typeiter;
1285 } else if (type->basetype == LY_TYPE_UNION) {
1286 LY_ARRAY_FOR(((struct lysc_type_union *)type)->types, v) {
1287 if (((struct lysc_type_union *)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
1288 for (typeiter = ((struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v])->realtype;
1289 typeiter->basetype == LY_TYPE_LEAFREF;
1290 typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
1291 ((struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v])->realtype = typeiter;
1292 }
1293 }
1294 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001295 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001296
1297 ly_set_rm_index(&unres->leafrefs, unres->leafrefs.count - 1, NULL);
1298 }
1299
1300 /* check xpath */
1301 while (unres->xpath.count) {
1302 node = unres->xpath.objs[unres->xpath.count - 1];
1303 cctx.cur_mod = node->module;
1304 cctx.pmod = node->module->parsed;
1305
Radek Krejciddace2c2021-01-08 11:30:56 +01001306 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001307
1308 ret = lys_compile_unres_xpath(&cctx, node, unres);
Radek Krejciddace2c2021-01-08 11:30:56 +01001309 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001310 LY_CHECK_RET(ret);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001311
1312 ly_set_rm_index(&unres->xpath, unres->xpath.count - 1, NULL);
1313 }
1314
1315 /* finish incomplete default values compilation */
1316 while (unres->dflts.count) {
1317 struct lysc_unres_dflt *r = unres->dflts.objs[unres->dflts.count - 1];
1318 cctx.cur_mod = r->leaf->module;
1319 cctx.pmod = r->leaf->module->parsed;
1320
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001321 LOG_LOCSET(&r->leaf->node, NULL, NULL, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001322
Radek Krejci2efc45b2020-12-22 16:25:44 +01001323 if (r->leaf->nodetype == LYS_LEAF) {
1324 ret = lys_compile_unres_leaf_dlft(&cctx, r->leaf, r->dflt, unres);
1325 } else {
1326 ret = lys_compile_unres_llist_dflts(&cctx, r->llist, r->dflt, r->dflts, unres);
1327 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001328 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001329 LY_CHECK_RET(ret);
1330
1331 lysc_unres_dflt_free(ctx, r);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001332 ly_set_rm_index(&unres->dflts, unres->dflts.count - 1, NULL);
1333 }
1334
1335 /* some unres items may have been added */
1336 if (unres->leafrefs.count || unres->xpath.count || unres->dflts.count) {
1337 return lys_compile_unres_glob(ctx, unres);
1338 }
1339
1340 return LY_SUCCESS;
1341}
1342
1343void
1344lys_compile_unres_glob_revert(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1345{
1346 uint32_t i;
1347 struct lys_module *m;
1348
1349 for (i = 0; i < unres->implementing.count; ++i) {
1350 m = unres->implementing.objs[i];
1351 assert(m->implemented);
1352
1353 /* make the module correctly non-implemented again */
1354 m->implemented = 0;
1355 lys_precompile_augments_deviations_revert(ctx, m);
1356 }
1357
1358 for (i = 0; i < unres->creating.count; ++i) {
1359 m = unres->creating.objs[i];
1360
1361 /* remove the module from the context and free it */
1362 ly_set_rm(&ctx->list, m, NULL);
1363 lys_module_free(m, NULL);
1364 }
1365
1366 if (unres->implementing.count) {
1367 /* recompile because some implemented modules are no longer implemented */
1368 lys_recompile(ctx, 0);
1369 }
1370}
1371
1372void
1373lys_compile_unres_glob_erase(const struct ly_ctx *ctx, struct lys_glob_unres *unres)
1374{
1375 uint32_t i;
1376
1377 ly_set_erase(&unres->implementing, NULL);
1378 ly_set_erase(&unres->creating, NULL);
1379 for (i = 0; i < unres->dflts.count; ++i) {
1380 lysc_unres_dflt_free(ctx, unres->dflts.objs[i]);
1381 }
1382 ly_set_erase(&unres->dflts, NULL);
1383 ly_set_erase(&unres->xpath, NULL);
1384 ly_set_erase(&unres->leafrefs, NULL);
1385}
1386
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001387/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001388 * @brief Finish compilation of all the module unres sets in a compile context.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001389 *
1390 * @param[in] ctx Compile context with unres sets.
1391 * @return LY_ERR value.
1392 */
1393static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001394lys_compile_unres_mod(struct lysc_ctx *ctx)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001395{
1396 struct lysc_node *node;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001397 struct lysc_augment *aug;
1398 struct lysc_deviation *dev;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001399 uint32_t i;
1400
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001401 /* remove all disabled nodes */
1402 for (i = 0; i < ctx->disabled.count; ++i) {
1403 node = ctx->disabled.snodes[i];
1404 if (node->flags & LYS_KEY) {
Radek Krejciddace2c2021-01-08 11:30:56 +01001405 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001406 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Key \"%s\" is disabled by its if-features.", node->name);
Radek Krejciddace2c2021-01-08 11:30:56 +01001407 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001408 return LY_EVALID;
1409 }
1410
Radek Krejci2a9fc652021-01-22 17:44:34 +01001411 lysc_node_free(ctx->ctx, node, 1);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001412 }
1413
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001414 /* check that all augments were applied */
1415 for (i = 0; i < ctx->augs.count; ++i) {
1416 aug = ctx->augs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001417 lysc_update_path(ctx, NULL, "{augment}");
1418 lysc_update_path(ctx, NULL, aug->nodeid->expr);
1419 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Augment target node \"%s\" from module \"%s\" was not found.",
Michal Vasko28fe5f62021-03-03 16:37:39 +01001420 aug->nodeid->expr, LYSP_MODULE_NAME(aug->aug_pmod));
Radek Krejci2efc45b2020-12-22 16:25:44 +01001421 lysc_update_path(ctx, NULL, NULL);
1422 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001423 }
1424 if (ctx->augs.count) {
1425 return LY_ENOTFOUND;
1426 }
1427
1428 /* check that all deviations were applied */
1429 for (i = 0; i < ctx->devs.count; ++i) {
1430 dev = ctx->devs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001431 lysc_update_path(ctx, NULL, "{deviation}");
1432 lysc_update_path(ctx, NULL, dev->nodeid->expr);
1433 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Deviation(s) target node \"%s\" from module \"%s\" was not found.",
1434 dev->nodeid->expr, LYSP_MODULE_NAME(dev->dev_pmods[0]));
1435 lysc_update_path(ctx, NULL, NULL);
1436 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001437 }
1438 if (ctx->devs.count) {
1439 return LY_ENOTFOUND;
1440 }
1441
1442 return LY_SUCCESS;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001443}
1444
1445/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001446 * @brief Erase all the module unres sets in a compile context.
1447 *
1448 * @param[in] ctx Compile context with unres sets.
1449 * @param[in] error Whether the compilation finished with an error or not.
1450 */
1451static void
1452lys_compile_unres_mod_erase(struct lysc_ctx *ctx, ly_bool error)
1453{
1454 uint32_t i;
1455
1456 ly_set_erase(&ctx->groupings, NULL);
1457 ly_set_erase(&ctx->tpdf_chain, NULL);
1458 ly_set_erase(&ctx->disabled, NULL);
1459
1460 if (!error) {
1461 /* there can be no leftover deviations or augments */
1462 LY_CHECK_ERR_RET(ctx->augs.count, LOGINT(ctx->ctx), );
1463 LY_CHECK_ERR_RET(ctx->devs.count, LOGINT(ctx->ctx), );
1464
1465 ly_set_erase(&ctx->augs, NULL);
1466 ly_set_erase(&ctx->devs, NULL);
1467 ly_set_erase(&ctx->uses_augs, NULL);
1468 ly_set_erase(&ctx->uses_rfns, NULL);
1469 } else {
1470 for (i = 0; i < ctx->augs.count; ++i) {
1471 lysc_augment_free(ctx->ctx, ctx->augs.objs[i]);
1472 }
1473 ly_set_erase(&ctx->augs, NULL);
1474 for (i = 0; i < ctx->devs.count; ++i) {
1475 lysc_deviation_free(ctx->ctx, ctx->devs.objs[i]);
1476 }
1477 ly_set_erase(&ctx->devs, NULL);
1478 for (i = 0; i < ctx->uses_augs.count; ++i) {
1479 lysc_augment_free(ctx->ctx, ctx->uses_augs.objs[i]);
1480 }
1481 ly_set_erase(&ctx->uses_augs, NULL);
1482 for (i = 0; i < ctx->uses_rfns.count; ++i) {
1483 lysc_refine_free(ctx->ctx, ctx->uses_rfns.objs[i]);
1484 }
1485 ly_set_erase(&ctx->uses_rfns, NULL);
1486 }
1487}
1488
1489/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001490 * @brief Compile identites in the current module and all its submodules.
1491 *
1492 * @param[in] ctx Compile context.
1493 * @return LY_ERR value.
1494 */
1495static LY_ERR
1496lys_compile_identities(struct lysc_ctx *ctx)
1497{
1498 struct lysp_submodule *submod;
1499 LY_ARRAY_COUNT_TYPE u;
1500
1501 if (!ctx->cur_mod->identities) {
1502 LY_CHECK_RET(lys_identity_precompile(ctx, NULL, NULL, ctx->cur_mod->parsed->identities, &ctx->cur_mod->identities));
1503 LY_ARRAY_FOR(ctx->cur_mod->parsed->includes, u) {
1504 submod = ctx->cur_mod->parsed->includes[u].submodule;
1505 LY_CHECK_RET(lys_identity_precompile(ctx, NULL, NULL, submod->identities, &ctx->cur_mod->identities));
1506 }
1507 }
1508
1509 if (ctx->cur_mod->parsed->identities) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001510 LY_CHECK_RET(lys_compile_identities_derived(ctx, ctx->cur_mod->parsed->identities, &ctx->cur_mod->identities));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001511 }
1512 lysc_update_path(ctx, NULL, "{submodule}");
1513 LY_ARRAY_FOR(ctx->cur_mod->parsed->includes, u) {
1514
1515 submod = ctx->cur_mod->parsed->includes[u].submodule;
1516 if (submod->identities) {
1517 lysc_update_path(ctx, NULL, submod->name);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001518 LY_CHECK_RET(lys_compile_identities_derived(ctx, submod->identities, &ctx->cur_mod->identities));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001519 lysc_update_path(ctx, NULL, NULL);
1520 }
1521 }
1522 lysc_update_path(ctx, NULL, NULL);
1523
1524 return LY_SUCCESS;
1525}
1526
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001527LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001528lys_recompile(struct ly_ctx *ctx, ly_bool log)
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001529{
1530 uint32_t idx;
1531 struct lys_module *mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001532 struct lys_glob_unres unres = {0};
1533 LY_ERR ret = LY_SUCCESS;
Radek Krejci430a5582020-12-01 13:35:18 +01001534 uint32_t prev_lo = 0;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001535
1536 if (!log) {
1537 /* recompile, must succeed because the modules were already compiled; hide messages because any
1538 * warnings were already printed, are not really relevant, and would hide the real error */
1539 prev_lo = ly_log_options(0);
1540 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001541
1542 /* free all the modules */
1543 for (idx = 0; idx < ctx->list.count; ++idx) {
1544 mod = ctx->list.objs[idx];
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001545 if (mod->compiled) {
1546 /* free the module */
1547 lysc_module_free(mod->compiled, NULL);
1548 mod->compiled = NULL;
1549 }
1550
1551 /* free precompiled iffeatures */
1552 lys_free_feature_iffeatures(mod->parsed);
1553 }
1554
1555 /* recompile all the modules */
1556 for (idx = 0; idx < ctx->list.count; ++idx) {
1557 mod = ctx->list.objs[idx];
Michal Vasko405cc9e2020-12-01 12:01:27 +01001558 if (!mod->implemented || mod->compiled) {
1559 /* nothing to do */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001560 continue;
1561 }
1562
Michal Vasko405cc9e2020-12-01 12:01:27 +01001563 /* recompile */
1564 ret = lys_compile(mod, 0, &unres);
1565 if (ret) {
1566 if (!log) {
1567 LOGERR(mod->ctx, ret, "Recompilation of module \"%s\" failed.", mod->name);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001568 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001569 goto cleanup;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001570 }
1571 }
1572
Michal Vasko405cc9e2020-12-01 12:01:27 +01001573 /* resolve global unres */
1574 LY_CHECK_GOTO(ret = lys_compile_unres_glob(ctx, &unres), cleanup);
1575
1576cleanup:
1577 if (!log) {
1578 ly_log_options(prev_lo);
1579 }
1580 lys_compile_unres_glob_erase(ctx, &unres);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001581 return ret;
1582}
1583
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001584LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001585lys_compile(struct lys_module *mod, uint32_t options, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001586{
1587 struct lysc_ctx ctx = {0};
1588 struct lysc_module *mod_c;
1589 struct lysp_module *sp;
1590 struct lysp_submodule *submod;
1591 struct lysp_node *pnode;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001592 struct lysp_node_grp *grp;
1593 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001594 LY_ERR ret = LY_SUCCESS;
1595
1596 LY_CHECK_ARG_RET(NULL, mod, mod->parsed, !mod->compiled, mod->ctx, LY_EINVAL);
1597
1598 if (!mod->implemented) {
1599 /* just imported modules are not compiled */
1600 return LY_SUCCESS;
1601 }
1602
1603 /* context will be changed */
Michal Vasko794ab4b2021-03-31 09:42:19 +02001604 ++mod->ctx->change_count;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001605
1606 sp = mod->parsed;
1607
1608 ctx.ctx = mod->ctx;
1609 ctx.cur_mod = mod;
1610 ctx.pmod = sp;
1611 ctx.options = options;
1612 ctx.path_len = 1;
1613 ctx.path[0] = '/';
Michal Vasko405cc9e2020-12-01 12:01:27 +01001614 ctx.unres = unres;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001615
1616 mod->compiled = mod_c = calloc(1, sizeof *mod_c);
1617 LY_CHECK_ERR_RET(!mod_c, LOGMEM(mod->ctx), LY_EMEM);
1618 mod_c->mod = mod;
1619
1620 /* process imports */
1621 LY_ARRAY_FOR(sp->imports, u) {
1622 LY_CHECK_GOTO(ret = lys_compile_import(&ctx, &sp->imports[u]), error);
1623 }
1624
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001625 /* identities */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001626 LY_CHECK_GOTO(ret = lys_compile_identities(&ctx), error);
1627
1628 /* augments and deviations */
1629 LY_CHECK_GOTO(ret = lys_precompile_augments_deviations(&ctx), error);
1630
1631 /* compile augments and deviations of our module from other modules so they can be applied during compilation */
1632 LY_CHECK_GOTO(ret = lys_precompile_own_augments(&ctx), error);
1633 LY_CHECK_GOTO(ret = lys_precompile_own_deviations(&ctx), error);
1634
1635 /* data nodes */
1636 LY_LIST_FOR(sp->data, pnode) {
1637 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), error);
1638 }
1639
Radek Krejci2a9fc652021-01-22 17:44:34 +01001640 /* top-level RPCs */
1641 LY_LIST_FOR((struct lysp_node *)sp->rpcs, pnode) {
1642 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), error);
1643 }
1644
1645 /* top-level notifications */
1646 LY_LIST_FOR((struct lysp_node *)sp->notifs, pnode) {
1647 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), error);
1648 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001649
1650 /* extension instances */
Radek Krejciab430862021-03-02 20:13:40 +01001651 COMPILE_EXTS_GOTO(&ctx, sp->exts, mod_c->exts, mod_c, ret, error);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001652
1653 /* the same for submodules */
1654 LY_ARRAY_FOR(sp->includes, u) {
1655 submod = sp->includes[u].submodule;
1656 ctx.pmod = (struct lysp_module *)submod;
1657
1658 LY_LIST_FOR(submod->data, pnode) {
1659 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
1660 LY_CHECK_GOTO(ret, error);
1661 }
1662
Radek Krejci2a9fc652021-01-22 17:44:34 +01001663 LY_LIST_FOR((struct lysp_node *)submod->rpcs, pnode) {
1664 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
1665 LY_CHECK_GOTO(ret, error);
1666 }
1667
1668 LY_LIST_FOR((struct lysp_node *)submod->notifs, pnode) {
1669 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
1670 LY_CHECK_GOTO(ret, error);
1671 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001672
Radek Krejciab430862021-03-02 20:13:40 +01001673 COMPILE_EXTS_GOTO(&ctx, submod->exts, mod_c->exts, mod_c, ret, error);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001674 }
Michal Vasko12606ee2020-11-25 17:05:11 +01001675 ctx.pmod = sp;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001676
1677 /* validate non-instantiated groupings from the parsed schema,
1678 * without it we would accept even the schemas with invalid grouping specification */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001679 ctx.options |= LYS_COMPILE_GROUPING;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001680 LY_LIST_FOR(sp->groupings, grp) {
1681 if (!(grp->flags & LYS_USED_GRP)) {
1682 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), error);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001683 }
1684 }
1685 LY_LIST_FOR(sp->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001686 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1687 if (!(grp->flags & LYS_USED_GRP)) {
1688 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), error);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001689 }
1690 }
1691 }
1692 LY_ARRAY_FOR(sp->includes, u) {
1693 submod = sp->includes[u].submodule;
1694 ctx.pmod = (struct lysp_module *)submod;
1695
Radek Krejci2a9fc652021-01-22 17:44:34 +01001696 LY_LIST_FOR(submod->groupings, grp) {
1697 if (!(grp->flags & LYS_USED_GRP)) {
1698 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), error);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001699 }
1700 }
1701 LY_LIST_FOR(submod->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001702 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1703 if (!(grp->flags & LYS_USED_GRP)) {
1704 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), error);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001705 }
1706 }
1707 }
1708 }
1709 ctx.pmod = sp;
1710
Radek Krejciddace2c2021-01-08 11:30:56 +01001711 LOG_LOCBACK(0, 0, 1, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001712
Michal Vasko405cc9e2020-12-01 12:01:27 +01001713 /* finish compilation for all unresolved module items in the context */
1714 LY_CHECK_GOTO(ret = lys_compile_unres_mod(&ctx), error);
Michal Vasko12606ee2020-11-25 17:05:11 +01001715
Michal Vasko405cc9e2020-12-01 12:01:27 +01001716 lys_compile_unres_mod_erase(&ctx, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001717 return LY_SUCCESS;
1718
1719error:
Radek Krejciddace2c2021-01-08 11:30:56 +01001720 LOG_LOCBACK(0, 0, 1, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001721 lys_precompile_augments_deviations_revert(ctx.ctx, mod);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001722 lys_compile_unres_mod_erase(&ctx, 1);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001723 lysc_module_free(mod_c, NULL);
1724 mod->compiled = NULL;
1725
1726 return ret;
1727}