blob: d51174ef715d3acdf83318856d1e69bdf1d4bb7e [file] [log] [blame]
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001/**
2 * @file tree_schema.h
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief libyang representation of YANG schema trees.
5 *
6 * Copyright (c) 2015 - 2018 CESNET, z.s.p.o.
7 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
14
15#ifndef LY_TREE_SCHEMA_H_
16#define LY_TREE_SCHEMA_H_
17
Radek Krejci54579462019-04-30 12:47:06 +020018#define PCRE2_CODE_UNIT_WIDTH 8
19
20#include <pcre2.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020021
Radek Krejci5aeea3a2018-09-05 13:29:36 +020022#include <stdint.h>
Radek Krejcid3ca0632019-04-16 16:54:54 +020023#include <stdio.h>
Radek Krejci5aeea3a2018-09-05 13:29:36 +020024
Michal Vaskobabf0bd2021-08-31 14:55:39 +020025#include "config.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020026#include "log.h"
27#include "tree.h"
Radek Krejcice8c1592018-10-29 15:35:51 +010028
Radek Krejci70853c52018-10-15 14:46:16 +020029#ifdef __cplusplus
30extern "C" {
31#endif
32
Radek Krejcica376bd2020-06-11 16:04:06 +020033struct ly_ctx;
Radek Krejci47fab892020-11-05 17:02:41 +010034struct ly_path;
Radek Krejcica376bd2020-06-11 16:04:06 +020035struct ly_set;
Radek Krejci47fab892020-11-05 17:02:41 +010036struct lys_module;
37struct lysc_node;
38struct lyxp_expr;
Radek Krejcica376bd2020-06-11 16:04:06 +020039
Radek Krejci5aeea3a2018-09-05 13:29:36 +020040/**
Radek Krejci8678fa42020-08-18 16:07:28 +020041 * @page howtoSchema YANG Modules
42 *
43 * To be able to work with YANG data instances, libyang has to represent YANG data models. All the processed modules are stored
44 * in libyang [context](@ref howtoContext) and loaded using [parser functions](@ref howtoSchemaParsers). It means, that there is
45 * no way to create/change YANG module programmatically. However, all the YANG model definitions are available and can be examined
46 * through the C structures. All the context's modules together form YANG Schema for the data being instantiated.
47 *
48 * Any YANG module is represented as ::lys_module. In fact, the module is represented in two different formats. As ::lys_module.parsed,
49 * there is a parsed schema reflecting the source YANG module. It is exactly what is read from the input. This format is good for
50 * converting from one format to another (YANG to YIN and vice versa), but it is not very useful for validating/manipulating YANG
51 * data. Therefore, there is ::lys_module.compiled storing the compiled YANG module. It is based on the parsed module, but all the
52 * references are resolved. It means that, for example, there are no `grouping`s or `typedef`s since they are supposed to be placed instead of
53 * `uses` or `type` references. This split also means, that the YANG module is fully validated after compilation of the parsed
54 * representation of the module. YANG submodules are available only in the parsed representation. When a submodule is compiled, it
55 * is fully integrated into its main module.
56 *
57 * The context can contain even modules without the compiled representation. Such modules are still useful as imports of other
58 * modules. The grouping or typedef definition can be even compiled into the importing modules. This is actually the main
59 * difference between the imported and implemented modules in the libyang context. The implemented modules are compiled while the
60 * imported modules are only parsed.
61 *
Radek Krejcib100b192020-10-26 08:37:45 +010062 * By default, the module is implemented (and compiled) in case it is explicitly loaded or referenced in another module as
63 * target of leafref, augment or deviation. This behavior can be changed via context options ::LY_CTX_ALL_IMPLEMENTED, when
64 * all the modules in the context are marked as implemented (note the problem with multiple revisions of a single module),
65 * or by ::LY_CTX_REF_IMPLEMENTED option, extending the set of references making the module implemented by when, must and
66 * default statements.
Radek Krejci8678fa42020-08-18 16:07:28 +020067 *
68 * All modules with deviation definition are always marked as implemented. The imported (not implemented) module can be set implemented by ::lys_set_implemented(). But
69 * the implemented module cannot be changed back to just imported module. Note also that only one revision of a specific module
70 * can be implemented in a single context. The imported modules are used only as a
71 * source of definitions for types and groupings for uses statements. The data in such modules are ignored - caller
72 * is not allowed to create the data (including instantiating identities) defined in the model via data parsers,
73 * the default nodes are not added into any data tree and mandatory nodes are not checked in the data trees.
74 *
Michal Vasko14ed9cd2021-01-28 14:16:25 +010075 * The compiled schema tree nodes are able to hold private objects (::lysc_node.priv as a pointer to a structure,
aPiecek9922ea92021-04-12 07:59:20 +020076 * function, variable, ...) used by a caller application unless ::LY_CTX_SET_PRIV_PARSED is set, in that case
77 * the ::lysc_node.priv pointers are used by libyang.
Radek Krejci8678fa42020-08-18 16:07:28 +020078 * Note that the object is not freed by libyang when the context is being destroyed. So the caller is responsible
79 * for freeing the provided structure after the context is destroyed or the private pointer is set to NULL in
Radek Krejci90ed21e2021-04-12 14:47:46 +020080 * appropriate schema nodes where the object was previously set. Also ::lysc_tree_dfs_full() can be useful to manage
81 * the private data.
Radek Krejci8678fa42020-08-18 16:07:28 +020082 *
83 * Despite all the schema structures and their members are available as part of the libyang API and callers can use
84 * it to navigate through the schema tree structure or to obtain various information, we recommend to use the following
85 * macros for the specific actions.
86 * - ::LYSC_TREE_DFS_BEGIN and ::LYSC_TREE_DFS_END to traverse the schema tree (depth-first).
87 * - ::LY_LIST_FOR and ::LY_ARRAY_FOR as described on @ref howtoStructures page.
88 *
89 * Further information about modules handling can be found on the following pages:
90 * - @subpage howtoSchemaParsers
91 * - @subpage howtoSchemaFeatures
92 * - @subpage howtoPlugins
93 * - @subpage howtoSchemaPrinters
94 *
95 * \note There are many functions to access information from the schema trees. Details are available in
96 * the [Schema Tree module](@ref schematree).
97 *
98 * For information about difference between implemented and imported modules, see the
99 * [context description](@ref howtoContext).
100 *
101 * Functions List (not assigned to above subsections)
102 * --------------------------------------------------
103 * - ::lys_getnext()
104 * - ::lys_nodetype2str()
105 * - ::lys_set_implemented()
Radek Krejci8678fa42020-08-18 16:07:28 +0200106 *
Michal Vaskod5cfa6e2020-11-23 16:56:08 +0100107 * - ::lysc_has_when()
Michal Vaskoef53c812021-10-13 10:21:03 +0200108 * - ::lysc_owner_module()
Michal Vaskod5cfa6e2020-11-23 16:56:08 +0100109 *
Michal Vasko544e58a2021-01-28 14:33:41 +0100110 * - ::lysc_node_child()
Radek Krejci8678fa42020-08-18 16:07:28 +0200111 * - ::lysc_node_actions()
112 * - ::lysc_node_notifs()
113 *
Michal Vasko544e58a2021-01-28 14:33:41 +0100114 * - ::lysp_node_child()
Radek Krejci8678fa42020-08-18 16:07:28 +0200115 * - ::lysp_node_actions()
116 * - ::lysp_node_notifs()
117 * - ::lysp_node_groupings()
118 * - ::lysp_node_typedefs()
119 */
120
121/**
122 * @page howtoSchemaFeatures YANG Features
123 *
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100124 * YANG feature statement is an important part of the language which can significantly affect the meaning of the schemas.
125 * Modifying features may have similar effects as loading/removing schema from the context so it is limited to context
126 * preparation period before working with data. YANG features, respectively their use in if-feature
127 * statements, are evaluated as part of schema compilation so a feature-specific compiled schema tree is generated
128 * as a result.
Radek Krejci8678fa42020-08-18 16:07:28 +0200129 *
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100130 * To enable any features, they must currently be specified when implementing a new schema with ::lys_parse() or
131 * ::ly_ctx_load_module(). To later examine what the status of a feature is, check its ::LYS_FENABLED flag or
132 * search for it first with ::lys_feature_value(). Lastly, to evaluate compiled if-features, use ::lysc_iffeature_value().
Radek Krejci8678fa42020-08-18 16:07:28 +0200133 *
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100134 * To iterate over all features of a particular YANG module, use ::lysp_feature_next().
Radek Krejci8678fa42020-08-18 16:07:28 +0200135 *
136 * Note, that the feature's state can affect some of the output formats (e.g. Tree format).
137 *
138 * Functions List
139 * --------------
Radek Krejci8678fa42020-08-18 16:07:28 +0200140 * - ::lys_feature_value()
Radek Krejci8678fa42020-08-18 16:07:28 +0200141 * - ::lysc_iffeature_value()
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100142 * - ::lysp_feature_next()
Radek Krejci8678fa42020-08-18 16:07:28 +0200143 */
144
145/**
Radek Krejci2ff0d572020-05-21 15:27:28 +0200146 * @ingroup trees
Radek Krejci8678fa42020-08-18 16:07:28 +0200147 * @defgroup schematree Schema Tree
Radek Krejci2ff0d572020-05-21 15:27:28 +0200148 * @{
149 *
150 * Data structures and functions to manipulate and access schema tree.
151 */
152
Michal Vasko64246d82020-08-19 12:35:00 +0200153/* *INDENT-OFF* */
154
Radek Krejci2ff0d572020-05-21 15:27:28 +0200155/**
Michal Vasko208a04a2020-10-21 15:17:12 +0200156 * @brief Macro to iterate via all elements in a schema (sub)tree including input and output.
157 * Note that __actions__ and __notifications__ of traversed nodes __are ignored__! To traverse
158 * on all the nodes including those, use ::lysc_tree_dfs_full() instead.
159 *
160 * This is the opening part to the #LYSC_TREE_DFS_END - they always have to be used together.
Radek Krejci0935f412019-08-20 16:15:18 +0200161 *
162 * The function follows deep-first search algorithm:
163 * <pre>
164 * 1
165 * / \
166 * 2 4
167 * / / \
168 * 3 5 6
169 * </pre>
170 *
171 * Use the same parameters for #LYSC_TREE_DFS_BEGIN and #LYSC_TREE_DFS_END. While
Radek Krejci2a9fc652021-01-22 17:44:34 +0100172 * START can be any of the lysc_node* types (including lysc_node_action and lysc_node_notif),
Radek Krejci0935f412019-08-20 16:15:18 +0200173 * ELEM variable must be of the struct lysc_node* type.
174 *
175 * To skip a particular subtree, instead of the continue statement, set LYSC_TREE_DFS_continue
176 * variable to non-zero value.
177 *
178 * Use with opening curly bracket '{' after the macro.
179 *
180 * @param START Pointer to the starting element processed first.
181 * @param ELEM Iterator intended for use in the block.
182 */
183#define LYSC_TREE_DFS_BEGIN(START, ELEM) \
Radek Krejci857189e2020-09-01 13:26:36 +0200184 { ly_bool LYSC_TREE_DFS_continue = 0; struct lysc_node *LYSC_TREE_DFS_next; \
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100185 for ((ELEM) = (LYSC_TREE_DFS_next) = (struct lysc_node *)(START); \
Radek Krejci0935f412019-08-20 16:15:18 +0200186 (ELEM); \
187 (ELEM) = (LYSC_TREE_DFS_next), LYSC_TREE_DFS_continue = 0)
188
189/**
190 * @brief Macro to iterate via all elements in a (sub)tree. This is the closing part
191 * to the #LYSC_TREE_DFS_BEGIN - they always have to be used together.
192 *
193 * Use the same parameters for #LYSC_TREE_DFS_BEGIN and #LYSC_TREE_DFS_END. While
Radek Krejci2a9fc652021-01-22 17:44:34 +0100194 * START can be a pointer to any of the lysc_node* types (including lysc_node_action and lysc_node_notif),
Radek Krejci0935f412019-08-20 16:15:18 +0200195 * ELEM variable must be pointer to the lysc_node type.
196 *
197 * Use with closing curly bracket '}' after the macro.
198 *
199 * @param START Pointer to the starting element processed first.
200 * @param ELEM Iterator intended for use in the block.
201 */
Radek Krejci0935f412019-08-20 16:15:18 +0200202#define LYSC_TREE_DFS_END(START, ELEM) \
203 /* select element for the next run - children first */ \
204 if (LYSC_TREE_DFS_continue) { \
205 (LYSC_TREE_DFS_next) = NULL; \
206 } else { \
Michal Vasko544e58a2021-01-28 14:33:41 +0100207 (LYSC_TREE_DFS_next) = (struct lysc_node *)lysc_node_child(ELEM); \
Michal Vasko208a04a2020-10-21 15:17:12 +0200208 } \
Radek Krejci0935f412019-08-20 16:15:18 +0200209 if (!(LYSC_TREE_DFS_next)) { \
Michal Vasko208a04a2020-10-21 15:17:12 +0200210 /* no children, try siblings */ \
211 _LYSC_TREE_DFS_NEXT(START, ELEM, LYSC_TREE_DFS_next); \
Radek Krejci0935f412019-08-20 16:15:18 +0200212 } \
213 while (!(LYSC_TREE_DFS_next)) { \
214 /* parent is already processed, go to its sibling */ \
Radek Krejci7d95fbb2021-01-26 17:33:13 +0100215 (ELEM) = (ELEM)->parent; \
Michal Vasko208a04a2020-10-21 15:17:12 +0200216 _LYSC_TREE_DFS_NEXT(START, ELEM, LYSC_TREE_DFS_next); \
217 } }
218
219/**
220 * @brief Helper macro for #LYSC_TREE_DFS_END, should not be used directly!
221 */
222#define _LYSC_TREE_DFS_NEXT(START, ELEM, NEXT) \
223 if ((ELEM) == (struct lysc_node *)(START)) { \
224 /* we are done, no next element to process */ \
225 break; \
226 } \
Michal Vasko544e58a2021-01-28 14:33:41 +0100227 (NEXT) = (ELEM)->next;
Radek Krejci0935f412019-08-20 16:15:18 +0200228
Michal Vasko64246d82020-08-19 12:35:00 +0200229/* *INDENT-ON* */
230
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200231#define LY_REV_SIZE 11 /**< revision data string length (including terminating NULL byte) */
232
Radek Krejcide7a9c42021-03-10 13:13:06 +0100233/**
234 * @defgroup schemanodetypes Schema Node Types
235 * Values of the ::lysp_node.nodetype and ::lysc_node.nodetype members.
236 * @{
237 */
Michal Vasko7f45cf22020-10-01 12:49:44 +0200238#define LYS_UNKNOWN 0x0000 /**< uninitalized unknown statement node */
239#define LYS_CONTAINER 0x0001 /**< container statement node */
240#define LYS_CHOICE 0x0002 /**< choice statement node */
241#define LYS_LEAF 0x0004 /**< leaf statement node */
242#define LYS_LEAFLIST 0x0008 /**< leaf-list statement node */
243#define LYS_LIST 0x0010 /**< list statement node */
244#define LYS_ANYXML 0x0020 /**< anyxml statement node */
245#define LYS_ANYDATA 0x0060 /**< anydata statement node, in tests it can be used for both #LYS_ANYXML and #LYS_ANYDATA */
246#define LYS_CASE 0x0080 /**< case statement node */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200247
Michal Vasko7f45cf22020-10-01 12:49:44 +0200248#define LYS_RPC 0x0100 /**< RPC statement node */
249#define LYS_ACTION 0x0200 /**< action statement node */
250#define LYS_NOTIF 0x0400 /**< notification statement node */
Radek Krejcie7b95092019-05-15 11:03:07 +0200251
Michal Vasko7f45cf22020-10-01 12:49:44 +0200252#define LYS_USES 0x0800 /**< uses statement node */
253#define LYS_INPUT 0x1000 /**< RPC/action input node */
254#define LYS_OUTPUT 0x2000 /**< RPC/action output node */
255#define LYS_GROUPING 0x4000
256#define LYS_AUGMENT 0x8000
Radek Krejci6d9b9b52018-11-02 12:43:39 +0100257
Radek Krejcif13b87b2020-12-01 22:02:17 +0100258#define LYS_NODETYPE_MASK 0xffff /**< Mask for nodetypes, the value is limited for 16 bits */
Radek Krejcide7a9c42021-03-10 13:13:06 +0100259/** @} schemanodetypes */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100260
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200261/**
Radek Krejci61837f72021-03-02 19:53:59 +0100262 * @brief Generic test for operation statements.
263 *
264 * This macro matches a subset of schema nodes that maps to common ::lysc_node or ::lysp_node structures. To match all
265 * such nodes, use ::LY_STMT_IS_NODE()
266 *
267 * This macro matches action and RPC.
Radek Krejci6b88a462021-02-17 12:39:34 +0100268 */
269#define LY_STMT_IS_OP(STMT) (((STMT) == LY_STMT_ACTION) || ((STMT) == LY_STMT_RPC))
270
271/**
Radek Krejci61837f72021-03-02 19:53:59 +0100272 * @brief Generic test for schema data nodes.
Radek Krejci6b88a462021-02-17 12:39:34 +0100273 *
Radek Krejci61837f72021-03-02 19:53:59 +0100274 * This macro matches a subset of schema nodes that maps to common ::lysc_node or ::lysp_node structures. To match all
275 * such nodes, use ::LY_STMT_IS_NODE()
Radek Krejci6b88a462021-02-17 12:39:34 +0100276 *
Radek Krejci61837f72021-03-02 19:53:59 +0100277 * This macro matches anydata, anyxml, augment, case, choice, container, grouping, leaf, leaf-list, list and uses. Note
278 * that the list of statements that can appear in parsed or compiled schema trees differs (e.g. no uses in compiled tree).
Radek Krejci6b88a462021-02-17 12:39:34 +0100279 */
Radek Krejci61837f72021-03-02 19:53:59 +0100280#define LY_STMT_IS_DATA_NODE(STMT) (((STMT) >= LY_STMT_ANYDATA) && ((STMT) <= LY_STMT_LIST))
281
282/**
283 * @brief Generic test for any schema node that maps to common ::lysc_node or ::lysp_node structures.
284 *
285 * Note that the list of statements that can appear in parsed or compiled schema trees differs (e.g. no uses in compiled tree).
286 *
287 * To check for some of the subsets of this test, try ::LY_STMT_IS_DATA_NODE() or ::LY_STMT_IS_OP().
288 *
289 * This macro matches action, anydata, anyxml, augment, case, choice, container, grouping, input, leaf, leaf-list, list,
290 * notification, output, RPC and uses.
291 */
292#define LY_STMT_IS_NODE(STMT) (((STMT) >= LY_STMT_NOTIFICATION) && ((STMT) <= LY_STMT_LIST))
Radek Krejci6b88a462021-02-17 12:39:34 +0100293
294/**
Radek Krejcid6b76452019-09-03 17:03:03 +0200295 * @brief List of YANG statements
296 */
297enum ly_stmt {
298 LY_STMT_NONE = 0,
Radek Krejci6b88a462021-02-17 12:39:34 +0100299
300 LY_STMT_NOTIFICATION, /**< in ::lysc_ext_substmt.storage stored as a pointer to linked list of `struct lysc_node_notif *`.
301 The RPCs/Actions and Notifications are expected in a separated lists than the rest of
302 data definition nodes as it is done in generic structures of libyang. */
Radek Krejci61837f72021-03-02 19:53:59 +0100303 LY_STMT_INPUT,
304 LY_STMT_OUTPUT,
Radek Krejci6b88a462021-02-17 12:39:34 +0100305
306/* LY_STMT_IS_OP */
Radek Krejcieccf6602021-02-05 19:42:54 +0100307 LY_STMT_ACTION, /**< in ::lysc_ext_substmt.storage stored as a pointer to linked list of `struct lysc_node_action *`.
Radek Krejci6b88a462021-02-17 12:39:34 +0100308 The RPCs/Actions and Notifications are expected in a separated lists than the rest of
309 data definition nodes as it is done in generic structures of libyang. */
310 LY_STMT_RPC, /**< in ::lysc_ext_substmt.storage stored as a pointer to linked list of `struct lysc_node_action *`.
311 The RPCs/Actions and Notifications are expected in a separated lists than the rest of
312 data definition nodes as it is done in generic structures of libyang. */
313
Radek Krejci61837f72021-03-02 19:53:59 +0100314/* LY_STMT_IS_DATA_NODE */
Radek Krejcieccf6602021-02-05 19:42:54 +0100315 LY_STMT_ANYDATA, /**< in ::lysc_ext_substmt.storage stored as a pointer to linked list of `struct lysc_node *`.
Radek Krejci6b88a462021-02-17 12:39:34 +0100316 Note that due to ::lysc_node compatibility the anydata is expected to be actually
317 mixed in the linked list with other ::lysc_node based nodes. The RPCs/Actions and
318 Notifications are expected in a separated lists as it is done in generic structures
319 of libyang. */
Radek Krejcieccf6602021-02-05 19:42:54 +0100320 LY_STMT_ANYXML, /**< in ::lysc_ext_substmt.storage stored as a pointer to linked list of `struct lysc_node *`.
Radek Krejci6b88a462021-02-17 12:39:34 +0100321 Note that due to ::lysc_node compatibility the anyxml is expected to be actually
322 mixed in the linked list with other ::lysc_node based nodes. The RPCs/Actions and
323 Notifications are expected in a separated lists as it is done in generic structures
324 of libyang. */
325 LY_STMT_AUGMENT,
326 LY_STMT_CASE, /**< TODO is it possible to compile cases without the parent choice? */
327 LY_STMT_CHOICE, /**< in ::lysc_ext_substmt.storage stored as a pointer to linked list of `struct lysc_node *`.
328 Note that due to ::lysc_node compatibility the choice is expected to be actually
329 mixed in the linked list with other ::lysc_node based nodes. The RPCs/Actions and
330 Notifications are expected in a separated lists as it is done in generic structures
331 of libyang. */
332 LY_STMT_CONTAINER, /**< in ::lysc_ext_substmt.storage stored as a pointer to linked list of `struct lysc_node *`.
333 Note that due to ::lysc_node compatibility the container is expected to be actually
334 mixed in the linked list with other ::lysc_node based nodes. The RPCs/Actions and
335 Notifications are expected in a separated lists as it is done in generic structures
336 of libyang. */
337 LY_STMT_GROUPING,
338 LY_STMT_LEAF, /**< in ::lysc_ext_substmt.storage stored as a pointer to linked list of `struct lysc_node *`.
339 Note that due to ::lysc_node compatibility the leaf is expected to be actually
340 mixed in the linked list with other ::lysc_node based nodes. The RPCs/Actions and
341 Notifications are expected in a separated lists as it is done in generic structures
342 of libyang. */
343 LY_STMT_LEAF_LIST, /**< in ::lysc_ext_substmt.storage stored as a pointer to linked list of `struct lysc_node *`.
344 Note that due to ::lysc_node compatibility the leaf-list is expected to be actually
345 mixed in the linked list with other ::lysc_node based nodes. The RPCs/Actions and
346 Notifications are expected in a separated lists as it is done in generic structures
347 of libyang. */
348 LY_STMT_LIST, /**< in ::lysc_ext_substmt.storage stored as a pointer to linked list of `struct lysc_node *`.
349 Note that due to ::lysc_node compatibility the list is expected to be actually
350 mixed in the linked list with other ::lysc_node based nodes. The RPCs/Actions and
351 Notifications are expected in a separated lists as it is done in generic structures
352 of libyang. */
353 LY_STMT_USES,
354
355/* rest */
Radek Krejcid6b76452019-09-03 17:03:03 +0200356 LY_STMT_ARGUMENT,
Radek Krejcid6b76452019-09-03 17:03:03 +0200357 LY_STMT_BASE,
358 LY_STMT_BELONGS_TO,
359 LY_STMT_BIT,
Radek Krejcieccf6602021-02-05 19:42:54 +0100360 LY_STMT_CONFIG, /**< in ::lysc_ext_substmt.storage stored as a pointer to `uint16_t`, only cardinality < #LY_STMT_CARD_SOME is allowed */
Radek Krejcid6b76452019-09-03 17:03:03 +0200361 LY_STMT_CONTACT,
Radek Krejcieccf6602021-02-05 19:42:54 +0100362 LY_STMT_DEFAULT,
Radek Krejci6b88a462021-02-17 12:39:34 +0100363 LY_STMT_DESCRIPTION, /**< in ::lysc_ext_substmt.storage stored as a pointer to `const char *` (cardinality < #LY_STMT_CARD_SOME)
364 or as a pointer to a [sized array](@ref sizedarrays) `const char **` */
Radek Krejcid6b76452019-09-03 17:03:03 +0200365 LY_STMT_DEVIATE,
366 LY_STMT_DEVIATION,
367 LY_STMT_ENUM,
368 LY_STMT_ERROR_APP_TAG,
369 LY_STMT_ERROR_MESSAGE,
370 LY_STMT_EXTENSION,
Radek Krejcieccf6602021-02-05 19:42:54 +0100371 LY_STMT_EXTENSION_INSTANCE,
Radek Krejcid6b76452019-09-03 17:03:03 +0200372 LY_STMT_FEATURE,
373 LY_STMT_FRACTION_DIGITS,
Radek Krejcid6b76452019-09-03 17:03:03 +0200374 LY_STMT_IDENTITY,
Radek Krejci6b88a462021-02-17 12:39:34 +0100375 LY_STMT_IF_FEATURE, /**< if-feature statements are not compiled, they are evaluated and the parent statement is
376 preserved only in case the evaluation of all the if-feature statements is true.
377 Therefore there is no storage expected. */
Radek Krejcid6b76452019-09-03 17:03:03 +0200378 LY_STMT_IMPORT,
379 LY_STMT_INCLUDE,
Radek Krejcid6b76452019-09-03 17:03:03 +0200380 LY_STMT_KEY,
Radek Krejcid6b76452019-09-03 17:03:03 +0200381 LY_STMT_LENGTH,
Radek Krejcieccf6602021-02-05 19:42:54 +0100382 LY_STMT_MANDATORY, /**< in ::lysc_ext_substmt.storage stored as a pointer to `uint16_t`, only cardinality < #LY_STMT_CARD_SOME is allowed */
Radek Krejcid6b76452019-09-03 17:03:03 +0200383 LY_STMT_MAX_ELEMENTS,
384 LY_STMT_MIN_ELEMENTS,
385 LY_STMT_MODIFIER,
386 LY_STMT_MODULE,
387 LY_STMT_MUST,
388 LY_STMT_NAMESPACE,
Radek Krejcid6b76452019-09-03 17:03:03 +0200389 LY_STMT_ORDERED_BY,
390 LY_STMT_ORGANIZATION,
Radek Krejcid6b76452019-09-03 17:03:03 +0200391 LY_STMT_PATH,
392 LY_STMT_PATTERN,
393 LY_STMT_POSITION,
394 LY_STMT_PREFIX,
395 LY_STMT_PRESENCE,
396 LY_STMT_RANGE,
Radek Krejci6b88a462021-02-17 12:39:34 +0100397 LY_STMT_REFERENCE, /**< in ::lysc_ext_substmt.storage stored as a pointer to `const char *` (cardinality < #LY_STMT_CARD_SOME)
398 or as a pointer to a [sized array](@ref sizedarrays) `const char **` */
Radek Krejcid6b76452019-09-03 17:03:03 +0200399 LY_STMT_REFINE,
400 LY_STMT_REQUIRE_INSTANCE,
401 LY_STMT_REVISION,
402 LY_STMT_REVISION_DATE,
Radek Krejcieccf6602021-02-05 19:42:54 +0100403 LY_STMT_STATUS, /**< in ::lysc_ext_substmt.storage stored as a pointer to `uint16_t`, only cardinality < #LY_STMT_CARD_SOME is allowed */
Radek Krejcid6b76452019-09-03 17:03:03 +0200404 LY_STMT_SUBMODULE,
Radek Krejcieccf6602021-02-05 19:42:54 +0100405 LY_STMT_TYPE, /**< in ::lysc_ext_substmt.storage stored as a pointer to `struct lysc_type *` (cardinality < #LY_STMT_CARD_SOME)
406 or as a pointer to a [sized array](@ref sizedarrays) `struct lysc_type **` */
Radek Krejcid6b76452019-09-03 17:03:03 +0200407 LY_STMT_TYPEDEF,
408 LY_STMT_UNIQUE,
Radek Krejcieccf6602021-02-05 19:42:54 +0100409 LY_STMT_UNITS, /**< in ::lysc_ext_substmt.storage stored as a pointer to `const char *` (cardinality < #LY_STMT_CARD_SOME)
410 or as a pointer to a [sized array](@ref sizedarrays) `const char **` */
Radek Krejcid6b76452019-09-03 17:03:03 +0200411 LY_STMT_VALUE,
412 LY_STMT_WHEN,
413 LY_STMT_YANG_VERSION,
Radek Krejci2b0f0f12021-03-02 16:02:35 +0100414 LY_STMT_YIN_ELEMENT,
415
416 /* separated from the list of statements
417 * the following tokens are part of the syntax and parsers have to work
418 * with them, but they are not a standard YANG statements
419 */
420 LY_STMT_SYNTAX_SEMICOLON,
421 LY_STMT_SYNTAX_LEFT_BRACE,
422 LY_STMT_SYNTAX_RIGHT_BRACE,
423
424 /*
425 * YIN-specific tokens, still they are part of the syntax, but not the standard statements
426 */
427 LY_STMT_ARG_TEXT,
428 LY_STMT_ARG_VALUE
Radek Krejcid6b76452019-09-03 17:03:03 +0200429};
430
431/**
Radek Krejcif8ca8192021-03-02 16:50:06 +0100432 * @brief Stringify statement identifier.
433 * @param[in] stmt The statement identifier to stringify.
434 * @return Constant string representation of the given @p stmt.
435 */
436const char *ly_stmt2str(enum ly_stmt stmt);
437
438/**
Radek Krejci39b7fc22021-02-26 23:29:18 +0100439 * @brief Convert nodetype to statement identifier
440 * @param[in] nodetype Nodetype to convert.
441 * @return Statement identifier representing the given @p nodetype.
442 */
443enum ly_stmt lys_nodetype2stmt(uint16_t nodetype);
444
445/**
Radek Krejcib1c11532021-03-29 14:14:19 +0200446 * @brief Possible cardinalities of the YANG statements.
447 *
448 * Used in extensions plugins to define cardinalities of the extension instance substatements.
449 */
450enum ly_stmt_cardinality {
451 LY_STMT_CARD_OPT, /* 0..1 */
452 LY_STMT_CARD_MAND, /* 1 */
453 LY_STMT_CARD_SOME, /* 1..n */
454 LY_STMT_CARD_ANY /* 0..n */
455};
456
457/**
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200458 * @brief YANG import-stmt
459 */
460struct lysp_import {
Radek Krejci086c7132018-10-26 15:29:04 +0200461 struct lys_module *module; /**< pointer to the imported module
462 (mandatory, but resolved when the referring module is completely parsed) */
463 const char *name; /**< name of the imported module (mandatory) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200464 const char *prefix; /**< prefix for the data from the imported schema (mandatory) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200465 const char *dsc; /**< description */
466 const char *ref; /**< reference */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200467 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Michal Vasko3e9bc2f2020-11-04 17:13:56 +0100468 uint16_t flags; /**< LYS_INTERNAL value (@ref snodeflags) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200469 char rev[LY_REV_SIZE]; /**< revision-date of the imported module */
470};
471
472/**
473 * @brief YANG include-stmt
474 */
475struct lysp_include {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100476 struct lysp_submodule *submodule;/**< pointer to the parsed submodule structure
Radek Krejci086c7132018-10-26 15:29:04 +0200477 (mandatory, but resolved when the referring module is completely parsed) */
478 const char *name; /**< name of the included submodule (mandatory) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200479 const char *dsc; /**< description */
480 const char *ref; /**< reference */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200481 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200482 char rev[LY_REV_SIZE]; /**< revision-date of the included submodule */
Radek Krejci771928a2021-01-19 13:42:36 +0100483 ly_bool injected; /**< flag to mark includes copied into main module from submodules,
484 only for backward compatibility with YANG 1.0, which does not require the
485 main module to include all submodules. */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200486};
487
488/**
489 * @brief YANG extension-stmt
490 */
491struct lysp_ext {
492 const char *name; /**< extension name */
Radek Krejci9f87b0c2021-03-05 14:45:26 +0100493 const char *argname; /**< argument name, NULL if not specified */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200494 const char *dsc; /**< description statement */
495 const char *ref; /**< reference statement */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200496 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejcif56e2a42019-09-09 14:15:25 +0200497 uint16_t flags; /**< LYS_STATUS_* and LYS_YINELEM_* values (@ref snodeflags) */
Michal Vasko5fe75f12020-03-02 13:52:37 +0100498
Radek Krejci720d2612021-03-03 19:44:22 +0100499 struct lysc_ext *compiled; /**< pointer to the compiled extension definition.
500 The extension definition is compiled only if there is compiled extension instance,
501 otherwise this pointer remains NULL. The compiled extension definition is shared
502 among all extension instances. */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200503};
504
505/**
506 * @brief Helper structure for generic storage of the extension instances content.
507 */
508struct lysp_stmt {
509 const char *stmt; /**< identifier of the statement */
510 const char *arg; /**< statement's argument */
Radek Krejci8df109d2021-04-23 12:19:08 +0200511 LY_VALUE_FORMAT format; /**< prefix format of the identifier/argument (::LY_VALUE_XML is YIN format) */
Radek Krejci0b013302021-03-29 15:22:32 +0200512 void *prefix_data; /**< Format-specific data for prefix resolution (see ly_resolve_prefix()) */
Michal Vaskofc2cd072021-02-24 13:17:17 +0100513
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200514 struct lysp_stmt *next; /**< link to the next statement */
Michal Vaskobc2559f2018-09-07 10:17:50 +0200515 struct lysp_stmt *child; /**< list of the statement's substatements (linked list) */
David Sedlákb9d75c42019-08-14 10:49:42 +0200516 uint16_t flags; /**< statement flags, can be set to LYS_YIN_ATTR */
Radek Krejci335332a2019-09-05 13:03:35 +0200517 enum ly_stmt kw; /**< numeric respresentation of the stmt value */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200518};
519
David Sedlákae4b4512019-08-14 10:45:56 +0200520#define LYS_YIN 0x1 /**< used to specify input format of extension instance */
521
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200522/**
523 * @brief YANG extension instance
524 */
525struct lysp_ext_instance {
David Sedlákbbd06ca2019-06-27 14:15:38 +0200526 const char *name; /**< extension identifier, including possible prefix */
527 const char *argument; /**< optional value of the extension's argument */
aPiecek60d9d672021-04-27 15:49:57 +0200528 LY_VALUE_FORMAT format; /**< prefix format of the extension name/argument (::LY_VALUE_XML is YIN format) */
529 struct lysp_node *parsed; /**< Simply parsed (unresolved) YANG schema tree serving as a cache.
530 Only lys_compile_extension_instance() can set this. */
Michal Vaskofc2cd072021-02-24 13:17:17 +0100531 void *prefix_data; /**< Format-specific data for prefix resolution
Radek Krejci0b013302021-03-29 15:22:32 +0200532 (see ly_resolve_prefix()) */
Michal Vaskofc2cd072021-02-24 13:17:17 +0100533
Radek Krejci5f9a3672021-03-05 21:35:22 +0100534 struct lysp_stmt *child; /**< list of the extension's substatements (linked list) */
535
Radek Krejci335332a2019-09-05 13:03:35 +0200536 void *parent; /**< pointer to the parent element holding the extension instance(s), use
Radek Krejciab430862021-03-02 20:13:40 +0100537 ::lysp_ext_instance#parent_stmt to access the schema element */
Radek Krejciab430862021-03-02 20:13:40 +0100538 enum ly_stmt parent_stmt; /**< value identifying placement of the extension instance */
539 LY_ARRAY_COUNT_TYPE parent_stmt_index; /**< in case the instance is in a substatement, this identifies
540 the index of that substatement in its [sized array](@ref sizedarrays) (if any) */
Michal Vasko3e9bc2f2020-11-04 17:13:56 +0100541 uint16_t flags; /**< LYS_INTERNAL value (@ref snodeflags) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200542};
543
544/**
545 * @brief YANG feature-stmt
546 */
547struct lysp_feature {
548 const char *name; /**< feature name (mandatory) */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100549 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
550 struct lysc_iffeature *iffeatures_c; /**< compiled if-features */
551 struct lysp_feature **depfeatures; /**< list of pointers to other features depending on this one
552 ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200553 const char *dsc; /**< description statement */
554 const char *ref; /**< reference statement */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200555 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100556 uint16_t flags; /**< [schema node flags](@ref snodeflags) - only LYS_STATUS_* values and
557 LYS_FENABLED are allowed */
558};
559
560/**
561 * @brief Compiled YANG if-feature-stmt
562 */
563struct lysc_iffeature {
564 uint8_t *expr; /**< 2bits array describing the if-feature expression in prefix format, see @ref ifftokens */
565 struct lysp_feature **features; /**< array of pointers to the features used in expression ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200566};
567
568/**
Michal Vasko7f45cf22020-10-01 12:49:44 +0200569 * @brief Qualified name (optional prefix followed by an identifier).
570 */
571struct lysp_qname {
572 const char *str; /**< qualified name string */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200573 const struct lysp_module *mod; /**< module to resolve any prefixes found in the string, it must be
Michal Vasko7f45cf22020-10-01 12:49:44 +0200574 stored explicitly because of deviations/refines */
575};
576
577/**
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200578 * @brief YANG identity-stmt
579 */
580struct lysp_ident {
581 const char *name; /**< identity name (mandatory), including possible prefix */
Michal Vasko7f45cf22020-10-01 12:49:44 +0200582 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
Radek Krejci151a5b72018-10-19 14:21:44 +0200583 const char **bases; /**< list of base identifiers ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200584 const char *dsc; /**< description statement */
585 const char *ref; /**< reference statement */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200586 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200587 uint16_t flags; /**< [schema node flags](@ref snodeflags) - only LYS_STATUS_ values are allowed */
588};
589
Michal Vasko71e64ca2018-09-07 16:30:29 +0200590/**
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200591 * @brief Covers restrictions: range, length, pattern, must
592 */
593struct lysp_restr {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100594#define LYSP_RESTR_PATTERN_ACK 0x06
595#define LYSP_RESTR_PATTERN_NACK 0x15
Michal Vasko7f45cf22020-10-01 12:49:44 +0200596 struct lysp_qname arg; /**< The restriction expression/value (mandatory);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200597 in case of pattern restriction, the first byte has a special meaning:
598 0x06 (ACK) for regular match and 0x15 (NACK) for invert-match */
599 const char *emsg; /**< error-message */
600 const char *eapptag; /**< error-app-tag value */
601 const char *dsc; /**< description */
602 const char *ref; /**< reference */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200603 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200604};
605
606/**
Michal Vasko71e64ca2018-09-07 16:30:29 +0200607 * @brief YANG revision-stmt
608 */
609struct lysp_revision {
Radek Krejcicb3e6472021-01-06 08:19:01 +0100610 char date[LY_REV_SIZE]; /**< revision date (madatory) */
Michal Vasko71e64ca2018-09-07 16:30:29 +0200611 const char *dsc; /**< description statement */
612 const char *ref; /**< reference statement */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200613 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Michal Vasko71e64ca2018-09-07 16:30:29 +0200614};
615
616/**
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200617 * @brief Enumeration/Bit value definition
618 */
619struct lysp_type_enum {
620 const char *name; /**< name (mandatory) */
621 const char *dsc; /**< description statement */
622 const char *ref; /**< reference statement */
Michal Vaskob55f6c12018-09-12 11:13:15 +0200623 int64_t value; /**< enum's value or bit's position */
Michal Vasko7f45cf22020-10-01 12:49:44 +0200624 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200625 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Michal Vaskob55f6c12018-09-12 11:13:15 +0200626 uint16_t flags; /**< [schema node flags](@ref snodeflags) - only LYS_STATUS_ and LYS_SET_VALUE
627 values are allowed */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200628};
629
630/**
631 * @brief YANG type-stmt
632 *
633 * Some of the items in the structure may be mandatory, but it is necessary to resolve the type's base type first
634 */
635struct lysp_type {
636 const char *name; /**< name of the type (mandatory) */
637 struct lysp_restr *range; /**< allowed values range - numerical, decimal64 */
638 struct lysp_restr *length; /**< allowed length of the value - string, binary */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200639 struct lysp_restr *patterns; /**< list of patterns ([sized array](@ref sizedarrays)) - string */
640 struct lysp_type_enum *enums; /**< list of enum-stmts ([sized array](@ref sizedarrays)) - enum */
641 struct lysp_type_enum *bits; /**< list of bit-stmts ([sized array](@ref sizedarrays)) - bits */
Michal Vasko004d3152020-06-11 19:59:22 +0200642 struct lyxp_expr *path; /**< parsed path - leafref */
Radek Krejci151a5b72018-10-19 14:21:44 +0200643 const char **bases; /**< list of base identifiers ([sized array](@ref sizedarrays)) - identityref */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200644 struct lysp_type *types; /**< list of sub-types ([sized array](@ref sizedarrays)) - union */
645 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200646
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200647 const struct lysp_module *pmod; /**< (sub)module where the type is defined (needed for deviations) */
Radek Krejci2167ee12018-11-02 16:09:07 +0100648 struct lysc_type *compiled; /**< pointer to the compiled type */
649
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200650 uint8_t fraction_digits; /**< number of fraction digits - decimal64 */
651 uint8_t require_instance; /**< require-instance flag - leafref, instance */
Radek Krejci4f28eda2018-11-12 11:46:16 +0100652 uint16_t flags; /**< [schema node flags](@ref spnodeflags) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200653};
654
655/**
656 * @brief YANG typedef-stmt
657 */
658struct lysp_tpdf {
659 const char *name; /**< name of the newly defined type (mandatory) */
660 const char *units; /**< units of the newly defined type */
Michal Vasko7f45cf22020-10-01 12:49:44 +0200661 struct lysp_qname dflt; /**< default value of the newly defined type, it may or may not be a qualified name */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200662 const char *dsc; /**< description statement */
663 const char *ref; /**< reference statement */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200664 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200665 struct lysp_type type; /**< base type from which the typedef is derived (mandatory) */
Radek Krejci4f28eda2018-11-12 11:46:16 +0100666 uint16_t flags; /**< [schema node flags](@ref spnodeflags) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200667};
668
669/**
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200670 * @brief YANG when-stmt
671 */
672struct lysp_when {
673 const char *cond; /**< specified condition (mandatory) */
674 const char *dsc; /**< description statement */
675 const char *ref; /**< reference statement */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200676 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200677};
678
679/**
680 * @brief YANG refine-stmt
681 */
682struct lysp_refine {
683 const char *nodeid; /**< target descendant schema nodeid (mandatory) */
684 const char *dsc; /**< description statement */
685 const char *ref; /**< reference statement */
Michal Vasko7f45cf22020-10-01 12:49:44 +0200686 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200687 struct lysp_restr *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200688 const char *presence; /**< presence description */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200689 struct lysp_qname *dflts; /**< list of default values ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200690 uint32_t min; /**< min-elements constraint */
691 uint32_t max; /**< max-elements constraint, 0 means unbounded */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200692 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200693 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
694};
695
696/**
Radek Krejci8678fa42020-08-18 16:07:28 +0200697 * @ingroup schematree
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200698 * @defgroup deviatetypes Deviate types
Radek Krejci8678fa42020-08-18 16:07:28 +0200699 *
700 * Type of the deviate operation (used as ::lysp_deviate.mod)
701 *
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200702 * @{
703 */
704#define LYS_DEV_NOT_SUPPORTED 1 /**< deviate type not-supported */
705#define LYS_DEV_ADD 2 /**< deviate type add */
706#define LYS_DEV_DELETE 3 /**< deviate type delete */
707#define LYS_DEV_REPLACE 4 /**< deviate type replace */
Radek Krejci2ff0d572020-05-21 15:27:28 +0200708/** @} deviatetypes */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200709
710/**
711 * @brief Generic deviate structure to get type and cast to lysp_deviate_* structure
712 */
713struct lysp_deviate {
714 uint8_t mod; /**< [type](@ref deviatetypes) of the deviate modification */
715 struct lysp_deviate *next; /**< next deviate structure in the list */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200716 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200717};
718
719struct lysp_deviate_add {
720 uint8_t mod; /**< [type](@ref deviatetypes) of the deviate modification */
721 struct lysp_deviate *next; /**< next deviate structure in the list */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200722 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Michal Vaskob55f6c12018-09-12 11:13:15 +0200723 const char *units; /**< units of the values */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200724 struct lysp_restr *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200725 struct lysp_qname *uniques; /**< list of uniques specifications ([sized array](@ref sizedarrays)) */
726 struct lysp_qname *dflts; /**< list of default values ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200727 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
728 uint32_t min; /**< min-elements constraint */
729 uint32_t max; /**< max-elements constraint, 0 means unbounded */
730};
731
732struct lysp_deviate_del {
733 uint8_t mod; /**< [type](@ref deviatetypes) of the deviate modification */
734 struct lysp_deviate *next; /**< next deviate structure in the list */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200735 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Michal Vaskob55f6c12018-09-12 11:13:15 +0200736 const char *units; /**< units of the values */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200737 struct lysp_restr *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200738 struct lysp_qname *uniques; /**< list of uniques specifications ([sized array](@ref sizedarrays)) */
739 struct lysp_qname *dflts; /**< list of default values ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200740};
741
742struct lysp_deviate_rpl {
743 uint8_t mod; /**< [type](@ref deviatetypes) of the deviate modification */
744 struct lysp_deviate *next; /**< next deviate structure in the list */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200745 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Michal Vaskob55f6c12018-09-12 11:13:15 +0200746 struct lysp_type *type; /**< type of the node */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200747 const char *units; /**< units of the values */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200748 struct lysp_qname dflt; /**< default value */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200749 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
750 uint32_t min; /**< min-elements constraint */
751 uint32_t max; /**< max-elements constraint, 0 means unbounded */
752};
753
754struct lysp_deviation {
Michal Vaskob55f6c12018-09-12 11:13:15 +0200755 const char *nodeid; /**< target absolute schema nodeid (mandatory) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200756 const char *dsc; /**< description statement */
757 const char *ref; /**< reference statement */
Michal Vasko22df3f02020-08-24 13:29:22 +0200758 struct lysp_deviate *deviates; /**< list of deviate specifications (linked list) */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200759 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200760};
761
Radek Krejci4f28eda2018-11-12 11:46:16 +0100762/**
Radek Krejci4f28eda2018-11-12 11:46:16 +0100763 * @ingroup snodeflags
Radek Krejci8678fa42020-08-18 16:07:28 +0200764 * @defgroup spnodeflags Parsed schema nodes flags
Radek Krejci4f28eda2018-11-12 11:46:16 +0100765 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200766 * Various flags for parsed schema nodes (used as ::lysp_node.flags).
Radek Krejci4f28eda2018-11-12 11:46:16 +0100767 *
768 * 1 - container 6 - anydata/anyxml 11 - output 16 - grouping 21 - enum
769 * 2 - choice 7 - case 12 - feature 17 - uses 22 - type
Radek Krejcid3ca0632019-04-16 16:54:54 +0200770 * 3 - leaf 8 - notification 13 - identity 18 - refine 23 - stmt
Radek Krejci4f28eda2018-11-12 11:46:16 +0100771 * 4 - leaflist 9 - rpc 14 - extension 19 - augment
772 * 5 - list 10 - input 15 - typedef 20 - deviate
773 *
Radek Krejcid3ca0632019-04-16 16:54:54 +0200774 * 1 1 1 1 1 1 1 1 1 1 2 2 2 2
775 * bit name 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
776 * ---------------------+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Michal Vasko5297a432020-08-31 12:27:51 +0200777 * 1 LYS_CONFIG_W |x|x|x|x|x|x| | | | | | | | | | | |x| |x| | | |
Radek Krejcid3ca0632019-04-16 16:54:54 +0200778 * LYS_SET_BASE | | | | | | | | | | | | | | | | | | | | | |x| |
779 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Michal Vasko5297a432020-08-31 12:27:51 +0200780 * 2 LYS_CONFIG_R |x|x|x|x|x|x| | | | | | | | | | | |x| |x| | | |
Radek Krejcid3ca0632019-04-16 16:54:54 +0200781 * LYS_SET_BIT | | | | | | | | | | | | | | | | | | | | | |x| |
782 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
783 * 3 LYS_STATUS_CURR |x|x|x|x|x|x|x|x|x| | |x|x|x|x|x|x| |x|x|x| | |
784 * LYS_SET_ENUM | | | | | | | | | | | | | | | | | | | | | |x| |
785 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
786 * 4 LYS_STATUS_DEPRC |x|x|x|x|x|x|x|x|x| | |x|x|x|x|x|x| |x|x|x| | |
787 * LYS_SET_FRDIGITS | | | | | | | | | | | | | | | | | | | | | |x| |
788 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
789 * 5 LYS_STATUS_OBSLT |x|x|x|x|x|x|x|x|x| | |x|x|x|x|x|x| |x|x|x| | |
790 * LYS_SET_LENGTH | | | | | | | | | | | | | | | | | | | | | |x| |
791 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
792 * 6 LYS_MAND_TRUE | |x|x| | |x| | | | | | | | | | | |x| |x| | | |
793 * LYS_SET_PATH | | | | | | | | | | | | | | | | | | | | | |x| |
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100794 * LYS_FENABLED | | | | | | | | | | | |x| | | | | | | | | | | |
Radek Krejcid3ca0632019-04-16 16:54:54 +0200795 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
796 * 7 LYS_MAND_FALSE | |x|x| | |x| | | | | | | | | | | |x| |x| | | |
797 * LYS_ORDBY_USER | | | |x|x| | | | | | | | | | | | | | | | | | |
798 * LYS_SET_PATTERN | | | | | | | | | | | | | | | | | | | | | |x| |
799 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
800 * 8 LYS_ORDBY_SYSTEM | | | |x|x| | | | | | | | | | | | | | | | | | |
801 * LYS_YINELEM_TRUE | | | | | | | | | | | | | |x| | | | | | | | | |
802 * LYS_SET_RANGE | | | | | | | | | | | | | | | | | | | | | |x| |
803 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
804 * 9 LYS_YINELEM_FALSE| | | | | | | | | | | | | |x| | | | | | | | | |
805 * LYS_SET_TYPE | | | | | | | | | | | | | | | | | | | | | |x| |
806 * LYS_SINGLEQUOTED | | | | | | | | | | | | | | | | | | | | | | |x|
807 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
808 * 10 LYS_SET_VALUE | | | | | | | | | | | | | | | | | | | | |x| | |
809 * LYS_SET_REQINST | | | | | | | | | | | | | | | | | | | | | |x| |
810 * LYS_SET_MIN | | | |x|x| | | | | | | | | | | | |x| |x| | | |
811 * LYS_DOUBLEQUOTED | | | | | | | | | | | | | | | | | | | | | | |x|
812 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
813 * 11 LYS_SET_MAX | | | |x|x| | | | | | | | | | | | |x| |x| | | |
Radek Krejcif2de0ed2019-05-02 14:13:18 +0200814 * LYS_USED_GRP | | | | | | | | | | | | | | | |x| | | | | | | |
David Sedlákae4b4512019-08-14 10:45:56 +0200815 * LYS_YIN_ATTR | | | | | | | | | | | | | | | | | | | | | | |x|
Michal Vasko5297a432020-08-31 12:27:51 +0200816 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
817 * 12 LYS_YIN_ARGUMENT | | | | | | | | | | | | | | | | | | | | | | |x|
Michal Vasko3e9bc2f2020-11-04 17:13:56 +0100818 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
819 * 13 LYS_INTERNAL |x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|
Radek Krejcif56e2a42019-09-09 14:15:25 +0200820 * ---------------------+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Radek Krejci4f28eda2018-11-12 11:46:16 +0100821 *
822 */
823
824/**
Radek Krejci4f28eda2018-11-12 11:46:16 +0100825 * @ingroup snodeflags
Radek Krejci8678fa42020-08-18 16:07:28 +0200826 * @defgroup scnodeflags Compiled schema nodes flags
Radek Krejci4f28eda2018-11-12 11:46:16 +0100827 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200828 * Various flags for compiled schema nodes (used as ::lysc_node.flags).
Radek Krejci4f28eda2018-11-12 11:46:16 +0100829 *
Radek Krejci61e042e2019-09-10 15:53:09 +0200830 * 1 - container 6 - anydata/anyxml 11 - identity
831 * 2 - choice 7 - case 12 - extension
832 * 3 - leaf 8 - notification 13 - bitenum
Michal Vasko03ff5a72019-09-11 13:49:33 +0200833 * 4 - leaflist 9 - rpc/action 14 - when
Michal Vaskoecd62de2019-11-13 12:35:11 +0100834 * 5 - list 10 - feature
Radek Krejci4f28eda2018-11-12 11:46:16 +0100835 *
Michal Vaskoecd62de2019-11-13 12:35:11 +0100836 * 1 1 1 1 1
837 * bit name 1 2 3 4 5 6 7 8 9 0 1 2 3 4
838 * ---------------------+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Michal Vaskod09b7622021-01-26 09:14:13 +0100839 * 1 LYS_CONFIG_W |x|x|x|x|x|x|x| | | | | | | |
Michal Vaskoecd62de2019-11-13 12:35:11 +0100840 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Michal Vaskod09b7622021-01-26 09:14:13 +0100841 * 2 LYS_CONFIG_R |x|x|x|x|x|x|x| | | | | | | |
Michal Vaskoecd62de2019-11-13 12:35:11 +0100842 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
843 * 3 LYS_STATUS_CURR |x|x|x|x|x|x|x|x|x|x|x|x| |x|
844 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
845 * 4 LYS_STATUS_DEPRC |x|x|x|x|x|x|x|x|x|x|x|x| |x|
846 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
847 * 5 LYS_STATUS_OBSLT |x|x|x|x|x|x|x|x|x|x|x|x| |x|
848 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
849 * 6 LYS_MAND_TRUE |x|x|x|x|x|x| | | | | | | | |
850 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
851 * 7 LYS_ORDBY_USER | | | |x|x| | | | | | | | | |
852 * LYS_MAND_FALSE | |x|x| | |x| | | | | | | | |
853 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
854 * 8 LYS_ORDBY_SYSTEM | | | |x|x| | | | | | | | | |
855 * LYS_PRESENCE |x| | | | | | | | | | | | | |
856 * LYS_UNIQUE | | |x| | | | | | | | | | | |
857 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
858 * 9 LYS_KEY | | |x| | | | | | | | | | | |
Michal Vaskoecd62de2019-11-13 12:35:11 +0100859 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
860 * 10 LYS_SET_DFLT | | |x|x| | |x| | | | | | | |
Michal Vaskod1e53b92021-01-28 13:11:06 +0100861 * LYS_IS_ENUM | | | | | | | | | | | | |x| |
Michal Vaskoecd62de2019-11-13 12:35:11 +0100862 * LYS_KEYLESS | | | | |x| | | | | | | | | |
863 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
864 * 11 LYS_SET_UNITS | | |x|x| | | | | | | | | | |
865 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
866 * 12 LYS_SET_CONFIG |x|x|x|x|x|x| | | | | | | | |
Michal Vaskod1e53b92021-01-28 13:11:06 +0100867 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
868 * 13 LYS_IS_INPUT |x|x|x|x|x|x|x| | | | | | | |
869 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
870 * 14 LYS_IS_OUTPUT |x|x|x|x|x|x|x| | | | | | | |
871 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+
872 * 15 LYS_IS_NOTIF |x|x|x|x|x|x|x| | | | | | | |
Michal Vaskoecd62de2019-11-13 12:35:11 +0100873 * ---------------------+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Radek Krejci4f28eda2018-11-12 11:46:16 +0100874 *
875 */
876
877/**
878 * @defgroup snodeflags Schema nodes flags
Radek Krejci8678fa42020-08-18 16:07:28 +0200879 *
880 * Various flags for schema nodes ([parsed](@ref spnodeflags) as well as [compiled](@ref scnodeflags)).
881 *
Radek Krejci4f28eda2018-11-12 11:46:16 +0100882 * @{
883 */
Michal Vaskod1e53b92021-01-28 13:11:06 +0100884#define LYS_CONFIG_W 0x01 /**< config true; */
885#define LYS_CONFIG_R 0x02 /**< config false; */
Michal Vaskob55f6c12018-09-12 11:13:15 +0200886#define LYS_CONFIG_MASK 0x03 /**< mask for config value */
Radek Krejci4f28eda2018-11-12 11:46:16 +0100887#define LYS_STATUS_CURR 0x04 /**< status current; */
888#define LYS_STATUS_DEPRC 0x08 /**< status deprecated; */
889#define LYS_STATUS_OBSLT 0x10 /**< status obsolete; */
890#define LYS_STATUS_MASK 0x1C /**< mask for status value */
891#define LYS_MAND_TRUE 0x20 /**< mandatory true; applicable only to ::lysp_node_choice/::lysc_node_choice,
Radek Krejcife909632019-02-12 15:34:42 +0100892 ::lysp_node_leaf/::lysc_node_leaf and ::lysp_node_anydata/::lysc_node_anydata.
893 The ::lysc_node_leaflist and ::lysc_node_leaflist have this flag in case that min-elements > 0.
894 The ::lysc_node_container has this flag if it is not a presence container and it has at least one
895 child with LYS_MAND_TRUE. */
Radek Krejcif1421c22019-02-19 13:05:20 +0100896#define LYS_MAND_FALSE 0x40 /**< mandatory false; applicable only to ::lysp_node_choice/::lysc_node_choice,
897 ::lysp_node_leaf/::lysc_node_leaf and ::lysp_node_anydata/::lysc_node_anydata.
898 This flag is present only in case the mandatory false statement was explicitly specified. */
Radek Krejci4f28eda2018-11-12 11:46:16 +0100899#define LYS_MAND_MASK 0x60 /**< mask for mandatory values */
Michal Vaskoc118ae22020-08-06 14:51:09 +0200900#define LYS_PRESENCE 0x80 /**< flag for presence property of a container, but it is not only for explicit presence
901 containers, but also for NP containers with some meaning, applicable only to
902 ::lysc_node_container */
Radek Krejci7adf4ff2018-12-05 08:55:00 +0100903#define LYS_UNIQUE 0x80 /**< flag for leafs being part of a unique set, applicable only to ::lysc_node_leaf */
Michal Vaskod1e53b92021-01-28 13:11:06 +0100904#define LYS_KEY 0x0100 /**< flag for leafs being a key of a list, applicable only to ::lysc_node_leaf */
905#define LYS_KEYLESS 0x0200 /**< flag for list without any key, applicable only to ::lysc_node_list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100906#define LYS_FENABLED 0x20 /**< feature enabled flag, applicable only to ::lysp_feature. */
Michal Vaskoe78faec2021-04-08 17:24:43 +0200907#define LYS_ORDBY_SYSTEM 0x80 /**< ordered-by system configuration lists, applicable only to
908 ::lysc_node_leaflist/::lysp_node_leaflist and ::lysc_node_list/::lysp_node_list */
909#define LYS_ORDBY_USER 0x40 /**< ordered-by user configuration lists, applicable only to
910 ::lysc_node_leaflist/::lysp_node_leaflist and ::lysc_node_list/::lysp_node_list;
911 is always set for state leaf-lists, and key-less lists */
Radek Krejci4f28eda2018-11-12 11:46:16 +0100912#define LYS_ORDBY_MASK 0x60 /**< mask for ordered-by values */
913#define LYS_YINELEM_TRUE 0x80 /**< yin-element true for extension's argument */
Michal Vaskod1e53b92021-01-28 13:11:06 +0100914#define LYS_YINELEM_FALSE 0x0100 /**< yin-element false for extension's argument */
915#define LYS_YINELEM_MASK 0x0180 /**< mask for yin-element value */
916#define LYS_USED_GRP 0x0400 /**< internal flag for validating not-instantiated groupings
Radek Krejcif2de0ed2019-05-02 14:13:18 +0200917 (resp. do not validate again the instantiated groupings). */
Michal Vaskod1e53b92021-01-28 13:11:06 +0100918#define LYS_SET_VALUE 0x0200 /**< value attribute is set */
919#define LYS_SET_MIN 0x0200 /**< min attribute is set */
920#define LYS_SET_MAX 0x0400 /**< max attribute is set */
Radek Krejcid505e3d2018-11-13 09:04:17 +0100921
922#define LYS_SET_BASE 0x0001 /**< type's flag for present base substatement */
923#define LYS_SET_BIT 0x0002 /**< type's flag for present bit substatement */
924#define LYS_SET_ENUM 0x0004 /**< type's flag for present enum substatement */
925#define LYS_SET_FRDIGITS 0x0008 /**< type's flag for present fraction-digits substatement */
926#define LYS_SET_LENGTH 0x0010 /**< type's flag for present length substatement */
927#define LYS_SET_PATH 0x0020 /**< type's flag for present path substatement */
928#define LYS_SET_PATTERN 0x0040 /**< type's flag for present pattern substatement */
929#define LYS_SET_RANGE 0x0080 /**< type's flag for present range substatement */
930#define LYS_SET_TYPE 0x0100 /**< type's flag for present type substatement */
931#define LYS_SET_REQINST 0x0200 /**< type's flag for present require-instance substatement */
Radek Krejciccd20f12019-02-15 14:12:27 +0100932#define LYS_SET_DFLT 0x0200 /**< flag to mark leaf/leaflist with own (or refined) default value, not a default value taken from its type, and default
Radek Krejci76b3e962018-12-14 17:01:25 +0100933 cases of choice. This information is important for refines, since it is prohibited to make leafs
934 with default statement mandatory. In case the default leaf value is taken from type, it is thrown
Radek Krejciccd20f12019-02-15 14:12:27 +0100935 away when it is refined to be mandatory node. Similarly it is used for deviations to distinguish
936 between own default or the default values taken from the type. */
937#define LYS_SET_UNITS 0x0400 /**< flag to know if the leaf's/leaflist's units are their own (flag set) or it is taken from the type. */
Radek Krejcif1421c22019-02-19 13:05:20 +0100938#define LYS_SET_CONFIG 0x0800 /**< flag to know if the config property was set explicitly (flag set) or it is inherited. */
Radek Krejci0e5d8382018-11-28 16:37:53 +0100939
Michal Vaskod1e53b92021-01-28 13:11:06 +0100940#define LYS_SINGLEQUOTED 0x0100 /**< flag for single-quoted argument of an extension instance's substatement, only when the source is YANG */
941#define LYS_DOUBLEQUOTED 0x0200 /**< flag for double-quoted argument of an extension instance's substatement, only when the source is YANG */
Radek Krejcid3ca0632019-04-16 16:54:54 +0200942
Michal Vaskod1e53b92021-01-28 13:11:06 +0100943#define LYS_YIN_ATTR 0x0400 /**< flag to identify YIN attribute parsed as extension's substatement, only when the source is YIN */
944#define LYS_YIN_ARGUMENT 0x0800 /**< flag to identify statement representing extension's argument, only when the source is YIN */
David Sedlákbbd06ca2019-06-27 14:15:38 +0200945
Michal Vasko3e9bc2f2020-11-04 17:13:56 +0100946#define LYS_INTERNAL 0x1000 /**< flag to identify internal parsed statements that should not be printed */
947
Michal Vaskod1e53b92021-01-28 13:11:06 +0100948#define LYS_IS_ENUM 0x0200 /**< flag to simply distinguish type in struct lysc_type_bitenum_item */
949
950#define LYS_IS_INPUT 0x1000 /**< flag for nodes that are in the subtree of an input statement */
951
952#define LYS_IS_OUTPUT 0x2000 /**< flag for nodes that are in the subtree of an output statement */
953
954#define LYS_IS_NOTIF 0x4000 /**< flag for nodes that are in the subtree of a notification statement */
Radek Krejci693262f2019-04-29 15:23:20 +0200955
Radek Krejcife909632019-02-12 15:34:42 +0100956#define LYS_FLAGS_COMPILED_MASK 0xff /**< mask for flags that maps to the compiled structures */
Radek Krejci2ff0d572020-05-21 15:27:28 +0200957/** @} snodeflags */
Michal Vaskob55f6c12018-09-12 11:13:15 +0200958
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200959/**
960 * @brief Generic YANG data node
961 */
962struct lysp_node {
Radek Krejci6d9b9b52018-11-02 12:43:39 +0100963 struct lysp_node *parent; /**< parent node (NULL if this is a top-level node) */
Radek Krejcide7a9c42021-03-10 13:13:06 +0100964 uint16_t nodetype; /**< [type of the node](@ref schemanodetypes) (mandatory) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200965 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
Radek Krejci6d9b9b52018-11-02 12:43:39 +0100966 struct lysp_node *next; /**< next sibling node (NULL if there is no one) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200967 const char *name; /**< node name (mandatory) */
968 const char *dsc; /**< description statement */
969 const char *ref; /**< reference statement */
Michal Vasko7f45cf22020-10-01 12:49:44 +0200970 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)),
971 must be qname because of refines */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200972 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200973};
974
975/**
976 * @brief Extension structure of the lysp_node for YANG container
977 */
978struct lysp_node_container {
Radek Krejci2a9fc652021-01-22 17:44:34 +0100979 union {
980 struct lysp_node node; /**< implicit cast for the members compatible with ::lysp_node */
981 struct {
982 struct lysp_node *parent; /**< parent node (NULL if this is a top-level node) */
983 uint16_t nodetype; /**< LYS_CONTAINER */
984 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
985 struct lysp_node *next; /**< pointer to the next sibling node (NULL if there is no one) */
986 const char *name; /**< node name (mandatory) */
987 const char *dsc; /**< description statement */
988 const char *ref; /**< reference statement */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100989 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
990 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
991 };
992 }; /**< common part corresponding to ::lysp_node */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200993
994 /* container */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200995 struct lysp_restr *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Radek Krejci9a3823e2021-01-27 20:26:46 +0100996 struct lysp_when *when; /**< when statement */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200997 const char *presence; /**< presence description */
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200998 struct lysp_tpdf *typedefs; /**< list of typedefs ([sized array](@ref sizedarrays)) */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100999 struct lysp_node_grp *groupings; /**< list of groupings (linked list) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001000 struct lysp_node *child; /**< list of data nodes (linked list) */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001001 struct lysp_node_action *actions;/**< list of actions (linked list) */
1002 struct lysp_node_notif *notifs; /**< list of notifications (linked list) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001003};
1004
1005struct lysp_node_leaf {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001006 union {
1007 struct lysp_node node; /**< implicit cast for the members compatible with ::lysp_node */
1008 struct {
1009 struct lysp_node *parent; /**< parent node (NULL if this is a top-level node) */
1010 uint16_t nodetype; /**< LYS_LEAF */
1011 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1012 struct lysp_node *next; /**< pointer to the next sibling node (NULL if there is no one) */
1013 const char *name; /**< node name (mandatory) */
1014 const char *dsc; /**< description statement */
1015 const char *ref; /**< reference statement */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001016 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
1017 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1018 };
1019 }; /**< common part corresponding to ::lysp_node */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001020
1021 /* leaf */
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001022 struct lysp_restr *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001023 struct lysp_when *when; /**< when statement */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001024 struct lysp_type type; /**< type of the leaf node (mandatory) */
1025 const char *units; /**< units of the leaf's type */
Michal Vasko7f45cf22020-10-01 12:49:44 +02001026 struct lysp_qname dflt; /**< default value, it may or may not be a qualified name */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001027};
1028
1029struct lysp_node_leaflist {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001030 union {
1031 struct lysp_node node; /**< implicit cast for the members compatible with ::lysp_node */
1032 struct {
1033 struct lysp_node *parent; /**< parent node (NULL if this is a top-level node) */
1034 uint16_t nodetype; /**< LYS_LEAFLIST */
1035 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1036 struct lysp_node *next; /**< pointer to the next sibling node (NULL if there is no one) */
1037 const char *name; /**< node name (mandatory) */
1038 const char *dsc; /**< description statement */
1039 const char *ref; /**< reference statement */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001040 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
1041 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1042 };
1043 }; /**< common part corresponding to ::lysp_node */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001044
1045 /* leaf-list */
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001046 struct lysp_restr *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001047 struct lysp_when *when; /**< when statement */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001048 struct lysp_type type; /**< type of the leaf node (mandatory) */
1049 const char *units; /**< units of the leaf's type */
Michal Vasko7f45cf22020-10-01 12:49:44 +02001050 struct lysp_qname *dflts; /**< list of default values ([sized array](@ref sizedarrays)), they may or
1051 may not be qualified names */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001052 uint32_t min; /**< min-elements constraint */
1053 uint32_t max; /**< max-elements constraint, 0 means unbounded */
1054};
1055
1056struct lysp_node_list {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001057 union {
1058 struct lysp_node node; /**< implicit cast for the members compatible with ::lysp_node */
1059 struct {
1060 struct lysp_node *parent; /**< parent node (NULL if this is a top-level node) */
1061 uint16_t nodetype; /**< LYS_LIST */
1062 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1063 struct lysp_node *next; /**< pointer to the next sibling node (NULL if there is no one) */
1064 const char *name; /**< node name (mandatory) */
1065 const char *dsc; /**< description statement */
1066 const char *ref; /**< reference statement */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001067 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
1068 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1069 };
1070 }; /**< common part corresponding to ::lysp_node */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001071
1072 /* list */
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001073 struct lysp_restr *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001074 struct lysp_when *when; /**< when statement */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001075 const char *key; /**< keys specification */
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001076 struct lysp_tpdf *typedefs; /**< list of typedefs ([sized array](@ref sizedarrays)) */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001077 struct lysp_node_grp *groupings; /**< list of groupings (linked list) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001078 struct lysp_node *child; /**< list of data nodes (linked list) */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001079 struct lysp_node_action *actions;/**< list of actions (linked list) */
1080 struct lysp_node_notif *notifs; /**< list of notifications (linked list) */
Michal Vasko7f45cf22020-10-01 12:49:44 +02001081 struct lysp_qname *uniques; /**< list of unique specifications ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001082 uint32_t min; /**< min-elements constraint */
1083 uint32_t max; /**< max-elements constraint, 0 means unbounded */
1084};
1085
1086struct lysp_node_choice {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001087 union {
1088 struct lysp_node node; /**< implicit cast for the members compatible with ::lysp_node */
1089 struct {
1090 struct lysp_node *parent; /**< parent node (NULL if this is a top-level node) */
1091 uint16_t nodetype; /**< LYS_CHOICE */
1092 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1093 struct lysp_node *next; /**< pointer to the next sibling node (NULL if there is no one) */
1094 const char *name; /**< node name (mandatory) */
1095 const char *dsc; /**< description statement */
1096 const char *ref; /**< reference statement */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001097 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
1098 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1099 };
1100 }; /**< common part corresponding to ::lysp_node */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001101
1102 /* choice */
1103 struct lysp_node *child; /**< list of data nodes (linked list) */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001104 struct lysp_when *when; /**< when statement */
Michal Vasko7f45cf22020-10-01 12:49:44 +02001105 struct lysp_qname dflt; /**< default case */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001106};
1107
1108struct lysp_node_case {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001109 union {
1110 struct lysp_node node; /**< implicit cast for the members compatible with ::lysp_node */
1111 struct {
1112 struct lysp_node *parent; /**< parent node (NULL if this is a top-level node) */
1113 uint16_t nodetype; /**< LYS_CASE */
1114 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1115 struct lysp_node *next; /**< pointer to the next sibling node (NULL if there is no one) */
1116 const char *name; /**< node name (mandatory) */
1117 const char *dsc; /**< description statement */
1118 const char *ref; /**< reference statement */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001119 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
1120 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1121 };
1122 }; /**< common part corresponding to ::lysp_node */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001123
1124 /* case */
1125 struct lysp_node *child; /**< list of data nodes (linked list) */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001126 struct lysp_when *when; /**< when statement */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001127};
1128
1129struct lysp_node_anydata {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001130 union {
1131 struct lysp_node node; /**< implicit cast for the members compatible with ::lysp_node */
1132 struct {
1133 struct lysp_node *parent; /**< parent node (NULL if this is a top-level node) */
1134 uint16_t nodetype; /**< LYS_ANYXML or LYS_ANYDATA */
1135 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1136 struct lysp_node *next; /**< pointer to the next sibling node (NULL if there is no one) */
1137 const char *name; /**< node name (mandatory) */
1138 const char *dsc; /**< description statement */
1139 const char *ref; /**< reference statement */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001140 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
1141 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1142 };
1143 }; /**< common part corresponding to ::lysp_node */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001144
1145 /* anyxml/anydata */
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001146 struct lysp_restr *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001147 struct lysp_when *when; /**< when statement */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001148};
1149
1150struct lysp_node_uses {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001151 union {
1152 struct lysp_node node; /**< implicit cast for the members compatible with ::lysp_node */
1153 struct {
1154 struct lysp_node *parent; /**< parent node (NULL if this is a top-level node) */
1155 uint16_t nodetype; /**< LYS_USES */
1156 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1157 struct lysp_node *next; /**< pointer to the next sibling node (NULL if there is no one) */
1158 const char *name; /**< grouping name reference (mandatory) */
1159 const char *dsc; /**< description statement */
1160 const char *ref; /**< reference statement */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001161 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
1162 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1163 };
1164 }; /**< common part corresponding to ::lysp_node */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001165
1166 /* uses */
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001167 struct lysp_refine *refines; /**< list of uses's refines ([sized array](@ref sizedarrays)) */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001168 struct lysp_node_augment *augments; /**< list of augments (linked list) */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001169 struct lysp_when *when; /**< when statement */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001170};
1171
1172/**
1173 * @brief YANG input-stmt and output-stmt
1174 */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001175struct lysp_node_action_inout {
1176 union {
1177 struct lysp_node node; /**< implicit cast for the members compatible with ::lysp_node */
1178 struct {
1179 struct lysp_node *parent; /**< parent node (NULL if this is a top-level node) */
1180 uint16_t nodetype; /**< LYS_INPUT or LYS_OUTPUT */
1181 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1182 struct lysp_node *next; /**< NULL */
1183 const char *name; /**< empty string */
1184 const char *dsc; /**< ALWAYS NULL, compatibility member with ::lysp_node */
1185 const char *ref; /**< ALWAYS NULL, compatibility member with ::lysp_node */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001186 struct lysp_qname *iffeatures; /**< ALWAYS NULL, compatibility member with ::lysp_node */
1187 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1188 };
1189 }; /**< common part corresponding to ::lysp_node */
1190
1191 /* inout */
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001192 struct lysp_restr *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
1193 struct lysp_tpdf *typedefs; /**< list of typedefs ([sized array](@ref sizedarrays)) */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001194 struct lysp_node_grp *groupings; /**< list of groupings (linked list) */
Radek Krejci01180ac2021-01-27 08:48:22 +01001195 struct lysp_node *child; /**< list of data nodes (linked list) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001196};
1197
1198/**
1199 * @brief YANG rpc-stmt and action-stmt
1200 */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001201struct lysp_node_action {
1202 union {
1203 struct lysp_node node; /**< implicit cast for the members compatible with ::lysp_node */
1204 struct {
1205 struct lysp_node *parent; /**< parent node (NULL if this is a top-level node) */
1206 uint16_t nodetype; /**< LYS_RPC or LYS_ACTION */
1207 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1208 struct lysp_node_action *next; /**< pointer to the next action (NULL if there is no one) */
1209 const char *name; /**< grouping name reference (mandatory) */
1210 const char *dsc; /**< description statement */
1211 const char *ref; /**< reference statement */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001212 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
1213 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1214 };
1215 }; /**< common part corresponding to ::lysp_node */
Michal Vasko7f45cf22020-10-01 12:49:44 +02001216
1217 /* action */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001218 struct lysp_tpdf *typedefs; /**< list of typedefs ([sized array](@ref sizedarrays)) */
1219 struct lysp_node_grp *groupings; /**< list of groupings (linked list) */
1220
1221 struct lysp_node_action_inout input; /**< RPC's/Action's input */
1222 struct lysp_node_action_inout output; /**< RPC's/Action's output */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001223};
1224
1225/**
1226 * @brief YANG notification-stmt
1227 */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001228struct lysp_node_notif {
1229 union {
1230 struct lysp_node node; /**< implicit cast for the members compatible with ::lysp_node */
1231 struct {
1232 struct lysp_node *parent; /**< parent node (NULL if this is a top-level node) */
1233 uint16_t nodetype; /**< LYS_NOTIF */
1234 uint16_t flags; /**< [schema node flags](@ref snodeflags) - only LYS_STATUS_* values are allowed */
1235 struct lysp_node_notif *next; /**< pointer to the next notification (NULL if there is no one) */
1236 const char *name; /**< grouping name reference (mandatory) */
1237 const char *dsc; /**< description statement */
1238 const char *ref; /**< reference statement */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001239 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
1240 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1241 };
1242 }; /**< common part corresponding to ::lysp_node */
Michal Vasko7f45cf22020-10-01 12:49:44 +02001243
1244 /* notif */
1245 struct lysp_restr *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001246 struct lysp_tpdf *typedefs; /**< list of typedefs ([sized array](@ref sizedarrays)) */
1247 struct lysp_node_grp *groupings; /**< list of groupings (linked list) */
Radek Krejci01180ac2021-01-27 08:48:22 +01001248 struct lysp_node *child; /**< list of data nodes (linked list) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001249};
1250
1251/**
Radek Krejci2a9fc652021-01-22 17:44:34 +01001252 * @brief YANG grouping-stmt
1253 */
1254struct lysp_node_grp {
1255 union {
1256 struct lysp_node node; /**< implicit cast for the members compatible with ::lysp_node */
1257 struct {
1258 struct lysp_node *parent;/**< parent node (NULL if this is a top-level grouping) */
1259 uint16_t nodetype; /**< LYS_GROUPING */
1260 uint16_t flags; /**< [schema node flags](@ref snodeflags) - only LYS_STATUS_* values are allowed */
1261 struct lysp_node_grp *next; /**< pointer to the next grouping (NULL if there is no one) */
1262 const char *name; /**< grouping name (mandatory) */
1263 const char *dsc; /**< description statement */
1264 const char *ref; /**< reference statement */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001265 struct lysp_qname *iffeatures; /**< ALWAYS NULL, compatibility member with ::lysp_node */
1266 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1267 };
1268 }; /**< common part corresponding to ::lysp_node */
1269
1270 /* grp */
1271 struct lysp_tpdf *typedefs; /**< list of typedefs ([sized array](@ref sizedarrays)) */
1272 struct lysp_node_grp *groupings; /**< list of groupings (linked list) */
Radek Krejci01180ac2021-01-27 08:48:22 +01001273 struct lysp_node *child; /**< list of data nodes (linked list) */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001274 struct lysp_node_action *actions; /**< list of actions (linked list) */
1275 struct lysp_node_notif *notifs; /**< list of notifications (linked list) */
1276};
1277
1278/**
1279 * @brief YANG uses-augment-stmt and augment-stmt (compatible with struct lysp_node )
1280 */
1281struct lysp_node_augment {
1282 union {
1283 struct lysp_node node; /**< implicit cast for the members compatible with ::lysp_node */
1284 struct {
1285 struct lysp_node *parent;/**< parent node (NULL if this is a top-level augment) */
1286 uint16_t nodetype; /**< LYS_AUGMENT */
1287 uint16_t flags; /**< [schema node flags](@ref snodeflags) - only LYS_STATUS_* values are allowed */
1288 struct lysp_node_augment *next; /**< pointer to the next augment (NULL if there is no one) */
1289 const char *nodeid; /**< target schema nodeid (mandatory) - absolute for global augments, descendant for uses's augments */
1290 const char *dsc; /**< description statement */
1291 const char *ref; /**< reference statement */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001292 struct lysp_qname *iffeatures; /**< list of if-feature expressions ([sized array](@ref sizedarrays)) */
1293 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1294 };
1295 }; /**< common part corresponding to ::lysp_node */
1296
1297 struct lysp_node *child; /**< list of data nodes (linked list) */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001298 struct lysp_when *when; /**< when statement */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001299 struct lysp_node_action *actions;/**< list of actions (linked list) */
1300 struct lysp_node_notif *notifs; /**< list of notifications (linked list) */
1301};
1302
1303/**
Radek Krejcif0fceb62018-09-05 14:58:45 +02001304 * @brief supported YANG schema version values
1305 */
1306typedef enum LYS_VERSION {
1307 LYS_VERSION_UNDEF = 0, /**< no specific version, YANG 1.0 as default */
Radek Krejci96e48da2020-09-04 13:18:06 +02001308 LYS_VERSION_1_0 = 1, /**< YANG 1 (1.0) */
Radek Krejcif0fceb62018-09-05 14:58:45 +02001309 LYS_VERSION_1_1 = 2 /**< YANG 1.1 */
1310} LYS_VERSION;
1311
1312/**
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001313 * @brief Printable YANG schema tree structure representing YANG module.
1314 *
1315 * Simple structure corresponding to the YANG format. The schema is only syntactically validated.
1316 */
1317struct lysp_module {
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001318 struct lys_module *mod; /**< covering module structure */
1319
Radek Krejcib7db73a2018-10-24 14:18:40 +02001320 struct lysp_revision *revs; /**< list of the module revisions ([sized array](@ref sizedarrays)), the first revision
1321 in the list is always the last (newest) revision of the module */
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001322 struct lysp_import *imports; /**< list of imported modules ([sized array](@ref sizedarrays)) */
1323 struct lysp_include *includes; /**< list of included submodules ([sized array](@ref sizedarrays)) */
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001324 struct lysp_ext *extensions; /**< list of extension statements ([sized array](@ref sizedarrays)) */
1325 struct lysp_feature *features; /**< list of feature definitions ([sized array](@ref sizedarrays)) */
1326 struct lysp_ident *identities; /**< list of identities ([sized array](@ref sizedarrays)) */
1327 struct lysp_tpdf *typedefs; /**< list of typedefs ([sized array](@ref sizedarrays)) */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001328 struct lysp_node_grp *groupings; /**< list of groupings (linked list) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001329 struct lysp_node *data; /**< list of module's top-level data nodes (linked list) */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001330 struct lysp_node_augment *augments; /**< list of augments (linked list) */
1331 struct lysp_node_action *rpcs; /**< list of RPCs (linked list) */
1332 struct lysp_node_notif *notifs; /**< list of notifications (linked list) */
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001333 struct lysp_deviation *deviations; /**< list of deviations ([sized array](@ref sizedarrays)) */
Michal Vaskoc3781c32020-10-06 14:04:08 +02001334 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001335
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001336 uint8_t version; /**< yang-version (LYS_VERSION values) */
Michal Vaskoc3781c32020-10-06 14:04:08 +02001337 uint8_t parsing : 1; /**< flag for circular check */
1338 uint8_t is_submod : 1; /**< always 0 */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001339};
1340
1341struct lysp_submodule {
Michal Vaskoc3781c32020-10-06 14:04:08 +02001342 struct lys_module *mod; /**< belongs to parent module (submodule - mandatory) */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001343
1344 struct lysp_revision *revs; /**< list of the module revisions ([sized array](@ref sizedarrays)), the first revision
1345 in the list is always the last (newest) revision of the module */
1346 struct lysp_import *imports; /**< list of imported modules ([sized array](@ref sizedarrays)) */
1347 struct lysp_include *includes; /**< list of included submodules ([sized array](@ref sizedarrays)) */
1348 struct lysp_ext *extensions; /**< list of extension statements ([sized array](@ref sizedarrays)) */
1349 struct lysp_feature *features; /**< list of feature definitions ([sized array](@ref sizedarrays)) */
1350 struct lysp_ident *identities; /**< list of identities ([sized array](@ref sizedarrays)) */
1351 struct lysp_tpdf *typedefs; /**< list of typedefs ([sized array](@ref sizedarrays)) */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001352 struct lysp_node_grp *groupings; /**< list of groupings (linked list) */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001353 struct lysp_node *data; /**< list of module's top-level data nodes (linked list) */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001354 struct lysp_node_augment *augments; /**< list of augments (linked list) */
1355 struct lysp_node_action *rpcs; /**< list of RPCs (linked list) */
1356 struct lysp_node_notif *notifs; /**< list of notifications (linked list) */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001357 struct lysp_deviation *deviations; /**< list of deviations ([sized array](@ref sizedarrays)) */
Michal Vaskoc3781c32020-10-06 14:04:08 +02001358 struct lysp_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001359
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001360 uint8_t version; /**< yang-version (LYS_VERSION values) */
Michal Vaskoc3781c32020-10-06 14:04:08 +02001361 uint8_t parsing : 1; /**< flag for circular check */
1362 uint8_t is_submod : 1; /**< always 1 */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001363
Michal Vaskoc3781c32020-10-06 14:04:08 +02001364 uint8_t latest_revision : 2; /**< flag to mark the latest available revision:
Radek Krejci086c7132018-10-26 15:29:04 +02001365 1 - the latest revision in searchdirs was not searched yet and this is the
1366 latest revision in the current context
1367 2 - searchdirs were searched and this is the latest available revision */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001368 const char *name; /**< name of the module (mandatory) */
1369 const char *filepath; /**< path, if the schema was read from a file, NULL in case of reading from memory */
1370 const char *prefix; /**< submodule belongsto prefix of main module (mandatory) */
1371 const char *org; /**< party/company responsible for the module */
1372 const char *contact; /**< contact information for the module */
1373 const char *dsc; /**< description of the module */
1374 const char *ref; /**< cross-reference for the module */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001375};
1376
1377/**
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001378 * @brief Get the parsed module or submodule name.
1379 *
1380 * @param[in] PMOD Parsed module or submodule.
1381 * @return Module or submodule name.
1382 */
1383#define LYSP_MODULE_NAME(PMOD) (PMOD->is_submod ? ((struct lysp_submodule *)PMOD)->name : ((struct lysp_module *)PMOD)->mod->name)
1384
1385/**
Radek Krejci8df109d2021-04-23 12:19:08 +02001386 * @brief Compiled prefix data pair mapping of prefixes to modules. In case the format is ::LY_VALUE_SCHEMA_RESOLVED,
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001387 * the expected prefix data is a sized array of these structures.
1388 */
1389struct lysc_prefix {
1390 char *prefix; /**< used prefix */
1391 const struct lys_module *mod; /**< mapping to a module */
1392};
1393
1394/**
Radek Krejci0e59c312019-08-15 15:34:15 +02001395 * @brief Compiled YANG extension-stmt
Radek Krejci9f87b0c2021-03-05 14:45:26 +01001396 *
1397 * Note that the compiled extension definition is created only in case the extension is instantiated. It is not available
1398 * from the compiled schema, but from the parsed extension definition which is being searched when an extension instance
1399 * is being compiled.
Radek Krejci0e59c312019-08-15 15:34:15 +02001400 */
1401struct lysc_ext {
1402 const char *name; /**< extension name */
Radek Krejci9f87b0c2021-03-05 14:45:26 +01001403 const char *argname; /**< argument name, NULL if not specified */
Radek Krejci0e59c312019-08-15 15:34:15 +02001404 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejcicc9e30f2021-03-29 12:45:08 +02001405 struct lyplg_ext *plugin; /**< Plugin implementing the specific extension */
Radek Krejci0935f412019-08-20 16:15:18 +02001406 struct lys_module *module; /**< module structure */
Michal Vasko6f4cbb62020-02-28 11:15:47 +01001407 uint32_t refcount; /**< reference counter since extension definition is shared among all its instances */
Radek Krejci0e59c312019-08-15 15:34:15 +02001408 uint16_t flags; /**< LYS_STATUS_* value (@ref snodeflags) */
1409};
1410
1411/**
Radek Krejcib1c11532021-03-29 14:14:19 +02001412 * @brief Description of the extension instance substatements.
1413 *
1414 * Provided by extensions plugins to libyang to be able to correctly compile the content of extension instances.
1415 * Note that order of the defined records matters - just follow the values of ::ly_stmt and order the records from lower to higher values.
1416 */
1417struct lysc_ext_substmt {
1418 enum ly_stmt stmt; /**< allowed substatement */
1419 enum ly_stmt_cardinality cardinality; /**< cardinality of the substatement */
1420 void *storage; /**< pointer to the storage of the compiled statement according to the specific
1421 lysc_ext_substmt::stmt and lysc_ext_substmt::cardinality */
1422};
1423
1424/**
Radek Krejcice8c1592018-10-29 15:35:51 +01001425 * @brief YANG extension instance
1426 */
1427struct lysc_ext_instance {
Radek Krejciad5963b2019-09-06 16:03:05 +02001428 struct lysc_ext *def; /**< pointer to the extension definition */
Radek Krejcice8c1592018-10-29 15:35:51 +01001429 const char *argument; /**< optional value of the extension's argument */
Radek Krejciab430862021-03-02 20:13:40 +01001430 struct lys_module *module; /**< module where the extension instantiated is defined */
Radek Krejci2a408df2018-10-29 16:32:26 +01001431 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5f9a3672021-03-05 21:35:22 +01001432 struct lysc_ext_substmt *substmts; /**< list of allowed substatements with the storage to access the present
1433 substatements ([sized array](@ref sizedarrays)) */
Radek Krejci0e59c312019-08-15 15:34:15 +02001434 void *data; /**< private plugins's data, not used by libyang */
Radek Krejciab430862021-03-02 20:13:40 +01001435
1436 void *parent; /**< pointer to the parent element holding the extension instance(s), use
1437 ::lysc_ext_instance#parent_stmt to access the schema element */
1438 enum ly_stmt parent_stmt; /**< value identifying placement of the extension instance in specific statement */
1439 LY_ARRAY_COUNT_TYPE parent_stmt_index; /**< in case the instance is in a substatement, this identifies
1440 the index of that substatement in its [sized array](@ref sizedarrays) (if any) */
Radek Krejcice8c1592018-10-29 15:35:51 +01001441};
1442
1443/**
Radek Krejcidd4e8d42018-10-16 14:55:43 +02001444 * @brief YANG when-stmt
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001445 */
Radek Krejcidd4e8d42018-10-16 14:55:43 +02001446struct lysc_when {
1447 struct lyxp_expr *cond; /**< XPath when condition */
Michal Vasko175012e2019-11-06 15:49:14 +01001448 struct lysc_node *context; /**< context node for evaluating the expression, NULL if the context is root node */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001449 struct lysc_prefix *prefixes; /**< compiled used prefixes in the condition */
Radek Krejcic8b31002019-01-08 10:24:45 +01001450 const char *dsc; /**< description */
1451 const char *ref; /**< reference */
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001452 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci00b874b2019-02-12 10:54:50 +01001453 uint32_t refcount; /**< reference counter since some of the when statements are shared among several nodes */
Michal Vaskoecd62de2019-11-13 12:35:11 +01001454 uint16_t flags; /**< [schema node flags](@ref snodeflags) - only LYS_STATUS is allowed */
Radek Krejcidd4e8d42018-10-16 14:55:43 +02001455};
1456
1457/**
Radek Krejci2a408df2018-10-29 16:32:26 +01001458 * @brief YANG identity-stmt
1459 */
1460struct lysc_ident {
1461 const char *name; /**< identity name (mandatory), including possible prefix */
Radek Krejcic8b31002019-01-08 10:24:45 +01001462 const char *dsc; /**< description */
1463 const char *ref; /**< reference */
Radek Krejci693262f2019-04-29 15:23:20 +02001464 struct lys_module *module; /**< module structure */
aPiecek6b3d5422021-07-30 15:55:43 +02001465 struct lysc_ident **derived; /**< list of (pointers to the) derived identities ([sized array](@ref sizedarrays))
1466 It also contains references to identities located in unimplemented modules. */
Radek Krejci2a408df2018-10-29 16:32:26 +01001467 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1468 uint16_t flags; /**< [schema node flags](@ref snodeflags) - only LYS_STATUS_ values are allowed */
1469};
1470
1471/**
Radek Krejci151a5b72018-10-19 14:21:44 +02001472 * @defgroup ifftokens if-feature expression tokens
Radek Krejci8678fa42020-08-18 16:07:28 +02001473 * Tokens of if-feature expression used in ::lysc_iffeature.expr.
Radek Krejci151a5b72018-10-19 14:21:44 +02001474 *
1475 * @{
1476 */
1477#define LYS_IFF_NOT 0x00 /**< operand "not" */
1478#define LYS_IFF_AND 0x01 /**< operand "and" */
1479#define LYS_IFF_OR 0x02 /**< operand "or" */
1480#define LYS_IFF_F 0x03 /**< feature */
Radek Krejci2ff0d572020-05-21 15:27:28 +02001481/** @} ifftokens */
Radek Krejci151a5b72018-10-19 14:21:44 +02001482
1483/**
Radek Krejcib7db73a2018-10-24 14:18:40 +02001484 * @brief Compiled YANG revision statement
1485 */
1486struct lysc_revision {
1487 char date[LY_REV_SIZE]; /**< revision-date (mandatory) */
1488 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1489};
1490
Radek Krejci2167ee12018-11-02 16:09:07 +01001491struct lysc_range {
Radek Krejci4f28eda2018-11-12 11:46:16 +01001492 struct lysc_range_part {
Radek Krejci693262f2019-04-29 15:23:20 +02001493 union { /**< min boundary */
Radek Krejcie7b95092019-05-15 11:03:07 +02001494 int64_t min_64; /**< for int8, int16, int32, int64 and decimal64 ( >= LY_TYPE_DEC64) */
1495 uint64_t min_u64; /**< for uint8, uint16, uint32, uint64, string and binary ( < LY_TYPE_DEC64) */
Radek Krejci2167ee12018-11-02 16:09:07 +01001496 };
Radek Krejci693262f2019-04-29 15:23:20 +02001497 union { /**< max boundary */
Radek Krejcie7b95092019-05-15 11:03:07 +02001498 int64_t max_64; /**< for int8, int16, int32, int64 and decimal64 ( >= LY_TYPE_DEC64) */
1499 uint64_t max_u64; /**< for uint8, uint16, uint32, uint64, string and binary ( < LY_TYPE_DEC64) */
Radek Krejci2167ee12018-11-02 16:09:07 +01001500 };
Radek Krejci4f28eda2018-11-12 11:46:16 +01001501 } *parts; /**< compiled range expression ([sized array](@ref sizedarrays)) */
Radek Krejcic8b31002019-01-08 10:24:45 +01001502 const char *dsc; /**< description */
1503 const char *ref; /**< reference */
Radek Krejci2167ee12018-11-02 16:09:07 +01001504 const char *emsg; /**< error-message */
1505 const char *eapptag; /**< error-app-tag value */
1506 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1507};
1508
1509struct lysc_pattern {
Radek Krejci54579462019-04-30 12:47:06 +02001510 const char *expr; /**< original, not compiled, regular expression */
1511 pcre2_code *code; /**< compiled regular expression */
Radek Krejcic8b31002019-01-08 10:24:45 +01001512 const char *dsc; /**< description */
1513 const char *ref; /**< reference */
Radek Krejci2167ee12018-11-02 16:09:07 +01001514 const char *emsg; /**< error-message */
1515 const char *eapptag; /**< error-app-tag value */
1516 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci0f969882020-08-21 16:56:47 +02001517 uint32_t inverted : 1; /**< invert-match flag */
1518 uint32_t refcount : 31; /**< reference counter */
Radek Krejci2167ee12018-11-02 16:09:07 +01001519};
1520
1521struct lysc_must {
Radek Krejci2167ee12018-11-02 16:09:07 +01001522 struct lyxp_expr *cond; /**< XPath when condition */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001523 struct lysc_prefix *prefixes; /**< compiled used prefixes in the condition */
Radek Krejcic8b31002019-01-08 10:24:45 +01001524 const char *dsc; /**< description */
1525 const char *ref; /**< reference */
Radek Krejci2167ee12018-11-02 16:09:07 +01001526 const char *emsg; /**< error-message */
1527 const char *eapptag; /**< error-app-tag value */
1528 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
1529};
1530
1531struct lysc_type {
Radek Krejci4f28eda2018-11-12 11:46:16 +01001532 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5f351892021-03-22 16:13:05 +01001533 struct lyplg_type *plugin; /**< type's plugin with built-in as well as user functions to canonize or validate the value of the type */
Radek Krejci2167ee12018-11-02 16:09:07 +01001534 LY_DATA_TYPE basetype; /**< Base type of the type */
Michal Vasko080064b2021-08-31 15:20:44 +02001535 uint32_t refcount; /**< reference counter for type sharing, it may be accessed concurrently when
Michal Vaskobabf0bd2021-08-31 14:55:39 +02001536 creating/freeing data node values that reference it (instance-identifier) */
Radek Krejci2167ee12018-11-02 16:09:07 +01001537};
1538
1539struct lysc_type_num {
Radek Krejci4f28eda2018-11-12 11:46:16 +01001540 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5f351892021-03-22 16:13:05 +01001541 struct lyplg_type *plugin; /**< type's plugin with built-in as well as user functions to canonize or validate the value of the type */
Radek Krejci2167ee12018-11-02 16:09:07 +01001542 LY_DATA_TYPE basetype; /**< Base type of the type */
Michal Vasko080064b2021-08-31 15:20:44 +02001543 uint32_t refcount; /**< reference counter for type sharing */
Radek Krejci2167ee12018-11-02 16:09:07 +01001544 struct lysc_range *range; /**< Optional range limitation */
1545};
1546
1547struct lysc_type_dec {
Radek Krejci4f28eda2018-11-12 11:46:16 +01001548 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5f351892021-03-22 16:13:05 +01001549 struct lyplg_type *plugin; /**< type's plugin with built-in as well as user functions to canonize or validate the value of the type */
Radek Krejci2167ee12018-11-02 16:09:07 +01001550 LY_DATA_TYPE basetype; /**< Base type of the type */
Michal Vasko080064b2021-08-31 15:20:44 +02001551 uint32_t refcount; /**< reference counter for type sharing */
Radek Krejci6cba4292018-11-15 17:33:29 +01001552 uint8_t fraction_digits; /**< fraction digits specification */
Radek Krejci2167ee12018-11-02 16:09:07 +01001553 struct lysc_range *range; /**< Optional range limitation */
1554};
1555
1556struct lysc_type_str {
Radek Krejci4f28eda2018-11-12 11:46:16 +01001557 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5f351892021-03-22 16:13:05 +01001558 struct lyplg_type *plugin; /**< type's plugin with built-in as well as user functions to canonize or validate the value of the type */
Radek Krejci2167ee12018-11-02 16:09:07 +01001559 LY_DATA_TYPE basetype; /**< Base type of the type */
Michal Vasko080064b2021-08-31 15:20:44 +02001560 uint32_t refcount; /**< reference counter for type sharing */
Radek Krejci2167ee12018-11-02 16:09:07 +01001561 struct lysc_range *length; /**< Optional length limitation */
Radek Krejci4586a022018-11-13 11:29:26 +01001562 struct lysc_pattern **patterns; /**< Optional list of pointers to pattern limitations ([sized array](@ref sizedarrays)) */
Radek Krejci2167ee12018-11-02 16:09:07 +01001563};
1564
Radek Krejci693262f2019-04-29 15:23:20 +02001565struct lysc_type_bitenum_item {
1566 const char *name; /**< enumeration identifier */
1567 const char *dsc; /**< description */
1568 const char *ref; /**< reference */
1569 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci693262f2019-04-29 15:23:20 +02001570 union {
1571 int32_t value; /**< integer value associated with the enumeration */
1572 uint32_t position; /**< non-negative integer value associated with the bit */
1573 };
1574 uint16_t flags; /**< [schema node flags](@ref snodeflags) - only LYS_STATUS_ and LYS_SET_VALUE
1575 values are allowed */
1576};
1577
Radek Krejci2167ee12018-11-02 16:09:07 +01001578struct lysc_type_enum {
Radek Krejci4f28eda2018-11-12 11:46:16 +01001579 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5f351892021-03-22 16:13:05 +01001580 struct lyplg_type *plugin; /**< type's plugin with built-in as well as user functions to canonize or validate the value of the type */
Radek Krejci2167ee12018-11-02 16:09:07 +01001581 LY_DATA_TYPE basetype; /**< Base type of the type */
Michal Vasko080064b2021-08-31 15:20:44 +02001582 uint32_t refcount; /**< reference counter for type sharing */
Radek Krejci693262f2019-04-29 15:23:20 +02001583 struct lysc_type_bitenum_item *enums; /**< enumerations list ([sized array](@ref sizedarrays)), mandatory (at least 1 item) */
1584};
1585
1586struct lysc_type_bits {
1587 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5f351892021-03-22 16:13:05 +01001588 struct lyplg_type *plugin; /**< type's plugin with built-in as well as user functions to canonize or validate the value of the type */
Radek Krejci693262f2019-04-29 15:23:20 +02001589 LY_DATA_TYPE basetype; /**< Base type of the type */
Michal Vasko080064b2021-08-31 15:20:44 +02001590 uint32_t refcount; /**< reference counter for type sharing */
Radek Krejci849a62a2019-05-22 15:29:05 +02001591 struct lysc_type_bitenum_item *bits; /**< bits list ([sized array](@ref sizedarrays)), mandatory (at least 1 item),
1592 the items are ordered by their position value. */
Radek Krejci2167ee12018-11-02 16:09:07 +01001593};
1594
1595struct lysc_type_leafref {
Radek Krejci4f28eda2018-11-12 11:46:16 +01001596 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5f351892021-03-22 16:13:05 +01001597 struct lyplg_type *plugin; /**< type's plugin with built-in as well as user functions to canonize or validate the value of the type */
Radek Krejci2167ee12018-11-02 16:09:07 +01001598 LY_DATA_TYPE basetype; /**< Base type of the type */
Michal Vasko080064b2021-08-31 15:20:44 +02001599 uint32_t refcount; /**< reference counter for type sharing */
Michal Vasko004d3152020-06-11 19:59:22 +02001600 struct lyxp_expr *path; /**< parsed target path, compiled path cannot be stored because of type sharing */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001601 struct lysc_prefix *prefixes; /**< resolved prefixes used in the path */
Michal Vaskoed725d72021-06-23 12:03:45 +02001602 const struct lys_module *cur_mod;/**< unused, not needed */
Radek Krejci412ddfa2018-11-23 11:44:11 +01001603 struct lysc_type *realtype; /**< pointer to the real (first non-leafref in possible leafrefs chain) type. */
Radek Krejci2167ee12018-11-02 16:09:07 +01001604 uint8_t require_instance; /**< require-instance flag */
1605};
1606
1607struct lysc_type_identityref {
Radek Krejci4f28eda2018-11-12 11:46:16 +01001608 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5f351892021-03-22 16:13:05 +01001609 struct lyplg_type *plugin; /**< type's plugin with built-in as well as user functions to canonize or validate the value of the type */
Radek Krejci2167ee12018-11-02 16:09:07 +01001610 LY_DATA_TYPE basetype; /**< Base type of the type */
Michal Vasko080064b2021-08-31 15:20:44 +02001611 uint32_t refcount; /**< reference counter for type sharing */
Radek Krejci555cb5b2018-11-16 14:54:33 +01001612 struct lysc_ident **bases; /**< list of pointers to the base identities ([sized array](@ref sizedarrays)),
Radek Krejci2167ee12018-11-02 16:09:07 +01001613 mandatory (at least 1 item) */
1614};
1615
1616struct lysc_type_instanceid {
Radek Krejci4f28eda2018-11-12 11:46:16 +01001617 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5f351892021-03-22 16:13:05 +01001618 struct lyplg_type *plugin; /**< type's plugin with built-in as well as user functions to canonize or validate the value of the type */
Radek Krejci2167ee12018-11-02 16:09:07 +01001619 LY_DATA_TYPE basetype; /**< Base type of the type */
Michal Vasko080064b2021-08-31 15:20:44 +02001620 uint32_t refcount; /**< reference counter for type sharing */
Radek Krejci2167ee12018-11-02 16:09:07 +01001621 uint8_t require_instance; /**< require-instance flag */
1622};
1623
Radek Krejci2167ee12018-11-02 16:09:07 +01001624struct lysc_type_union {
Radek Krejci4f28eda2018-11-12 11:46:16 +01001625 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5f351892021-03-22 16:13:05 +01001626 struct lyplg_type *plugin; /**< type's plugin with built-in as well as user functions to canonize or validate the value of the type */
Radek Krejci2167ee12018-11-02 16:09:07 +01001627 LY_DATA_TYPE basetype; /**< Base type of the type */
Michal Vasko080064b2021-08-31 15:20:44 +02001628 uint32_t refcount; /**< reference counter for type sharing */
Radek Krejci2167ee12018-11-02 16:09:07 +01001629 struct lysc_type **types; /**< list of types in the union ([sized array](@ref sizedarrays)), mandatory (at least 1 item) */
1630};
1631
1632struct lysc_type_bin {
Radek Krejci4f28eda2018-11-12 11:46:16 +01001633 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci5f351892021-03-22 16:13:05 +01001634 struct lyplg_type *plugin; /**< type's plugin with built-in as well as user functions to canonize or validate the value of the type */
Radek Krejci2167ee12018-11-02 16:09:07 +01001635 LY_DATA_TYPE basetype; /**< Base type of the type */
Michal Vasko080064b2021-08-31 15:20:44 +02001636 uint32_t refcount; /**< reference counter for type sharing */
Radek Krejci2167ee12018-11-02 16:09:07 +01001637 struct lysc_range *length; /**< Optional length limitation */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001638};
1639
Michal Vasko60ea6352020-06-29 13:39:39 +02001640/**
1641 * @brief Maximum number of hashes stored in a schema node.
1642 */
1643#define LYS_NODE_HASH_COUNT 4
1644
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001645/**
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001646 * @brief Compiled YANG data node
1647 */
1648struct lysc_node {
Radek Krejcide7a9c42021-03-10 13:13:06 +01001649 uint16_t nodetype; /**< [type of the node](@ref schemanodetypes) (mandatory) */
Radek Krejcidd4e8d42018-10-16 14:55:43 +02001650 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
Michal Vasko60ea6352020-06-29 13:39:39 +02001651 uint8_t hash[LYS_NODE_HASH_COUNT]; /**< schema hash required for LYB printer/parser */
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001652 struct lys_module *module; /**< module structure */
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001653 struct lysc_node *parent; /**< parent node (NULL in case of top level node) */
1654 struct lysc_node *next; /**< next sibling node (NULL if there is no one) */
1655 struct lysc_node *prev; /**< pointer to the previous sibling node \note Note that this pointer is
1656 never NULL. If there is no sibling node, pointer points to the node
1657 itself. In case of the first node, this pointer points to the last
1658 node in the list. */
Radek Krejcidd4e8d42018-10-16 14:55:43 +02001659 const char *name; /**< node name (mandatory) */
Radek Krejci12fb9142019-01-08 09:45:30 +01001660 const char *dsc; /**< description */
1661 const char *ref; /**< reference */
Radek Krejcie53a8dc2018-10-17 12:52:40 +02001662 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
aPiecek9922ea92021-04-12 07:59:20 +02001663 void *priv; /**< private arbitrary user data, not used by libyang unless ::LY_CTX_SET_PRIV_PARSED is set */
Radek Krejcidd4e8d42018-10-16 14:55:43 +02001664};
1665
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001666struct lysc_node_action_inout {
1667 union {
1668 struct lysc_node node; /**< implicit cast for the members compatible with ::lysc_node */
1669 struct {
1670 uint16_t nodetype; /**< LYS_INPUT or LYS_OUTPUT */
1671 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1672 uint8_t hash[LYS_NODE_HASH_COUNT]; /**< schema hash required for LYB printer/parser */
1673 struct lys_module *module; /**< module structure */
Radek Krejci5960c312021-01-27 20:24:22 +01001674 struct lysc_node *parent;/**< parent node (NULL in case of top level node) */
Michal Vasko544e58a2021-01-28 14:33:41 +01001675 struct lysc_node *next; /**< next sibling node (output node for input, NULL for output) */
1676 struct lysc_node *prev; /**< pointer to the previous sibling node (input and output node pointing to each other) */
Radek Krejci5960c312021-01-27 20:24:22 +01001677 const char *name; /**< "input" or "output" */
1678 const char *dsc; /**< ALWAYS NULL, compatibility member with ::lysc_node */
1679 const char *ref; /**< ALWAYS NULL, compatibility member with ::lysc_node */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001680 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
aPiecek9922ea92021-04-12 07:59:20 +02001681 void *priv; /** private arbitrary user data, not used by libyang unless ::LY_CTX_SET_PRIV_PARSED is set */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001682 };
1683 };
1684
Radek Krejci9a3823e2021-01-27 20:26:46 +01001685 struct lysc_node *child; /**< first child node (linked list) */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001686 struct lysc_must *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
1687};
1688
1689struct lysc_node_action {
1690 union {
1691 struct lysc_node node; /**< implicit cast for the members compatible with ::lysc_node */
1692 struct {
1693 uint16_t nodetype; /**< LYS_RPC or LYS_ACTION */
1694 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1695 uint8_t hash[LYS_NODE_HASH_COUNT]; /**< schema hash required for LYB printer/parser */
1696 struct lys_module *module; /**< module structure */
1697 struct lysc_node *parent; /**< parent node (NULL in case of top level node - RPC) */
1698 struct lysc_node_action *next; /**< next sibling node (NULL if there is no one) */
1699 struct lysc_node_action *prev; /**< pointer to the previous sibling node \note Note that this pointer is
1700 never NULL. If there is no sibling node, pointer points to the node
1701 itself. In case of the first node, this pointer points to the last
1702 node in the list. */
1703 const char *name; /**< action/RPC name (mandatory) */
1704 const char *dsc; /**< description */
1705 const char *ref; /**< reference */
1706 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
aPiecek9922ea92021-04-12 07:59:20 +02001707 void *priv; /** private arbitrary user data, not used by libyang unless ::LY_CTX_SET_PRIV_PARSED is set */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001708 };
1709 };
1710
Radek Krejci9a3823e2021-01-27 20:26:46 +01001711 struct lysc_when **when; /**< list of pointers to when statements ([sized array](@ref sizedarrays)),
1712 the action/RPC nodes do not contain the when statement on their own, but they can
1713 inherit it from the parent's uses. */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001714 struct lysc_node_action_inout input; /**< RPC's/action's input */
1715 struct lysc_node_action_inout output; /**< RPC's/action's output */
1716
1717};
1718
1719struct lysc_node_notif {
1720 union {
1721 struct lysc_node node; /**< implicit cast for the members compatible with ::lysc_node */
1722 struct {
1723 uint16_t nodetype; /**< LYS_NOTIF */
1724 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1725 uint8_t hash[LYS_NODE_HASH_COUNT]; /**< schema hash required for LYB printer/parser */
1726 struct lys_module *module; /**< module structure */
1727 struct lysc_node *parent; /**< parent node (NULL in case of top level node) */
1728 struct lysc_node_notif *next; /**< next sibling node (NULL if there is no one) */
1729 struct lysc_node_notif *prev; /**< pointer to the previous sibling node \note Note that this pointer is
1730 never NULL. If there is no sibling node, pointer points to the node
1731 itself. In case of the first node, this pointer points to the last
1732 node in the list. */
1733 const char *name; /**< Notification name (mandatory) */
1734 const char *dsc; /**< description */
1735 const char *ref; /**< reference */
1736 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
aPiecek9922ea92021-04-12 07:59:20 +02001737 void *priv; /** private arbitrary user data, not used by libyang unless ::LY_CTX_SET_PRIV_PARSED is set */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001738 };
1739 };
1740
Radek Krejci9a3823e2021-01-27 20:26:46 +01001741 struct lysc_node *child; /**< first child node (linked list) */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001742 struct lysc_must *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001743 struct lysc_when **when; /**< list of pointers to when statements ([sized array](@ref sizedarrays)),
1744 the notification nodes do not contain the when statement on their own, but they can
1745 inherit it from the parent's uses. */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001746};
1747
1748struct lysc_node_container {
1749 union {
1750 struct lysc_node node; /**< implicit cast for the members compatible with ::lysc_node */
1751 struct {
1752 uint16_t nodetype; /**< LYS_CONTAINER */
1753 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1754 uint8_t hash[LYS_NODE_HASH_COUNT]; /**< schema hash required for LYB printer/parser */
1755 struct lys_module *module; /**< module structure */
1756 struct lysc_node *parent; /**< parent node (NULL in case of top level node) */
1757 struct lysc_node *next; /**< next sibling node (NULL if there is no one) */
1758 struct lysc_node *prev; /**< pointer to the previous sibling node \note Note that this pointer is
1759 never NULL. If there is no sibling node, pointer points to the node
1760 itself. In case of the first node, this pointer points to the last
1761 node in the list. */
1762 const char *name; /**< node name (mandatory) */
1763 const char *dsc; /**< description */
1764 const char *ref; /**< reference */
1765 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
aPiecek9922ea92021-04-12 07:59:20 +02001766 void *priv; /**< private arbitrary user data, not used by libyang unless ::LY_CTX_SET_PRIV_PARSED is set */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001767 };
1768 };
Radek Krejci4f28eda2018-11-12 11:46:16 +01001769
1770 struct lysc_node *child; /**< first child node (linked list) */
1771 struct lysc_must *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001772 struct lysc_when **when; /**< list of pointers to when statements ([sized array](@ref sizedarrays)) */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001773 struct lysc_node_action *actions;/**< first of actions nodes (linked list) */
1774 struct lysc_node_notif *notifs; /**< first of notifications nodes (linked list) */
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001775};
1776
Radek Krejcia3045382018-11-22 14:30:31 +01001777struct lysc_node_case {
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001778 union {
1779 struct lysc_node node; /**< implicit cast for the members compatible with ::lysc_node */
1780 struct {
1781 uint16_t nodetype; /**< LYS_CASE */
1782 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1783 uint8_t hash[LYS_NODE_HASH_COUNT]; /**< schema hash required for LYB printer/parser, unused */
1784 struct lys_module *module; /**< module structure */
1785 struct lysc_node *parent; /**< parent node (NULL in case of top level node) */
1786 struct lysc_node *next; /**< next sibling node (NULL if there is no one) */
1787 struct lysc_node *prev; /**< pointer to the previous sibling node \note Note that this pointer is
Radek Krejci056d0a82018-12-06 16:57:25 +01001788 never NULL. If there is no sibling node, pointer points to the node
1789 itself. In case of the first node, this pointer points to the last
1790 node in the list. */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001791 const char *name; /**< name of the case, including the implicit case */
1792 const char *dsc; /**< description */
1793 const char *ref; /**< reference */
1794 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
aPiecek9922ea92021-04-12 07:59:20 +02001795 void *priv; /**< private arbitrary user data, not used by libyang unless ::LY_CTX_SET_PRIV_PARSED is set */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001796 };
1797 };
Radek Krejci056d0a82018-12-06 16:57:25 +01001798
Radek Krejcia3045382018-11-22 14:30:31 +01001799 struct lysc_node *child; /**< first child node of the case (linked list). Note that all the children of all the sibling cases are linked
Radek Krejcife13da42019-02-15 14:51:01 +01001800 each other as siblings with the parent pointer pointing to appropriate case node. */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001801 struct lysc_when **when; /**< list of pointers to when statements ([sized array](@ref sizedarrays)) */
Radek Krejcia3045382018-11-22 14:30:31 +01001802};
1803
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001804struct lysc_node_choice {
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001805 union {
1806 struct lysc_node node; /**< implicit cast for the members compatible with ::lysc_node */
1807 struct {
1808 uint16_t nodetype; /**< LYS_CHOICE */
1809 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1810 uint8_t hash[LYS_NODE_HASH_COUNT]; /**< schema hash required for LYB printer/parser, unused */
1811 struct lys_module *module; /**< module structure */
1812 struct lysc_node *parent; /**< parent node (NULL in case of top level node) */
1813 struct lysc_node *next; /**< next sibling node (NULL if there is no one) */
1814 struct lysc_node *prev; /**< pointer to the previous sibling node \note Note that this pointer is
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001815 never NULL. If there is no sibling node, pointer points to the node
1816 itself. In case of the first node, this pointer points to the last
1817 node in the list. */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001818 const char *name; /**< node name (mandatory) */
1819 const char *dsc; /**< description */
1820 const char *ref; /**< reference */
1821 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
aPiecek9922ea92021-04-12 07:59:20 +02001822 void *priv; /**< private arbitrary user data, not used by libyang unless ::LY_CTX_SET_PRIV_PARSED is set */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001823 };
1824 };
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001825
Radek Krejcia9026eb2018-12-12 16:04:47 +01001826 struct lysc_node_case *cases; /**< list of the cases (linked list). Note that all the children of all the cases are linked each other
1827 as siblings. Their parent pointers points to the specific case they belongs to, so distinguish the
1828 case is simple. */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001829 struct lysc_when **when; /**< list of pointers to when statements ([sized array](@ref sizedarrays)) */
Radek Krejci056d0a82018-12-06 16:57:25 +01001830 struct lysc_node_case *dflt; /**< default case of the choice, only a pointer into the cases array. */
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001831};
1832
1833struct lysc_node_leaf {
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001834 union {
1835 struct lysc_node node; /**< implicit cast for the members compatible with ::lysc_node */
1836 struct {
1837 uint16_t nodetype; /**< LYS_LEAF */
1838 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1839 uint8_t hash[LYS_NODE_HASH_COUNT]; /**< schema hash required for LYB printer/parser */
1840 struct lys_module *module; /**< module structure */
1841 struct lysc_node *parent; /**< parent node (NULL in case of top level node) */
1842 struct lysc_node *next; /**< next sibling node (NULL if there is no one) */
1843 struct lysc_node *prev; /**< pointer to the previous sibling node \note Note that this pointer is
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001844 never NULL. If there is no sibling node, pointer points to the node
1845 itself. In case of the first node, this pointer points to the last
1846 node in the list. */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001847 const char *name; /**< node name (mandatory) */
1848 const char *dsc; /**< description */
1849 const char *ref; /**< reference */
1850 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
aPiecek9922ea92021-04-12 07:59:20 +02001851 void *priv; /**< private arbitrary user data, not used by libyang unless ::LY_CTX_SET_PRIV_PARSED is set */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001852 };
1853 };
Radek Krejci4f28eda2018-11-12 11:46:16 +01001854
1855 struct lysc_must *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001856 struct lysc_when **when; /**< list of pointers to when statements ([sized array](@ref sizedarrays)) */
Radek Krejci4f28eda2018-11-12 11:46:16 +01001857 struct lysc_type *type; /**< type of the leaf node (mandatory) */
Radek Krejcib57cf1e2018-11-23 14:07:05 +01001858
Radek Krejci4f28eda2018-11-12 11:46:16 +01001859 const char *units; /**< units of the leaf's type */
Michal Vasko33876022021-04-27 16:42:24 +02001860 struct lyd_value *dflt; /**< default value, use ::lyd_value_get_canonical() to get the canonical string */
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001861};
1862
1863struct lysc_node_leaflist {
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001864 union {
1865 struct lysc_node node; /**< implicit cast for the members compatible with ::lysc_node */
1866 struct {
1867 uint16_t nodetype; /**< LYS_LEAFLIST */
1868 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1869 uint8_t hash[LYS_NODE_HASH_COUNT]; /**< schema hash required for LYB printer/parser */
1870 struct lys_module *module; /**< module structure */
1871 struct lysc_node *parent; /**< parent node (NULL in case of top level node) */
1872 struct lysc_node *next; /**< next sibling node (NULL if there is no one) */
1873 struct lysc_node *prev; /**< pointer to the previous sibling node \note Note that this pointer is
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001874 never NULL. If there is no sibling node, pointer points to the node
1875 itself. In case of the first node, this pointer points to the last
1876 node in the list. */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001877 const char *name; /**< node name (mandatory) */
1878 const char *dsc; /**< description */
1879 const char *ref; /**< reference */
1880 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
aPiecek9922ea92021-04-12 07:59:20 +02001881 void *priv; /**< private arbitrary user data, not used by libyang unless ::LY_CTX_SET_PRIV_PARSED is set */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001882 };
1883 };
Radek Krejcib57cf1e2018-11-23 14:07:05 +01001884
1885 struct lysc_must *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001886 struct lysc_when **when; /**< list of pointers to when statements ([sized array](@ref sizedarrays)) */
Radek Krejcib57cf1e2018-11-23 14:07:05 +01001887 struct lysc_type *type; /**< type of the leaf node (mandatory) */
1888
Radek Krejci0e5d8382018-11-28 16:37:53 +01001889 const char *units; /**< units of the leaf's type */
Michal Vasko33876022021-04-27 16:42:24 +02001890 struct lyd_value **dflts; /**< list ([sized array](@ref sizedarrays)) of default values, use
1891 ::lyd_value_get_canonical() to get the canonical strings */
Michal Vaskoba99a3e2020-08-18 15:50:05 +02001892
Radek Krejci0e5d8382018-11-28 16:37:53 +01001893 uint32_t min; /**< min-elements constraint */
1894 uint32_t max; /**< max-elements constraint */
1895
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001896};
1897
1898struct lysc_node_list {
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001899 union {
1900 struct lysc_node node; /**< implicit cast for the members compatible with ::lysc_node */
1901 struct {
1902 uint16_t nodetype; /**< LYS_LIST */
1903 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1904 uint8_t hash[LYS_NODE_HASH_COUNT]; /**< schema hash required for LYB printer/parser */
1905 struct lys_module *module; /**< module structure */
1906 struct lysc_node *parent; /**< parent node (NULL in case of top level node) */
1907 struct lysc_node *next; /**< next sibling node (NULL if there is no one) */
1908 struct lysc_node *prev; /**< pointer to the previous sibling node \note Note that this pointer is
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001909 never NULL. If there is no sibling node, pointer points to the node
1910 itself. In case of the first node, this pointer points to the last
1911 node in the list. */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001912 const char *name; /**< node name (mandatory) */
1913 const char *dsc; /**< description */
1914 const char *ref; /**< reference */
1915 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
aPiecek9922ea92021-04-12 07:59:20 +02001916 void *priv; /**< private arbitrary user data, not used by libyang unless ::LY_CTX_SET_PRIV_PARSED is set */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001917 };
1918 };
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001919
1920 struct lysc_node *child; /**< first child node (linked list) */
1921 struct lysc_must *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001922 struct lysc_when **when; /**< list of pointers to when statements ([sized array](@ref sizedarrays)) */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001923 struct lysc_node_action *actions;/**< first of actions nodes (linked list) */
1924 struct lysc_node_notif *notifs; /**< first of notifications nodes (linked list) */
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001925
Radek Krejci2a9fc652021-01-22 17:44:34 +01001926 struct lysc_node_leaf ***uniques;/**< list of sized arrays of pointers to the unique nodes ([sized array](@ref sizedarrays)) */
Radek Krejci9bb94eb2018-12-04 16:48:35 +01001927 uint32_t min; /**< min-elements constraint */
1928 uint32_t max; /**< max-elements constraint */
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001929};
1930
1931struct lysc_node_anydata {
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001932 union {
1933 struct lysc_node node; /**< implicit cast for the members compatible with ::lysc_node */
1934 struct {
1935 uint16_t nodetype; /**< LYS_ANYXML or LYS_ANYDATA */
1936 uint16_t flags; /**< [schema node flags](@ref snodeflags) */
1937 uint8_t hash[LYS_NODE_HASH_COUNT]; /**< schema hash required for LYB printer/parser */
1938 struct lys_module *module; /**< module structure */
1939 struct lysc_node *parent; /**< parent node (NULL in case of top level node) */
1940 struct lysc_node *next; /**< next sibling node (NULL if there is no one) */
1941 struct lysc_node *prev; /**< pointer to the previous sibling node \note Note that this pointer is
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001942 never NULL. If there is no sibling node, pointer points to the node
1943 itself. In case of the first node, this pointer points to the last
1944 node in the list. */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001945 const char *name; /**< node name (mandatory) */
1946 const char *dsc; /**< description */
1947 const char *ref; /**< reference */
1948 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
aPiecek9922ea92021-04-12 07:59:20 +02001949 void *priv; /**< private arbitrary user data, not used by libyang unless ::LY_CTX_SET_PRIV_PARSED is set */
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001950 };
1951 };
Radek Krejci9800fb82018-12-13 14:26:23 +01001952
1953 struct lysc_must *musts; /**< list of must restrictions ([sized array](@ref sizedarrays)) */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001954 struct lysc_when **when; /**< list of pointers to when statements ([sized array](@ref sizedarrays)) */
Radek Krejcibd8d9ba2018-11-02 16:06:26 +01001955};
1956
Radek Krejcidd4e8d42018-10-16 14:55:43 +02001957/**
1958 * @brief Compiled YANG schema tree structure representing YANG module.
1959 *
1960 * Semantically validated YANG schema tree for data tree parsing.
1961 * Contains only the necessary information for the data validation.
1962 */
1963struct lysc_module {
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001964 struct lys_module *mod; /**< covering module structure */
Radek Krejcidd4e8d42018-10-16 14:55:43 +02001965
Radek Krejci2a408df2018-10-29 16:32:26 +01001966 struct lysc_node *data; /**< list of module's top-level data nodes (linked list) */
Radek Krejci2a9fc652021-01-22 17:44:34 +01001967 struct lysc_node_action *rpcs; /**< first of actions nodes (linked list) */
1968 struct lysc_node_notif *notifs; /**< first of notifications nodes (linked list) */
Radek Krejcice8c1592018-10-29 15:35:51 +01001969 struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001970};
1971
1972/**
Radek Krejci490a5462020-11-05 08:44:42 +01001973 * @brief Examine whether a node is user-ordered list or leaf-list.
1974 *
1975 * @param[in] lysc_node Schema node to examine.
1976 * @return Boolean value whether the @p node is user-ordered or not.
1977 */
1978#define lysc_is_userordered(lysc_node) \
1979 ((!lysc_node || !(lysc_node->nodetype & (LYS_LEAFLIST | LYS_LIST)) || !(lysc_node->flags & LYS_ORDBY_USER)) ? 0 : 1)
1980
1981/**
1982 * @brief Examine whether a node is a list's key.
1983 *
1984 * @param[in] lysc_node Schema node to examine.
1985 * @return Boolean value whether the @p node is a key or not.
1986 */
1987#define lysc_is_key(lysc_node) \
Michal Vaskobce7ee32021-02-04 11:05:25 +01001988 ((!lysc_node || (lysc_node->nodetype != LYS_LEAF) || !(lysc_node->flags & LYS_KEY)) ? 0 : 1)
Radek Krejci490a5462020-11-05 08:44:42 +01001989
1990/**
Michal Vasko5c123b02020-12-04 14:34:04 +01001991 * @brief Examine whether a node is a non-presence container.
1992 *
1993 * @param[in] lysc_node Schema node to examine.
1994 * @return Boolean value whether the @p node is a NP container or not.
1995 */
1996#define lysc_is_np_cont(lysc_node) \
Michal Vaskobce7ee32021-02-04 11:05:25 +01001997 ((!lysc_node || (lysc_node->nodetype != LYS_CONTAINER) || (lysc_node->flags & LYS_PRESENCE)) ? 0 : 1)
1998
1999/**
Michal Vaskoe78faec2021-04-08 17:24:43 +02002000 * @brief Examine whether a node is a key-less list or a non-configuration leaf-list.
Michal Vaskobce7ee32021-02-04 11:05:25 +01002001 *
2002 * @param[in] lysc_node Schema node to examine.
2003 * @return Boolean value whether the @p node is a list with duplicate instances allowed.
2004 */
2005#define lysc_is_dup_inst_list(lysc_node) \
2006 ((lysc_node && (((lysc_node->nodetype == LYS_LIST) && (lysc_node->flags & LYS_KEYLESS)) || \
Michal Vaskoe78faec2021-04-08 17:24:43 +02002007 ((lysc_node->nodetype == LYS_LEAFLIST) && !(lysc_node->flags & LYS_CONFIG_W)))) ? 1 : 0)
Michal Vasko5c123b02020-12-04 14:34:04 +01002008
2009/**
Michal Vaskod5cfa6e2020-11-23 16:56:08 +01002010 * @brief Check whether the schema node data instance existence depends on any when conditions.
2011 * This node and any direct parent choice and case schema nodes are also examined for when conditions.
2012 *
2013 * Be careful, this function is not recursive and checks only conditions that apply to this node directly.
2014 * Meaning if there are any conditions associated with any data parent instance of @p node, they are not returned.
2015 *
2016 * @param[in] node Schema node to examine.
2017 * @return When condition associated with the node data instance, NULL if there is none.
2018 */
2019const struct lysc_when *lysc_has_when(const struct lysc_node *node);
2020
2021/**
Michal Vaskoef53c812021-10-13 10:21:03 +02002022 * @brief Get the owner module of the schema node. It is the module of the top-level node. Generally,
2023 * in case of augments it is the target module, recursively, otherwise it is the module where the node is defined.
2024 *
2025 * @param[in] node Schema node to examine.
2026 * @return Module owner of the node.
2027 */
2028const struct lys_module *lysc_owner_module(const struct lysc_node *node);
2029
2030/**
Radek Krejci2a9fc652021-01-22 17:44:34 +01002031 * @brief Get the groupings linked list of the given (parsed) schema node.
Radek Krejci53ea6152018-12-13 15:21:15 +01002032 * Decides the node's type and in case it has a groupings array, returns it.
2033 * @param[in] node Node to examine.
Radek Krejci2a9fc652021-01-22 17:44:34 +01002034 * @return The node's groupings linked list if any, NULL otherwise.
Radek Krejci53ea6152018-12-13 15:21:15 +01002035 */
Radek Krejci2a9fc652021-01-22 17:44:34 +01002036const struct lysp_node_grp *lysp_node_groupings(const struct lysp_node *node);
Radek Krejci53ea6152018-12-13 15:21:15 +01002037
2038/**
Radek Krejci056d0a82018-12-06 16:57:25 +01002039 * @brief Get the typedefs sized array of the given (parsed) schema node.
2040 * Decides the node's type and in case it has a typedefs array, returns it.
2041 * @param[in] node Node to examine.
2042 * @return The node's typedefs sized array if any, NULL otherwise.
2043 */
2044const struct lysp_tpdf *lysp_node_typedefs(const struct lysp_node *node);
2045
2046/**
Radek Krejci2a9fc652021-01-22 17:44:34 +01002047 * @brief Get the actions/RPCs linked list of the given (parsed) schema node.
Radek Krejci056d0a82018-12-06 16:57:25 +01002048 * Decides the node's type and in case it has a actions/RPCs array, returns it.
2049 * @param[in] node Node to examine.
Radek Krejci2a9fc652021-01-22 17:44:34 +01002050 * @return The node's actions/RPCs linked list if any, NULL otherwise.
Radek Krejci056d0a82018-12-06 16:57:25 +01002051 */
Radek Krejci2a9fc652021-01-22 17:44:34 +01002052const struct lysp_node_action *lysp_node_actions(const struct lysp_node *node);
Radek Krejci056d0a82018-12-06 16:57:25 +01002053
2054/**
Radek Krejci2a9fc652021-01-22 17:44:34 +01002055 * @brief Get the Notifications linked list of the given (parsed) schema node.
Radek Krejci056d0a82018-12-06 16:57:25 +01002056 * Decides the node's type and in case it has a Notifications array, returns it.
2057 * @param[in] node Node to examine.
Radek Krejci2a9fc652021-01-22 17:44:34 +01002058 * @return The node's Notifications linked list if any, NULL otherwise.
Radek Krejci056d0a82018-12-06 16:57:25 +01002059 */
Radek Krejci2a9fc652021-01-22 17:44:34 +01002060const struct lysp_node_notif *lysp_node_notifs(const struct lysp_node *node);
Radek Krejci056d0a82018-12-06 16:57:25 +01002061
2062/**
2063 * @brief Get the children linked list of the given (parsed) schema node.
2064 * Decides the node's type and in case it has a children list, returns it.
2065 * @param[in] node Node to examine.
2066 * @return The node's children linked list if any, NULL otherwise.
2067 */
Michal Vasko544e58a2021-01-28 14:33:41 +01002068const struct lysp_node *lysp_node_child(const struct lysp_node *node);
Radek Krejci056d0a82018-12-06 16:57:25 +01002069
2070/**
Radek Krejci2a9fc652021-01-22 17:44:34 +01002071 * @brief Get the actions/RPCs linked list of the given (compiled) schema node.
Radek Krejci056d0a82018-12-06 16:57:25 +01002072 * Decides the node's type and in case it has a actions/RPCs array, returns it.
2073 * @param[in] node Node to examine.
Radek Krejci2a9fc652021-01-22 17:44:34 +01002074 * @return The node's actions/RPCs linked list if any, NULL otherwise.
Radek Krejci056d0a82018-12-06 16:57:25 +01002075 */
Radek Krejci2a9fc652021-01-22 17:44:34 +01002076const struct lysc_node_action *lysc_node_actions(const struct lysc_node *node);
Radek Krejci056d0a82018-12-06 16:57:25 +01002077
2078/**
Radek Krejci2a9fc652021-01-22 17:44:34 +01002079 * @brief Get the Notifications linked list of the given (compiled) schema node.
Radek Krejci056d0a82018-12-06 16:57:25 +01002080 * Decides the node's type and in case it has a Notifications array, returns it.
2081 * @param[in] node Node to examine.
Radek Krejci2a9fc652021-01-22 17:44:34 +01002082 * @return The node's Notifications linked list if any, NULL otherwise.
Radek Krejci056d0a82018-12-06 16:57:25 +01002083 */
Radek Krejci2a9fc652021-01-22 17:44:34 +01002084const struct lysc_node_notif *lysc_node_notifs(const struct lysc_node *node);
Radek Krejci056d0a82018-12-06 16:57:25 +01002085
2086/**
2087 * @brief Get the children linked list of the given (compiled) schema node.
Michal Vasko2a668712020-10-21 11:48:09 +02002088 *
Michal Vasko544e58a2021-01-28 14:33:41 +01002089 * Note that ::LYS_CHOICE has only ::LYS_CASE children.
2090 * Also, ::LYS_RPC and ::LYS_ACTION have the first child ::LYS_INPUT, its sibling is ::LYS_OUTPUT.
2091 *
Michal Vasko2a668712020-10-21 11:48:09 +02002092 * @param[in] node Node to examine.
Michal Vasko2a668712020-10-21 11:48:09 +02002093 * @return Children linked list if any,
2094 * @return NULL otherwise.
2095 */
Michal Vasko544e58a2021-01-28 14:33:41 +01002096const struct lysc_node *lysc_node_child(const struct lysc_node *node);
Michal Vasko2a668712020-10-21 11:48:09 +02002097
2098/**
Radek Krejci9a3823e2021-01-27 20:26:46 +01002099 * @brief Get the must statements list if present in the @p node
2100 *
2101 * @param[in] node Node to examine.
2102 * @return Pointer to the list of must restrictions ([sized array](@ref sizedarrays))
2103 * @return NULL if there is no must statement in the node, no matter if it is not even allowed or just present
2104 */
2105struct lysc_must *lysc_node_musts(const struct lysc_node *node);
2106
2107/**
2108 * @brief Get the when statements list if present in the @p node
2109 *
2110 * @param[in] node Node to examine.
2111 * @return Pointer to the list of pointers to when statements ([sized array](@ref sizedarrays))
2112 * @return NULL if there is no when statement in the node, no matter if it is not even allowed or just present
2113 */
2114struct lysc_when **lysc_node_when(const struct lysc_node *node);
2115
2116/**
Michal Vaskof1ab44f2020-10-22 08:58:32 +02002117 * @brief Callback to be called for every schema node in a DFS traversal.
2118 *
2119 * @param[in] node Current node.
2120 * @param[in] data Arbitrary user data.
2121 * @param[out] dfs_continue Set to true if the current subtree should be skipped and continue with siblings instead.
2122 * @return LY_SUCCESS on success,
2123 * @return LY_ERR value to terminate DFS and return this value.
2124 */
Michal Vasko8f07dfe2021-03-02 16:10:24 +01002125typedef LY_ERR (*lysc_dfs_clb)(struct lysc_node *node, void *data, ly_bool *dfs_continue);
Michal Vaskof1ab44f2020-10-22 08:58:32 +02002126
2127/**
2128 * @brief DFS traversal of all the schema nodes in a (sub)tree including any actions and nested notifications.
2129 *
2130 * Node with children, actions, and notifications is traversed in this order:
2131 * 1) each child subtree;
2132 * 2) each action subtree;
2133 * 3) each notification subtree.
2134 *
2135 * For algorithm illustration or traversal with actions and notifications skipped, see ::LYSC_TREE_DFS_BEGIN.
2136 *
2137 * @param[in] root Schema root to fully traverse.
2138 * @param[in] dfs_clb Callback to call for each node.
2139 * @param[in] data Arbitrary user data passed to @p dfs_clb.
2140 * @return LY_SUCCESS on success,
2141 * @return LY_ERR value returned by @p dfs_clb.
2142 */
2143LY_ERR lysc_tree_dfs_full(const struct lysc_node *root, lysc_dfs_clb dfs_clb, void *data);
2144
2145/**
2146 * @brief DFS traversal of all the schema nodes in a module including RPCs and notifications.
2147 *
2148 * For more details, see ::lysc_tree_dfs_full().
2149 *
2150 * @param[in] mod Module to fully traverse.
2151 * @param[in] dfs_clb Callback to call for each node.
2152 * @param[in] data Arbitrary user data passed to @p dfs_clb.
2153 * @return LY_SUCCESS on success,
2154 * @return LY_ERR value returned by @p dfs_clb.
2155 */
2156LY_ERR lysc_module_dfs_full(const struct lys_module *mod, lysc_dfs_clb dfs_clb, void *data);
2157
2158/**
Radek Krejci151a5b72018-10-19 14:21:44 +02002159 * @brief Get how the if-feature statement currently evaluates.
2160 *
2161 * @param[in] iff Compiled if-feature statement to evaluate.
Michal Vasko28d78432020-05-26 13:10:53 +02002162 * @return LY_SUCCESS if the statement evaluates to true,
2163 * @return LY_ENOT if it evaluates to false,
2164 * @return LY_ERR on error.
Radek Krejci151a5b72018-10-19 14:21:44 +02002165 */
Michal Vasko28d78432020-05-26 13:10:53 +02002166LY_ERR lysc_iffeature_value(const struct lysc_iffeature *iff);
Radek Krejci151a5b72018-10-19 14:21:44 +02002167
2168/**
aPiecekf4a0a192021-08-03 15:14:17 +02002169 * @brief Get how the if-feature statement is evaluated for certain identity.
2170 *
2171 * The function can be called even if the identity does not contain
2172 * if-features, in which case ::LY_SUCCESS is returned.
2173 *
2174 * @param[in] ident Compiled identity statement to evaluate.
2175 * @return LY_SUCCESS if the statement evaluates to true,
2176 * @return LY_ENOT if it evaluates to false,
2177 * @return LY_ERR on error.
2178 */
2179LY_ERR lys_identity_iffeature_value(const struct lysc_ident *ident);
2180
2181/**
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01002182 * @brief Get the next feature in the module or submodules.
Radek Krejci151a5b72018-10-19 14:21:44 +02002183 *
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01002184 * @param[in] last Last returned feature.
Michal Vasko4ec4bc02021-10-12 10:17:28 +02002185 * @param[in] pmod Parsed module and submodules whose features to iterate over.
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01002186 * @param[in,out] idx Submodule index, set to 0 on first call.
2187 * @return Next found feature, NULL if the last has already been returned.
Radek Krejci151a5b72018-10-19 14:21:44 +02002188 */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01002189struct lysp_feature *lysp_feature_next(const struct lysp_feature *last, const struct lysp_module *pmod, uint32_t *idx);
Radek Krejci151a5b72018-10-19 14:21:44 +02002190
Radek Krejcibed13942020-10-19 16:06:28 +02002191/**
Radek Krejcidab4f0b2021-03-29 14:07:18 +02002192 * @brief Get pointer to the storage of the specified substatement in the given extension instance.
2193 *
2194 * The function simplifies access into the ::lysc_ext_instance.substmts sized array.
2195 *
2196 * @param[in] ext Compiled extension instance to process.
2197 * @param[in] substmt Extension substatement to search for.
2198 * @param[out] instance_p Pointer where the storage of the @p substmt will be provided. The specific type returned depends
2199 * on the @p substmt and can be found in the documentation of each ::ly_stmt value. Also note that some of the substatements
2200 * (::lysc_node based or flags) can share the storage with other substatements. In case the pointer is NULL, still the return
2201 * code can be used to at least know if the substatement is allowed for the extension.
2202 * @param[out] cardinality_p Pointer to provide allowed cardinality of the substatements in the extension. Note that in some
2203 * cases, the type of the storage depends also on the cardinality of the substatement.
2204 * @return LY_SUCCESS if the @p substmt found.
2205 * @return LY_ENOT in case the @p ext is not able to store (does not allow) the specified @p substmt.
2206 */
2207LY_ERR lysc_ext_substmt(const struct lysc_ext_instance *ext, enum ly_stmt substmt,
2208 void **instance_p, enum ly_stmt_cardinality *cardinality_p);
2209
2210/**
Radek Krejcibed13942020-10-19 16:06:28 +02002211 * @defgroup findxpathoptions Atomize XPath options
2212 * Options to modify behavior of ::lys_find_xpath() and ::lys_find_xpath_atoms() searching for schema nodes in schema tree.
2213 * @{
2214 */
Michal Vasko4ad69e72021-10-26 16:25:55 +02002215#define LYS_FIND_XP_SCHEMA 0x08 /**< Apply node access restrictions defined for 'when' and 'must' evaluation. */
2216#define LYS_FIND_XP_OUTPUT 0x10 /**< Search RPC/action output nodes instead of input ones. */
2217#define LYS_FIND_NO_MATCH_ERROR 0x40 /**< Return error if a path segmenbt matches no nodes, otherwise only warning
2218 is printed. */
Radek Krejci576f8fa2020-10-26 21:23:58 +01002219/** @} findxpathoptions */
Michal Vasko072de482020-08-05 13:27:21 +02002220
Radek Krejci151a5b72018-10-19 14:21:44 +02002221/**
Michal Vasko40308e72020-10-20 16:38:40 +02002222 * @brief Get all the schema nodes that are required for @p xpath to be evaluated (atoms).
Michal Vasko519fd602020-05-26 12:17:39 +02002223 *
Michal Vasko26512682021-01-11 11:35:40 +01002224 * @param[in] ctx libyang context to use. May be NULL if @p ctx_node is set.
2225 * @param[in] ctx_node XPath schema context node. Use NULL for the root node.
Radek Krejci8df109d2021-04-23 12:19:08 +02002226 * @param[in] xpath Data XPath expression filtering the matching nodes. ::LY_VALUE_JSON prefix format is expected.
Radek Krejcibed13942020-10-19 16:06:28 +02002227 * @param[in] options Whether to apply some node access restrictions, see @ref findxpathoptions.
Michal Vasko519fd602020-05-26 12:17:39 +02002228 * @param[out] set Set of found atoms (schema nodes).
2229 * @return LY_SUCCESS on success, @p set is returned.
Michal Vasko40308e72020-10-20 16:38:40 +02002230 * @return LY_ERR value on error.
Michal Vasko519fd602020-05-26 12:17:39 +02002231 */
Michal Vasko26512682021-01-11 11:35:40 +01002232LY_ERR lys_find_xpath_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath,
2233 uint32_t options, struct ly_set **set);
Michal Vasko519fd602020-05-26 12:17:39 +02002234
Michal Vasko072de482020-08-05 13:27:21 +02002235/**
Michal Vasko40308e72020-10-20 16:38:40 +02002236 * @brief Get all the schema nodes that are required for @p expr to be evaluated (atoms).
Michal Vasko072de482020-08-05 13:27:21 +02002237 *
Michal Vasko26512682021-01-11 11:35:40 +01002238 * @param[in] ctx_node XPath schema context node. Use NULL for the root node.
Michal Vasko40308e72020-10-20 16:38:40 +02002239 * @param[in] cur_mod Current module for the expression (where it was "instantiated").
2240 * @param[in] expr Parsed expression to use.
2241 * @param[in] prefixes Sized array of compiled prefixes.
2242 * @param[in] options Whether to apply some node access restrictions, see @ref findxpathoptions.
2243 * @param[out] set Set of found atoms (schema nodes).
2244 * @return LY_SUCCESS on success, @p set is returned.
2245 * @return LY_ERR value on error.
2246 */
2247LY_ERR lys_find_expr_atoms(const struct lysc_node *ctx_node, const struct lys_module *cur_mod,
2248 const struct lyxp_expr *expr, const struct lysc_prefix *prefixes, uint32_t options, struct ly_set **set);
2249
2250/**
2251 * @brief Evaluate an @p xpath expression on schema nodes.
2252 *
Michal Vasko26512682021-01-11 11:35:40 +01002253 * @param[in] ctx libyang context to use for absolute @p xpath. May be NULL if @p ctx_node is set.
2254 * @param[in] ctx_node XPath schema context node for relative @p xpath. Use NULL for the root node.
Radek Krejci8df109d2021-04-23 12:19:08 +02002255 * @param[in] xpath Data XPath expression filtering the matching nodes. ::LY_VALUE_JSON prefix format is expected.
Radek Krejcibed13942020-10-19 16:06:28 +02002256 * @param[in] options Whether to apply some node access restrictions, see @ref findxpathoptions.
Michal Vasko072de482020-08-05 13:27:21 +02002257 * @param[out] set Set of found schema nodes.
2258 * @return LY_SUCCESS on success, @p set is returned.
2259 * @return LY_ERR value if an error occurred.
2260 */
Michal Vasko26512682021-01-11 11:35:40 +01002261LY_ERR lys_find_xpath(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
2262 struct ly_set **set);
Michal Vasko519fd602020-05-26 12:17:39 +02002263
2264/**
Radek Krejcibc5644c2020-10-27 14:53:17 +01002265 * @brief Get all the schema nodes that are required for @p path to be evaluated (atoms).
2266 *
2267 * @param[in] path Compiled path to use.
2268 * @param[out] set Set of found atoms (schema nodes).
2269 * @return LY_SUCCESS on success, @p set is returned.
2270 * @return LY_ERR value on error.
2271 */
2272LY_ERR lys_find_lypath_atoms(const struct ly_path *path, struct ly_set **set);
2273
2274/**
2275 * @brief Get all the schema nodes that are required for @p path to be evaluated (atoms).
2276 *
Michal Vasko26512682021-01-11 11:35:40 +01002277 * @param[in] ctx libyang context to use for absolute @p path. May be NULL if @p ctx_node is set.
2278 * @param[in] ctx_node XPath schema context node for relative @p path. Use NULL for the root node.
Radek Krejcibc5644c2020-10-27 14:53:17 +01002279 * @param[in] path JSON path to examine.
2280 * @param[in] output Search operation output instead of input.
2281 * @param[out] set Set of found atoms (schema nodes).
2282 * @return LY_ERR value on error.
2283 */
2284LY_ERR lys_find_path_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output,
2285 struct ly_set **set);
2286
2287/**
2288 * @brief Get a schema node based on the given data path (JSON format, see @ref howtoXPath).
2289 *
Michal Vasko26512682021-01-11 11:35:40 +01002290 * @param[in] ctx libyang context to use for absolute @p path. May be NULL if @p ctx_node is set.
2291 * @param[in] ctx_node XPath schema context node for relative @p path. Use NULL for the root node.
Radek Krejcibc5644c2020-10-27 14:53:17 +01002292 * @param[in] path JSON path of the node to get.
2293 * @param[in] output Search operation output instead of input.
2294 * @return Found schema node or NULL.
2295 */
2296const struct lysc_node *lys_find_path(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path,
2297 ly_bool output);
2298
2299/**
Michal Vasko03ff5a72019-09-11 13:49:33 +02002300 * @brief Types of the different schema paths.
2301 */
2302typedef enum {
Michal Vasko65de0402020-08-03 16:34:19 +02002303 LYSC_PATH_LOG, /**< Descriptive path format used in log messages */
2304 LYSC_PATH_DATA /**< Similar to ::LYSC_PATH_LOG except that schema-only nodes (choice, case) are skipped */
Michal Vasko03ff5a72019-09-11 13:49:33 +02002305} LYSC_PATH_TYPE;
2306
2307/**
Radek Krejci327de162019-06-14 12:52:07 +02002308 * @brief Generate path of the given node in the requested format.
2309 *
2310 * @param[in] node Schema path of this node will be generated.
2311 * @param[in] pathtype Format of the path to generate.
Radek Krejci1c0c3442019-07-23 16:08:47 +02002312 * @param[in,out] buffer Prepared buffer of the @p buflen length to store the generated path.
2313 * If NULL, memory for the complete path is allocated.
2314 * @param[in] buflen Size of the provided @p buffer.
Radek Krejci327de162019-06-14 12:52:07 +02002315 * @return NULL in case of memory allocation error, path of the node otherwise.
Radek Krejci1c0c3442019-07-23 16:08:47 +02002316 * In case the @p buffer is NULL, the returned string is dynamically allocated and caller is responsible to free it.
Radek Krejci327de162019-06-14 12:52:07 +02002317 */
Michal Vasko03ff5a72019-09-11 13:49:33 +02002318char *lysc_path(const struct lysc_node *node, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen);
Radek Krejci327de162019-06-14 12:52:07 +02002319
2320/**
Radek Krejci5aeea3a2018-09-05 13:29:36 +02002321 * @brief Available YANG schema tree structures representing YANG module.
2322 */
2323struct lys_module {
Radek Krejci0bcdaed2019-01-10 10:21:34 +01002324 struct ly_ctx *ctx; /**< libyang context of the module (mandatory) */
2325 const char *name; /**< name of the module (mandatory) */
Radek Krejci0af46292019-01-11 16:02:31 +01002326 const char *revision; /**< revision of the module (if present) */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01002327 const char *ns; /**< namespace of the module (module - mandatory) */
2328 const char *prefix; /**< module prefix or submodule belongsto prefix of main module (mandatory) */
2329 const char *filepath; /**< path, if the schema was read from a file, NULL in case of reading from memory */
2330 const char *org; /**< party/company responsible for the module */
2331 const char *contact; /**< contact information for the module */
2332 const char *dsc; /**< description of the module */
2333 const char *ref; /**< cross-reference for the module */
2334
Radek Krejci5aeea3a2018-09-05 13:29:36 +02002335 struct lysp_module *parsed; /**< Simply parsed (unresolved) YANG schema tree */
Radek Krejci0af46292019-01-11 16:02:31 +01002336 struct lysc_module *compiled; /**< Compiled and fully validated YANG schema tree for data parsing.
2337 Available only for implemented modules. */
Michal Vasko7f45cf22020-10-01 12:49:44 +02002338
Radek Krejci80d281e2020-09-14 17:42:54 +02002339 struct lysc_ident *identities; /**< List of compiled identities of the module ([sized array](@ref sizedarrays))
aPiecek6b3d5422021-07-30 15:55:43 +02002340 also contains the disabled identities when their if-feature(s) are evaluated to \"false\",
2341 and also the list is filled even if the module is not implemented.
2342 The list is located here because it avoids problems when the module became implemented in
Radek Krejci80d281e2020-09-14 17:42:54 +02002343 future (no matter if implicitly via augment/deviate or explicitly via
2344 ::lys_set_implemented()). Note that if the module is not implemented (compiled), the
2345 identities cannot be instantiated in data (in identityrefs). */
Michal Vasko7f45cf22020-10-01 12:49:44 +02002346
2347 struct lys_module **augmented_by;/**< List of modules that augment this module ([sized array](@ref sizedarrays)) */
2348 struct lys_module **deviated_by; /**< List of modules that deviate this module ([sized array](@ref sizedarrays)) */
2349
Michal Vasko89b5c072020-10-06 13:52:44 +02002350 ly_bool implemented; /**< flag if the module is implemented, not just imported */
Michal Vasko01db7de2021-04-16 12:23:30 +02002351 ly_bool to_compile; /**< flag marking a module that was changed but not (re)compiled, see
2352 ::LY_CTX_EXPLICIT_COMPILE. */
aPiecek8ca21bd2021-07-26 14:31:01 +02002353 uint8_t latest_revision; /**< Flag to mark the latest available revision, see [latest_revision options](@ref latestrevflags). */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02002354};
2355
Radek Krejci151a5b72018-10-19 14:21:44 +02002356/**
aPiecek8ca21bd2021-07-26 14:31:01 +02002357 * @defgroup latestrevflags Options for ::lys_module.latest_revision.
2358 *
2359 * Various information bits of ::lys_module.latest_revision.
2360 *
2361 * @{
2362 */
aPiecek94d330b2021-08-04 11:57:31 +02002363#define LYS_MOD_LATEST_REV 0x01 /**< This is the latest revision of the module in the current context. */
2364#define LYS_MOD_LATEST_SEARCHDIRS 0x02 /**< This is the latest revision of the module found in searchdirs. */
aPiecekd4911ee2021-07-30 07:40:24 +02002365#define LYS_MOD_IMPORTED_REV 0x04 /**< This is the module revision used when importing the module without an explicit revision-date.
2366 It is used for all such imports regardless of any changes made in the context. */
aPiecek8ca21bd2021-07-26 14:31:01 +02002367/** @} latestrevflags */
2368
2369/**
Michal Vasko82c31e62020-07-17 15:30:40 +02002370 * @brief Get the current real status of the specified feature in the module.
2371 *
2372 * If the feature is enabled, but some of its if-features are false, the feature is considered
2373 * disabled.
Radek Krejci151a5b72018-10-19 14:21:44 +02002374 *
2375 * @param[in] module Module where the feature is defined.
2376 * @param[in] feature Name of the feature to inspect.
Michal Vasko82c31e62020-07-17 15:30:40 +02002377 * @return LY_SUCCESS if the feature is enabled,
2378 * @return LY_ENOT if the feature is disabled,
2379 * @return LY_ENOTFOUND if the feature was not found.
Radek Krejci151a5b72018-10-19 14:21:44 +02002380 */
Michal Vasko82c31e62020-07-17 15:30:40 +02002381LY_ERR lys_feature_value(const struct lys_module *module, const char *feature);
Radek Krejcidd4e8d42018-10-16 14:55:43 +02002382
2383/**
Radek Krejcia3045382018-11-22 14:30:31 +01002384 * @brief Get next schema tree (sibling) node element that can be instantiated in a data tree. Returned node can
2385 * be from an augment.
2386 *
Radek Krejci8678fa42020-08-18 16:07:28 +02002387 * ::lys_getnext() is supposed to be called sequentially. In the first call, the \p last parameter is usually NULL
Radek Krejcia3045382018-11-22 14:30:31 +01002388 * and function starts returning i) the first \p parent's child or ii) the first top level element of the \p module.
2389 * Consequent calls suppose to provide the previously returned node as the \p last parameter and still the same
2390 * \p parent and \p module parameters.
2391 *
2392 * Without options, the function is used to traverse only the schema nodes that can be paired with corresponding
2393 * data nodes in a data tree. By setting some \p options the behavior can be modified to the extent that
2394 * all the schema nodes are iteratively returned.
2395 *
2396 * @param[in] last Previously returned schema tree node, or NULL in case of the first call.
2397 * @param[in] parent Parent of the subtree where the function starts processing.
2398 * @param[in] module In case of iterating on top level elements, the \p parent is NULL and
2399 * module must be specified.
2400 * @param[in] options [ORed options](@ref sgetnextflags).
2401 * @return Next schema tree node that can be instantiated in a data tree, NULL in case there is no such element.
2402 */
2403const struct lysc_node *lys_getnext(const struct lysc_node *last, const struct lysc_node *parent,
Radek Krejci1deb5be2020-08-26 16:43:36 +02002404 const struct lysc_module *module, uint32_t options);
Radek Krejcia3045382018-11-22 14:30:31 +01002405
2406/**
Radek Krejci035dacf2021-02-12 18:25:53 +01002407 * @brief Get next schema tree (sibling) node element that can be instantiated in a data tree.
Radek Krejci8678fa42020-08-18 16:07:28 +02002408 *
Radek Krejci035dacf2021-02-12 18:25:53 +01002409 * In contrast to ::lys_getnext(), ::lys_getnext_ext() is limited by the given @p ext instance as a schema tree root.
2410 * If the extension does not contain any schema node, NULL is returned. If the @p parent is provided, the functionality
2411 * is completely the same as ::lys_getnext().
2412 *
2413 * ::lys_getnext_ext() is supposed to be called sequentially. In the first call, the \p last parameter is usually NULL
2414 * and function starts returning i) the first \p parent's child or ii) the first top level element of the given @p ext
2415 * instance. Consequent calls suppose to provide the previously returned node as the \p last parameter and still the same
2416 * \p parent and \p ext parameters.
2417 *
2418 * Without options, the function is used to traverse only the schema nodes that can be paired with corresponding
2419 * data nodes in a data tree. By setting some \p options the behavior can be modified to the extent that
2420 * all the schema nodes are iteratively returned.
2421 *
2422 * @param[in] last Previously returned schema tree node, or NULL in case of the first call.
2423 * @param[in] parent Parent of the subtree where the function starts processing.
2424 * @param[in] ext The extension instance to provide a separate schema tree. To consider the top level elements in the tree,
2425 * the \p parent must be NULL. anyway, at least one of @p parent and @p ext parameters must be specified.
2426 * @param[in] options [ORed options](@ref sgetnextflags).
2427 * @return Next schema tree node that can be instantiated in a data tree, NULL in case there is no such element.
2428 */
2429const struct lysc_node *lys_getnext_ext(const struct lysc_node *last, const struct lysc_node *parent,
2430 const struct lysc_ext_instance *ext, uint32_t options);
2431
2432/**
2433 * @defgroup sgetnextflags Options for ::lys_getnext() and ::lys_getnext_ext().
2434 *
2435 * Various options setting behavior of ::lys_getnext() and ::lys_getnext_ext().
Radek Krejci8678fa42020-08-18 16:07:28 +02002436 *
Radek Krejcia3045382018-11-22 14:30:31 +01002437 * @{
2438 */
Radek Krejci8678fa42020-08-18 16:07:28 +02002439#define LYS_GETNEXT_WITHCHOICE 0x01 /**< ::lys_getnext() option to allow returning #LYS_CHOICE nodes instead of looking into them */
2440#define LYS_GETNEXT_NOCHOICE 0x02 /**< ::lys_getnext() option to ignore (kind of conditional) nodes within choice node */
2441#define LYS_GETNEXT_WITHCASE 0x04 /**< ::lys_getnext() option to allow returning #LYS_CASE nodes instead of looking into them */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01002442#define LYS_GETNEXT_INTONPCONT 0x08 /**< ::lys_getnext() option to look into non-presence container, instead of returning container itself */
2443#define LYS_GETNEXT_OUTPUT 0x10 /**< ::lys_getnext() option to provide RPC's/action's output schema nodes instead of input schema nodes
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002444 provided by default */
Radek Krejcia3045382018-11-22 14:30:31 +01002445/** @} sgetnextflags */
2446
2447/**
2448 * @brief Get child node according to the specified criteria.
2449 *
2450 * @param[in] parent Optional parent of the node to find. If not specified, the module's top-level nodes are searched.
2451 * @param[in] module module of the node to find. It is also limitation for the children node of the given parent.
2452 * @param[in] name Name of the node to find.
2453 * @param[in] name_len Optional length of the name in case it is not NULL-terminated string.
2454 * @param[in] nodetype Optional criteria (to speedup) specifying nodetype(s) of the node to find.
2455 * Used as a bitmask, so multiple nodetypes can be specified.
2456 * @param[in] options [ORed options](@ref sgetnextflags).
2457 * @return Found node if any.
2458 */
Michal Vaskoe444f752020-02-10 12:20:06 +01002459const struct lysc_node *lys_find_child(const struct lysc_node *parent, const struct lys_module *module,
Radek Krejci1deb5be2020-08-26 16:43:36 +02002460 const char *name, size_t name_len, uint16_t nodetype, uint32_t options);
Radek Krejcia3045382018-11-22 14:30:31 +01002461
2462/**
Radek Krejci77a8bcd2019-09-11 11:20:02 +02002463 * @brief Make the specific module implemented.
2464 *
Michal Vaskoe8988e92021-01-25 11:26:29 +01002465 * If the module is already implemented but with a different set of features, the whole context is recompiled.
2466 *
Radek Krejci77a8bcd2019-09-11 11:20:02 +02002467 * @param[in] mod Module to make implemented. It is not an error
2468 * to provide already implemented module, it just does nothing.
Michal Vaskoe8988e92021-01-25 11:26:29 +01002469 * @param[in] features Optional array specifying the enabled features terminated with NULL overriding any previous
2470 * feature setting. The feature string '*' enables all the features and array of length 1 with only the terminating
2471 * NULL explicitly disables all the features. In case the parameter is NULL, the features are untouched - left disabled
2472 * in a newly implemented module or with the current features settings in case the module is already implemented.
Michal Vaskoe444f752020-02-10 12:20:06 +01002473 * @return LY_SUCCESS on success.
2474 * @return LY_EDENIED in case the context contains some other revision of the same module which is already implemented.
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01002475 * @return LY_ERR on other errors during module compilation.
Radek Krejci77a8bcd2019-09-11 11:20:02 +02002476 */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01002477LY_ERR lys_set_implemented(struct lys_module *mod, const char **features);
Radek Krejcia3045382018-11-22 14:30:31 +01002478
Radek Krejci084289f2019-07-09 17:35:30 +02002479/**
Radek Krejci0935f412019-08-20 16:15:18 +02002480 * @brief Stringify schema nodetype.
Michal Vaskod43d71a2020-08-07 14:54:58 +02002481 *
Radek Krejci0935f412019-08-20 16:15:18 +02002482 * @param[in] nodetype Nodetype to stringify.
2483 * @return Constant string with the name of the node's type.
2484 */
2485const char *lys_nodetype2str(uint16_t nodetype);
2486
Michal Vaskod43d71a2020-08-07 14:54:58 +02002487/**
2488 * @brief Getter for original XPath expression from a parsed expression.
2489 *
2490 * @param[in] path Parsed expression.
2491 * @return Original string expression.
2492 */
2493const char *lyxp_get_expr(const struct lyxp_expr *path);
2494
Radek Krejci2ff0d572020-05-21 15:27:28 +02002495/** @} schematree */
Radek Krejci5aeea3a2018-09-05 13:29:36 +02002496
Radek Krejci70853c52018-10-15 14:46:16 +02002497#ifdef __cplusplus
2498}
2499#endif
2500
Radek Krejci5aeea3a2018-09-05 13:29:36 +02002501#endif /* LY_TREE_SCHEMA_H_ */