blob: 3ea8f0b1348597f0fe74c332bfd51f7194baeed4 [file] [log] [blame]
David Sedlákf824ad52018-10-14 23:58:15 +02001/**
2 * @file parser_yin.c
3 * @author David Sedlák <xsedla1d@stud.fit.vutbr.cz>
David Sedlák3b4db242018-10-19 16:11:01 +02004 * @brief YIN parser.
5 *
David Sedlákb1ce3f82019-06-05 14:37:26 +02006 * Copyright (c) 2015 - 2019 CESNET, z.s.p.o.
David Sedlák3b4db242018-10-19 16:11:01 +02007 *
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
David Sedlákf824ad52018-10-14 23:58:15 +020013 */
Michal Vaskofc2cd072021-02-24 13:17:17 +010014#define _GNU_SOURCE
15
David Sedlák3ffbc522019-07-02 17:49:28 +020016#include <assert.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020017#include <ctype.h>
18#include <errno.h>
19#include <stdarg.h>
20#include <stdbool.h>
Radek Krejci47fab892020-11-05 17:02:41 +010021#include <stdint.h>
David Sedlák3b4db242018-10-19 16:11:01 +020022#include <stdio.h>
23#include <stdlib.h>
David Sedlák872c7b42018-10-26 13:15:20 +020024#include <string.h>
David Sedlákf824ad52018-10-14 23:58:15 +020025
Radek Krejci535ea9f2020-05-29 16:01:05 +020026#include "common.h"
Michal Vaskofc2cd072021-02-24 13:17:17 +010027#include "compat.h"
David Sedlákf824ad52018-10-14 23:58:15 +020028#include "context.h"
David Sedlákecf5eb82019-06-03 14:12:44 +020029#include "dict.h"
Radek Krejci47fab892020-11-05 17:02:41 +010030#include "in.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020031#include "in_internal.h"
Radek Krejci47fab892020-11-05 17:02:41 +010032#include "log.h"
Michal Vasko63f3d842020-07-08 10:10:14 +020033#include "parser_internal.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020034#include "parser_schema.h"
Michal Vasko69730152020-10-09 16:30:07 +020035#include "path.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020036#include "set.h"
David Sedlákecf5eb82019-06-03 14:12:44 +020037#include "tree.h"
Michal Vaskofc2cd072021-02-24 13:17:17 +010038#include "tree_data_internal.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010039#include "tree_edit.h"
David Sedlákecf5eb82019-06-03 14:12:44 +020040#include "tree_schema.h"
David Sedlák3b4db242018-10-19 16:11:01 +020041#include "tree_schema_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020042#include "xml.h"
David Sedlák00250342019-06-21 14:19:39 +020043
Radek Krejci77114102021-03-10 15:21:57 +010044struct lys_glob_unres;
45
David Sedlák2b214ac2019-06-06 16:11:03 +020046/**
47 * @brief check if given string is URI of yin namespace.
David Sedlák8985a142019-07-31 16:43:06 +020048 *
David Sedlák2b214ac2019-06-06 16:11:03 +020049 * @param ns Namespace URI to check.
50 *
51 * @return true if ns equals YIN_NS_URI false otherwise.
52 */
53#define IS_YIN_NS(ns) (strcmp(ns, YIN_NS_URI) == 0)
54
Michal Vaskoafac7822020-10-20 14:22:26 +020055enum yin_argument {
56 YIN_ARG_UNKNOWN = 0, /**< parsed argument can not be matched with any supported yin argument keyword */
57 YIN_ARG_NAME, /**< argument name */
58 YIN_ARG_TARGET_NODE, /**< argument target-node */
59 YIN_ARG_MODULE, /**< argument module */
60 YIN_ARG_VALUE, /**< argument value */
61 YIN_ARG_TEXT, /**< argument text */
62 YIN_ARG_CONDITION, /**< argument condition */
63 YIN_ARG_URI, /**< argument uri */
64 YIN_ARG_DATE, /**< argument data */
65 YIN_ARG_TAG, /**< argument tag */
66 YIN_ARG_NONE /**< empty (special value) */
67};
68
Michal Vasko22df3f02020-08-24 13:29:22 +020069const char * const yin_attr_list[] = {
David Sedlákf6251182019-06-06 10:22:13 +020070 [YIN_ARG_NAME] = "name",
71 [YIN_ARG_TARGET_NODE] = "target-node",
72 [YIN_ARG_MODULE] = "module",
73 [YIN_ARG_VALUE] = "value",
74 [YIN_ARG_TEXT] = "text",
75 [YIN_ARG_CONDITION] = "condition",
76 [YIN_ARG_URI] = "uri",
77 [YIN_ARG_DATE] = "date",
78 [YIN_ARG_TAG] = "tag",
David Sedlák071f7662019-09-12 02:02:51 +020079 [YIN_ARG_NONE] = "none",
David Sedlákf6251182019-06-06 10:22:13 +020080};
81
Michal Vaskoafac7822020-10-20 14:22:26 +020082#define yin_attr2str(STMT) yin_attr_list[STMT]
83
84#define VALID_VALS1 " Only valid value is \"%s\"."
85#define VALID_VALS2 " Valid values are \"%s\" and \"%s\"."
86#define VALID_VALS3 " Valid values are \"%s\", \"%s\" and \"%s\"."
87#define VALID_VALS4 " Valid values are \"%s\", \"%s\", \"%s\" and \"%s\"."
88
89/* shortcut to determin if keyword can in general be subelement of deviation regardles of it's type */
90#define isdevsub(kw) (kw == LY_STMT_CONFIG || kw == LY_STMT_DEFAULT || kw == LY_STMT_MANDATORY || \
91 kw == LY_STMT_MAX_ELEMENTS || kw == LY_STMT_MIN_ELEMENTS || \
92 kw == LY_STMT_MUST || kw == LY_STMT_TYPE || kw == LY_STMT_UNIQUE || \
93 kw == LY_STMT_UNITS || kw == LY_STMT_EXTENSION_INSTANCE)
94
95/* flags to set constraints of subelements */
96#define YIN_SUBELEM_MANDATORY 0x01 /**< is set when subelement is mandatory */
97#define YIN_SUBELEM_UNIQUE 0x02 /**< is set when subelement is unique */
98#define YIN_SUBELEM_FIRST 0x04 /**< is set when subelement is actually yang argument mapped to yin element */
99#define YIN_SUBELEM_VER2 0x08 /**< subelemnt is allowed only in modules with version at least 2 (YANG 1.1) */
100
101#define YIN_SUBELEM_PARSED 0x80 /**< is set during parsing when given subelement is encountered for the first
102 time to simply check validity of given constraints */
103
104struct yin_subelement {
105 enum ly_stmt type; /**< type of keyword */
106 void *dest; /**< meta infromation passed to responsible function (mostly information about where parsed subelement should be stored) */
107 uint16_t flags; /**< describes constraints of subelement can be set to YIN_SUBELEM_MANDATORY, YIN_SUBELEM_UNIQUE, YIN_SUBELEM_FIRST, YIN_SUBELEM_VER2, and YIN_SUBELEM_DEFAULT_TEXT */
108};
109
110/* Meta information passed to yin_parse_argument function,
111 holds information about where content of argument element will be stored. */
112struct yin_argument_meta {
113 uint16_t *flags; /**< Argument flags */
114 const char **argument; /**< Argument value */
115};
116
117/**
118 * @brief Meta information passed to functions working with tree_schema,
119 * that require additional information about parent node.
120 */
121struct tree_node_meta {
122 struct lysp_node *parent; /**< parent node */
123 struct lysp_node **nodes; /**< linked list of siblings */
124};
125
126/**
127 * @brief Meta information passed to yin_parse_import function.
128 */
129struct import_meta {
130 const char *prefix; /**< module prefix. */
131 struct lysp_import **imports; /**< imports to add to. */
132};
133
134/**
135 * @brief Meta information passed to yin_parse_include function.
136 */
137struct include_meta {
138 const char *name; /**< Module/submodule name. */
139 struct lysp_include **includes; /**< [Sized array](@ref sizedarrays) of parsed includes to add to. */
140};
141
142/**
143 * @brief Meta information passed to yin_parse_inout function.
144 */
145struct inout_meta {
146 struct lysp_node *parent; /**< Parent node. */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100147 struct lysp_node_action_inout *inout_p; /**< inout_p Input/output pointer to write to. */
Michal Vaskoafac7822020-10-20 14:22:26 +0200148};
149
150/**
151 * @brief Meta information passed to yin_parse_minmax function.
152 */
153struct minmax_dev_meta {
154 uint32_t *lim; /**< min/max value to write to. */
155 uint16_t *flags; /**< min/max flags to write to. */
156 struct lysp_ext_instance **exts; /**< extension instances to add to. */
157};
158
159LY_ERR yin_parse_content(struct lys_yin_parser_ctx *ctx, struct yin_subelement *subelem_info, size_t subelem_info_size,
160 enum ly_stmt current_element, const char **text_content, struct lysp_ext_instance **exts);
161
162/**
163 * @brief Match yang keyword from yin data.
164 *
165 * @param[in,out] ctx Yin parser context for logging and to store current state.
166 * @param[in] name Start of keyword name
167 * @param[in] name_len Lenght of keyword name.
168 * @param[in] prefix Start of keyword prefix.
169 * @param[in] prefix_len Lenght of prefix.
170 * @param[in] parrent Identification of parrent element, use LY_STMT_NONE for elements without parrent.
171 *
172 * @return yang_keyword values.
173 */
Radek Krejcid6b76452019-09-03 17:03:03 +0200174enum ly_stmt
Michal Vaskob36053d2020-03-26 15:49:30 +0100175yin_match_keyword(struct lys_yin_parser_ctx *ctx, const char *name, size_t name_len,
Radek Krejci0f969882020-08-21 16:56:47 +0200176 const char *prefix, size_t prefix_len, enum ly_stmt parent)
David Sedlák1bccdfa2019-06-17 15:55:27 +0200177{
David Sedlák8f7a1172019-06-20 14:42:18 +0200178 const char *start = NULL;
Radek Krejcid6b76452019-09-03 17:03:03 +0200179 enum ly_stmt kw = LY_STMT_NONE;
David Sedlák8f7a1172019-06-20 14:42:18 +0200180 const struct lyxml_ns *ns = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +0200181 struct ly_in *in;
David Sedlák8f7a1172019-06-20 14:42:18 +0200182
Michal Vasko69730152020-10-09 16:30:07 +0200183 if (!name || (name_len == 0)) {
Radek Krejcid6b76452019-09-03 17:03:03 +0200184 return LY_STMT_NONE;
David Sedlák1bccdfa2019-06-17 15:55:27 +0200185 }
186
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200187 ns = lyxml_ns_get(&ctx->xmlctx->ns, prefix, prefix_len);
David Sedlák8f7a1172019-06-20 14:42:18 +0200188 if (ns) {
189 if (!IS_YIN_NS(ns->uri)) {
Radek Krejcid6b76452019-09-03 17:03:03 +0200190 return LY_STMT_EXTENSION_INSTANCE;
David Sedlák8f7a1172019-06-20 14:42:18 +0200191 }
192 } else {
193 /* elements without namespace are automatically unknown */
Radek Krejcid6b76452019-09-03 17:03:03 +0200194 return LY_STMT_NONE;
David Sedlák8f7a1172019-06-20 14:42:18 +0200195 }
David Sedlák1bccdfa2019-06-17 15:55:27 +0200196
Michal Vasko63f3d842020-07-08 10:10:14 +0200197 LY_CHECK_RET(ly_in_new_memory(name, &in), LY_STMT_NONE);
198 start = in->current;
Radek Krejcid54412f2020-12-17 20:25:35 +0100199 kw = lysp_match_kw(in, NULL);
Michal Vasko63f3d842020-07-08 10:10:14 +0200200 name = in->current;
201 ly_in_free(in, 0);
David Sedlák8f7a1172019-06-20 14:42:18 +0200202
203 if (name - start == (long int)name_len) {
David Sedlákc1771b12019-07-10 15:55:46 +0200204 /* this is done because of collision in yang statement value and yang argument mapped to yin element value */
Michal Vasko69730152020-10-09 16:30:07 +0200205 if ((kw == LY_STMT_VALUE) && (parent == LY_STMT_ERROR_MESSAGE)) {
Radek Krejcid6b76452019-09-03 17:03:03 +0200206 return LY_STMT_ARG_VALUE;
David Sedlákc1771b12019-07-10 15:55:46 +0200207 }
David Sedlák1bccdfa2019-06-17 15:55:27 +0200208 return kw;
209 } else {
David Sedlák3ffbc522019-07-02 17:49:28 +0200210 if (strncmp(start, "text", name_len) == 0) {
Radek Krejcid6b76452019-09-03 17:03:03 +0200211 return LY_STMT_ARG_TEXT;
David Sedlák3ffbc522019-07-02 17:49:28 +0200212 } else {
Radek Krejcid6b76452019-09-03 17:03:03 +0200213 return LY_STMT_NONE;
David Sedlák3ffbc522019-07-02 17:49:28 +0200214 }
David Sedlák1bccdfa2019-06-17 15:55:27 +0200215 }
216}
217
Michal Vaskoafac7822020-10-20 14:22:26 +0200218/**
219 * @brief Match argument name.
220 *
221 * @param[in] name String representing name.
222 * @param[in] len Lenght of the name.
223 *
224 * @return yin_argument values.
225 */
David Sedlákc5b20842019-08-13 10:18:31 +0200226enum yin_argument
David Sedlák060b00e2019-06-19 11:12:06 +0200227yin_match_argument_name(const char *name, size_t len)
David Sedlák3b4db242018-10-19 16:11:01 +0200228{
David Sedlákc5b20842019-08-13 10:18:31 +0200229 enum yin_argument arg = YIN_ARG_UNKNOWN;
David Sedlák872c7b42018-10-26 13:15:20 +0200230 size_t already_read = 0;
Michal Vasko69730152020-10-09 16:30:07 +0200231
David Sedlák7ff55a92019-06-17 11:11:41 +0200232 LY_CHECK_RET(len == 0, YIN_ARG_NONE);
David Sedlák3b4db242018-10-19 16:11:01 +0200233
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200234#define READ_INC(LEN) already_read += LEN
235#define ARG_SET(STMT) arg=STMT
236#define ARG_CHECK(STR, LEN) (!strncmp((name) + already_read, STR, LEN) && (READ_INC(LEN)))
David Sedlákc10e7902018-12-17 02:17:59 +0100237
David Sedlák1c8b2702019-02-22 11:03:02 +0100238 switch (*name) {
David Sedlák94de2aa2019-02-15 12:42:11 +0100239 case 'c':
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200240 READ_INC(1);
241 if (ARG_CHECK("ondition", 8)) {
242 ARG_SET(YIN_ARG_CONDITION);
243 }
David Sedlák3b4db242018-10-19 16:11:01 +0200244 break;
David Sedlák872c7b42018-10-26 13:15:20 +0200245
David Sedlák94de2aa2019-02-15 12:42:11 +0100246 case 'd':
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200247 READ_INC(1);
248 if (ARG_CHECK("ate", 3)) {
249 ARG_SET(YIN_ARG_DATE);
250 }
David Sedlák3b4db242018-10-19 16:11:01 +0200251 break;
David Sedlák872c7b42018-10-26 13:15:20 +0200252
David Sedlák94de2aa2019-02-15 12:42:11 +0100253 case 'm':
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200254 READ_INC(1);
255 if (ARG_CHECK("odule", 5)) {
256 ARG_SET(YIN_ARG_MODULE);
257 }
David Sedlák872c7b42018-10-26 13:15:20 +0200258 break;
259
David Sedlák94de2aa2019-02-15 12:42:11 +0100260 case 'n':
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200261 READ_INC(1);
262 if (ARG_CHECK("ame", 3)) {
263 ARG_SET(YIN_ARG_NAME);
264 }
David Sedlák872c7b42018-10-26 13:15:20 +0200265 break;
266
David Sedlák94de2aa2019-02-15 12:42:11 +0100267 case 't':
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200268 READ_INC(1);
269 if (ARG_CHECK("a", 1)) {
270 if (ARG_CHECK("g", 1)) {
271 ARG_SET(YIN_ARG_TAG);
272 } else if (ARG_CHECK("rget-node", 9)) {
273 ARG_SET(YIN_ARG_TARGET_NODE);
274 }
275 } else if (ARG_CHECK("ext", 3)) {
276 ARG_SET(YIN_ARG_TEXT);
277 }
David Sedlák3b4db242018-10-19 16:11:01 +0200278 break;
David Sedlák872c7b42018-10-26 13:15:20 +0200279
David Sedlák94de2aa2019-02-15 12:42:11 +0100280 case 'u':
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200281 READ_INC(1);
282 if (ARG_CHECK("ri", 2)) {
283 ARG_SET(YIN_ARG_URI);
284 }
David Sedlák3b4db242018-10-19 16:11:01 +0200285 break;
David Sedlák872c7b42018-10-26 13:15:20 +0200286
David Sedlák94de2aa2019-02-15 12:42:11 +0100287 case 'v':
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200288 READ_INC(1);
289 if (ARG_CHECK("alue", 4)) {
290 ARG_SET(YIN_ARG_VALUE);
291 }
David Sedlák3b4db242018-10-19 16:11:01 +0200292 break;
293 }
294
David Sedlákc10e7902018-12-17 02:17:59 +0100295 /* whole argument must be matched */
David Sedlák872c7b42018-10-26 13:15:20 +0200296 if (already_read != len) {
David Sedláka7406952019-04-05 10:33:07 +0200297 arg = YIN_ARG_UNKNOWN;
David Sedlák872c7b42018-10-26 13:15:20 +0200298 }
299
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200300#undef ARG_CHECK
301#undef ARG_SET
302#undef READ_INC
David Sedlák18730132019-03-15 15:51:34 +0100303
David Sedlák872c7b42018-10-26 13:15:20 +0200304 return arg;
David Sedlák3b4db242018-10-19 16:11:01 +0200305}
306
Radek Krejcid6b76452019-09-03 17:03:03 +0200307#define IS_NODE_ELEM(kw) (kw == LY_STMT_ANYXML || kw == LY_STMT_ANYDATA || kw == LY_STMT_LEAF || kw == LY_STMT_LEAF_LIST || \
308 kw == LY_STMT_TYPEDEF || kw == LY_STMT_USES || kw == LY_STMT_LIST || kw == LY_STMT_NOTIFICATION || \
309 kw == LY_STMT_GROUPING || kw == LY_STMT_CONTAINER || kw == LY_STMT_CASE || kw == LY_STMT_CHOICE || \
310 kw == LY_STMT_ACTION || kw == LY_STMT_RPC || kw == LY_STMT_AUGMENT)
David Sedlák81497a32019-08-13 16:56:26 +0200311
Radek Krejcid6b76452019-09-03 17:03:03 +0200312#define HAS_META(kw) (IS_NODE_ELEM(kw) || kw == LY_STMT_IMPORT || kw == LY_STMT_INCLUDE || kw == LY_STMT_INPUT || kw == LY_STMT_OUTPUT)
David Sedlák81497a32019-08-13 16:56:26 +0200313
David Sedlák26ea1432019-08-14 13:42:23 +0200314/**
315 * @brief Free subelems information allocated on heap.
316 *
317 * @param[in] count Size of subelems array.
318 * @param[in] subelems Subelems array to free.
319 */
David Sedlák81497a32019-08-13 16:56:26 +0200320static void
321subelems_deallocator(size_t count, struct yin_subelement *subelems)
322{
Michal Vaskod989ba02020-08-24 10:59:24 +0200323 for (size_t i = 0; i < count; ++i) {
David Sedlák81497a32019-08-13 16:56:26 +0200324 if (HAS_META(subelems[i].type)) {
325 free(subelems[i].dest);
326 }
327 }
328
329 free(subelems);
330}
331
David Sedlák26ea1432019-08-14 13:42:23 +0200332/**
333 * @brief Allocate subelems information on heap.
334 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200335 * @param[in] ctx YIN parser context, used for logging.
David Sedlák26ea1432019-08-14 13:42:23 +0200336 * @param[in] count Number of subelements.
337 * @param[in] parent Parent node if any.
338 * @param[out] result Allocated subelems array.
339 *
340 * @return LY_SUCCESS on success LY_EMEM on memmory allocation failure.
341 */
David Sedlák81497a32019-08-13 16:56:26 +0200342static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100343subelems_allocator(struct lys_yin_parser_ctx *ctx, size_t count, struct lysp_node *parent,
Radek Krejci0f969882020-08-21 16:56:47 +0200344 struct yin_subelement **result, ...)
David Sedlák81497a32019-08-13 16:56:26 +0200345{
346 va_list ap;
347
348 *result = calloc(count, sizeof **result);
David Sedlákbf8a2b72019-08-14 16:48:10 +0200349 LY_CHECK_GOTO(!(*result), mem_err);
David Sedlák81497a32019-08-13 16:56:26 +0200350
351 va_start(ap, result);
352 for (size_t i = 0; i < count; ++i) {
353 /* TYPE */
Radek Krejcid6b76452019-09-03 17:03:03 +0200354 (*result)[i].type = va_arg(ap, enum ly_stmt);
David Sedlák81497a32019-08-13 16:56:26 +0200355 /* DEST */
356 if (IS_NODE_ELEM((*result)[i].type)) {
357 struct tree_node_meta *node_meta = NULL;
358 node_meta = calloc(1, sizeof *node_meta);
David Sedlákbf8a2b72019-08-14 16:48:10 +0200359 LY_CHECK_GOTO(!node_meta, mem_err);
David Sedlák81497a32019-08-13 16:56:26 +0200360 node_meta->parent = parent;
David Sedlákbf8a2b72019-08-14 16:48:10 +0200361 node_meta->nodes = va_arg(ap, void *);
David Sedlák81497a32019-08-13 16:56:26 +0200362 (*result)[i].dest = node_meta;
Radek Krejcid6b76452019-09-03 17:03:03 +0200363 } else if ((*result)[i].type == LY_STMT_IMPORT) {
David Sedlák81497a32019-08-13 16:56:26 +0200364 struct import_meta *imp_meta = NULL;
365 imp_meta = calloc(1, sizeof *imp_meta);
David Sedlákbf8a2b72019-08-14 16:48:10 +0200366 LY_CHECK_GOTO(!imp_meta, mem_err);
David Sedlák81497a32019-08-13 16:56:26 +0200367 imp_meta->prefix = va_arg(ap, const char *);
368 imp_meta->imports = va_arg(ap, struct lysp_import **);
369 (*result)[i].dest = imp_meta;
Radek Krejcid6b76452019-09-03 17:03:03 +0200370 } else if ((*result)[i].type == LY_STMT_INCLUDE) {
David Sedlák81497a32019-08-13 16:56:26 +0200371 struct include_meta *inc_meta = NULL;
372 inc_meta = calloc(1, sizeof *inc_meta);
David Sedlákbf8a2b72019-08-14 16:48:10 +0200373 LY_CHECK_GOTO(!inc_meta, mem_err);
David Sedlák81497a32019-08-13 16:56:26 +0200374 inc_meta->name = va_arg(ap, const char *);
375 inc_meta->includes = va_arg(ap, struct lysp_include **);
376 (*result)[i].dest = inc_meta;
Michal Vasko69730152020-10-09 16:30:07 +0200377 } else if (((*result)[i].type == LY_STMT_INPUT) || ((*result)[i].type == LY_STMT_OUTPUT)) {
David Sedlák81497a32019-08-13 16:56:26 +0200378 struct inout_meta *inout_meta = NULL;
379 inout_meta = calloc(1, sizeof *inout_meta);
David Sedlákbf8a2b72019-08-14 16:48:10 +0200380 LY_CHECK_GOTO(!inout_meta, mem_err);
David Sedlák81497a32019-08-13 16:56:26 +0200381 inout_meta->parent = parent;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100382 inout_meta->inout_p = va_arg(ap, struct lysp_node_action_inout *);
David Sedlák81497a32019-08-13 16:56:26 +0200383 (*result)[i].dest = inout_meta;
384 } else {
385 (*result)[i].dest = va_arg(ap, void *);
386 }
387 /* FLAGS */
388 (*result)[i].flags = va_arg(ap, int);
389 }
390 va_end(ap);
391
392 return LY_SUCCESS;
393
David Sedlákbf8a2b72019-08-14 16:48:10 +0200394mem_err:
David Sedlák81497a32019-08-13 16:56:26 +0200395 subelems_deallocator(count, *result);
Michal Vaskob36053d2020-03-26 15:49:30 +0100396 LOGMEM(ctx->xmlctx->ctx);
David Sedlák81497a32019-08-13 16:56:26 +0200397 return LY_EMEM;
398}
399
Michal Vaskoafac7822020-10-20 14:22:26 +0200400/**
401 * @brief Check that val is valid UTF8 character sequence of val_type.
402 * Doesn't check empty string, only character validity.
403 *
404 * @param[in] ctx Yin parser context for logging.
405 * @param[in] val_type Type of the input string to select method of checking character validity.
406 *
407 * @return LY_ERR values.
408 */
David Sedlák8f7a1172019-06-20 14:42:18 +0200409LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100410yin_validate_value(struct lys_yin_parser_ctx *ctx, enum yang_arg val_type)
David Sedlák4a650532019-07-10 11:55:18 +0200411{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200412 uint8_t prefix = 0;
413 uint32_t c;
Michal Vaskob36053d2020-03-26 15:49:30 +0100414 size_t utf8_char_len, already_read = 0;
415 const char *val;
416
417 assert((ctx->xmlctx->status == LYXML_ELEM_CONTENT) || (ctx->xmlctx->status == LYXML_ATTR_CONTENT));
418
419 val = ctx->xmlctx->value;
420 while (already_read < ctx->xmlctx->value_len) {
David Sedlák4a650532019-07-10 11:55:18 +0200421 LY_CHECK_ERR_RET(ly_getutf8((const char **)&val, &c, &utf8_char_len),
Michal Vasko69730152020-10-09 16:30:07 +0200422 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INCHAR, (val)[-utf8_char_len]), LY_EVALID);
David Sedlák4a650532019-07-10 11:55:18 +0200423
424 switch (val_type) {
425 case Y_IDENTIF_ARG:
Radek Krejci1deb5be2020-08-26 16:43:36 +0200426 LY_CHECK_RET(lysp_check_identifierchar((struct lys_parser_ctx *)ctx, c, already_read ? 0 : 1, NULL));
David Sedlák4a650532019-07-10 11:55:18 +0200427 break;
428 case Y_PREF_IDENTIF_ARG:
Radek Krejci1deb5be2020-08-26 16:43:36 +0200429 LY_CHECK_RET(lysp_check_identifierchar((struct lys_parser_ctx *)ctx, c, already_read ? 0 : 1, &prefix));
David Sedlák4a650532019-07-10 11:55:18 +0200430 break;
431 case Y_STR_ARG:
432 case Y_MAYBE_STR_ARG:
433 LY_CHECK_RET(lysp_check_stringchar((struct lys_parser_ctx *)ctx, c));
434 break;
435 }
Radek Iša2eac74c2021-03-15 15:53:08 +0100436
437 already_read += utf8_char_len;
438 LY_CHECK_ERR_RET(already_read > ctx->xmlctx->value_len, LOGINT(ctx->xmlctx->ctx), LY_EINT);
David Sedlák4a650532019-07-10 11:55:18 +0200439 }
440
Radek Iša42cc0b72021-03-15 16:51:31 +0100441 if ((already_read == 0) &&
442 ((val_type == Y_PREF_IDENTIF_ARG) || (val_type == Y_IDENTIF_ARG))) {
443 /* Empty identifier or prefix*/
444 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YIN, "Empty identifier is not allowed.");
445 return LY_EVALID;
446 }
447
David Sedlák4a650532019-07-10 11:55:18 +0200448 return LY_SUCCESS;
449}
450
David Sedlákb4e44562019-07-04 15:42:12 +0200451/**
Michal Vaskob36053d2020-03-26 15:49:30 +0100452 * @brief Parse yin attributes.
David Sedlákb4e44562019-07-04 15:42:12 +0200453 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200454 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák4a650532019-07-10 11:55:18 +0200455 * @param[in] arg_type Type of argument that is expected in parsed element (use YIN_ARG_NONE for elements without
456 * special argument).
David Sedlákbf8a2b72019-08-14 16:48:10 +0200457 * @param[out] arg_val Where value of argument should be stored. Can be NULL iff arg_type is specified as YIN_ARG_NONE.
David Sedlák292763b2019-07-09 11:10:53 +0200458 * @param[in] val_type Type of expected value of attribute.
David Sedlákb4e44562019-07-04 15:42:12 +0200459 * @param[in] current_element Identification of current element, used for logging.
460 *
461 * @return LY_ERR values.
462 */
463static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100464yin_parse_attribute(struct lys_yin_parser_ctx *ctx, enum yin_argument arg_type, const char **arg_val, enum yang_arg val_type,
Radek Krejci0f969882020-08-21 16:56:47 +0200465 enum ly_stmt current_element)
David Sedlák8f7a1172019-06-20 14:42:18 +0200466{
David Sedlákc5b20842019-08-13 10:18:31 +0200467 enum yin_argument arg = YIN_ARG_UNKNOWN;
David Sedlák619db942019-07-03 14:47:30 +0200468 bool found = false;
David Sedlák8f7a1172019-06-20 14:42:18 +0200469
David Sedlák1bccdfa2019-06-17 15:55:27 +0200470 /* validation of attributes */
Michal Vaskob36053d2020-03-26 15:49:30 +0100471 while (ctx->xmlctx->status == LYXML_ATTRIBUTE) {
David Sedlák00250342019-06-21 14:19:39 +0200472 /* yin arguments represented as attributes have no namespace, which in this case means no prefix */
Michal Vaskob36053d2020-03-26 15:49:30 +0100473 if (!ctx->xmlctx->prefix) {
474 arg = yin_match_argument_name(ctx->xmlctx->name, ctx->xmlctx->name_len);
David Sedlák7ff55a92019-06-17 11:11:41 +0200475 if (arg == YIN_ARG_NONE) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100476 /* skip it */
477 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
David Sedlák7ff55a92019-06-17 11:11:41 +0200478 } else if (arg == arg_type) {
David Sedlák1538a842019-08-08 15:38:51 +0200479 LY_CHECK_ERR_RET(found, LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_DUP_ATTR,
Michal Vasko69730152020-10-09 16:30:07 +0200480 yin_attr2str(arg), ly_stmt2str(current_element)), LY_EVALID);
David Sedlák619db942019-07-03 14:47:30 +0200481 found = true;
Michal Vaskob36053d2020-03-26 15:49:30 +0100482
483 /* go to value */
484 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
485 LY_CHECK_RET(yin_validate_value(ctx, val_type));
Radek Krejci011e4aa2020-09-04 15:22:31 +0200486 INSERT_STRING_RET(ctx->xmlctx->ctx, ctx->xmlctx->value, ctx->xmlctx->value_len, ctx->xmlctx->dynamic, *arg_val);
David Sedlák169cc522019-08-15 13:23:45 +0200487 LY_CHECK_RET(!(*arg_val), LY_EMEM);
David Sedlák2b214ac2019-06-06 16:11:03 +0200488 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100489 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_UNEXP_ATTR, ctx->xmlctx->name_len,
Michal Vasko69730152020-10-09 16:30:07 +0200490 ctx->xmlctx->name, ly_stmt2str(current_element));
David Sedlák619db942019-07-03 14:47:30 +0200491 return LY_EVALID;
David Sedláka7406952019-04-05 10:33:07 +0200492 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100493 } else {
494 /* skip it */
495 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
David Sedláka7406952019-04-05 10:33:07 +0200496 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100497
498 /* next attribute */
499 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
David Sedláka7406952019-04-05 10:33:07 +0200500 }
501
David Sedlák292763b2019-07-09 11:10:53 +0200502 /* anything else than Y_MAYBE_STR_ARG is mandatory */
Michal Vasko69730152020-10-09 16:30:07 +0200503 if ((val_type != Y_MAYBE_STR_ARG) && !found) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100504 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LYVE_SYNTAX_YIN, "Missing mandatory attribute %s of %s element.",
Michal Vasko69730152020-10-09 16:30:07 +0200505 yin_attr2str(arg_type), ly_stmt2str(current_element));
David Sedlák619db942019-07-03 14:47:30 +0200506 return LY_EVALID;
507 }
508
509 return LY_SUCCESS;
David Sedláka7406952019-04-05 10:33:07 +0200510}
511
David Sedlákd6e56892019-07-01 15:40:24 +0200512/**
Radek Krejci12b1c152019-09-05 16:20:48 +0200513 * @brief Get record with given type.
David Sedlákd6e56892019-07-01 15:40:24 +0200514 *
515 * @param[in] type Type of wanted record.
516 * @param[in] array_size Size of array.
517 * @param[in] array Searched array.
518 *
519 * @return Pointer to desired record on success, NULL if element is not in the array.
520 */
David Sedlákb4e44562019-07-04 15:42:12 +0200521static struct yin_subelement *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200522get_record(enum ly_stmt type, LY_ARRAY_COUNT_TYPE array_size, struct yin_subelement *array)
David Sedlákd6e56892019-07-01 15:40:24 +0200523{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200524 for (LY_ARRAY_COUNT_TYPE u = 0; u < array_size; ++u) {
Radek Krejci12b1c152019-09-05 16:20:48 +0200525 if (array[u].type == type) {
526 return &array[u];
David Sedlákd6e56892019-07-01 15:40:24 +0200527 }
528 }
David Sedlákd6e56892019-07-01 15:40:24 +0200529 return NULL;
530}
531
David Sedlákbba38e52019-07-09 15:20:01 +0200532/**
533 * @brief Helper function to check mandatory constraint of subelement.
534 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200535 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbba38e52019-07-09 15:20:01 +0200536 * @param[in] subelem_info Array of information about subelements.
537 * @param[in] subelem_info_size Size of subelem_info array.
538 * @param[in] current_element Identification of element that is currently being parsed, used for logging.
539 *
540 * @return LY_ERR values.
541 */
542static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100543yin_check_subelem_mandatory_constraint(struct lys_yin_parser_ctx *ctx, struct yin_subelement *subelem_info,
Radek Krejci0f969882020-08-21 16:56:47 +0200544 signed char subelem_info_size, enum ly_stmt current_element)
David Sedlák21f87cd2019-07-03 16:53:23 +0200545{
David Sedlákb0faad82019-07-04 14:28:59 +0200546 for (signed char i = 0; i < subelem_info_size; ++i) {
David Sedlák5545f5d2019-07-11 11:55:16 +0200547 /* if there is element that is mandatory and isn't parsed log error and return LY_EVALID */
Radek Krejci12b1c152019-09-05 16:20:48 +0200548 if ((subelem_info[i].flags & YIN_SUBELEM_MANDATORY) && !(subelem_info[i].flags & YIN_SUBELEM_PARSED)) {
David Sedlák1538a842019-08-08 15:38:51 +0200549 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_MAND_SUBELEM,
Michal Vasko69730152020-10-09 16:30:07 +0200550 ly_stmt2str(subelem_info[i].type), ly_stmt2str(current_element));
David Sedlák21f87cd2019-07-03 16:53:23 +0200551 return LY_EVALID;
552 }
553 }
554
555 return LY_SUCCESS;
556}
557
David Sedlákbba38e52019-07-09 15:20:01 +0200558/**
559 * @brief Helper function to check "first" constraint of subelement.
560 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200561 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbba38e52019-07-09 15:20:01 +0200562 * @param[in] subelem_info Array of information about subelements.
563 * @param[in] subelem_info_size Size of subelem_info array.
564 * @param[in] current_element Identification of element that is currently being parsed, used for logging.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200565 * @param[in] exp_first Record in subelem_info array that is expected to be defined as first subelement, used for logging.
David Sedlákbba38e52019-07-09 15:20:01 +0200566 *
567 * @return LY_ERR values.
568 */
569static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100570yin_check_subelem_first_constraint(struct lys_yin_parser_ctx *ctx, struct yin_subelement *subelem_info,
Radek Krejci0f969882020-08-21 16:56:47 +0200571 signed char subelem_info_size, enum ly_stmt current_element,
572 struct yin_subelement *exp_first)
David Sedlák21f87cd2019-07-03 16:53:23 +0200573{
David Sedlákb0faad82019-07-04 14:28:59 +0200574 for (signed char i = 0; i < subelem_info_size; ++i) {
David Sedlák21f87cd2019-07-03 16:53:23 +0200575 if (subelem_info[i].flags & YIN_SUBELEM_PARSED) {
David Sedlák1538a842019-08-08 15:38:51 +0200576 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_FIRT_SUBELEM,
Michal Vasko69730152020-10-09 16:30:07 +0200577 ly_stmt2str(exp_first->type), ly_stmt2str(current_element));
David Sedlák21f87cd2019-07-03 16:53:23 +0200578 return LY_EVALID;
579 }
580 }
581
582 return LY_SUCCESS;
583}
584
David Sedlákbba38e52019-07-09 15:20:01 +0200585/**
David Sedlákb4e44562019-07-04 15:42:12 +0200586 * @brief Parse simple element without any special constraints and argument mapped to yin attribute,
587 * for example prefix or namespace element.
David Sedlákd6e56892019-07-01 15:40:24 +0200588 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200589 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákb4e44562019-07-04 15:42:12 +0200590 * @param[in] kw Type of current element.
591 * @param[out] value Where value of attribute should be stored.
592 * @param[in] arg_type Expected type of attribute.
David Sedlák292763b2019-07-09 11:10:53 +0200593 * @param[in] arg_val_type Type of expected value of attribute.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200594 * @param[in,out] exts Extension instances to add to.
David Sedlákd6e56892019-07-01 15:40:24 +0200595 * @return LY_ERR values.
596 */
David Sedlákb4e44562019-07-04 15:42:12 +0200597static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100598yin_parse_simple_element(struct lys_yin_parser_ctx *ctx, enum ly_stmt kw, const char **value,
Radek Krejci0f969882020-08-21 16:56:47 +0200599 enum yin_argument arg_type, enum yang_arg arg_val_type, struct lysp_ext_instance **exts)
David Sedlákb4e44562019-07-04 15:42:12 +0200600{
Michal Vaskob36053d2020-03-26 15:49:30 +0100601 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
602 LY_CHECK_RET(yin_parse_attribute(ctx, arg_type, value, arg_val_type, kw));
Radek Krejcif13b87b2020-12-01 22:02:17 +0100603 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200604 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
605 };
David Sedlákb4e44562019-07-04 15:42:12 +0200606
Radek Krejcif13b87b2020-12-01 22:02:17 +0100607 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), kw, NULL, exts);
David Sedlákb4e44562019-07-04 15:42:12 +0200608}
609
610/**
David Sedlák6542aed2019-08-14 10:47:43 +0200611 * @brief Parse path element.
612 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200613 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák6542aed2019-08-14 10:47:43 +0200614 * @param[in] kw Type of current element.
615 * @param[out] type Type structure to store parsed value, flags and extension instances.
David Sedlák6542aed2019-08-14 10:47:43 +0200616 * @return LY_ERR values.
617 */
618static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100619yin_parse_path(struct lys_yin_parser_ctx *ctx, enum ly_stmt kw, struct lysp_type *type)
David Sedlák6542aed2019-08-14 10:47:43 +0200620{
Michal Vasko004d3152020-06-11 19:59:22 +0200621 LY_ERR ret;
622 const char *str_path;
623
624 LY_CHECK_RET(yin_parse_simple_element(ctx, kw, &str_path, YIN_ARG_VALUE, Y_STR_ARG, &type->exts));
Michal Vaskoed725d72021-06-23 12:03:45 +0200625 ret = ly_path_parse(ctx->xmlctx->ctx, NULL, str_path, 0, 1, LY_PATH_BEGIN_EITHER,
Michal Vasko69730152020-10-09 16:30:07 +0200626 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_LEAFREF, &type->path);
Michal Vasko004d3152020-06-11 19:59:22 +0200627 lydict_remove(ctx->xmlctx->ctx, str_path);
628 LY_CHECK_RET(ret);
David Sedlák6542aed2019-08-14 10:47:43 +0200629 type->flags |= LYS_SET_PATH;
630
631 return LY_SUCCESS;
632}
633
634/**
David Sedlákd3983112019-07-12 11:20:56 +0200635 * @brief Parse pattern element.
636 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200637 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200638 * @param[in,out] type Type structure to store parsed value, flags and extension instances.
David Sedlákd3983112019-07-12 11:20:56 +0200639 * @return LY_ERR values.
640 */
641static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100642yin_parse_pattern(struct lys_yin_parser_ctx *ctx, struct lysp_type *type)
David Sedlákd3983112019-07-12 11:20:56 +0200643{
644 const char *real_value = NULL;
645 char *saved_value = NULL;
646 struct lysp_restr *restr;
647
Michal Vaskob36053d2020-03-26 15:49:30 +0100648 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, type->patterns, restr, LY_EMEM);
649 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
650 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &real_value, Y_STR_ARG, LY_STMT_PATTERN));
David Sedlákd3983112019-07-12 11:20:56 +0200651 size_t len = strlen(real_value);
652
653 saved_value = malloc(len + 2);
Michal Vaskob36053d2020-03-26 15:49:30 +0100654 LY_CHECK_ERR_RET(!saved_value, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
David Sedlákd3983112019-07-12 11:20:56 +0200655 memmove(saved_value + 1, real_value, len);
Michal Vaskoe180ed02021-02-05 16:31:20 +0100656 lydict_remove(ctx->xmlctx->ctx, real_value);
Radek Krejcif13b87b2020-12-01 22:02:17 +0100657 saved_value[0] = LYSP_RESTR_PATTERN_ACK;
David Sedlákd3983112019-07-12 11:20:56 +0200658 saved_value[len + 1] = '\0';
Michal Vasko7f45cf22020-10-01 12:49:44 +0200659 LY_CHECK_RET(lydict_insert_zc(ctx->xmlctx->ctx, saved_value, &restr->arg.str));
Michal Vasko8a67eff2021-12-07 14:04:47 +0100660 restr->arg.mod = PARSER_CUR_PMOD(ctx);
David Sedlákd3983112019-07-12 11:20:56 +0200661 type->flags |= LYS_SET_PATTERN;
662
Radek Krejcif13b87b2020-12-01 22:02:17 +0100663 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200664 {LY_STMT_DESCRIPTION, &restr->dsc, YIN_SUBELEM_UNIQUE},
665 {LY_STMT_ERROR_APP_TAG, &restr->eapptag, YIN_SUBELEM_UNIQUE},
666 {LY_STMT_ERROR_MESSAGE, &restr->emsg, YIN_SUBELEM_UNIQUE},
667 {LY_STMT_MODIFIER, &restr->arg, YIN_SUBELEM_UNIQUE},
668 {LY_STMT_REFERENCE, &restr->ref, YIN_SUBELEM_UNIQUE},
669 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
670 };
Michal Vasko69730152020-10-09 16:30:07 +0200671
Radek Krejcif13b87b2020-12-01 22:02:17 +0100672 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_PATTERN, NULL, &restr->exts);
David Sedlákd3983112019-07-12 11:20:56 +0200673}
674
David Sedlákc5b20842019-08-13 10:18:31 +0200675/**
676 * @brief Parse fraction-digits element.
677 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200678 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákc5b20842019-08-13 10:18:31 +0200679 * @param[in,out] type Type structure to store value, flags and extension instances.
David Sedlákc5b20842019-08-13 10:18:31 +0200680 * @return LY_ERR values.
681 */
David Sedlákf75d55e2019-07-12 16:52:50 +0200682static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100683yin_parse_fracdigits(struct lys_yin_parser_ctx *ctx, struct lysp_type *type)
David Sedlákf75d55e2019-07-12 16:52:50 +0200684{
685 const char *temp_val = NULL;
686 char *ptr;
Michal Vasko73d77ab2021-07-23 12:45:55 +0200687 unsigned long long int num;
David Sedlákf75d55e2019-07-12 16:52:50 +0200688
Michal Vaskob36053d2020-03-26 15:49:30 +0100689 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
690 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &temp_val, Y_STR_ARG, LY_STMT_FRACTION_DIGITS));
David Sedlákf75d55e2019-07-12 16:52:50 +0200691
Michal Vasko69730152020-10-09 16:30:07 +0200692 if ((temp_val[0] == '\0') || (temp_val[0] == '0') || !isdigit(temp_val[0])) {
David Sedlák1538a842019-08-08 15:38:51 +0200693 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", "fraction-digits");
Michal Vaskoe180ed02021-02-05 16:31:20 +0100694 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákf75d55e2019-07-12 16:52:50 +0200695 return LY_EVALID;
696 }
697
698 errno = 0;
Michal Vasko73d77ab2021-07-23 12:45:55 +0200699 num = strtoull(temp_val, &ptr, LY_BASE_DEC);
David Sedlákf75d55e2019-07-12 16:52:50 +0200700 if (*ptr != '\0') {
David Sedlák1538a842019-08-08 15:38:51 +0200701 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", "fraction-digits");
Michal Vaskoe180ed02021-02-05 16:31:20 +0100702 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákf75d55e2019-07-12 16:52:50 +0200703 return LY_EVALID;
704 }
Radek Krejcif13b87b2020-12-01 22:02:17 +0100705 if ((errno == ERANGE) || (num > LY_TYPE_DEC64_FD_MAX)) {
David Sedlák1538a842019-08-08 15:38:51 +0200706 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", "fraction-digits");
Michal Vaskoe180ed02021-02-05 16:31:20 +0100707 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákf75d55e2019-07-12 16:52:50 +0200708 return LY_EVALID;
709 }
Michal Vaskoe180ed02021-02-05 16:31:20 +0100710 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákf75d55e2019-07-12 16:52:50 +0200711 type->fraction_digits = num;
712 type->flags |= LYS_SET_FRDIGITS;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100713 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200714 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
715 };
Michal Vasko69730152020-10-09 16:30:07 +0200716
Radek Krejcif13b87b2020-12-01 22:02:17 +0100717 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_FRACTION_DIGITS, NULL, &type->exts);
David Sedlákf75d55e2019-07-12 16:52:50 +0200718}
719
David Sedlák07869a52019-07-12 14:28:19 +0200720/**
David Sedlák43801c92019-08-05 15:58:54 +0200721 * @brief Parse enum element.
David Sedlák07869a52019-07-12 14:28:19 +0200722 *
723 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200724 * @param[in,out] type Type structure to store parsed value, flags and extension instances.
David Sedlák07869a52019-07-12 14:28:19 +0200725 * @return LY_ERR values.
726 */
David Sedlákca36c422019-07-12 12:47:55 +0200727static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100728yin_parse_enum(struct lys_yin_parser_ctx *ctx, struct lysp_type *type)
David Sedlákca36c422019-07-12 12:47:55 +0200729{
David Sedlák07869a52019-07-12 14:28:19 +0200730 struct lysp_type_enum *en;
David Sedlák1e696782019-07-17 15:06:07 +0200731
Michal Vaskob36053d2020-03-26 15:49:30 +0100732 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, type->enums, en, LY_EMEM);
David Sedlák43801c92019-08-05 15:58:54 +0200733 type->flags |= LYS_SET_ENUM;
Michal Vaskob36053d2020-03-26 15:49:30 +0100734 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
735 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &en->name, Y_STR_ARG, LY_STMT_ENUM));
David Sedlák43801c92019-08-05 15:58:54 +0200736 LY_CHECK_RET(lysp_check_enum_name((struct lys_parser_ctx *)ctx, en->name, strlen(en->name)));
Michal Vaskob36053d2020-03-26 15:49:30 +0100737 CHECK_NONEMPTY((struct lys_parser_ctx *)ctx, strlen(en->name), "enum");
David Sedlák43801c92019-08-05 15:58:54 +0200738 CHECK_UNIQUENESS((struct lys_parser_ctx *)ctx, type->enums, name, "enum", en->name);
David Sedlákca36c422019-07-12 12:47:55 +0200739
Radek Krejcif13b87b2020-12-01 22:02:17 +0100740 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200741 {LY_STMT_DESCRIPTION, &en->dsc, YIN_SUBELEM_UNIQUE},
742 {LY_STMT_IF_FEATURE, &en->iffeatures, 0},
743 {LY_STMT_REFERENCE, &en->ref, YIN_SUBELEM_UNIQUE},
744 {LY_STMT_STATUS, &en->flags, YIN_SUBELEM_UNIQUE},
745 {LY_STMT_VALUE, en, YIN_SUBELEM_UNIQUE},
746 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
747 };
Michal Vasko69730152020-10-09 16:30:07 +0200748
Radek Krejcif13b87b2020-12-01 22:02:17 +0100749 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_ENUM, NULL, &en->exts);
David Sedlák43801c92019-08-05 15:58:54 +0200750}
751
752/**
753 * @brief Parse bit element.
754 *
755 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200756 * @param[in,out] type Type structure to store parsed value, flags and extension instances.
David Sedlák43801c92019-08-05 15:58:54 +0200757 * @return LY_ERR values.
758 */
759static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100760yin_parse_bit(struct lys_yin_parser_ctx *ctx, struct lysp_type *type)
David Sedlák43801c92019-08-05 15:58:54 +0200761{
762 struct lysp_type_enum *en;
763
Michal Vaskob36053d2020-03-26 15:49:30 +0100764 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, type->bits, en, LY_EMEM);
David Sedlák43801c92019-08-05 15:58:54 +0200765 type->flags |= LYS_SET_BIT;
Michal Vaskob36053d2020-03-26 15:49:30 +0100766 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
767 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &en->name, Y_IDENTIF_ARG, LY_STMT_BIT));
Radek Iša8b640882021-03-12 17:59:34 +0100768 CHECK_UNIQUENESS((struct lys_parser_ctx *)ctx, type->bits, name, "bit", en->name);
David Sedlák43801c92019-08-05 15:58:54 +0200769
Radek Krejcif13b87b2020-12-01 22:02:17 +0100770 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200771 {LY_STMT_DESCRIPTION, &en->dsc, YIN_SUBELEM_UNIQUE},
772 {LY_STMT_IF_FEATURE, &en->iffeatures, 0},
773 {LY_STMT_POSITION, en, YIN_SUBELEM_UNIQUE},
774 {LY_STMT_REFERENCE, &en->ref, YIN_SUBELEM_UNIQUE},
775 {LY_STMT_STATUS, &en->flags, YIN_SUBELEM_UNIQUE},
776 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
777 };
Michal Vasko69730152020-10-09 16:30:07 +0200778
Radek Krejcif13b87b2020-12-01 22:02:17 +0100779 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_BIT, NULL, &en->exts);
David Sedlákca36c422019-07-12 12:47:55 +0200780}
781
David Sedlákd3983112019-07-12 11:20:56 +0200782/**
David Sedlák5f8191e2019-07-08 16:35:52 +0200783 * @brief Parse simple element without any special constraints and argument mapped to yin attribute, that can have
784 * more instances, such as base or if-feature.
785 *
786 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák5f8191e2019-07-08 16:35:52 +0200787 * @param[in] kw Type of current element.
788 * @param[out] values Parsed values to add to.
789 * @param[in] arg_type Expected type of attribute.
David Sedlák292763b2019-07-09 11:10:53 +0200790 * @param[in] arg_val_type Type of expected value of attribute.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200791 * @param[in,out] exts Extension instances to add to.
David Sedlák5f8191e2019-07-08 16:35:52 +0200792 * @return LY_ERR values.
793 */
794static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100795yin_parse_simple_elements(struct lys_yin_parser_ctx *ctx, enum ly_stmt kw, const char ***values, enum yin_argument arg_type,
Radek Krejci0f969882020-08-21 16:56:47 +0200796 enum yang_arg arg_val_type, struct lysp_ext_instance **exts)
David Sedlák5f8191e2019-07-08 16:35:52 +0200797{
798 const char **value;
Michal Vasko69730152020-10-09 16:30:07 +0200799
Michal Vaskob36053d2020-03-26 15:49:30 +0100800 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *values, value, LY_EMEM);
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200801 LY_ARRAY_COUNT_TYPE index = LY_ARRAY_COUNT(*values) - 1;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100802 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200803 {LY_STMT_EXTENSION_INSTANCE, &index, 0}
804 };
David Sedlák968ac342019-07-11 15:17:59 +0200805
Michal Vaskob36053d2020-03-26 15:49:30 +0100806 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
807 LY_CHECK_RET(yin_parse_attribute(ctx, arg_type, value, arg_val_type, kw));
David Sedlák5f8191e2019-07-08 16:35:52 +0200808
Radek Krejcif13b87b2020-12-01 22:02:17 +0100809 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), kw, NULL, exts);
David Sedlák5f8191e2019-07-08 16:35:52 +0200810}
811
812/**
David Sedlák6542aed2019-08-14 10:47:43 +0200813 * @brief Parse simple element without any special constraints and argument mapped to yin attribute.
814 *
815 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák6542aed2019-08-14 10:47:43 +0200816 * @param[in] kw Type of current element.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200817 * @param[in] subinfo Information about subelement, is used to determin which function should be called and where to store parsed value.
David Sedlák6542aed2019-08-14 10:47:43 +0200818 * @param[in] arg_type Expected type of attribute.
819 * @param[in] arg_val_type Type of expected value of attribute.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200820 * @param[in,out] exts Extension instances to add to.
David Sedlák6542aed2019-08-14 10:47:43 +0200821 * @return LY_ERR values.
822 */
823static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100824yin_parse_simple_elem(struct lys_yin_parser_ctx *ctx, enum ly_stmt kw, struct yin_subelement *subinfo,
Radek Krejci0f969882020-08-21 16:56:47 +0200825 enum yin_argument arg_type, enum yang_arg arg_val_type, struct lysp_ext_instance **exts)
David Sedlák6542aed2019-08-14 10:47:43 +0200826{
827 if (subinfo->flags & YIN_SUBELEM_UNIQUE) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100828 LY_CHECK_RET(yin_parse_simple_element(ctx, kw, (const char **)subinfo->dest,
Michal Vasko69730152020-10-09 16:30:07 +0200829 arg_type, arg_val_type, exts));
David Sedlák6542aed2019-08-14 10:47:43 +0200830 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100831 LY_CHECK_RET(yin_parse_simple_elements(ctx, kw, (const char ***)subinfo->dest,
Michal Vasko69730152020-10-09 16:30:07 +0200832 arg_type, arg_val_type, exts));
David Sedlák6542aed2019-08-14 10:47:43 +0200833 }
834
835 return LY_SUCCESS;
836}
837
838/**
839 * @brief Parse base element.
840 *
841 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák6542aed2019-08-14 10:47:43 +0200842 * @param[in] parent Identification of parent element.
843 * @param[out] dest Where parsed values should be stored.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200844 * @param[in,out] exts Extension instances to add to.
David Sedlák6542aed2019-08-14 10:47:43 +0200845 * @return LY_ERR values.
846 */
847static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100848yin_parse_base(struct lys_yin_parser_ctx *ctx, enum ly_stmt parent, void *dest, struct lysp_ext_instance **exts)
David Sedlák6542aed2019-08-14 10:47:43 +0200849{
850 struct lysp_type *type = NULL;
851
Radek Krejcid6b76452019-09-03 17:03:03 +0200852 if (parent == LY_STMT_TYPE) {
David Sedlák6542aed2019-08-14 10:47:43 +0200853 type = (struct lysp_type *)dest;
Michal Vaskob36053d2020-03-26 15:49:30 +0100854 LY_CHECK_RET(yin_parse_simple_elements(ctx, LY_STMT_BASE, &type->bases, YIN_ARG_NAME,
Michal Vasko69730152020-10-09 16:30:07 +0200855 Y_PREF_IDENTIF_ARG, exts));
David Sedlák6542aed2019-08-14 10:47:43 +0200856 type->flags |= LYS_SET_BASE;
Radek Krejcid6b76452019-09-03 17:03:03 +0200857 } else if (parent == LY_STMT_IDENTITY) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100858 LY_CHECK_RET(yin_parse_simple_elements(ctx, LY_STMT_BASE, (const char ***)dest,
Michal Vasko69730152020-10-09 16:30:07 +0200859 YIN_ARG_NAME, Y_PREF_IDENTIF_ARG, exts));
David Sedlák6542aed2019-08-14 10:47:43 +0200860 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100861 LOGINT(ctx->xmlctx->ctx);
David Sedlák6542aed2019-08-14 10:47:43 +0200862 return LY_EINT;
863 }
864
865 return LY_SUCCESS;
866}
867
868/**
David Sedlákbf8a2b72019-08-14 16:48:10 +0200869 * @brief Parse require-instance element.
David Sedlákcf5569a2019-07-11 13:31:34 +0200870 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200871 * @param[in,out] ctx YIN parser context for logging and to store current state.
Michal Vaskob36053d2020-03-26 15:49:30 +0100872 * @param[out] type Type structure to store value, flag and extensions.
David Sedlákcf5569a2019-07-11 13:31:34 +0200873 * @return LY_ERR values.
874 */
875static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100876yin_pasrse_reqinstance(struct lys_yin_parser_ctx *ctx, struct lysp_type *type)
David Sedlákcf5569a2019-07-11 13:31:34 +0200877{
878 const char *temp_val = NULL;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100879 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200880 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
881 };
David Sedlákcf5569a2019-07-11 13:31:34 +0200882
883 type->flags |= LYS_SET_REQINST;
Michal Vaskob36053d2020-03-26 15:49:30 +0100884 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
885 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &temp_val, Y_STR_ARG, LY_STMT_REQUIRE_INSTANCE));
David Sedlákcf5569a2019-07-11 13:31:34 +0200886 if (strcmp(temp_val, "true") == 0) {
887 type->require_instance = 1;
888 } else if (strcmp(temp_val, "false") != 0) {
David Sedlák26ea1432019-08-14 13:42:23 +0200889 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS2, temp_val, "value",
Michal Vasko69730152020-10-09 16:30:07 +0200890 "require-instance", "true", "false");
Michal Vaskoe180ed02021-02-05 16:31:20 +0100891 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákcf5569a2019-07-11 13:31:34 +0200892 return LY_EVALID;
893 }
Michal Vaskoe180ed02021-02-05 16:31:20 +0100894 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákcf5569a2019-07-11 13:31:34 +0200895
Radek Krejcif13b87b2020-12-01 22:02:17 +0100896 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_REQUIRE_INSTANCE, NULL, &type->exts);
David Sedlákcf5569a2019-07-11 13:31:34 +0200897}
898
899/**
David Sedlákce77bf52019-07-11 16:59:31 +0200900 * @brief Parse modifier element.
901 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200902 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákce77bf52019-07-11 16:59:31 +0200903 * @param[in,out] pat Value to write to.
904 * @param[in,out] exts Extension instances to add to.
905 *
906 * @return LY_ERR values.
907 */
908static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100909yin_parse_modifier(struct lys_yin_parser_ctx *ctx, const char **pat, struct lysp_ext_instance **exts)
David Sedlákce77bf52019-07-11 16:59:31 +0200910{
David Sedlákd3983112019-07-12 11:20:56 +0200911 assert(**pat == 0x06);
David Sedlákce77bf52019-07-11 16:59:31 +0200912 const char *temp_val;
913 char *modified_val;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100914 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200915 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
916 };
David Sedlákce77bf52019-07-11 16:59:31 +0200917
Michal Vaskob36053d2020-03-26 15:49:30 +0100918 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
919 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &temp_val, Y_STR_ARG, LY_STMT_MODIFIER));
David Sedlákce77bf52019-07-11 16:59:31 +0200920 if (strcmp(temp_val, "invert-match") != 0) {
David Sedlák26ea1432019-08-14 13:42:23 +0200921 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS1, temp_val, "value",
Michal Vasko69730152020-10-09 16:30:07 +0200922 "modifier", "invert-match");
Michal Vaskoe180ed02021-02-05 16:31:20 +0100923 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákce77bf52019-07-11 16:59:31 +0200924 return LY_EVALID;
925 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100926 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákce77bf52019-07-11 16:59:31 +0200927
928 /* allocate new value */
David Sedlákd3983112019-07-12 11:20:56 +0200929 modified_val = malloc(strlen(*pat) + 1);
Michal Vaskob36053d2020-03-26 15:49:30 +0100930 LY_CHECK_ERR_RET(!modified_val, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
David Sedlákd3983112019-07-12 11:20:56 +0200931 strcpy(modified_val, *pat);
Michal Vaskob36053d2020-03-26 15:49:30 +0100932 lydict_remove(ctx->xmlctx->ctx, *pat);
David Sedlákce77bf52019-07-11 16:59:31 +0200933
934 /* modify the new value */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100935 modified_val[0] = LYSP_RESTR_PATTERN_NACK;
Radek Krejci011e4aa2020-09-04 15:22:31 +0200936 LY_CHECK_RET(lydict_insert_zc(ctx->xmlctx->ctx, modified_val, pat));
David Sedlákce77bf52019-07-11 16:59:31 +0200937
Radek Krejcif13b87b2020-12-01 22:02:17 +0100938 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_MODIFIER, NULL, exts);
David Sedlákce77bf52019-07-11 16:59:31 +0200939}
940
941/**
David Sedlákb7296dd2019-07-11 14:58:38 +0200942 * @brief Parse a restriction element (length, range or one instance of must).
943 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200944 * @param[in,out] ctx YIN parser context for logging and to store current state.
Radek Krejcid6b76452019-09-03 17:03:03 +0200945 * @param[in] restr_kw Identificaton of element that is being parsed, can be set to LY_STMT_MUST, LY_STMT_LENGTH or LY_STMT_RANGE.
David Sedlák6542aed2019-08-14 10:47:43 +0200946 * @param[in] restr Value to write to.
David Sedlákb7296dd2019-07-11 14:58:38 +0200947 */
948static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100949yin_parse_restriction(struct lys_yin_parser_ctx *ctx, enum ly_stmt restr_kw, struct lysp_restr *restr)
David Sedlákb7296dd2019-07-11 14:58:38 +0200950{
Radek Krejcid6b76452019-09-03 17:03:03 +0200951 assert(restr_kw == LY_STMT_MUST || restr_kw == LY_STMT_LENGTH || restr_kw == LY_STMT_RANGE);
Radek Krejcif13b87b2020-12-01 22:02:17 +0100952 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200953 {LY_STMT_DESCRIPTION, &restr->dsc, YIN_SUBELEM_UNIQUE},
954 {LY_STMT_ERROR_APP_TAG, &restr->eapptag, YIN_SUBELEM_UNIQUE},
955 {LY_STMT_ERROR_MESSAGE, &restr->emsg, YIN_SUBELEM_UNIQUE},
956 {LY_STMT_REFERENCE, &restr->ref, YIN_SUBELEM_UNIQUE},
957 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
958 };
David Sedlákb7296dd2019-07-11 14:58:38 +0200959 /* argument of must is called condition, but argument of length and range is called value */
Radek Krejcid6b76452019-09-03 17:03:03 +0200960 enum yin_argument arg_type = (restr_kw == LY_STMT_MUST) ? YIN_ARG_CONDITION : YIN_ARG_VALUE;
David Sedlákb7296dd2019-07-11 14:58:38 +0200961
Michal Vaskob36053d2020-03-26 15:49:30 +0100962 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
Michal Vasko7f45cf22020-10-01 12:49:44 +0200963 LY_CHECK_RET(yin_parse_attribute(ctx, arg_type, &restr->arg.str, Y_STR_ARG, restr_kw));
Michal Vasko8a67eff2021-12-07 14:04:47 +0100964 restr->arg.mod = PARSER_CUR_PMOD(ctx);
Michal Vaskob36053d2020-03-26 15:49:30 +0100965
Radek Krejcif13b87b2020-12-01 22:02:17 +0100966 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), restr_kw, NULL, &restr->exts);
David Sedlákb7296dd2019-07-11 14:58:38 +0200967}
968
969/**
David Sedlák6542aed2019-08-14 10:47:43 +0200970 * @brief Parse range element.
971 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200972 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák6542aed2019-08-14 10:47:43 +0200973 * @param[out] type Type structure to store parsed value and flags.
974 *
975 * @return LY_ERR values.
976 */
977static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100978yin_parse_range(struct lys_yin_parser_ctx *ctx, struct lysp_type *type)
David Sedlák6542aed2019-08-14 10:47:43 +0200979{
980 type->range = calloc(1, sizeof *type->range);
Michal Vaskob36053d2020-03-26 15:49:30 +0100981 LY_CHECK_ERR_RET(!type->range, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
982 LY_CHECK_RET(yin_parse_restriction(ctx, LY_STMT_RANGE, type->range));
Michal Vasko44f3d2c2020-08-24 09:49:38 +0200983 type->flags |= LYS_SET_RANGE;
David Sedlák6542aed2019-08-14 10:47:43 +0200984
985 return LY_SUCCESS;
986}
987
988/**
989 * @brief Parse length element.
990 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200991 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák6542aed2019-08-14 10:47:43 +0200992 * @param[out] type Type structure to store parsed value and flags.
993 *
994 * @return LY_ERR values.
995 */
996static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100997yin_parse_length(struct lys_yin_parser_ctx *ctx, struct lysp_type *type)
David Sedlák6542aed2019-08-14 10:47:43 +0200998{
999 type->length = calloc(1, sizeof *type->length);
Michal Vaskob36053d2020-03-26 15:49:30 +01001000 LY_CHECK_ERR_RET(!type->length, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
1001 LY_CHECK_RET(yin_parse_restriction(ctx, LY_STMT_LENGTH, type->length));
David Sedlák6542aed2019-08-14 10:47:43 +02001002 type->flags |= LYS_SET_LENGTH;
1003
1004 return LY_SUCCESS;
1005}
1006
1007/**
David Sedlákbc9ec9c2019-07-11 15:53:55 +02001008 * @brief Parse must element.
1009 *
1010 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbc9ec9c2019-07-11 15:53:55 +02001011 * @param[in,out] restrs Restrictions to add to.
1012 *
1013 * @return LY_ERR values.
1014 */
1015static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001016yin_parse_must(struct lys_yin_parser_ctx *ctx, struct lysp_restr **restrs)
David Sedlákbc9ec9c2019-07-11 15:53:55 +02001017{
1018 struct lysp_restr *restr;
1019
Michal Vaskob36053d2020-03-26 15:49:30 +01001020 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *restrs, restr, LY_EMEM);
1021 return yin_parse_restriction(ctx, LY_STMT_MUST, restr);
David Sedlákbc9ec9c2019-07-11 15:53:55 +02001022}
1023
1024/**
Michal Vasko7f45cf22020-10-01 12:49:44 +02001025 * @brief Parse a node id into an array.
1026 *
1027 * @param[in,out] ctx YIN parser context for logging and to store current state.
1028 * @param[in] kw Type of current element.
1029 * @param[in] subinfo Information about subelement, is used to determin which function should be called and where to store parsed value.
1030 * @param[in,out] exts Extension instances to add to.
1031 *
1032 * @return LY_ERR values.
1033 */
1034static LY_ERR
1035yin_parse_qname(struct lys_yin_parser_ctx *ctx, enum ly_stmt kw, struct yin_subelement *subinfo,
1036 struct lysp_ext_instance **exts)
1037{
1038 struct lysp_qname *qname, **qnames;
1039
1040 switch (kw) {
1041 case LY_STMT_DEFAULT:
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001042 if (subinfo->flags & YIN_SUBELEM_UNIQUE) {
1043 qname = (struct lysp_qname *)subinfo->dest;
Michal Vasko7f45cf22020-10-01 12:49:44 +02001044 } else {
1045 qnames = (struct lysp_qname **)subinfo->dest;
1046 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *qnames, qname, LY_EMEM);
Michal Vasko7f45cf22020-10-01 12:49:44 +02001047 }
Michal Vasko8a67eff2021-12-07 14:04:47 +01001048 qname->mod = PARSER_CUR_PMOD(ctx);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001049 return yin_parse_simple_element(ctx, kw, &qname->str, YIN_ARG_VALUE, Y_STR_ARG, exts);
Radek Išabe8a6532021-03-29 08:54:22 +02001050 case LY_STMT_UNIQUE:
1051 assert(!(subinfo->flags & YIN_SUBELEM_UNIQUE));
1052 qnames = (struct lysp_qname **)subinfo->dest;
1053 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *qnames, qname, LY_EMEM);
Michal Vasko8a67eff2021-12-07 14:04:47 +01001054 qname->mod = PARSER_CUR_PMOD(ctx);
Radek Išabe8a6532021-03-29 08:54:22 +02001055 return yin_parse_simple_element(ctx, kw, &qname->str, YIN_ARG_TAG, Y_STR_ARG, exts);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001056 case LY_STMT_IF_FEATURE:
1057 assert(!(subinfo->flags & YIN_SUBELEM_UNIQUE));
1058 qnames = (struct lysp_qname **)subinfo->dest;
1059 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *qnames, qname, LY_EMEM);
Michal Vasko8a67eff2021-12-07 14:04:47 +01001060 qname->mod = PARSER_CUR_PMOD(ctx);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001061 return yin_parse_simple_element(ctx, kw, &qname->str, YIN_ARG_NAME, Y_STR_ARG, exts);
Michal Vasko7f45cf22020-10-01 12:49:44 +02001062 default:
1063 break;
1064 }
1065
1066 LOGINT(ctx->xmlctx->ctx);
1067 return LY_EINT;
1068}
1069
1070/**
David Sedlák5545f5d2019-07-11 11:55:16 +02001071 * @brief Parse position or value element.
1072 *
1073 * @param[in,out] ctx YIN parser context for logging and to store current state.
Radek Krejcid6b76452019-09-03 17:03:03 +02001074 * @param[in] kw Type of current element, can be set to LY_STMT_POSITION or LY_STMT_VALUE.
David Sedlákbf8a2b72019-08-14 16:48:10 +02001075 * @param[out] enm Enum structure to save value, flags and extension instances.
David Sedlák5545f5d2019-07-11 11:55:16 +02001076 *
1077 * @return LY_ERR values.
1078 */
1079static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001080yin_parse_value_pos(struct lys_yin_parser_ctx *ctx, enum ly_stmt kw, struct lysp_type_enum *enm)
David Sedlák5545f5d2019-07-11 11:55:16 +02001081{
Radek Krejcid6b76452019-09-03 17:03:03 +02001082 assert(kw == LY_STMT_POSITION || kw == LY_STMT_VALUE);
David Sedlák5545f5d2019-07-11 11:55:16 +02001083 const char *temp_val = NULL;
1084 char *ptr;
Michal Vasko73d77ab2021-07-23 12:45:55 +02001085 long long int num = 0;
1086 unsigned long long int unum = 0;
David Sedlák5545f5d2019-07-11 11:55:16 +02001087
1088 /* set value flag */
1089 enm->flags |= LYS_SET_VALUE;
1090
1091 /* get attribute value */
Michal Vaskob36053d2020-03-26 15:49:30 +01001092 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1093 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &temp_val, Y_STR_ARG, kw));
Michal Vasko69730152020-10-09 16:30:07 +02001094 if (!temp_val || (temp_val[0] == '\0') || (temp_val[0] == '+') ||
Radek Krejci0f969882020-08-21 16:56:47 +02001095 ((temp_val[0] == '0') && (temp_val[1] != '\0')) || ((kw == LY_STMT_POSITION) && !strcmp(temp_val, "-0"))) {
David Sedlák1538a842019-08-08 15:38:51 +02001096 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", ly_stmt2str(kw));
David Sedlák5545f5d2019-07-11 11:55:16 +02001097 goto error;
1098 }
1099
1100 /* convert value */
1101 errno = 0;
Radek Krejcid6b76452019-09-03 17:03:03 +02001102 if (kw == LY_STMT_VALUE) {
Michal Vasko73d77ab2021-07-23 12:45:55 +02001103 num = strtoll(temp_val, &ptr, LY_BASE_DEC);
Michal Vasko69730152020-10-09 16:30:07 +02001104 if ((num < INT64_C(-2147483648)) || (num > INT64_C(2147483647))) {
David Sedlák1538a842019-08-08 15:38:51 +02001105 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", ly_stmt2str(kw));
David Sedlák5545f5d2019-07-11 11:55:16 +02001106 goto error;
1107 }
1108 } else {
Michal Vasko73d77ab2021-07-23 12:45:55 +02001109 unum = strtoull(temp_val, &ptr, LY_BASE_DEC);
David Sedlák5545f5d2019-07-11 11:55:16 +02001110 if (unum > UINT64_C(4294967295)) {
David Sedlák1538a842019-08-08 15:38:51 +02001111 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", ly_stmt2str(kw));
David Sedlák5545f5d2019-07-11 11:55:16 +02001112 goto error;
1113 }
1114 }
1115 /* check if whole argument value was converted */
1116 if (*ptr != '\0') {
David Sedlák1538a842019-08-08 15:38:51 +02001117 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", ly_stmt2str(kw));
David Sedlákebcd0eb2019-07-16 17:55:12 +02001118 goto error;
David Sedlák5545f5d2019-07-11 11:55:16 +02001119 }
1120 if (errno == ERANGE) {
David Sedlák1538a842019-08-08 15:38:51 +02001121 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_OOB_YIN, temp_val, "value", ly_stmt2str(kw));
David Sedlák5545f5d2019-07-11 11:55:16 +02001122 goto error;
1123 }
1124 /* save correctly ternary operator can't be used because num and unum have different signes */
Radek Krejcid6b76452019-09-03 17:03:03 +02001125 if (kw == LY_STMT_VALUE) {
David Sedlák5545f5d2019-07-11 11:55:16 +02001126 enm->value = num;
1127 } else {
1128 enm->value = unum;
1129 }
Michal Vaskoe180ed02021-02-05 16:31:20 +01001130 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlák5545f5d2019-07-11 11:55:16 +02001131
1132 /* parse subelements */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001133 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001134 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1135 };
Michal Vasko69730152020-10-09 16:30:07 +02001136
Radek Krejcif13b87b2020-12-01 22:02:17 +01001137 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), kw, NULL, &enm->exts);
David Sedlák5545f5d2019-07-11 11:55:16 +02001138
David Sedlákbf8a2b72019-08-14 16:48:10 +02001139error:
Michal Vaskoe180ed02021-02-05 16:31:20 +01001140 lydict_remove(ctx->xmlctx->ctx, temp_val);
Michal Vaskob36053d2020-03-26 15:49:30 +01001141 return LY_EVALID;
David Sedlák5545f5d2019-07-11 11:55:16 +02001142}
1143
David Sedlák05404f62019-07-24 14:11:53 +02001144/**
1145 * @brief Parse belongs-to element.
1146 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001147 * @param[in] ctx YIN parser context for logging and to store current state.
David Sedlák05404f62019-07-24 14:11:53 +02001148 * @param[out] submod Structure of submodule that is being parsed.
1149 * @param[in,out] exts Extension instances to add to.
1150 *
1151 * @return LY_ERR values
1152 */
1153static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001154yin_parse_belongs_to(struct lys_yin_parser_ctx *ctx, struct lysp_submodule *submod, struct lysp_ext_instance **exts)
David Sedlák05404f62019-07-24 14:11:53 +02001155{
Michal Vaskoc3781c32020-10-06 14:04:08 +02001156 const char *belongsto;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001157 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001158 {LY_STMT_PREFIX, &submod->prefix, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE},
1159 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1160 };
David Sedlák05404f62019-07-24 14:11:53 +02001161
Michal Vaskob36053d2020-03-26 15:49:30 +01001162 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
Michal Vaskoc3781c32020-10-06 14:04:08 +02001163 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_MODULE, &belongsto, Y_IDENTIF_ARG, LY_STMT_BELONGS_TO));
Michal Vasko8a67eff2021-12-07 14:04:47 +01001164 if (PARSER_CUR_PMOD(ctx)->mod->name != belongsto) {
Michal Vaskoc3781c32020-10-06 14:04:08 +02001165 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YIN, "Submodule \"belongs-to\" value \"%s\" does not match its module name \"%s\".",
Michal Vasko8a67eff2021-12-07 14:04:47 +01001166 belongsto, PARSER_CUR_PMOD(ctx)->mod->name);
Michal Vaskoc3781c32020-10-06 14:04:08 +02001167 lydict_remove(ctx->xmlctx->ctx, belongsto);
1168 return LY_EVALID;
1169 }
1170 lydict_remove(ctx->xmlctx->ctx, belongsto);
Michal Vaskob36053d2020-03-26 15:49:30 +01001171
Radek Krejcif13b87b2020-12-01 22:02:17 +01001172 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_BELONGS_TO, NULL, exts);
David Sedlák05404f62019-07-24 14:11:53 +02001173}
1174
David Sedlák5545f5d2019-07-11 11:55:16 +02001175/**
David Sedlákc1771b12019-07-10 15:55:46 +02001176 * @brief Function to parse meta tags (description, contact, ...) eg. elements with
David Sedlákbf8a2b72019-08-14 16:48:10 +02001177 * text element as child.
David Sedlákb4e44562019-07-04 15:42:12 +02001178 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001179 * @param[in,out] ctx YIN parser context for logging and to store current state.
Radek Krejcid6b76452019-09-03 17:03:03 +02001180 * @param[in] elem_type Type of element can be set to LY_STMT_ORGANIZATION or LY_STMT_CONTACT or LY_STMT_DESCRIPTION or LY_STMT_REFERENCE.
David Sedlákb4e44562019-07-04 15:42:12 +02001181 * @param[out] value Where the content of meta element should be stored.
David Sedlákbf8a2b72019-08-14 16:48:10 +02001182 * @param[in,out] exts Extension instances to add to.
David Sedlákb4e44562019-07-04 15:42:12 +02001183 *
1184 * @return LY_ERR values.
1185 */
1186static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001187yin_parse_meta(struct lys_yin_parser_ctx *ctx, enum ly_stmt elem_type, const char **value, struct lysp_ext_instance **exts)
David Sedlákb4e44562019-07-04 15:42:12 +02001188{
Radek Krejcid6b76452019-09-03 17:03:03 +02001189 assert(elem_type == LY_STMT_ORGANIZATION || elem_type == LY_STMT_CONTACT || elem_type == LY_STMT_DESCRIPTION || elem_type == LY_STMT_REFERENCE);
David Sedlákb4e44562019-07-04 15:42:12 +02001190
Radek Krejcif13b87b2020-12-01 22:02:17 +01001191 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001192 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1193 {LY_STMT_ARG_TEXT, value, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE | YIN_SUBELEM_FIRST}
1194 };
Michal Vasko69730152020-10-09 16:30:07 +02001195
David Sedlákdf2a9732019-08-07 13:23:16 +02001196 /* check attributes */
Michal Vaskob36053d2020-03-26 15:49:30 +01001197 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1198 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NONE, NULL, Y_MAYBE_STR_ARG, elem_type));
David Sedlákb4e44562019-07-04 15:42:12 +02001199
David Sedlákdf2a9732019-08-07 13:23:16 +02001200 /* parse content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001201 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), elem_type, NULL, exts);
David Sedlákb4e44562019-07-04 15:42:12 +02001202}
1203
1204/**
David Sedlákc1771b12019-07-10 15:55:46 +02001205 * @brief Parse error-message element.
1206 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001207 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákc1771b12019-07-10 15:55:46 +02001208 * @param[out] value Where the content of error-message element should be stored.
David Sedlákbf8a2b72019-08-14 16:48:10 +02001209 * @param[in,out] exts Extension instances to add to.
David Sedlákc1771b12019-07-10 15:55:46 +02001210 *
1211 * @return LY_ERR values.
1212 */
1213static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001214yin_parse_err_msg(struct lys_yin_parser_ctx *ctx, const char **value, struct lysp_ext_instance **exts)
David Sedlákc1771b12019-07-10 15:55:46 +02001215{
Radek Krejcif13b87b2020-12-01 22:02:17 +01001216 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001217 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1218 {LY_STMT_ARG_VALUE, value, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE | YIN_SUBELEM_FIRST}
1219 };
David Sedlákc1771b12019-07-10 15:55:46 +02001220
David Sedlákdf2a9732019-08-07 13:23:16 +02001221 /* check attributes */
Michal Vaskob36053d2020-03-26 15:49:30 +01001222 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1223 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NONE, NULL, Y_MAYBE_STR_ARG, LY_STMT_ERROR_MESSAGE));
David Sedlákdf2a9732019-08-07 13:23:16 +02001224
Radek Krejcif13b87b2020-12-01 22:02:17 +01001225 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_ERROR_MESSAGE, NULL, exts);
David Sedlákc1771b12019-07-10 15:55:46 +02001226}
1227
1228/**
David Sedlák6542aed2019-08-14 10:47:43 +02001229 * @brief Parse type element.
David Sedlák374d2b32019-07-17 15:06:55 +02001230 *
1231 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák6542aed2019-08-14 10:47:43 +02001232 * @param[in] parent Identification of parent element.
David Sedlákbf8a2b72019-08-14 16:48:10 +02001233 * @param[in,out] type Type to write to.
David Sedlák374d2b32019-07-17 15:06:55 +02001234 *
1235 * @return LY_ERR values.
1236 */
1237static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001238yin_parse_type(struct lys_yin_parser_ctx *ctx, enum ly_stmt parent, struct yin_subelement *subinfo)
David Sedlák374d2b32019-07-17 15:06:55 +02001239{
David Sedlák6542aed2019-08-14 10:47:43 +02001240 struct lysp_type *type = NULL;
Michal Vasko69730152020-10-09 16:30:07 +02001241
Radek Krejcid6b76452019-09-03 17:03:03 +02001242 if (parent == LY_STMT_DEVIATE) {
David Sedlák6542aed2019-08-14 10:47:43 +02001243 *(struct lysp_type **)subinfo->dest = calloc(1, sizeof **(struct lysp_type **)subinfo->dest);
Michal Vaskob36053d2020-03-26 15:49:30 +01001244 LY_CHECK_ERR_RET(!(*(struct lysp_type **)subinfo->dest), LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
David Sedlák6542aed2019-08-14 10:47:43 +02001245 type = *((struct lysp_type **)subinfo->dest);
Michal Vaskod989ba02020-08-24 10:59:24 +02001246 } else {
David Sedlák6542aed2019-08-14 10:47:43 +02001247 type = (struct lysp_type *)subinfo->dest;
1248 }
Michal Vaskoe9c050f2020-10-06 14:01:23 +02001249
David Sedlák6542aed2019-08-14 10:47:43 +02001250 /* type as child of another type */
Radek Krejcid6b76452019-09-03 17:03:03 +02001251 if (parent == LY_STMT_TYPE) {
David Sedlák6542aed2019-08-14 10:47:43 +02001252 struct lysp_type *nested_type = NULL;
Michal Vaskob36053d2020-03-26 15:49:30 +01001253 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, type->types, nested_type, LY_EMEM);
David Sedlák6542aed2019-08-14 10:47:43 +02001254 type->flags |= LYS_SET_TYPE;
1255 type = nested_type;
1256 }
Michal Vaskoe9c050f2020-10-06 14:01:23 +02001257
Michal Vasko8a67eff2021-12-07 14:04:47 +01001258 type->pmod = PARSER_CUR_PMOD(ctx);
Michal Vasko5bbcc242021-02-23 09:29:13 +01001259
Radek Krejcif13b87b2020-12-01 22:02:17 +01001260 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001261 {LY_STMT_BASE, type, 0},
1262 {LY_STMT_BIT, type, 0},
1263 {LY_STMT_ENUM, type, 0},
1264 {LY_STMT_FRACTION_DIGITS, type, YIN_SUBELEM_UNIQUE},
1265 {LY_STMT_LENGTH, type, YIN_SUBELEM_UNIQUE},
1266 {LY_STMT_PATH, type, YIN_SUBELEM_UNIQUE},
1267 {LY_STMT_PATTERN, type, 0},
1268 {LY_STMT_RANGE, type, YIN_SUBELEM_UNIQUE},
1269 {LY_STMT_REQUIRE_INSTANCE, type, YIN_SUBELEM_UNIQUE},
Michal Vasko608b0c02021-09-23 08:26:53 +02001270 {LY_STMT_TYPE, type, 0},
Radek Krejci0f969882020-08-21 16:56:47 +02001271 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1272 };
Michal Vaskob36053d2020-03-26 15:49:30 +01001273
1274 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1275 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &type->name, Y_PREF_IDENTIF_ARG, LY_STMT_TYPE));
Radek Krejcif13b87b2020-12-01 22:02:17 +01001276 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_TYPE, NULL, &type->exts);
David Sedlák374d2b32019-07-17 15:06:55 +02001277}
1278
David Sedlák1af868e2019-07-17 17:03:14 +02001279/**
1280 * @brief Parse max-elements element.
1281 *
1282 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák1af868e2019-07-17 17:03:14 +02001283 * @param[in,out] max Value to write to.
David Sedláka2dad212019-07-18 12:45:19 +02001284 * @param[in] flags Flags to write to.
David Sedlák1af868e2019-07-17 17:03:14 +02001285 * @param[in,out] exts Extension instances to add to.
1286 *
1287 * @return LY_ERR values.
1288 */
1289static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001290yin_parse_maxelements(struct lys_yin_parser_ctx *ctx, uint32_t *max, uint16_t *flags, struct lysp_ext_instance **exts)
David Sedlák1af868e2019-07-17 17:03:14 +02001291{
1292 const char *temp_val = NULL;
1293 char *ptr;
Michal Vasko73d77ab2021-07-23 12:45:55 +02001294 unsigned long long int num;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001295 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001296 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1297 };
David Sedlák374d2b32019-07-17 15:06:55 +02001298
David Sedlák1af868e2019-07-17 17:03:14 +02001299 *flags |= LYS_SET_MAX;
Michal Vaskob36053d2020-03-26 15:49:30 +01001300 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1301 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &temp_val, Y_STR_ARG, LY_STMT_MAX_ELEMENTS));
Michal Vasko69730152020-10-09 16:30:07 +02001302 if (!temp_val || (temp_val[0] == '\0') || (temp_val[0] == '0') || ((temp_val[0] != 'u') && !isdigit(temp_val[0]))) {
David Sedlák1538a842019-08-08 15:38:51 +02001303 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", "max-elements");
Michal Vaskoe180ed02021-02-05 16:31:20 +01001304 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlák1af868e2019-07-17 17:03:14 +02001305 return LY_EVALID;
1306 }
1307
1308 if (strcmp(temp_val, "unbounded")) {
1309 errno = 0;
Michal Vasko73d77ab2021-07-23 12:45:55 +02001310 num = strtoull(temp_val, &ptr, LY_BASE_DEC);
David Sedlák1af868e2019-07-17 17:03:14 +02001311 if (*ptr != '\0') {
David Sedlák1538a842019-08-08 15:38:51 +02001312 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", "max-elements");
Michal Vaskoe180ed02021-02-05 16:31:20 +01001313 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlák1af868e2019-07-17 17:03:14 +02001314 return LY_EVALID;
1315 }
1316 if ((errno == ERANGE) || (num > UINT32_MAX)) {
David Sedlák1538a842019-08-08 15:38:51 +02001317 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_OOB_YIN, temp_val, "value", "max-elements");
Michal Vaskoe180ed02021-02-05 16:31:20 +01001318 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlák1af868e2019-07-17 17:03:14 +02001319 return LY_EVALID;
1320 }
1321 *max = num;
1322 }
Michal Vaskoe180ed02021-02-05 16:31:20 +01001323 lydict_remove(ctx->xmlctx->ctx, temp_val);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001324 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_MAX_ELEMENTS, NULL, exts);
David Sedlák1af868e2019-07-17 17:03:14 +02001325}
David Sedlák374d2b32019-07-17 15:06:55 +02001326
1327/**
David Sedlákbf8a2b72019-08-14 16:48:10 +02001328 * @brief Parse min-elements element.
David Sedlák09e18c92019-07-18 11:17:11 +02001329 *
1330 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák09e18c92019-07-18 11:17:11 +02001331 * @param[in,out] min Value to write to.
David Sedláka2dad212019-07-18 12:45:19 +02001332 * @param[in] flags Flags to write to.
David Sedlák09e18c92019-07-18 11:17:11 +02001333 * @param[in,out] exts Extension instances to add to.
1334 *
1335 * @return LY_ERR values.
1336 */
1337static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001338yin_parse_minelements(struct lys_yin_parser_ctx *ctx, uint32_t *min, uint16_t *flags, struct lysp_ext_instance **exts)
David Sedlák09e18c92019-07-18 11:17:11 +02001339{
1340 const char *temp_val = NULL;
1341 char *ptr;
Michal Vasko73d77ab2021-07-23 12:45:55 +02001342 unsigned long long int num;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001343 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001344 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1345 };
David Sedlák09e18c92019-07-18 11:17:11 +02001346
1347 *flags |= LYS_SET_MIN;
Michal Vaskob36053d2020-03-26 15:49:30 +01001348 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1349 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &temp_val, Y_STR_ARG, LY_STMT_MIN_ELEMENTS));
David Sedlák09e18c92019-07-18 11:17:11 +02001350
Michal Vasko69730152020-10-09 16:30:07 +02001351 if (!temp_val || (temp_val[0] == '\0') || ((temp_val[0] == '0') && (temp_val[1] != '\0'))) {
David Sedlák1538a842019-08-08 15:38:51 +02001352 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", "min-elements");
Michal Vaskoe180ed02021-02-05 16:31:20 +01001353 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlák09e18c92019-07-18 11:17:11 +02001354 return LY_EVALID;
1355 }
1356
1357 errno = 0;
Michal Vasko73d77ab2021-07-23 12:45:55 +02001358 num = strtoull(temp_val, &ptr, LY_BASE_DEC);
David Sedlák09e18c92019-07-18 11:17:11 +02001359 if (ptr[0] != 0) {
David Sedlák1538a842019-08-08 15:38:51 +02001360 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", "min-elements");
Michal Vaskoe180ed02021-02-05 16:31:20 +01001361 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlák09e18c92019-07-18 11:17:11 +02001362 return LY_EVALID;
1363 }
Michal Vasko69730152020-10-09 16:30:07 +02001364 if ((errno == ERANGE) || (num > UINT32_MAX)) {
David Sedlák1538a842019-08-08 15:38:51 +02001365 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_OOB_YIN, temp_val, "value", "min-elements");
Michal Vaskoe180ed02021-02-05 16:31:20 +01001366 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlák09e18c92019-07-18 11:17:11 +02001367 return LY_EVALID;
1368 }
1369 *min = num;
Michal Vaskoe180ed02021-02-05 16:31:20 +01001370 lydict_remove(ctx->xmlctx->ctx, temp_val);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001371 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_MIN_ELEMENTS, NULL, exts);
David Sedlák09e18c92019-07-18 11:17:11 +02001372}
1373
David Sedláka2dad212019-07-18 12:45:19 +02001374/**
1375 * @brief Parse min-elements or max-elements element.
1376 *
1377 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedláka2dad212019-07-18 12:45:19 +02001378 * @param[in] parent Identification of parent element.
1379 * @param[in] current Identification of current element.
1380 * @param[in] dest Where the parsed value and flags should be stored.
1381 *
1382 * @return LY_ERR values.
1383 */
David Sedlák09e18c92019-07-18 11:17:11 +02001384static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001385yin_parse_minmax(struct lys_yin_parser_ctx *ctx, enum ly_stmt parent, enum ly_stmt current, void *dest)
David Sedlák09e18c92019-07-18 11:17:11 +02001386{
Radek Krejcid6b76452019-09-03 17:03:03 +02001387 assert(current == LY_STMT_MAX_ELEMENTS || current == LY_STMT_MIN_ELEMENTS);
1388 assert(parent == LY_STMT_LEAF_LIST || parent == LY_STMT_REFINE || parent == LY_STMT_LIST || parent == LY_STMT_DEVIATE);
David Sedlák09e18c92019-07-18 11:17:11 +02001389 uint32_t *lim;
1390 uint16_t *flags;
1391 struct lysp_ext_instance **exts;
1392
Radek Krejcid6b76452019-09-03 17:03:03 +02001393 if (parent == LY_STMT_LEAF_LIST) {
1394 lim = (current == LY_STMT_MAX_ELEMENTS) ? &((struct lysp_node_leaflist *)dest)->max : &((struct lysp_node_leaflist *)dest)->min;
David Sedlák09e18c92019-07-18 11:17:11 +02001395 flags = &((struct lysp_node_leaflist *)dest)->flags;
1396 exts = &((struct lysp_node_leaflist *)dest)->exts;
Radek Krejcid6b76452019-09-03 17:03:03 +02001397 } else if (parent == LY_STMT_REFINE) {
1398 lim = (current == LY_STMT_MAX_ELEMENTS) ? &((struct lysp_refine *)dest)->max : &((struct lysp_refine *)dest)->min;
David Sedlák09e18c92019-07-18 11:17:11 +02001399 flags = &((struct lysp_refine *)dest)->flags;
1400 exts = &((struct lysp_refine *)dest)->exts;
Radek Krejcid6b76452019-09-03 17:03:03 +02001401 } else if (parent == LY_STMT_LIST) {
1402 lim = (current == LY_STMT_MAX_ELEMENTS) ? &((struct lysp_node_list *)dest)->max : &((struct lysp_node_list *)dest)->min;
David Sedlák09e18c92019-07-18 11:17:11 +02001403 flags = &((struct lysp_node_list *)dest)->flags;
1404 exts = &((struct lysp_node_list *)dest)->exts;
David Sedlák4ffcec82019-07-25 15:10:21 +02001405 } else {
1406 lim = ((struct minmax_dev_meta *)dest)->lim;
1407 flags = ((struct minmax_dev_meta *)dest)->flags;
1408 exts = ((struct minmax_dev_meta *)dest)->exts;
David Sedlák09e18c92019-07-18 11:17:11 +02001409 }
1410
Radek Krejcid6b76452019-09-03 17:03:03 +02001411 if (current == LY_STMT_MAX_ELEMENTS) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001412 LY_CHECK_RET(yin_parse_maxelements(ctx, lim, flags, exts));
David Sedlák09e18c92019-07-18 11:17:11 +02001413 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +01001414 LY_CHECK_RET(yin_parse_minelements(ctx, lim, flags, exts));
David Sedlák09e18c92019-07-18 11:17:11 +02001415 }
1416
1417 return LY_SUCCESS;
1418}
1419
1420/**
David Sedlákbf8a2b72019-08-14 16:48:10 +02001421 * @brief Parse ordered-by element.
David Sedláka2dad212019-07-18 12:45:19 +02001422 *
1423 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedláka2dad212019-07-18 12:45:19 +02001424 * @param[out] flags Flags to write to.
David Sedlákbf8a2b72019-08-14 16:48:10 +02001425 * @param[in,out] exts Extension instances to add to.
David Sedláka2dad212019-07-18 12:45:19 +02001426 *
1427 * @return LY_ERR values.
1428 */
1429static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001430yin_parse_orderedby(struct lys_yin_parser_ctx *ctx, uint16_t *flags, struct lysp_ext_instance **exts)
David Sedláka2dad212019-07-18 12:45:19 +02001431{
1432 const char *temp_val;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001433 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001434 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1435 };
David Sedláka2dad212019-07-18 12:45:19 +02001436
Michal Vaskob36053d2020-03-26 15:49:30 +01001437 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1438 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &temp_val, Y_STR_ARG, LY_STMT_ORDERED_BY));
David Sedláka2dad212019-07-18 12:45:19 +02001439 if (strcmp(temp_val, "system") == 0) {
1440 *flags |= LYS_ORDBY_SYSTEM;
1441 } else if (strcmp(temp_val, "user") == 0) {
1442 *flags |= LYS_ORDBY_USER;
1443 } else {
David Sedlák26ea1432019-08-14 13:42:23 +02001444 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS2, temp_val, "value",
Michal Vasko69730152020-10-09 16:30:07 +02001445 "ordered-by", "system", "user");
Michal Vaskoe180ed02021-02-05 16:31:20 +01001446 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedláka2dad212019-07-18 12:45:19 +02001447 return LY_EVALID;
1448 }
Michal Vaskoe180ed02021-02-05 16:31:20 +01001449 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedláka2dad212019-07-18 12:45:19 +02001450
Radek Krejcif13b87b2020-12-01 22:02:17 +01001451 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_ORDERED_BY, NULL, exts);
David Sedláka2dad212019-07-18 12:45:19 +02001452}
1453
1454/**
David Sedlákbf8a2b72019-08-14 16:48:10 +02001455 * @brief Parse any-data or any-xml element.
David Sedlák8a83bbb2019-07-18 14:46:00 +02001456 *
1457 * @param[in,out] ctx YIN parser context for logging and to store current state.
Radek Krejcid6b76452019-09-03 17:03:03 +02001458 * @param[in] any_kw Identification of current element, can be set to LY_STMT_ANYDATA or LY_STMT_ANYXML
David Sedlákad83cf92019-08-13 12:53:53 +02001459 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlák8a83bbb2019-07-18 14:46:00 +02001460 *
1461 * @return LY_ERR values.
1462 */
1463static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001464yin_parse_any(struct lys_yin_parser_ctx *ctx, enum ly_stmt any_kw, struct tree_node_meta *node_meta)
David Sedlák8a83bbb2019-07-18 14:46:00 +02001465{
David Sedlák8a83bbb2019-07-18 14:46:00 +02001466 struct lysp_node_anydata *any;
1467
David Sedlák8d552d62019-08-06 15:29:05 +02001468 /* create new sibling */
Michal Vaskob36053d2020-03-26 15:49:30 +01001469 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, any, next, LY_EMEM);
Radek Krejcid6b76452019-09-03 17:03:03 +02001470 any->nodetype = (any_kw == LY_STMT_ANYDATA) ? LYS_ANYDATA : LYS_ANYXML;
David Sedlák8a83bbb2019-07-18 14:46:00 +02001471 any->parent = node_meta->parent;
1472
David Sedlákbf8a2b72019-08-14 16:48:10 +02001473 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001474 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1475 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &any->name, Y_IDENTIF_ARG, any_kw));
David Sedlák8a83bbb2019-07-18 14:46:00 +02001476
Radek Krejcif13b87b2020-12-01 22:02:17 +01001477 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001478 {LY_STMT_CONFIG, &any->flags, YIN_SUBELEM_UNIQUE},
1479 {LY_STMT_DESCRIPTION, &any->dsc, YIN_SUBELEM_UNIQUE},
1480 {LY_STMT_IF_FEATURE, &any->iffeatures, 0},
1481 {LY_STMT_MANDATORY, &any->flags, YIN_SUBELEM_UNIQUE},
1482 {LY_STMT_MUST, &any->musts, 0},
1483 {LY_STMT_REFERENCE, &any->ref, YIN_SUBELEM_UNIQUE},
1484 {LY_STMT_STATUS, &any->flags, YIN_SUBELEM_UNIQUE},
1485 {LY_STMT_WHEN, &any->when, YIN_SUBELEM_UNIQUE},
1486 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1487 };
Michal Vasko69730152020-10-09 16:30:07 +02001488
Radek Krejcif13b87b2020-12-01 22:02:17 +01001489 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), any_kw, NULL, &any->exts);
David Sedlák8a83bbb2019-07-18 14:46:00 +02001490}
1491
1492/**
David Sedlák203ca3a2019-07-18 15:26:25 +02001493 * @brief parse leaf element.
1494 *
1495 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákad83cf92019-08-13 12:53:53 +02001496 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlák203ca3a2019-07-18 15:26:25 +02001497 *
1498 * @return LY_ERR values.
1499 */
1500static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001501yin_parse_leaf(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *node_meta)
David Sedlák203ca3a2019-07-18 15:26:25 +02001502{
David Sedlák203ca3a2019-07-18 15:26:25 +02001503 struct lysp_node_leaf *leaf;
1504
David Sedlák8d552d62019-08-06 15:29:05 +02001505 /* create structure new leaf */
Michal Vaskob36053d2020-03-26 15:49:30 +01001506 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, leaf, next, LY_EMEM);
David Sedlák203ca3a2019-07-18 15:26:25 +02001507 leaf->nodetype = LYS_LEAF;
1508 leaf->parent = node_meta->parent;
1509
David Sedlák203ca3a2019-07-18 15:26:25 +02001510 /* parser argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001511 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1512 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &leaf->name, Y_IDENTIF_ARG, LY_STMT_LEAF));
David Sedlák203ca3a2019-07-18 15:26:25 +02001513
1514 /* parse content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001515 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001516 {LY_STMT_CONFIG, &leaf->flags, YIN_SUBELEM_UNIQUE},
1517 {LY_STMT_DEFAULT, &leaf->dflt, YIN_SUBELEM_UNIQUE},
1518 {LY_STMT_DESCRIPTION, &leaf->dsc, YIN_SUBELEM_UNIQUE},
1519 {LY_STMT_IF_FEATURE, &leaf->iffeatures, 0},
1520 {LY_STMT_MANDATORY, &leaf->flags, YIN_SUBELEM_UNIQUE},
1521 {LY_STMT_MUST, &leaf->musts, 0},
1522 {LY_STMT_REFERENCE, &leaf->ref, YIN_SUBELEM_UNIQUE},
1523 {LY_STMT_STATUS, &leaf->flags, YIN_SUBELEM_UNIQUE},
1524 {LY_STMT_TYPE, &leaf->type, YIN_SUBELEM_UNIQUE | YIN_SUBELEM_MANDATORY},
1525 {LY_STMT_UNITS, &leaf->units, YIN_SUBELEM_UNIQUE},
1526 {LY_STMT_WHEN, &leaf->when, YIN_SUBELEM_UNIQUE},
1527 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1528 };
Michal Vasko69730152020-10-09 16:30:07 +02001529
Radek Krejcif13b87b2020-12-01 22:02:17 +01001530 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_LEAF, NULL, &leaf->exts);
David Sedlák203ca3a2019-07-18 15:26:25 +02001531}
1532
1533/**
David Sedlákc3da3ef2019-07-19 12:56:08 +02001534 * @brief Parse leaf-list element.
1535 *
1536 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákad83cf92019-08-13 12:53:53 +02001537 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlákc3da3ef2019-07-19 12:56:08 +02001538 *
1539 * @return LY_ERR values.
1540 */
1541static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001542yin_parse_leaflist(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *node_meta)
David Sedlákc3da3ef2019-07-19 12:56:08 +02001543{
David Sedlákc3da3ef2019-07-19 12:56:08 +02001544 struct lysp_node_leaflist *llist;
David Sedlákc3da3ef2019-07-19 12:56:08 +02001545
Michal Vaskob36053d2020-03-26 15:49:30 +01001546 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, llist, next, LY_EMEM);
David Sedlák8d552d62019-08-06 15:29:05 +02001547
David Sedlákc3da3ef2019-07-19 12:56:08 +02001548 llist->nodetype = LYS_LEAFLIST;
1549 llist->parent = node_meta->parent;
1550
David Sedlákc3da3ef2019-07-19 12:56:08 +02001551 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001552 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1553 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &llist->name, Y_IDENTIF_ARG, LY_STMT_LEAF_LIST));
David Sedlákc3da3ef2019-07-19 12:56:08 +02001554
1555 /* parse content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001556 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001557 {LY_STMT_CONFIG, &llist->flags, YIN_SUBELEM_UNIQUE},
1558 {LY_STMT_DEFAULT, &llist->dflts, 0},
1559 {LY_STMT_DESCRIPTION, &llist->dsc, YIN_SUBELEM_UNIQUE},
1560 {LY_STMT_IF_FEATURE, &llist->iffeatures, 0},
1561 {LY_STMT_MAX_ELEMENTS, llist, YIN_SUBELEM_UNIQUE},
1562 {LY_STMT_MIN_ELEMENTS, llist, YIN_SUBELEM_UNIQUE},
1563 {LY_STMT_MUST, &llist->musts, 0},
1564 {LY_STMT_ORDERED_BY, &llist->flags, YIN_SUBELEM_UNIQUE},
1565 {LY_STMT_REFERENCE, &llist->ref, YIN_SUBELEM_UNIQUE},
1566 {LY_STMT_STATUS, &llist->flags, YIN_SUBELEM_UNIQUE},
1567 {LY_STMT_TYPE, &llist->type, YIN_SUBELEM_UNIQUE | YIN_SUBELEM_MANDATORY},
1568 {LY_STMT_UNITS, &llist->units, YIN_SUBELEM_UNIQUE},
1569 {LY_STMT_WHEN, &llist->when, YIN_SUBELEM_UNIQUE},
1570 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1571 };
Michal Vasko69730152020-10-09 16:30:07 +02001572
Radek Krejcif13b87b2020-12-01 22:02:17 +01001573 LY_CHECK_RET(yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_LEAF_LIST, NULL, &llist->exts));
David Sedlákc3da3ef2019-07-19 12:56:08 +02001574
David Sedlákbf8a2b72019-08-14 16:48:10 +02001575 /* check invalid combination of subelements */
David Sedlákc3da3ef2019-07-19 12:56:08 +02001576 if ((llist->min) && (llist->dflts)) {
David Sedlák1538a842019-08-08 15:38:51 +02001577 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INCHILDSTMSCOMB_YIN, "min-elements", "default", "leaf-list");
David Sedlákc3da3ef2019-07-19 12:56:08 +02001578 return LY_EVALID;
1579 }
Michal Vasko69730152020-10-09 16:30:07 +02001580 if (llist->max && (llist->min > llist->max)) {
David Sedlák1538a842019-08-08 15:38:51 +02001581 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_MINMAX, llist->min, llist->max);
David Sedlákc3da3ef2019-07-19 12:56:08 +02001582 return LY_EVALID;
1583 }
1584
1585 return LY_SUCCESS;
1586}
1587
1588/**
David Sedlák04e17b22019-07-19 15:29:48 +02001589 * @brief Parse typedef element.
1590 *
1591 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák05404f62019-07-24 14:11:53 +02001592 * @param[in] typedef_meta Meta information about parent node and typedefs to add to.
David Sedlák04e17b22019-07-19 15:29:48 +02001593 *
1594 * @return LY_ERR values.
1595 */
1596static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001597yin_parse_typedef(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *typedef_meta)
David Sedlák04e17b22019-07-19 15:29:48 +02001598{
1599 struct lysp_tpdf *tpdf;
David Sedlákbf8a2b72019-08-14 16:48:10 +02001600 struct lysp_tpdf **tpdfs = (struct lysp_tpdf **)typedef_meta->nodes;
Michal Vasko69730152020-10-09 16:30:07 +02001601
Michal Vaskob36053d2020-03-26 15:49:30 +01001602 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *tpdfs, tpdf, LY_EMEM);
David Sedlák04e17b22019-07-19 15:29:48 +02001603
1604 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001605 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1606 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &tpdf->name, Y_IDENTIF_ARG, LY_STMT_TYPEDEF));
David Sedlák04e17b22019-07-19 15:29:48 +02001607
1608 /* parse content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001609 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001610 {LY_STMT_DEFAULT, &tpdf->dflt, YIN_SUBELEM_UNIQUE},
1611 {LY_STMT_DESCRIPTION, &tpdf->dsc, YIN_SUBELEM_UNIQUE},
1612 {LY_STMT_REFERENCE, &tpdf->ref, YIN_SUBELEM_UNIQUE},
1613 {LY_STMT_STATUS, &tpdf->flags, YIN_SUBELEM_UNIQUE},
1614 {LY_STMT_TYPE, &tpdf->type, YIN_SUBELEM_UNIQUE | YIN_SUBELEM_MANDATORY},
1615 {LY_STMT_UNITS, &tpdf->units, YIN_SUBELEM_UNIQUE},
1616 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1617 };
Michal Vasko69730152020-10-09 16:30:07 +02001618
Radek Krejcif13b87b2020-12-01 22:02:17 +01001619 LY_CHECK_RET(yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_TYPEDEF, NULL, &tpdf->exts));
David Sedlák04e17b22019-07-19 15:29:48 +02001620
1621 /* store data for collision check */
aPiecek75b83a02021-06-29 10:34:38 +02001622 if (typedef_meta->parent) {
aPiecek8d4e75d2021-06-24 14:47:06 +02001623 assert(ctx->main_ctx);
1624 LY_CHECK_RET(ly_set_add(&ctx->main_ctx->tpdfs_nodes, typedef_meta->parent, 0, NULL));
David Sedlák04e17b22019-07-19 15:29:48 +02001625 }
1626
1627 return LY_SUCCESS;
1628}
1629
1630/**
David Sedlákd2d676a2019-07-22 11:28:19 +02001631 * @brief Parse refine element.
1632 *
1633 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákd2d676a2019-07-22 11:28:19 +02001634 * @param[in,out] refines Refines to add to.
1635 *
1636 * @return LY_ERR values.
1637 */
1638static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001639yin_parse_refine(struct lys_yin_parser_ctx *ctx, struct lysp_refine **refines)
David Sedlákd2d676a2019-07-22 11:28:19 +02001640{
1641 struct lysp_refine *rf;
1642
1643 /* allocate new refine */
Michal Vaskob36053d2020-03-26 15:49:30 +01001644 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *refines, rf, LY_EMEM);
David Sedlákd2d676a2019-07-22 11:28:19 +02001645
1646 /* parse attribute */
Michal Vaskob36053d2020-03-26 15:49:30 +01001647 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1648 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_TARGET_NODE, &rf->nodeid, Y_STR_ARG, LY_STMT_REFINE));
1649 CHECK_NONEMPTY(ctx, strlen(rf->nodeid), "refine");
David Sedlákd2d676a2019-07-22 11:28:19 +02001650
1651 /* parse content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001652 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001653 {LY_STMT_CONFIG, &rf->flags, YIN_SUBELEM_UNIQUE},
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001654 {LY_STMT_DEFAULT, &rf->dflts, 0},
Radek Krejci0f969882020-08-21 16:56:47 +02001655 {LY_STMT_DESCRIPTION, &rf->dsc, YIN_SUBELEM_UNIQUE},
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001656 {LY_STMT_IF_FEATURE, &rf->iffeatures, 0},
Radek Krejci0f969882020-08-21 16:56:47 +02001657 {LY_STMT_MANDATORY, &rf->flags, YIN_SUBELEM_UNIQUE},
1658 {LY_STMT_MAX_ELEMENTS, rf, YIN_SUBELEM_UNIQUE},
1659 {LY_STMT_MIN_ELEMENTS, rf, YIN_SUBELEM_UNIQUE},
1660 {LY_STMT_MUST, &rf->musts, 0},
1661 {LY_STMT_PRESENCE, &rf->presence, YIN_SUBELEM_UNIQUE},
1662 {LY_STMT_REFERENCE, &rf->ref, YIN_SUBELEM_UNIQUE},
1663 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1664 };
Michal Vasko69730152020-10-09 16:30:07 +02001665
Radek Krejcif13b87b2020-12-01 22:02:17 +01001666 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_REFINE, NULL, &rf->exts);
David Sedlákd2d676a2019-07-22 11:28:19 +02001667}
1668
1669/**
David Sedlák0d6de5a2019-07-22 13:25:44 +02001670 * @brief Parse uses element.
1671 *
1672 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákad83cf92019-08-13 12:53:53 +02001673 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlák0d6de5a2019-07-22 13:25:44 +02001674 *
1675 * @return LY_ERR values.
1676 */
1677static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001678yin_parse_uses(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *node_meta)
David Sedlák0d6de5a2019-07-22 13:25:44 +02001679{
David Sedlák0d6de5a2019-07-22 13:25:44 +02001680 struct lysp_node_uses *uses;
1681
David Sedlák8d552d62019-08-06 15:29:05 +02001682 /* create new uses */
Michal Vaskob36053d2020-03-26 15:49:30 +01001683 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, uses, next, LY_EMEM);
David Sedlák0d6de5a2019-07-22 13:25:44 +02001684 uses->nodetype = LYS_USES;
1685 uses->parent = node_meta->parent;
1686
David Sedlák0d6de5a2019-07-22 13:25:44 +02001687 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001688 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1689 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &uses->name, Y_PREF_IDENTIF_ARG, LY_STMT_USES));
David Sedlák0d6de5a2019-07-22 13:25:44 +02001690
1691 /* parse content */
David Sedlák6881b512019-08-13 12:52:00 +02001692 struct tree_node_meta augments = {(struct lysp_node *)uses, (struct lysp_node **)&uses->augments};
Radek Krejcif13b87b2020-12-01 22:02:17 +01001693 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001694 {LY_STMT_AUGMENT, &augments, 0},
1695 {LY_STMT_DESCRIPTION, &uses->dsc, YIN_SUBELEM_UNIQUE},
1696 {LY_STMT_IF_FEATURE, &uses->iffeatures, 0},
1697 {LY_STMT_REFERENCE, &uses->ref, YIN_SUBELEM_UNIQUE},
1698 {LY_STMT_REFINE, &uses->refines, 0},
1699 {LY_STMT_STATUS, &uses->flags, YIN_SUBELEM_UNIQUE},
1700 {LY_STMT_WHEN, &uses->when, YIN_SUBELEM_UNIQUE},
1701 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1702 };
Michal Vasko69730152020-10-09 16:30:07 +02001703
Radek Krejcif13b87b2020-12-01 22:02:17 +01001704 LY_CHECK_RET(yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_USES, NULL, &uses->exts));
David Sedlák0d6de5a2019-07-22 13:25:44 +02001705
1706 return LY_SUCCESS;
1707}
1708
1709/**
David Sedlákaa854b02019-07-22 14:17:10 +02001710 * @brief Parse revision element.
1711 *
1712 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákaa854b02019-07-22 14:17:10 +02001713 * @param[in,out] revs Parsed revisions to add to.
1714 *
1715 * @return LY_ERR values.
1716 */
1717static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001718yin_parse_revision(struct lys_yin_parser_ctx *ctx, struct lysp_revision **revs)
David Sedlákaa854b02019-07-22 14:17:10 +02001719{
1720 struct lysp_revision *rev;
1721 const char *temp_date = NULL;
1722
1723 /* allocate new reivison */
Michal Vaskob36053d2020-03-26 15:49:30 +01001724 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *revs, rev, LY_EMEM);
David Sedlákaa854b02019-07-22 14:17:10 +02001725
1726 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001727 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1728 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_DATE, &temp_date, Y_STR_ARG, LY_STMT_REVISION));
David Sedlákaa854b02019-07-22 14:17:10 +02001729 /* check value */
1730 if (lysp_check_date((struct lys_parser_ctx *)ctx, temp_date, strlen(temp_date), "revision")) {
Michal Vaskoe180ed02021-02-05 16:31:20 +01001731 lydict_remove(ctx->xmlctx->ctx, temp_date);
David Sedlákaa854b02019-07-22 14:17:10 +02001732 return LY_EVALID;
1733 }
Radek Krejci36642162021-01-12 16:49:22 +01001734 memcpy(rev->date, temp_date, LY_REV_SIZE);
Michal Vaskoe180ed02021-02-05 16:31:20 +01001735 lydict_remove(ctx->xmlctx->ctx, temp_date);
David Sedlákaa854b02019-07-22 14:17:10 +02001736
1737 /* parse content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001738 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001739 {LY_STMT_DESCRIPTION, &rev->dsc, YIN_SUBELEM_UNIQUE},
1740 {LY_STMT_REFERENCE, &rev->ref, YIN_SUBELEM_UNIQUE},
1741 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1742 };
Michal Vasko69730152020-10-09 16:30:07 +02001743
Radek Krejcif13b87b2020-12-01 22:02:17 +01001744 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_REVISION, NULL, &rev->exts);
David Sedlákaa854b02019-07-22 14:17:10 +02001745}
1746
David Sedlák5e13dea2019-07-22 16:06:45 +02001747/**
1748 * @brief Parse include element.
1749 *
1750 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák5e13dea2019-07-22 16:06:45 +02001751 * @param[in,out] inc_meta Meta informatinou about module/submodule name and includes to add to.
1752 *
1753 * @return LY_ERR values.
1754 */
David Sedlák0c2bab92019-07-22 15:33:19 +02001755static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001756yin_parse_include(struct lys_yin_parser_ctx *ctx, struct include_meta *inc_meta)
David Sedlák0c2bab92019-07-22 15:33:19 +02001757{
1758 struct lysp_include *inc;
1759
1760 /* allocate new include */
Michal Vaskob36053d2020-03-26 15:49:30 +01001761 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *inc_meta->includes, inc, LY_EMEM);
David Sedlák0c2bab92019-07-22 15:33:19 +02001762
1763 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001764 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1765 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_MODULE, &inc->name, Y_IDENTIF_ARG, LY_STMT_INCLUDE));
David Sedlák0c2bab92019-07-22 15:33:19 +02001766
1767 /* submodules share the namespace with the module names, so there must not be
1768 * a module of the same name in the context, no need for revision matching */
Michal Vaskob36053d2020-03-26 15:49:30 +01001769 if (!strcmp(inc_meta->name, inc->name) || ly_ctx_get_module_latest(ctx->xmlctx->ctx, inc->name)) {
Radek Krejci854e1552020-12-21 15:05:23 +01001770 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_NAME2_COL, "module", "submodule", inc->name);
David Sedlák0c2bab92019-07-22 15:33:19 +02001771 return LY_EVALID;
1772 }
1773
1774 /* parse content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001775 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001776 {LY_STMT_DESCRIPTION, &inc->dsc, YIN_SUBELEM_UNIQUE | YIN_SUBELEM_VER2},
1777 {LY_STMT_REFERENCE, &inc->ref, YIN_SUBELEM_UNIQUE | YIN_SUBELEM_VER2},
1778 {LY_STMT_REVISION_DATE, &inc->rev, YIN_SUBELEM_UNIQUE},
1779 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1780 };
Michal Vasko69730152020-10-09 16:30:07 +02001781
Radek Krejcif13b87b2020-12-01 22:02:17 +01001782 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_INCLUDE, NULL, &inc->exts);
David Sedlák0c2bab92019-07-22 15:33:19 +02001783}
1784
David Sedlákaa854b02019-07-22 14:17:10 +02001785/**
David Sedlákbf8a2b72019-08-14 16:48:10 +02001786 * @brief Parse revision-date element.
David Sedlákdfbbb442019-08-06 16:33:21 +02001787 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001788 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001789 * @param[in,out] rev Array to store the parsed value in.
1790 * @param[in,out] exts Extension instances to add to.
1791 *
1792 * @return LY_ERR values.
1793 */
1794static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001795yin_parse_revision_date(struct lys_yin_parser_ctx *ctx, char *rev, struct lysp_ext_instance **exts)
David Sedlákdfbbb442019-08-06 16:33:21 +02001796{
1797 const char *temp_rev;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001798 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001799 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1800 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001801
Michal Vaskob36053d2020-03-26 15:49:30 +01001802 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1803 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_DATE, &temp_rev, Y_STR_ARG, LY_STMT_REVISION_DATE));
David Sedlákdfbbb442019-08-06 16:33:21 +02001804 LY_CHECK_ERR_RET(lysp_check_date((struct lys_parser_ctx *)ctx, temp_rev, strlen(temp_rev), "revision-date") != LY_SUCCESS,
Michal Vaskoe180ed02021-02-05 16:31:20 +01001805 lydict_remove(ctx->xmlctx->ctx, temp_rev), LY_EVALID);
David Sedlákdfbbb442019-08-06 16:33:21 +02001806
1807 strcpy(rev, temp_rev);
Michal Vaskoe180ed02021-02-05 16:31:20 +01001808 lydict_remove(ctx->xmlctx->ctx, temp_rev);
David Sedlákdfbbb442019-08-06 16:33:21 +02001809
Radek Krejcif13b87b2020-12-01 22:02:17 +01001810 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_REVISION_DATE, NULL, exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02001811}
1812
1813/**
1814 * @brief Parse config element.
1815 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001816 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001817 * @param[in,out] flags Flags to add to.
1818 * @param[in,out] exts Extension instances to add to.
1819 *
1820 * @return LY_ERR values.
1821 */
1822static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001823yin_parse_config(struct lys_yin_parser_ctx *ctx, uint16_t *flags, struct lysp_ext_instance **exts)
David Sedlákdfbbb442019-08-06 16:33:21 +02001824{
1825 const char *temp_val = NULL;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001826 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001827 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1828 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001829
Michal Vaskob36053d2020-03-26 15:49:30 +01001830 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1831 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &temp_val, Y_STR_ARG, LY_STMT_CONFIG));
David Sedlákdfbbb442019-08-06 16:33:21 +02001832 if (strcmp(temp_val, "true") == 0) {
1833 *flags |= LYS_CONFIG_W;
1834 } else if (strcmp(temp_val, "false") == 0) {
1835 *flags |= LYS_CONFIG_R;
1836 } else {
David Sedlák26ea1432019-08-14 13:42:23 +02001837 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS2, temp_val, "value", "config",
Michal Vasko69730152020-10-09 16:30:07 +02001838 "true", "false");
Michal Vaskoe180ed02021-02-05 16:31:20 +01001839 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákdfbbb442019-08-06 16:33:21 +02001840 return LY_EVALID;
1841 }
Michal Vaskoe180ed02021-02-05 16:31:20 +01001842 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákdfbbb442019-08-06 16:33:21 +02001843
Radek Krejcif13b87b2020-12-01 22:02:17 +01001844 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_CONFIG, NULL, exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02001845}
1846
1847/**
1848 * @brief Parse yang-version element.
1849 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001850 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001851 * @param[out] version Storage for the parsed information.
David Sedlákbf8a2b72019-08-14 16:48:10 +02001852 * @param[in,out] exts Extension instances to add to.
David Sedlákdfbbb442019-08-06 16:33:21 +02001853 *
1854 * @return LY_ERR values.
1855 */
1856static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001857yin_parse_yangversion(struct lys_yin_parser_ctx *ctx, uint8_t *version, struct lysp_ext_instance **exts)
David Sedlákdfbbb442019-08-06 16:33:21 +02001858{
1859 const char *temp_version = NULL;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001860 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001861 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1862 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001863
Michal Vaskob36053d2020-03-26 15:49:30 +01001864 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1865 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &temp_version, Y_STR_ARG, LY_STMT_YANG_VERSION));
Radek Krejci96e48da2020-09-04 13:18:06 +02001866 if (strcmp(temp_version, "1") == 0) {
David Sedlákdfbbb442019-08-06 16:33:21 +02001867 *version = LYS_VERSION_1_0;
1868 } else if (strcmp(temp_version, "1.1") == 0) {
1869 *version = LYS_VERSION_1_1;
1870 } else {
David Sedlák26ea1432019-08-14 13:42:23 +02001871 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS2, temp_version, "value",
Michal Vasko69730152020-10-09 16:30:07 +02001872 "yang-version", "1", "1.1");
Michal Vaskoe180ed02021-02-05 16:31:20 +01001873 lydict_remove(ctx->xmlctx->ctx, temp_version);
David Sedlákdfbbb442019-08-06 16:33:21 +02001874 return LY_EVALID;
1875 }
Michal Vaskoe180ed02021-02-05 16:31:20 +01001876 lydict_remove(ctx->xmlctx->ctx, temp_version);
David Sedlákdfbbb442019-08-06 16:33:21 +02001877
Radek Krejcif13b87b2020-12-01 22:02:17 +01001878 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_YANG_VERSION, NULL, exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02001879}
1880
1881/**
1882 * @brief Parse import element.
1883 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001884 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001885 * @param[in,out] imp_meta Meta information about prefix and imports to add to.
1886 *
1887 * @return LY_ERR values.
1888 */
1889static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001890yin_parse_import(struct lys_yin_parser_ctx *ctx, struct import_meta *imp_meta)
David Sedlákdfbbb442019-08-06 16:33:21 +02001891{
1892 struct lysp_import *imp;
Michal Vasko69730152020-10-09 16:30:07 +02001893
David Sedlákdfbbb442019-08-06 16:33:21 +02001894 /* allocate new element in sized array for import */
Michal Vaskob36053d2020-03-26 15:49:30 +01001895 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *imp_meta->imports, imp, LY_EMEM);
David Sedlákdfbbb442019-08-06 16:33:21 +02001896
Radek Krejcif13b87b2020-12-01 22:02:17 +01001897 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001898 {LY_STMT_DESCRIPTION, &imp->dsc, YIN_SUBELEM_UNIQUE},
1899 {LY_STMT_PREFIX, &imp->prefix, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE},
1900 {LY_STMT_REFERENCE, &imp->ref, YIN_SUBELEM_UNIQUE},
1901 {LY_STMT_REVISION_DATE, imp->rev, YIN_SUBELEM_UNIQUE},
1902 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1903 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001904
1905 /* parse import attributes */
Michal Vaskob36053d2020-03-26 15:49:30 +01001906 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1907 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_MODULE, &imp->name, Y_IDENTIF_ARG, LY_STMT_IMPORT));
Radek Krejcif13b87b2020-12-01 22:02:17 +01001908 LY_CHECK_RET(yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_IMPORT, NULL, &imp->exts));
David Sedlákdfbbb442019-08-06 16:33:21 +02001909 /* check prefix validity */
1910 LY_CHECK_RET(lysp_check_prefix((struct lys_parser_ctx *)ctx, *imp_meta->imports, imp_meta->prefix, &imp->prefix), LY_EVALID);
1911
1912 return LY_SUCCESS;
1913}
1914
1915/**
1916 * @brief Parse mandatory element.
1917 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001918 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001919 * @param[in,out] flags Flags to add to.
1920 * @param[in,out] exts Extension instances to add to.
1921 *
1922 * @return LY_ERR values.
1923 */
1924static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001925yin_parse_mandatory(struct lys_yin_parser_ctx *ctx, uint16_t *flags, struct lysp_ext_instance **exts)
David Sedlákdfbbb442019-08-06 16:33:21 +02001926{
1927 const char *temp_val = NULL;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001928 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001929 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1930 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001931
Michal Vaskob36053d2020-03-26 15:49:30 +01001932 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1933 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &temp_val, Y_STR_ARG, LY_STMT_MANDATORY));
David Sedlákdfbbb442019-08-06 16:33:21 +02001934 if (strcmp(temp_val, "true") == 0) {
1935 *flags |= LYS_MAND_TRUE;
1936 } else if (strcmp(temp_val, "false") == 0) {
1937 *flags |= LYS_MAND_FALSE;
1938 } else {
David Sedlák26ea1432019-08-14 13:42:23 +02001939 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS2, temp_val, "value",
Michal Vasko69730152020-10-09 16:30:07 +02001940 "mandatory", "true", "false");
Michal Vaskoe180ed02021-02-05 16:31:20 +01001941 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákdfbbb442019-08-06 16:33:21 +02001942 return LY_EVALID;
1943 }
Michal Vaskoe180ed02021-02-05 16:31:20 +01001944 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákdfbbb442019-08-06 16:33:21 +02001945
Radek Krejcif13b87b2020-12-01 22:02:17 +01001946 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_MANDATORY, NULL, exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02001947}
1948
1949/**
1950 * @brief Parse status element.
1951 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001952 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001953 * @param[in,out] flags Flags to add to.
1954 * @param[in,out] exts Extension instances to add to.
1955 *
1956 * @return LY_ERR values.
1957 */
1958static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001959yin_parse_status(struct lys_yin_parser_ctx *ctx, uint16_t *flags, struct lysp_ext_instance **exts)
David Sedlákdfbbb442019-08-06 16:33:21 +02001960{
1961 const char *value = NULL;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001962 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001963 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1964 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001965
Michal Vaskob36053d2020-03-26 15:49:30 +01001966 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1967 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &value, Y_STR_ARG, LY_STMT_STATUS));
David Sedlákdfbbb442019-08-06 16:33:21 +02001968 if (strcmp(value, "current") == 0) {
1969 *flags |= LYS_STATUS_CURR;
1970 } else if (strcmp(value, "deprecated") == 0) {
1971 *flags |= LYS_STATUS_DEPRC;
1972 } else if (strcmp(value, "obsolete") == 0) {
1973 *flags |= LYS_STATUS_OBSLT;
1974 } else {
David Sedlák26ea1432019-08-14 13:42:23 +02001975 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS3, value, "value",
Michal Vasko69730152020-10-09 16:30:07 +02001976 "status", "current", "deprecated", "obsolete");
Michal Vaskoe180ed02021-02-05 16:31:20 +01001977 lydict_remove(ctx->xmlctx->ctx, value);
David Sedlákdfbbb442019-08-06 16:33:21 +02001978 return LY_EVALID;
1979 }
Michal Vaskoe180ed02021-02-05 16:31:20 +01001980 lydict_remove(ctx->xmlctx->ctx, value);
David Sedlákdfbbb442019-08-06 16:33:21 +02001981
Radek Krejcif13b87b2020-12-01 22:02:17 +01001982 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_STATUS, NULL, exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02001983}
1984
1985/**
1986 * @brief Parse when element.
1987 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001988 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001989 * @param[out] when_p When pointer to parse to.
1990 */
1991static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001992yin_parse_when(struct lys_yin_parser_ctx *ctx, struct lysp_when **when_p)
David Sedlákdfbbb442019-08-06 16:33:21 +02001993{
1994 struct lysp_when *when;
David Sedláka56e0012019-08-15 13:21:25 +02001995 LY_ERR ret = LY_SUCCESS;
1996
David Sedlákdfbbb442019-08-06 16:33:21 +02001997 when = calloc(1, sizeof *when);
Michal Vaskob36053d2020-03-26 15:49:30 +01001998 LY_CHECK_ERR_RET(!when, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
Radek Krejcif6923e82020-07-02 16:36:53 +02001999
2000 ret = lyxml_ctx_next(ctx->xmlctx);
2001 LY_CHECK_ERR_RET(ret, free(when), ret);
2002
Michal Vaskob36053d2020-03-26 15:49:30 +01002003 ret = yin_parse_attribute(ctx, YIN_ARG_CONDITION, &when->cond, Y_STR_ARG, LY_STMT_WHEN);
David Sedláka56e0012019-08-15 13:21:25 +02002004 LY_CHECK_ERR_RET(ret, free(when), ret);
2005
David Sedlákdfbbb442019-08-06 16:33:21 +02002006 *when_p = when;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002007 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02002008 {LY_STMT_DESCRIPTION, &when->dsc, YIN_SUBELEM_UNIQUE},
2009 {LY_STMT_REFERENCE, &when->ref, YIN_SUBELEM_UNIQUE},
2010 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
2011 };
David Sedlákdfbbb442019-08-06 16:33:21 +02002012
Radek Krejcif13b87b2020-12-01 22:02:17 +01002013 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_WHEN, NULL, &when->exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02002014}
2015
2016/**
2017 * @brief Parse yin-elemenet element.
2018 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02002019 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02002020 * @param[in,out] data Data to read from, always moved to currently handled position.
2021 * @param[in,out] flags Flags to add to.
David Sedlákbf8a2b72019-08-14 16:48:10 +02002022 * @prama[in,out] exts Extension instances to add to.
David Sedlákdfbbb442019-08-06 16:33:21 +02002023 *
2024 * @return LY_ERR values.
2025 */
2026static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002027yin_parse_yin_element(struct lys_yin_parser_ctx *ctx, uint16_t *flags, struct lysp_ext_instance **exts)
David Sedlákdfbbb442019-08-06 16:33:21 +02002028{
2029 const char *temp_val = NULL;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002030 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02002031 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
2032 };
David Sedlákdfbbb442019-08-06 16:33:21 +02002033
Michal Vaskob36053d2020-03-26 15:49:30 +01002034 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2035 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &temp_val, Y_STR_ARG, LY_STMT_YIN_ELEMENT));
David Sedlákdfbbb442019-08-06 16:33:21 +02002036 if (strcmp(temp_val, "true") == 0) {
2037 *flags |= LYS_YINELEM_TRUE;
2038 } else if (strcmp(temp_val, "false") == 0) {
2039 *flags |= LYS_YINELEM_FALSE;
2040 } else {
David Sedlák26ea1432019-08-14 13:42:23 +02002041 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS2, temp_val, "value",
Michal Vasko69730152020-10-09 16:30:07 +02002042 "yin-element", "true", "false");
Michal Vaskoe180ed02021-02-05 16:31:20 +01002043 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákdfbbb442019-08-06 16:33:21 +02002044 return LY_EVALID;
2045 }
Michal Vaskoe180ed02021-02-05 16:31:20 +01002046 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákdfbbb442019-08-06 16:33:21 +02002047
Radek Krejcif13b87b2020-12-01 22:02:17 +01002048 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_YIN_ELEMENT, NULL, exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02002049}
2050
2051/**
2052 * @brief Parse argument element.
2053 *
Michal Vaskob36053d2020-03-26 15:49:30 +01002054 * @param[in,out] xmlctx Xml context.
David Sedlákbf8a2b72019-08-14 16:48:10 +02002055 * @param[in,out] arg_meta Meta information about destionation of parsed data.
2056 * @param[in,out] exts Extension instances to add to.
David Sedlákdfbbb442019-08-06 16:33:21 +02002057 *
2058 * @return LY_ERR values.
2059 */
2060static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002061yin_parse_argument(struct lys_yin_parser_ctx *ctx, struct yin_argument_meta *arg_meta, struct lysp_ext_instance **exts)
David Sedlákdfbbb442019-08-06 16:33:21 +02002062{
Radek Krejcif13b87b2020-12-01 22:02:17 +01002063 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02002064 {LY_STMT_YIN_ELEMENT, arg_meta->flags, YIN_SUBELEM_UNIQUE},
2065 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
2066 };
David Sedlákdfbbb442019-08-06 16:33:21 +02002067
Michal Vaskob36053d2020-03-26 15:49:30 +01002068 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2069 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, arg_meta->argument, Y_IDENTIF_ARG, LY_STMT_ARGUMENT));
David Sedlákdfbbb442019-08-06 16:33:21 +02002070
Radek Krejcif13b87b2020-12-01 22:02:17 +01002071 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_ARGUMENT, NULL, exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02002072}
2073
2074/**
2075 * @brief Parse the extension statement.
2076 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02002077 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02002078 * @param[in,out] extensions Extensions to add to.
2079 *
2080 * @return LY_ERR values.
2081 */
2082static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002083yin_parse_extension(struct lys_yin_parser_ctx *ctx, struct lysp_ext **extensions)
David Sedlákdfbbb442019-08-06 16:33:21 +02002084{
2085 struct lysp_ext *ex;
Michal Vasko69730152020-10-09 16:30:07 +02002086
Michal Vaskob36053d2020-03-26 15:49:30 +01002087 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *extensions, ex, LY_EMEM);
2088 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2089 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &ex->name, Y_IDENTIF_ARG, LY_STMT_EXTENSION));
David Sedlákdfbbb442019-08-06 16:33:21 +02002090
Radek Krejci9f87b0c2021-03-05 14:45:26 +01002091 struct yin_argument_meta arg_info = {&ex->flags, &ex->argname};
Radek Krejcif13b87b2020-12-01 22:02:17 +01002092 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02002093 {LY_STMT_ARGUMENT, &arg_info, YIN_SUBELEM_UNIQUE},
2094 {LY_STMT_DESCRIPTION, &ex->dsc, YIN_SUBELEM_UNIQUE},
2095 {LY_STMT_REFERENCE, &ex->ref, YIN_SUBELEM_UNIQUE},
2096 {LY_STMT_STATUS, &ex->flags, YIN_SUBELEM_UNIQUE},
2097 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
2098 };
David Sedlákdfbbb442019-08-06 16:33:21 +02002099
Radek Krejcif13b87b2020-12-01 22:02:17 +01002100 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_EXTENSION, NULL, &ex->exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02002101}
2102
2103/**
David Sedlák5e13dea2019-07-22 16:06:45 +02002104 * @brief Parse feature element.
2105 *
2106 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák5e13dea2019-07-22 16:06:45 +02002107 * @param[in,out] features Features to add to.
2108 *
2109 * @return LY_ERR values.
2110 */
2111static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002112yin_parse_feature(struct lys_yin_parser_ctx *ctx, struct lysp_feature **features)
David Sedlák5e13dea2019-07-22 16:06:45 +02002113{
2114 struct lysp_feature *feat;
2115
2116 /* allocate new feature */
Michal Vaskob36053d2020-03-26 15:49:30 +01002117 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *features, feat, LY_EMEM);
David Sedlák5e13dea2019-07-22 16:06:45 +02002118
2119 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002120 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2121 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &feat->name, Y_IDENTIF_ARG, LY_STMT_FEATURE));
David Sedlák5e13dea2019-07-22 16:06:45 +02002122
2123 /* parse content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01002124 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02002125 {LY_STMT_DESCRIPTION, &feat->dsc, YIN_SUBELEM_UNIQUE},
2126 {LY_STMT_IF_FEATURE, &feat->iffeatures, 0},
2127 {LY_STMT_REFERENCE, &feat->ref, YIN_SUBELEM_UNIQUE},
2128 {LY_STMT_STATUS, &feat->flags, YIN_SUBELEM_UNIQUE},
2129 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
2130 };
Michal Vasko69730152020-10-09 16:30:07 +02002131
Radek Krejcif13b87b2020-12-01 22:02:17 +01002132 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_FEATURE, NULL, &feat->exts);
David Sedlák5e13dea2019-07-22 16:06:45 +02002133}
2134
2135/**
David Sedlák28794f22019-07-22 16:45:00 +02002136 * @brief Parse identity element.
2137 *
2138 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák28794f22019-07-22 16:45:00 +02002139 * @param[in,out] identities Identities to add to.
2140 *
2141 * @return LY_ERR values.
2142 */
2143static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002144yin_parse_identity(struct lys_yin_parser_ctx *ctx, struct lysp_ident **identities)
David Sedlák28794f22019-07-22 16:45:00 +02002145{
2146 struct lysp_ident *ident;
2147
2148 /* allocate new identity */
Michal Vaskob36053d2020-03-26 15:49:30 +01002149 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *identities, ident, LY_EMEM);
David Sedlák28794f22019-07-22 16:45:00 +02002150
2151 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002152 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2153 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &ident->name, Y_IDENTIF_ARG, LY_STMT_IDENTITY));
David Sedlák28794f22019-07-22 16:45:00 +02002154
2155 /* parse content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01002156 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02002157 {LY_STMT_BASE, &ident->bases, 0},
2158 {LY_STMT_DESCRIPTION, &ident->dsc, YIN_SUBELEM_UNIQUE},
2159 {LY_STMT_IF_FEATURE, &ident->iffeatures, YIN_SUBELEM_VER2},
2160 {LY_STMT_REFERENCE, &ident->ref, YIN_SUBELEM_UNIQUE},
2161 {LY_STMT_STATUS, &ident->flags, YIN_SUBELEM_UNIQUE},
2162 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
2163 };
Michal Vasko69730152020-10-09 16:30:07 +02002164
Radek Krejcif13b87b2020-12-01 22:02:17 +01002165 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_IDENTITY, NULL, &ident->exts);
David Sedlák28794f22019-07-22 16:45:00 +02002166}
2167
2168/**
David Sedlákaf536aa2019-07-23 13:42:23 +02002169 * @brief Parse list element.
2170 *
2171 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákad83cf92019-08-13 12:53:53 +02002172 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlákaf536aa2019-07-23 13:42:23 +02002173 *
2174 * @return LY_ERR values.
2175 */
2176static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002177yin_parse_list(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *node_meta)
David Sedlákaf536aa2019-07-23 13:42:23 +02002178{
David Sedlákaf536aa2019-07-23 13:42:23 +02002179 struct lysp_node_list *list;
David Sedlák81497a32019-08-13 16:56:26 +02002180 LY_ERR ret = LY_SUCCESS;
2181 struct yin_subelement *subelems = NULL;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002182 size_t subelems_size;
David Sedlákaf536aa2019-07-23 13:42:23 +02002183
Michal Vaskob36053d2020-03-26 15:49:30 +01002184 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, list, next, LY_EMEM);
David Sedlákaf536aa2019-07-23 13:42:23 +02002185 list->nodetype = LYS_LIST;
2186 list->parent = node_meta->parent;
2187
David Sedlákaf536aa2019-07-23 13:42:23 +02002188 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002189 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2190 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &list->name, Y_IDENTIF_ARG, LY_STMT_LIST));
David Sedlákaf536aa2019-07-23 13:42:23 +02002191
2192 /* parse list content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01002193 LY_CHECK_RET(subelems_allocator(ctx, subelems_size = 25, (struct lysp_node *)list, &subelems,
Michal Vasko69730152020-10-09 16:30:07 +02002194 LY_STMT_ACTION, &list->actions, 0,
2195 LY_STMT_ANYDATA, &list->child, 0,
2196 LY_STMT_ANYXML, &list->child, 0,
2197 LY_STMT_CHOICE, &list->child, 0,
2198 LY_STMT_CONFIG, &list->flags, YIN_SUBELEM_UNIQUE,
2199 LY_STMT_CONTAINER, &list->child, 0,
2200 LY_STMT_DESCRIPTION, &list->dsc, YIN_SUBELEM_UNIQUE,
2201 LY_STMT_GROUPING, &list->groupings, 0,
2202 LY_STMT_IF_FEATURE, &list->iffeatures, 0,
2203 LY_STMT_KEY, &list->key, YIN_SUBELEM_UNIQUE,
2204 LY_STMT_LEAF, &list->child, 0,
2205 LY_STMT_LEAF_LIST, &list->child, 0,
2206 LY_STMT_LIST, &list->child, 0,
2207 LY_STMT_MAX_ELEMENTS, list, YIN_SUBELEM_UNIQUE,
2208 LY_STMT_MIN_ELEMENTS, list, YIN_SUBELEM_UNIQUE,
2209 LY_STMT_MUST, &list->musts, 0,
2210 LY_STMT_NOTIFICATION, &list->notifs, 0,
2211 LY_STMT_ORDERED_BY, &list->flags, YIN_SUBELEM_UNIQUE,
2212 LY_STMT_REFERENCE, &list->ref, YIN_SUBELEM_UNIQUE,
2213 LY_STMT_STATUS, &list->flags, YIN_SUBELEM_UNIQUE,
2214 LY_STMT_TYPEDEF, &list->typedefs, 0,
2215 LY_STMT_UNIQUE, &list->uniques, 0,
2216 LY_STMT_USES, &list->child, 0,
2217 LY_STMT_WHEN, &list->when, YIN_SUBELEM_UNIQUE,
2218 LY_STMT_EXTENSION_INSTANCE, NULL, 0));
Radek Krejcif13b87b2020-12-01 22:02:17 +01002219 ret = yin_parse_content(ctx, subelems, subelems_size, LY_STMT_LIST, NULL, &list->exts);
2220 subelems_deallocator(subelems_size, subelems);
David Sedlák81497a32019-08-13 16:56:26 +02002221 LY_CHECK_RET(ret);
David Sedlákaf536aa2019-07-23 13:42:23 +02002222
Michal Vasko69730152020-10-09 16:30:07 +02002223 if (list->max && (list->min > list->max)) {
David Sedlák1538a842019-08-08 15:38:51 +02002224 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_MINMAX, list->min, list->max);
David Sedlákaf536aa2019-07-23 13:42:23 +02002225 return LY_EVALID;
2226 }
2227
2228 return LY_SUCCESS;
2229}
2230
2231/**
David Sedlák031b9e72019-07-23 15:19:37 +02002232 * @brief Parse notification element.
2233 *
2234 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák05404f62019-07-24 14:11:53 +02002235 * @param[in,out] notif_meta Meta information about parent node and notifications to add to.
David Sedlák031b9e72019-07-23 15:19:37 +02002236 *
2237 * @return LY_ERR values.
2238 */
2239static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002240yin_parse_notification(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *notif_meta)
David Sedlák031b9e72019-07-23 15:19:37 +02002241{
Radek Krejci2a9fc652021-01-22 17:44:34 +01002242 struct lysp_node_notif *notif;
2243 struct lysp_node_notif **notifs = (struct lysp_node_notif **)notif_meta->nodes;
David Sedlák81497a32019-08-13 16:56:26 +02002244 LY_ERR ret = LY_SUCCESS;
2245 struct yin_subelement *subelems = NULL;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002246 size_t subelems_size;
David Sedlák031b9e72019-07-23 15:19:37 +02002247
2248 /* allocate new notification */
Radek Krejci2a9fc652021-01-22 17:44:34 +01002249 LY_LIST_NEW_RET(ctx->xmlctx->ctx, notifs, notif, next, LY_EMEM);
David Sedlák031b9e72019-07-23 15:19:37 +02002250 notif->nodetype = LYS_NOTIF;
2251 notif->parent = notif_meta->parent;
2252
2253 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002254 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2255 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &notif->name, Y_IDENTIF_ARG, LY_STMT_NOTIFICATION));
David Sedlák031b9e72019-07-23 15:19:37 +02002256
2257 /* parse notification content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01002258 LY_CHECK_RET(subelems_allocator(ctx, subelems_size = 16, (struct lysp_node *)notif, &subelems,
Radek Krejci01180ac2021-01-27 08:48:22 +01002259 LY_STMT_ANYDATA, &notif->child, 0,
2260 LY_STMT_ANYXML, &notif->child, 0,
2261 LY_STMT_CHOICE, &notif->child, 0,
2262 LY_STMT_CONTAINER, &notif->child, 0,
Michal Vasko69730152020-10-09 16:30:07 +02002263 LY_STMT_DESCRIPTION, &notif->dsc, YIN_SUBELEM_UNIQUE,
2264 LY_STMT_GROUPING, &notif->groupings, 0,
2265 LY_STMT_IF_FEATURE, &notif->iffeatures, 0,
Radek Krejci01180ac2021-01-27 08:48:22 +01002266 LY_STMT_LEAF, &notif->child, 0,
2267 LY_STMT_LEAF_LIST, &notif->child, 0,
2268 LY_STMT_LIST, &notif->child, 0,
Michal Vasko69730152020-10-09 16:30:07 +02002269 LY_STMT_MUST, &notif->musts, YIN_SUBELEM_VER2,
2270 LY_STMT_REFERENCE, &notif->ref, YIN_SUBELEM_UNIQUE,
2271 LY_STMT_STATUS, &notif->flags, YIN_SUBELEM_UNIQUE,
2272 LY_STMT_TYPEDEF, &notif->typedefs, 0,
Radek Krejci01180ac2021-01-27 08:48:22 +01002273 LY_STMT_USES, &notif->child, 0,
Michal Vasko69730152020-10-09 16:30:07 +02002274 LY_STMT_EXTENSION_INSTANCE, NULL, 0));
David Sedlák81497a32019-08-13 16:56:26 +02002275
Radek Krejcif13b87b2020-12-01 22:02:17 +01002276 ret = yin_parse_content(ctx, subelems, subelems_size, LY_STMT_NOTIFICATION, NULL, &notif->exts);
2277 subelems_deallocator(subelems_size, subelems);
David Sedlák81497a32019-08-13 16:56:26 +02002278 LY_CHECK_RET(ret);
David Sedlák031b9e72019-07-23 15:19:37 +02002279
David Sedlák031b9e72019-07-23 15:19:37 +02002280 return LY_SUCCESS;
2281}
2282
2283/**
David Sedlákbf8a2b72019-08-14 16:48:10 +02002284 * @brief Parse grouping element.
David Sedláke3ce9ef2019-07-23 16:34:30 +02002285 *
2286 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbf8a2b72019-08-14 16:48:10 +02002287 * @param[in,out] gr_meta Meta information about parent node and groupings to add to.
David Sedláke3ce9ef2019-07-23 16:34:30 +02002288 *
2289 * @return LY_ERR values.
2290 */
2291static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002292yin_parse_grouping(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *gr_meta)
David Sedláke3ce9ef2019-07-23 16:34:30 +02002293{
Radek Krejci2a9fc652021-01-22 17:44:34 +01002294 struct lysp_node_grp *grp;
2295 struct lysp_node_grp **grps = (struct lysp_node_grp **)gr_meta->nodes;
David Sedlák81497a32019-08-13 16:56:26 +02002296 LY_ERR ret = LY_SUCCESS;
2297 struct yin_subelement *subelems = NULL;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002298 size_t subelems_size;
David Sedláke3ce9ef2019-07-23 16:34:30 +02002299
2300 /* create new grouping */
Radek Krejci2a9fc652021-01-22 17:44:34 +01002301 LY_LIST_NEW_RET(ctx->xmlctx->ctx, grps, grp, next, LY_EMEM);
David Sedláke3ce9ef2019-07-23 16:34:30 +02002302 grp->nodetype = LYS_GROUPING;
2303 grp->parent = gr_meta->parent;
2304
2305 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002306 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2307 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &grp->name, Y_IDENTIF_ARG, LY_STMT_GROUPING));
David Sedláke3ce9ef2019-07-23 16:34:30 +02002308
2309 /* parse grouping content */
Radek Krejci2a9fc652021-01-22 17:44:34 +01002310 LY_CHECK_RET(subelems_allocator(ctx, subelems_size = 16, &grp->node, &subelems,
Michal Vasko69730152020-10-09 16:30:07 +02002311 LY_STMT_ACTION, &grp->actions, 0,
Radek Krejci01180ac2021-01-27 08:48:22 +01002312 LY_STMT_ANYDATA, &grp->child, 0,
2313 LY_STMT_ANYXML, &grp->child, 0,
2314 LY_STMT_CHOICE, &grp->child, 0,
2315 LY_STMT_CONTAINER, &grp->child, 0,
Michal Vasko69730152020-10-09 16:30:07 +02002316 LY_STMT_DESCRIPTION, &grp->dsc, YIN_SUBELEM_UNIQUE,
2317 LY_STMT_GROUPING, &grp->groupings, 0,
Radek Krejci01180ac2021-01-27 08:48:22 +01002318 LY_STMT_LEAF, &grp->child, 0,
2319 LY_STMT_LEAF_LIST, &grp->child, 0,
2320 LY_STMT_LIST, &grp->child, 0,
Michal Vasko69730152020-10-09 16:30:07 +02002321 LY_STMT_NOTIFICATION, &grp->notifs, 0,
2322 LY_STMT_REFERENCE, &grp->ref, YIN_SUBELEM_UNIQUE,
2323 LY_STMT_STATUS, &grp->flags, YIN_SUBELEM_UNIQUE,
2324 LY_STMT_TYPEDEF, &grp->typedefs, 0,
Radek Krejci01180ac2021-01-27 08:48:22 +01002325 LY_STMT_USES, &grp->child, 0,
Michal Vasko69730152020-10-09 16:30:07 +02002326 LY_STMT_EXTENSION_INSTANCE, NULL, 0));
Radek Krejcif13b87b2020-12-01 22:02:17 +01002327 ret = yin_parse_content(ctx, subelems, subelems_size, LY_STMT_GROUPING, NULL, &grp->exts);
2328 subelems_deallocator(subelems_size, subelems);
David Sedlák81497a32019-08-13 16:56:26 +02002329
aPiecek63e080d2021-06-29 13:53:28 +02002330 /* store data for collision check */
2331 if (!ret && grp->parent) {
2332 assert(ctx->main_ctx);
2333 LY_CHECK_RET(ly_set_add(&ctx->main_ctx->grps_nodes, grp->parent, 0, NULL));
2334 }
2335
Radek Krejci2a9fc652021-01-22 17:44:34 +01002336 return ret;
David Sedláke3ce9ef2019-07-23 16:34:30 +02002337}
2338
2339/**
David Sedlákbf8a2b72019-08-14 16:48:10 +02002340 * @brief Parse container element.
David Sedlákf111bcb2019-07-23 17:15:51 +02002341 *
2342 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákad83cf92019-08-13 12:53:53 +02002343 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlákf111bcb2019-07-23 17:15:51 +02002344 *
2345 * @return LY_ERR values.
2346 */
2347static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002348yin_parse_container(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *node_meta)
David Sedlákf111bcb2019-07-23 17:15:51 +02002349{
David Sedlákf111bcb2019-07-23 17:15:51 +02002350 struct lysp_node_container *cont;
David Sedlák81497a32019-08-13 16:56:26 +02002351 LY_ERR ret = LY_SUCCESS;
2352 struct yin_subelement *subelems = NULL;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002353 size_t subelems_size;
David Sedlákf111bcb2019-07-23 17:15:51 +02002354
2355 /* create new container */
Michal Vaskob36053d2020-03-26 15:49:30 +01002356 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, cont, next, LY_EMEM);
David Sedlákf111bcb2019-07-23 17:15:51 +02002357 cont->nodetype = LYS_CONTAINER;
2358 cont->parent = node_meta->parent;
2359
David Sedlákf111bcb2019-07-23 17:15:51 +02002360 /* parse aegument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002361 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2362 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &cont->name, Y_IDENTIF_ARG, LY_STMT_CONTAINER));
David Sedlákf111bcb2019-07-23 17:15:51 +02002363
2364 /* parse container content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01002365 LY_CHECK_RET(subelems_allocator(ctx, subelems_size = 21, (struct lysp_node *)cont, &subelems,
Michal Vasko69730152020-10-09 16:30:07 +02002366 LY_STMT_ACTION, &cont->actions, YIN_SUBELEM_VER2,
2367 LY_STMT_ANYDATA, &cont->child, YIN_SUBELEM_VER2,
2368 LY_STMT_ANYXML, &cont->child, 0,
2369 LY_STMT_CHOICE, &cont->child, 0,
2370 LY_STMT_CONFIG, &cont->flags, YIN_SUBELEM_UNIQUE,
2371 LY_STMT_CONTAINER, &cont->child, 0,
2372 LY_STMT_DESCRIPTION, &cont->dsc, YIN_SUBELEM_UNIQUE,
2373 LY_STMT_GROUPING, &cont->groupings, 0,
2374 LY_STMT_IF_FEATURE, &cont->iffeatures, 0,
2375 LY_STMT_LEAF, &cont->child, 0,
2376 LY_STMT_LEAF_LIST, &cont->child, 0,
2377 LY_STMT_LIST, &cont->child, 0,
2378 LY_STMT_MUST, &cont->musts, 0,
2379 LY_STMT_NOTIFICATION, &cont->notifs, YIN_SUBELEM_VER2,
2380 LY_STMT_PRESENCE, &cont->presence, YIN_SUBELEM_UNIQUE,
2381 LY_STMT_REFERENCE, &cont->ref, YIN_SUBELEM_UNIQUE,
2382 LY_STMT_STATUS, &cont->flags, YIN_SUBELEM_UNIQUE,
2383 LY_STMT_TYPEDEF, &cont->typedefs, 0,
2384 LY_STMT_USES, &cont->child, 0,
2385 LY_STMT_WHEN, &cont->when, YIN_SUBELEM_UNIQUE,
2386 LY_STMT_EXTENSION_INSTANCE, NULL, 0));
Radek Krejcif13b87b2020-12-01 22:02:17 +01002387 ret = yin_parse_content(ctx, subelems, subelems_size, LY_STMT_CONTAINER, NULL, &cont->exts);
2388 subelems_deallocator(subelems_size, subelems);
David Sedlák81497a32019-08-13 16:56:26 +02002389
Radek Krejci2a9fc652021-01-22 17:44:34 +01002390 return ret;
David Sedlákf111bcb2019-07-23 17:15:51 +02002391}
2392
2393/**
David Sedlák5379d392019-07-24 10:42:03 +02002394 * @brief Parse case element.
2395 *
2396 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákad83cf92019-08-13 12:53:53 +02002397 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlák5379d392019-07-24 10:42:03 +02002398 *
2399 * @return LY_ERR values.
2400 */
2401static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002402yin_parse_case(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *node_meta)
David Sedlák5379d392019-07-24 10:42:03 +02002403{
David Sedlák5379d392019-07-24 10:42:03 +02002404 struct lysp_node_case *cas;
David Sedlák81497a32019-08-13 16:56:26 +02002405 LY_ERR ret = LY_SUCCESS;
Michal Vasko69730152020-10-09 16:30:07 +02002406 struct yin_subelement *subelems = NULL;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002407 size_t subelems_size;
David Sedlák5379d392019-07-24 10:42:03 +02002408
2409 /* create new case */
Michal Vaskob36053d2020-03-26 15:49:30 +01002410 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, cas, next, LY_EMEM);
David Sedlák5379d392019-07-24 10:42:03 +02002411 cas->nodetype = LYS_CASE;
2412 cas->parent = node_meta->parent;
2413
David Sedlák5379d392019-07-24 10:42:03 +02002414 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002415 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2416 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &cas->name, Y_IDENTIF_ARG, LY_STMT_CASE));
David Sedlák5379d392019-07-24 10:42:03 +02002417
2418 /* parse case content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01002419 LY_CHECK_RET(subelems_allocator(ctx, subelems_size = 14, (struct lysp_node *)cas, &subelems,
Michal Vasko69730152020-10-09 16:30:07 +02002420 LY_STMT_ANYDATA, &cas->child, YIN_SUBELEM_VER2,
2421 LY_STMT_ANYXML, &cas->child, 0,
2422 LY_STMT_CHOICE, &cas->child, 0,
2423 LY_STMT_CONTAINER, &cas->child, 0,
2424 LY_STMT_DESCRIPTION, &cas->dsc, YIN_SUBELEM_UNIQUE,
2425 LY_STMT_IF_FEATURE, &cas->iffeatures, 0,
2426 LY_STMT_LEAF, &cas->child, 0,
2427 LY_STMT_LEAF_LIST, &cas->child, 0,
2428 LY_STMT_LIST, &cas->child, 0,
2429 LY_STMT_REFERENCE, &cas->ref, YIN_SUBELEM_UNIQUE,
2430 LY_STMT_STATUS, &cas->flags, YIN_SUBELEM_UNIQUE,
2431 LY_STMT_USES, &cas->child, 0,
2432 LY_STMT_WHEN, &cas->when, YIN_SUBELEM_UNIQUE,
2433 LY_STMT_EXTENSION_INSTANCE, NULL, 0));
Radek Krejcif13b87b2020-12-01 22:02:17 +01002434 ret = yin_parse_content(ctx, subelems, subelems_size, LY_STMT_CASE, NULL, &cas->exts);
2435 subelems_deallocator(subelems_size, subelems);
David Sedlák81497a32019-08-13 16:56:26 +02002436
2437 return ret;
David Sedlák5379d392019-07-24 10:42:03 +02002438}
2439
2440/**
David Sedlák05404f62019-07-24 14:11:53 +02002441 * @brief Parse choice element.
David Sedlákb7abcfa2019-07-24 12:33:35 +02002442 *
2443 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákad83cf92019-08-13 12:53:53 +02002444 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlákb7abcfa2019-07-24 12:33:35 +02002445 *
2446 * @return LY_ERR values.
2447 */
2448LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002449yin_parse_choice(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *node_meta)
David Sedlákb7abcfa2019-07-24 12:33:35 +02002450{
David Sedlák81497a32019-08-13 16:56:26 +02002451 LY_ERR ret = LY_SUCCESS;
2452 struct yin_subelement *subelems = NULL;
David Sedlákb7abcfa2019-07-24 12:33:35 +02002453 struct lysp_node_choice *choice;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002454 size_t subelems_size;
David Sedlákb7abcfa2019-07-24 12:33:35 +02002455
2456 /* create new choice */
Michal Vaskob36053d2020-03-26 15:49:30 +01002457 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, choice, next, LY_EMEM);
David Sedlák8d552d62019-08-06 15:29:05 +02002458
David Sedlákb7abcfa2019-07-24 12:33:35 +02002459 choice->nodetype = LYS_CHOICE;
2460 choice->parent = node_meta->parent;
2461
David Sedlákb7abcfa2019-07-24 12:33:35 +02002462 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002463 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2464 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &choice->name, Y_IDENTIF_ARG, LY_STMT_CHOICE));
David Sedlákb7abcfa2019-07-24 12:33:35 +02002465
2466 /* parse choice content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01002467 LY_CHECK_RET(subelems_allocator(ctx, subelems_size = 17, (struct lysp_node *)choice, &subelems,
Michal Vasko69730152020-10-09 16:30:07 +02002468 LY_STMT_ANYDATA, &choice->child, YIN_SUBELEM_VER2,
2469 LY_STMT_ANYXML, &choice->child, 0,
2470 LY_STMT_CASE, &choice->child, 0,
2471 LY_STMT_CHOICE, &choice->child, YIN_SUBELEM_VER2,
2472 LY_STMT_CONFIG, &choice->flags, YIN_SUBELEM_UNIQUE,
2473 LY_STMT_CONTAINER, &choice->child, 0,
2474 LY_STMT_DEFAULT, &choice->dflt, YIN_SUBELEM_UNIQUE,
2475 LY_STMT_DESCRIPTION, &choice->dsc, YIN_SUBELEM_UNIQUE,
2476 LY_STMT_IF_FEATURE, &choice->iffeatures, 0,
2477 LY_STMT_LEAF, &choice->child, 0,
2478 LY_STMT_LEAF_LIST, &choice->child, 0,
2479 LY_STMT_LIST, &choice->child, 0,
2480 LY_STMT_MANDATORY, &choice->flags, YIN_SUBELEM_UNIQUE,
2481 LY_STMT_REFERENCE, &choice->ref, YIN_SUBELEM_UNIQUE,
2482 LY_STMT_STATUS, &choice->flags, YIN_SUBELEM_UNIQUE,
2483 LY_STMT_WHEN, &choice->when, YIN_SUBELEM_UNIQUE,
2484 LY_STMT_EXTENSION_INSTANCE, NULL, 0));
Radek Krejcif13b87b2020-12-01 22:02:17 +01002485 ret = yin_parse_content(ctx, subelems, subelems_size, LY_STMT_CHOICE, NULL, &choice->exts);
2486 subelems_deallocator(subelems_size, subelems);
David Sedlák81497a32019-08-13 16:56:26 +02002487 return ret;
David Sedlákb7abcfa2019-07-24 12:33:35 +02002488}
2489
2490/**
David Sedlák05404f62019-07-24 14:11:53 +02002491 * @brief Parse input or output element.
2492 *
2493 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbf8a2b72019-08-14 16:48:10 +02002494 * @param[in] inout_kw Identification of input/output element.
David Sedlák05404f62019-07-24 14:11:53 +02002495 * @param[in] inout_meta Meta information about parent node and siblings and input/output pointer to write to.
2496 *
2497 * @return LY_ERR values.
2498 */
2499static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002500yin_parse_inout(struct lys_yin_parser_ctx *ctx, enum ly_stmt inout_kw, struct inout_meta *inout_meta)
David Sedlák05404f62019-07-24 14:11:53 +02002501{
David Sedlák81497a32019-08-13 16:56:26 +02002502 LY_ERR ret = LY_SUCCESS;
2503 struct yin_subelement *subelems = NULL;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002504 size_t subelems_size;
David Sedlák81497a32019-08-13 16:56:26 +02002505
David Sedlák05404f62019-07-24 14:11:53 +02002506 /* initiate structure */
Radek Krejci2a9fc652021-01-22 17:44:34 +01002507 LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), (inout_kw == LY_STMT_INPUT) ? "input" : "output", 0, &inout_meta->inout_p->name));
Radek Krejcid6b76452019-09-03 17:03:03 +02002508 inout_meta->inout_p->nodetype = (inout_kw == LY_STMT_INPUT) ? LYS_INPUT : LYS_OUTPUT;
David Sedlák05404f62019-07-24 14:11:53 +02002509 inout_meta->inout_p->parent = inout_meta->parent;
2510
2511 /* check attributes */
Michal Vaskob36053d2020-03-26 15:49:30 +01002512 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2513 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NONE, NULL, Y_MAYBE_STR_ARG, inout_kw));
David Sedlák05404f62019-07-24 14:11:53 +02002514
2515 /* parser input/output content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01002516 LY_CHECK_RET(subelems_allocator(ctx, subelems_size = 12, (struct lysp_node *)inout_meta->inout_p, &subelems,
Radek Krejci01180ac2021-01-27 08:48:22 +01002517 LY_STMT_ANYDATA, &inout_meta->inout_p->child, YIN_SUBELEM_VER2,
2518 LY_STMT_ANYXML, &inout_meta->inout_p->child, 0,
2519 LY_STMT_CHOICE, &inout_meta->inout_p->child, 0,
2520 LY_STMT_CONTAINER, &inout_meta->inout_p->child, 0,
Michal Vasko69730152020-10-09 16:30:07 +02002521 LY_STMT_GROUPING, &inout_meta->inout_p->groupings, 0,
Radek Krejci01180ac2021-01-27 08:48:22 +01002522 LY_STMT_LEAF, &inout_meta->inout_p->child, 0,
2523 LY_STMT_LEAF_LIST, &inout_meta->inout_p->child, 0,
2524 LY_STMT_LIST, &inout_meta->inout_p->child, 0,
Michal Vasko69730152020-10-09 16:30:07 +02002525 LY_STMT_MUST, &inout_meta->inout_p->musts, YIN_SUBELEM_VER2,
2526 LY_STMT_TYPEDEF, &inout_meta->inout_p->typedefs, 0,
Radek Krejci01180ac2021-01-27 08:48:22 +01002527 LY_STMT_USES, &inout_meta->inout_p->child, 0,
Michal Vasko69730152020-10-09 16:30:07 +02002528 LY_STMT_EXTENSION_INSTANCE, NULL, 0));
Radek Krejcif13b87b2020-12-01 22:02:17 +01002529 ret = yin_parse_content(ctx, subelems, subelems_size, inout_kw, NULL, &inout_meta->inout_p->exts);
2530 subelems_deallocator(subelems_size, subelems);
David Sedlák81497a32019-08-13 16:56:26 +02002531 LY_CHECK_RET(ret);
David Sedlák05404f62019-07-24 14:11:53 +02002532
Radek Krejci01180ac2021-01-27 08:48:22 +01002533 if (!inout_meta->inout_p->child) {
Michal Vaskob83af8a2020-01-06 09:49:22 +01002534 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_MISSTMT, "data-def-stmt", ly_stmt2str(inout_kw));
2535 return LY_EVALID;
2536 }
2537
David Sedlák05404f62019-07-24 14:11:53 +02002538 return LY_SUCCESS;
2539}
2540
David Sedlák992fb7c2019-07-24 16:51:01 +02002541/**
2542 * @brief Parse action element.
2543 *
2544 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák992fb7c2019-07-24 16:51:01 +02002545 * @param[in] act_meta Meta information about parent node and actions to add to.
2546 *
2547 * @return LY_ERR values.
2548 */
David Sedlák85d0eca2019-07-24 15:15:21 +02002549static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002550yin_parse_action(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *act_meta)
David Sedlák85d0eca2019-07-24 15:15:21 +02002551{
Radek Krejci2a9fc652021-01-22 17:44:34 +01002552 struct lysp_node_action *act, **acts = (struct lysp_node_action **)act_meta->nodes;
David Sedlák81497a32019-08-13 16:56:26 +02002553 LY_ERR ret = LY_SUCCESS;
2554 struct yin_subelement *subelems = NULL;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002555 size_t subelems_size;
Radek Krejci39b7fc22021-02-26 23:29:18 +01002556 enum ly_stmt kw = act_meta->parent ? LY_STMT_ACTION : LY_STMT_RPC;
David Sedlák85d0eca2019-07-24 15:15:21 +02002557
2558 /* create new action */
Radek Krejci2a9fc652021-01-22 17:44:34 +01002559 LY_LIST_NEW_RET(ctx->xmlctx->ctx, acts, act, next, LY_EMEM);
Michal Vasko1bf09392020-03-27 12:38:10 +01002560 act->nodetype = act_meta->parent ? LYS_ACTION : LYS_RPC;
David Sedlák85d0eca2019-07-24 15:15:21 +02002561 act->parent = act_meta->parent;
2562
2563 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002564 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
Radek Krejci39b7fc22021-02-26 23:29:18 +01002565 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &act->name, Y_IDENTIF_ARG, kw));
David Sedlák85d0eca2019-07-24 15:15:21 +02002566
2567 /* parse content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01002568 LY_CHECK_RET(subelems_allocator(ctx, subelems_size = 9, (struct lysp_node *)act, &subelems,
Michal Vasko69730152020-10-09 16:30:07 +02002569 LY_STMT_DESCRIPTION, &act->dsc, YIN_SUBELEM_UNIQUE,
2570 LY_STMT_GROUPING, &act->groupings, 0,
2571 LY_STMT_IF_FEATURE, &act->iffeatures, 0,
2572 LY_STMT_INPUT, &act->input, YIN_SUBELEM_UNIQUE,
2573 LY_STMT_OUTPUT, &act->output, YIN_SUBELEM_UNIQUE,
2574 LY_STMT_REFERENCE, &act->ref, YIN_SUBELEM_UNIQUE,
2575 LY_STMT_STATUS, &act->flags, YIN_SUBELEM_UNIQUE,
2576 LY_STMT_TYPEDEF, &act->typedefs, 0,
2577 LY_STMT_EXTENSION_INSTANCE, NULL, 0));
Radek Krejci39b7fc22021-02-26 23:29:18 +01002578 ret = (yin_parse_content(ctx, subelems, subelems_size, kw, NULL, &act->exts));
Radek Krejcif13b87b2020-12-01 22:02:17 +01002579 subelems_deallocator(subelems_size, subelems);
David Sedlák81497a32019-08-13 16:56:26 +02002580 LY_CHECK_RET(ret);
2581
Michal Vasko7f45cf22020-10-01 12:49:44 +02002582 /* always initialize inout, they are technically present (needed for later deviations/refines) */
2583 if (!act->input.nodetype) {
2584 act->input.nodetype = LYS_INPUT;
2585 act->input.parent = (struct lysp_node *)act;
Radek Krejci2a9fc652021-01-22 17:44:34 +01002586 LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), "input", 0, &act->input.name));
Michal Vasko7f45cf22020-10-01 12:49:44 +02002587 }
2588 if (!act->output.nodetype) {
2589 act->output.nodetype = LYS_OUTPUT;
2590 act->output.parent = (struct lysp_node *)act;
Radek Krejci2a9fc652021-01-22 17:44:34 +01002591 LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), "output", 0, &act->output.name));
Michal Vasko7f45cf22020-10-01 12:49:44 +02002592 }
2593
David Sedlák85d0eca2019-07-24 15:15:21 +02002594 return LY_SUCCESS;
2595}
2596
David Sedlák05404f62019-07-24 14:11:53 +02002597/**
David Sedlák992fb7c2019-07-24 16:51:01 +02002598 * @brief Parse augment element.
2599 *
2600 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák992fb7c2019-07-24 16:51:01 +02002601 * @param[in] aug_meta Meta information about parent node and augments to add to.
2602 *
2603 * @return LY_ERR values.
2604 */
2605static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002606yin_parse_augment(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *aug_meta)
David Sedlák992fb7c2019-07-24 16:51:01 +02002607{
Radek Krejci2a9fc652021-01-22 17:44:34 +01002608 struct lysp_node_augment *aug;
2609 struct lysp_node_augment **augs = (struct lysp_node_augment **)aug_meta->nodes;
David Sedlák81497a32019-08-13 16:56:26 +02002610 LY_ERR ret = LY_SUCCESS;
2611 struct yin_subelement *subelems = NULL;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002612 size_t subelems_size;
David Sedlák992fb7c2019-07-24 16:51:01 +02002613
2614 /* create new augment */
Radek Krejci2a9fc652021-01-22 17:44:34 +01002615 LY_LIST_NEW_RET(ctx->xmlctx->ctx, augs, aug, next, LY_EMEM);
David Sedlák992fb7c2019-07-24 16:51:01 +02002616 aug->nodetype = LYS_AUGMENT;
2617 aug->parent = aug_meta->parent;
2618
2619 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002620 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2621 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_TARGET_NODE, &aug->nodeid, Y_STR_ARG, LY_STMT_AUGMENT));
2622 CHECK_NONEMPTY((struct lys_parser_ctx *)ctx, strlen(aug->nodeid), "augment");
David Sedlák992fb7c2019-07-24 16:51:01 +02002623
2624 /* parser augment content */
Radek Krejcif13b87b2020-12-01 22:02:17 +01002625 LY_CHECK_RET(subelems_allocator(ctx, subelems_size = 17, (struct lysp_node *)aug, &subelems,
Michal Vasko69730152020-10-09 16:30:07 +02002626 LY_STMT_ACTION, &aug->actions, YIN_SUBELEM_VER2,
2627 LY_STMT_ANYDATA, &aug->child, YIN_SUBELEM_VER2,
2628 LY_STMT_ANYXML, &aug->child, 0,
2629 LY_STMT_CASE, &aug->child, 0,
2630 LY_STMT_CHOICE, &aug->child, 0,
2631 LY_STMT_CONTAINER, &aug->child, 0,
2632 LY_STMT_DESCRIPTION, &aug->dsc, YIN_SUBELEM_UNIQUE,
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002633 LY_STMT_IF_FEATURE, &aug->iffeatures, 0,
Michal Vasko69730152020-10-09 16:30:07 +02002634 LY_STMT_LEAF, &aug->child, 0,
2635 LY_STMT_LEAF_LIST, &aug->child, 0,
2636 LY_STMT_LIST, &aug->child, 0,
2637 LY_STMT_NOTIFICATION, &aug->notifs, YIN_SUBELEM_VER2,
2638 LY_STMT_REFERENCE, &aug->ref, YIN_SUBELEM_UNIQUE,
2639 LY_STMT_STATUS, &aug->flags, YIN_SUBELEM_UNIQUE,
2640 LY_STMT_USES, &aug->child, 0,
2641 LY_STMT_WHEN, &aug->when, YIN_SUBELEM_UNIQUE,
2642 LY_STMT_EXTENSION_INSTANCE, NULL, 0));
Radek Krejcif13b87b2020-12-01 22:02:17 +01002643 ret = yin_parse_content(ctx, subelems, subelems_size, LY_STMT_AUGMENT, NULL, &aug->exts);
2644 subelems_deallocator(subelems_size, subelems);
David Sedlák992fb7c2019-07-24 16:51:01 +02002645
Radek Krejci2a9fc652021-01-22 17:44:34 +01002646 return ret;
David Sedlák992fb7c2019-07-24 16:51:01 +02002647}
2648
David Sedlák8b754462019-07-25 16:22:13 +02002649/**
2650 * @brief Parse deviate element.
2651 *
2652 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák8b754462019-07-25 16:22:13 +02002653 * @param[in] deviates Deviates to add to.
2654 *
2655 * @return LY_ERR values.
2656 */
David Sedlák4ffcec82019-07-25 15:10:21 +02002657static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002658yin_parse_deviate(struct lys_yin_parser_ctx *ctx, struct lysp_deviate **deviates)
David Sedlák4ffcec82019-07-25 15:10:21 +02002659{
2660 LY_ERR ret = LY_SUCCESS;
2661 uint8_t dev_mod;
2662 const char *temp_val;
David Sedlák8d552d62019-08-06 15:29:05 +02002663 struct lysp_deviate *d;
David Sedlák4ffcec82019-07-25 15:10:21 +02002664 struct lysp_deviate_add *d_add = NULL;
2665 struct lysp_deviate_rpl *d_rpl = NULL;
2666 struct lysp_deviate_del *d_del = NULL;
2667
2668 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002669 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2670 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &temp_val, Y_STR_ARG, LY_STMT_DEVIATE));
David Sedlák4ffcec82019-07-25 15:10:21 +02002671
2672 if (strcmp(temp_val, "not-supported") == 0) {
2673 dev_mod = LYS_DEV_NOT_SUPPORTED;
2674 } else if (strcmp(temp_val, "add") == 0) {
2675 dev_mod = LYS_DEV_ADD;
2676 } else if (strcmp(temp_val, "replace") == 0) {
2677 dev_mod = LYS_DEV_REPLACE;
2678 } else if (strcmp(temp_val, "delete") == 0) {
2679 dev_mod = LYS_DEV_DELETE;
2680 } else {
David Sedlák26ea1432019-08-14 13:42:23 +02002681 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS4, temp_val, "value", "deviate",
Michal Vasko69730152020-10-09 16:30:07 +02002682 "not-supported", "add", "replace", "delete");
Michal Vaskoe180ed02021-02-05 16:31:20 +01002683 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlák4ffcec82019-07-25 15:10:21 +02002684 return LY_EVALID;
2685 }
Michal Vaskoe180ed02021-02-05 16:31:20 +01002686 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlák4ffcec82019-07-25 15:10:21 +02002687
2688 if (dev_mod == LYS_DEV_NOT_SUPPORTED) {
2689 d = calloc(1, sizeof *d);
Michal Vaskob36053d2020-03-26 15:49:30 +01002690 LY_CHECK_ERR_RET(!d, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
Radek Krejcif13b87b2020-12-01 22:02:17 +01002691 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02002692 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
2693 };
Radek Krejcif13b87b2020-12-01 22:02:17 +01002694 ret = yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_DEVIATE, NULL, &d->exts);
David Sedlák4ffcec82019-07-25 15:10:21 +02002695
2696 } else if (dev_mod == LYS_DEV_ADD) {
2697 d_add = calloc(1, sizeof *d_add);
Michal Vaskob36053d2020-03-26 15:49:30 +01002698 LY_CHECK_ERR_RET(!d_add, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
David Sedlák4ffcec82019-07-25 15:10:21 +02002699 d = (struct lysp_deviate *)d_add;
2700 struct minmax_dev_meta min = {&d_add->min, &d_add->flags, &d_add->exts};
2701 struct minmax_dev_meta max = {&d_add->max, &d_add->flags, &d_add->exts};
Radek Krejcif13b87b2020-12-01 22:02:17 +01002702 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02002703 {LY_STMT_CONFIG, &d_add->flags, YIN_SUBELEM_UNIQUE},
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002704 {LY_STMT_DEFAULT, &d_add->dflts, 0},
Radek Krejci0f969882020-08-21 16:56:47 +02002705 {LY_STMT_MANDATORY, &d_add->flags, YIN_SUBELEM_UNIQUE},
2706 {LY_STMT_MAX_ELEMENTS, &max, YIN_SUBELEM_UNIQUE},
2707 {LY_STMT_MIN_ELEMENTS, &min, YIN_SUBELEM_UNIQUE},
2708 {LY_STMT_MUST, &d_add->musts, 0},
2709 {LY_STMT_UNIQUE, &d_add->uniques, 0},
2710 {LY_STMT_UNITS, &d_add->units, YIN_SUBELEM_UNIQUE},
2711 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
2712 };
Radek Krejcif13b87b2020-12-01 22:02:17 +01002713 ret = yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_DEVIATE, NULL, &d_add->exts);
David Sedlák4ffcec82019-07-25 15:10:21 +02002714
2715 } else if (dev_mod == LYS_DEV_REPLACE) {
2716 d_rpl = calloc(1, sizeof *d_rpl);
Michal Vaskob36053d2020-03-26 15:49:30 +01002717 LY_CHECK_ERR_RET(!d_rpl, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
David Sedlák4ffcec82019-07-25 15:10:21 +02002718 d = (struct lysp_deviate *)d_rpl;
2719 struct minmax_dev_meta min = {&d_rpl->min, &d_rpl->flags, &d_rpl->exts};
2720 struct minmax_dev_meta max = {&d_rpl->max, &d_rpl->flags, &d_rpl->exts};
Radek Krejcif13b87b2020-12-01 22:02:17 +01002721 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02002722 {LY_STMT_CONFIG, &d_rpl->flags, YIN_SUBELEM_UNIQUE},
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002723 {LY_STMT_DEFAULT, &d_rpl->dflt, YIN_SUBELEM_UNIQUE},
Radek Krejci0f969882020-08-21 16:56:47 +02002724 {LY_STMT_MANDATORY, &d_rpl->flags, YIN_SUBELEM_UNIQUE},
2725 {LY_STMT_MAX_ELEMENTS, &max, YIN_SUBELEM_UNIQUE},
2726 {LY_STMT_MIN_ELEMENTS, &min, YIN_SUBELEM_UNIQUE},
2727 {LY_STMT_TYPE, &d_rpl->type, YIN_SUBELEM_UNIQUE},
2728 {LY_STMT_UNITS, &d_rpl->units, YIN_SUBELEM_UNIQUE},
2729 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
2730 };
Radek Krejcif13b87b2020-12-01 22:02:17 +01002731 ret = yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_DEVIATE, NULL, &d_rpl->exts);
David Sedlák4ffcec82019-07-25 15:10:21 +02002732
2733 } else {
2734 d_del = calloc(1, sizeof *d_del);
Michal Vaskob36053d2020-03-26 15:49:30 +01002735 LY_CHECK_ERR_RET(!d_del, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
David Sedlák4ffcec82019-07-25 15:10:21 +02002736 d = (struct lysp_deviate *)d_del;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002737 struct yin_subelement subelems[] = {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002738 {LY_STMT_DEFAULT, &d_del->dflts, 0},
Radek Krejci0f969882020-08-21 16:56:47 +02002739 {LY_STMT_MUST, &d_del->musts, 0},
2740 {LY_STMT_UNIQUE, &d_del->uniques, 0},
2741 {LY_STMT_UNITS, &d_del->units, YIN_SUBELEM_UNIQUE},
2742 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
2743 };
Radek Krejcif13b87b2020-12-01 22:02:17 +01002744 ret = yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_DEVIATE, NULL, &d_del->exts);
David Sedlák4ffcec82019-07-25 15:10:21 +02002745 }
2746 LY_CHECK_GOTO(ret, cleanup);
2747
2748 d->mod = dev_mod;
2749 /* insert into siblings */
David Sedlák8d552d62019-08-06 15:29:05 +02002750 LY_LIST_INSERT(deviates, d, next);
David Sedlák4ffcec82019-07-25 15:10:21 +02002751
2752 return ret;
2753
2754cleanup:
2755 free(d);
David Sedlák4ffcec82019-07-25 15:10:21 +02002756 return ret;
2757}
2758
David Sedlák992fb7c2019-07-24 16:51:01 +02002759/**
David Sedlák8b754462019-07-25 16:22:13 +02002760 * @brief Parse deviation element.
2761 *
2762 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák8b754462019-07-25 16:22:13 +02002763 * @param[in] deviations Deviations to add to.
2764 *
2765 * @return LY_ERR values.
2766 */
2767static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002768yin_parse_deviation(struct lys_yin_parser_ctx *ctx, struct lysp_deviation **deviations)
David Sedlák8b754462019-07-25 16:22:13 +02002769{
2770 struct lysp_deviation *dev;
2771
2772 /* create new deviation */
Michal Vaskob36053d2020-03-26 15:49:30 +01002773 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *deviations, dev, LY_EMEM);
David Sedlák8b754462019-07-25 16:22:13 +02002774
2775 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002776 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2777 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_TARGET_NODE, &dev->nodeid, Y_STR_ARG, LY_STMT_DEVIATION));
2778 CHECK_NONEMPTY((struct lys_parser_ctx *)ctx, strlen(dev->nodeid), "deviation");
Radek Krejcif13b87b2020-12-01 22:02:17 +01002779 struct yin_subelement subelems[] = {
Radek Krejci0f969882020-08-21 16:56:47 +02002780 {LY_STMT_DESCRIPTION, &dev->dsc, YIN_SUBELEM_UNIQUE},
2781 {LY_STMT_DEVIATE, &dev->deviates, YIN_SUBELEM_MANDATORY},
2782 {LY_STMT_REFERENCE, &dev->ref, YIN_SUBELEM_UNIQUE},
2783 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
2784 };
Michal Vasko69730152020-10-09 16:30:07 +02002785
Radek Krejcif13b87b2020-12-01 22:02:17 +01002786 return yin_parse_content(ctx, subelems, ly_sizeofarray(subelems), LY_STMT_DEVIATION, NULL, &dev->exts);
David Sedlák8b754462019-07-25 16:22:13 +02002787}
2788
2789/**
David Sedlákc5b20842019-08-13 10:18:31 +02002790 * @brief map keyword to keyword-group.
2791 *
2792 * @param[in] ctx YIN parser context used for logging.
2793 * @param[in] kw Keyword that is child of module or submodule.
2794 * @param[out] group Group of keyword.
2795 *
2796 * @return LY_SUCCESS on success LY_EINT if kw can't be mapped to kw_group, should not happen if called correctly.
2797 */
David Sedláke6cd89e2019-08-07 12:46:02 +02002798static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002799kw2kw_group(struct lys_yin_parser_ctx *ctx, enum ly_stmt kw, enum yang_module_stmt *group)
David Sedláke6cd89e2019-08-07 12:46:02 +02002800{
2801 switch (kw) {
Radek Krejci0f969882020-08-21 16:56:47 +02002802 /* module header */
2803 case LY_STMT_NONE:
2804 case LY_STMT_NAMESPACE:
2805 case LY_STMT_PREFIX:
2806 case LY_STMT_BELONGS_TO:
2807 case LY_STMT_YANG_VERSION:
2808 *group = Y_MOD_MODULE_HEADER;
2809 break;
2810 /* linkage */
2811 case LY_STMT_INCLUDE:
2812 case LY_STMT_IMPORT:
2813 *group = Y_MOD_LINKAGE;
2814 break;
2815 /* meta */
2816 case LY_STMT_ORGANIZATION:
2817 case LY_STMT_CONTACT:
2818 case LY_STMT_DESCRIPTION:
2819 case LY_STMT_REFERENCE:
2820 *group = Y_MOD_META;
2821 break;
2822 /* revision */
2823 case LY_STMT_REVISION:
2824 *group = Y_MOD_REVISION;
2825 break;
2826 /* body */
2827 case LY_STMT_ANYDATA:
2828 case LY_STMT_ANYXML:
2829 case LY_STMT_AUGMENT:
2830 case LY_STMT_CHOICE:
2831 case LY_STMT_CONTAINER:
2832 case LY_STMT_DEVIATION:
2833 case LY_STMT_EXTENSION:
2834 case LY_STMT_FEATURE:
2835 case LY_STMT_GROUPING:
2836 case LY_STMT_IDENTITY:
2837 case LY_STMT_LEAF:
2838 case LY_STMT_LEAF_LIST:
2839 case LY_STMT_LIST:
2840 case LY_STMT_NOTIFICATION:
2841 case LY_STMT_RPC:
2842 case LY_STMT_TYPEDEF:
2843 case LY_STMT_USES:
2844 case LY_STMT_EXTENSION_INSTANCE:
2845 *group = Y_MOD_BODY;
2846 break;
2847 default:
2848 LOGINT(ctx->xmlctx->ctx);
2849 return LY_EINT;
David Sedláke6cd89e2019-08-07 12:46:02 +02002850 }
2851
2852 return LY_SUCCESS;
2853}
2854
David Sedlákc5b20842019-08-13 10:18:31 +02002855/**
2856 * @brief Check if relative order of two keywords is valid.
2857 *
2858 * @param[in] ctx YIN parser context used for logging.
2859 * @param[in] kw Current keyword.
2860 * @param[in] next_kw Next keyword.
Radek Krejcid6b76452019-09-03 17:03:03 +02002861 * @param[in] parrent Identification of parrent element, can be se to to LY_STMT_MODULE of LY_STMT_SUBMODULE,
David Sedlákc5b20842019-08-13 10:18:31 +02002862 * because relative order is required only in module and submodule sub-elements, used for logging.
2863 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02002864 * @return LY_SUCCESS on success and LY_EVALID if relative order is invalid.
David Sedlákc5b20842019-08-13 10:18:31 +02002865 */
David Sedláke6cd89e2019-08-07 12:46:02 +02002866static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002867yin_check_relative_order(struct lys_yin_parser_ctx *ctx, enum ly_stmt kw, enum ly_stmt next_kw, enum ly_stmt parrent)
David Sedláke6cd89e2019-08-07 12:46:02 +02002868{
Radek Krejcid6b76452019-09-03 17:03:03 +02002869 assert(parrent == LY_STMT_MODULE || parrent == LY_STMT_SUBMODULE);
David Sedláke6cd89e2019-08-07 12:46:02 +02002870 enum yang_module_stmt gr, next_gr;
2871
2872 LY_CHECK_RET(kw2kw_group(ctx, kw, &gr));
2873 LY_CHECK_RET(kw2kw_group(ctx, next_kw, &next_gr));
2874
2875 if (gr > next_gr) {
2876 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INORDER_YIN, ly_stmt2str(parrent), ly_stmt2str(next_kw), ly_stmt2str(kw));
2877 return LY_EVALID;
2878 }
2879
2880 return LY_SUCCESS;
2881}
2882
David Sedlákc5dd0942019-09-13 10:23:59 +02002883/**
Michal Vaskoafac7822020-10-20 14:22:26 +02002884 * @brief Parse argument of extension subelement that is classic yang keyword and not another instance of extension.
2885 *
2886 * @param[in,out] ctx Yin parser context for logging and to store current state.
2887 * @param[in] elem_type Type of element that is currently being parsed.
2888 * @param[out] arg Value to write to.
2889 *
2890 * @return LY_ERR values.
2891 */
2892static LY_ERR
2893yin_parse_extension_instance_arg(struct lys_yin_parser_ctx *ctx, enum ly_stmt elem_type, const char **arg)
2894{
2895 enum ly_stmt child;
2896
2897 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2898
2899 switch (elem_type) {
2900 case LY_STMT_ACTION:
2901 case LY_STMT_ANYDATA:
2902 case LY_STMT_ANYXML:
2903 case LY_STMT_ARGUMENT:
2904 case LY_STMT_BASE:
2905 case LY_STMT_BIT:
2906 case LY_STMT_CASE:
2907 case LY_STMT_CHOICE:
2908 case LY_STMT_CONTAINER:
2909 case LY_STMT_ENUM:
2910 case LY_STMT_EXTENSION:
2911 case LY_STMT_FEATURE:
2912 case LY_STMT_GROUPING:
2913 case LY_STMT_IDENTITY:
2914 case LY_STMT_IF_FEATURE:
2915 case LY_STMT_LEAF:
2916 case LY_STMT_LEAF_LIST:
2917 case LY_STMT_LIST:
2918 case LY_STMT_MODULE:
2919 case LY_STMT_NOTIFICATION:
2920 case LY_STMT_RPC:
2921 case LY_STMT_SUBMODULE:
2922 case LY_STMT_TYPE:
2923 case LY_STMT_TYPEDEF:
2924 case LY_STMT_UNITS:
2925 case LY_STMT_USES:
2926 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, arg, Y_MAYBE_STR_ARG, elem_type));
2927 break;
2928 case LY_STMT_AUGMENT:
2929 case LY_STMT_DEVIATION:
2930 case LY_STMT_REFINE:
2931 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_TARGET_NODE, arg, Y_MAYBE_STR_ARG, elem_type));
2932 break;
2933 case LY_STMT_CONFIG:
2934 case LY_STMT_DEFAULT:
2935 case LY_STMT_DEVIATE:
2936 case LY_STMT_ERROR_APP_TAG:
2937 case LY_STMT_FRACTION_DIGITS:
2938 case LY_STMT_KEY:
2939 case LY_STMT_LENGTH:
2940 case LY_STMT_MANDATORY:
2941 case LY_STMT_MAX_ELEMENTS:
2942 case LY_STMT_MIN_ELEMENTS:
2943 case LY_STMT_MODIFIER:
2944 case LY_STMT_ORDERED_BY:
2945 case LY_STMT_PATH:
2946 case LY_STMT_PATTERN:
2947 case LY_STMT_POSITION:
2948 case LY_STMT_PREFIX:
2949 case LY_STMT_PRESENCE:
2950 case LY_STMT_RANGE:
2951 case LY_STMT_REQUIRE_INSTANCE:
2952 case LY_STMT_STATUS:
2953 case LY_STMT_VALUE:
2954 case LY_STMT_YANG_VERSION:
2955 case LY_STMT_YIN_ELEMENT:
2956 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, arg, Y_MAYBE_STR_ARG, elem_type));
2957 break;
2958 case LY_STMT_IMPORT:
2959 case LY_STMT_INCLUDE:
2960 case LY_STMT_BELONGS_TO:
2961 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_MODULE, arg, Y_MAYBE_STR_ARG, elem_type));
2962 break;
2963 case LY_STMT_INPUT:
2964 case LY_STMT_OUTPUT:
2965 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NONE, arg, Y_MAYBE_STR_ARG, elem_type));
2966 break;
2967 case LY_STMT_MUST:
2968 case LY_STMT_WHEN:
2969 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_CONDITION, arg, Y_MAYBE_STR_ARG, elem_type));
2970 break;
2971 case LY_STMT_NAMESPACE:
2972 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_URI, arg, Y_MAYBE_STR_ARG, elem_type));
2973 break;
2974 case LY_STMT_REVISION:
2975 case LY_STMT_REVISION_DATE:
2976 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_DATE, arg, Y_MAYBE_STR_ARG, elem_type));
2977 break;
2978 case LY_STMT_UNIQUE:
2979 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_TAG, arg, Y_MAYBE_STR_ARG, elem_type));
2980 break;
2981 /* argument is mapped to yin element */
2982 case LY_STMT_CONTACT:
2983 case LY_STMT_DESCRIPTION:
2984 case LY_STMT_ORGANIZATION:
2985 case LY_STMT_REFERENCE:
2986 case LY_STMT_ERROR_MESSAGE:
2987 /* there shouldn't be any attribute, argument is supposed to be first subelement */
2988 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NONE, arg, Y_MAYBE_STR_ARG, elem_type));
2989
2990 /* no content */
2991 assert(ctx->xmlctx->status == LYXML_ELEM_CONTENT);
2992 if (ctx->xmlctx->ws_only) {
2993 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2994 }
2995 if (((ctx->xmlctx->status == LYXML_ELEM_CONTENT) && !ctx->xmlctx->ws_only) || (ctx->xmlctx->status != LYXML_ELEMENT)) {
2996 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_FIRT_SUBELEM,
2997 elem_type == LY_STMT_ERROR_MESSAGE ? "value" : "text", ly_stmt2str(elem_type));
2998 return LY_EVALID;
2999 }
3000
3001 /* parse child element */
3002 child = yin_match_keyword(ctx, ctx->xmlctx->name, ctx->xmlctx->name_len, ctx->xmlctx->prefix, ctx->xmlctx->prefix_len, elem_type);
3003 if (((elem_type == LY_STMT_ERROR_MESSAGE) && (child != LY_STMT_ARG_VALUE)) ||
3004 ((elem_type != LY_STMT_ERROR_MESSAGE) && (child != LY_STMT_ARG_TEXT))) {
3005 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_UNEXP_SUBELEM, ctx->xmlctx->name_len, ctx->xmlctx->name,
3006 ly_stmt2str(elem_type));
3007 return LY_EVALID;
3008 }
3009 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3010
3011 /* no attributes expected? TODO */
3012 while (ctx->xmlctx->status == LYXML_ATTRIBUTE) {
3013 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3014 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3015 }
3016
3017 /* load and save content */
3018 INSERT_STRING_RET(ctx->xmlctx->ctx, ctx->xmlctx->value, ctx->xmlctx->value_len, ctx->xmlctx->dynamic, *arg);
3019 LY_CHECK_RET(!*arg, LY_EMEM);
3020
3021 /* load closing tag of subelement */
3022 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3023
3024 /* if only subelement was parsed as argument, load also closing tag TODO what? */
3025 /*if (ctx->xmlctx->status == LYXML_ELEMENT) {
3026 LY_CHECK_RET(lyxml_get_element(&ctx->xmlctx, data, &prefix, &prefix_len, &name, &name_len));
3027 }*/
3028 break;
3029 default:
3030 LOGINT(ctx->xmlctx->ctx);
3031 return LY_EINT;
3032 }
3033
3034 return LY_SUCCESS;
3035}
3036
3037/**
3038 * @brief Parse yin element into generic structure.
3039 *
3040 * @param[in,out] ctx Yin parser context for XML context, logging, and to store current state.
3041 * @param[in] parent Identification of parent element.
3042 * @param[out] element Where the element structure should be stored.
3043 *
3044 * @return LY_ERR values.
3045 */
3046LY_ERR
3047yin_parse_element_generic(struct lys_yin_parser_ctx *ctx, enum ly_stmt parent, struct lysp_stmt **element)
3048{
3049 LY_ERR ret = LY_SUCCESS;
3050 struct lysp_stmt *last = NULL, *new = NULL;
Michal Vaskofc2cd072021-02-24 13:17:17 +01003051 char *id;
Michal Vaskoafac7822020-10-20 14:22:26 +02003052
3053 assert(ctx->xmlctx->status == LYXML_ELEMENT);
3054
3055 /* allocate new structure for element */
3056 *element = calloc(1, sizeof(**element));
3057 LY_CHECK_ERR_GOTO(!(*element), LOGMEM(ctx->xmlctx->ctx); ret = LY_EMEM, cleanup);
Michal Vaskofc2cd072021-02-24 13:17:17 +01003058
3059 /* store identifier */
3060 if (ctx->xmlctx->prefix_len) {
3061 if (asprintf(&id, "%.*s:%.*s", (int)ctx->xmlctx->prefix_len, ctx->xmlctx->prefix, (int)ctx->xmlctx->name_len,
3062 ctx->xmlctx->name) == -1) {
3063 LOGMEM(ctx->xmlctx->ctx);
3064 ret = LY_EMEM;
3065 goto cleanup;
3066 }
3067 LY_CHECK_GOTO(ret = lydict_insert_zc(ctx->xmlctx->ctx, id, &(*element)->stmt), cleanup);
3068
3069 /* store prefix data for the statement */
Radek Krejci8df109d2021-04-23 12:19:08 +02003070 LY_CHECK_GOTO(ret = ly_store_prefix_data(ctx->xmlctx->ctx, (*element)->stmt, strlen((*element)->stmt), LY_VALUE_XML,
Michal Vaskofc2cd072021-02-24 13:17:17 +01003071 &ctx->xmlctx->ns, &(*element)->format, &(*element)->prefix_data), cleanup);
3072 } else {
3073 LY_CHECK_GOTO(ret = lydict_insert(ctx->xmlctx->ctx, ctx->xmlctx->name, ctx->xmlctx->name_len, &(*element)->stmt), cleanup);
3074 }
Michal Vaskoafac7822020-10-20 14:22:26 +02003075
3076 (*element)->kw = yin_match_keyword(ctx, ctx->xmlctx->name, ctx->xmlctx->name_len, ctx->xmlctx->prefix,
3077 ctx->xmlctx->prefix_len, parent);
3078
3079 last = (*element)->child;
3080 if ((*element)->kw == LY_STMT_NONE) {
3081 /* unrecognized element */
3082 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_UNEXP_SUBELEM, ctx->xmlctx->name_len, ctx->xmlctx->name,
3083 ly_stmt2str(parent));
3084 ret = LY_EVALID;
3085 goto cleanup;
3086 } else if ((*element)->kw != LY_STMT_EXTENSION_INSTANCE) {
3087 /* element is known yang keyword, which means argument can be parsed correctly. */
3088 ret = yin_parse_extension_instance_arg(ctx, (*element)->kw, &(*element)->arg);
3089 LY_CHECK_GOTO(ret, cleanup);
3090 } else {
3091 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3092
3093 /* load attributes in generic way, save all attributes in linked list */
3094 while (ctx->xmlctx->status == LYXML_ATTRIBUTE) {
3095 new = calloc(1, sizeof(*last));
3096 LY_CHECK_ERR_GOTO(!new, LOGMEM(ctx->xmlctx->ctx); ret = LY_EMEM, cleanup);
3097 if (!(*element)->child) {
3098 /* save first */
3099 (*element)->child = new;
3100 } else {
3101 last->next = new;
3102 }
3103 last = new;
3104
3105 last->flags |= LYS_YIN_ATTR;
3106 LY_CHECK_GOTO(ret = lydict_insert(ctx->xmlctx->ctx, ctx->xmlctx->name, ctx->xmlctx->name_len, &last->stmt), cleanup);
3107 last->kw = LY_STMT_NONE;
3108 /* attributes with prefix are ignored */
3109 if (!ctx->xmlctx->prefix) {
3110 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3111
3112 INSERT_STRING_RET(ctx->xmlctx->ctx, ctx->xmlctx->value, ctx->xmlctx->value_len, ctx->xmlctx->dynamic, last->arg);
3113 LY_CHECK_ERR_GOTO(!last->arg, ret = LY_EMEM, cleanup);
3114 } else {
3115 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3116 }
3117 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3118 }
3119 }
3120
3121 if ((ctx->xmlctx->status != LYXML_ELEM_CONTENT) || ctx->xmlctx->ws_only) {
3122 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3123 while (ctx->xmlctx->status == LYXML_ELEMENT) {
3124 /* parse subelements */
3125 ret = yin_parse_element_generic(ctx, (*element)->kw, &new);
3126 LY_CHECK_GOTO(ret, cleanup);
3127 if (!(*element)->child) {
3128 /* save first */
3129 (*element)->child = new;
3130 } else {
3131 last->next = new;
3132 }
3133 last = new;
3134
3135 assert(ctx->xmlctx->status == LYXML_ELEM_CLOSE);
3136 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3137 }
3138 } else {
3139 /* save element content */
3140 if (ctx->xmlctx->value_len) {
3141 INSERT_STRING_RET(ctx->xmlctx->ctx, ctx->xmlctx->value, ctx->xmlctx->value_len, ctx->xmlctx->dynamic, (*element)->arg);
3142 LY_CHECK_ERR_GOTO(!(*element)->arg, ret = LY_EMEM, cleanup);
Michal Vaskofc2cd072021-02-24 13:17:17 +01003143
3144 /* store prefix data for the argument as well */
Radek Krejci8df109d2021-04-23 12:19:08 +02003145 LY_CHECK_GOTO(ret = ly_store_prefix_data(ctx->xmlctx->ctx, (*element)->arg, strlen((*element)->arg), LY_VALUE_XML,
Michal Vaskofc2cd072021-02-24 13:17:17 +01003146 &ctx->xmlctx->ns, &(*element)->format, &(*element)->prefix_data), cleanup);
Michal Vaskoafac7822020-10-20 14:22:26 +02003147 }
3148
3149 /* read closing tag */
3150 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3151 }
3152
3153cleanup:
3154 return ret;
3155}
3156
3157/**
3158 * @brief Parse instance of extension.
3159 *
3160 * @param[in,out] ctx Yin parser context for logging and to store current state.
Radek Krejcifc596f92021-02-26 22:40:26 +01003161 * @param[in] subelem The statement this extension instance is a subelement of.
Michal Vaskoafac7822020-10-20 14:22:26 +02003162 * @param[in] subelem_index Index of the keyword instance this extension instance is a subelement of
3163 * @param[in,out] exts Extension instance to add to.
3164 *
3165 * @return LY_ERR values.
3166 */
3167LY_ERR
Radek Krejcifc596f92021-02-26 22:40:26 +01003168yin_parse_extension_instance(struct lys_yin_parser_ctx *ctx, enum ly_stmt subelem, LY_ARRAY_COUNT_TYPE subelem_index,
Michal Vaskoafac7822020-10-20 14:22:26 +02003169 struct lysp_ext_instance **exts)
3170{
3171 struct lysp_ext_instance *e;
3172 struct lysp_stmt *last_subelem = NULL, *new_subelem = NULL;
Michal Vaskofc2cd072021-02-24 13:17:17 +01003173 char *ext_name;
Michal Vaskoafac7822020-10-20 14:22:26 +02003174
3175 assert(ctx->xmlctx->status == LYXML_ELEMENT);
Radek Krejci3aac9a72020-12-01 12:24:26 +01003176 assert(exts);
Michal Vaskoafac7822020-10-20 14:22:26 +02003177
3178 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *exts, e, LY_EMEM);
3179
Michal Vaskofc2cd072021-02-24 13:17:17 +01003180 if (!ctx->xmlctx->prefix_len) {
3181 LOGVAL_PARSER(ctx, LYVE_SYNTAX, "Extension instance \"%*.s\" without the mandatory prefix.",
3182 (int)ctx->xmlctx->name_len, ctx->xmlctx->name);
3183 return LY_EVALID;
3184 }
3185
3186 /* store prefixed name */
3187 if (asprintf(&ext_name, "%.*s:%.*s", (int)ctx->xmlctx->prefix_len, ctx->xmlctx->prefix, (int)ctx->xmlctx->name_len,
3188 ctx->xmlctx->name) == -1) {
3189 LOGMEM(ctx->xmlctx->ctx);
3190 return LY_EMEM;
3191 }
3192 LY_CHECK_RET(lydict_insert_zc(ctx->xmlctx->ctx, ext_name, &e->name));
3193
3194 /* store prefix data for the name */
Radek Krejci8df109d2021-04-23 12:19:08 +02003195 LY_CHECK_RET(ly_store_prefix_data(ctx->xmlctx->ctx, e->name, strlen(e->name), LY_VALUE_XML, &ctx->xmlctx->ns,
Michal Vaskofc2cd072021-02-24 13:17:17 +01003196 &e->format, &e->prefix_data));
3197
Radek Krejciab430862021-03-02 20:13:40 +01003198 e->parent_stmt = subelem;
3199 e->parent_stmt_index = subelem_index;
Michal Vaskofc2cd072021-02-24 13:17:17 +01003200
Michal Vaskoafac7822020-10-20 14:22:26 +02003201 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3202
3203 /* store attributes as subelements */
3204 while (ctx->xmlctx->status == LYXML_ATTRIBUTE) {
3205 if (!ctx->xmlctx->prefix) {
3206 new_subelem = calloc(1, sizeof(*new_subelem));
3207 if (!e->child) {
3208 e->child = new_subelem;
3209 } else {
3210 last_subelem->next = new_subelem;
3211 }
3212 last_subelem = new_subelem;
3213
3214 last_subelem->flags |= LYS_YIN_ATTR;
3215 LY_CHECK_RET(lydict_insert(ctx->xmlctx->ctx, ctx->xmlctx->name, ctx->xmlctx->name_len, &last_subelem->stmt));
3216 LY_CHECK_RET(!last_subelem->stmt, LY_EMEM);
3217 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3218
Michal Vaskofc2cd072021-02-24 13:17:17 +01003219 INSERT_STRING_RET(ctx->xmlctx->ctx, ctx->xmlctx->value, ctx->xmlctx->value_len, ctx->xmlctx->dynamic,
3220 last_subelem->arg);
Michal Vaskoafac7822020-10-20 14:22:26 +02003221 LY_CHECK_RET(!last_subelem->arg, LY_EMEM);
3222 } else {
3223 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3224 }
3225
3226 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3227 }
3228
3229 /* parse subelements */
3230 assert(ctx->xmlctx->status == LYXML_ELEM_CONTENT);
3231 if (ctx->xmlctx->ws_only) {
3232 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3233 while (ctx->xmlctx->status == LYXML_ELEMENT) {
3234 LY_CHECK_RET(yin_parse_element_generic(ctx, LY_STMT_EXTENSION_INSTANCE, &new_subelem));
3235 if (!e->child) {
3236 e->child = new_subelem;
3237 } else {
3238 last_subelem->next = new_subelem;
3239 }
3240 last_subelem = new_subelem;
3241
3242 assert(ctx->xmlctx->status == LYXML_ELEM_CLOSE);
3243 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3244 }
3245 } else if (ctx->xmlctx->value_len) {
3246 /* save text content */
3247 INSERT_STRING_RET(ctx->xmlctx->ctx, ctx->xmlctx->value, ctx->xmlctx->value_len, ctx->xmlctx->dynamic, e->argument);
3248 LY_CHECK_RET(!e->argument, LY_EMEM);
3249
Michal Vaskofc2cd072021-02-24 13:17:17 +01003250 /* store prefix data for the argument as well */
Radek Krejci8df109d2021-04-23 12:19:08 +02003251 LY_CHECK_RET(ly_store_prefix_data(ctx->xmlctx->ctx, e->argument, strlen(e->argument), LY_VALUE_XML,
Radek Krejci07a55962021-03-02 20:16:43 +01003252 &ctx->xmlctx->ns, &e->format, &e->prefix_data));
Michal Vaskofc2cd072021-02-24 13:17:17 +01003253
Michal Vaskoafac7822020-10-20 14:22:26 +02003254 /* parser next */
3255 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3256 }
3257
aPiecek60d9d672021-04-27 15:49:57 +02003258 e->parsed = NULL;
3259
Michal Vaskoafac7822020-10-20 14:22:26 +02003260 return LY_SUCCESS;
3261}
3262
3263/**
3264 * @brief Generic function for content parsing
3265 *
3266 * @param[in,out] ctx Yin parser context for logging and to store current state.
3267 * @param[in] subelem_info array of valid subelement types and meta information
3268 * @param[in] subelem_info_size Size of subelem_info array.
3269 * @param[in] current_element Type of current element.
3270 * @param[out] text_content Where the text content of element should be stored if any. Text content is ignored if set to NULL.
3271 * @param[in,out] exts Extension instance to add to. Can be set to null if element cannot have extension as subelements.
3272 *
3273 * @return LY_ERR values.
3274 */
David Sedlákd6e56892019-07-01 15:40:24 +02003275LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01003276yin_parse_content(struct lys_yin_parser_ctx *ctx, struct yin_subelement *subelem_info, size_t subelem_info_size,
Radek Krejci0f969882020-08-21 16:56:47 +02003277 enum ly_stmt current_element, const char **text_content, struct lysp_ext_instance **exts)
David Sedlákd6e56892019-07-01 15:40:24 +02003278{
3279 LY_ERR ret = LY_SUCCESS;
Michal Vaskob36053d2020-03-26 15:49:30 +01003280 enum LYXML_PARSER_STATUS next_status;
Radek Krejcid6b76452019-09-03 17:03:03 +02003281 enum ly_stmt kw = LY_STMT_NONE, last_kw = LY_STMT_NONE;
David Sedlák1af868e2019-07-17 17:03:14 +02003282 struct yin_subelement *subelem = NULL;
David Sedlák09e18c92019-07-18 11:17:11 +02003283
Michal Vaskob36053d2020-03-26 15:49:30 +01003284 assert(ctx->xmlctx->status == LYXML_ELEM_CONTENT);
David Sedlákd6e56892019-07-01 15:40:24 +02003285
Michal Vaskob36053d2020-03-26 15:49:30 +01003286 if (ctx->xmlctx->ws_only) {
3287 /* check whether there are any children */
3288 LY_CHECK_GOTO(ret = lyxml_ctx_peek(ctx->xmlctx, &next_status), cleanup);
3289 } else {
3290 /* we want to parse the value */
3291 next_status = LYXML_ELEM_CLOSE;
3292 }
3293
3294 if (next_status == LYXML_ELEMENT) {
3295 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3296
3297 /* current element has subelements as content */
3298 while (ctx->xmlctx->status == LYXML_ELEMENT) {
3299 /* match keyword */
3300 last_kw = kw;
3301 kw = yin_match_keyword(ctx, ctx->xmlctx->name, ctx->xmlctx->name_len, ctx->xmlctx->prefix,
Michal Vasko69730152020-10-09 16:30:07 +02003302 ctx->xmlctx->prefix_len, current_element);
Michal Vaskob36053d2020-03-26 15:49:30 +01003303
3304 /* check if this element can be child of current element */
3305 subelem = get_record(kw, subelem_info_size, subelem_info);
3306 if (!subelem) {
Michal Vasko69730152020-10-09 16:30:07 +02003307 if ((current_element == LY_STMT_DEVIATE) && isdevsub(kw)) {
Michal Vaskob36053d2020-03-26 15:49:30 +01003308 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INDEV_YIN, ly_stmt2str(kw));
3309 } else {
3310 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_UNEXP_SUBELEM, ctx->xmlctx->name_len,
Michal Vasko69730152020-10-09 16:30:07 +02003311 ctx->xmlctx->name, ly_stmt2str(current_element));
Michal Vaskob36053d2020-03-26 15:49:30 +01003312 }
3313 ret = LY_EVALID;
3314 goto cleanup;
3315 }
3316
3317 /* relative order is required only in module and submodule sub-elements */
Michal Vasko69730152020-10-09 16:30:07 +02003318 if ((current_element == LY_STMT_MODULE) || (current_element == LY_STMT_SUBMODULE)) {
Michal Vaskob36053d2020-03-26 15:49:30 +01003319 ret = yin_check_relative_order(ctx, last_kw, kw, current_element);
3320 LY_CHECK_GOTO(ret, cleanup);
3321 }
3322
3323 /* flag check */
3324 if ((subelem->flags & YIN_SUBELEM_UNIQUE) && (subelem->flags & YIN_SUBELEM_PARSED)) {
3325 /* subelement uniquenes */
3326 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_SUBELEM_REDEF, ly_stmt2str(kw), ly_stmt2str(current_element));
3327 return LY_EVALID;
3328 }
3329 if (subelem->flags & YIN_SUBELEM_FIRST) {
3330 /* subelement is supposed to be defined as first subelement */
3331 ret = yin_check_subelem_first_constraint(ctx, subelem_info, subelem_info_size, current_element, subelem);
3332 LY_CHECK_GOTO(ret, cleanup);
3333 }
3334 if (subelem->flags & YIN_SUBELEM_VER2) {
3335 /* subelement is supported only in version 1.1 or higher */
Michal Vasko8a67eff2021-12-07 14:04:47 +01003336 if (PARSER_CUR_PMOD(ctx)->version < LYS_VERSION_1_1) {
Michal Vaskob36053d2020-03-26 15:49:30 +01003337 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INSUBELEM2, ly_stmt2str(kw), ly_stmt2str(current_element));
David Sedlákd6e56892019-07-01 15:40:24 +02003338 ret = LY_EVALID;
3339 goto cleanup;
3340 }
David Sedlákd6e56892019-07-01 15:40:24 +02003341 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003342 /* note that element was parsed for easy uniqueness check in next iterations */
3343 subelem->flags |= YIN_SUBELEM_PARSED;
3344
3345 switch (kw) {
3346 /* call responsible function */
3347 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01003348 ret = yin_parse_extension_instance(ctx, current_element,
Michal Vasko69730152020-10-09 16:30:07 +02003349 (subelem->dest) ? *((LY_ARRAY_COUNT_TYPE *)subelem->dest) : 0, exts);
Michal Vaskob36053d2020-03-26 15:49:30 +01003350 break;
3351 case LY_STMT_ACTION:
3352 case LY_STMT_RPC:
3353 ret = yin_parse_action(ctx, (struct tree_node_meta *)subelem->dest);
3354 break;
3355 case LY_STMT_ANYDATA:
3356 case LY_STMT_ANYXML:
3357 ret = yin_parse_any(ctx, kw, (struct tree_node_meta *)subelem->dest);
3358 break;
3359 case LY_STMT_ARGUMENT:
3360 ret = yin_parse_argument(ctx, (struct yin_argument_meta *)subelem->dest, exts);
3361 break;
3362 case LY_STMT_AUGMENT:
3363 ret = yin_parse_augment(ctx, (struct tree_node_meta *)subelem->dest);
3364 break;
3365 case LY_STMT_BASE:
3366 ret = yin_parse_base(ctx, current_element, subelem->dest, exts);
3367 break;
3368 case LY_STMT_BELONGS_TO:
3369 ret = yin_parse_belongs_to(ctx, (struct lysp_submodule *)subelem->dest, exts);
3370 break;
3371 case LY_STMT_BIT:
3372 ret = yin_parse_bit(ctx, (struct lysp_type *)subelem->dest);
3373 break;
3374 case LY_STMT_CASE:
3375 ret = yin_parse_case(ctx, (struct tree_node_meta *)subelem->dest);
3376 break;
3377 case LY_STMT_CHOICE:
3378 ret = yin_parse_choice(ctx, (struct tree_node_meta *)subelem->dest);
3379 break;
3380 case LY_STMT_CONFIG:
3381 ret = yin_parse_config(ctx, (uint16_t *)subelem->dest, exts);
3382 break;
3383 case LY_STMT_CONTACT:
3384 case LY_STMT_DESCRIPTION:
3385 case LY_STMT_ORGANIZATION:
3386 case LY_STMT_REFERENCE:
3387 ret = yin_parse_meta(ctx, kw, (const char **)subelem->dest, exts);
3388 break;
3389 case LY_STMT_CONTAINER:
3390 ret = yin_parse_container(ctx, (struct tree_node_meta *)subelem->dest);
3391 break;
3392 case LY_STMT_DEFAULT:
Michal Vasko7f45cf22020-10-01 12:49:44 +02003393 ret = yin_parse_qname(ctx, kw, subelem, exts);
3394 break;
Michal Vaskob36053d2020-03-26 15:49:30 +01003395 case LY_STMT_ERROR_APP_TAG:
3396 case LY_STMT_KEY:
3397 case LY_STMT_PRESENCE:
3398 ret = yin_parse_simple_elem(ctx, kw, subelem, YIN_ARG_VALUE, Y_STR_ARG, exts);
3399 break;
3400 case LY_STMT_DEVIATE:
3401 ret = yin_parse_deviate(ctx, (struct lysp_deviate **)subelem->dest);
3402 break;
3403 case LY_STMT_DEVIATION:
3404 ret = yin_parse_deviation(ctx, (struct lysp_deviation **)subelem->dest);
3405 break;
3406 case LY_STMT_ENUM:
3407 ret = yin_parse_enum(ctx, (struct lysp_type *)subelem->dest);
3408 break;
3409 case LY_STMT_ERROR_MESSAGE:
3410 ret = yin_parse_err_msg(ctx, (const char **)subelem->dest, exts);
3411 break;
3412 case LY_STMT_EXTENSION:
3413 ret = yin_parse_extension(ctx, (struct lysp_ext **)subelem->dest);
3414 break;
3415 case LY_STMT_FEATURE:
3416 ret = yin_parse_feature(ctx, (struct lysp_feature **)subelem->dest);
3417 break;
3418 case LY_STMT_FRACTION_DIGITS:
3419 ret = yin_parse_fracdigits(ctx, (struct lysp_type *)subelem->dest);
3420 break;
3421 case LY_STMT_GROUPING:
3422 ret = yin_parse_grouping(ctx, (struct tree_node_meta *)subelem->dest);
3423 break;
3424 case LY_STMT_IDENTITY:
3425 ret = yin_parse_identity(ctx, (struct lysp_ident **)subelem->dest);
3426 break;
Radek Išabe8a6532021-03-29 08:54:22 +02003427 case LY_STMT_UNIQUE:
Michal Vaskob36053d2020-03-26 15:49:30 +01003428 case LY_STMT_IF_FEATURE:
Michal Vasko7f45cf22020-10-01 12:49:44 +02003429 ret = yin_parse_qname(ctx, kw, subelem, exts);
3430 break;
Michal Vaskob36053d2020-03-26 15:49:30 +01003431 case LY_STMT_UNITS:
3432 ret = yin_parse_simple_elem(ctx, kw, subelem, YIN_ARG_NAME, Y_STR_ARG, exts);
3433 break;
3434 case LY_STMT_IMPORT:
3435 ret = yin_parse_import(ctx, (struct import_meta *)subelem->dest);
3436 break;
3437 case LY_STMT_INCLUDE:
Michal Vasko8a67eff2021-12-07 14:04:47 +01003438 if ((current_element == LY_STMT_SUBMODULE) && (PARSER_CUR_PMOD(ctx)->version == LYS_VERSION_1_1)) {
Radek Krejcieeee95c2021-01-19 10:57:22 +01003439 LOGWRN(PARSER_CTX(ctx), "YANG version 1.1 expects all includes in main module, includes in submodules (%s) are not necessary.",
Michal Vasko8a67eff2021-12-07 14:04:47 +01003440 ((struct lysp_submodule *)PARSER_CUR_PMOD(ctx))->name);
Radek Krejcieeee95c2021-01-19 10:57:22 +01003441 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003442 ret = yin_parse_include(ctx, (struct include_meta *)subelem->dest);
3443 break;
3444 case LY_STMT_INPUT:
3445 case LY_STMT_OUTPUT:
3446 ret = yin_parse_inout(ctx, kw, (struct inout_meta *)subelem->dest);
3447 break;
3448 case LY_STMT_LEAF:
3449 ret = yin_parse_leaf(ctx, (struct tree_node_meta *)subelem->dest);
3450 break;
3451 case LY_STMT_LEAF_LIST:
3452 ret = yin_parse_leaflist(ctx, (struct tree_node_meta *)subelem->dest);
3453 break;
3454 case LY_STMT_LENGTH:
3455 ret = yin_parse_length(ctx, (struct lysp_type *)subelem->dest);
3456 break;
3457 case LY_STMT_LIST:
3458 ret = yin_parse_list(ctx, (struct tree_node_meta *)subelem->dest);
3459 break;
3460 case LY_STMT_MANDATORY:
3461 ret = yin_parse_mandatory(ctx, (uint16_t *)subelem->dest, exts);
3462 break;
3463 case LY_STMT_MAX_ELEMENTS:
3464 case LY_STMT_MIN_ELEMENTS:
3465 ret = yin_parse_minmax(ctx, current_element, kw, subelem->dest);
3466 break;
3467 case LY_STMT_MODIFIER:
3468 ret = yin_parse_modifier(ctx, (const char **)subelem->dest, exts);
3469 break;
3470 case LY_STMT_MUST:
3471 ret = yin_parse_must(ctx, (struct lysp_restr **)subelem->dest);
3472 break;
3473 case LY_STMT_NAMESPACE:
3474 ret = yin_parse_simple_elem(ctx, kw, subelem, YIN_ARG_URI, Y_STR_ARG, exts);
3475 break;
3476 case LY_STMT_NOTIFICATION:
3477 ret = yin_parse_notification(ctx, (struct tree_node_meta *)subelem->dest);
3478 break;
3479 case LY_STMT_ORDERED_BY:
3480 ret = yin_parse_orderedby(ctx, (uint16_t *)subelem->dest, exts);
3481 break;
3482 case LY_STMT_PATH:
3483 ret = yin_parse_path(ctx, kw, (struct lysp_type *)subelem->dest);
3484 break;
3485 case LY_STMT_PATTERN:
3486 ret = yin_parse_pattern(ctx, (struct lysp_type *)subelem->dest);
3487 break;
3488 case LY_STMT_VALUE:
3489 case LY_STMT_POSITION:
3490 ret = yin_parse_value_pos(ctx, kw, (struct lysp_type_enum *)subelem->dest);
3491 break;
3492 case LY_STMT_PREFIX:
3493 ret = yin_parse_simple_elem(ctx, kw, subelem, YIN_ARG_VALUE, Y_IDENTIF_ARG, exts);
3494 break;
3495 case LY_STMT_RANGE:
3496 ret = yin_parse_range(ctx, (struct lysp_type *)subelem->dest);
3497 break;
3498 case LY_STMT_REFINE:
3499 ret = yin_parse_refine(ctx, (struct lysp_refine **)subelem->dest);
3500 break;
3501 case LY_STMT_REQUIRE_INSTANCE:
3502 ret = yin_pasrse_reqinstance(ctx, (struct lysp_type *)subelem->dest);
3503 break;
3504 case LY_STMT_REVISION:
3505 ret = yin_parse_revision(ctx, (struct lysp_revision **)subelem->dest);
3506 break;
3507 case LY_STMT_REVISION_DATE:
3508 ret = yin_parse_revision_date(ctx, (char *)subelem->dest, exts);
3509 break;
3510 case LY_STMT_STATUS:
3511 ret = yin_parse_status(ctx, (uint16_t *)subelem->dest, exts);
3512 break;
3513 case LY_STMT_TYPE:
3514 ret = yin_parse_type(ctx, current_element, subelem);
3515 break;
3516 case LY_STMT_TYPEDEF:
3517 ret = yin_parse_typedef(ctx, (struct tree_node_meta *)subelem->dest);
3518 break;
Michal Vaskob36053d2020-03-26 15:49:30 +01003519 case LY_STMT_USES:
3520 ret = yin_parse_uses(ctx, (struct tree_node_meta *)subelem->dest);
3521 break;
3522 case LY_STMT_WHEN:
3523 ret = yin_parse_when(ctx, (struct lysp_when **)subelem->dest);
3524 break;
3525 case LY_STMT_YANG_VERSION:
3526 ret = yin_parse_yangversion(ctx, (uint8_t *)subelem->dest, exts);
3527 break;
3528 case LY_STMT_YIN_ELEMENT:
3529 ret = yin_parse_yin_element(ctx, (uint16_t *)subelem->dest, exts);
3530 break;
3531 case LY_STMT_ARG_TEXT:
3532 case LY_STMT_ARG_VALUE:
3533 /* TODO what to do with content/attributes? */
3534 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3535 while (ctx->xmlctx->status == LYXML_ATTRIBUTE) {
3536 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3537 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3538 }
3539 ret = yin_parse_content(ctx, NULL, 0, kw, (const char **)subelem->dest, NULL);
3540 break;
3541 default:
3542 LOGINT(ctx->xmlctx->ctx);
3543 ret = LY_EINT;
David Sedlák3ffbc522019-07-02 17:49:28 +02003544 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003545 LY_CHECK_GOTO(ret, cleanup);
3546 subelem = NULL;
3547
3548 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
David Sedlákd6e56892019-07-01 15:40:24 +02003549 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003550 } else {
3551 LY_CHECK_RET(ret);
3552 /* elements with text or none content */
3553 /* save text content, if text_content isn't set, it's just ignored */
3554 /* no resources are allocated in this branch, no need to use cleanup label */
3555 LY_CHECK_RET(yin_validate_value(ctx, Y_STR_ARG));
3556 if (text_content) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02003557 INSERT_STRING_RET(ctx->xmlctx->ctx, ctx->xmlctx->value, ctx->xmlctx->value_len, ctx->xmlctx->dynamic, *text_content);
Michal Vaskob36053d2020-03-26 15:49:30 +01003558 LY_CHECK_RET(!*text_content, LY_EMEM);
3559 }
3560
3561 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
David Sedlákd6e56892019-07-01 15:40:24 +02003562 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003563
David Sedlák8b754462019-07-25 16:22:13 +02003564 /* mandatory subelemnts are checked only after whole element was succesfully parsed */
3565 LY_CHECK_RET(yin_check_subelem_mandatory_constraint(ctx, subelem_info, subelem_info_size, current_element));
David Sedlákd6e56892019-07-01 15:40:24 +02003566
3567cleanup:
David Sedlákd6e56892019-07-01 15:40:24 +02003568 return ret;
3569}
3570
David Sedlákaa98bba2019-09-12 11:52:14 +02003571/**
Michal Vaskoafac7822020-10-20 14:22:26 +02003572 * @brief Parse module element.
David Sedlákaa98bba2019-09-12 11:52:14 +02003573 *
3574 * @param[in,out] ctx Yin parser context for logging and to store current state.
Michal Vaskoafac7822020-10-20 14:22:26 +02003575 * @param[out] mod Parsed module structure.
David Sedlákaa98bba2019-09-12 11:52:14 +02003576 *
3577 * @return LY_ERR values.
3578 */
David Sedlák1e2cdd02019-06-27 14:17:43 +02003579LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01003580yin_parse_mod(struct lys_yin_parser_ctx *ctx, struct lysp_module *mod)
David Sedlák3b4db242018-10-19 16:11:01 +02003581{
David Sedlák81497a32019-08-13 16:56:26 +02003582 LY_ERR ret = LY_SUCCESS;
3583 struct yin_subelement *subelems = NULL;
Michal Vasko8dc31992021-02-22 10:30:47 +01003584 const struct lysp_submodule *dup;
Radek Krejcif13b87b2020-12-01 22:02:17 +01003585 size_t subelems_size;
David Sedlák3b4db242018-10-19 16:11:01 +02003586
Michal Vaskoc3781c32020-10-06 14:04:08 +02003587 mod->is_submod = 0;
3588
Michal Vaskob36053d2020-03-26 15:49:30 +01003589 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3590 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &mod->mod->name, Y_IDENTIF_ARG, LY_STMT_MODULE));
Radek Krejcif13b87b2020-12-01 22:02:17 +01003591 LY_CHECK_RET(subelems_allocator(ctx, subelems_size = 28, NULL, &subelems,
Michal Vasko69730152020-10-09 16:30:07 +02003592 LY_STMT_ANYDATA, &mod->data, YIN_SUBELEM_VER2,
3593 LY_STMT_ANYXML, &mod->data, 0,
3594 LY_STMT_AUGMENT, &mod->augments, 0,
3595 LY_STMT_CHOICE, &mod->data, 0,
3596 LY_STMT_CONTACT, &mod->mod->contact, YIN_SUBELEM_UNIQUE,
3597 LY_STMT_CONTAINER, &mod->data, 0,
3598 LY_STMT_DESCRIPTION, &mod->mod->dsc, YIN_SUBELEM_UNIQUE,
3599 LY_STMT_DEVIATION, &mod->deviations, 0,
3600 LY_STMT_EXTENSION, &mod->extensions, 0,
3601 LY_STMT_FEATURE, &mod->features, 0,
3602 LY_STMT_GROUPING, &mod->groupings, 0,
3603 LY_STMT_IDENTITY, &mod->identities, 0,
3604 LY_STMT_IMPORT, mod->mod->prefix, &mod->imports, 0,
3605 LY_STMT_INCLUDE, mod->mod->name, &mod->includes, 0,
3606 LY_STMT_LEAF, &mod->data, 0,
3607 LY_STMT_LEAF_LIST, &mod->data, 0,
3608 LY_STMT_LIST, &mod->data, 0,
3609 LY_STMT_NAMESPACE, &mod->mod->ns, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE,
3610 LY_STMT_NOTIFICATION, &mod->notifs, 0,
3611 LY_STMT_ORGANIZATION, &mod->mod->org, YIN_SUBELEM_UNIQUE,
3612 LY_STMT_PREFIX, &mod->mod->prefix, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE,
3613 LY_STMT_REFERENCE, &mod->mod->ref, YIN_SUBELEM_UNIQUE,
3614 LY_STMT_REVISION, &mod->revs, 0,
3615 LY_STMT_RPC, &mod->rpcs, 0,
3616 LY_STMT_TYPEDEF, &mod->typedefs, 0,
3617 LY_STMT_USES, &mod->data, 0,
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003618 LY_STMT_YANG_VERSION, &mod->version, YIN_SUBELEM_UNIQUE,
Michal Vasko69730152020-10-09 16:30:07 +02003619 LY_STMT_EXTENSION_INSTANCE, NULL, 0));
David Sedlák81497a32019-08-13 16:56:26 +02003620
Radek Krejcif13b87b2020-12-01 22:02:17 +01003621 ret = yin_parse_content(ctx, subelems, subelems_size, LY_STMT_MODULE, NULL, &mod->exts);
3622 subelems_deallocator(subelems_size, subelems);
David Sedláked809f12019-09-13 10:15:11 +02003623 LY_CHECK_RET(ret);
David Sedlák81497a32019-08-13 16:56:26 +02003624
David Sedláked809f12019-09-13 10:15:11 +02003625 /* submodules share the namespace with the module names, so there must not be
3626 * a submodule of the same name in the context, no need for revision matching */
Michal Vasko8dc31992021-02-22 10:30:47 +01003627 dup = ly_ctx_get_submodule_latest(ctx->xmlctx->ctx, mod->mod->name);
David Sedláked809f12019-09-13 10:15:11 +02003628 if (dup) {
Radek Krejci854e1552020-12-21 15:05:23 +01003629 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_NAME2_COL, "module", "submodule", mod->mod->name);
David Sedláked809f12019-09-13 10:15:11 +02003630 return LY_EVALID;
3631 }
3632
3633 return LY_SUCCESS;
David Sedlák3b4db242018-10-19 16:11:01 +02003634}
3635
Michal Vaskoafac7822020-10-20 14:22:26 +02003636/**
3637 * @brief Parse submodule element.
3638 *
3639 * @param[in,out] ctx Yin parser context for logging and to store current state.
3640 * @param[in] mod_attrs Attributes of submodule element.
3641 * @param[out] submod Parsed submodule structure.
3642 *
3643 * @return LY_ERR values.
3644 */
David Sedlák3b4db242018-10-19 16:11:01 +02003645LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01003646yin_parse_submod(struct lys_yin_parser_ctx *ctx, struct lysp_submodule *submod)
David Sedlák298ff6d2019-07-26 14:29:03 +02003647{
David Sedlák81497a32019-08-13 16:56:26 +02003648 LY_ERR ret = LY_SUCCESS;
3649 struct yin_subelement *subelems = NULL;
Michal Vasko8dc31992021-02-22 10:30:47 +01003650 const struct lysp_submodule *dup;
Radek Krejcif13b87b2020-12-01 22:02:17 +01003651 size_t subelems_size;
David Sedlák298ff6d2019-07-26 14:29:03 +02003652
Michal Vaskoc3781c32020-10-06 14:04:08 +02003653 submod->is_submod = 1;
3654
Michal Vaskob36053d2020-03-26 15:49:30 +01003655 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3656 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &submod->name, Y_IDENTIF_ARG, LY_STMT_SUBMODULE));
Radek Krejcif13b87b2020-12-01 22:02:17 +01003657 LY_CHECK_RET(subelems_allocator(ctx, subelems_size = 27, NULL, &subelems,
Michal Vasko69730152020-10-09 16:30:07 +02003658 LY_STMT_ANYDATA, &submod->data, YIN_SUBELEM_VER2,
3659 LY_STMT_ANYXML, &submod->data, 0,
3660 LY_STMT_AUGMENT, &submod->augments, 0,
3661 LY_STMT_BELONGS_TO, submod, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE,
3662 LY_STMT_CHOICE, &submod->data, 0,
3663 LY_STMT_CONTACT, &submod->contact, YIN_SUBELEM_UNIQUE,
3664 LY_STMT_CONTAINER, &submod->data, 0,
3665 LY_STMT_DESCRIPTION, &submod->dsc, YIN_SUBELEM_UNIQUE,
3666 LY_STMT_DEVIATION, &submod->deviations, 0,
3667 LY_STMT_EXTENSION, &submod->extensions, 0,
3668 LY_STMT_FEATURE, &submod->features, 0,
3669 LY_STMT_GROUPING, &submod->groupings, 0,
3670 LY_STMT_IDENTITY, &submod->identities, 0,
3671 LY_STMT_IMPORT, submod->prefix, &submod->imports, 0,
3672 LY_STMT_INCLUDE, submod->name, &submod->includes, 0,
3673 LY_STMT_LEAF, &submod->data, 0,
3674 LY_STMT_LEAF_LIST, &submod->data, 0,
3675 LY_STMT_LIST, &submod->data, 0,
3676 LY_STMT_NOTIFICATION, &submod->notifs, 0,
3677 LY_STMT_ORGANIZATION, &submod->org, YIN_SUBELEM_UNIQUE,
3678 LY_STMT_REFERENCE, &submod->ref, YIN_SUBELEM_UNIQUE,
3679 LY_STMT_REVISION, &submod->revs, 0,
3680 LY_STMT_RPC, &submod->rpcs, 0,
3681 LY_STMT_TYPEDEF, &submod->typedefs, 0,
3682 LY_STMT_USES, &submod->data, 0,
3683 LY_STMT_YANG_VERSION, &submod->version, YIN_SUBELEM_UNIQUE,
3684 LY_STMT_EXTENSION_INSTANCE, NULL, 0));
David Sedlák81497a32019-08-13 16:56:26 +02003685
Radek Krejcif13b87b2020-12-01 22:02:17 +01003686 ret = yin_parse_content(ctx, subelems, subelems_size, LY_STMT_SUBMODULE, NULL, &submod->exts);
3687 subelems_deallocator(subelems_size, subelems);
David Sedláked809f12019-09-13 10:15:11 +02003688 LY_CHECK_RET(ret);
David Sedlák81497a32019-08-13 16:56:26 +02003689
David Sedláked809f12019-09-13 10:15:11 +02003690 /* submodules share the namespace with the module names, so there must not be
3691 * a submodule of the same name in the context, no need for revision matching */
Michal Vasko8dc31992021-02-22 10:30:47 +01003692 dup = ly_ctx_get_submodule_latest(ctx->xmlctx->ctx, submod->name);
Michal Vaskoc3781c32020-10-06 14:04:08 +02003693 if (dup && strcmp(dup->mod->name, submod->mod->name)) {
Radek Krejci854e1552020-12-21 15:05:23 +01003694 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_NAME_COL, "submodules", dup->name);
David Sedláked809f12019-09-13 10:15:11 +02003695 return LY_EVALID;
3696 }
3697
3698 return LY_SUCCESS;
David Sedlák298ff6d2019-07-26 14:29:03 +02003699}
3700
3701LY_ERR
Michal Vasko63f3d842020-07-08 10:10:14 +02003702yin_parse_submodule(struct lys_yin_parser_ctx **yin_ctx, struct ly_ctx *ctx, struct lys_parser_ctx *main_ctx,
Radek Krejci0f969882020-08-21 16:56:47 +02003703 struct ly_in *in, struct lysp_submodule **submod)
David Sedlák8985a142019-07-31 16:43:06 +02003704{
Radek Krejcid6b76452019-09-03 17:03:03 +02003705 enum ly_stmt kw = LY_STMT_NONE;
David Sedlák8985a142019-07-31 16:43:06 +02003706 LY_ERR ret = LY_SUCCESS;
David Sedlák8985a142019-07-31 16:43:06 +02003707 struct lysp_submodule *mod_p = NULL;
3708
aPiecek56be92a2021-07-01 07:18:10 +02003709 assert(yin_ctx && ctx && main_ctx && in && submod);
3710
David Sedlák8985a142019-07-31 16:43:06 +02003711 /* create context */
3712 *yin_ctx = calloc(1, sizeof **yin_ctx);
David Sedlák1b623122019-08-05 15:27:49 +02003713 LY_CHECK_ERR_RET(!(*yin_ctx), LOGMEM(ctx), LY_EMEM);
Michal Vaskob36053d2020-03-26 15:49:30 +01003714 (*yin_ctx)->format = LYS_IN_YIN;
aPiecek56be92a2021-07-01 07:18:10 +02003715 (*yin_ctx)->main_ctx = main_ctx;
Michal Vasko63f3d842020-07-08 10:10:14 +02003716 LY_CHECK_RET(lyxml_ctx_new(ctx, in, &(*yin_ctx)->xmlctx));
David Sedlák8985a142019-07-31 16:43:06 +02003717
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003718 mod_p = calloc(1, sizeof *mod_p);
3719 LY_CHECK_ERR_GOTO(!mod_p, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko8a67eff2021-12-07 14:04:47 +01003720 mod_p->mod = PARSER_CUR_PMOD(main_ctx)->mod;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003721 mod_p->parsing = 1;
Michal Vasko8a67eff2021-12-07 14:04:47 +01003722
3723 /* use main context parsed mods adding the current one */
3724 (*yin_ctx)->parsed_mods = main_ctx->parsed_mods;
3725 ly_set_add((*yin_ctx)->parsed_mods, mod_p, 1, NULL);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003726
David Sedlák8985a142019-07-31 16:43:06 +02003727 /* check submodule */
Michal Vaskob36053d2020-03-26 15:49:30 +01003728 kw = yin_match_keyword(*yin_ctx, (*yin_ctx)->xmlctx->name, (*yin_ctx)->xmlctx->name_len, (*yin_ctx)->xmlctx->prefix,
Michal Vasko69730152020-10-09 16:30:07 +02003729 (*yin_ctx)->xmlctx->prefix_len, LY_STMT_NONE);
Radek Krejcid6b76452019-09-03 17:03:03 +02003730 if (kw == LY_STMT_MODULE) {
David Sedlák8985a142019-07-31 16:43:06 +02003731 LOGERR(ctx, LY_EDENIED, "Input data contains module in situation when a submodule is expected.");
3732 ret = LY_EINVAL;
3733 goto cleanup;
Radek Krejcid6b76452019-09-03 17:03:03 +02003734 } else if (kw != LY_STMT_SUBMODULE) {
David Sedlák1538a842019-08-08 15:38:51 +02003735 LOGVAL_PARSER((struct lys_parser_ctx *)*yin_ctx, LY_VCODE_MOD_SUBOMD, ly_stmt2str(kw));
David Sedlák8985a142019-07-31 16:43:06 +02003736 ret = LY_EVALID;
3737 goto cleanup;
3738 }
3739
Michal Vaskob36053d2020-03-26 15:49:30 +01003740 ret = yin_parse_submod(*yin_ctx, mod_p);
David Sedlák8985a142019-07-31 16:43:06 +02003741 LY_CHECK_GOTO(ret, cleanup);
3742
David Sedlákbf8a2b72019-08-14 16:48:10 +02003743 /* skip possible trailing whitespaces at end of the input */
Michal Vasko63f3d842020-07-08 10:10:14 +02003744 while (isspace(in->current[0])) {
Radek Krejcidd713ce2021-01-04 23:12:12 +01003745 if (in->current[0] == '\n') {
3746 LY_IN_NEW_LINE(in);
3747 }
Michal Vasko63f3d842020-07-08 10:10:14 +02003748 ly_in_skip(in, 1);
David Sedlák6d781b62019-08-02 15:22:52 +02003749 }
Michal Vasko63f3d842020-07-08 10:10:14 +02003750 if (in->current[0]) {
3751 LOGVAL_PARSER((struct lys_parser_ctx *)*yin_ctx, LY_VCODE_TRAILING_SUBMOD, 15, in->current,
Michal Vasko69730152020-10-09 16:30:07 +02003752 strlen(in->current) > 15 ? "..." : "");
David Sedlák6d781b62019-08-02 15:22:52 +02003753 ret = LY_EVALID;
3754 goto cleanup;
3755 }
3756
David Sedlák8985a142019-07-31 16:43:06 +02003757 mod_p->parsing = 0;
3758 *submod = mod_p;
3759
3760cleanup:
3761 if (ret) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003762 lysp_module_free((struct lysp_module *)mod_p);
David Sedlák1b623122019-08-05 15:27:49 +02003763 yin_parser_ctx_free(*yin_ctx);
3764 *yin_ctx = NULL;
David Sedlák8985a142019-07-31 16:43:06 +02003765 }
David Sedlák8985a142019-07-31 16:43:06 +02003766 return ret;
3767}
3768
3769LY_ERR
aPiecekc3e26142021-06-22 14:25:49 +02003770yin_parse_module(struct lys_yin_parser_ctx **yin_ctx, struct ly_in *in, struct lys_module *mod)
David Sedlák3b4db242018-10-19 16:11:01 +02003771{
David Sedláke4889912018-11-02 09:52:40 +01003772 LY_ERR ret = LY_SUCCESS;
Radek Krejcid6b76452019-09-03 17:03:03 +02003773 enum ly_stmt kw = LY_STMT_NONE;
David Sedlák3017da42019-02-15 09:48:04 +01003774 struct lysp_module *mod_p = NULL;
David Sedlák3b4db242018-10-19 16:11:01 +02003775
David Sedlák8985a142019-07-31 16:43:06 +02003776 /* create context */
3777 *yin_ctx = calloc(1, sizeof **yin_ctx);
David Sedlák1b623122019-08-05 15:27:49 +02003778 LY_CHECK_ERR_RET(!(*yin_ctx), LOGMEM(mod->ctx), LY_EMEM);
Michal Vaskob36053d2020-03-26 15:49:30 +01003779 (*yin_ctx)->format = LYS_IN_YIN;
Michal Vasko8a67eff2021-12-07 14:04:47 +01003780 LY_CHECK_ERR_RET(ly_set_new(&(*yin_ctx)->parsed_mods), free(*yin_ctx); LOGMEM(mod->ctx), LY_EMEM);
Michal Vasko63f3d842020-07-08 10:10:14 +02003781 LY_CHECK_RET(lyxml_ctx_new(mod->ctx, in, &(*yin_ctx)->xmlctx));
aPiecek8d4e75d2021-06-24 14:47:06 +02003782 (*yin_ctx)->main_ctx = (struct lys_parser_ctx *)(*yin_ctx);
David Sedlákda8ffa32019-07-08 14:17:10 +02003783
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003784 mod_p = calloc(1, sizeof *mod_p);
3785 LY_CHECK_ERR_GOTO(!mod_p, LOGMEM(mod->ctx), cleanup);
3786 mod_p->mod = mod;
Michal Vasko8a67eff2021-12-07 14:04:47 +01003787 ly_set_add((*yin_ctx)->parsed_mods, mod_p, 1, NULL);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003788
David Sedlák8985a142019-07-31 16:43:06 +02003789 /* check module */
Michal Vaskob36053d2020-03-26 15:49:30 +01003790 kw = yin_match_keyword(*yin_ctx, (*yin_ctx)->xmlctx->name, (*yin_ctx)->xmlctx->name_len, (*yin_ctx)->xmlctx->prefix,
Michal Vasko69730152020-10-09 16:30:07 +02003791 (*yin_ctx)->xmlctx->prefix_len, LY_STMT_NONE);
Radek Krejcid6b76452019-09-03 17:03:03 +02003792 if (kw == LY_STMT_SUBMODULE) {
David Sedlák8985a142019-07-31 16:43:06 +02003793 LOGERR(mod->ctx, LY_EDENIED, "Input data contains submodule which cannot be parsed directly without its main module.");
David Sedlák3017da42019-02-15 09:48:04 +01003794 ret = LY_EINVAL;
3795 goto cleanup;
Radek Krejcid6b76452019-09-03 17:03:03 +02003796 } else if (kw != LY_STMT_MODULE) {
David Sedlák1538a842019-08-08 15:38:51 +02003797 LOGVAL_PARSER((struct lys_parser_ctx *)*yin_ctx, LY_VCODE_MOD_SUBOMD, ly_stmt2str(kw));
David Sedlák3017da42019-02-15 09:48:04 +01003798 ret = LY_EVALID;
3799 goto cleanup;
David Sedláke4889912018-11-02 09:52:40 +01003800 }
3801
David Sedlák00250342019-06-21 14:19:39 +02003802 /* parse module substatements */
Michal Vaskob36053d2020-03-26 15:49:30 +01003803 ret = yin_parse_mod(*yin_ctx, mod_p);
David Sedlák3017da42019-02-15 09:48:04 +01003804 LY_CHECK_GOTO(ret, cleanup);
David Sedlák2e411422018-12-17 02:35:39 +01003805
David Sedlákbf8a2b72019-08-14 16:48:10 +02003806 /* skip possible trailing whitespaces at end of the input */
Michal Vasko63f3d842020-07-08 10:10:14 +02003807 while (isspace(in->current[0])) {
Radek Krejcidd713ce2021-01-04 23:12:12 +01003808 if (in->current[0] == '\n') {
3809 LY_IN_NEW_LINE(in);
3810 }
Michal Vasko63f3d842020-07-08 10:10:14 +02003811 ly_in_skip(in, 1);
David Sedlák6d781b62019-08-02 15:22:52 +02003812 }
Michal Vasko63f3d842020-07-08 10:10:14 +02003813 if (in->current[0]) {
3814 LOGVAL_PARSER((struct lys_parser_ctx *)*yin_ctx, LY_VCODE_TRAILING_MOD, 15, in->current,
Michal Vasko69730152020-10-09 16:30:07 +02003815 strlen(in->current) > 15 ? "..." : "");
David Sedlák6d781b62019-08-02 15:22:52 +02003816 ret = LY_EVALID;
3817 goto cleanup;
3818 }
3819
David Sedlák3017da42019-02-15 09:48:04 +01003820 mod->parsed = mod_p;
3821
3822cleanup:
David Sedlák8f7a1172019-06-20 14:42:18 +02003823 if (ret != LY_SUCCESS) {
David Sedlák3017da42019-02-15 09:48:04 +01003824 lysp_module_free(mod_p);
David Sedlák1b623122019-08-05 15:27:49 +02003825 yin_parser_ctx_free(*yin_ctx);
3826 *yin_ctx = NULL;
David Sedlák3017da42019-02-15 09:48:04 +01003827 }
David Sedlák2e411422018-12-17 02:35:39 +01003828 return ret;
David Sedlák3b4db242018-10-19 16:11:01 +02003829}