blob: bda517cfcc0f9bd7f438dfdc498c2faba346df92 [file] [log] [blame]
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001/**
2 * @file schema_compile.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
Michal Vasko19a09022021-06-15 11:54:08 +02004 * @author Michal Vasko <mvasko@cesnet.cz>
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02005 * @brief Schema compilation.
6 *
Michal Vasko35274cf2024-07-04 12:01:00 +02007 * Copyright (c) 2015 - 2024 CESNET, z.s.p.o.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02008 *
9 * This source code is licensed under BSD 3-Clause License (the "License").
10 * You may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * https://opensource.org/licenses/BSD-3-Clause
14 */
15
16#define _GNU_SOURCE
17
18#include "schema_compile.h"
19
20#include <assert.h>
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020021#include <stddef.h>
22#include <stdint.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020027#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 Vasko8f702ee2024-02-20 15:44:24 +010032#include "ly_common.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020033#include "parser_schema.h"
34#include "path.h"
Radek Krejci0aa1f702021-04-01 16:16:19 +020035#include "plugins.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020036#include "plugins_exts.h"
Radek Krejci3e6632f2021-03-22 22:08:21 +010037#include "plugins_internal.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020038#include "plugins_types.h"
39#include "schema_compile_amend.h"
40#include "schema_compile_node.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010041#include "schema_features.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020042#include "set.h"
43#include "tree.h"
44#include "tree_data.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020045#include "tree_schema.h"
Michal Vaskoc636ea42022-09-16 10:20:31 +020046#include "tree_schema_free.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020047#include "tree_schema_internal.h"
48#include "xpath.h"
49
Michal Vaskoa0ba01e2022-10-19 13:26:57 +020050void
51lysc_update_path(struct lysc_ctx *ctx, const struct lys_module *parent_module, const char *name)
52{
53 int len;
54 uint8_t nextlevel = 0; /* 0 - no starttag, 1 - '/' starttag, 2 - '=' starttag + '}' endtag */
55
56 if (!name) {
57 /* removing last path segment */
58 if (ctx->path[ctx->path_len - 1] == '}') {
59 for ( ; ctx->path[ctx->path_len] != '=' && ctx->path[ctx->path_len] != '{'; --ctx->path_len) {}
60 if (ctx->path[ctx->path_len] == '=') {
61 ctx->path[ctx->path_len++] = '}';
62 } else {
63 /* not a top-level special tag, remove also preceiding '/' */
64 goto remove_nodelevel;
65 }
66 } else {
67remove_nodelevel:
68 for ( ; ctx->path[ctx->path_len] != '/'; --ctx->path_len) {}
69 if (ctx->path_len == 0) {
70 /* top-level (last segment) */
71 ctx->path_len = 1;
72 }
73 }
74 /* set new terminating NULL-byte */
75 ctx->path[ctx->path_len] = '\0';
76 } else {
77 if (ctx->path_len > 1) {
78 if (!parent_module && (ctx->path[ctx->path_len - 1] == '}') && (ctx->path[ctx->path_len - 2] != '\'')) {
79 /* extension of the special tag */
80 nextlevel = 2;
81 --ctx->path_len;
82 } else {
83 /* there is already some path, so add next level */
84 nextlevel = 1;
85 }
86 } /* else the path is just initiated with '/', so do not add additional slash in case of top-level nodes */
87
88 if (nextlevel != 2) {
89 if ((parent_module && (parent_module == ctx->cur_mod)) || (!parent_module && (ctx->path_len > 1) && (name[0] == '{'))) {
90 /* module not changed, print the name unprefixed */
Michal Vasko7a266772024-01-23 11:02:38 +010091 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s",
92 nextlevel ? "/" : "", name);
Michal Vaskoa0ba01e2022-10-19 13:26:57 +020093 } else {
Michal Vasko7a266772024-01-23 11:02:38 +010094 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s:%s",
95 nextlevel ? "/" : "", ctx->cur_mod->name, name);
Michal Vaskoa0ba01e2022-10-19 13:26:57 +020096 }
97 } else {
98 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "='%s'}", name);
99 }
100 if (len >= LYSC_CTX_BUFSIZE - (int)ctx->path_len) {
101 /* output truncated */
102 ctx->path_len = LYSC_CTX_BUFSIZE - 1;
103 } else {
104 ctx->path_len += len;
105 }
106 }
107
Michal Vasko7a266772024-01-23 11:02:38 +0100108 ly_log_location_revert(0, 0, 1, 0);
109 ly_log_location(NULL, NULL, ctx->path, NULL);
Michal Vaskoa0ba01e2022-10-19 13:26:57 +0200110}
111
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200112/**
113 * @brief Fill in the prepared compiled extensions definition structure according to the parsed extension definition.
Michal Vasko193dacd2022-10-13 08:43:05 +0200114 *
115 * @param[in] ctx Compile context.
116 * @param[in] extp Parsed extension instance.
117 * @param[out] ext Compiled extension definition.
118 * @return LY_ERR value.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200119 */
120static LY_ERR
Michal Vasko193dacd2022-10-13 08:43:05 +0200121lys_compile_extension(struct lysc_ctx *ctx, struct lysp_ext_instance *extp, struct lysc_ext **ext)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200122{
123 LY_ERR ret = LY_SUCCESS;
Michal Vasko193dacd2022-10-13 08:43:05 +0200124 struct lysp_ext *ep = extp->def;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200125
Michal Vasko193dacd2022-10-13 08:43:05 +0200126 if (!ep->compiled) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200127 lysc_update_path(ctx, NULL, "{extension}");
Michal Vasko193dacd2022-10-13 08:43:05 +0200128 lysc_update_path(ctx, NULL, ep->name);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200129
130 /* compile the extension definition */
Michal Vasko193dacd2022-10-13 08:43:05 +0200131 *ext = ep->compiled = calloc(1, sizeof **ext);
Michal Vasko193dacd2022-10-13 08:43:05 +0200132 DUP_STRING_GOTO(ctx->ctx, ep->name, (*ext)->name, ret, cleanup);
133 DUP_STRING_GOTO(ctx->ctx, ep->argname, (*ext)->argname, ret, cleanup);
134 LY_CHECK_GOTO(ret = lysp_ext_find_definition(ctx->ctx, extp, (const struct lys_module **)&(*ext)->module, NULL),
135 cleanup);
Michal Vaskoc636ea42022-09-16 10:20:31 +0200136
137 /* compile nested extensions */
Michal Vasko193dacd2022-10-13 08:43:05 +0200138 COMPILE_EXTS_GOTO(ctx, ep->exts, (*ext)->exts, *ext, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200139
140 lysc_update_path(ctx, NULL, NULL);
141 lysc_update_path(ctx, NULL, NULL);
142
143 /* find extension definition plugin */
Michal Vasko193dacd2022-10-13 08:43:05 +0200144 (*ext)->plugin = extp->record ? (struct lyplg_ext *)&extp->record->plugin : NULL;
Michal Vasko54b11952022-06-08 12:29:39 +0200145 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200146
Michal Vasko193dacd2022-10-13 08:43:05 +0200147 *ext = ep->compiled;
Michal Vaskoc636ea42022-09-16 10:20:31 +0200148
Michal Vasko193dacd2022-10-13 08:43:05 +0200149cleanup:
Radek Krejci2efc45b2020-12-22 16:25:44 +0100150 if (ret) {
151 lysc_update_path(ctx, NULL, NULL);
152 lysc_update_path(ctx, NULL, NULL);
153 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200154 return ret;
155}
156
157LY_ERR
Michal Vasko193dacd2022-10-13 08:43:05 +0200158lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *extp, struct lysc_ext_instance *ext, void *parent)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200159{
Radek Krejci85ac8312021-03-03 20:21:33 +0100160 LY_ERR ret = LY_SUCCESS;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200161
Michal Vasko193dacd2022-10-13 08:43:05 +0200162 DUP_STRING_GOTO(ctx->ctx, extp->argument, ext->argument, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200163 ext->module = ctx->cur_mod;
164 ext->parent = parent;
Michal Vasko193dacd2022-10-13 08:43:05 +0200165 ext->parent_stmt = extp->parent_stmt;
166 ext->parent_stmt_index = extp->parent_stmt_index;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200167
Michal Vasko193dacd2022-10-13 08:43:05 +0200168 lysc_update_path(ctx, (ext->parent_stmt & LY_STMT_NODE_MASK) ? ((struct lysc_node *)ext->parent)->module : NULL,
169 "{extension}");
170 lysc_update_path(ctx, NULL, extp->name);
Michal Vaskofc2cd072021-02-24 13:17:17 +0100171
Michal Vasko193dacd2022-10-13 08:43:05 +0200172 /* compile extension if not already */
173 LY_CHECK_GOTO(ret = lys_compile_extension(ctx, extp, &ext->def), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200174
Michal Vasko35274cf2024-07-04 12:01:00 +0200175 /* compile nested extensions */
176 COMPILE_EXTS_GOTO(ctx, extp->exts, ext->exts, ext, ret, cleanup);
177
178 /* compile this extension */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200179 if (ext->def->plugin && ext->def->plugin->compile) {
180 if (ext->argument) {
Radek Krejcia6016992021-03-03 10:13:41 +0100181 lysc_update_path(ctx, ext->module, ext->argument);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200182 }
Michal Vasko193dacd2022-10-13 08:43:05 +0200183 ret = ext->def->plugin->compile(ctx, extp, ext);
Radek Krejcicc21a4f2021-02-09 15:23:31 +0100184 if (ret == LY_ENOT) {
Michal Vaskoc636ea42022-09-16 10:20:31 +0200185 lysc_ext_instance_free(&ctx->free_ctx, ext);
Radek Krejcicc21a4f2021-02-09 15:23:31 +0100186 }
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 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200192
193cleanup:
Radek Krejci2efc45b2020-12-22 16:25:44 +0100194 lysc_update_path(ctx, NULL, NULL);
Michal Vaskofc2cd072021-02-24 13:17:17 +0100195 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200196 return ret;
197}
198
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200199static void
Michal Vaskoc130e162021-10-19 11:30:00 +0200200lysc_unres_must_free(struct lysc_unres_must *m)
201{
202 LY_ARRAY_FREE(m->local_mods);
203 free(m);
204}
205
206static void
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200207lysc_unres_dflt_free(const struct ly_ctx *ctx, struct lysc_unres_dflt *r)
208{
209 assert(!r->dflt || !r->dflts);
210 if (r->dflt) {
211 lysp_qname_free((struct ly_ctx *)ctx, r->dflt);
212 free(r->dflt);
213 } else {
214 FREE_ARRAY((struct ly_ctx *)ctx, r->dflts, lysp_qname_free);
215 }
216 free(r);
217}
218
Michal Vasko193dacd2022-10-13 08:43:05 +0200219LY_ERR
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200220lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
Michal Vasko9b232082022-06-07 10:59:31 +0200221 const struct lysp_ident *identities_p, struct lysc_ident **identities)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200222{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100223 LY_ARRAY_COUNT_TYPE u;
Michal Vaskoc636ea42022-09-16 10:20:31 +0200224 struct lysc_ctx cctx;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100225 struct lysc_ident *ident;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200226 LY_ERR ret = LY_SUCCESS;
227
228 assert(ctx_sc || ctx);
229
230 if (!ctx_sc) {
Michal Vaskoc636ea42022-09-16 10:20:31 +0200231 if (parsed_mod) {
Michal Vaskoedb0fa52022-10-04 10:36:00 +0200232 LYSC_CTX_INIT_PMOD(cctx, parsed_mod, NULL);
Michal Vaskoc636ea42022-09-16 10:20:31 +0200233 } else {
234 LYSC_CTX_INIT_CTX(cctx, ctx);
235 }
236 ctx_sc = &cctx;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200237 }
238
239 if (!identities_p) {
240 return LY_SUCCESS;
241 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200242
243 lysc_update_path(ctx_sc, NULL, "{identity}");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200244 LY_ARRAY_FOR(identities_p, u) {
245 lysc_update_path(ctx_sc, NULL, identities_p[u].name);
246
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100247 /* add new compiled identity */
Michal Vasko9b232082022-06-07 10:59:31 +0200248 LY_ARRAY_NEW_GOTO(ctx_sc->ctx, *identities, ident, ret, done);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100249
250 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].name, ident->name, ret, done);
251 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].dsc, ident->dsc, ret, done);
252 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].ref, ident->ref, ret, done);
253 ident->module = ctx_sc->cur_mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200254 /* 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 +0100255 COMPILE_EXTS_GOTO(ctx_sc, identities_p[u].exts, ident->exts, ident, ret, done);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100256 ident->flags = identities_p[u].flags;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200257
258 lysc_update_path(ctx_sc, NULL, NULL);
259 }
260 lysc_update_path(ctx_sc, NULL, NULL);
Michal Vasko9b232082022-06-07 10:59:31 +0200261
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200262done:
Michal Vasko9b232082022-06-07 10:59:31 +0200263 if (ret) {
264 lysc_update_path(ctx_sc, NULL, NULL);
265 lysc_update_path(ctx_sc, NULL, NULL);
266 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200267 return ret;
268}
269
270/**
271 * @brief Check circular dependency of identities - identity MUST NOT reference itself (via their base statement).
272 *
273 * The function works in the same way as lys_compile_feature_circular_check() with different structures and error messages.
274 *
275 * @param[in] ctx Compile context for logging.
276 * @param[in] ident The base identity (its derived list is being extended by the identity being currently processed).
277 * @param[in] derived The list of derived identities of the identity being currently processed (not the one provided as @p ident)
278 * @return LY_SUCCESS if everything is ok.
279 * @return LY_EVALID if the identity is derived from itself.
280 */
281static LY_ERR
282lys_compile_identity_circular_check(struct lysc_ctx *ctx, struct lysc_ident *ident, struct lysc_ident **derived)
283{
284 LY_ERR ret = LY_SUCCESS;
285 LY_ARRAY_COUNT_TYPE u, v;
286 struct ly_set recursion = {0};
287 struct lysc_ident *drv;
288
289 if (!derived) {
290 return LY_SUCCESS;
291 }
292
293 for (u = 0; u < LY_ARRAY_COUNT(derived); ++u) {
294 if (ident == derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100295 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200296 "Identity \"%s\" is indirectly derived from itself.", ident->name);
297 ret = LY_EVALID;
298 goto cleanup;
299 }
300 ret = ly_set_add(&recursion, derived[u], 0, NULL);
301 LY_CHECK_GOTO(ret, cleanup);
302 }
303
304 for (v = 0; v < recursion.count; ++v) {
305 drv = recursion.objs[v];
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200306 for (u = 0; u < LY_ARRAY_COUNT(drv->derived); ++u) {
307 if (ident == drv->derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100308 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200309 "Identity \"%s\" is indirectly derived from itself.", ident->name);
310 ret = LY_EVALID;
311 goto cleanup;
312 }
313 ret = ly_set_add(&recursion, drv->derived[u], 0, NULL);
314 LY_CHECK_GOTO(ret, cleanup);
315 }
316 }
317
318cleanup:
319 ly_set_erase(&recursion, NULL);
320 return ret;
321}
322
323LY_ERR
324lys_compile_identity_bases(struct lysc_ctx *ctx, const struct lysp_module *base_pmod, const char **bases_p,
aPiecekf4a0a192021-08-03 15:14:17 +0200325 struct lysc_ident *ident, struct lysc_ident ***bases)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200326{
327 LY_ARRAY_COUNT_TYPE u, v;
328 const char *s, *name;
329 const struct lys_module *mod;
330 struct lysc_ident **idref;
331
aPiecekf4a0a192021-08-03 15:14:17 +0200332 assert(ident || bases);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200333
334 if ((LY_ARRAY_COUNT(bases_p) > 1) && (ctx->pmod->version < LYS_VERSION_1_1)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100335 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200336 "Multiple bases in %s are allowed only in YANG 1.1 modules.", ident ? "identity" : "identityref type");
337 return LY_EVALID;
338 }
339
340 LY_ARRAY_FOR(bases_p, u) {
341 s = strchr(bases_p[u], ':');
342 if (s) {
343 /* prefixed identity */
344 name = &s[1];
Radek Krejci8df109d2021-04-23 12:19:08 +0200345 mod = ly_resolve_prefix(ctx->ctx, bases_p[u], s - bases_p[u], LY_VALUE_SCHEMA, (void *)base_pmod);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200346 } else {
347 name = bases_p[u];
348 mod = base_pmod->mod;
349 }
350 if (!mod) {
351 if (ident) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100352 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200353 "Invalid prefix used for base (%s) of identity \"%s\".", bases_p[u], ident->name);
354 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100355 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200356 "Invalid prefix used for base (%s) of identityref.", bases_p[u]);
357 }
358 return LY_EVALID;
359 }
360
361 idref = NULL;
362 LY_ARRAY_FOR(mod->identities, v) {
363 if (!strcmp(name, mod->identities[v].name)) {
364 if (ident) {
365 if (ident == &mod->identities[v]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100366 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200367 "Identity \"%s\" is derived from itself.", ident->name);
368 return LY_EVALID;
369 }
370 LY_CHECK_RET(lys_compile_identity_circular_check(ctx, &mod->identities[v], ident->derived));
371 /* we have match! store the backlink */
372 LY_ARRAY_NEW_RET(ctx->ctx, mod->identities[v].derived, idref, LY_EMEM);
373 *idref = ident;
374 } else {
375 /* we have match! store the found identity */
376 LY_ARRAY_NEW_RET(ctx->ctx, *bases, idref, LY_EMEM);
377 *idref = &mod->identities[v];
378 }
379 break;
380 }
381 }
aPiecekf4a0a192021-08-03 15:14:17 +0200382 if (!idref) {
Radek Krejci10443f42021-03-28 17:40:35 +0200383 if (ident) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100384 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200385 "Unable to find base (%s) of identity \"%s\".", bases_p[u], ident->name);
386 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100387 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200388 "Unable to find base (%s) of identityref.", bases_p[u]);
389 }
390 return LY_EVALID;
391 }
392 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100393
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200394 return LY_SUCCESS;
395}
396
397/**
398 * @brief For the given array of identities, set the backlinks from all their base identities.
Michal Vasko193dacd2022-10-13 08:43:05 +0200399 *
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200400 * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
401 * @param[in] idents_p Array of identities definitions from the parsed schema structure.
aPiecekf4a0a192021-08-03 15:14:17 +0200402 * @param[in,out] idents Array of referencing identities to which the backlinks are supposed to be set.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200403 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
404 */
405static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100406lys_compile_identities_derived(struct lysc_ctx *ctx, struct lysp_ident *idents_p, struct lysc_ident **idents)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200407{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100408 LY_ARRAY_COUNT_TYPE u, v;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200409
410 lysc_update_path(ctx, NULL, "{identity}");
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100411
aPiecekf3e2db82021-08-05 10:18:43 +0200412 for (u = 0; u < LY_ARRAY_COUNT(*idents); ++u) {
aPiecekf4a0a192021-08-03 15:14:17 +0200413 /* find matching parsed identity */
aPiecekf3e2db82021-08-05 10:18:43 +0200414 for (v = 0; v < LY_ARRAY_COUNT(idents_p); ++v) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100415 if (idents_p[v].name == (*idents)[u].name) {
416 break;
417 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100418 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100419
Michal Vaskodc6f84c2021-06-15 14:50:27 +0200420 if ((v == LY_ARRAY_COUNT(idents_p)) || !idents_p[v].bases) {
421 /* identity not found (it may be from a submodule) or identity without bases */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200422 continue;
423 }
Michal Vaskodc6f84c2021-06-15 14:50:27 +0200424
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100425 lysc_update_path(ctx, NULL, (*idents)[u].name);
aPiecekf4a0a192021-08-03 15:14:17 +0200426 LY_CHECK_RET(lys_compile_identity_bases(ctx, ctx->pmod, idents_p[v].bases, &(*idents)[u], NULL));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200427 lysc_update_path(ctx, NULL, NULL);
428 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100429
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200430 lysc_update_path(ctx, NULL, NULL);
431 return LY_SUCCESS;
432}
433
Michal Vaskoe20599c2022-12-02 10:45:01 +0100434LY_ERR
435lys_compile_expr_implement(const struct ly_ctx *ctx, const struct lyxp_expr *expr, LY_VALUE_FORMAT format,
436 void *prefix_data, ly_bool implement, struct lys_glob_unres *unres, const struct lys_module **mod_p)
437{
438 uint32_t i;
439 const char *ptr, *start, **imp_f, *all_f[] = {"*", NULL};
440 const struct lys_module *mod;
441
442 assert(implement || mod_p);
443
Michal Vaskoaa548942023-06-08 12:23:14 +0200444 if (mod_p) {
445 *mod_p = NULL;
446 }
447
Michal Vaskoe20599c2022-12-02 10:45:01 +0100448 for (i = 0; i < expr->used; ++i) {
449 if ((expr->tokens[i] != LYXP_TOKEN_NAMETEST) && (expr->tokens[i] != LYXP_TOKEN_LITERAL)) {
450 /* token cannot have a prefix */
451 continue;
452 }
453
454 start = expr->expr + expr->tok_pos[i];
455 if (!(ptr = ly_strnchr(start, ':', expr->tok_len[i]))) {
456 /* token without a prefix */
457 continue;
458 }
459
460 if (!(mod = ly_resolve_prefix(ctx, start, ptr - start, format, prefix_data))) {
461 /* unknown prefix, do not care right now */
462 continue;
463 }
464
465 /* unimplemented module found */
466 if (!mod->implemented && !implement) {
467 /* should not be implemented now */
468 *mod_p = mod;
469 break;
470 }
471
472 if (!mod->implemented) {
473 /* implement if not implemented */
474 imp_f = (ctx->flags & LY_CTX_ENABLE_IMP_FEATURES) ? all_f : NULL;
475 LY_CHECK_RET(lys_implement((struct lys_module *)mod, imp_f, unres));
476 }
477 if (!mod->compiled) {
478 /* compile if not implemented before or only marked for compilation */
479 LY_CHECK_RET(lys_compile((struct lys_module *)mod, &unres->ds_unres));
480 }
481 }
482
483 return LY_SUCCESS;
484}
485
486/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200487 * @brief Check when for cyclic dependencies.
488 *
489 * @param[in] set Set with all the referenced nodes.
490 * @param[in] node Node whose "when" referenced nodes are in @p set.
491 * @return LY_ERR value
492 */
493static LY_ERR
494lys_compile_unres_when_cyclic(struct lyxp_set *set, const struct lysc_node *node)
495{
496 struct lyxp_set tmp_set;
497 struct lyxp_set_scnode *xp_scnode;
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200498 uint32_t i, j, idx;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200499 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200500 LY_ERR ret = LY_SUCCESS;
501
502 memset(&tmp_set, 0, sizeof tmp_set);
503
504 /* prepare in_ctx of the set */
505 for (i = 0; i < set->used; ++i) {
506 xp_scnode = &set->val.scnodes[i];
507
Radek Krejcif13b87b2020-12-01 22:02:17 +0100508 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_START_USED) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200509 /* check node when, skip the context node (it was just checked) */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100510 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200511 }
512 }
513
514 for (i = 0; i < set->used; ++i) {
515 xp_scnode = &set->val.scnodes[i];
Radek Krejcif13b87b2020-12-01 22:02:17 +0100516 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200517 /* already checked */
518 continue;
519 }
520
Michal Vasko1a09b212021-05-06 13:00:10 +0200521 if ((xp_scnode->type != LYXP_NODE_ELEM) || !lysc_node_when(xp_scnode->scnode)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200522 /* no when to check */
Michal Vasko1a09b212021-05-06 13:00:10 +0200523 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200524 continue;
525 }
526
527 node = xp_scnode->scnode;
528 do {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100529 struct lysc_when **when_list, *when;
530
Michal Vasko7a266772024-01-23 11:02:38 +0100531 LOG_LOCSET(node, NULL);
Radek Krejci9a3823e2021-01-27 20:26:46 +0100532 when_list = lysc_node_when(node);
533 LY_ARRAY_FOR(when_list, u) {
534 when = when_list[u];
Radek Krejci8df109d2021-04-23 12:19:08 +0200535 ret = lyxp_atomize(set->ctx, when->cond, node->module, LY_VALUE_SCHEMA_RESOLVED, when->prefixes,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +0200536 when->context, when->context, &tmp_set, LYXP_SCNODE_SCHEMA);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200537 if (ret != LY_SUCCESS) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100538 LOGVAL(set->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when->cond->expr);
Michal Vasko7a266772024-01-23 11:02:38 +0100539 LOG_LOCBACK(1, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200540 goto cleanup;
541 }
542
543 for (j = 0; j < tmp_set.used; ++j) {
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200544 if (tmp_set.val.scnodes[j].type != LYXP_NODE_ELEM) {
545 /* skip roots'n'stuff, no when, nothing to check */
Michal Vasko1a09b212021-05-06 13:00:10 +0200546 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200547 continue;
548 }
549
550 /* try to find this node in our set */
551 if (lyxp_set_scnode_contains(set, tmp_set.val.scnodes[j].scnode, LYXP_NODE_ELEM, -1, &idx) &&
552 (set->val.scnodes[idx].in_ctx == LYXP_SET_SCNODE_START_USED)) {
553 LOGVAL(set->ctx, LYVE_SEMANTICS, "When condition cyclic dependency on the node \"%s\".",
554 tmp_set.val.scnodes[j].scnode->name);
555 ret = LY_EVALID;
Michal Vasko7a266772024-01-23 11:02:38 +0100556 LOG_LOCBACK(1, 0);
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200557 goto cleanup;
558 }
559
560 /* needs to be checked, if in both sets, will be ignored */
561 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
562 }
563
564 if (when->context != node) {
565 /* node actually depends on this "when", not the context node */
566 assert(tmp_set.val.scnodes[0].scnode == when->context);
567 if (tmp_set.val.scnodes[0].in_ctx == LYXP_SET_SCNODE_START_USED) {
568 /* replace the non-traversed context node with the dependent node */
569 tmp_set.val.scnodes[0].scnode = (struct lysc_node *)node;
570 } else {
571 /* context node was traversed, so just add the dependent node */
572 ret = lyxp_set_scnode_insert_node(&tmp_set, node, LYXP_SET_SCNODE_START_USED, LYXP_AXIS_CHILD, NULL);
Michal Vasko7a266772024-01-23 11:02:38 +0100573 LY_CHECK_ERR_GOTO(ret, LOG_LOCBACK(1, 0), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200574 }
575 }
576
577 /* merge this set into the global when set */
578 lyxp_set_scnode_merge(set, &tmp_set);
579 }
Michal Vasko7a266772024-01-23 11:02:38 +0100580 LOG_LOCBACK(1, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200581
582 /* check when of non-data parents as well */
583 node = node->parent;
584 } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE)));
585
586 /* this node when was checked (xp_scnode could have been reallocd) */
Michal Vasko60edc2f2021-07-20 09:18:02 +0200587 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200588 }
589
590cleanup:
591 lyxp_set_free_content(&tmp_set);
592 return ret;
593}
594
595LY_ERR
596lysc_check_status(struct lysc_ctx *ctx, uint16_t flags1, void *mod1, const char *name1, uint16_t flags2, void *mod2,
597 const char *name2)
598{
599 uint16_t flg1, flg2;
600
601 flg1 = (flags1 & LYS_STATUS_MASK) ? (flags1 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
602 flg2 = (flags2 & LYS_STATUS_MASK) ? (flags2 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
603
604 if ((flg1 < flg2) && (mod1 == mod2)) {
605 if (ctx) {
Michal Vasko23864e02021-06-24 09:23:58 +0200606 LOGVAL(ctx->ctx, LYVE_REFERENCE, "A %s definition \"%s\" is not allowed to reference %s definition \"%s\".",
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200607 flg1 == LYS_STATUS_CURR ? "current" : "deprecated", name1,
608 flg2 == LYS_STATUS_OBSLT ? "obsolete" : "deprecated", name2);
609 }
610 return LY_EVALID;
611 }
612
613 return LY_SUCCESS;
614}
615
Michal Vaskocfaff232020-10-20 09:35:14 +0200616/**
Michal Vaskoc130e162021-10-19 11:30:00 +0200617 * @brief Check when expressions of a node on a complete compiled schema tree.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200618 *
619 * @param[in] ctx Compile context.
Michal Vasko4ed3bd52022-12-02 10:28:04 +0100620 * @param[in] when When to check.
621 * @param[in] node Node with @p when.
Michal Vasko4ed3bd52022-12-02 10:28:04 +0100622 * @return LY_ERR value.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200623 */
624static LY_ERR
Michal Vaskoe20599c2022-12-02 10:45:01 +0100625lys_compile_unres_when(struct lysc_ctx *ctx, const struct lysc_when *when, const struct lysc_node *node)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200626{
Michal Vasko4ed3bd52022-12-02 10:28:04 +0100627 struct lyxp_set tmp_set = {0};
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200628 uint32_t i, opts;
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200629 struct lysc_node *schema;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200630 LY_ERR ret = LY_SUCCESS;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200631
Michal Vaskod1e53b92021-01-28 13:11:06 +0100632 opts = LYXP_SCNODE_SCHEMA | ((node->flags & LYS_IS_OUTPUT) ? LYXP_SCNODE_OUTPUT : 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200633
Michal Vasko4ed3bd52022-12-02 10:28:04 +0100634 /* check "when" */
635 ret = lyxp_atomize(ctx->ctx, when->cond, node->module, LY_VALUE_SCHEMA_RESOLVED, when->prefixes, when->context,
636 when->context, &tmp_set, opts);
637 if (ret) {
638 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when->cond->expr);
639 goto cleanup;
640 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200641
Michal Vasko4ed3bd52022-12-02 10:28:04 +0100642 ctx->path[0] = '\0';
643 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
644 for (i = 0; i < tmp_set.used; ++i) {
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200645 if (tmp_set.val.scnodes[i].type != LYXP_NODE_ELEM) {
646 /* skip roots'n'stuff */
647 continue;
648 } else if (tmp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_START_USED) {
649 /* context node not actually traversed */
650 continue;
651 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200652
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200653 schema = tmp_set.val.scnodes[i].scnode;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200654
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200655 /* XPath expression cannot reference "lower" status than the node that has the definition */
656 if (lysc_check_status(NULL, when->flags, node->module, node->name, schema->flags, schema->module,
657 schema->name)) {
658 LOGWRN(ctx->ctx, "When condition \"%s\" may be referencing %s node \"%s\".", when->cond->expr,
659 (schema->flags == LYS_STATUS_OBSLT) ? "obsolete" : "deprecated", schema->name);
660 }
661
662 /* check dummy node children/value accessing */
663 if (lysc_data_parent(schema) == node) {
664 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node children.");
665 ret = LY_EVALID;
666 goto cleanup;
667 } else if ((schema == node) && (tmp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL)) {
668 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node value.");
669 ret = LY_EVALID;
670 goto cleanup;
671 }
672 }
673
674 if (when->context != node) {
675 /* node actually depends on this "when", not the context node */
676 assert(tmp_set.val.scnodes[0].scnode == when->context);
677 if (tmp_set.val.scnodes[0].in_ctx == LYXP_SET_SCNODE_START_USED) {
678 /* replace the non-traversed context node with the dependent node */
679 tmp_set.val.scnodes[0].scnode = (struct lysc_node *)node;
680 } else {
681 /* context node was traversed, so just add the dependent node */
682 ret = lyxp_set_scnode_insert_node(&tmp_set, node, LYXP_SET_SCNODE_START_USED, LYXP_AXIS_CHILD, NULL);
683 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200684 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200685 }
686
Michal Vasko4ed3bd52022-12-02 10:28:04 +0100687 /* check cyclic dependencies */
688 ret = lys_compile_unres_when_cyclic(&tmp_set, node);
689 LY_CHECK_GOTO(ret, cleanup);
690
Michal Vaskoc130e162021-10-19 11:30:00 +0200691cleanup:
692 lyxp_set_free_content(&tmp_set);
Michal Vaskoc130e162021-10-19 11:30:00 +0200693 return ret;
694}
695
696/**
697 * @brief Check must expressions of a node on a complete compiled schema tree.
698 *
699 * @param[in] ctx Compile context.
700 * @param[in] node Node to check.
701 * @param[in] local_mods Sized array of local modules for musts of @p node at the same index.
Michal Vaskoaa548942023-06-08 12:23:14 +0200702 * @return LY_ERR value.
Michal Vaskoc130e162021-10-19 11:30:00 +0200703 */
704static LY_ERR
Michal Vaskoaa548942023-06-08 12:23:14 +0200705lys_compile_unres_must(struct lysc_ctx *ctx, const struct lysc_node *node, const struct lysp_module **local_mods)
Michal Vaskoc130e162021-10-19 11:30:00 +0200706{
707 struct lyxp_set tmp_set;
708 uint32_t i, opts;
709 LY_ARRAY_COUNT_TYPE u;
Michal Vaskoaa548942023-06-08 12:23:14 +0200710 struct lysc_must *musts;
Michal Vaskoc130e162021-10-19 11:30:00 +0200711 LY_ERR ret = LY_SUCCESS;
Michal Vaskoc130e162021-10-19 11:30:00 +0200712 uint16_t flg;
713
Michal Vasko7a266772024-01-23 11:02:38 +0100714 LOG_LOCSET(node, NULL);
Michal Vaskoc130e162021-10-19 11:30:00 +0200715
716 memset(&tmp_set, 0, sizeof tmp_set);
717 opts = LYXP_SCNODE_SCHEMA | ((node->flags & LYS_IS_OUTPUT) ? LYXP_SCNODE_OUTPUT : 0);
718
719 musts = lysc_node_musts(node);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200720 LY_ARRAY_FOR(musts, u) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200721 /* check "must" */
Radek Krejci8df109d2021-04-23 12:19:08 +0200722 ret = lyxp_atomize(ctx->ctx, musts[u].cond, node->module, LY_VALUE_SCHEMA_RESOLVED, musts[u].prefixes, node,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +0200723 node, &tmp_set, opts);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200724 if (ret) {
Michal Vasko7c3134d2022-07-14 10:57:59 +0200725 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid must condition \"%s\".", musts[u].cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200726 goto cleanup;
727 }
728
729 ctx->path[0] = '\0';
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100730 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200731 for (i = 0; i < tmp_set.used; ++i) {
732 /* skip roots'n'stuff */
733 if (tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko7c3134d2022-07-14 10:57:59 +0200734 struct lysc_node *schema = tmp_set.val.scnodes[i].scnode;
735
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200736 /* XPath expression cannot reference "lower" status than the node that has the definition */
Michal Vaskoc130e162021-10-19 11:30:00 +0200737 if (local_mods[u]->mod == node->module) {
738 /* use flags of the context node since the definition is local */
739 flg = node->flags;
740 } else {
741 /* definition is foreign (deviation, refine), always current */
742 flg = LYS_STATUS_CURR;
743 }
Michal Vasko7c3134d2022-07-14 10:57:59 +0200744 if (lysc_check_status(NULL, flg, local_mods[u]->mod, node->name, schema->flags, schema->module,
745 schema->name)) {
746 LOGWRN(ctx->ctx, "Must condition \"%s\" may be referencing %s node \"%s\".", musts[u].cond->expr,
747 (schema->flags == LYS_STATUS_OBSLT) ? "obsolete" : "deprecated", schema->name);
748 break;
749 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200750 }
751 }
752
753 lyxp_set_free_content(&tmp_set);
754 }
755
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200756cleanup:
757 lyxp_set_free_content(&tmp_set);
Michal Vasko7a266772024-01-23 11:02:38 +0100758 LOG_LOCBACK(1, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200759 return ret;
760}
761
762/**
Michal Vaskof4fa90d2021-11-11 15:05:19 +0100763 * @brief Remove all disabled bits/enums from a sized array.
764 *
765 * @param[in] ctx Context with the dictionary.
766 * @param[in] items Sized array of bits/enums.
767 */
768static void
Michal Vaskoc636ea42022-09-16 10:20:31 +0200769lys_compile_unres_disabled_bitenum_remove(struct lysf_ctx *ctx, struct lysc_type_bitenum_item *items)
Michal Vaskof4fa90d2021-11-11 15:05:19 +0100770{
771 LY_ARRAY_COUNT_TYPE u = 0, last_u;
772
773 while (u < LY_ARRAY_COUNT(items)) {
774 if (items[u].flags & LYS_DISABLED) {
775 /* free the disabled item */
776 lysc_enum_item_free(ctx, &items[u]);
777
778 /* replace it with the following items */
779 last_u = LY_ARRAY_COUNT(items) - 1;
780 if (u < last_u) {
781 memmove(items + u, items + u + 1, (last_u - u) * sizeof *items);
782 }
783
784 /* one item less */
785 LY_ARRAY_DECREMENT(items);
786 continue;
787 }
788
789 ++u;
790 }
791}
792
793/**
794 * @brief Find and remove all disabled bits/enums in a leaf/leaf-list type.
795 *
796 * @param[in] ctx Compile context.
797 * @param[in] leaf Leaf/leaf-list to check.
798 * @return LY_ERR value
799 */
800static LY_ERR
801lys_compile_unres_disabled_bitenum(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf)
802{
803 struct lysc_type **t;
804 LY_ARRAY_COUNT_TYPE u, count;
805 struct lysc_type_enum *ent;
Michal Vasko28864d52023-03-23 08:07:46 +0100806 ly_bool has_value = 0;
Michal Vaskof4fa90d2021-11-11 15:05:19 +0100807
808 if (leaf->type->basetype == LY_TYPE_UNION) {
809 t = ((struct lysc_type_union *)leaf->type)->types;
810 count = LY_ARRAY_COUNT(t);
811 } else {
812 t = &leaf->type;
813 count = 1;
814 }
815 for (u = 0; u < count; ++u) {
816 if ((t[u]->basetype == LY_TYPE_BITS) || (t[u]->basetype == LY_TYPE_ENUM)) {
817 /* remove all disabled items */
818 ent = (struct lysc_type_enum *)(t[u]);
Michal Vaskoc636ea42022-09-16 10:20:31 +0200819 lys_compile_unres_disabled_bitenum_remove(&ctx->free_ctx, ent->enums);
Michal Vaskof4fa90d2021-11-11 15:05:19 +0100820
Michal Vasko28864d52023-03-23 08:07:46 +0100821 if (LY_ARRAY_COUNT(ent->enums)) {
822 has_value = 1;
Michal Vaskof4fa90d2021-11-11 15:05:19 +0100823 }
Michal Vasko28864d52023-03-23 08:07:46 +0100824 } else {
825 has_value = 1;
Michal Vaskof4fa90d2021-11-11 15:05:19 +0100826 }
827 }
828
Michal Vasko28864d52023-03-23 08:07:46 +0100829 if (!has_value) {
830 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Node \"%s\" without any (or all disabled) valid values.", leaf->name);
831 return LY_EVALID;
832 }
833
Michal Vaskof4fa90d2021-11-11 15:05:19 +0100834 return LY_SUCCESS;
835}
836
837/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200838 * @brief Check leafref for its target existence on a complete compiled schema tree.
839 *
840 * @param[in] ctx Compile context.
841 * @param[in] node Context node for the leafref.
842 * @param[in] lref Leafref to check/resolve.
Michal Vaskoc130e162021-10-19 11:30:00 +0200843 * @param[in] local_mod Local module for the leafref type.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200844 * @return LY_ERR value.
845 */
846static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +0100847lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, struct lysc_type_leafref *lref,
Michal Vaskoaa548942023-06-08 12:23:14 +0200848 const struct lysp_module *local_mod)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200849{
Michal Vaskod1e53b92021-01-28 13:11:06 +0100850 const struct lysc_node *target = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200851 struct ly_path *p;
852 struct lysc_type *type;
Michal Vaskoc130e162021-10-19 11:30:00 +0200853 uint16_t flg;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200854
855 assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
856
Michal Vaskof2a793b2023-03-13 11:56:50 +0100857 if (lref->realtype) {
858 /* already resolved, may happen (shared union typedef with a leafref) */
859 return LY_SUCCESS;
860 }
861
Michal Vaskoed725d72021-06-23 12:03:45 +0200862 /* try to find the target, current module is that of the context node (RFC 7950 6.4.1 second bullet) */
Michal Vaskoedb0fa52022-10-04 10:36:00 +0200863 LY_CHECK_RET(ly_path_compile_leafref(ctx->ctx, node, ctx->ext, lref->path,
Michal Vaskod1e53b92021-01-28 13:11:06 +0100864 (node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
Michal Vasko24fc4d12021-07-12 14:41:20 +0200865 LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &p));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200866
867 /* get the target node */
868 target = p[LY_ARRAY_COUNT(p) - 1].node;
Michal Vasko59391122024-08-16 15:38:02 +0200869 ly_path_free(node->module->ctx, p);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200870
871 if (!(target->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100872 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 +0200873 lref->path->expr, lys_nodetype2str(target->nodetype));
874 return LY_EVALID;
875 }
876
877 /* check status */
878 ctx->path[0] = '\0';
879 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
880 ctx->path_len = strlen(ctx->path);
Michal Vaskoc130e162021-10-19 11:30:00 +0200881 if (node->module == local_mod->mod) {
882 /* use flags of the context node since the definition is local */
883 flg = node->flags;
884 } else {
885 /* definition is foreign (deviation), always current */
886 flg = LYS_STATUS_CURR;
887 }
888 if (lysc_check_status(ctx, flg, local_mod->mod, node->name, target->flags, target->module, target->name)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200889 return LY_EVALID;
890 }
891 ctx->path_len = 1;
892 ctx->path[1] = '\0';
893
894 /* check config */
895 if (lref->require_instance) {
Michal Vaskod1e53b92021-01-28 13:11:06 +0100896 if ((node->flags & LYS_CONFIG_W) && (target->flags & LYS_CONFIG_R)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100897 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target is supposed"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200898 " to represent configuration data (as the leafref does), but it does not.", lref->path->expr);
899 return LY_EVALID;
900 }
901 }
902
Michal Vaskod15c7de2022-05-09 15:34:09 +0200903 /* check for circular chain of leafrefs */
904 for (type = ((struct lysc_node_leaf *)target)->type;
905 type && (type->basetype == LY_TYPE_LEAFREF);
906 type = ((struct lysc_type_leafref *)type)->realtype) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200907 if (type == (struct lysc_type *)lref) {
908 /* circular chain detected */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100909 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - circular chain of leafrefs detected.",
910 lref->path->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200911 return LY_EVALID;
912 }
913 }
914
Michal Vaskod15c7de2022-05-09 15:34:09 +0200915 /* store the type */
916 lref->realtype = ((struct lysc_node_leaf *)target)->type;
917 ++lref->realtype->refcount;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200918 return LY_SUCCESS;
919}
920
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200921/**
922 * @brief Compile default value(s) for leaf or leaf-list expecting a complete compiled schema tree.
923 *
924 * @param[in] ctx Compile context.
925 * @param[in] node Leaf or leaf-list to compile the default value(s) for.
926 * @param[in] type Type of the default value.
927 * @param[in] dflt Default value.
928 * @param[in] dflt_pmod Parsed module of the @p dflt to resolve possible prefixes.
929 * @param[in,out] storage Storage for the compiled default value.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100930 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vaskoaa548942023-06-08 12:23:14 +0200931 * @return LY_ERECOMPILE if the whole dep set needs to be recompiled for the value to be checked.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200932 * @return LY_ERR value.
933 */
934static LY_ERR
935lys_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 +0100936 const struct lysp_module *dflt_pmod, struct lyd_value *storage, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200937{
938 LY_ERR ret;
Michal Vasko25d6ad02020-10-22 12:20:22 +0200939 uint32_t options;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200940 struct ly_err_item *err = NULL;
941
Radek Krejci0b013302021-03-29 15:22:32 +0200942 options = (ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED) ? LYPLG_TYPE_STORE_IMPLEMENT : 0;
Radek Krejci8df109d2021-04-23 12:19:08 +0200943 ret = type->plugin->store(ctx->ctx, type, dflt, strlen(dflt), options, LY_VALUE_SCHEMA, (void *)dflt_pmod,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100944 LYD_HINT_SCHEMA, node, storage, unres, &err);
Michal Vasko1ccbf542021-04-19 11:35:00 +0200945 if (ret == LY_ERECOMPILE) {
946 /* fine, but we need to recompile */
947 return LY_ERECOMPILE;
948 } else if (ret == LY_EINCOMPLETE) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200949 /* we have no data so we will not be resolving it */
950 ret = LY_SUCCESS;
951 }
952
953 if (ret) {
Michal Vasko7a266772024-01-23 11:02:38 +0100954 LOG_LOCSET(node, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200955 if (err) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100956 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type (%s).", err->msg);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200957 ly_err_free(err);
958 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100959 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200960 }
Michal Vasko7a266772024-01-23 11:02:38 +0100961 LOG_LOCBACK(1, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200962 return ret;
963 }
964
Michal Vasko04338d92021-09-01 07:58:14 +0200965 LY_ATOMIC_INC_BARRIER(((struct lysc_type *)storage->realtype)->refcount);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200966 return LY_SUCCESS;
967}
968
969/**
970 * @brief Compile default value of a leaf expecting a complete compiled schema tree.
971 *
972 * @param[in] ctx Compile context.
973 * @param[in] leaf Leaf that the default value is for.
974 * @param[in] dflt Default value to compile.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100975 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200976 * @return LY_ERR value.
977 */
978static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +0100979lys_compile_unres_leaf_dlft(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf, struct lysp_qname *dflt,
980 struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200981{
982 LY_ERR ret;
983
984 assert(!leaf->dflt);
985
986 if (leaf->flags & (LYS_MAND_TRUE | LYS_KEY)) {
987 /* ignore default values for keys and mandatory leaves */
988 return LY_SUCCESS;
989 }
990
991 /* allocate the default value */
992 leaf->dflt = calloc(1, sizeof *leaf->dflt);
993 LY_CHECK_ERR_RET(!leaf->dflt, LOGMEM(ctx->ctx), LY_EMEM);
994
995 /* store the default value */
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100996 ret = lys_compile_unres_dflt(ctx, &leaf->node, leaf->type, dflt->str, dflt->mod, leaf->dflt, unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200997 if (ret) {
998 free(leaf->dflt);
999 leaf->dflt = NULL;
1000 }
1001
1002 return ret;
1003}
1004
1005/**
1006 * @brief Compile default values of a leaf-list expecting a complete compiled schema tree.
1007 *
1008 * @param[in] ctx Compile context.
1009 * @param[in] llist Leaf-list that the default value(s) are for.
1010 * @param[in] dflt Default value to compile, in case of a single value.
1011 * @param[in] dflts Sized array of default values, in case of more values.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001012 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001013 * @return LY_ERR value.
1014 */
1015static LY_ERR
1016lys_compile_unres_llist_dflts(struct lysc_ctx *ctx, struct lysc_node_leaflist *llist, struct lysp_qname *dflt,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001017 struct lysp_qname *dflts, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001018{
1019 LY_ERR ret;
1020 LY_ARRAY_COUNT_TYPE orig_count, u, v;
1021
1022 assert(dflt || dflts);
1023
Radek Krejcic7d13e32020-12-09 12:32:24 +01001024 /* in case there were already some defaults and we are adding new by deviations */
1025 orig_count = LY_ARRAY_COUNT(llist->dflts);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001026
1027 /* allocate new items */
Radek Krejcic7d13e32020-12-09 12:32:24 +01001028 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 +02001029
1030 /* fill each new default value */
1031 if (dflts) {
1032 LY_ARRAY_FOR(dflts, u) {
1033 llist->dflts[orig_count + u] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001034 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflts[u].str, dflts[u].mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001035 llist->dflts[orig_count + u], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001036 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count + u]), ret);
1037 LY_ARRAY_INCREMENT(llist->dflts);
1038 }
1039 } else {
1040 llist->dflts[orig_count] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001041 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflt->str, dflt->mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001042 llist->dflts[orig_count], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001043 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count]), ret);
1044 LY_ARRAY_INCREMENT(llist->dflts);
1045 }
1046
1047 /* check default value uniqueness */
1048 if (llist->flags & LYS_CONFIG_W) {
1049 /* configuration data values must be unique - so check the default values */
1050 for (u = orig_count; u < LY_ARRAY_COUNT(llist->dflts); ++u) {
1051 for (v = 0; v < u; ++v) {
aPiecek0a6705b2023-11-14 14:20:58 +01001052 if (!llist->dflts[u]->realtype->plugin->compare(ctx->ctx, llist->dflts[u], llist->dflts[v])) {
Radek Krejcia6016992021-03-03 10:13:41 +01001053 lysc_update_path(ctx, llist->parent ? llist->parent->module : NULL, llist->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001054 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Configuration leaf-list has multiple defaults of the same value \"%s\".",
Michal Vasko7b3a00e2023-08-09 11:58:03 +02001055 (char *)llist->dflts[u]->realtype->plugin->print(ctx->ctx, llist->dflts[u], LY_VALUE_CANON,
1056 NULL, NULL, NULL));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001057 lysc_update_path(ctx, NULL, NULL);
1058 return LY_EVALID;
1059 }
1060 }
1061 }
1062 }
1063
1064 return LY_SUCCESS;
1065}
1066
Michal Vaskof4258e12021-06-15 12:11:42 +02001067/**
aPiecek732cd142021-07-07 16:29:59 +02001068 * @brief Iteratively get all leafrefs from @p node
1069 * if the node is of type union, otherwise just return the leafref.
1070 *
1071 * @param[in] node Node that may contain the leafref.
1072 * @param[in,out] index Value that is passed between function calls.
1073 * For each new node, initialize value of the @p index to 0, otherwise
1074 * do not modify the value between calls.
1075 * @return Pointer to the leafref or next leafref, otherwise NULL.
1076 */
1077static struct lysc_type_leafref *
Michal Vasko350e8dd2024-04-16 09:27:19 +02001078lys_type_leafref_next(const struct lysc_node *node, LY_ARRAY_COUNT_TYPE *index)
aPiecek732cd142021-07-07 16:29:59 +02001079{
1080 struct lysc_type_leafref *ret = NULL;
1081 struct lysc_type_union *uni;
1082 struct lysc_type *leaf_type;
1083
1084 assert(node->nodetype & LYD_NODE_TERM);
1085
1086 leaf_type = ((struct lysc_node_leaf *)node)->type;
1087 if (leaf_type->basetype == LY_TYPE_UNION) {
1088 uni = (struct lysc_type_union *)leaf_type;
1089
1090 /* find next union leafref */
1091 while (*index < LY_ARRAY_COUNT(uni->types)) {
1092 if (uni->types[*index]->basetype == LY_TYPE_LEAFREF) {
1093 ret = (struct lysc_type_leafref *)uni->types[*index];
1094 ++(*index);
1095 break;
1096 }
1097
1098 ++(*index);
1099 }
1100 } else {
1101 /* return just the single leafref */
1102 if (*index == 0) {
1103 ++(*index);
1104 assert(leaf_type->basetype == LY_TYPE_LEAFREF);
1105 ret = (struct lysc_type_leafref *)leaf_type;
1106 }
1107 }
1108
1109 return ret;
1110}
1111
1112/**
Michal Vaskoaa548942023-06-08 12:23:14 +02001113 * @brief Implement all referenced modules by leafrefs, when and must conditions.
1114 *
1115 * @param[in] ctx libyang context.
1116 * @param[in] unres Global unres structure with the sets to resolve.
1117 * @return LY_SUCCESS on success.
1118 * @return LY_ERECOMPILE if the whole dep set needs to be recompiled with the new implemented modules.
1119 * @return LY_ERR value on error.
1120 */
1121static LY_ERR
1122lys_compile_unres_depset_implement(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1123{
1124 struct lys_depset_unres *ds_unres = &unres->ds_unres;
1125 struct lysc_type_leafref *lref;
1126 const struct lys_module *mod;
1127 LY_ARRAY_COUNT_TYPE u;
1128 struct lysc_unres_leafref *l;
1129 struct lysc_unres_when *w;
1130 struct lysc_unres_must *m;
1131 struct lysc_must *musts;
1132 ly_bool not_implemented;
1133 uint32_t di = 0, li = 0, wi = 0, mi = 0;
1134
1135implement_all:
1136 /* disabled leafrefs - even those because we need to check their target exists */
1137 while (di < ds_unres->disabled_leafrefs.count) {
1138 l = ds_unres->disabled_leafrefs.objs[di];
1139
1140 u = 0;
1141 while ((lref = lys_type_leafref_next(l->node, &u))) {
1142 LY_CHECK_RET(lys_compile_expr_implement(ctx, lref->path, LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, 1, unres, NULL));
1143 }
1144
1145 ++di;
1146 }
1147
1148 /* leafrefs */
1149 while (li < ds_unres->leafrefs.count) {
1150 l = ds_unres->leafrefs.objs[li];
1151
1152 u = 0;
1153 while ((lref = lys_type_leafref_next(l->node, &u))) {
1154 LY_CHECK_RET(lys_compile_expr_implement(ctx, lref->path, LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, 1, unres, NULL));
1155 }
1156
1157 ++li;
1158 }
1159
1160 /* when conditions */
1161 while (wi < ds_unres->whens.count) {
1162 w = ds_unres->whens.objs[wi];
1163
1164 LY_CHECK_RET(lys_compile_expr_implement(ctx, w->when->cond, LY_VALUE_SCHEMA_RESOLVED, w->when->prefixes,
1165 ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod));
1166 if (mod) {
1167 LOGWRN(ctx, "When condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
1168 w->when->cond->expr, mod->name);
1169
1170 /* remove from the set to skip the check */
1171 ly_set_rm_index(&ds_unres->whens, wi, free);
1172 continue;
1173 }
1174
1175 ++wi;
1176 }
1177
1178 /* must conditions */
1179 while (mi < ds_unres->musts.count) {
1180 m = ds_unres->musts.objs[mi];
1181
1182 not_implemented = 0;
1183 musts = lysc_node_musts(m->node);
1184 LY_ARRAY_FOR(musts, u) {
1185 LY_CHECK_RET(lys_compile_expr_implement(ctx, musts[u].cond, LY_VALUE_SCHEMA_RESOLVED, musts[u].prefixes,
1186 ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod));
1187 if (mod) {
1188 LOGWRN(ctx, "Must condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
1189 musts[u].cond->expr, mod->name);
1190
1191 /* need to implement modules from all the expressions */
1192 not_implemented = 1;
1193 }
1194 }
1195
1196 if (not_implemented) {
1197 /* remove from the set to skip the check */
1198 lysc_unres_must_free(m);
1199 ly_set_rm_index(&ds_unres->musts, mi, NULL);
1200 continue;
1201 }
1202
1203 ++mi;
1204 }
1205
1206 if ((di < ds_unres->disabled_leafrefs.count) || (li < ds_unres->leafrefs.count) || (wi < ds_unres->whens.count)) {
1207 /* new items in the sets */
1208 goto implement_all;
1209 }
1210
1211 return LY_SUCCESS;
1212}
1213
1214/**
Michal Vasko93b9b242024-03-19 09:14:30 +01001215 * @brief Check that a disabled node (to be freed) can be freed and is not referenced.
1216 *
1217 * @param[in] node Disabled node to check.
1218 * @return LY_ERR value.
1219 */
1220static LY_ERR
1221lys_compile_unres_check_disabled(const struct lysc_node *node)
1222{
1223 const struct lysc_node *parent;
Michal Vasko99bfd402024-04-05 10:20:36 +02001224 struct lysc_node_list *slist;
Michal Vasko93b9b242024-03-19 09:14:30 +01001225 LY_ARRAY_COUNT_TYPE u, v;
Michal Vasko99bfd402024-04-05 10:20:36 +02001226 int found;
Michal Vasko93b9b242024-03-19 09:14:30 +01001227
1228 if (node->flags & LYS_KEY) {
1229 LOG_LOCSET(node, NULL);
1230 LOGVAL(node->module->ctx, LYVE_REFERENCE, "Key \"%s\" is disabled.", node->name);
1231 LOG_LOCBACK(1, 0);
1232 return LY_EVALID;
1233 }
1234
1235 for (parent = node->parent; parent; parent = parent->parent) {
1236 if (parent->nodetype != LYS_LIST) {
1237 continue;
1238 }
1239
Michal Vasko99bfd402024-04-05 10:20:36 +02001240 /* check and fix list uniques */
Michal Vasko93b9b242024-03-19 09:14:30 +01001241 slist = (struct lysc_node_list *)parent;
Michal Vasko99bfd402024-04-05 10:20:36 +02001242 found = 0;
Michal Vasko93b9b242024-03-19 09:14:30 +01001243 LY_ARRAY_FOR(slist->uniques, u) {
1244 LY_ARRAY_FOR(slist->uniques[u], v) {
1245 if (slist->uniques[u][v] == (struct lysc_node_leaf *)node) {
Michal Vasko99bfd402024-04-05 10:20:36 +02001246 found = 1;
1247 break;
1248 }
1249 }
1250
1251 if (found) {
1252 break;
1253 }
1254 }
1255
1256 if (found) {
1257 if (LY_ARRAY_COUNT(slist->uniques[u]) > 1) {
1258 /* remove the item */
1259 if (v < LY_ARRAY_COUNT(slist->uniques[u]) - 1) {
1260 memmove(&slist->uniques[u][v], &slist->uniques[u][v + 1],
1261 (LY_ARRAY_COUNT(slist->uniques[u]) - v - 1) * sizeof slist->uniques[u][v]);
1262 }
1263 LY_ARRAY_DECREMENT(slist->uniques[u]);
1264 } else {
1265 /* remove the whole unique array */
1266 LY_ARRAY_FREE(slist->uniques[u]);
1267 if (LY_ARRAY_COUNT(slist->uniques) > 1) {
1268 if (u < LY_ARRAY_COUNT(slist->uniques) - 1) {
1269 memmove(&slist->uniques[u], &slist->uniques[u + 1],
1270 (LY_ARRAY_COUNT(slist->uniques) - u - 1) * sizeof slist->uniques[u]);
1271 }
1272 LY_ARRAY_DECREMENT(slist->uniques);
1273 } else {
1274 LY_ARRAY_FREE(slist->uniques);
1275 slist->uniques = NULL;
Michal Vasko93b9b242024-03-19 09:14:30 +01001276 }
1277 }
1278 }
1279 }
1280
1281 return LY_SUCCESS;
1282}
1283
1284/**
Michal Vaskof4258e12021-06-15 12:11:42 +02001285 * @brief Finish dependency set compilation by resolving all the unres sets.
1286 *
1287 * @param[in] ctx libyang context.
1288 * @param[in] unres Global unres structure with the sets to resolve.
1289 * @return LY_SUCCESS on success.
1290 * @return LY_ERECOMPILE if the dep set needs to be recompiled.
1291 * @return LY_ERR value on error.
1292 */
1293static LY_ERR
1294lys_compile_unres_depset(struct ly_ctx *ctx, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +01001295{
Michal Vaskoaa548942023-06-08 12:23:14 +02001296 LY_ERR ret = LY_SUCCESS;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001297 struct lysc_node *node;
aPiecek732cd142021-07-07 16:29:59 +02001298 struct lysc_type *typeiter;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001299 struct lysc_type_leafref *lref;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001300 struct lysc_ctx cctx = {0};
1301 struct lys_depset_unres *ds_unres = &unres->ds_unres;
aPiecekd7bd52d2021-07-08 08:59:59 +02001302 struct ly_path *path;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001303 LY_ARRAY_COUNT_TYPE v;
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001304 struct lysc_unres_leafref *l;
Michal Vasko4ed3bd52022-12-02 10:28:04 +01001305 struct lysc_unres_when *w;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001306 struct lysc_unres_must *m;
Michal Vaskoe20599c2022-12-02 10:45:01 +01001307 struct lysc_unres_dflt *d;
aPiecekd7bd52d2021-07-08 08:59:59 +02001308 uint32_t i, processed_leafrefs = 0;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001309
aPiecekd7bd52d2021-07-08 08:59:59 +02001310resolve_all:
Michal Vaskoaa548942023-06-08 12:23:14 +02001311 /* implement all referenced modules to get final ds_unres set */
1312 if ((ret = lys_compile_unres_depset_implement(ctx, unres))) {
1313 goto cleanup;
1314 }
1315
1316 /* check disabled leafrefs */
aPiecekc6526b42021-07-12 15:21:39 +02001317 while (ds_unres->disabled_leafrefs.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001318 /* remember index, it can change before we get to free this item */
1319 i = ds_unres->disabled_leafrefs.count - 1;
1320 l = ds_unres->disabled_leafrefs.objs[i];
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001321 LYSC_CTX_INIT_PMOD(cctx, l->node->module->parsed, l->ext);
aPiecekc6526b42021-07-12 15:21:39 +02001322
Michal Vasko7a266772024-01-23 11:02:38 +01001323 LOG_LOCSET(l->node, NULL);
aPiecekc6526b42021-07-12 15:21:39 +02001324 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001325 while ((ret == LY_SUCCESS) && (lref = lys_type_leafref_next(l->node, &v))) {
Michal Vaskoaa548942023-06-08 12:23:14 +02001326 ret = lys_compile_unres_leafref(&cctx, l->node, lref, l->local_mod);
aPiecekc6526b42021-07-12 15:21:39 +02001327 }
Michal Vasko7a266772024-01-23 11:02:38 +01001328 LOG_LOCBACK(1, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001329 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001330
1331 ly_set_rm_index(&ds_unres->disabled_leafrefs, i, free);
aPiecekc6526b42021-07-12 15:21:39 +02001332 }
Michal Vaskoa23e1d92021-07-13 12:04:16 +02001333
Michal Vasko4ed3bd52022-12-02 10:28:04 +01001334 /* for leafref, we need 2 rounds - first detects circular chain by storing the first referred type (which
1335 * can be also leafref, in case it is already resolved, go through the chain and check that it does not
1336 * point to the starting leafref type). The second round stores the first non-leafref type for later data validation.
1337 * Also do the same check for set of the disabled leafrefs, but without the second round. */
aPiecekd7bd52d2021-07-08 08:59:59 +02001338 for (i = processed_leafrefs; i < ds_unres->leafrefs.count; ++i) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001339 l = ds_unres->leafrefs.objs[i];
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001340 LYSC_CTX_INIT_PMOD(cctx, l->node->module->parsed, l->ext);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001341
Michal Vasko7a266772024-01-23 11:02:38 +01001342 LOG_LOCSET(l->node, NULL);
aPiecek732cd142021-07-07 16:29:59 +02001343 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001344 while ((ret == LY_SUCCESS) && (lref = lys_type_leafref_next(l->node, &v))) {
Michal Vaskoaa548942023-06-08 12:23:14 +02001345 ret = lys_compile_unres_leafref(&cctx, l->node, lref, l->local_mod);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001346 }
Michal Vasko7a266772024-01-23 11:02:38 +01001347 LOG_LOCBACK(1, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001348 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001349 }
aPiecekd7bd52d2021-07-08 08:59:59 +02001350 for (i = processed_leafrefs; i < ds_unres->leafrefs.count; ++i) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001351 l = ds_unres->leafrefs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001352
Michal Vasko405cc9e2020-12-01 12:01:27 +01001353 /* store pointer to the real type */
aPiecek732cd142021-07-07 16:29:59 +02001354 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001355 while ((lref = lys_type_leafref_next(l->node, &v))) {
aPiecek732cd142021-07-07 16:29:59 +02001356 for (typeiter = lref->realtype;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001357 typeiter->basetype == LY_TYPE_LEAFREF;
1358 typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
Michal Vaskod15c7de2022-05-09 15:34:09 +02001359
Michal Vaskoc636ea42022-09-16 10:20:31 +02001360 lysc_type_free(&cctx.free_ctx, lref->realtype);
aPiecek732cd142021-07-07 16:29:59 +02001361 lref->realtype = typeiter;
Michal Vaskod15c7de2022-05-09 15:34:09 +02001362 ++lref->realtype->refcount;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001363 }
1364
Michal Vaskoe20599c2022-12-02 10:45:01 +01001365 /* if 'goto' will be used on the 'resolve_all' label, then the current leafref will not be processed again */
aPiecekd7bd52d2021-07-08 08:59:59 +02001366 processed_leafrefs++;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001367 }
1368
Michal Vaskoaa548942023-06-08 12:23:14 +02001369 /* check when, the referenced modules must be implemented now */
Michal Vaskoc130e162021-10-19 11:30:00 +02001370 while (ds_unres->whens.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001371 i = ds_unres->whens.count - 1;
Michal Vasko4ed3bd52022-12-02 10:28:04 +01001372 w = ds_unres->whens.objs[i];
1373 LYSC_CTX_INIT_PMOD(cctx, w->node->module->parsed, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001374
Michal Vaskoe6943a02024-02-27 09:04:07 +01001375 LOG_LOCSET(w->node, NULL);
Michal Vaskoe20599c2022-12-02 10:45:01 +01001376 ret = lys_compile_unres_when(&cctx, w->when, w->node);
Michal Vaskoe6943a02024-02-27 09:04:07 +01001377 LOG_LOCBACK(1, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001378 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001379
Michal Vasko4ed3bd52022-12-02 10:28:04 +01001380 free(w);
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001381 ly_set_rm_index(&ds_unres->whens, i, NULL);
Michal Vaskoc130e162021-10-19 11:30:00 +02001382 }
1383
1384 /* check must */
1385 while (ds_unres->musts.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001386 i = ds_unres->musts.count - 1;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001387 m = ds_unres->musts.objs[i];
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001388 LYSC_CTX_INIT_PMOD(cctx, m->node->module->parsed, m->ext);
Michal Vaskoc130e162021-10-19 11:30:00 +02001389
Michal Vasko7a266772024-01-23 11:02:38 +01001390 LOG_LOCSET(m->node, NULL);
Michal Vaskoaa548942023-06-08 12:23:14 +02001391 ret = lys_compile_unres_must(&cctx, m->node, m->local_mods);
Michal Vasko7a266772024-01-23 11:02:38 +01001392 LOG_LOCBACK(1, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001393 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoc130e162021-10-19 11:30:00 +02001394
1395 lysc_unres_must_free(m);
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001396 ly_set_rm_index(&ds_unres->musts, i, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001397 }
1398
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001399 /* remove disabled enums/bits */
Michal Vasko5eaf7322021-11-22 15:58:26 +01001400 while (ds_unres->disabled_bitenums.count) {
1401 i = ds_unres->disabled_bitenums.count - 1;
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001402 node = ds_unres->disabled_bitenums.objs[i];
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001403 LYSC_CTX_INIT_PMOD(cctx, node->module->parsed, NULL);
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001404
Michal Vasko7a266772024-01-23 11:02:38 +01001405 LOG_LOCSET(node, NULL);
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001406 ret = lys_compile_unres_disabled_bitenum(&cctx, (struct lysc_node_leaf *)node);
Michal Vasko7a266772024-01-23 11:02:38 +01001407 LOG_LOCBACK(1, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001408 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001409
1410 ly_set_rm_index(&ds_unres->disabled_bitenums, i, NULL);
1411 }
1412
Michal Vasko405cc9e2020-12-01 12:01:27 +01001413 /* finish incomplete default values compilation */
Michal Vaskof4258e12021-06-15 12:11:42 +02001414 while (ds_unres->dflts.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001415 i = ds_unres->dflts.count - 1;
Michal Vaskoe20599c2022-12-02 10:45:01 +01001416 d = ds_unres->dflts.objs[i];
1417 LYSC_CTX_INIT_PMOD(cctx, d->leaf->module->parsed, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001418
Michal Vasko7a266772024-01-23 11:02:38 +01001419 LOG_LOCSET(&d->leaf->node, NULL);
Michal Vaskoe20599c2022-12-02 10:45:01 +01001420 if (d->leaf->nodetype == LYS_LEAF) {
1421 ret = lys_compile_unres_leaf_dlft(&cctx, d->leaf, d->dflt, unres);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001422 } else {
Michal Vaskoe20599c2022-12-02 10:45:01 +01001423 ret = lys_compile_unres_llist_dflts(&cctx, d->llist, d->dflt, d->dflts, unres);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001424 }
Michal Vasko7a266772024-01-23 11:02:38 +01001425 LOG_LOCBACK(1, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001426 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001427
Michal Vaskoe20599c2022-12-02 10:45:01 +01001428 lysc_unres_dflt_free(ctx, d);
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001429 ly_set_rm_index(&ds_unres->dflts, i, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001430 }
1431
Michal Vaskoaa548942023-06-08 12:23:14 +02001432 /* some unres items may have been added by the default values */
aPiecekc6526b42021-07-12 15:21:39 +02001433 if ((processed_leafrefs != ds_unres->leafrefs.count) || ds_unres->disabled_leafrefs.count ||
Michal Vaskoc130e162021-10-19 11:30:00 +02001434 ds_unres->whens.count || ds_unres->musts.count || ds_unres->dflts.count) {
aPiecekd7bd52d2021-07-08 08:59:59 +02001435 goto resolve_all;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001436 }
1437
Michal Vasko30ab8e72021-04-19 12:47:52 +02001438 /* finally, remove all disabled nodes */
Michal Vaskof4258e12021-06-15 12:11:42 +02001439 for (i = 0; i < ds_unres->disabled.count; ++i) {
1440 node = ds_unres->disabled.snodes[i];
Michal Vasko93b9b242024-03-19 09:14:30 +01001441 ret = lys_compile_unres_check_disabled(node);
1442 LY_CHECK_GOTO(ret, cleanup);
1443
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001444 LYSC_CTX_INIT_PMOD(cctx, node->module->parsed, NULL);
Michal Vasko30ab8e72021-04-19 12:47:52 +02001445
Michal Vaskoc636ea42022-09-16 10:20:31 +02001446 lysc_node_free(&cctx.free_ctx, node, 1);
Michal Vasko30ab8e72021-04-19 12:47:52 +02001447 }
1448
aPiecekd7bd52d2021-07-08 08:59:59 +02001449 /* also check if the leafref target has not been disabled */
1450 for (i = 0; i < ds_unres->leafrefs.count; ++i) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001451 l = ds_unres->leafrefs.objs[i];
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001452 LYSC_CTX_INIT_PMOD(cctx, l->node->module->parsed, l->ext);
aPiecekd7bd52d2021-07-08 08:59:59 +02001453
1454 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001455 while ((lref = lys_type_leafref_next(l->node, &v))) {
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001456 ret = ly_path_compile_leafref(cctx.ctx, l->node, cctx.ext, lref->path,
Michal Vaskoc130e162021-10-19 11:30:00 +02001457 (l->node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
aPiecekd7bd52d2021-07-08 08:59:59 +02001458 LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &path);
Michal Vasko59391122024-08-16 15:38:02 +02001459 ly_path_free(l->node->module->ctx, path);
aPiecekd7bd52d2021-07-08 08:59:59 +02001460
1461 assert(ret != LY_ERECOMPILE);
1462 if (ret) {
Michal Vasko7a266772024-01-23 11:02:38 +01001463 LOG_LOCSET(l->node, NULL);
Michal Vaskoe02e7402021-07-23 08:29:28 +02001464 LOGVAL(ctx, LYVE_REFERENCE, "Target of leafref \"%s\" cannot be referenced because it is disabled.",
Michal Vaskoc130e162021-10-19 11:30:00 +02001465 l->node->name);
Michal Vasko7a266772024-01-23 11:02:38 +01001466 LOG_LOCBACK(1, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001467 ret = LY_EVALID;
1468 goto cleanup;
aPiecekd7bd52d2021-07-08 08:59:59 +02001469 }
1470 }
1471 }
1472
Michal Vaskoc636ea42022-09-16 10:20:31 +02001473cleanup:
1474 lysf_ctx_erase(&cctx.free_ctx);
1475 return ret;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001476}
1477
Michal Vaskof4258e12021-06-15 12:11:42 +02001478/**
1479 * @brief Erase dep set unres.
1480 *
1481 * @param[in] ctx libyang context.
1482 * @param[in] unres Global unres structure with the sets to resolve.
1483 */
1484static void
1485lys_compile_unres_depset_erase(const struct ly_ctx *ctx, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +01001486{
1487 uint32_t i;
1488
Michal Vasko4ed3bd52022-12-02 10:28:04 +01001489 ly_set_erase(&unres->ds_unres.whens, free);
Michal Vaskoc130e162021-10-19 11:30:00 +02001490 for (i = 0; i < unres->ds_unres.musts.count; ++i) {
1491 lysc_unres_must_free(unres->ds_unres.musts.objs[i]);
1492 }
1493 ly_set_erase(&unres->ds_unres.musts, NULL);
1494 ly_set_erase(&unres->ds_unres.leafrefs, free);
Michal Vaskof4258e12021-06-15 12:11:42 +02001495 for (i = 0; i < unres->ds_unres.dflts.count; ++i) {
1496 lysc_unres_dflt_free(ctx, unres->ds_unres.dflts.objs[i]);
Michal Vaskodf6319c2021-06-10 14:41:05 +02001497 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001498 ly_set_erase(&unres->ds_unres.dflts, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001499 ly_set_erase(&unres->ds_unres.disabled, NULL);
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001500 ly_set_erase(&unres->ds_unres.disabled_leafrefs, free);
1501 ly_set_erase(&unres->ds_unres.disabled_bitenums, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001502}
1503
Michal Vasko709f9a52021-07-21 10:51:59 +02001504/**
1505 * @brief Compile all flagged modules in a dependency set, recursively if recompilation is needed.
1506 *
1507 * @param[in] ctx libyang context.
1508 * @param[in] dep_set Dependency set to compile.
1509 * @param[in,out] unres Global unres to use.
1510 * @return LY_ERR value.
1511 */
1512static LY_ERR
1513lys_compile_depset_r(struct ly_ctx *ctx, struct ly_set *dep_set, struct lys_glob_unres *unres)
Michal Vaskof4258e12021-06-15 12:11:42 +02001514{
1515 LY_ERR ret = LY_SUCCESS;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001516 struct lysf_ctx fctx = {.ctx = ctx};
Michal Vaskof4258e12021-06-15 12:11:42 +02001517 struct lys_module *mod;
1518 uint32_t i;
1519
1520 for (i = 0; i < dep_set->count; ++i) {
1521 mod = dep_set->objs[i];
1522 if (!mod->to_compile) {
1523 /* skip */
1524 continue;
1525 }
1526 assert(mod->implemented);
1527
1528 /* free the compiled module, if any */
Michal Vaskoc636ea42022-09-16 10:20:31 +02001529 lysc_module_free(&fctx, mod->compiled);
Michal Vaskof4258e12021-06-15 12:11:42 +02001530 mod->compiled = NULL;
1531
1532 /* (re)compile the module */
1533 LY_CHECK_GOTO(ret = lys_compile(mod, &unres->ds_unres), cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001534 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001535
1536 /* resolve dep set unres */
1537 ret = lys_compile_unres_depset(ctx, unres);
1538 if (ret == LY_ERECOMPILE) {
1539 /* new module is implemented, discard current dep set unres and recompile the whole dep set */
1540 lys_compile_unres_depset_erase(ctx, unres);
Michal Vasko709f9a52021-07-21 10:51:59 +02001541 return lys_compile_depset_r(ctx, dep_set, unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001542 } else if (ret) {
1543 /* error */
1544 goto cleanup;
1545 }
1546
1547 /* success, unset the flags of all the modules in the dep set */
1548 for (i = 0; i < dep_set->count; ++i) {
1549 mod = dep_set->objs[i];
1550 mod->to_compile = 0;
1551 }
1552
1553cleanup:
1554 lys_compile_unres_depset_erase(ctx, unres);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001555 lysf_ctx_erase(&fctx);
Michal Vaskof4258e12021-06-15 12:11:42 +02001556 return ret;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001557}
1558
Michal Vasko6a4ef772022-02-08 15:07:44 +01001559/**
1560 * @brief Check if-feature of all features of all modules in a dep set.
1561 *
1562 * @param[in] dep_set Dep set to check.
1563 * @return LY_ERR value.
1564 */
1565static LY_ERR
1566lys_compile_depset_check_features(struct ly_set *dep_set)
1567{
1568 struct lys_module *mod;
1569 uint32_t i;
1570
1571 for (i = 0; i < dep_set->count; ++i) {
1572 mod = dep_set->objs[i];
1573 if (!mod->to_compile) {
1574 /* skip */
1575 continue;
1576 }
1577
1578 /* check features of this module */
1579 LY_CHECK_RET(lys_check_features(mod->parsed));
1580 }
1581
1582 return LY_SUCCESS;
1583}
1584
Michal Vasko709f9a52021-07-21 10:51:59 +02001585LY_ERR
1586lys_compile_depset_all(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1587{
1588 uint32_t i;
1589
1590 for (i = 0; i < unres->dep_sets.count; ++i) {
Michal Vasko6a4ef772022-02-08 15:07:44 +01001591 LY_CHECK_RET(lys_compile_depset_check_features(unres->dep_sets.objs[i]));
Michal Vasko709f9a52021-07-21 10:51:59 +02001592 LY_CHECK_RET(lys_compile_depset_r(ctx, unres->dep_sets.objs[i], unres));
1593 }
1594
1595 return LY_SUCCESS;
1596}
1597
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001598/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001599 * @brief Finish compilation of all the module unres sets in a compile context.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001600 *
1601 * @param[in] ctx Compile context with unres sets.
1602 * @return LY_ERR value.
1603 */
1604static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001605lys_compile_unres_mod(struct lysc_ctx *ctx)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001606{
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001607 struct lysc_augment *aug;
1608 struct lysc_deviation *dev;
Michal Vasko1ade6f12021-04-19 11:32:45 +02001609 struct lys_module *orig_mod = ctx->cur_mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001610 uint32_t i;
1611
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001612 /* check that all augments were applied */
1613 for (i = 0; i < ctx->augs.count; ++i) {
1614 aug = ctx->augs.objs[i];
Michal Vasko1ade6f12021-04-19 11:32:45 +02001615 ctx->cur_mod = aug->aug_pmod->mod;
Michal Vaskoa0ba01e2022-10-19 13:26:57 +02001616 if (aug->ext) {
1617 lysc_update_path(ctx, NULL, "{extension}");
1618 lysc_update_path(ctx, NULL, aug->ext->name);
1619 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01001620 lysc_update_path(ctx, NULL, "{augment}");
Michal Vasko8824a6e2024-01-19 12:42:21 +01001621 lysc_update_path(ctx, NULL, aug->nodeid->str);
Michal Vaskoa0ba01e2022-10-19 13:26:57 +02001622 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Augment%s target node \"%s\" from module \"%s\" was not found.",
Michal Vasko8824a6e2024-01-19 12:42:21 +01001623 aug->ext ? " extension" : "", aug->nodeid->str, LYSP_MODULE_NAME(aug->aug_pmod));
Michal Vasko1ade6f12021-04-19 11:32:45 +02001624 ctx->cur_mod = orig_mod;
Radek Krejci2efc45b2020-12-22 16:25:44 +01001625 lysc_update_path(ctx, NULL, NULL);
1626 lysc_update_path(ctx, NULL, NULL);
Michal Vaskoa0ba01e2022-10-19 13:26:57 +02001627 if (aug->ext) {
1628 lysc_update_path(ctx, NULL, NULL);
1629 lysc_update_path(ctx, NULL, NULL);
1630 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001631 }
1632 if (ctx->augs.count) {
1633 return LY_ENOTFOUND;
1634 }
1635
1636 /* check that all deviations were applied */
1637 for (i = 0; i < ctx->devs.count; ++i) {
1638 dev = ctx->devs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001639 lysc_update_path(ctx, NULL, "{deviation}");
Michal Vasko8824a6e2024-01-19 12:42:21 +01001640 lysc_update_path(ctx, NULL, dev->nodeid->str);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001641 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Deviation(s) target node \"%s\" from module \"%s\" was not found.",
Michal Vasko8824a6e2024-01-19 12:42:21 +01001642 dev->nodeid->str, LYSP_MODULE_NAME(dev->dev_pmods[0]));
Radek Krejci2efc45b2020-12-22 16:25:44 +01001643 lysc_update_path(ctx, NULL, NULL);
1644 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001645 }
1646 if (ctx->devs.count) {
1647 return LY_ENOTFOUND;
1648 }
1649
1650 return LY_SUCCESS;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001651}
1652
1653/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001654 * @brief Erase all the module unres sets in a compile context.
1655 *
1656 * @param[in] ctx Compile context with unres sets.
1657 * @param[in] error Whether the compilation finished with an error or not.
1658 */
1659static void
1660lys_compile_unres_mod_erase(struct lysc_ctx *ctx, ly_bool error)
1661{
1662 uint32_t i;
1663
1664 ly_set_erase(&ctx->groupings, NULL);
1665 ly_set_erase(&ctx->tpdf_chain, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001666
1667 if (!error) {
1668 /* there can be no leftover deviations or augments */
1669 LY_CHECK_ERR_RET(ctx->augs.count, LOGINT(ctx->ctx), );
1670 LY_CHECK_ERR_RET(ctx->devs.count, LOGINT(ctx->ctx), );
1671
1672 ly_set_erase(&ctx->augs, NULL);
1673 ly_set_erase(&ctx->devs, NULL);
1674 ly_set_erase(&ctx->uses_augs, NULL);
1675 ly_set_erase(&ctx->uses_rfns, NULL);
1676 } else {
1677 for (i = 0; i < ctx->augs.count; ++i) {
1678 lysc_augment_free(ctx->ctx, ctx->augs.objs[i]);
1679 }
1680 ly_set_erase(&ctx->augs, NULL);
1681 for (i = 0; i < ctx->devs.count; ++i) {
1682 lysc_deviation_free(ctx->ctx, ctx->devs.objs[i]);
1683 }
1684 ly_set_erase(&ctx->devs, NULL);
1685 for (i = 0; i < ctx->uses_augs.count; ++i) {
1686 lysc_augment_free(ctx->ctx, ctx->uses_augs.objs[i]);
1687 }
1688 ly_set_erase(&ctx->uses_augs, NULL);
1689 for (i = 0; i < ctx->uses_rfns.count; ++i) {
1690 lysc_refine_free(ctx->ctx, ctx->uses_rfns.objs[i]);
1691 }
1692 ly_set_erase(&ctx->uses_rfns, NULL);
1693 }
1694}
1695
Michal Vaskod39bea42021-06-14 10:42:49 +02001696LY_ERR
Michal Vaskof4258e12021-06-15 12:11:42 +02001697lys_compile(struct lys_module *mod, struct lys_depset_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001698{
Michal Vaskoc636ea42022-09-16 10:20:31 +02001699 struct lysc_ctx ctx;
Michal Vasko0b395e12021-04-23 13:43:07 +02001700 struct lysc_module *mod_c = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001701 struct lysp_module *sp;
1702 struct lysp_submodule *submod;
1703 struct lysp_node *pnode;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001704 struct lysp_node_grp *grp;
1705 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001706 LY_ERR ret = LY_SUCCESS;
1707
1708 LY_CHECK_ARG_RET(NULL, mod, mod->parsed, !mod->compiled, mod->ctx, LY_EINVAL);
1709
Michal Vaskof4258e12021-06-15 12:11:42 +02001710 assert(mod->implemented && mod->to_compile);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001711
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001712 sp = mod->parsed;
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001713 LYSC_CTX_INIT_PMOD(ctx, sp, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001714 ctx.unres = unres;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001715
Michal Vasko0b395e12021-04-23 13:43:07 +02001716 ++mod->ctx->change_count;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001717 mod->compiled = mod_c = calloc(1, sizeof *mod_c);
1718 LY_CHECK_ERR_RET(!mod_c, LOGMEM(mod->ctx), LY_EMEM);
1719 mod_c->mod = mod;
1720
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001721 /* compile augments and deviations of our module from other modules so they can be applied during compilation */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001722 LY_CHECK_GOTO(ret = lys_precompile_own_augments(&ctx), cleanup);
1723 LY_CHECK_GOTO(ret = lys_precompile_own_deviations(&ctx), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001724
1725 /* data nodes */
1726 LY_LIST_FOR(sp->data, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001727 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001728 }
1729
Radek Krejci2a9fc652021-01-22 17:44:34 +01001730 /* top-level RPCs */
1731 LY_LIST_FOR((struct lysp_node *)sp->rpcs, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001732 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001733 }
1734
1735 /* top-level notifications */
1736 LY_LIST_FOR((struct lysp_node *)sp->notifs, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001737 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001738 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001739
Michal Vasko193dacd2022-10-13 08:43:05 +02001740 /* module extension instances */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001741 COMPILE_EXTS_GOTO(&ctx, sp->exts, mod_c->exts, mod_c, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001742
1743 /* the same for submodules */
1744 LY_ARRAY_FOR(sp->includes, u) {
1745 submod = sp->includes[u].submodule;
1746 ctx.pmod = (struct lysp_module *)submod;
1747
1748 LY_LIST_FOR(submod->data, pnode) {
1749 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001750 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001751 }
1752
Radek Krejci2a9fc652021-01-22 17:44:34 +01001753 LY_LIST_FOR((struct lysp_node *)submod->rpcs, pnode) {
1754 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001755 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001756 }
1757
1758 LY_LIST_FOR((struct lysp_node *)submod->notifs, pnode) {
1759 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001760 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001761 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001762
Michal Vasko1ccbf542021-04-19 11:35:00 +02001763 COMPILE_EXTS_GOTO(&ctx, submod->exts, mod_c->exts, mod_c, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001764 }
Michal Vasko12606ee2020-11-25 17:05:11 +01001765 ctx.pmod = sp;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001766
1767 /* validate non-instantiated groupings from the parsed schema,
1768 * without it we would accept even the schemas with invalid grouping specification */
Michal Vasko7c565922021-06-10 14:58:27 +02001769 ctx.compile_opts |= LYS_COMPILE_GROUPING;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001770 LY_LIST_FOR(sp->groupings, grp) {
1771 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001772 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001773 }
1774 }
1775 LY_LIST_FOR(sp->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001776 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1777 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001778 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001779 }
1780 }
1781 }
1782 LY_ARRAY_FOR(sp->includes, u) {
1783 submod = sp->includes[u].submodule;
1784 ctx.pmod = (struct lysp_module *)submod;
1785
Radek Krejci2a9fc652021-01-22 17:44:34 +01001786 LY_LIST_FOR(submod->groupings, grp) {
1787 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001788 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001789 }
1790 }
1791 LY_LIST_FOR(submod->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001792 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1793 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001794 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001795 }
1796 }
1797 }
1798 }
1799 ctx.pmod = sp;
1800
Michal Vasko7a266772024-01-23 11:02:38 +01001801 ly_log_location_revert(0, 0, 1, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001802
Michal Vasko405cc9e2020-12-01 12:01:27 +01001803 /* finish compilation for all unresolved module items in the context */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001804 LY_CHECK_GOTO(ret = lys_compile_unres_mod(&ctx), cleanup);
Michal Vasko12606ee2020-11-25 17:05:11 +01001805
Michal Vasko1ccbf542021-04-19 11:35:00 +02001806cleanup:
Michal Vasko7a266772024-01-23 11:02:38 +01001807 ly_log_location_revert(0, 0, 1, 0);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001808 lys_compile_unres_mod_erase(&ctx, ret);
1809 if (ret) {
Michal Vaskoc636ea42022-09-16 10:20:31 +02001810 lysc_module_free(&ctx.free_ctx, mod_c);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001811 mod->compiled = NULL;
1812 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001813 return ret;
1814}
Michal Vasko65333882021-06-10 14:12:16 +02001815
aPiecek6b3d5422021-07-30 15:55:43 +02001816LY_ERR
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001817lys_compile_identities(struct lys_module *mod)
1818{
Michal Vasko776ae742022-08-04 11:08:21 +02001819 LY_ERR rc = LY_SUCCESS;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001820 struct lysc_ctx ctx;
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001821 struct lysp_submodule *submod;
1822 LY_ARRAY_COUNT_TYPE u;
1823
aPiecek6b3d5422021-07-30 15:55:43 +02001824 /* pre-compile identities of the module and any submodules */
Michal Vasko776ae742022-08-04 11:08:21 +02001825 rc = lys_identity_precompile(NULL, mod->ctx, mod->parsed, mod->parsed->identities, &mod->identities);
1826 LY_CHECK_GOTO(rc, cleanup);
aPiecek6b3d5422021-07-30 15:55:43 +02001827 LY_ARRAY_FOR(mod->parsed->includes, u) {
1828 submod = mod->parsed->includes[u].submodule;
Michal Vasko776ae742022-08-04 11:08:21 +02001829 rc = lys_identity_precompile(NULL, mod->ctx, (struct lysp_module *)submod, submod->identities, &mod->identities);
1830 LY_CHECK_GOTO(rc, cleanup);
aPiecek6b3d5422021-07-30 15:55:43 +02001831 }
1832
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001833 /* prepare context */
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001834 LYSC_CTX_INIT_PMOD(ctx, mod->parsed, NULL);
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001835
1836 if (mod->parsed->identities) {
Michal Vasko776ae742022-08-04 11:08:21 +02001837 rc = lys_compile_identities_derived(&ctx, mod->parsed->identities, &mod->identities);
1838 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001839 }
1840 lysc_update_path(&ctx, NULL, "{submodule}");
1841 LY_ARRAY_FOR(mod->parsed->includes, u) {
1842 submod = mod->parsed->includes[u].submodule;
1843 if (submod->identities) {
1844 ctx.pmod = (struct lysp_module *)submod;
1845 lysc_update_path(&ctx, NULL, submod->name);
Michal Vasko776ae742022-08-04 11:08:21 +02001846 rc = lys_compile_identities_derived(&ctx, submod->identities, &mod->identities);
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001847 lysc_update_path(&ctx, NULL, NULL);
1848 }
Michal Vasko776ae742022-08-04 11:08:21 +02001849
1850 if (rc) {
1851 break;
1852 }
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001853 }
1854 lysc_update_path(&ctx, NULL, NULL);
1855
Michal Vasko776ae742022-08-04 11:08:21 +02001856cleanup:
1857 /* always needed when using lysc_update_path() */
Michal Vasko7a266772024-01-23 11:02:38 +01001858 ly_log_location_revert(0, 0, 1, 0);
Michal Vasko776ae742022-08-04 11:08:21 +02001859 return rc;
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001860}
1861
1862/**
Michal Vasko65333882021-06-10 14:12:16 +02001863 * @brief Check whether a module does not have any (recursive) compiled import.
1864 *
1865 * @param[in] mod Module to examine.
1866 * @return LY_SUCCESS on success.
Michal Vaskof4258e12021-06-15 12:11:42 +02001867 * @return LY_ERECOMPILE on required recompilation of the dep set.
Michal Vasko65333882021-06-10 14:12:16 +02001868 * @return LY_ERR on error.
1869 */
1870static LY_ERR
1871lys_has_compiled_import_r(struct lys_module *mod)
1872{
1873 LY_ARRAY_COUNT_TYPE u;
Michal Vaskoe7927122021-06-15 12:00:04 +02001874 struct lys_module *m;
Michal Vasko65333882021-06-10 14:12:16 +02001875
1876 LY_ARRAY_FOR(mod->parsed->imports, u) {
Michal Vaskoe7927122021-06-15 12:00:04 +02001877 m = mod->parsed->imports[u].module;
1878 if (!m->implemented) {
Michal Vasko65333882021-06-10 14:12:16 +02001879 continue;
1880 }
1881
Michal Vaskoe7927122021-06-15 12:00:04 +02001882 if (!m->to_compile) {
Michal Vaskod39bea42021-06-14 10:42:49 +02001883 /* module was not/will not be compiled in this compilation (so disabled nodes are not present) */
Michal Vaskof4258e12021-06-15 12:11:42 +02001884 m->to_compile = 1;
Michal Vasko65333882021-06-10 14:12:16 +02001885 return LY_ERECOMPILE;
1886 }
1887
1888 /* recursive */
Michal Vaskoe7927122021-06-15 12:00:04 +02001889 LY_CHECK_RET(lys_has_compiled_import_r(m));
Michal Vasko65333882021-06-10 14:12:16 +02001890 }
1891
1892 return LY_SUCCESS;
1893}
1894
1895LY_ERR
1896lys_implement(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
1897{
Michal Vaskodc668d22023-02-13 10:23:13 +01001898 LY_ERR r;
Michal Vasko65333882021-06-10 14:12:16 +02001899 struct lys_module *m;
1900
1901 assert(!mod->implemented);
1902
Michal Vasko978532b2022-01-21 14:13:40 +01001903 /* check collision with other implemented revision */
Michal Vasko65333882021-06-10 14:12:16 +02001904 m = ly_ctx_get_module_implemented(mod->ctx, mod->name);
1905 if (m) {
1906 assert(m != mod);
Michal Vaskodc668d22023-02-13 10:23:13 +01001907 LOGERR(mod->ctx, LY_EDENIED, "Module \"%s@%s\" is already implemented in revision \"%s\".",
1908 mod->name, mod->revision ? mod->revision : "<none>", m->revision ? m->revision : "<none>");
1909 return LY_EDENIED;
Michal Vasko65333882021-06-10 14:12:16 +02001910 }
1911
1912 /* set features */
Michal Vaskodc668d22023-02-13 10:23:13 +01001913 r = lys_set_features(mod->parsed, features);
1914 if (r && (r != LY_EEXIST)) {
1915 return r;
Michal Vasko65333882021-06-10 14:12:16 +02001916 }
1917
Michal Vasko65333882021-06-10 14:12:16 +02001918 /*
1919 * mark the module implemented, which means
1920 * 1) to (re)compile it only ::lys_compile() call is needed
1921 * 2) its compilation will never cause new modules to be implemented (::lys_compile() does not return ::LY_ERECOMPILE)
1922 * but there can be some unres items added that do
1923 */
1924 mod->implemented = 1;
1925
Michal Vaskoa9f807e2021-06-15 12:07:16 +02001926 /* this module is compiled in this compilation */
1927 mod->to_compile = 1;
1928
Michal Vasko65333882021-06-10 14:12:16 +02001929 /* add the module into newly implemented module set */
1930 LY_CHECK_RET(ly_set_add(&unres->implementing, mod, 1, NULL));
1931
Michal Vaskoa9f807e2021-06-15 12:07:16 +02001932 /* mark target modules with our augments and deviations */
1933 LY_CHECK_RET(lys_precompile_augments_deviations(mod, unres));
Michal Vasko65333882021-06-10 14:12:16 +02001934
Michal Vaskod39bea42021-06-14 10:42:49 +02001935 /* check whether this module may reference any modules compiled previously */
1936 LY_CHECK_RET(lys_has_compiled_import_r(mod));
Michal Vasko65333882021-06-10 14:12:16 +02001937
Michal Vasko65333882021-06-10 14:12:16 +02001938 return LY_SUCCESS;
1939}