blob: 880a297d7d8b9f86554b845d894633ef6441e27d [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
Radek Krejci535ea9f2020-05-29 16:01:05 +020020#include "common.h"
Radek Krejci2d7a47b2019-05-16 13:34:10 +020021#include "set.h"
22#include "tree_schema.h"
David Sedlákebd3acf2019-07-26 15:04:32 +020023#include "xml.h"
Radek Krejci2d7a47b2019-05-16 13:34:10 +020024
FredGand944bdc2019-11-05 21:57:07 +080025#define YIN_NS_URI "urn:ietf:params:xml:ns:yang:yin:1"
26
Radek Krejci335332a2019-09-05 13:03:35 +020027/**
28 * @brief Check module version is at least 2 (YANG 1.1) because of the keyword presence.
29 * Logs error message and returns LY_EVALID in case of module in YANG version 1.0.
30 * @param[in] CTX yang parser context to get current module and for logging.
31 * @param[in] KW keyword allowed only in YANG version 1.1 (or later) - for logging.
32 * @param[in] PARENT parent statement where the KW is present - for logging.
33 */
34#define PARSER_CHECK_STMTVER2_RET(CTX, KW, PARENT) \
35 if ((CTX)->mod_version < 2) {LOGVAL_PARSER((CTX), LY_VCODE_INCHILDSTMT2, KW, PARENT); return LY_EVALID;}
Radek Krejcid33273d2018-10-25 14:55:52 +020036
Radek Krejcia9026eb2018-12-12 16:04:47 +010037/* These 2 macros checks YANG's identifier grammar rule */
38#define is_yangidentstartchar(c) ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_')
39#define is_yangidentchar(c) ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || \
David Sedlákebd3acf2019-07-26 15:04:32 +020040 c == '_' || c == '-' || c == '.')
Radek Krejcia9026eb2018-12-12 16:04:47 +010041
David Sedlák4a650532019-07-10 11:55:18 +020042/* Macro to check YANG's yang-char grammar rule */
David Sedlák2c0d5ef2019-08-14 11:40:44 +020043#define is_yangutf8char(c) ((c >= 0x20 && c <= 0xd7ff) || c == 0x09 || c == 0x0a || c == 0x0d || \
David Sedlák4a650532019-07-10 11:55:18 +020044 (c >= 0xe000 && c <= 0xfdcf) || (c >= 0xfdf0 && c <= 0xfffd) || \
45 (c >= 0x10000 && c <= 0x1fffd) || (c >= 0x20000 && c <= 0x2fffd) || \
46 (c >= 0x30000 && c <= 0x3fffd) || (c >= 0x40000 && c <= 0x2fffd) || \
47 (c >= 0x50000 && c <= 0x5fffd) || (c >= 0x60000 && c <= 0x6fffd) || \
48 (c >= 0x70000 && c <= 0x7fffd) || (c >= 0x80000 && c <= 0x8fffd) || \
49 (c >= 0x90000 && c <= 0x9fffd) || (c >= 0xa0000 && c <= 0xafffd) || \
50 (c >= 0xb0000 && c <= 0xbfffd) || (c >= 0xc0000 && c <= 0xcfffd) || \
51 (c >= 0xd0000 && c <= 0xdfffd) || (c >= 0xe0000 && c <= 0xefffd) || \
52 (c >= 0xf0000 && c <= 0xffffd) || (c >= 0x100000 && c <= 0x10fffd))
53
Radek Krejci70853c52018-10-15 14:46:16 +020054/**
David Sedlákca36c422019-07-12 12:47:55 +020055 * @brief Try to find object with MEMBER string matching the IDENT in the given ARRAY.
56 * Macro logs an error message and returns LY_EVALID in case of existence of a matching object.
57 *
58 * @param[in] CTX yang parser context for logging.
59 * @param[in] ARRAY [sized array](@ref sizedarrays) of a generic objects with member named MEMBER to search.
60 * @param[in] MEMBER Name of the member of the objects in the ARRAY to compare.
61 * @param[in] STMT Name of the compared YANG statements for logging.
62 * @param[in] IDENT String trying to find in the ARRAY's objects inside the MEMBER member.
63 */
64#define CHECK_UNIQUENESS(CTX, ARRAY, MEMBER, STMT, IDENT) \
65 if (ARRAY) { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +020066 for (LY_ARRAY_COUNT_TYPE u_ = 0; u_ < LY_ARRAY_COUNT(ARRAY) - 1; ++u_) { \
Radek Krejci7eb54ba2020-05-18 16:30:04 +020067 if (!strcmp((ARRAY)[u_].MEMBER, IDENT)) { \
David Sedlákca36c422019-07-12 12:47:55 +020068 LOGVAL_PARSER(CTX, LY_VCODE_DUPIDENT, IDENT, STMT); \
69 return LY_EVALID; \
70 } \
71 } \
72 }
73
Michal Vaskob36053d2020-03-26 15:49:30 +010074#define CHECK_NONEMPTY(CTX, VALUE_LEN, STMT) \
David Sedlák129a09c2019-07-12 14:08:34 +020075 if (!VALUE_LEN) { \
Michal Vaskob36053d2020-03-26 15:49:30 +010076 LOGWRN(PARSER_CTX(CTX), "Empty argument of %s statement does not make sense.", STMT); \
David Sedlák129a09c2019-07-12 14:08:34 +020077 }
Radek Krejci70853c52018-10-15 14:46:16 +020078
79/**
Radek Krejcie3846472018-10-15 15:24:51 +020080 * @brief List of YANG statement groups - the (sub)module's substatements
81 */
82enum yang_module_stmt {
83 Y_MOD_MODULE_HEADER,
84 Y_MOD_LINKAGE,
85 Y_MOD_META,
86 Y_MOD_REVISION,
87 Y_MOD_BODY
88};
89
90/**
91 * @brief Types of arguments of YANG statements
92 */
93enum yang_arg {
94 Y_IDENTIF_ARG, /**< YANG "identifier-arg-str" rule */
Radek Krejcia9026eb2018-12-12 16:04:47 +010095 Y_PREF_IDENTIF_ARG, /**< YANG "identifier-ref-arg-str" or node-identifier rule */
Radek Krejcie3846472018-10-15 15:24:51 +020096 Y_STR_ARG, /**< YANG "string" rule */
97 Y_MAYBE_STR_ARG /**< optional YANG "string" rule */
98};
99
Michal Vaskob36053d2020-03-26 15:49:30 +0100100#define PARSER_CTX(CTX) (CTX)->format == LYS_IN_YANG ? ((struct lys_yang_parser_ctx *)CTX)->ctx : ((struct lys_yin_parser_ctx *)CTX)->xmlctx->ctx
101
102#define LOGVAL_PARSER(CTX, ...) (CTX)->format == LYS_IN_YANG ? LOGVAL_YANG(CTX, __VA_ARGS__) : LOGVAL_YIN(CTX, __VA_ARGS__)
103
104#define LOGVAL_YANG(CTX, ...) LOGVAL(PARSER_CTX(CTX), ((struct lys_yang_parser_ctx *)CTX)->pos_type, \
105 ((struct lys_yang_parser_ctx *)CTX)->pos_type == LY_VLOG_LINE ? \
106 (void *)&((struct lys_yang_parser_ctx *)CTX)->line : \
107 (void *)((struct lys_yang_parser_ctx *)CTX)->path, __VA_ARGS__)
108
109#define LOGVAL_YIN(CTX, ...) LOGVAL(PARSER_CTX(CTX), LY_VLOG_LINE, \
110 &((struct lys_yin_parser_ctx *)CTX)->xmlctx->line, __VA_ARGS__)
111
112struct lys_parser_ctx {
113 LYS_INFORMAT format; /**< parser format */
114 struct ly_set tpdfs_nodes; /**< set of typedef nodes */
115 struct ly_set grps_nodes; /**< set of grouping nodes */
116 uint8_t mod_version; /**< module's version */
117};
118
Radek Krejcie3846472018-10-15 15:24:51 +0200119/**
David Sedlákebd3acf2019-07-26 15:04:32 +0200120 * @brief Internal context for yang schema parser.
Radek Krejci70853c52018-10-15 14:46:16 +0200121 */
Michal Vaskob36053d2020-03-26 15:49:30 +0100122struct lys_yang_parser_ctx {
123 LYS_INFORMAT format; /**< parser format */
David Sedlákebd3acf2019-07-26 15:04:32 +0200124 struct ly_set tpdfs_nodes; /**< set of typedef nodes */
125 struct ly_set grps_nodes; /**< set of grouping nodes */
126 uint8_t mod_version; /**< module's version */
Radek Krejci335332a2019-09-05 13:03:35 +0200127 enum LY_VLOG_ELEM pos_type; /**< */
David Sedlákebd3acf2019-07-26 15:04:32 +0200128 struct ly_ctx *ctx; /**< context of then yang schemas */
Radek Krejci335332a2019-09-05 13:03:35 +0200129 union {
130 uint64_t line; /**< line number */
131 const char *path; /**< path */
132 };
David Sedlákebd3acf2019-07-26 15:04:32 +0200133 uint64_t indent; /**< current position on the line for YANG indentation */
Radek Krejci70853c52018-10-15 14:46:16 +0200134};
135
David Sedlákebd3acf2019-07-26 15:04:32 +0200136/**
137 * @brief free lys parser context.
138 */
Michal Vaskob36053d2020-03-26 15:49:30 +0100139void yang_parser_ctx_free(struct lys_yang_parser_ctx *ctx);
David Sedlákebd3acf2019-07-26 15:04:32 +0200140
141/**
142 * @brief Internal context for yin schema parser.
143 */
Michal Vaskob36053d2020-03-26 15:49:30 +0100144struct lys_yin_parser_ctx {
145 LYS_INFORMAT format; /**< parser format */
David Sedlákebd3acf2019-07-26 15:04:32 +0200146 struct ly_set tpdfs_nodes; /**< set of typedef nodes */
147 struct ly_set grps_nodes; /**< set of grouping nodes */
148 uint8_t mod_version; /**< module's version */
Michal Vaskob36053d2020-03-26 15:49:30 +0100149 struct lyxml_ctx *xmlctx; /**< context for xml parser */
David Sedlákebd3acf2019-07-26 15:04:32 +0200150};
151
152/**
153 * @brief free yin parser context
154 *
155 * @param[in] ctx Context to free.
156 */
Michal Vaskob36053d2020-03-26 15:49:30 +0100157void yin_parser_ctx_free(struct lys_yin_parser_ctx *ctx);
David Sedlákebd3acf2019-07-26 15:04:32 +0200158
Radek Krejci1c0c3442019-07-23 16:08:47 +0200159struct lysc_incomplete_dflt {
160 struct lyd_value *dflt;
161 struct lys_module *dflt_mod;
162 struct lysc_node *context_node;
163};
164
Radek Krejci70853c52018-10-15 14:46:16 +0200165/**
Radek Krejci535ea9f2020-05-29 16:01:05 +0200166 * @brief internal context for compilation
167 */
168struct lysc_ctx {
169 struct ly_ctx *ctx;
170 struct lys_module *mod;
171 struct lys_module *mod_def; /**< context module for the definitions of the nodes being currently
172 processed - groupings are supposed to be evaluated in place where
173 defined, but its content instances are supposed to be placed into
174 the target module (mod) */
175 struct ly_set groupings; /**< stack for groupings circular check */
Michal Vasko004d3152020-06-11 19:59:22 +0200176 struct ly_set xpath; /**< to validate leafref's targets */
177 struct ly_set leafrefs; /**< when/must to check */
Radek Krejci535ea9f2020-05-29 16:01:05 +0200178 struct ly_set dflts; /**< set of incomplete default values */
179 struct ly_set tpdf_chain;
180 uint16_t path_len;
181 int options; /**< various @ref scflags. */
182#define LYSC_CTX_BUFSIZE 4078
183 char path[LYSC_CTX_BUFSIZE];
184};
185
186/**
David Sedlák4a650532019-07-10 11:55:18 +0200187 * @brief Check that \p c is valid UTF8 code point for YANG string.
188 *
Michal Vaskob36053d2020-03-26 15:49:30 +0100189 * @param[in] ctx parser context for logging.
David Sedlák4a650532019-07-10 11:55:18 +0200190 * @param[in] c UTF8 code point of a character to check.
191 * @return LY_ERR values.
192 */
193LY_ERR lysp_check_stringchar(struct lys_parser_ctx *ctx, unsigned int c);
194
195/**
196 * @brief Check that \p c is valid UTF8 code point for YANG identifier.
197 *
Michal Vaskob36053d2020-03-26 15:49:30 +0100198 * @param[in] ctx parser context for logging.
David Sedlák4a650532019-07-10 11:55:18 +0200199 * @param[in] c UTF8 code point of a character to check.
200 * @param[in] first Flag to check the first character of an identifier, which is more restricted.
201 * @param[in,out] prefix Storage for internally used flag in case of possible prefixed identifiers:
202 * 0 - colon not yet found (no prefix)
203 * 1 - \p c is the colon character
204 * 2 - prefix already processed, now processing the identifier
205 *
206 * If the identifier cannot be prefixed, NULL is expected.
207 * @return LY_ERR values.
208 */
209LY_ERR lysp_check_identifierchar(struct lys_parser_ctx *ctx, unsigned int c, int first, int *prefix);
210
211/**
Radek Krejcia1911222019-07-22 17:24:50 +0200212 * @brief Internal structure for lys_get_prefix().
213 */
214struct lys_get_prefix_data {
215 const struct lys_module *context_mod;
216 struct ly_set prefixes;
217};
218
219/**
220 * @brief Schema mapping of YANG modules to prefixes in values.
221 *
222 * Implementation of ly_clb_get_prefix. Inverse function to lys_resolve_prefix.
223 *
224 * In this case the @p mod is searched in the list of imports and the import's prefix
225 * (not the module's itself) prefix is returned.
226 */
227const char *lys_get_prefix(const struct lys_module *mod, void *private);
228
229/**
230 * @brief Schema mapping of prefix in values to YANG modules (imports).
231 *
232 * Implementation of ly_clb_resolve_prefix. Inverse function to lys_get_prefix().
233 *
234 * In this case the @p prefix is searched in the list of imports' prefixes (not the prefixes of the imported modules themselves).
235 */
Michal Vasko52927e22020-03-16 17:26:14 +0100236const struct lys_module *lys_resolve_prefix(const struct ly_ctx *ctx, const char *prefix, size_t prefix_len, void *private);
Radek Krejcia1911222019-07-22 17:24:50 +0200237
238/**
Radek Krejci70853c52018-10-15 14:46:16 +0200239 * @brief Check the currently present prefixes in the module for collision with the new one.
240 *
Radek Krejcibbe09a92018-11-08 09:36:54 +0100241 * @param[in] ctx Context for logging.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100242 * @param[in] imports List of current imports of the module to check prefix collision.
243 * @param[in] module_prefix Prefix of the module to check collision.
Radek Krejci70853c52018-10-15 14:46:16 +0200244 * @param[in] value Newly added prefix value (including its location to distinguish collision with itself).
245 * @return LY_EEXIST when prefix is already used in the module, LY_SUCCESS otherwise
246 */
Radek Krejcie7b95092019-05-15 11:03:07 +0200247LY_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 +0200248
Radek Krejci86d106e2018-10-18 09:53:19 +0200249/**
250 * @brief Check date string (4DIGIT "-" 2DIGIT "-" 2DIGIT)
251 *
Radek Krejcibbe09a92018-11-08 09:36:54 +0100252 * @param[in] ctx Optional context for logging.
Radek Krejci86d106e2018-10-18 09:53:19 +0200253 * @param[in] date Date string to check (non-necessarily terminated by \0)
254 * @param[in] date_len Length of the date string, 10 expected.
255 * @param[in] stmt Statement name for error message.
256 * @return LY_ERR value.
257 */
Radek Krejcie7b95092019-05-15 11:03:07 +0200258LY_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 +0100259
260/**
261 * @brief Check names of typedefs in the parsed module to detect collisions.
262 *
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100263 * @param[in] ctx Parser context for logging and to maintain tpdfs_nodes
264 * @param[in] mod Module where the type is being defined.
Radek Krejcibbe09a92018-11-08 09:36:54 +0100265 * @return LY_ERR value.
266 */
Radek Krejcie7b95092019-05-15 11:03:07 +0200267LY_ERR lysp_check_typedefs(struct lys_parser_ctx *ctx, struct lysp_module *mod);
Radek Krejci86d106e2018-10-18 09:53:19 +0200268
269/**
David Sedlákd2ebe572019-07-22 12:53:14 +0200270 * @brief Finalize some of the structures in case they are stored in sized array,
271 * which can be possibly reallocated and some other data may point to them.
272 *
273 * Update parent pointers in the nodes inside grouping/augment/RPC/Notification, which could be reallocated.
274 *
275 * @param[in] mod Parsed module to be updated.
276 * @return LY_ERR value (currently only LY_SUCCESS, but it can change in future).
277 */
278LY_ERR
279lysp_parse_finalize_reallocated(struct lys_parser_ctx *ctx, struct lysp_grp *groupings, struct lysp_augment *augments,
280 struct lysp_action *actions, struct lysp_notif *notifs);
281
282/**
Radek Krejci86d106e2018-10-18 09:53:19 +0200283 * @brief Just move the newest revision into the first position, does not sort the rest
284 * @param[in] revs Sized-array of the revisions in a printable schema tree.
285 */
286void lysp_sort_revisions(struct lysp_revision *revs);
287
288/**
David Sedlák6544c182019-07-12 13:17:33 +0200289 * @brief Find type specified type definition.
Radek Krejcibbe09a92018-11-08 09:36:54 +0100290 *
291 * @param[in] id Name of the type including possible prefix. Module where the prefix is being searched is start_module.
292 * @param[in] start_node Context node where the type is being instantiated to be able to search typedefs in parents.
293 * @param[in] start_module Module where the type is being instantiated for search for typedefs.
Radek Krejci4f28eda2018-11-12 11:46:16 +0100294 * @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 +0100295 * @param[out] tpdf Found type definition.
296 * @param[out] node Node where the found typedef is defined, NULL in case of a top-level typedef.
297 * @param[out] module Module where the found typedef is being defined, NULL in case of built-in YANG types.
298 */
299LY_ERR lysp_type_find(const char *id, struct lysp_node *start_node, struct lysp_module *start_module,
Radek Krejci4f28eda2018-11-12 11:46:16 +0100300 LY_DATA_TYPE *type, const struct lysp_tpdf **tpdf, struct lysp_node **node, struct lysp_module **module);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100301
302/**
David Sedlák6544c182019-07-12 13:17:33 +0200303 * @brief Validate enum name.
304 *
305 * @param[in] ctx yang parser context for logging.
306 * @param[in] name String to check.
307 * @param[in] name_len Length of name.
308 *
309 * @return LY_ERR values
310 */
David Sedlák07869a52019-07-12 14:28:19 +0200311LY_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 +0200312
313/**
Radek Krejci086c7132018-10-26 15:29:04 +0200314 * @brief Find and parse module of the given name.
315 *
316 * @param[in] ctx libyang context.
317 * @param[in] name Name of the module to load.
318 * @param[in] revison Optional revision of the module to load. If NULL, the newest revision is loaded.
Radek Krejcied5acc52019-04-25 15:57:04 +0200319 * @param[in] implement Flag if the loaded module is supposed to be marked as implemented. If revision is NULL and implement flag set,
320 * the implemented module in the context is returned despite it might not be of the latest revision, because in this case the module
321 * of the latest revision can not be made implemented.
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100322 * @param[in] require_parsed Flag to require parsed module structure in case the module is already in the context,
323 * but only the compiled structure is available.
Radek Krejci086c7132018-10-26 15:29:04 +0200324 * @param[out] mod Parsed module structure.
325 * @return LY_ERR value.
326 */
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100327LY_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 +0200328
329/**
Radek Krejcid33273d2018-10-25 14:55:52 +0200330 * @brief Parse included submodule into the simply parsed YANG module.
331 *
Radek Krejci3b1f9292018-11-08 10:58:35 +0100332 * @param[in] ctx parser context
Radek Krejcid33273d2018-10-25 14:55:52 +0200333 * @param[in] mod Module including a submodule.
Radek Krejcid33273d2018-10-25 14:55:52 +0200334 * @param[in,out] inc Include structure holding all available information about the include statement, the parsed
335 * submodule is stored into this structure.
336 * @return LY_ERR value.
337 */
Michal Vaskob36053d2020-03-26 15:49:30 +0100338LY_ERR lysp_load_submodule(struct lys_parser_ctx *pctx, struct lysp_module *mod, struct lysp_include *inc);
Radek Krejcid33273d2018-10-25 14:55:52 +0200339
340/**
Radek Krejci096235c2019-01-11 11:12:19 +0100341 * @brief Compile printable schema into a validated schema linking all the references.
342 *
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200343 * @param[in, out] mod Pointer to the schema structure holding pointers to both schema structure types. The ::lys_module#parsed
Radek Krejci096235c2019-01-11 11:12:19 +0100344 * member is used as input and ::lys_module#compiled is used to hold the result of the compilation.
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200345 * If the compilation fails, the whole module is removed from context, freed and @p mod is set to NULL!
Radek Krejci096235c2019-01-11 11:12:19 +0100346 * @param[in] options Various options to modify compiler behavior, see [compile flags](@ref scflags).
347 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
348 */
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200349LY_ERR lys_compile(struct lys_module **mod, int options);
Radek Krejci096235c2019-01-11 11:12:19 +0100350
351/**
Radek Krejcibbe09a92018-11-08 09:36:54 +0100352 * @brief Get address of a node's actions list if any.
353 *
354 * Decides the node's type and in case it has an actions list, returns its address.
355 * @param[in] node Node to check.
356 * @return Address of the node's actions member if any, NULL otherwise.
357 */
Radek Krejci056d0a82018-12-06 16:57:25 +0100358struct lysp_action **lysp_node_actions_p(struct lysp_node *node);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100359
360/**
361 * @brief Get address of a node's notifications list if any.
362 *
363 * Decides the node's type and in case it has a notifications list, returns its address.
364 * @param[in] node Node to check.
365 * @return Address of the node's notifs member if any, NULL otherwise.
366 */
Radek Krejci056d0a82018-12-06 16:57:25 +0100367struct lysp_notif **lysp_node_notifs_p(struct lysp_node *node);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100368
369/**
370 * @brief Get address of a node's child pointer if any.
371 *
372 * Decides the node's type and in case it has a children list, returns its address.
373 * @param[in] node Node to check.
374 * @return Address of the node's child member if any, NULL otherwise.
375 */
Radek Krejci056d0a82018-12-06 16:57:25 +0100376struct lysp_node **lysp_node_children_p(struct lysp_node *node);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100377
378/**
379 * @brief Get address of a node's child pointer if any.
380 *
381 * Decides the node's type and in case it has a children list, returns its address.
382 * @param[in] node Node to check.
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100383 * @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 +0100384 * @return Address of the node's child member if any, NULL otherwise.
385 */
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100386struct lysc_node **lysc_node_children_p(const struct lysc_node *node, uint16_t flags);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100387
388/**
Radek Krejcifc11bd72019-04-11 16:00:05 +0200389 * @brief Get address of a node's notifs pointer if any.
390 *
391 * Decides the node's type and in case it has a notifs array, returns its address.
392 * @param[in] node Node to check.
393 * @return Address of the node's notifs member if any, NULL otherwise.
394 */
395struct lysc_notif **lysc_node_notifs_p(struct lysc_node *node);
396
397/**
398 * @brief Get address of a node's actions pointer if any.
399 *
400 * Decides the node's type and in case it has a actions array, returns its address.
401 * @param[in] node Node to check.
402 * @return Address of the node's actions member if any, NULL otherwise.
403 */
404struct lysc_action **lysc_node_actions_p(struct lysc_node *node);
405
406/**
Radek Krejcid3ca0632019-04-16 16:54:54 +0200407 * @brief Iterate over the specified type of the extension instances
408 *
409 * @param[in] ext ([Sized array](@ref sizedarrays)) of extensions to explore
410 * @param[in] index Index in the \p ext array where to start searching (first call with 0, the consequent calls with
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200411 * the returned index increased by 1 (until the iteration is not terminated by returning LY_ARRAY_COUNT(ext).
Radek Krejcid3ca0632019-04-16 16:54:54 +0200412 * @param[in] substmt Type of the extension (its belongins to the specific substatement) to iterate, use
413 * #LYEXT_SUBSTMT_ALL to go through all the extensions in the array
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200414 * @result index in the ext array, LY_ARRAY_COUNT(ext) value if not present.
Radek Krejcid3ca0632019-04-16 16:54:54 +0200415 */
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200416LY_ARRAY_COUNT_TYPE lysp_ext_instance_iter(struct lysp_ext_instance *ext, LY_ARRAY_COUNT_TYPE index, LYEXT_SUBSTMT substmt);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200417
418/**
Radek Krejci96a0bfd2018-11-22 15:25:06 +0100419 * @brief Get the covering schema module structure for the given parsed module structure.
420 * @param[in] ctx libyang context to search.
421 * @param[in] mod Parsed schema structure.
422 * @return Corresponding lys_module structure for the given parsed schema structure.
423 */
424struct lys_module *lysp_find_module(struct ly_ctx *ctx, const struct lysp_module *mod);
425
426/**
Radek Krejcice8c1592018-10-29 15:35:51 +0100427 * @brief Find the module referenced by prefix in the provided parsed mod.
428 *
429 * @param[in] mod Schema module where the prefix was used.
430 * @param[in] prefix Prefix used to reference a module.
431 * @param[in] len Length of the prefix since it is not necessary NULL-terminated.
432 * @return Pointer to the module or NULL if the module is not found.
433 */
Radek Krejcia3045382018-11-22 14:30:31 +0100434struct lysp_module *lysp_module_find_prefix(const struct lysp_module *mod, const char *prefix, size_t len);
Radek Krejcice8c1592018-10-29 15:35:51 +0100435
436/**
437 * @brief Find the module referenced by prefix in the provided compiled mod.
438 *
439 * @param[in] mod Schema module where the prefix was used.
440 * @param[in] prefix Prefix used to reference a module.
441 * @param[in] len Length of the prefix since it is not necessary NULL-terminated.
Radek Krejcib3289d62019-09-18 12:21:39 +0200442 * @return Pointer to the module or NULL if the module is not found or it is not compiled.
Radek Krejcice8c1592018-10-29 15:35:51 +0100443 */
Radek Krejcia3045382018-11-22 14:30:31 +0100444struct lysc_module *lysc_module_find_prefix(const struct lysc_module *mod, const char *prefix, size_t len);
Radek Krejcice8c1592018-10-29 15:35:51 +0100445
446/**
Radek Krejci4f28eda2018-11-12 11:46:16 +0100447 * @brief Check statement's status for invalid combination.
448 *
449 * The modX parameters are used just to determine if both flags are in the same module,
450 * so any of the schema module structure can be used, but both modules must be provided
451 * in the same type.
452 *
453 * @param[in] ctx Compile context for logging.
454 * @param[in] flags1 Flags of the referencing node.
455 * @param[in] mod1 Module of the referencing node,
456 * @param[in] name1 Schema node name of the referencing node.
457 * @param[in] flags2 Flags of the referenced node.
458 * @param[in] mod2 Module of the referenced node,
459 * @param[in] name2 Schema node name of the referenced node.
460 * @return LY_ERR value
461 */
462LY_ERR lysc_check_status(struct lysc_ctx *ctx,
463 uint16_t flags1, void *mod1, const char *name1,
464 uint16_t flags2, void *mod2, const char *name2);
465
466/**
Radek Krejci95710c92019-02-11 15:49:55 +0100467 * @brief Find the node according to the given descendant/absolute schema nodeid.
468 * Used in unique, refine and augment statements.
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100469 *
470 * @param[in] ctx Compile context
471 * @param[in] nodeid Descendant-schema-nodeid (according to the YANG grammar)
472 * @param[in] nodeid_len Length of the given nodeid, if it is not NULL-terminated string.
473 * @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 +0100474 * If no context node is provided, the nodeid is actually expected to be the absolute schema node .
475 * @param[in] context_module Explicit module to resolve prefixes in @nodeid.
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100476 * @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 +0100477 * the given nodetype, LY_EDENIED is returned (and target is provided), but no error message is printed.
478 * The value can be even an ORed value to allow multiple nodetypes.
479 * @param[in] implement Flag if the modules mentioned in the nodeid are supposed to be made implemented.
Michal Vasko1bf09392020-03-27 12:38:10 +0100480 * @param[out] target Found target node if any. In case of RPC/action input/output node, LYS_RPC or LYS_ACTION node is actually returned
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100481 * since the input/output has not a standalone node structure and it is part of ::lysc_action which is better compatible with ::lysc_node.
482 * @param[out] result_flag Output parameter to announce if the schema nodeid goes through the action's input/output or a Notification.
483 * The LYSC_OPT_RPC_INPUT, LYSC_OPT_RPC_OUTPUT and LYSC_OPT_NOTIFICATION are used as flags.
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100484 * @return LY_ERR values - LY_ENOTFOUND, LY_EVALID, LY_EDENIED or LY_SUCCESS.
485 */
Radek Krejci95710c92019-02-11 15:49:55 +0100486LY_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 +0100487 const struct lys_module *context_module, int nodetype, int implement,
488 const struct lysc_node **target, uint16_t *result_flag);
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100489
490/**
Radek Krejci151a5b72018-10-19 14:21:44 +0200491 * @brief Find the module referenced by prefix in the provided mod.
492 *
Radek Krejci693262f2019-04-29 15:23:20 +0200493 * Reverse function to lys_prefix_find_module().
494 *
Radek Krejci151a5b72018-10-19 14:21:44 +0200495 * @param[in] mod Schema module where the prefix was used.
496 * @param[in] prefix Prefix used to reference a module.
497 * @param[in] len Length of the prefix since it is not necessary NULL-terminated.
498 * @return Pointer to the module or NULL if the module is not found.
499 */
Radek Krejcia3045382018-11-22 14:30:31 +0100500struct lys_module *lys_module_find_prefix(const struct lys_module *mod, const char *prefix, size_t len);
501
502/**
Radek Krejci693262f2019-04-29 15:23:20 +0200503 * @brief Find the prefix used to referenced the import module in the provided mod.
504 *
505 * Reverse function to lys_module_find_prefix().
506 *
507 * Note that original prefixes are present only in the parsed schema. In case it is not available
508 * (only compiled schema available), the own prefix of the import module is returned instead.
509 *
510 * @param[in] mod Schema module where the import module was used.
511 * @param[in] import Module referenced in mod.
512 * @return Prefix of the import module.
513 */
514const char *lys_prefix_find_module(const struct lys_module *mod, const struct lys_module *import);
515
516/**
Radek Krejci693262f2019-04-29 15:23:20 +0200517 * @brief Stringify YANG built-in type.
Michal Vasko1bf09392020-03-27 12:38:10 +0100518 * @param[in] basetype Built-in type ID to stringify.
Radek Krejci693262f2019-04-29 15:23:20 +0200519 * @return Constant string with the name of the built-in type.
520 */
521const char *lys_datatype2str(LY_DATA_TYPE basetype);
522
Michal Vaskob36053d2020-03-26 15:49:30 +0100523typedef LY_ERR (*lys_custom_check)(const struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *check_data);
524
Radek Krejci693262f2019-04-29 15:23:20 +0200525/**
Michal Vaskob36053d2020-03-26 15:49:30 +0100526 * @brief Parse module from a string.
Radek Krejcid33273d2018-10-25 14:55:52 +0200527 *
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100528 * The modules are added into the context and the latest_revision flag is updated.
Radek Krejcid33273d2018-10-25 14:55:52 +0200529 *
530 * @param[in] ctx libyang context where to process the data model.
Michal Vasko63f3d842020-07-08 10:10:14 +0200531 * @param[in] in Input structure.
Radek Krejcid33273d2018-10-25 14:55:52 +0200532 * @param[in] format Format of the input data (YANG or YIN).
Radek Krejcid33273d2018-10-25 14:55:52 +0200533 * @param[in] implement Flag if the schema is supposed to be marked as implemented.
Radek Krejci9ed7a192018-10-31 16:23:51 +0100534 * @param[in] custom_check Callback to check the parsed schema before it is accepted.
535 * @param[in] check_data Caller's data to pass to the custom_check callback.
Radek Krejcid33273d2018-10-25 14:55:52 +0200536 * @return Pointer to the data model structure or NULL on error.
537 */
Michal Vasko63f3d842020-07-08 10:10:14 +0200538struct lys_module *lys_parse_mem_module(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, int implement,
Michal Vaskob36053d2020-03-26 15:49:30 +0100539 lys_custom_check custom_check, void *check_data);
Radek Krejcid33273d2018-10-25 14:55:52 +0200540
541/**
Michal Vaskob36053d2020-03-26 15:49:30 +0100542 * @brief Parse submodule from a string.
Radek Krejcid33273d2018-10-25 14:55:52 +0200543 *
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100544 * The latest_revision flag of submodule is updated.
545 *
546 * @param[in] ctx libyang context where to process the data model.
Michal Vasko63f3d842020-07-08 10:10:14 +0200547 * @param[in] in Input structure.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100548 * @param[in] format Format of the input data (YANG or YIN).
549 * @param[in] main_ctx Parser context of the main module.
550 * @param[in] custom_check Callback to check the parsed schema before it is accepted.
551 * @param[in] check_data Caller's data to pass to the custom_check callback.
552 * @return Pointer to the data model structure or NULL on error.
553 */
Michal Vasko63f3d842020-07-08 10:10:14 +0200554struct lysp_submodule *lys_parse_mem_submodule(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format,
555 struct lys_parser_ctx *main_ctx, lys_custom_check custom_check,
556 void *check_data);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100557
558/**
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200559 * @brief Fill filepath value if available in input handler @p in
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100560 *
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200561 * @param[in] ctx Context with dictionary where the filepath value will be stored.
562 * @param[in] in Input handler to examine (filepath is not available for all the input types).
563 * @param[out] filepath Address of the variable where the filepath is stored.
Radek Krejcid33273d2018-10-25 14:55:52 +0200564 */
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200565void lys_parser_fill_filepath(struct ly_ctx *ctx, struct ly_in *in, const char **filepath);
Radek Krejcid33273d2018-10-25 14:55:52 +0200566
567/**
568 * @brief Load the (sub)module into the context.
569 *
570 * This function does not check the presence of the (sub)module in context, it should be done before calling this function.
571 *
572 * module_name and submodule_name are alternatives - only one of the
573 *
574 * @param[in] ctx libyang context where to work.
575 * @param[in] name Name of the (sub)module to load.
576 * @param[in] revision Optional revision of the (sub)module to load, if NULL the newest revision is being loaded.
577 * @param[in] implement Flag if the (sub)module is supposed to be marked as implemented.
Radek Krejci3b1f9292018-11-08 10:58:35 +0100578 * @param[in] main_ctx Parser context of the main module in case of loading submodule.
fredgancd485b82019-10-18 15:00:17 +0800579 * @param[in] main_name Main module name in case of loading submodule.
Radek Krejci78f06822019-10-30 12:54:05 +0100580 * @param[in] required Module is required so error (even if the input file not found) are important. If 0, there is some
581 * backup and it is actually ok if the input data are not found. However, parser reports errors even in this case.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100582 * @param[out] result Parsed YANG schema tree of the requested module (struct lys_module*) or submodule (struct lysp_submodule*).
583 * If it is a module, it is already in the context!
Radek Krejcid33273d2018-10-25 14:55:52 +0200584 * @return LY_ERR value, in case of LY_SUCCESS, the \arg result is always provided.
585 */
fredgancd485b82019-10-18 15:00:17 +0800586LY_ERR lys_module_localfile(struct ly_ctx *ctx, const char *name, const char *revision, int implement,
Radek Krejci78f06822019-10-30 12:54:05 +0100587 struct lys_parser_ctx *main_ctx, const char *main_name, int required, void **result);
Radek Krejci086c7132018-10-26 15:29:04 +0200588
589/**
Michal Vasko33ff9422020-07-03 09:50:39 +0200590 * @brief Compile information from the identity statement
591 *
592 * The backlinks to the identities derived from this one are supposed to be filled later via lys_compile_identity_bases().
593 *
594 * @param[in] ctx_sc Compile context - alternative to the combination of @p ctx and @p module.
595 * @param[in] ctx libyang context.
596 * @param[in] module Module of the features.
597 * @param[in] identities_p Array of the parsed identity definitions to precompile.
598 * @param[in,out] identities Pointer to the storage of the (pre)compiled identities array where the new identities are
599 * supposed to be added. The storage is supposed to be initiated to NULL when the first parsed identities are going
600 * to be processed.
601 * @return LY_ERR value.
602 */
603LY_ERR lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lys_module *module,
604 struct lysp_ident *identities_p, struct lysc_ident **identities);
605
606/**
Radek Krejci0af46292019-01-11 16:02:31 +0100607 * @brief Create pre-compiled features array.
608 *
609 * Features are compiled in two steps to allow forward references between them via their if-feature statements.
610 * In case of not implemented schemas, the precompiled list of features is stored in lys_module structure and
611 * the compilation is not finished (if-feature and extensions are missing) and all the features are permanently
612 * disabled without a chance to change it. The list is used as target for any if-feature statement in any
613 * implemented module to get valid data to evaluate its result. The compilation is finished via
614 * lys_feature_precompile_finish() in implemented modules. In case a not implemented module becomes implemented,
615 * the precompiled list is reused to finish the compilation to preserve pointers already used in various compiled
616 * if-feature structures.
617 *
Radek Krejci327de162019-06-14 12:52:07 +0200618 * @param[in] ctx_sc Compile context - alternative to the combination of @p ctx and @p module.
Radek Krejci0af46292019-01-11 16:02:31 +0100619 * @param[in] ctx libyang context.
Radek Krejci693262f2019-04-29 15:23:20 +0200620 * @param[in] module Module of the features.
Radek Krejci0935f412019-08-20 16:15:18 +0200621 * @param[in] features_p Array of the parsed features definitions to precompile.
Radek Krejci0af46292019-01-11 16:02:31 +0100622 * @param[in,out] features Pointer to the storage of the (pre)compiled features array where the new features are
623 * supposed to be added. The storage is supposed to be initiated to NULL when the first parsed features are going
624 * to be processed.
625 * @return LY_ERR value.
626 */
Radek Krejci0935f412019-08-20 16:15:18 +0200627LY_ERR lys_feature_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lys_module *module,
628 struct lysp_feature *features_p, struct lysc_feature **features);
Radek Krejci693262f2019-04-29 15:23:20 +0200629
630/**
631 * @brief Get the @ref ifftokens from the given position in the 2bits array
632 * (libyang format of the if-feature expression).
633 * @param[in] list The 2bits array with the compiled if-feature expression.
634 * @param[in] pos Position (0-based) to specify from which position get the operator.
635 */
636uint8_t lysc_iff_getop(uint8_t *list, int pos);
Radek Krejci0af46292019-01-11 16:02:31 +0100637
638/**
Michal Vasko03ff5a72019-09-11 13:49:33 +0200639 * @brief Checks pattern syntax.
640 *
641 * @param[in] ctx Context.
642 * @param[in] log_path Path for logging errors.
643 * @param[in] pattern Pattern to check.
644 * @param[in,out] pcre2_code Compiled PCRE2 pattern. If NULL, the compiled information used to validate pattern are freed.
645 * @return LY_ERR value - LY_SUCCESS, LY_EMEM, LY_EVALID.
646 */
647LY_ERR lys_compile_type_pattern_check(struct ly_ctx *ctx, const char *log_path, const char *pattern, pcre2_code **code);
648
649/**
Radek Krejcifc11bd72019-04-11 16:00:05 +0200650 * @brief Macro to free [sized array](@ref sizedarrays) of items using the provided free function. The ARRAY itself is also freed,
651 * but the memory is not sanitized.
652 */
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200653#define FREE_ARRAY(CTX, ARRAY, FUNC) {LY_ARRAY_COUNT_TYPE c__; LY_ARRAY_FOR(ARRAY, c__){FUNC(CTX, &(ARRAY)[c__]);}LY_ARRAY_FREE(ARRAY);}
Radek Krejcifc11bd72019-04-11 16:00:05 +0200654
655/**
656 * @brief Macro to free the specified MEMBER of a structure using the provided free function. The memory is not sanitized.
657 */
658#define FREE_MEMBER(CTX, MEMBER, FUNC) if (MEMBER) {FUNC(CTX, MEMBER);free(MEMBER);}
659
660/**
661 * @brief Macro to free [sized array](@ref sizedarrays) of strings stored in the context's dictionary. The ARRAY itself is also freed,
662 * but the memory is not sanitized.
663 */
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200664#define FREE_STRINGS(CTX, ARRAY) {LY_ARRAY_COUNT_TYPE c__; LY_ARRAY_FOR(ARRAY, c__){FREE_STRING(CTX, ARRAY[c__]);}LY_ARRAY_FREE(ARRAY);}
Radek Krejcifc11bd72019-04-11 16:00:05 +0200665
666/**
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100667 * @brief Free the parsed submodule structure.
668 * @param[in] ctx libyang context where the string data resides in a dictionary.
669 * @param[in,out] submod Parsed schema submodule structure to free.
Radek Krejci086c7132018-10-26 15:29:04 +0200670 */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100671void lysp_submodule_free(struct ly_ctx *ctx, struct lysp_submodule *submod);
Radek Krejci086c7132018-10-26 15:29:04 +0200672
Radek Krejci38d85362019-09-05 16:26:38 +0200673/**
674 * @brief Free the parsed type structure.
675 * @param[in] ctx libyang context where the string data resides in a dictionary.
Michal Vasko8d544252020-03-02 10:19:52 +0100676 * @param[in] type Parsed schema type structure to free. Note that the type itself is not freed.
Radek Krejci38d85362019-09-05 16:26:38 +0200677 */
678void lysp_type_free(struct ly_ctx *ctx, struct lysp_type *type);
Radek Krejci335332a2019-09-05 13:03:35 +0200679
Radek Krejciad5963b2019-09-06 16:03:05 +0200680/**
Michal Vasko8d544252020-03-02 10:19:52 +0100681 * @brief Free the parsed extension instance structure.
682 * @param[in] ctx libyang context where the string data resides in a dictionary.
683 * @param[in] type Parsed extension instance structure to free. Note that the instance itself is not freed.
684 */
685void lysp_ext_instance_free(struct ly_ctx *ctx, struct lysp_ext_instance *ext);
686
687/**
Radek Krejciad5963b2019-09-06 16:03:05 +0200688 * @param[in,out] exts [sized array](@ref sizedarrays) For extension instances in case of statements that do not store extension instances in their own list.
689 */
690LY_ERR lysp_stmt_parse(struct lysc_ctx *ctx, const struct lysp_stmt *stmt, enum ly_stmt kw, void **result, struct lysp_ext_instance **exts);
Radek Krejci335332a2019-09-05 13:03:35 +0200691
Radek Krejcid33273d2018-10-25 14:55:52 +0200692/**
Radek Krejcicdfecd92018-11-26 11:27:32 +0100693 * @brief Free the compiled type structure.
694 * @param[in] ctx libyang context where the string data resides in a dictionary.
695 * @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.
696 */
697void lysc_type_free(struct ly_ctx *ctx, struct lysc_type *type);
698
699/**
Radek Krejci0af46292019-01-11 16:02:31 +0100700 * @brief Free the compiled if-feature structure.
701 * @param[in] ctx libyang context where the string data resides in a dictionary.
702 * @param[in,out] iff Compiled if-feature structure to be cleaned.
703 * Since the structure is typically part of the sized array, the structure itself is not freed.
704 */
705void lysc_iffeature_free(struct ly_ctx *ctx, struct lysc_iffeature *iff);
706
707/**
Radek Krejciccd20f12019-02-15 14:12:27 +0100708 * @brief Free the compiled must structure.
709 * @param[in] ctx libyang context where the string data resides in a dictionary.
710 * @param[in,out] must Compiled must structure to be cleaned.
711 * Since the structure is typically part of the sized array, the structure itself is not freed.
712 */
713void lysc_must_free(struct ly_ctx *ctx, struct lysc_must *must);
714
715/**
Radek Krejcif538ce52019-03-05 10:46:14 +0100716 * @brief Free the data inside compiled input/output structure.
717 * @param[in] ctx libyang context where the string data resides in a dictionary.
718 * @param[in,out] inout Compiled inout structure to be cleaned.
719 * Since the structure is part of the RPC/action structure, it is not freed itself.
720 */
721void lysc_action_inout_free(struct ly_ctx *ctx, struct lysc_action_inout *inout);
722
723/**
724 * @brief Free the data inside compiled RPC/action structure.
725 * @param[in] ctx libyang context where the string data resides in a dictionary.
726 * @param[in,out] action Compiled action structure to be cleaned.
727 * Since the structure is typically part of the sized array, the structure itself is not freed.
728 */
729void lysc_action_free(struct ly_ctx *ctx, struct lysc_action *action);
730
731/**
Radek Krejcifc11bd72019-04-11 16:00:05 +0200732 * @brief Free the items inside the compiled Notification structure.
733 * @param[in] ctx libyang context where the string data resides in a dictionary.
734 * @param[in,out] action Compiled Notification structure to be cleaned.
735 * Since the structure is typically part of the sized array, the structure itself is not freed.
736 */
737void lysc_notif_free(struct ly_ctx *ctx, struct lysc_notif *notif);
738
739/**
Radek Krejci0af46292019-01-11 16:02:31 +0100740 * @brief Free the compiled extension instance structure.
741 * @param[in] ctx libyang context where the string data resides in a dictionary.
742 * @param[in,out] ext Compiled extension instance structure to be cleaned.
743 * Since the structure is typically part of the sized array, the structure itself is not freed.
744 */
745void lysc_ext_instance_free(struct ly_ctx *ctx, struct lysc_ext_instance *ext);
746
747/**
Radek Krejci19a96102018-11-15 13:38:09 +0100748 * @brief Free the compiled node structure.
749 * @param[in] ctx libyang context where the string data resides in a dictionary.
750 * @param[in,out] node Compiled node structure to be freed.
751 */
752void lysc_node_free(struct ly_ctx *ctx, struct lysc_node *node);
753
754/**
Radek Krejcif2de0ed2019-05-02 14:13:18 +0200755 * @brief Free the compiled container node structure.
756 *
757 * Only the container-specific members are freed, for generic node free function,
758 * use lysc_node_free().
759 *
760 * @param[in] ctx libyang context where the string data resides in a dictionary.
761 * @param[in,out] node Compiled container node structure to be freed.
762 */
763void lysc_node_container_free(struct ly_ctx *ctx, struct lysc_node_container *node);
764
765/**
Radek Krejci19a96102018-11-15 13:38:09 +0100766 * @brief Free the compiled schema structure.
767 * @param[in,out] module Compiled schema module structure to free.
768 * @param[in] private_destructor Function to remove private data from the compiled schema tree.
769 */
770void lysc_module_free(struct lysc_module *module, void (*private_destructor)(const struct lysc_node *node, void *priv));
771
772/**
Radek Krejci86d106e2018-10-18 09:53:19 +0200773 * @brief Free the schema structure. It just frees, it does not remove the schema from its context.
774 * @param[in,out] module Schema module structure to free.
775 * @param[in] private_destructor Function to remove private data from the compiled schema tree.
776 */
777void lys_module_free(struct lys_module *module, void (*private_destructor)(const struct lysc_node *node, void *priv));
778
779/**
Radek Krejci95710c92019-02-11 15:49:55 +0100780 * @brief Make the specific module implemented, use the provided value as flag.
781 *
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200782 * @param[in] mod Module to make implemented. It is not an error to provide already implemented module, it just does nothing.
Radek Krejci95710c92019-02-11 15:49:55 +0100783 * @param[in] implemented Flag value for the ::lys_module#implemented item.
784 * @return LY_SUCCESS or LY_EDENIED in case the context contains some other revision of the
785 * same module which is already implemented.
786 */
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200787LY_ERR lys_set_implemented_internal(struct lys_module *mod, uint8_t implemented);
Radek Krejci95710c92019-02-11 15:49:55 +0100788
David Sedlák18e494b2018-12-17 03:58:39 +0100789/**
790 * @brief match yang keyword
David Sedlák1bccdfa2019-06-17 15:55:27 +0200791 *
Michal Vasko14654712020-02-06 08:35:21 +0100792 * @param[in] ctx yang parser context for logging, can be NULL if keyword is from YIN data.
Michal Vasko63f3d842020-07-08 10:10:14 +0200793 * @param[in,out] in Input structure, is updated.
Michal Vasko14654712020-02-06 08:35:21 +0100794 * @return yang_keyword values.
David Sedlák18e494b2018-12-17 03:58:39 +0100795 */
Michal Vasko63f3d842020-07-08 10:10:14 +0200796enum ly_stmt lysp_match_kw(struct lys_yang_parser_ctx *ctx, struct ly_in *in);
David Sedlák1bccdfa2019-06-17 15:55:27 +0200797
Michal Vasko14654712020-02-06 08:35:21 +0100798/**
799 * @brief Generate path of the given node in the requested format.
800 *
801 * @param[in] node Schema path of this node will be generated.
802 * @param[in] parent Build relative path only until this parent is found. If NULL, the full absolute path is printed.
803 * @param[in] pathtype Format of the path to generate.
804 * @param[in,out] buffer Prepared buffer of the @p buflen length to store the generated path.
805 * If NULL, memory for the complete path is allocated.
806 * @param[in] buflen Size of the provided @p buffer.
807 * @return NULL in case of memory allocation error, path of the node otherwise.
808 * In case the @p buffer is NULL, the returned string is dynamically allocated and caller is responsible to free it.
809 */
810char *lysc_path_until(const struct lysc_node *node, const struct lysc_node *parent, LYSC_PATH_TYPE pathtype, char *buffer,
Michal Vasko90932a92020-02-12 14:33:03 +0100811 size_t buflen);
Michal Vasko14654712020-02-06 08:35:21 +0100812
Michal Vasko62ed12d2020-05-21 10:08:25 +0200813/**
814 * @brief Get schema parent that can be instantiated in data. In other words, skip any choice or case nodes.
815 *
816 * @param[in] schema Schema node to get the parent for.
817 * @return Parent, NULL if top-level (in data).
818 */
819const struct lysc_node *lysc_data_parent(const struct lysc_node *schema);
820
Michal Vasko00cbf532020-06-15 13:58:47 +0200821/**
822 * @brief Learn whether a node is in an operation output.
823 *
824 * @param[in] schema Schema node to examine.
825 * @return non-zero is the node is in output,
826 * @return 0 if it is not.
827 */
828int lysc_is_output(const struct lysc_node *schema);
829
Radek Krejci70853c52018-10-15 14:46:16 +0200830#endif /* LY_TREE_SCHEMA_INTERNAL_H_ */