blob: 3693f5574acf54186d88034e85aedb7fc964e916 [file] [log] [blame]
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001/**
2 * @file schema_compile.h
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief Header for schema compilation.
5 *
6 * Copyright (c) 2015 - 2020 CESNET, z.s.p.o.
7 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
14
15#ifndef LY_SCHEMA_COMPILE_H_
16#define LY_SCHEMA_COMPILE_H_
17
Radek Krejci47fab892020-11-05 17:02:41 +010018#include <stddef.h>
19#include <stdint.h>
20
21#include "common.h"
22#include "dict.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020023#include "log.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020024#include "set.h"
Radek Krejci47fab892020-11-05 17:02:41 +010025#include "tree.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010026#include "tree_edit.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020027#include "tree_schema.h"
28
Radek Krejci47fab892020-11-05 17:02:41 +010029struct lyxp_expr;
30
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020031/**
Radek Krejci5f9a3672021-03-05 21:35:22 +010032 * @brief YANG schema compilation context.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020033 */
34struct lysc_ctx {
Radek Krejci5f9a3672021-03-05 21:35:22 +010035 struct ly_ctx *ctx; /**< libyang context */
Michal Vaskob8df5762021-01-12 15:15:53 +010036 struct lys_module *cur_mod; /**< module currently being compiled,
37 - identifier/path - used as the current module for unprefixed nodes
38 - augment - module where the augment is defined
39 - deviation - module where the deviation is defined
40 - uses - module where the uses is defined */
41 struct lysp_module *pmod; /**< parsed module being processed,
42 - identifier/path - used for searching imports to resolve prefixed nodes
43 - augment - module where the augment is defined
44 - deviation - module where the deviation is defined
45 - uses - module where the grouping is defined */
Radek Krejci6b88a462021-02-17 12:39:34 +010046 struct lysc_ext_instance *ext; /**< extension instance being processed and serving as a source for its substatements
47 instead of the module itself */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020048 struct ly_set groupings; /**< stack for groupings circular check */
Radek Krejci5f9a3672021-03-05 21:35:22 +010049 struct ly_set tpdf_chain; /**< stack for typedefs circular check */
50 struct ly_set disabled; /**< set of compiled nodes whose if-feature(s) was not satisfied (stored ::lysc_node *) */
51 struct ly_set augs; /**< set of compiled non-applied top-level augments (stored ::lysc_augment *) */
52 struct ly_set devs; /**< set of compiled non-applied deviations (stored ::lysc_deviation *) */
53 struct ly_set uses_augs; /**< set of compiled non-applied uses augments (stored ::lysc_augment *) */
54 struct ly_set uses_rfns; /**< set of compiled non-applied uses refines (stored ::lysc_refine *) */
Michal Vasko405cc9e2020-12-01 12:01:27 +010055 struct lys_glob_unres *unres; /**< global unres sets */
Radek Krejci5f9a3672021-03-05 21:35:22 +010056 uint32_t path_len; /**< number of path bytes used */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020057 uint32_t options; /**< various @ref scflags. */
58#define LYSC_CTX_BUFSIZE 4078
Radek Krejci5f9a3672021-03-05 21:35:22 +010059 char path[LYSC_CTX_BUFSIZE];/**< Path identifying the schema node currently being processed */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020060};
61
62/**
Michal Vasko405cc9e2020-12-01 12:01:27 +010063 * @brief Structure for unresolved items that may depend on any implemented module data so their resolution
64 * can only be performed after all module basic compilation is done.
65 */
66struct lys_glob_unres {
67 struct ly_set implementing; /**< set of YANG schemas being atomically implemented (compiled); the first added
68 module is always the explcitly implemented module, the other ones are dependencies */
69 struct ly_set creating; /**< set of YANG schemas being atomically created (parsed); it is a subset of implemented
70 and all these modules are freed if any error occurs */
71 struct ly_set xpath; /**< when/must to check */
72 struct ly_set leafrefs; /**< to validate leafref's targets */
73 struct ly_set dflts; /**< set of incomplete default values */
Michal Vasko1ccbf542021-04-19 11:35:00 +020074 ly_bool full_compilation; /**< flag marking that all the currently implemented modules were compiled in this
75 compilation (meaning that all their disabled nodes are still present) */
76 ly_bool recompile; /**< flag marking that a module needs to be recompiled for this compilation to succeed */
Michal Vasko405cc9e2020-12-01 12:01:27 +010077};
78
79/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020080 * @brief Structure for remembering default values of leaves and leaf-lists. They are resolved at schema compilation
81 * end when the whole schema tree is available.
82 */
83struct lysc_unres_dflt {
84 union {
85 struct lysc_node_leaf *leaf;
86 struct lysc_node_leaflist *llist;
87 };
88 struct lysp_qname *dflt;
89 struct lysp_qname *dflts; /**< this is a sized array */
90};
91
92/**
93 * @brief Duplicate string into dictionary
94 * @param[in] CTX libyang context of the dictionary.
95 * @param[in] ORIG String to duplicate.
96 * @param[out] DUP Where to store the result.
97 */
98#define DUP_STRING(CTX, ORIG, DUP, RET) if (ORIG) {RET = lydict_insert(CTX, ORIG, 0, &DUP);}
Radek Krejci771928a2021-01-19 13:42:36 +010099#define DUP_STRING_RET(CTX, ORIG, DUP) if (ORIG) {LY_ERR __ret = lydict_insert(CTX, ORIG, 0, &DUP); LY_CHECK_RET(__ret);}
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200100#define DUP_STRING_GOTO(CTX, ORIG, DUP, RET, GOTO) if (ORIG) {LY_CHECK_GOTO(RET = lydict_insert(CTX, ORIG, 0, &DUP), GOTO);}
101
102#define DUP_ARRAY(CTX, ORIG_ARRAY, NEW_ARRAY, DUP_FUNC) \
103 if (ORIG_ARRAY) { \
Michal Vasko5347e3a2020-11-03 17:14:57 +0100104 LY_ARRAY_COUNT_TYPE __u; \
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200105 LY_ARRAY_CREATE_RET(CTX, NEW_ARRAY, LY_ARRAY_COUNT(ORIG_ARRAY), LY_EMEM); \
Michal Vasko5347e3a2020-11-03 17:14:57 +0100106 LY_ARRAY_FOR(ORIG_ARRAY, __u) { \
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200107 LY_ARRAY_INCREMENT(NEW_ARRAY); \
Michal Vasko5347e3a2020-11-03 17:14:57 +0100108 LY_CHECK_RET(DUP_FUNC(CTX, &(NEW_ARRAY)[__u], &(ORIG_ARRAY)[__u])); \
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200109 } \
110 }
111
Michal Vasko5347e3a2020-11-03 17:14:57 +0100112#define COMPILE_OP_ARRAY_GOTO(CTX, ARRAY_P, ARRAY_C, PARENT, FUNC, USES_STATUS, RET, GOTO) \
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200113 if (ARRAY_P) { \
Michal Vasko5347e3a2020-11-03 17:14:57 +0100114 LY_ARRAY_COUNT_TYPE __u = (ARRAY_C) ? LY_ARRAY_COUNT(ARRAY_C) : 0; \
115 LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, __u + LY_ARRAY_COUNT(ARRAY_P), RET, GOTO); \
116 LY_ARRAY_FOR(ARRAY_P, __u) { \
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200117 LY_ARRAY_INCREMENT(ARRAY_C); \
Michal Vasko5347e3a2020-11-03 17:14:57 +0100118 RET = FUNC(CTX, &(ARRAY_P)[__u], PARENT, &(ARRAY_C)[LY_ARRAY_COUNT(ARRAY_C) - 1], USES_STATUS); \
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200119 if (RET == LY_EDENIED) { \
120 LY_ARRAY_DECREMENT(ARRAY_C); \
Michal Vasko5347e3a2020-11-03 17:14:57 +0100121 RET = LY_SUCCESS; \
122 } else if (RET) { \
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200123 goto GOTO; \
124 } \
125 } \
126 }
127
Michal Vasko5347e3a2020-11-03 17:14:57 +0100128#define COMPILE_ARRAY_GOTO(CTX, ARRAY_P, ARRAY_C, FUNC, RET, GOTO) \
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200129 if (ARRAY_P) { \
Michal Vasko5347e3a2020-11-03 17:14:57 +0100130 LY_ARRAY_COUNT_TYPE __u = (ARRAY_C) ? LY_ARRAY_COUNT(ARRAY_C) : 0; \
131 LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, __u + LY_ARRAY_COUNT(ARRAY_P), RET, GOTO); \
132 LY_ARRAY_FOR(ARRAY_P, __u) { \
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200133 LY_ARRAY_INCREMENT(ARRAY_C); \
Michal Vasko5347e3a2020-11-03 17:14:57 +0100134 RET = FUNC(CTX, &(ARRAY_P)[__u], &(ARRAY_C)[LY_ARRAY_COUNT(ARRAY_C) - 1]); \
135 LY_CHECK_GOTO(RET, GOTO); \
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200136 } \
137 }
138
Radek Krejciab430862021-03-02 20:13:40 +0100139#define COMPILE_EXTS_GOTO(CTX, EXTS_P, EXT_C, PARENT, RET, GOTO) \
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200140 if (EXTS_P) { \
Michal Vasko5347e3a2020-11-03 17:14:57 +0100141 LY_ARRAY_COUNT_TYPE __u = (EXT_C) ? LY_ARRAY_COUNT(EXT_C) : 0; \
142 LY_ARRAY_CREATE_GOTO((CTX)->ctx, EXT_C, __u + LY_ARRAY_COUNT(EXTS_P), RET, GOTO); \
143 LY_ARRAY_FOR(EXTS_P, __u) { \
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200144 LY_ARRAY_INCREMENT(EXT_C); \
Radek Krejciab430862021-03-02 20:13:40 +0100145 RET = lys_compile_ext(CTX, &(EXTS_P)[__u], &(EXT_C)[LY_ARRAY_COUNT(EXT_C) - 1], PARENT, NULL); \
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100146 if (RET == LY_ENOT) { \
Michal Vasko5347e3a2020-11-03 17:14:57 +0100147 LY_ARRAY_DECREMENT(EXT_C); \
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100148 RET = LY_SUCCESS; \
Michal Vasko5347e3a2020-11-03 17:14:57 +0100149 } else if (RET) { \
150 goto GOTO; \
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100151 } \
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200152 } \
153 }
154
155/**
156 * @brief Fill in the prepared compiled extension instance structure according to the parsed extension instance.
157 *
158 * @param[in] ctx Compilation context.
159 * @param[in] ext_p Parsed extension instance.
160 * @param[in,out] ext Prepared compiled extension instance.
161 * @param[in] parent Extension instance parent.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200162 * @param[in] ext_mod Optional module with the extension instance extension definition, set only for internal annotations.
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100163 * @return LY_SUCCESS on success.
164 * @return LY_ENOT if the extension is disabled and should be ignored.
165 * @return LY_ERR on error.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200166 */
167LY_ERR lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext, void *parent,
Radek Krejciab430862021-03-02 20:13:40 +0100168 const struct lys_module *ext_mod);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200169
170/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200171 * @brief Compile information from the identity statement
172 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200173 * The backlinks to the identities derived from this one are supposed to be filled later via ::lys_compile_identity_bases().
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200174 *
175 * @param[in] ctx_sc Compile context - alternative to the combination of @p ctx and @p parsed_mod.
176 * @param[in] ctx libyang context.
177 * @param[in] parsed_mod Module with the identities.
178 * @param[in] identities_p Array of the parsed identity definitions to precompile.
179 * @param[in,out] identities Pointer to the storage of the (pre)compiled identities array where the new identities are
180 * supposed to be added. The storage is supposed to be initiated to NULL when the first parsed identities are going
181 * to be processed.
182 * @return LY_ERR value.
183 */
184LY_ERR lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
185 struct lysp_ident *identities_p, struct lysc_ident **identities);
186
187/**
188 * @brief Find and process the referenced base identities from another identity or identityref
189 *
190 * For bases in identity set backlinks to them from the base identities. For identityref, store
191 * the array of pointers to the base identities. So one of the ident or bases parameter must be set
192 * to distinguish these two use cases.
193 *
194 * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
195 * @param[in] base_pmod Module where to resolve @p bases_p prefixes.
196 * @param[in] bases_p Array of names (including prefix if necessary) of base identities.
197 * @param[in] ident Referencing identity to work with, NULL for identityref.
198 * @param[in] bases Array of bases of identityref to fill in.
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100199 * @param[in] enabled Whether the base is disabled, must be set if @p ident is set.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200200 * @return LY_ERR value.
201 */
202LY_ERR lys_compile_identity_bases(struct lysc_ctx *ctx, const struct lysp_module *base_pmod, const char **bases_p,
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100203 struct lysc_ident *ident, struct lysc_ident ***bases, ly_bool *enabled);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200204
205/**
206 * @brief Check statement's status for invalid combination.
207 *
208 * The modX parameters are used just to determine if both flags are in the same module,
209 * so any of the schema module structure can be used, but both modules must be provided
210 * in the same type.
211 *
212 * @param[in] ctx Compile context for logging.
213 * @param[in] flags1 Flags of the referencing node.
214 * @param[in] mod1 Module of the referencing node,
215 * @param[in] name1 Schema node name of the referencing node.
216 * @param[in] flags2 Flags of the referenced node.
217 * @param[in] mod2 Module of the referenced node,
218 * @param[in] name2 Schema node name of the referenced node.
219 * @return LY_ERR value
220 */
221LY_ERR lysc_check_status(struct lysc_ctx *ctx, uint16_t flags1, void *mod1, const char *name1, uint16_t flags2,
222 void *mod2, const char *name2);
223
224/**
Michal Vasko25d6ad02020-10-22 12:20:22 +0200225 * @brief Check parsed expression for any prefixes of unimplemented modules.
226 *
227 * @param[in] ctx libyang context.
228 * @param[in] expr Parsed expression.
229 * @param[in] format Prefix format.
230 * @param[in] prefix_data Format-specific data (see ::ly_resolve_prefix()).
231 * @param[in] implement Whether all the non-implemented modules should are implemented or the first
232 * non-implemented module, if any, returned in @p mod_p.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100233 * @param[in,out] unres Global unres structure of newly implemented modules.
Michal Vasko25d6ad02020-10-22 12:20:22 +0200234 * @param[out] mod_p Module that is not implemented.
235 * @return LY_SUCCESS on success.
236 * @return LY_ERR on error.
237 */
238LY_ERR lys_compile_expr_implement(const struct ly_ctx *ctx, const struct lyxp_expr *expr, LY_PREFIX_FORMAT format,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100239 void *prefix_data, ly_bool implement, struct lys_glob_unres *unres, const struct lys_module **mod_p);
240
241/**
242 * @brief Finish compilation of all the global unres sets.
Michal Vasko1ccbf542021-04-19 11:35:00 +0200243 * Will always finish the compilation (never return @p unres with `recompile` set).
Michal Vasko405cc9e2020-12-01 12:01:27 +0100244 *
245 * @param[in] ctx libyang context.
246 * @param[in] unres Global unres structure with the sets to resolve.
247 * @return LY_ERR value.
248 */
249LY_ERR lys_compile_unres_glob(struct ly_ctx *ctx, struct lys_glob_unres *unres);
250
251/**
252 * @brief Revert a failed compilation (free new modules, unimplement newly implemented modules).
253 *
254 * @param[in] ctx libyang context.
255 * @param[in] unres Global unres set with newly implemented modules.
256 */
257void lys_compile_unres_glob_revert(struct ly_ctx *ctx, struct lys_glob_unres *unres);
258
259/**
260 * @brief Erase all the global unres sets.
261 *
262 * @param[in] ctx libyang context.
263 * @param[in] unres Global unres structure with the sets.
264 */
265void lys_compile_unres_glob_erase(const struct ly_ctx *ctx, struct lys_glob_unres *unres);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200266
267/**
Michal Vasko916aefb2020-11-02 15:43:16 +0100268 * @brief Recompile the whole context based on the current flags.
269 *
270 * @param[in] ctx Context to recompile.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100271 * @param[in] log Whether to log all the errors.
Michal Vasko916aefb2020-11-02 15:43:16 +0100272 * @return LY_SUCCESS on success.
273 * @return LY_ERR on error.
274 */
Michal Vasko405cc9e2020-12-01 12:01:27 +0100275LY_ERR lys_recompile(struct ly_ctx *ctx, ly_bool log);
Michal Vasko916aefb2020-11-02 15:43:16 +0100276
277/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200278 * @brief Compile printable schema into a validated schema linking all the references.
279 *
280 * @param[in] mod Pointer to the schema structure holding pointers to both schema structure types. The ::lys_module#parsed
281 * member is used as input and ::lys_module#compiled is used to hold the result of the compilation.
282 * @param[in] options Various options to modify compiler behavior, see [compile flags](@ref scflags).
Michal Vasko1ccbf542021-04-19 11:35:00 +0200283 * @param[in,out] unres Global unres structure for newly implemented modules. If `recompile` was set, @p mod
284 * was actually not compiled because there is at least one compiled imported module that must be recompiled first.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200285 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
286 */
Michal Vasko405cc9e2020-12-01 12:01:27 +0100287LY_ERR lys_compile(struct lys_module *mod, uint32_t options, struct lys_glob_unres *unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200288
289#endif /* LY_SCHEMA_COMPILE_H_ */