blob: 33f5c7c445b4964d096dac7269d722d297585d47 [file] [log] [blame]
Radek Krejci70853c52018-10-15 14:46:16 +02001/**
2 * @file tree_schema_internal.h
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief internal functions for 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_INTERNAL_H_
16#define LY_TREE_SCHEMA_INTERNAL_H_
17
Radek Krejci2d7a47b2019-05-16 13:34:10 +020018#include <stdint.h>
19
20#include "set.h"
21#include "tree_schema.h"
David Sedlákebd3acf2019-07-26 15:04:32 +020022#include "xml.h"
Radek Krejci2d7a47b2019-05-16 13:34:10 +020023
David Sedlákb3077192019-06-19 10:55:37 +020024#define LOGVAL_PARSER(CTX, ...) LOGVAL((CTX)->ctx, LY_VLOG_LINE, &(CTX)->line, __VA_ARGS__)
Radek Krejcid33273d2018-10-25 14:55:52 +020025
Radek Krejcia9026eb2018-12-12 16:04:47 +010026/* These 2 macros checks YANG's identifier grammar rule */
27#define is_yangidentstartchar(c) ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_')
28#define is_yangidentchar(c) ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || \
David Sedlákebd3acf2019-07-26 15:04:32 +020029 c == '_' || c == '-' || c == '.')
Radek Krejcia9026eb2018-12-12 16:04:47 +010030
David Sedlák4a650532019-07-10 11:55:18 +020031/* Macro to check YANG's yang-char grammar rule */
David Sedlák2c0d5ef2019-08-14 11:40:44 +020032#define is_yangutf8char(c) ((c >= 0x20 && c <= 0xd7ff) || c == 0x09 || c == 0x0a || c == 0x0d || \
David Sedlák4a650532019-07-10 11:55:18 +020033 (c >= 0xe000 && c <= 0xfdcf) || (c >= 0xfdf0 && c <= 0xfffd) || \
34 (c >= 0x10000 && c <= 0x1fffd) || (c >= 0x20000 && c <= 0x2fffd) || \
35 (c >= 0x30000 && c <= 0x3fffd) || (c >= 0x40000 && c <= 0x2fffd) || \
36 (c >= 0x50000 && c <= 0x5fffd) || (c >= 0x60000 && c <= 0x6fffd) || \
37 (c >= 0x70000 && c <= 0x7fffd) || (c >= 0x80000 && c <= 0x8fffd) || \
38 (c >= 0x90000 && c <= 0x9fffd) || (c >= 0xa0000 && c <= 0xafffd) || \
39 (c >= 0xb0000 && c <= 0xbfffd) || (c >= 0xc0000 && c <= 0xcfffd) || \
40 (c >= 0xd0000 && c <= 0xdfffd) || (c >= 0xe0000 && c <= 0xefffd) || \
41 (c >= 0xf0000 && c <= 0xffffd) || (c >= 0x100000 && c <= 0x10fffd))
42
Radek Krejci70853c52018-10-15 14:46:16 +020043/**
David Sedlákca36c422019-07-12 12:47:55 +020044 * @brief Try to find object with MEMBER string matching the IDENT in the given ARRAY.
45 * Macro logs an error message and returns LY_EVALID in case of existence of a matching object.
46 *
47 * @param[in] CTX yang parser context for logging.
48 * @param[in] ARRAY [sized array](@ref sizedarrays) of a generic objects with member named MEMBER to search.
49 * @param[in] MEMBER Name of the member of the objects in the ARRAY to compare.
50 * @param[in] STMT Name of the compared YANG statements for logging.
51 * @param[in] IDENT String trying to find in the ARRAY's objects inside the MEMBER member.
52 */
53#define CHECK_UNIQUENESS(CTX, ARRAY, MEMBER, STMT, IDENT) \
54 if (ARRAY) { \
55 for (unsigned int u = 0; u < LY_ARRAY_SIZE(ARRAY) - 1; ++u) { \
56 if (!strcmp((ARRAY)[u].MEMBER, IDENT)) { \
57 LOGVAL_PARSER(CTX, LY_VCODE_DUPIDENT, IDENT, STMT); \
58 return LY_EVALID; \
59 } \
60 } \
61 }
62
David Sedlákb9b892c2019-07-12 14:44:02 +020063#define YANG_CHECK_NONEMPTY(CTX, VALUE_LEN, STMT) \
David Sedlák129a09c2019-07-12 14:08:34 +020064 if (!VALUE_LEN) { \
65 LOGWRN((CTX)->ctx, "Empty argument of %s statement does not make sense.", STMT); \
66 }
67
David Sedlákca36c422019-07-12 12:47:55 +020068/**
Radek Krejcie3846472018-10-15 15:24:51 +020069 * @brief List of YANG statement groups - the (sub)module's substatements
70 */
71enum yang_module_stmt {
72 Y_MOD_MODULE_HEADER,
73 Y_MOD_LINKAGE,
74 Y_MOD_META,
75 Y_MOD_REVISION,
76 Y_MOD_BODY
77};
78
79/**
80 * @brief Types of arguments of YANG statements
81 */
82enum yang_arg {
83 Y_IDENTIF_ARG, /**< YANG "identifier-arg-str" rule */
Radek Krejcia9026eb2018-12-12 16:04:47 +010084 Y_PREF_IDENTIF_ARG, /**< YANG "identifier-ref-arg-str" or node-identifier rule */
Radek Krejcie3846472018-10-15 15:24:51 +020085 Y_STR_ARG, /**< YANG "string" rule */
86 Y_MAYBE_STR_ARG /**< optional YANG "string" rule */
87};
88
89/**
David Sedlákebd3acf2019-07-26 15:04:32 +020090 * @brief Internal context for yang schema parser.
Radek Krejci70853c52018-10-15 14:46:16 +020091 */
Radek Krejcie7b95092019-05-15 11:03:07 +020092struct lys_parser_ctx {
David Sedlákebd3acf2019-07-26 15:04:32 +020093 struct ly_set tpdfs_nodes; /**< set of typedef nodes */
94 struct ly_set grps_nodes; /**< set of grouping nodes */
95 uint8_t mod_version; /**< module's version */
96 struct ly_ctx *ctx; /**< context of then yang schemas */
97 uint64_t line; /**< line number */
98 uint64_t indent; /**< current position on the line for YANG indentation */
Radek Krejci70853c52018-10-15 14:46:16 +020099};
100
David Sedlákebd3acf2019-07-26 15:04:32 +0200101/**
102 * @brief free lys parser context.
103 */
104void lys_parser_ctx_free(struct lys_parser_ctx *ctx);
105
106/**
107 * @brief Internal context for yin schema parser.
108 */
109struct yin_parser_ctx {
110 struct ly_set tpdfs_nodes; /**< set of typedef nodes */
111 struct ly_set grps_nodes; /**< set of grouping nodes */
112 uint8_t mod_version; /**< module's version */
113 struct lyxml_context xml_ctx; /**< context for xml parser */
114};
115
116/**
117 * @brief free yin parser context
118 *
119 * @param[in] ctx Context to free.
120 */
121void yin_parser_ctx_free(struct yin_parser_ctx *ctx);
122
Radek Krejci1c0c3442019-07-23 16:08:47 +0200123struct lysc_incomplete_dflt {
124 struct lyd_value *dflt;
125 struct lys_module *dflt_mod;
126 struct lysc_node *context_node;
127};
128
Radek Krejci70853c52018-10-15 14:46:16 +0200129/**
Radek Krejci4f28eda2018-11-12 11:46:16 +0100130 * @brief internal context for compilation
131 */
132struct lysc_ctx {
133 struct ly_ctx *ctx;
134 struct lys_module *mod;
Radek Krejci0af46292019-01-11 16:02:31 +0100135 struct lys_module *mod_def; /**< context module for the definitions of the nodes being currently
136 processed - groupings are supposed to be evaluated in place where
137 defined, but its content instances are supposed to be placed into
138 the target module (mod) */
139 struct ly_set groupings; /**< stack for groupings circular check */
140 struct ly_set unres; /**< to validate leafref's target and xpath of when/must */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200141 struct ly_set dflts; /**< set of incomplete default values */
Radek Krejci99b5b2a2019-04-30 16:57:04 +0200142 struct ly_set tpdf_chain;
Radek Krejci4f28eda2018-11-12 11:46:16 +0100143 uint16_t path_len;
Radek Krejciec4da802019-05-02 13:02:41 +0200144 int options; /**< various @ref scflags. */
Radek Krejci4f28eda2018-11-12 11:46:16 +0100145#define LYSC_CTX_BUFSIZE 4078
146 char path[LYSC_CTX_BUFSIZE];
Radek Krejci70853c52018-10-15 14:46:16 +0200147};
148
149/**
David Sedlák4a650532019-07-10 11:55:18 +0200150 * @brief Check that \p c is valid UTF8 code point for YANG string.
151 *
152 * @param[in] ctx yang parser context for logging.
153 * @param[in] c UTF8 code point of a character to check.
154 * @return LY_ERR values.
155 */
156LY_ERR lysp_check_stringchar(struct lys_parser_ctx *ctx, unsigned int c);
157
158/**
159 * @brief Check that \p c is valid UTF8 code point for YANG identifier.
160 *
161 * @param[in] ctx yang parser context for logging.
162 * @param[in] c UTF8 code point of a character to check.
163 * @param[in] first Flag to check the first character of an identifier, which is more restricted.
164 * @param[in,out] prefix Storage for internally used flag in case of possible prefixed identifiers:
165 * 0 - colon not yet found (no prefix)
166 * 1 - \p c is the colon character
167 * 2 - prefix already processed, now processing the identifier
168 *
169 * If the identifier cannot be prefixed, NULL is expected.
170 * @return LY_ERR values.
171 */
172LY_ERR lysp_check_identifierchar(struct lys_parser_ctx *ctx, unsigned int c, int first, int *prefix);
173
174/**
Radek Krejcia1911222019-07-22 17:24:50 +0200175 * @brief Internal structure for lys_get_prefix().
176 */
177struct lys_get_prefix_data {
178 const struct lys_module *context_mod;
179 struct ly_set prefixes;
180};
181
182/**
183 * @brief Schema mapping of YANG modules to prefixes in values.
184 *
185 * Implementation of ly_clb_get_prefix. Inverse function to lys_resolve_prefix.
186 *
187 * In this case the @p mod is searched in the list of imports and the import's prefix
188 * (not the module's itself) prefix is returned.
189 */
190const char *lys_get_prefix(const struct lys_module *mod, void *private);
191
192/**
193 * @brief Schema mapping of prefix in values to YANG modules (imports).
194 *
195 * Implementation of ly_clb_resolve_prefix. Inverse function to lys_get_prefix().
196 *
197 * In this case the @p prefix is searched in the list of imports' prefixes (not the prefixes of the imported modules themselves).
198 */
199const struct lys_module *lys_resolve_prefix(struct ly_ctx *ctx, const char *prefix, size_t prefix_len, void *private);
200
201/**
Radek Krejci70853c52018-10-15 14:46:16 +0200202 * @brief Check the currently present prefixes in the module for collision with the new one.
203 *
Radek Krejcibbe09a92018-11-08 09:36:54 +0100204 * @param[in] ctx Context for logging.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100205 * @param[in] imports List of current imports of the module to check prefix collision.
206 * @param[in] module_prefix Prefix of the module to check collision.
Radek Krejci70853c52018-10-15 14:46:16 +0200207 * @param[in] value Newly added prefix value (including its location to distinguish collision with itself).
208 * @return LY_EEXIST when prefix is already used in the module, LY_SUCCESS otherwise
209 */
Radek Krejcie7b95092019-05-15 11:03:07 +0200210LY_ERR lysp_check_prefix(struct lys_parser_ctx *ctx, struct lysp_import *imports, const char *module_prefix, const char **value);
Radek Krejci70853c52018-10-15 14:46:16 +0200211
Radek Krejci86d106e2018-10-18 09:53:19 +0200212/**
213 * @brief Check date string (4DIGIT "-" 2DIGIT "-" 2DIGIT)
214 *
Radek Krejcibbe09a92018-11-08 09:36:54 +0100215 * @param[in] ctx Optional context for logging.
Radek Krejci86d106e2018-10-18 09:53:19 +0200216 * @param[in] date Date string to check (non-necessarily terminated by \0)
217 * @param[in] date_len Length of the date string, 10 expected.
218 * @param[in] stmt Statement name for error message.
219 * @return LY_ERR value.
220 */
Radek Krejcie7b95092019-05-15 11:03:07 +0200221LY_ERR lysp_check_date(struct lys_parser_ctx *ctx, const char *date, int date_len, const char *stmt);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100222
223/**
224 * @brief Check names of typedefs in the parsed module to detect collisions.
225 *
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100226 * @param[in] ctx Parser context for logging and to maintain tpdfs_nodes
227 * @param[in] mod Module where the type is being defined.
Radek Krejcibbe09a92018-11-08 09:36:54 +0100228 * @return LY_ERR value.
229 */
Radek Krejcie7b95092019-05-15 11:03:07 +0200230LY_ERR lysp_check_typedefs(struct lys_parser_ctx *ctx, struct lysp_module *mod);
Radek Krejci86d106e2018-10-18 09:53:19 +0200231
232/**
David Sedlákd2ebe572019-07-22 12:53:14 +0200233 * @brief Finalize some of the structures in case they are stored in sized array,
234 * which can be possibly reallocated and some other data may point to them.
235 *
236 * Update parent pointers in the nodes inside grouping/augment/RPC/Notification, which could be reallocated.
237 *
238 * @param[in] mod Parsed module to be updated.
239 * @return LY_ERR value (currently only LY_SUCCESS, but it can change in future).
240 */
241LY_ERR
242lysp_parse_finalize_reallocated(struct lys_parser_ctx *ctx, struct lysp_grp *groupings, struct lysp_augment *augments,
243 struct lysp_action *actions, struct lysp_notif *notifs);
244
245/**
Radek Krejci86d106e2018-10-18 09:53:19 +0200246 * @brief Just move the newest revision into the first position, does not sort the rest
247 * @param[in] revs Sized-array of the revisions in a printable schema tree.
248 */
249void lysp_sort_revisions(struct lysp_revision *revs);
250
251/**
David Sedlák6544c182019-07-12 13:17:33 +0200252 * @brief Find type specified type definition.
Radek Krejcibbe09a92018-11-08 09:36:54 +0100253 *
254 * @param[in] id Name of the type including possible prefix. Module where the prefix is being searched is start_module.
255 * @param[in] start_node Context node where the type is being instantiated to be able to search typedefs in parents.
256 * @param[in] start_module Module where the type is being instantiated for search for typedefs.
Radek Krejci4f28eda2018-11-12 11:46:16 +0100257 * @param[out] type Built-in type identifier of the id. If #LY_TYPE_UNKNOWN, tpdf is expected to contain found YANG schema typedef statement.
Radek Krejcibbe09a92018-11-08 09:36:54 +0100258 * @param[out] tpdf Found type definition.
259 * @param[out] node Node where the found typedef is defined, NULL in case of a top-level typedef.
260 * @param[out] module Module where the found typedef is being defined, NULL in case of built-in YANG types.
261 */
262LY_ERR lysp_type_find(const char *id, struct lysp_node *start_node, struct lysp_module *start_module,
Radek Krejci4f28eda2018-11-12 11:46:16 +0100263 LY_DATA_TYPE *type, const struct lysp_tpdf **tpdf, struct lysp_node **node, struct lysp_module **module);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100264
265/**
David Sedlák6544c182019-07-12 13:17:33 +0200266 * @brief Validate enum name.
267 *
268 * @param[in] ctx yang parser context for logging.
269 * @param[in] name String to check.
270 * @param[in] name_len Length of name.
271 *
272 * @return LY_ERR values
273 */
David Sedlák07869a52019-07-12 14:28:19 +0200274LY_ERR lysp_check_enum_name(struct lys_parser_ctx *ctx, const char *name, size_t name_len);
David Sedlák6544c182019-07-12 13:17:33 +0200275
276/**
Radek Krejci086c7132018-10-26 15:29:04 +0200277 * @brief Find and parse module of the given name.
278 *
279 * @param[in] ctx libyang context.
280 * @param[in] name Name of the module to load.
281 * @param[in] revison Optional revision of the module to load. If NULL, the newest revision is loaded.
Radek Krejcied5acc52019-04-25 15:57:04 +0200282 * @param[in] implement Flag if the loaded module is supposed to be marked as implemented. If revision is NULL and implement flag set,
283 * the implemented module in the context is returned despite it might not be of the latest revision, because in this case the module
284 * of the latest revision can not be made implemented.
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100285 * @param[in] require_parsed Flag to require parsed module structure in case the module is already in the context,
286 * but only the compiled structure is available.
Radek Krejci086c7132018-10-26 15:29:04 +0200287 * @param[out] mod Parsed module structure.
288 * @return LY_ERR value.
289 */
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100290LY_ERR lysp_load_module(struct ly_ctx *ctx, const char *name, const char *revision, int implement, int require_parsed, struct lys_module **mod);
Radek Krejci086c7132018-10-26 15:29:04 +0200291
292/**
Radek Krejcid33273d2018-10-25 14:55:52 +0200293 * @brief Parse included submodule into the simply parsed YANG module.
294 *
Radek Krejci3b1f9292018-11-08 10:58:35 +0100295 * @param[in] ctx parser context
Radek Krejcid33273d2018-10-25 14:55:52 +0200296 * @param[in] mod Module including a submodule.
Radek Krejcid33273d2018-10-25 14:55:52 +0200297 * @param[in,out] inc Include structure holding all available information about the include statement, the parsed
298 * submodule is stored into this structure.
299 * @return LY_ERR value.
300 */
Radek Krejcie7b95092019-05-15 11:03:07 +0200301LY_ERR lysp_load_submodule(struct lys_parser_ctx *ctx, struct lysp_module *mod, struct lysp_include *inc);
Radek Krejcid33273d2018-10-25 14:55:52 +0200302
303/**
Radek Krejci096235c2019-01-11 11:12:19 +0100304 * @defgroup scflags Schema compile flags
305 * @ingroup schematree
306 *
307 * @{
308 */
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100309#define LYSC_OPT_RPC_INPUT LYS_CONFIG_W /**< Internal option when compiling schema tree of RPC/action input */
310#define LYSC_OPT_RPC_OUTPUT LYS_CONFIG_R /**< Internal option when compiling schema tree of RPC/action output */
Radek Krejcifc11bd72019-04-11 16:00:05 +0200311#define LYSC_OPT_RPC_MASK LYS_CONFIG_MASK /**< mask for the internal RPC options */
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100312#define LYSC_OPT_FREE_SP 0x04 /**< Free the input printable schema */
313#define LYSC_OPT_INTERNAL 0x08 /**< Internal compilation caused by dependency */
314#define LYSC_OPT_NOTIFICATION 0x10 /**< Internal option when compiling schema tree of Notification */
Radek Krejcif2de0ed2019-05-02 14:13:18 +0200315
316#define LYSC_OPT_GROUPING 0x20 /** Compiling (validation) of a non-instantiated grouping.
317 In this case not all the restrictions are checked since they can be valid only
318 in the real placement of the grouping. TODO - what specifically is not done */
Radek Krejci096235c2019-01-11 11:12:19 +0100319/** @} scflags */
320
321/**
322 * @brief Compile printable schema into a validated schema linking all the references.
323 *
324 * @param[in, out] mod Schema structure holding pointers to both schema structure types. The ::lys_module#parsed
325 * member is used as input and ::lys_module#compiled is used to hold the result of the compilation.
326 * @param[in] options Various options to modify compiler behavior, see [compile flags](@ref scflags).
327 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
328 */
329LY_ERR lys_compile(struct lys_module *mod, int options);
330
331/**
Radek Krejcibbe09a92018-11-08 09:36:54 +0100332 * @brief Get address of a node's actions list if any.
333 *
334 * Decides the node's type and in case it has an actions list, returns its address.
335 * @param[in] node Node to check.
336 * @return Address of the node's actions member if any, NULL otherwise.
337 */
Radek Krejci056d0a82018-12-06 16:57:25 +0100338struct lysp_action **lysp_node_actions_p(struct lysp_node *node);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100339
340/**
341 * @brief Get address of a node's notifications list if any.
342 *
343 * Decides the node's type and in case it has a notifications list, returns its address.
344 * @param[in] node Node to check.
345 * @return Address of the node's notifs member if any, NULL otherwise.
346 */
Radek Krejci056d0a82018-12-06 16:57:25 +0100347struct lysp_notif **lysp_node_notifs_p(struct lysp_node *node);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100348
349/**
350 * @brief Get address of a node's child pointer if any.
351 *
352 * Decides the node's type and in case it has a children list, returns its address.
353 * @param[in] node Node to check.
354 * @return Address of the node's child member if any, NULL otherwise.
355 */
Radek Krejci056d0a82018-12-06 16:57:25 +0100356struct lysp_node **lysp_node_children_p(struct lysp_node *node);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100357
358/**
359 * @brief Get address of a node's child pointer if any.
360 *
361 * Decides the node's type and in case it has a children list, returns its address.
362 * @param[in] node Node to check.
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100363 * @param[in] flags Config flag to distinguish input (LYS_CONFIG_W) and output (LYS_CONFIG_R) data in case of RPC/action node.
Radek Krejcibbe09a92018-11-08 09:36:54 +0100364 * @return Address of the node's child member if any, NULL otherwise.
365 */
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100366struct lysc_node **lysc_node_children_p(const struct lysc_node *node, uint16_t flags);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100367
368/**
Radek Krejcifc11bd72019-04-11 16:00:05 +0200369 * @brief Get address of a node's notifs pointer if any.
370 *
371 * Decides the node's type and in case it has a notifs array, returns its address.
372 * @param[in] node Node to check.
373 * @return Address of the node's notifs member if any, NULL otherwise.
374 */
375struct lysc_notif **lysc_node_notifs_p(struct lysc_node *node);
376
377/**
378 * @brief Get address of a node's actions pointer if any.
379 *
380 * Decides the node's type and in case it has a actions array, returns its address.
381 * @param[in] node Node to check.
382 * @return Address of the node's actions member if any, NULL otherwise.
383 */
384struct lysc_action **lysc_node_actions_p(struct lysc_node *node);
385
386/**
Radek Krejcid3ca0632019-04-16 16:54:54 +0200387 * @brief Iterate over the specified type of the extension instances
388 *
389 * @param[in] ext ([Sized array](@ref sizedarrays)) of extensions to explore
390 * @param[in] index Index in the \p ext array where to start searching (first call with 0, the consequent calls with
391 * the returned index increased by 1 (until the iteration is not terminated by returning LY_ARRAY_SIZE(ext).
392 * @param[in] substmt Type of the extension (its belongins to the specific substatement) to iterate, use
393 * #LYEXT_SUBSTMT_ALL to go through all the extensions in the array
394 * @result index in the ext array, LY_ARRAY_SIZE(ext) value if not present.
395 */
396unsigned int lysp_ext_instance_iter(struct lysp_ext_instance *ext, unsigned int index, LYEXT_SUBSTMT substmt);
397
398/**
Radek Krejci96a0bfd2018-11-22 15:25:06 +0100399 * @brief Get the covering schema module structure for the given parsed module structure.
400 * @param[in] ctx libyang context to search.
401 * @param[in] mod Parsed schema structure.
402 * @return Corresponding lys_module structure for the given parsed schema structure.
403 */
404struct lys_module *lysp_find_module(struct ly_ctx *ctx, const struct lysp_module *mod);
405
406/**
Radek Krejcice8c1592018-10-29 15:35:51 +0100407 * @brief Find the module referenced by prefix in the provided parsed mod.
408 *
409 * @param[in] mod Schema module where the prefix was used.
410 * @param[in] prefix Prefix used to reference a module.
411 * @param[in] len Length of the prefix since it is not necessary NULL-terminated.
412 * @return Pointer to the module or NULL if the module is not found.
413 */
Radek Krejcia3045382018-11-22 14:30:31 +0100414struct lysp_module *lysp_module_find_prefix(const struct lysp_module *mod, const char *prefix, size_t len);
Radek Krejcice8c1592018-10-29 15:35:51 +0100415
416/**
417 * @brief Find the module referenced by prefix in the provided compiled mod.
418 *
419 * @param[in] mod Schema module where the prefix was used.
420 * @param[in] prefix Prefix used to reference a module.
421 * @param[in] len Length of the prefix since it is not necessary NULL-terminated.
422 * @return Pointer to the module or NULL if the module is not found.
423 */
Radek Krejcia3045382018-11-22 14:30:31 +0100424struct lysc_module *lysc_module_find_prefix(const struct lysc_module *mod, const char *prefix, size_t len);
Radek Krejcice8c1592018-10-29 15:35:51 +0100425
426/**
Radek Krejci4f28eda2018-11-12 11:46:16 +0100427 * @brief Check statement's status for invalid combination.
428 *
429 * The modX parameters are used just to determine if both flags are in the same module,
430 * so any of the schema module structure can be used, but both modules must be provided
431 * in the same type.
432 *
433 * @param[in] ctx Compile context for logging.
434 * @param[in] flags1 Flags of the referencing node.
435 * @param[in] mod1 Module of the referencing node,
436 * @param[in] name1 Schema node name of the referencing node.
437 * @param[in] flags2 Flags of the referenced node.
438 * @param[in] mod2 Module of the referenced node,
439 * @param[in] name2 Schema node name of the referenced node.
440 * @return LY_ERR value
441 */
442LY_ERR lysc_check_status(struct lysc_ctx *ctx,
443 uint16_t flags1, void *mod1, const char *name1,
444 uint16_t flags2, void *mod2, const char *name2);
445
446/**
Radek Krejci95710c92019-02-11 15:49:55 +0100447 * @brief Find the node according to the given descendant/absolute schema nodeid.
448 * Used in unique, refine and augment statements.
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100449 *
450 * @param[in] ctx Compile context
451 * @param[in] nodeid Descendant-schema-nodeid (according to the YANG grammar)
452 * @param[in] nodeid_len Length of the given nodeid, if it is not NULL-terminated string.
453 * @param[in] context_node Node where the nodeid is specified to correctly resolve prefixes and to start searching.
Radek Krejci7af64242019-02-18 13:07:53 +0100454 * If no context node is provided, the nodeid is actually expected to be the absolute schema node .
455 * @param[in] context_module Explicit module to resolve prefixes in @nodeid.
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100456 * @param[in] nodetype Optional (can be 0) restriction for target's nodetype. If target exists, but does not match
Radek Krejci95710c92019-02-11 15:49:55 +0100457 * the given nodetype, LY_EDENIED is returned (and target is provided), but no error message is printed.
458 * The value can be even an ORed value to allow multiple nodetypes.
459 * @param[in] implement Flag if the modules mentioned in the nodeid are supposed to be made implemented.
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100460 * @param[out] target Found target node if any. In case of RPC/action input/output node, LYS_ACTION node is actually returned
461 * since the input/output has not a standalone node structure and it is part of ::lysc_action which is better compatible with ::lysc_node.
462 * @param[out] result_flag Output parameter to announce if the schema nodeid goes through the action's input/output or a Notification.
463 * The LYSC_OPT_RPC_INPUT, LYSC_OPT_RPC_OUTPUT and LYSC_OPT_NOTIFICATION are used as flags.
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100464 * @return LY_ERR values - LY_ENOTFOUND, LY_EVALID, LY_EDENIED or LY_SUCCESS.
465 */
Radek Krejci95710c92019-02-11 15:49:55 +0100466LY_ERR lys_resolve_schema_nodeid(struct lysc_ctx *ctx, const char *nodeid, size_t nodeid_len, const struct lysc_node *context_node,
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100467 const struct lys_module *context_module, int nodetype, int implement,
468 const struct lysc_node **target, uint16_t *result_flag);
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100469
470/**
Radek Krejci151a5b72018-10-19 14:21:44 +0200471 * @brief Find the module referenced by prefix in the provided mod.
472 *
Radek Krejci693262f2019-04-29 15:23:20 +0200473 * Reverse function to lys_prefix_find_module().
474 *
Radek Krejci151a5b72018-10-19 14:21:44 +0200475 * @param[in] mod Schema module where the prefix was used.
476 * @param[in] prefix Prefix used to reference a module.
477 * @param[in] len Length of the prefix since it is not necessary NULL-terminated.
478 * @return Pointer to the module or NULL if the module is not found.
479 */
Radek Krejcia3045382018-11-22 14:30:31 +0100480struct lys_module *lys_module_find_prefix(const struct lys_module *mod, const char *prefix, size_t len);
481
482/**
Radek Krejci693262f2019-04-29 15:23:20 +0200483 * @brief Find the prefix used to referenced the import module in the provided mod.
484 *
485 * Reverse function to lys_module_find_prefix().
486 *
487 * Note that original prefixes are present only in the parsed schema. In case it is not available
488 * (only compiled schema available), the own prefix of the import module is returned instead.
489 *
490 * @param[in] mod Schema module where the import module was used.
491 * @param[in] import Module referenced in mod.
492 * @return Prefix of the import module.
493 */
494const char *lys_prefix_find_module(const struct lys_module *mod, const struct lys_module *import);
495
496/**
Radek Krejcia3045382018-11-22 14:30:31 +0100497 * @brief Stringify schema nodetype.
498 * @param[in] nodetype Nodetype to stringify.
499 * @return Constant string with the name of the node's type.
500 */
501const char *lys_nodetype2str(uint16_t nodetype);
Radek Krejci151a5b72018-10-19 14:21:44 +0200502
503/**
Radek Krejci693262f2019-04-29 15:23:20 +0200504 * @brief Stringify YANG built-in type.
505 * @param[in] basetype Built-in tyep ID to stringify.
506 * @return Constant string with the name of the built-in type.
507 */
508const char *lys_datatype2str(LY_DATA_TYPE basetype);
509
510/**
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100511 * @brief Parse YANG module from a string.
Radek Krejcid33273d2018-10-25 14:55:52 +0200512 *
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100513 * The modules are added into the context and the latest_revision flag is updated.
Radek Krejcid33273d2018-10-25 14:55:52 +0200514 *
515 * @param[in] ctx libyang context where to process the data model.
516 * @param[in] data The string containing the dumped data model in the specified
517 * format.
518 * @param[in] format Format of the input data (YANG or YIN).
Radek Krejcid33273d2018-10-25 14:55:52 +0200519 * @param[in] implement Flag if the schema is supposed to be marked as implemented.
Radek Krejci9ed7a192018-10-31 16:23:51 +0100520 * @param[in] custom_check Callback to check the parsed schema before it is accepted.
521 * @param[in] check_data Caller's data to pass to the custom_check callback.
Radek Krejcid33273d2018-10-25 14:55:52 +0200522 * @return Pointer to the data model structure or NULL on error.
523 */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100524struct lys_module *lys_parse_mem_module(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, int implement,
525 LY_ERR (*custom_check)(struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *check_data),
526 void *check_data);
Radek Krejcid33273d2018-10-25 14:55:52 +0200527
528/**
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100529 * @brief Parse YANG submodule from a string.
Radek Krejcid33273d2018-10-25 14:55:52 +0200530 *
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100531 * The latest_revision flag of submodule is updated.
532 *
533 * @param[in] ctx libyang context where to process the data model.
534 * @param[in] data The string containing the dumped data model in the specified
535 * format.
536 * @param[in] format Format of the input data (YANG or YIN).
537 * @param[in] main_ctx Parser context of the main module.
538 * @param[in] custom_check Callback to check the parsed schema before it is accepted.
539 * @param[in] check_data Caller's data to pass to the custom_check callback.
540 * @return Pointer to the data model structure or NULL on error.
541 */
Radek Krejcie7b95092019-05-15 11:03:07 +0200542struct lysp_submodule *lys_parse_mem_submodule(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, struct lys_parser_ctx *main_ctx,
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100543 LY_ERR (*custom_check)(struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *check_data),
544 void *check_data);
545
546/**
547 * @brief Parse YANG module or submodule from a file descriptor.
548 *
549 * The modules are added into the context, submodules not. The latest_revision flag is updated in both cases.
Radek Krejcid33273d2018-10-25 14:55:52 +0200550 *
551 * \note Current implementation supports only reading data from standard (disk) file, not from sockets, pipes, etc.
552 *
553 * @param[in] ctx libyang context where to process the data model.
554 * @param[in] fd File descriptor of a regular file (e.g. sockets are not supported) containing the schema
555 * in the specified format.
556 * @param[in] format Format of the input data (YANG or YIN).
Radek Krejcid33273d2018-10-25 14:55:52 +0200557 * @param[in] implement Flag if the schema is supposed to be marked as implemented.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100558 * @param[in] main_ctx Parser context of the main module in case of parsing submodule. This flag decides if the module
559 * or submodule was expected to be parsed.
Radek Krejci9ed7a192018-10-31 16:23:51 +0100560 * @param[in] custom_check Callback to check the parsed schema before it is accepted.
561 * @param[in] check_data Caller's data to pass to the custom_check callback.
Radek Krejcid33273d2018-10-25 14:55:52 +0200562 * @return Pointer to the data model structure or NULL on error.
563 */
Radek Krejcie7b95092019-05-15 11:03:07 +0200564void *lys_parse_fd_(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, int implement, struct lys_parser_ctx *main_ctx,
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100565 LY_ERR (*custom_check)(struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *data),
566 void *check_data);
Radek Krejcid33273d2018-10-25 14:55:52 +0200567
568/**
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100569 * @brief Parse YANG module from a file descriptor.
Radek Krejcid33273d2018-10-25 14:55:52 +0200570 *
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100571 * The modules are added into the context. The latest_revision flag is updated.
Radek Krejcid33273d2018-10-25 14:55:52 +0200572 *
573 * \note Current implementation supports only reading data from standard (disk) file, not from sockets, pipes, etc.
574 *
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100575 * @param[in] ctx libyang context where to process the data model.
576 * @param[in] fd File descriptor of a regular file (e.g. sockets are not supported) containing the schema
577 * in the specified format.
578 * @param[in] format Format of the input data (YANG or YIN).
579 * @param[in] implement Flag if the schema is supposed to be marked as implemented.
580 * @param[in] custom_check Callback to check the parsed schema before it is accepted.
581 * @param[in] check_data Caller's data to pass to the custom_check callback.
582 * @return Pointer to the data model structure or NULL on error.
583 */
584struct lys_module *lys_parse_fd_module(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, int implement,
585 LY_ERR (*custom_check)(struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *check_data),
586 void *check_data);
587
588/**
589 * @brief Parse YANG submodule from a file descriptor.
590 *
591 * The latest_revision flag of submodules is updated.
592 *
593 * \note Current implementation supports only reading data from standard (disk) file, not from sockets, pipes, etc.
594 *
595 * @param[in] ctx libyang context where to process the data model.
596 * @param[in] fd File descriptor of a regular file (e.g. sockets are not supported) containing the schema
597 * in the specified format.
598 * @param[in] format Format of the input data (YANG or YIN).
599 * @param[in] main_ctx Parser context of the main module.
600 * @param[in] custom_check Callback to check the parsed schema before it is accepted.
601 * @param[in] check_data Caller's data to pass to the custom_check callback.
602 * @return Pointer to the data model structure or NULL on error.
603 */
Radek Krejcie7b95092019-05-15 11:03:07 +0200604struct lysp_submodule *lys_parse_fd_submodule(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, struct lys_parser_ctx *main_ctx,
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100605 LY_ERR (*custom_check)(struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *check_data),
606 void *check_data);
607
608/**
609 * @brief Parse YANG module from a filepath.
610 *
611 * The modules are added into the context. The latest_revision flag is updated.
612 *
613 * \note Current implementation supports only reading data from standard (disk) file, not from sockets, pipes, etc.
Radek Krejcid33273d2018-10-25 14:55:52 +0200614 *
615 * @param[in] ctx libyang context where to process the data model.
616 * @param[in] path Path to the file with the model in the specified format.
617 * @param[in] format Format of the input data (YANG or YIN).
Radek Krejcid33273d2018-10-25 14:55:52 +0200618 * @param[in] implement Flag if the schema is supposed to be marked as implemented.
Radek Krejci9ed7a192018-10-31 16:23:51 +0100619 * @param[in] custom_check Callback to check the parsed schema before it is accepted.
620 * @param[in] check_data Caller's data to pass to the custom_check callback.
Radek Krejcid33273d2018-10-25 14:55:52 +0200621 * @return Pointer to the data model structure or NULL on error.
622 */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100623struct lys_module *lys_parse_path_(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format, int implement,
624 LY_ERR (*custom_check)(struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *data),
625 void *check_data);
Radek Krejcid33273d2018-10-25 14:55:52 +0200626
627/**
628 * @brief Load the (sub)module into the context.
629 *
630 * This function does not check the presence of the (sub)module in context, it should be done before calling this function.
631 *
632 * module_name and submodule_name are alternatives - only one of the
633 *
634 * @param[in] ctx libyang context where to work.
635 * @param[in] name Name of the (sub)module to load.
636 * @param[in] revision Optional revision of the (sub)module to load, if NULL the newest revision is being loaded.
637 * @param[in] implement Flag if the (sub)module is supposed to be marked as implemented.
Radek Krejci3b1f9292018-11-08 10:58:35 +0100638 * @param[in] main_ctx Parser context of the main module in case of loading submodule.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100639 * @param[out] result Parsed YANG schema tree of the requested module (struct lys_module*) or submodule (struct lysp_submodule*).
640 * If it is a module, it is already in the context!
Radek Krejcid33273d2018-10-25 14:55:52 +0200641 * @return LY_ERR value, in case of LY_SUCCESS, the \arg result is always provided.
642 */
Radek Krejcie7b95092019-05-15 11:03:07 +0200643LY_ERR lys_module_localfile(struct ly_ctx *ctx, const char *name, const char *revision, int implement, struct lys_parser_ctx *main_ctx,
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100644 void **result);
Radek Krejci086c7132018-10-26 15:29:04 +0200645
646/**
Radek Krejci0af46292019-01-11 16:02:31 +0100647 * @brief Create pre-compiled features array.
648 *
649 * Features are compiled in two steps to allow forward references between them via their if-feature statements.
650 * In case of not implemented schemas, the precompiled list of features is stored in lys_module structure and
651 * the compilation is not finished (if-feature and extensions are missing) and all the features are permanently
652 * disabled without a chance to change it. The list is used as target for any if-feature statement in any
653 * implemented module to get valid data to evaluate its result. The compilation is finished via
654 * lys_feature_precompile_finish() in implemented modules. In case a not implemented module becomes implemented,
655 * the precompiled list is reused to finish the compilation to preserve pointers already used in various compiled
656 * if-feature structures.
657 *
Radek Krejci327de162019-06-14 12:52:07 +0200658 * @param[in] ctx_sc Compile context - alternative to the combination of @p ctx and @p module.
Radek Krejci0af46292019-01-11 16:02:31 +0100659 * @param[in] ctx libyang context.
Radek Krejci693262f2019-04-29 15:23:20 +0200660 * @param[in] module Module of the features.
Radek Krejci0af46292019-01-11 16:02:31 +0100661 * @param[in] features_p Array if the parsed features definitions to precompile.
662 * @param[in,out] features Pointer to the storage of the (pre)compiled features array where the new features are
663 * supposed to be added. The storage is supposed to be initiated to NULL when the first parsed features are going
664 * to be processed.
665 * @return LY_ERR value.
Radek Krejci086c7132018-10-26 15:29:04 +0200666 */
Radek Krejci327de162019-06-14 12:52:07 +0200667LY_ERR lys_feature_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lys_module *module, struct lysp_feature *features_p, struct lysc_feature **features);
Radek Krejci693262f2019-04-29 15:23:20 +0200668
669/**
670 * @brief Get the @ref ifftokens from the given position in the 2bits array
671 * (libyang format of the if-feature expression).
672 * @param[in] list The 2bits array with the compiled if-feature expression.
673 * @param[in] pos Position (0-based) to specify from which position get the operator.
674 */
675uint8_t lysc_iff_getop(uint8_t *list, int pos);
Radek Krejci0af46292019-01-11 16:02:31 +0100676
677/**
Radek Krejcifc11bd72019-04-11 16:00:05 +0200678 * @brief Macro to free [sized array](@ref sizedarrays) of items using the provided free function. The ARRAY itself is also freed,
679 * but the memory is not sanitized.
680 */
681#define FREE_ARRAY(CTX, ARRAY, FUNC) {uint64_t c__; LY_ARRAY_FOR(ARRAY, c__){FUNC(CTX, &(ARRAY)[c__]);}LY_ARRAY_FREE(ARRAY);}
682
683/**
684 * @brief Macro to free the specified MEMBER of a structure using the provided free function. The memory is not sanitized.
685 */
686#define FREE_MEMBER(CTX, MEMBER, FUNC) if (MEMBER) {FUNC(CTX, MEMBER);free(MEMBER);}
687
688/**
689 * @brief Macro to free [sized array](@ref sizedarrays) of strings stored in the context's dictionary. The ARRAY itself is also freed,
690 * but the memory is not sanitized.
691 */
692#define FREE_STRINGS(CTX, ARRAY) {uint64_t c__; LY_ARRAY_FOR(ARRAY, c__){FREE_STRING(CTX, ARRAY[c__]);}LY_ARRAY_FREE(ARRAY);}
Radek Krejci086c7132018-10-26 15:29:04 +0200693
694/**
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100695 * @brief Free the parsed submodule structure.
696 * @param[in] ctx libyang context where the string data resides in a dictionary.
697 * @param[in,out] submod Parsed schema submodule structure to free.
Radek Krejci086c7132018-10-26 15:29:04 +0200698 */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100699void lysp_submodule_free(struct ly_ctx *ctx, struct lysp_submodule *submod);
Radek Krejci086c7132018-10-26 15:29:04 +0200700
Radek Krejcid33273d2018-10-25 14:55:52 +0200701/**
Radek Krejcicdfecd92018-11-26 11:27:32 +0100702 * @brief Free the compiled type structure.
703 * @param[in] ctx libyang context where the string data resides in a dictionary.
704 * @param[in,out] type Compiled type structure to be freed. The structure has refcount, so it is freed only in case the value is decreased to 0.
705 */
706void lysc_type_free(struct ly_ctx *ctx, struct lysc_type *type);
707
708/**
Radek Krejci0af46292019-01-11 16:02:31 +0100709 * @brief Free the compiled if-feature structure.
710 * @param[in] ctx libyang context where the string data resides in a dictionary.
711 * @param[in,out] iff Compiled if-feature structure to be cleaned.
712 * Since the structure is typically part of the sized array, the structure itself is not freed.
713 */
714void lysc_iffeature_free(struct ly_ctx *ctx, struct lysc_iffeature *iff);
715
716/**
Radek Krejciccd20f12019-02-15 14:12:27 +0100717 * @brief Free the compiled must structure.
718 * @param[in] ctx libyang context where the string data resides in a dictionary.
719 * @param[in,out] must Compiled must structure to be cleaned.
720 * Since the structure is typically part of the sized array, the structure itself is not freed.
721 */
722void lysc_must_free(struct ly_ctx *ctx, struct lysc_must *must);
723
724/**
Radek Krejcif538ce52019-03-05 10:46:14 +0100725 * @brief Free the data inside compiled input/output structure.
726 * @param[in] ctx libyang context where the string data resides in a dictionary.
727 * @param[in,out] inout Compiled inout structure to be cleaned.
728 * Since the structure is part of the RPC/action structure, it is not freed itself.
729 */
730void lysc_action_inout_free(struct ly_ctx *ctx, struct lysc_action_inout *inout);
731
732/**
733 * @brief Free the data inside compiled RPC/action structure.
734 * @param[in] ctx libyang context where the string data resides in a dictionary.
735 * @param[in,out] action Compiled action structure to be cleaned.
736 * Since the structure is typically part of the sized array, the structure itself is not freed.
737 */
738void lysc_action_free(struct ly_ctx *ctx, struct lysc_action *action);
739
740/**
Radek Krejcifc11bd72019-04-11 16:00:05 +0200741 * @brief Free the items inside the compiled Notification structure.
742 * @param[in] ctx libyang context where the string data resides in a dictionary.
743 * @param[in,out] action Compiled Notification structure to be cleaned.
744 * Since the structure is typically part of the sized array, the structure itself is not freed.
745 */
746void lysc_notif_free(struct ly_ctx *ctx, struct lysc_notif *notif);
747
748/**
Radek Krejci0af46292019-01-11 16:02:31 +0100749 * @brief Free the compiled extension instance structure.
750 * @param[in] ctx libyang context where the string data resides in a dictionary.
751 * @param[in,out] ext Compiled extension instance structure to be cleaned.
752 * Since the structure is typically part of the sized array, the structure itself is not freed.
753 */
754void lysc_ext_instance_free(struct ly_ctx *ctx, struct lysc_ext_instance *ext);
755
756/**
Radek Krejci19a96102018-11-15 13:38:09 +0100757 * @brief Free the compiled node structure.
758 * @param[in] ctx libyang context where the string data resides in a dictionary.
759 * @param[in,out] node Compiled node structure to be freed.
760 */
761void lysc_node_free(struct ly_ctx *ctx, struct lysc_node *node);
762
763/**
Radek Krejcif2de0ed2019-05-02 14:13:18 +0200764 * @brief Free the compiled container node structure.
765 *
766 * Only the container-specific members are freed, for generic node free function,
767 * use lysc_node_free().
768 *
769 * @param[in] ctx libyang context where the string data resides in a dictionary.
770 * @param[in,out] node Compiled container node structure to be freed.
771 */
772void lysc_node_container_free(struct ly_ctx *ctx, struct lysc_node_container *node);
773
774/**
Radek Krejci19a96102018-11-15 13:38:09 +0100775 * @brief Free the compiled schema structure.
776 * @param[in,out] module Compiled schema module structure to free.
777 * @param[in] private_destructor Function to remove private data from the compiled schema tree.
778 */
779void lysc_module_free(struct lysc_module *module, void (*private_destructor)(const struct lysc_node *node, void *priv));
Radek Krejci86d106e2018-10-18 09:53:19 +0200780
781/**
782 * @brief Free the schema structure. It just frees, it does not remove the schema from its context.
Radek Krejci70853c52018-10-15 14:46:16 +0200783 * @param[in,out] module Schema module structure to free.
784 * @param[in] private_destructor Function to remove private data from the compiled schema tree.
785 */
786void lys_module_free(struct lys_module *module, void (*private_destructor)(const struct lysc_node *node, void *priv));
787
788/**
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100789 * @brief Parse submodule from YANG data.
David Sedlák1b623122019-08-05 15:27:49 +0200790 * @param[in,out] ctx Parser context.
791 * @param[in] ly_ctx Context of YANG schemas.
792 * @param[in] main_ctx Parser context of main module.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100793 * @param[in] data Input data to be parsed.
794 * @param[out] submod Pointer to the parsed submodule structure.
795 * @return LY_ERR value - LY_SUCCESS, LY_EINVAL or LY_EVALID.
Radek Krejci70853c52018-10-15 14:46:16 +0200796 */
David Sedlák1b623122019-08-05 15:27:49 +0200797LY_ERR yang_parse_submodule(struct lys_parser_ctx **context, struct ly_ctx *ly_ctx, struct lys_parser_ctx *main_ctx,
798 const char *data, struct lysp_submodule **submod);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100799
800/**
801 * @brief Parse module from YANG data.
802 * @param[in] ctx Parser context.
803 * @param[in] data Input data to be parsed.
804 * @param[in, out] mod Prepared module structure where the parsed information, including the parsed
805 * module structure, will be filled in.
806 * @return LY_ERR value - LY_SUCCESS, LY_EINVAL or LY_EVALID.
807 */
David Sedlák1b623122019-08-05 15:27:49 +0200808LY_ERR yang_parse_module(struct lys_parser_ctx **context, const char *data, struct lys_module *mod);
Radek Krejci70853c52018-10-15 14:46:16 +0200809
Radek Krejci95710c92019-02-11 15:49:55 +0100810/**
David Sedlákecf5eb82019-06-03 14:12:44 +0200811 * @brief Parse module from YIN data.
David Sedlák8985a142019-07-31 16:43:06 +0200812 *
813 * @param[in,out] yin_ctx Context created during parsing, is used to finalize lysp_model after it's completly parsed.
David Sedlákecf5eb82019-06-03 14:12:44 +0200814 * @param[in] data Input data to be parsed.
David Sedlákb666bcc2019-06-05 15:00:05 +0200815 * @param[in,out] mod Prepared module structure where the parsed information, including the parsed
David Sedlákecf5eb82019-06-03 14:12:44 +0200816 * module structure, will be filled in.
David Sedlák8985a142019-07-31 16:43:06 +0200817 *
David Sedlák68826732019-06-05 10:50:58 +0200818 * @return LY_ERR values.
David Sedlákecf5eb82019-06-03 14:12:44 +0200819 */
David Sedlák8985a142019-07-31 16:43:06 +0200820LY_ERR yin_parse_module(struct yin_parser_ctx **yin_ctx, const char *data, struct lys_module *mod);
821
822/**
823 * @brief Parse submodule from YIN data.
824 *
825 * @param[in,out] yin_ctx Context created during parsing, is used to finalize lysp_model after it's completly parsed.
826 * @param[in] ctx Libyang context.
David Sedlák1b623122019-08-05 15:27:49 +0200827 * @param[in] main_ctx Parser context of main module.
828 * @param[in,out] data Input data to be parsed.
829 * @param[in,out] submod Submodule structure where the parsed information, will be filled in.
David Sedlák8985a142019-07-31 16:43:06 +0200830 *
831 * @return LY_ERR values.
832 */
David Sedlák1b623122019-08-05 15:27:49 +0200833LY_ERR yin_parse_submodule(struct yin_parser_ctx **yin_ctx, struct ly_ctx *ctx, struct lys_parser_ctx *main_ctx,
David Sedlák8985a142019-07-31 16:43:06 +0200834 const char *data, struct lysp_submodule **submod);
Radek Krejci70853c52018-10-15 14:46:16 +0200835
David Sedlák1b623122019-08-05 15:27:49 +0200836
Radek Krejci95710c92019-02-11 15:49:55 +0100837/**
838 * @brief Make the specific module implemented, use the provided value as flag.
839 *
840 * @param[in] ctx libyang context to change.
841 * @param[in] mod Module from the given context to make implemented. It is not an error
842 * to provide already implemented module, it just does nothing.
843 * @param[in] implemented Flag value for the ::lys_module#implemented item.
844 * @return LY_SUCCESS or LY_EDENIED in case the context contains some other revision of the
845 * same module which is already implemented.
846 */
847LY_ERR ly_ctx_module_implement_internal(struct ly_ctx *ctx, struct lys_module *mod, uint8_t implemented);
Radek Krejci70853c52018-10-15 14:46:16 +0200848
David Sedlák18e494b2018-12-17 03:58:39 +0100849/**
850 * @brief match yang keyword
David Sedlák1bccdfa2019-06-17 15:55:27 +0200851 *
852 * param[in] ctx yang parser context for logging, can be NULL if keyword is from YIN data.
853 * param[in,out] data Data to read from, always moved to currently handled character.
854 *
855 * return yang_keyword values.
David Sedlák18e494b2018-12-17 03:58:39 +0100856 */
David Sedlák5f8f0332019-06-18 16:34:30 +0200857enum yang_keyword lysp_match_kw(struct lys_parser_ctx *ctx, const char **data);
David Sedlák1bccdfa2019-06-17 15:55:27 +0200858
Radek Krejci70853c52018-10-15 14:46:16 +0200859#endif /* LY_TREE_SCHEMA_INTERNAL_H_ */