blob: 9fb7b617ebe1b9241434b854e6dc09a40642f92d [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 */
Radek Krejci535ea9f2020-05-29 16:01:05 +020014#include "parser_yin.h"
David Sedlákecf5eb82019-06-03 14:12:44 +020015
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>
David Sedlák3b4db242018-10-19 16:11:01 +020021#include <stdio.h>
22#include <stdlib.h>
David Sedlák872c7b42018-10-26 13:15:20 +020023#include <string.h>
David Sedlákf824ad52018-10-14 23:58:15 +020024
Radek Krejci535ea9f2020-05-29 16:01:05 +020025#include "common.h"
David Sedlákf824ad52018-10-14 23:58:15 +020026#include "context.h"
David Sedlákecf5eb82019-06-03 14:12:44 +020027#include "dict.h"
Michal Vasko004d3152020-06-11 19:59:22 +020028#include "path.h"
Michal Vasko63f3d842020-07-08 10:10:14 +020029#include "parser_internal.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020030#include "parser_schema.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020031#include "set.h"
David Sedlákecf5eb82019-06-03 14:12:44 +020032#include "tree.h"
33#include "tree_schema.h"
David Sedlák3b4db242018-10-19 16:11:01 +020034#include "tree_schema_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020035#include "xml.h"
David Sedlák00250342019-06-21 14:19:39 +020036
David Sedlák2b214ac2019-06-06 16:11:03 +020037/**
38 * @brief check if given string is URI of yin namespace.
David Sedlák8985a142019-07-31 16:43:06 +020039 *
David Sedlák2b214ac2019-06-06 16:11:03 +020040 * @param ns Namespace URI to check.
41 *
42 * @return true if ns equals YIN_NS_URI false otherwise.
43 */
44#define IS_YIN_NS(ns) (strcmp(ns, YIN_NS_URI) == 0)
45
Michal Vasko22df3f02020-08-24 13:29:22 +020046const char * const yin_attr_list[] = {
David Sedlákf6251182019-06-06 10:22:13 +020047 [YIN_ARG_NAME] = "name",
48 [YIN_ARG_TARGET_NODE] = "target-node",
49 [YIN_ARG_MODULE] = "module",
50 [YIN_ARG_VALUE] = "value",
51 [YIN_ARG_TEXT] = "text",
52 [YIN_ARG_CONDITION] = "condition",
53 [YIN_ARG_URI] = "uri",
54 [YIN_ARG_DATE] = "date",
55 [YIN_ARG_TAG] = "tag",
David Sedlák071f7662019-09-12 02:02:51 +020056 [YIN_ARG_NONE] = "none",
David Sedlákf6251182019-06-06 10:22:13 +020057};
58
Radek Krejcid6b76452019-09-03 17:03:03 +020059enum ly_stmt
Michal Vaskob36053d2020-03-26 15:49:30 +010060yin_match_keyword(struct lys_yin_parser_ctx *ctx, const char *name, size_t name_len,
Radek Krejci0f969882020-08-21 16:56:47 +020061 const char *prefix, size_t prefix_len, enum ly_stmt parent)
David Sedlák1bccdfa2019-06-17 15:55:27 +020062{
David Sedlák8f7a1172019-06-20 14:42:18 +020063 const char *start = NULL;
Radek Krejcid6b76452019-09-03 17:03:03 +020064 enum ly_stmt kw = LY_STMT_NONE;
David Sedlák8f7a1172019-06-20 14:42:18 +020065 const struct lyxml_ns *ns = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +020066 struct ly_in *in;
David Sedlák8f7a1172019-06-20 14:42:18 +020067
68 if (!name || name_len == 0) {
Radek Krejcid6b76452019-09-03 17:03:03 +020069 return LY_STMT_NONE;
David Sedlák1bccdfa2019-06-17 15:55:27 +020070 }
71
Michal Vaskoc8a230d2020-08-14 12:17:10 +020072 ns = lyxml_ns_get(&ctx->xmlctx->ns, prefix, prefix_len);
David Sedlák8f7a1172019-06-20 14:42:18 +020073 if (ns) {
74 if (!IS_YIN_NS(ns->uri)) {
Radek Krejcid6b76452019-09-03 17:03:03 +020075 return LY_STMT_EXTENSION_INSTANCE;
David Sedlák8f7a1172019-06-20 14:42:18 +020076 }
77 } else {
78 /* elements without namespace are automatically unknown */
Radek Krejcid6b76452019-09-03 17:03:03 +020079 return LY_STMT_NONE;
David Sedlák8f7a1172019-06-20 14:42:18 +020080 }
David Sedlák1bccdfa2019-06-17 15:55:27 +020081
Michal Vasko63f3d842020-07-08 10:10:14 +020082 LY_CHECK_RET(ly_in_new_memory(name, &in), LY_STMT_NONE);
83 start = in->current;
84 kw = lysp_match_kw(NULL, in);
85 name = in->current;
86 ly_in_free(in, 0);
David Sedlák8f7a1172019-06-20 14:42:18 +020087
88 if (name - start == (long int)name_len) {
David Sedlákc1771b12019-07-10 15:55:46 +020089 /* this is done because of collision in yang statement value and yang argument mapped to yin element value */
Michal Vasko63f3d842020-07-08 10:10:14 +020090 if (kw == LY_STMT_VALUE && parent == LY_STMT_ERROR_MESSAGE) {
Radek Krejcid6b76452019-09-03 17:03:03 +020091 return LY_STMT_ARG_VALUE;
David Sedlákc1771b12019-07-10 15:55:46 +020092 }
David Sedlák1bccdfa2019-06-17 15:55:27 +020093 return kw;
94 } else {
David Sedlák3ffbc522019-07-02 17:49:28 +020095 if (strncmp(start, "text", name_len) == 0) {
Radek Krejcid6b76452019-09-03 17:03:03 +020096 return LY_STMT_ARG_TEXT;
David Sedlák3ffbc522019-07-02 17:49:28 +020097 } else {
Radek Krejcid6b76452019-09-03 17:03:03 +020098 return LY_STMT_NONE;
David Sedlák3ffbc522019-07-02 17:49:28 +020099 }
David Sedlák1bccdfa2019-06-17 15:55:27 +0200100 }
101}
102
David Sedlákc5b20842019-08-13 10:18:31 +0200103enum yin_argument
David Sedlák060b00e2019-06-19 11:12:06 +0200104yin_match_argument_name(const char *name, size_t len)
David Sedlák3b4db242018-10-19 16:11:01 +0200105{
David Sedlákc5b20842019-08-13 10:18:31 +0200106 enum yin_argument arg = YIN_ARG_UNKNOWN;
David Sedlák872c7b42018-10-26 13:15:20 +0200107 size_t already_read = 0;
David Sedlák7ff55a92019-06-17 11:11:41 +0200108 LY_CHECK_RET(len == 0, YIN_ARG_NONE);
David Sedlák3b4db242018-10-19 16:11:01 +0200109
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200110#define READ_INC(LEN) already_read += LEN
111#define ARG_SET(STMT) arg=STMT
112#define ARG_CHECK(STR, LEN) (!strncmp((name) + already_read, STR, LEN) && (READ_INC(LEN)))
David Sedlákc10e7902018-12-17 02:17:59 +0100113
David Sedlák1c8b2702019-02-22 11:03:02 +0100114 switch (*name) {
David Sedlák94de2aa2019-02-15 12:42:11 +0100115 case 'c':
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200116 READ_INC(1);
117 if (ARG_CHECK("ondition", 8)) {
118 ARG_SET(YIN_ARG_CONDITION);
119 }
David Sedlák3b4db242018-10-19 16:11:01 +0200120 break;
David Sedlák872c7b42018-10-26 13:15:20 +0200121
David Sedlák94de2aa2019-02-15 12:42:11 +0100122 case 'd':
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200123 READ_INC(1);
124 if (ARG_CHECK("ate", 3)) {
125 ARG_SET(YIN_ARG_DATE);
126 }
David Sedlák3b4db242018-10-19 16:11:01 +0200127 break;
David Sedlák872c7b42018-10-26 13:15:20 +0200128
David Sedlák94de2aa2019-02-15 12:42:11 +0100129 case 'm':
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200130 READ_INC(1);
131 if (ARG_CHECK("odule", 5)) {
132 ARG_SET(YIN_ARG_MODULE);
133 }
David Sedlák872c7b42018-10-26 13:15:20 +0200134 break;
135
David Sedlák94de2aa2019-02-15 12:42:11 +0100136 case 'n':
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200137 READ_INC(1);
138 if (ARG_CHECK("ame", 3)) {
139 ARG_SET(YIN_ARG_NAME);
140 }
David Sedlák872c7b42018-10-26 13:15:20 +0200141 break;
142
David Sedlák94de2aa2019-02-15 12:42:11 +0100143 case 't':
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200144 READ_INC(1);
145 if (ARG_CHECK("a", 1)) {
146 if (ARG_CHECK("g", 1)) {
147 ARG_SET(YIN_ARG_TAG);
148 } else if (ARG_CHECK("rget-node", 9)) {
149 ARG_SET(YIN_ARG_TARGET_NODE);
150 }
151 } else if (ARG_CHECK("ext", 3)) {
152 ARG_SET(YIN_ARG_TEXT);
153 }
David Sedlák3b4db242018-10-19 16:11:01 +0200154 break;
David Sedlák872c7b42018-10-26 13:15:20 +0200155
David Sedlák94de2aa2019-02-15 12:42:11 +0100156 case 'u':
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200157 READ_INC(1);
158 if (ARG_CHECK("ri", 2)) {
159 ARG_SET(YIN_ARG_URI);
160 }
David Sedlák3b4db242018-10-19 16:11:01 +0200161 break;
David Sedlák872c7b42018-10-26 13:15:20 +0200162
David Sedlák94de2aa2019-02-15 12:42:11 +0100163 case 'v':
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200164 READ_INC(1);
165 if (ARG_CHECK("alue", 4)) {
166 ARG_SET(YIN_ARG_VALUE);
167 }
David Sedlák3b4db242018-10-19 16:11:01 +0200168 break;
169 }
170
David Sedlákc10e7902018-12-17 02:17:59 +0100171 /* whole argument must be matched */
David Sedlák872c7b42018-10-26 13:15:20 +0200172 if (already_read != len) {
David Sedláka7406952019-04-05 10:33:07 +0200173 arg = YIN_ARG_UNKNOWN;
David Sedlák872c7b42018-10-26 13:15:20 +0200174 }
175
Radek Krejci8bb8d9d2020-08-21 14:53:27 +0200176#undef ARG_CHECK
177#undef ARG_SET
178#undef READ_INC
David Sedlák18730132019-03-15 15:51:34 +0100179
David Sedlák872c7b42018-10-26 13:15:20 +0200180 return arg;
David Sedlák3b4db242018-10-19 16:11:01 +0200181}
182
Radek Krejcid6b76452019-09-03 17:03:03 +0200183#define IS_NODE_ELEM(kw) (kw == LY_STMT_ANYXML || kw == LY_STMT_ANYDATA || kw == LY_STMT_LEAF || kw == LY_STMT_LEAF_LIST || \
184 kw == LY_STMT_TYPEDEF || kw == LY_STMT_USES || kw == LY_STMT_LIST || kw == LY_STMT_NOTIFICATION || \
185 kw == LY_STMT_GROUPING || kw == LY_STMT_CONTAINER || kw == LY_STMT_CASE || kw == LY_STMT_CHOICE || \
186 kw == LY_STMT_ACTION || kw == LY_STMT_RPC || kw == LY_STMT_AUGMENT)
David Sedlák81497a32019-08-13 16:56:26 +0200187
Radek Krejcid6b76452019-09-03 17:03:03 +0200188#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 +0200189
David Sedlák26ea1432019-08-14 13:42:23 +0200190/**
191 * @brief Free subelems information allocated on heap.
192 *
193 * @param[in] count Size of subelems array.
194 * @param[in] subelems Subelems array to free.
195 */
David Sedlák81497a32019-08-13 16:56:26 +0200196static void
197subelems_deallocator(size_t count, struct yin_subelement *subelems)
198{
Michal Vaskod989ba02020-08-24 10:59:24 +0200199 for (size_t i = 0; i < count; ++i) {
David Sedlák81497a32019-08-13 16:56:26 +0200200 if (HAS_META(subelems[i].type)) {
201 free(subelems[i].dest);
202 }
203 }
204
205 free(subelems);
206}
207
David Sedlák26ea1432019-08-14 13:42:23 +0200208/**
209 * @brief Allocate subelems information on heap.
210 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200211 * @param[in] ctx YIN parser context, used for logging.
David Sedlák26ea1432019-08-14 13:42:23 +0200212 * @param[in] count Number of subelements.
213 * @param[in] parent Parent node if any.
214 * @param[out] result Allocated subelems array.
215 *
216 * @return LY_SUCCESS on success LY_EMEM on memmory allocation failure.
217 */
David Sedlák81497a32019-08-13 16:56:26 +0200218static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100219subelems_allocator(struct lys_yin_parser_ctx *ctx, size_t count, struct lysp_node *parent,
Radek Krejci0f969882020-08-21 16:56:47 +0200220 struct yin_subelement **result, ...)
David Sedlák81497a32019-08-13 16:56:26 +0200221{
222 va_list ap;
223
224 *result = calloc(count, sizeof **result);
David Sedlákbf8a2b72019-08-14 16:48:10 +0200225 LY_CHECK_GOTO(!(*result), mem_err);
David Sedlák81497a32019-08-13 16:56:26 +0200226
227 va_start(ap, result);
228 for (size_t i = 0; i < count; ++i) {
229 /* TYPE */
Radek Krejcid6b76452019-09-03 17:03:03 +0200230 (*result)[i].type = va_arg(ap, enum ly_stmt);
David Sedlák81497a32019-08-13 16:56:26 +0200231 /* DEST */
232 if (IS_NODE_ELEM((*result)[i].type)) {
233 struct tree_node_meta *node_meta = NULL;
234 node_meta = calloc(1, sizeof *node_meta);
David Sedlákbf8a2b72019-08-14 16:48:10 +0200235 LY_CHECK_GOTO(!node_meta, mem_err);
David Sedlák81497a32019-08-13 16:56:26 +0200236 node_meta->parent = parent;
David Sedlákbf8a2b72019-08-14 16:48:10 +0200237 node_meta->nodes = va_arg(ap, void *);
David Sedlák81497a32019-08-13 16:56:26 +0200238 (*result)[i].dest = node_meta;
Radek Krejcid6b76452019-09-03 17:03:03 +0200239 } else if ((*result)[i].type == LY_STMT_IMPORT) {
David Sedlák81497a32019-08-13 16:56:26 +0200240 struct import_meta *imp_meta = NULL;
241 imp_meta = calloc(1, sizeof *imp_meta);
David Sedlákbf8a2b72019-08-14 16:48:10 +0200242 LY_CHECK_GOTO(!imp_meta, mem_err);
David Sedlák81497a32019-08-13 16:56:26 +0200243 imp_meta->prefix = va_arg(ap, const char *);
244 imp_meta->imports = va_arg(ap, struct lysp_import **);
245 (*result)[i].dest = imp_meta;
Radek Krejcid6b76452019-09-03 17:03:03 +0200246 } else if ((*result)[i].type == LY_STMT_INCLUDE) {
David Sedlák81497a32019-08-13 16:56:26 +0200247 struct include_meta *inc_meta = NULL;
248 inc_meta = calloc(1, sizeof *inc_meta);
David Sedlákbf8a2b72019-08-14 16:48:10 +0200249 LY_CHECK_GOTO(!inc_meta, mem_err);
David Sedlák81497a32019-08-13 16:56:26 +0200250 inc_meta->name = va_arg(ap, const char *);
251 inc_meta->includes = va_arg(ap, struct lysp_include **);
252 (*result)[i].dest = inc_meta;
Radek Krejcid6b76452019-09-03 17:03:03 +0200253 } else if ((*result)[i].type == LY_STMT_INPUT || (*result)[i].type == LY_STMT_OUTPUT) {
David Sedlák81497a32019-08-13 16:56:26 +0200254 struct inout_meta *inout_meta = NULL;
255 inout_meta = calloc(1, sizeof *inout_meta);
David Sedlákbf8a2b72019-08-14 16:48:10 +0200256 LY_CHECK_GOTO(!inout_meta, mem_err);
David Sedlák81497a32019-08-13 16:56:26 +0200257 inout_meta->parent = parent;
258 inout_meta->inout_p = va_arg(ap, struct lysp_action_inout *);
259 (*result)[i].dest = inout_meta;
260 } else {
261 (*result)[i].dest = va_arg(ap, void *);
262 }
263 /* FLAGS */
264 (*result)[i].flags = va_arg(ap, int);
265 }
266 va_end(ap);
267
268 return LY_SUCCESS;
269
David Sedlákbf8a2b72019-08-14 16:48:10 +0200270mem_err:
David Sedlák81497a32019-08-13 16:56:26 +0200271 subelems_deallocator(count, *result);
Michal Vaskob36053d2020-03-26 15:49:30 +0100272 LOGMEM(ctx->xmlctx->ctx);
David Sedlák81497a32019-08-13 16:56:26 +0200273 return LY_EMEM;
274}
275
David Sedlák8f7a1172019-06-20 14:42:18 +0200276LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100277yin_validate_value(struct lys_yin_parser_ctx *ctx, enum yang_arg val_type)
David Sedlák4a650532019-07-10 11:55:18 +0200278{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200279 uint8_t prefix = 0;
280 uint32_t c;
Michal Vaskob36053d2020-03-26 15:49:30 +0100281 size_t utf8_char_len, already_read = 0;
282 const char *val;
283
284 assert((ctx->xmlctx->status == LYXML_ELEM_CONTENT) || (ctx->xmlctx->status == LYXML_ATTR_CONTENT));
285
286 val = ctx->xmlctx->value;
287 while (already_read < ctx->xmlctx->value_len) {
David Sedlák4a650532019-07-10 11:55:18 +0200288 LY_CHECK_ERR_RET(ly_getutf8((const char **)&val, &c, &utf8_char_len),
289 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INCHAR, (val)[-utf8_char_len]), LY_EVALID);
290 already_read += utf8_char_len;
Michal Vaskob36053d2020-03-26 15:49:30 +0100291 LY_CHECK_ERR_RET(already_read > ctx->xmlctx->value_len, LOGINT(ctx->xmlctx->ctx), LY_EINT);
David Sedlák4a650532019-07-10 11:55:18 +0200292
293 switch (val_type) {
294 case Y_IDENTIF_ARG:
Radek Krejci1deb5be2020-08-26 16:43:36 +0200295 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 +0200296 break;
297 case Y_PREF_IDENTIF_ARG:
Radek Krejci1deb5be2020-08-26 16:43:36 +0200298 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 +0200299 break;
300 case Y_STR_ARG:
301 case Y_MAYBE_STR_ARG:
302 LY_CHECK_RET(lysp_check_stringchar((struct lys_parser_ctx *)ctx, c));
303 break;
304 }
305 }
306
307 return LY_SUCCESS;
308}
309
David Sedlákb4e44562019-07-04 15:42:12 +0200310/**
Michal Vaskob36053d2020-03-26 15:49:30 +0100311 * @brief Parse yin attributes.
David Sedlákb4e44562019-07-04 15:42:12 +0200312 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200313 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák4a650532019-07-10 11:55:18 +0200314 * @param[in] arg_type Type of argument that is expected in parsed element (use YIN_ARG_NONE for elements without
315 * special argument).
David Sedlákbf8a2b72019-08-14 16:48:10 +0200316 * @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 +0200317 * @param[in] val_type Type of expected value of attribute.
David Sedlákb4e44562019-07-04 15:42:12 +0200318 * @param[in] current_element Identification of current element, used for logging.
319 *
320 * @return LY_ERR values.
321 */
322static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100323yin_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 +0200324 enum ly_stmt current_element)
David Sedlák8f7a1172019-06-20 14:42:18 +0200325{
David Sedlákc5b20842019-08-13 10:18:31 +0200326 enum yin_argument arg = YIN_ARG_UNKNOWN;
David Sedlák619db942019-07-03 14:47:30 +0200327 bool found = false;
David Sedlák8f7a1172019-06-20 14:42:18 +0200328
David Sedlák1bccdfa2019-06-17 15:55:27 +0200329 /* validation of attributes */
Michal Vaskob36053d2020-03-26 15:49:30 +0100330 while (ctx->xmlctx->status == LYXML_ATTRIBUTE) {
David Sedlák00250342019-06-21 14:19:39 +0200331 /* yin arguments represented as attributes have no namespace, which in this case means no prefix */
Michal Vaskob36053d2020-03-26 15:49:30 +0100332 if (!ctx->xmlctx->prefix) {
333 arg = yin_match_argument_name(ctx->xmlctx->name, ctx->xmlctx->name_len);
David Sedlák7ff55a92019-06-17 11:11:41 +0200334 if (arg == YIN_ARG_NONE) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100335 /* skip it */
336 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
David Sedlák7ff55a92019-06-17 11:11:41 +0200337 } else if (arg == arg_type) {
David Sedlák1538a842019-08-08 15:38:51 +0200338 LY_CHECK_ERR_RET(found, LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_DUP_ATTR,
David Sedlák292763b2019-07-09 11:10:53 +0200339 yin_attr2str(arg), ly_stmt2str(current_element)), LY_EVALID);
David Sedlák619db942019-07-03 14:47:30 +0200340 found = true;
Michal Vaskob36053d2020-03-26 15:49:30 +0100341
342 /* go to value */
343 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
344 LY_CHECK_RET(yin_validate_value(ctx, val_type));
Radek Krejci011e4aa2020-09-04 15:22:31 +0200345 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 +0200346 LY_CHECK_RET(!(*arg_val), LY_EMEM);
David Sedlák2b214ac2019-06-06 16:11:03 +0200347 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100348 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_UNEXP_ATTR, ctx->xmlctx->name_len,
349 ctx->xmlctx->name, ly_stmt2str(current_element));
David Sedlák619db942019-07-03 14:47:30 +0200350 return LY_EVALID;
David Sedláka7406952019-04-05 10:33:07 +0200351 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100352 } else {
353 /* skip it */
354 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
David Sedláka7406952019-04-05 10:33:07 +0200355 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100356
357 /* next attribute */
358 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
David Sedláka7406952019-04-05 10:33:07 +0200359 }
360
David Sedlák292763b2019-07-09 11:10:53 +0200361 /* anything else than Y_MAYBE_STR_ARG is mandatory */
362 if (val_type != Y_MAYBE_STR_ARG && !found) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100363 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LYVE_SYNTAX_YIN, "Missing mandatory attribute %s of %s element.",
364 yin_attr2str(arg_type), ly_stmt2str(current_element));
David Sedlák619db942019-07-03 14:47:30 +0200365 return LY_EVALID;
366 }
367
368 return LY_SUCCESS;
David Sedláka7406952019-04-05 10:33:07 +0200369}
370
David Sedlákd6e56892019-07-01 15:40:24 +0200371/**
Radek Krejci12b1c152019-09-05 16:20:48 +0200372 * @brief Get record with given type.
David Sedlákd6e56892019-07-01 15:40:24 +0200373 *
374 * @param[in] type Type of wanted record.
375 * @param[in] array_size Size of array.
376 * @param[in] array Searched array.
377 *
378 * @return Pointer to desired record on success, NULL if element is not in the array.
379 */
David Sedlákb4e44562019-07-04 15:42:12 +0200380static struct yin_subelement *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200381get_record(enum ly_stmt type, LY_ARRAY_COUNT_TYPE array_size, struct yin_subelement *array)
David Sedlákd6e56892019-07-01 15:40:24 +0200382{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200383 for (LY_ARRAY_COUNT_TYPE u = 0; u < array_size; ++u) {
Radek Krejci12b1c152019-09-05 16:20:48 +0200384 if (array[u].type == type) {
385 return &array[u];
David Sedlákd6e56892019-07-01 15:40:24 +0200386 }
387 }
David Sedlákd6e56892019-07-01 15:40:24 +0200388 return NULL;
389}
390
David Sedlákbba38e52019-07-09 15:20:01 +0200391/**
392 * @brief Helper function to check mandatory constraint of subelement.
393 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200394 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbba38e52019-07-09 15:20:01 +0200395 * @param[in] subelem_info Array of information about subelements.
396 * @param[in] subelem_info_size Size of subelem_info array.
397 * @param[in] current_element Identification of element that is currently being parsed, used for logging.
398 *
399 * @return LY_ERR values.
400 */
401static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100402yin_check_subelem_mandatory_constraint(struct lys_yin_parser_ctx *ctx, struct yin_subelement *subelem_info,
Radek Krejci0f969882020-08-21 16:56:47 +0200403 signed char subelem_info_size, enum ly_stmt current_element)
David Sedlák21f87cd2019-07-03 16:53:23 +0200404{
David Sedlákb0faad82019-07-04 14:28:59 +0200405 for (signed char i = 0; i < subelem_info_size; ++i) {
David Sedlák5545f5d2019-07-11 11:55:16 +0200406 /* if there is element that is mandatory and isn't parsed log error and return LY_EVALID */
Radek Krejci12b1c152019-09-05 16:20:48 +0200407 if ((subelem_info[i].flags & YIN_SUBELEM_MANDATORY) && !(subelem_info[i].flags & YIN_SUBELEM_PARSED)) {
David Sedlák1538a842019-08-08 15:38:51 +0200408 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_MAND_SUBELEM,
David Sedlák555c7202019-07-04 12:14:12 +0200409 ly_stmt2str(subelem_info[i].type), ly_stmt2str(current_element));
David Sedlák21f87cd2019-07-03 16:53:23 +0200410 return LY_EVALID;
411 }
412 }
413
414 return LY_SUCCESS;
415}
416
David Sedlákbba38e52019-07-09 15:20:01 +0200417/**
418 * @brief Helper function to check "first" constraint of subelement.
419 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200420 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbba38e52019-07-09 15:20:01 +0200421 * @param[in] subelem_info Array of information about subelements.
422 * @param[in] subelem_info_size Size of subelem_info array.
423 * @param[in] current_element Identification of element that is currently being parsed, used for logging.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200424 * @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 +0200425 *
426 * @return LY_ERR values.
427 */
428static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100429yin_check_subelem_first_constraint(struct lys_yin_parser_ctx *ctx, struct yin_subelement *subelem_info,
Radek Krejci0f969882020-08-21 16:56:47 +0200430 signed char subelem_info_size, enum ly_stmt current_element,
431 struct yin_subelement *exp_first)
David Sedlák21f87cd2019-07-03 16:53:23 +0200432{
David Sedlákb0faad82019-07-04 14:28:59 +0200433 for (signed char i = 0; i < subelem_info_size; ++i) {
David Sedlák21f87cd2019-07-03 16:53:23 +0200434 if (subelem_info[i].flags & YIN_SUBELEM_PARSED) {
David Sedlák1538a842019-08-08 15:38:51 +0200435 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_FIRT_SUBELEM,
436 ly_stmt2str(exp_first->type), ly_stmt2str(current_element));
David Sedlák21f87cd2019-07-03 16:53:23 +0200437 return LY_EVALID;
438 }
439 }
440
441 return LY_SUCCESS;
442}
443
David Sedlákbba38e52019-07-09 15:20:01 +0200444/**
David Sedlákb4e44562019-07-04 15:42:12 +0200445 * @brief Parse simple element without any special constraints and argument mapped to yin attribute,
446 * for example prefix or namespace element.
David Sedlákd6e56892019-07-01 15:40:24 +0200447 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200448 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákb4e44562019-07-04 15:42:12 +0200449 * @param[in] kw Type of current element.
450 * @param[out] value Where value of attribute should be stored.
451 * @param[in] arg_type Expected type of attribute.
David Sedlák292763b2019-07-09 11:10:53 +0200452 * @param[in] arg_val_type Type of expected value of attribute.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200453 * @param[in,out] exts Extension instances to add to.
David Sedlákd6e56892019-07-01 15:40:24 +0200454 * @return LY_ERR values.
455 */
David Sedlákb4e44562019-07-04 15:42:12 +0200456static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100457yin_parse_simple_element(struct lys_yin_parser_ctx *ctx, enum ly_stmt kw, const char **value,
Radek Krejci0f969882020-08-21 16:56:47 +0200458 enum yin_argument arg_type, enum yang_arg arg_val_type, struct lysp_ext_instance **exts)
David Sedlákb4e44562019-07-04 15:42:12 +0200459{
Michal Vaskob36053d2020-03-26 15:49:30 +0100460 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
461 LY_CHECK_RET(yin_parse_attribute(ctx, arg_type, value, arg_val_type, kw));
David Sedlák968ac342019-07-11 15:17:59 +0200462 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200463 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
464 };
David Sedlákb4e44562019-07-04 15:42:12 +0200465
Michal Vaskob36053d2020-03-26 15:49:30 +0100466 return yin_parse_content(ctx, subelems, 1, kw, NULL, exts);
David Sedlákb4e44562019-07-04 15:42:12 +0200467}
468
469/**
David Sedlák6542aed2019-08-14 10:47:43 +0200470 * @brief Parse path element.
471 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200472 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák6542aed2019-08-14 10:47:43 +0200473 * @param[in] kw Type of current element.
474 * @param[out] type Type structure to store parsed value, flags and extension instances.
David Sedlák6542aed2019-08-14 10:47:43 +0200475 * @return LY_ERR values.
476 */
477static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100478yin_parse_path(struct lys_yin_parser_ctx *ctx, enum ly_stmt kw, struct lysp_type *type)
David Sedlák6542aed2019-08-14 10:47:43 +0200479{
Michal Vasko004d3152020-06-11 19:59:22 +0200480 LY_ERR ret;
481 const char *str_path;
482
483 LY_CHECK_RET(yin_parse_simple_element(ctx, kw, &str_path, YIN_ARG_VALUE, Y_STR_ARG, &type->exts));
Michal Vasko6b26e742020-07-17 15:02:10 +0200484 ret = ly_path_parse(ctx->xmlctx->ctx, NULL, str_path, 0, LY_PATH_BEGIN_EITHER, LY_PATH_LREF_TRUE,
Michal Vasko004d3152020-06-11 19:59:22 +0200485 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_LEAFREF, &type->path);
486 lydict_remove(ctx->xmlctx->ctx, str_path);
487 LY_CHECK_RET(ret);
David Sedlák6542aed2019-08-14 10:47:43 +0200488 type->flags |= LYS_SET_PATH;
489
490 return LY_SUCCESS;
491}
492
493/**
David Sedlákd3983112019-07-12 11:20:56 +0200494 * @brief Parse pattern element.
495 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200496 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200497 * @param[in,out] type Type structure to store parsed value, flags and extension instances.
David Sedlákd3983112019-07-12 11:20:56 +0200498 * @return LY_ERR values.
499 */
500static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100501yin_parse_pattern(struct lys_yin_parser_ctx *ctx, struct lysp_type *type)
David Sedlákd3983112019-07-12 11:20:56 +0200502{
503 const char *real_value = NULL;
504 char *saved_value = NULL;
505 struct lysp_restr *restr;
506
Michal Vaskob36053d2020-03-26 15:49:30 +0100507 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, type->patterns, restr, LY_EMEM);
508 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
509 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 +0200510 size_t len = strlen(real_value);
511
512 saved_value = malloc(len + 2);
Michal Vaskob36053d2020-03-26 15:49:30 +0100513 LY_CHECK_ERR_RET(!saved_value, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
David Sedlákd3983112019-07-12 11:20:56 +0200514 memmove(saved_value + 1, real_value, len);
Michal Vaskob36053d2020-03-26 15:49:30 +0100515 FREE_STRING(ctx->xmlctx->ctx, real_value);
David Sedlákd3983112019-07-12 11:20:56 +0200516 saved_value[0] = 0x06;
517 saved_value[len + 1] = '\0';
Michal Vasko7f45cf22020-10-01 12:49:44 +0200518 LY_CHECK_RET(lydict_insert_zc(ctx->xmlctx->ctx, saved_value, &restr->arg.str));
519 restr->arg.mod = ctx->main_mod;
David Sedlákd3983112019-07-12 11:20:56 +0200520 type->flags |= LYS_SET_PATTERN;
521
522 struct yin_subelement subelems[6] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200523 {LY_STMT_DESCRIPTION, &restr->dsc, YIN_SUBELEM_UNIQUE},
524 {LY_STMT_ERROR_APP_TAG, &restr->eapptag, YIN_SUBELEM_UNIQUE},
525 {LY_STMT_ERROR_MESSAGE, &restr->emsg, YIN_SUBELEM_UNIQUE},
526 {LY_STMT_MODIFIER, &restr->arg, YIN_SUBELEM_UNIQUE},
527 {LY_STMT_REFERENCE, &restr->ref, YIN_SUBELEM_UNIQUE},
528 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
529 };
Michal Vaskob36053d2020-03-26 15:49:30 +0100530 return yin_parse_content(ctx, subelems, 6, LY_STMT_PATTERN, NULL, &restr->exts);
David Sedlákd3983112019-07-12 11:20:56 +0200531}
532
David Sedlákc5b20842019-08-13 10:18:31 +0200533/**
534 * @brief Parse fraction-digits element.
535 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200536 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákc5b20842019-08-13 10:18:31 +0200537 * @param[in,out] type Type structure to store value, flags and extension instances.
David Sedlákc5b20842019-08-13 10:18:31 +0200538 * @return LY_ERR values.
539 */
David Sedlákf75d55e2019-07-12 16:52:50 +0200540static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100541yin_parse_fracdigits(struct lys_yin_parser_ctx *ctx, struct lysp_type *type)
David Sedlákf75d55e2019-07-12 16:52:50 +0200542{
543 const char *temp_val = NULL;
544 char *ptr;
545 unsigned long int num;
546
Michal Vaskob36053d2020-03-26 15:49:30 +0100547 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
548 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 +0200549
550 if (temp_val[0] == '\0' || (temp_val[0] == '0') || !isdigit(temp_val[0])) {
David Sedlák1538a842019-08-08 15:38:51 +0200551 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", "fraction-digits");
Michal Vaskob36053d2020-03-26 15:49:30 +0100552 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlákf75d55e2019-07-12 16:52:50 +0200553 return LY_EVALID;
554 }
555
556 errno = 0;
557 num = strtoul(temp_val, &ptr, 10);
558 if (*ptr != '\0') {
David Sedlák1538a842019-08-08 15:38:51 +0200559 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", "fraction-digits");
Michal Vaskob36053d2020-03-26 15:49:30 +0100560 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlákf75d55e2019-07-12 16:52:50 +0200561 return LY_EVALID;
562 }
563 if ((errno == ERANGE) || (num > 18)) {
David Sedlák1538a842019-08-08 15:38:51 +0200564 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", "fraction-digits");
Michal Vaskob36053d2020-03-26 15:49:30 +0100565 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlákf75d55e2019-07-12 16:52:50 +0200566 return LY_EVALID;
567 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100568 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlákf75d55e2019-07-12 16:52:50 +0200569 type->fraction_digits = num;
570 type->flags |= LYS_SET_FRDIGITS;
571 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200572 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
573 };
Michal Vaskob36053d2020-03-26 15:49:30 +0100574 return yin_parse_content(ctx, subelems, 1, LY_STMT_FRACTION_DIGITS, NULL, &type->exts);
David Sedlákf75d55e2019-07-12 16:52:50 +0200575}
576
David Sedlák07869a52019-07-12 14:28:19 +0200577/**
David Sedlák43801c92019-08-05 15:58:54 +0200578 * @brief Parse enum element.
David Sedlák07869a52019-07-12 14:28:19 +0200579 *
580 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200581 * @param[in,out] type Type structure to store parsed value, flags and extension instances.
David Sedlák07869a52019-07-12 14:28:19 +0200582 * @return LY_ERR values.
583 */
David Sedlákca36c422019-07-12 12:47:55 +0200584static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100585yin_parse_enum(struct lys_yin_parser_ctx *ctx, struct lysp_type *type)
David Sedlákca36c422019-07-12 12:47:55 +0200586{
David Sedlák07869a52019-07-12 14:28:19 +0200587 struct lysp_type_enum *en;
David Sedlák1e696782019-07-17 15:06:07 +0200588
Michal Vaskob36053d2020-03-26 15:49:30 +0100589 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, type->enums, en, LY_EMEM);
David Sedlák43801c92019-08-05 15:58:54 +0200590 type->flags |= LYS_SET_ENUM;
Michal Vaskob36053d2020-03-26 15:49:30 +0100591 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
592 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 +0200593 LY_CHECK_RET(lysp_check_enum_name((struct lys_parser_ctx *)ctx, en->name, strlen(en->name)));
Michal Vaskob36053d2020-03-26 15:49:30 +0100594 CHECK_NONEMPTY((struct lys_parser_ctx *)ctx, strlen(en->name), "enum");
David Sedlák43801c92019-08-05 15:58:54 +0200595 CHECK_UNIQUENESS((struct lys_parser_ctx *)ctx, type->enums, name, "enum", en->name);
David Sedlákca36c422019-07-12 12:47:55 +0200596
597 struct yin_subelement subelems[6] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200598 {LY_STMT_DESCRIPTION, &en->dsc, YIN_SUBELEM_UNIQUE},
599 {LY_STMT_IF_FEATURE, &en->iffeatures, 0},
600 {LY_STMT_REFERENCE, &en->ref, YIN_SUBELEM_UNIQUE},
601 {LY_STMT_STATUS, &en->flags, YIN_SUBELEM_UNIQUE},
602 {LY_STMT_VALUE, en, YIN_SUBELEM_UNIQUE},
603 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
604 };
Michal Vaskob36053d2020-03-26 15:49:30 +0100605 return yin_parse_content(ctx, subelems, 6, LY_STMT_ENUM, NULL, &en->exts);
David Sedlák43801c92019-08-05 15:58:54 +0200606}
607
608/**
609 * @brief Parse bit element.
610 *
611 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200612 * @param[in,out] type Type structure to store parsed value, flags and extension instances.
David Sedlák43801c92019-08-05 15:58:54 +0200613 * @return LY_ERR values.
614 */
615static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100616yin_parse_bit(struct lys_yin_parser_ctx *ctx, struct lysp_type *type)
David Sedlák43801c92019-08-05 15:58:54 +0200617{
618 struct lysp_type_enum *en;
619
Michal Vaskob36053d2020-03-26 15:49:30 +0100620 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, type->bits, en, LY_EMEM);
David Sedlák43801c92019-08-05 15:58:54 +0200621 type->flags |= LYS_SET_BIT;
Michal Vaskob36053d2020-03-26 15:49:30 +0100622 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
623 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &en->name, Y_IDENTIF_ARG, LY_STMT_BIT));
David Sedlák43801c92019-08-05 15:58:54 +0200624 CHECK_UNIQUENESS((struct lys_parser_ctx *)ctx, type->enums, name, "bit", en->name);
625
626 struct yin_subelement subelems[6] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200627 {LY_STMT_DESCRIPTION, &en->dsc, YIN_SUBELEM_UNIQUE},
628 {LY_STMT_IF_FEATURE, &en->iffeatures, 0},
629 {LY_STMT_POSITION, en, YIN_SUBELEM_UNIQUE},
630 {LY_STMT_REFERENCE, &en->ref, YIN_SUBELEM_UNIQUE},
631 {LY_STMT_STATUS, &en->flags, YIN_SUBELEM_UNIQUE},
632 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
633 };
Michal Vaskob36053d2020-03-26 15:49:30 +0100634 return yin_parse_content(ctx, subelems, 6, LY_STMT_BIT, NULL, &en->exts);
David Sedlákca36c422019-07-12 12:47:55 +0200635}
636
David Sedlákd3983112019-07-12 11:20:56 +0200637/**
David Sedlák5f8191e2019-07-08 16:35:52 +0200638 * @brief Parse simple element without any special constraints and argument mapped to yin attribute, that can have
639 * more instances, such as base or if-feature.
640 *
641 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák5f8191e2019-07-08 16:35:52 +0200642 * @param[in] kw Type of current element.
643 * @param[out] values Parsed values to add to.
644 * @param[in] arg_type Expected type of attribute.
David Sedlák292763b2019-07-09 11:10:53 +0200645 * @param[in] arg_val_type Type of expected value of attribute.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200646 * @param[in,out] exts Extension instances to add to.
David Sedlák5f8191e2019-07-08 16:35:52 +0200647 * @return LY_ERR values.
648 */
649static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100650yin_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 +0200651 enum yang_arg arg_val_type, struct lysp_ext_instance **exts)
David Sedlák5f8191e2019-07-08 16:35:52 +0200652{
653 const char **value;
Michal Vaskob36053d2020-03-26 15:49:30 +0100654 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *values, value, LY_EMEM);
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200655 LY_ARRAY_COUNT_TYPE index = LY_ARRAY_COUNT(*values) - 1;
David Sedlák968ac342019-07-11 15:17:59 +0200656 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200657 {LY_STMT_EXTENSION_INSTANCE, &index, 0}
658 };
David Sedlák968ac342019-07-11 15:17:59 +0200659
Michal Vaskob36053d2020-03-26 15:49:30 +0100660 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
661 LY_CHECK_RET(yin_parse_attribute(ctx, arg_type, value, arg_val_type, kw));
David Sedlák5f8191e2019-07-08 16:35:52 +0200662
Michal Vaskob36053d2020-03-26 15:49:30 +0100663 return yin_parse_content(ctx, subelems, 1, kw, NULL, exts);
David Sedlák5f8191e2019-07-08 16:35:52 +0200664}
665
666/**
David Sedlák6542aed2019-08-14 10:47:43 +0200667 * @brief Parse simple element without any special constraints and argument mapped to yin attribute.
668 *
669 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák6542aed2019-08-14 10:47:43 +0200670 * @param[in] kw Type of current element.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200671 * @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 +0200672 * @param[in] arg_type Expected type of attribute.
673 * @param[in] arg_val_type Type of expected value of attribute.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200674 * @param[in,out] exts Extension instances to add to.
David Sedlák6542aed2019-08-14 10:47:43 +0200675 * @return LY_ERR values.
676 */
677static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100678yin_parse_simple_elem(struct lys_yin_parser_ctx *ctx, enum ly_stmt kw, struct yin_subelement *subinfo,
Radek Krejci0f969882020-08-21 16:56:47 +0200679 enum yin_argument arg_type, enum yang_arg arg_val_type, struct lysp_ext_instance **exts)
David Sedlák6542aed2019-08-14 10:47:43 +0200680{
681 if (subinfo->flags & YIN_SUBELEM_UNIQUE) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100682 LY_CHECK_RET(yin_parse_simple_element(ctx, kw, (const char **)subinfo->dest,
David Sedlák6542aed2019-08-14 10:47:43 +0200683 arg_type, arg_val_type, exts));
684 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100685 LY_CHECK_RET(yin_parse_simple_elements(ctx, kw, (const char ***)subinfo->dest,
David Sedlák6542aed2019-08-14 10:47:43 +0200686 arg_type, arg_val_type, exts));
687 }
688
689 return LY_SUCCESS;
690}
691
692/**
693 * @brief Parse base element.
694 *
695 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák6542aed2019-08-14 10:47:43 +0200696 * @param[in] parent Identification of parent element.
697 * @param[out] dest Where parsed values should be stored.
David Sedlákbf8a2b72019-08-14 16:48:10 +0200698 * @param[in,out] exts Extension instances to add to.
David Sedlák6542aed2019-08-14 10:47:43 +0200699 * @return LY_ERR values.
700 */
701static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100702yin_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 +0200703{
704 struct lysp_type *type = NULL;
705
Radek Krejcid6b76452019-09-03 17:03:03 +0200706 if (parent == LY_STMT_TYPE) {
David Sedlák6542aed2019-08-14 10:47:43 +0200707 type = (struct lysp_type *)dest;
Michal Vaskob36053d2020-03-26 15:49:30 +0100708 LY_CHECK_RET(yin_parse_simple_elements(ctx, LY_STMT_BASE, &type->bases, YIN_ARG_NAME,
David Sedlák6542aed2019-08-14 10:47:43 +0200709 Y_PREF_IDENTIF_ARG, exts));
710 type->flags |= LYS_SET_BASE;
Radek Krejcid6b76452019-09-03 17:03:03 +0200711 } else if (parent == LY_STMT_IDENTITY) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100712 LY_CHECK_RET(yin_parse_simple_elements(ctx, LY_STMT_BASE, (const char ***)dest,
David Sedlák6542aed2019-08-14 10:47:43 +0200713 YIN_ARG_NAME, Y_PREF_IDENTIF_ARG, exts));
714 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100715 LOGINT(ctx->xmlctx->ctx);
David Sedlák6542aed2019-08-14 10:47:43 +0200716 return LY_EINT;
717 }
718
719 return LY_SUCCESS;
720}
721
722/**
David Sedlákbf8a2b72019-08-14 16:48:10 +0200723 * @brief Parse require-instance element.
David Sedlákcf5569a2019-07-11 13:31:34 +0200724 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200725 * @param[in,out] ctx YIN parser context for logging and to store current state.
Michal Vaskob36053d2020-03-26 15:49:30 +0100726 * @param[out] type Type structure to store value, flag and extensions.
David Sedlákcf5569a2019-07-11 13:31:34 +0200727 * @return LY_ERR values.
728 */
729static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100730yin_pasrse_reqinstance(struct lys_yin_parser_ctx *ctx, struct lysp_type *type)
David Sedlákcf5569a2019-07-11 13:31:34 +0200731{
732 const char *temp_val = NULL;
David Sedlák968ac342019-07-11 15:17:59 +0200733 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200734 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
735 };
David Sedlákcf5569a2019-07-11 13:31:34 +0200736
737 type->flags |= LYS_SET_REQINST;
Michal Vaskob36053d2020-03-26 15:49:30 +0100738 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
739 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 +0200740 if (strcmp(temp_val, "true") == 0) {
741 type->require_instance = 1;
742 } else if (strcmp(temp_val, "false") != 0) {
David Sedlák26ea1432019-08-14 13:42:23 +0200743 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS2, temp_val, "value",
744 "require-instance", "true", "false");
Michal Vaskob36053d2020-03-26 15:49:30 +0100745 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlákcf5569a2019-07-11 13:31:34 +0200746 return LY_EVALID;
747 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100748 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlákcf5569a2019-07-11 13:31:34 +0200749
Michal Vaskob36053d2020-03-26 15:49:30 +0100750 return yin_parse_content(ctx, subelems, 1, LY_STMT_REQUIRE_INSTANCE, NULL, &type->exts);
David Sedlákcf5569a2019-07-11 13:31:34 +0200751}
752
753/**
David Sedlákce77bf52019-07-11 16:59:31 +0200754 * @brief Parse modifier element.
755 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200756 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákce77bf52019-07-11 16:59:31 +0200757 * @param[in,out] pat Value to write to.
758 * @param[in,out] exts Extension instances to add to.
759 *
760 * @return LY_ERR values.
761 */
762static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100763yin_parse_modifier(struct lys_yin_parser_ctx *ctx, const char **pat, struct lysp_ext_instance **exts)
David Sedlákce77bf52019-07-11 16:59:31 +0200764{
David Sedlákd3983112019-07-12 11:20:56 +0200765 assert(**pat == 0x06);
David Sedlákce77bf52019-07-11 16:59:31 +0200766 const char *temp_val;
767 char *modified_val;
768 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200769 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
770 };
David Sedlákce77bf52019-07-11 16:59:31 +0200771
Michal Vaskob36053d2020-03-26 15:49:30 +0100772 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
773 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 +0200774 if (strcmp(temp_val, "invert-match") != 0) {
David Sedlák26ea1432019-08-14 13:42:23 +0200775 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS1, temp_val, "value",
776 "modifier", "invert-match");
Michal Vaskob36053d2020-03-26 15:49:30 +0100777 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlákce77bf52019-07-11 16:59:31 +0200778 return LY_EVALID;
779 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100780 lydict_remove(ctx->xmlctx->ctx, temp_val);
David Sedlákce77bf52019-07-11 16:59:31 +0200781
782 /* allocate new value */
David Sedlákd3983112019-07-12 11:20:56 +0200783 modified_val = malloc(strlen(*pat) + 1);
Michal Vaskob36053d2020-03-26 15:49:30 +0100784 LY_CHECK_ERR_RET(!modified_val, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
David Sedlákd3983112019-07-12 11:20:56 +0200785 strcpy(modified_val, *pat);
Michal Vaskob36053d2020-03-26 15:49:30 +0100786 lydict_remove(ctx->xmlctx->ctx, *pat);
David Sedlákce77bf52019-07-11 16:59:31 +0200787
788 /* modify the new value */
789 modified_val[0] = 0x15;
Radek Krejci011e4aa2020-09-04 15:22:31 +0200790 LY_CHECK_RET(lydict_insert_zc(ctx->xmlctx->ctx, modified_val, pat));
David Sedlákce77bf52019-07-11 16:59:31 +0200791
Michal Vaskob36053d2020-03-26 15:49:30 +0100792 return yin_parse_content(ctx, subelems, 1, LY_STMT_MODIFIER, NULL, exts);
David Sedlákce77bf52019-07-11 16:59:31 +0200793}
794
795/**
David Sedlákb7296dd2019-07-11 14:58:38 +0200796 * @brief Parse a restriction element (length, range or one instance of must).
797 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200798 * @param[in,out] ctx YIN parser context for logging and to store current state.
Radek Krejcid6b76452019-09-03 17:03:03 +0200799 * @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 +0200800 * @param[in] restr Value to write to.
David Sedlákb7296dd2019-07-11 14:58:38 +0200801 */
802static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100803yin_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 +0200804{
Radek Krejcid6b76452019-09-03 17:03:03 +0200805 assert(restr_kw == LY_STMT_MUST || restr_kw == LY_STMT_LENGTH || restr_kw == LY_STMT_RANGE);
David Sedlákb7296dd2019-07-11 14:58:38 +0200806 struct yin_subelement subelems[5] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200807 {LY_STMT_DESCRIPTION, &restr->dsc, YIN_SUBELEM_UNIQUE},
808 {LY_STMT_ERROR_APP_TAG, &restr->eapptag, YIN_SUBELEM_UNIQUE},
809 {LY_STMT_ERROR_MESSAGE, &restr->emsg, YIN_SUBELEM_UNIQUE},
810 {LY_STMT_REFERENCE, &restr->ref, YIN_SUBELEM_UNIQUE},
811 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
812 };
David Sedlákb7296dd2019-07-11 14:58:38 +0200813 /* argument of must is called condition, but argument of length and range is called value */
Radek Krejcid6b76452019-09-03 17:03:03 +0200814 enum yin_argument arg_type = (restr_kw == LY_STMT_MUST) ? YIN_ARG_CONDITION : YIN_ARG_VALUE;
David Sedlákb7296dd2019-07-11 14:58:38 +0200815
Michal Vaskob36053d2020-03-26 15:49:30 +0100816 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
Michal Vasko7f45cf22020-10-01 12:49:44 +0200817 LY_CHECK_RET(yin_parse_attribute(ctx, arg_type, &restr->arg.str, Y_STR_ARG, restr_kw));
818 restr->arg.mod = ctx->main_mod;
Michal Vaskob36053d2020-03-26 15:49:30 +0100819
820 return yin_parse_content(ctx, subelems, 5, restr_kw, NULL, &restr->exts);
David Sedlákb7296dd2019-07-11 14:58:38 +0200821}
822
823/**
David Sedlák6542aed2019-08-14 10:47:43 +0200824 * @brief Parse range element.
825 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200826 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák6542aed2019-08-14 10:47:43 +0200827 * @param[out] type Type structure to store parsed value and flags.
828 *
829 * @return LY_ERR values.
830 */
831static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100832yin_parse_range(struct lys_yin_parser_ctx *ctx, struct lysp_type *type)
David Sedlák6542aed2019-08-14 10:47:43 +0200833{
834 type->range = calloc(1, sizeof *type->range);
Michal Vaskob36053d2020-03-26 15:49:30 +0100835 LY_CHECK_ERR_RET(!type->range, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
836 LY_CHECK_RET(yin_parse_restriction(ctx, LY_STMT_RANGE, type->range));
Michal Vasko44f3d2c2020-08-24 09:49:38 +0200837 type->flags |= LYS_SET_RANGE;
David Sedlák6542aed2019-08-14 10:47:43 +0200838
839 return LY_SUCCESS;
840}
841
842/**
843 * @brief Parse length element.
844 *
David Sedlákbf8a2b72019-08-14 16:48:10 +0200845 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák6542aed2019-08-14 10:47:43 +0200846 * @param[out] type Type structure to store parsed value and flags.
847 *
848 * @return LY_ERR values.
849 */
850static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100851yin_parse_length(struct lys_yin_parser_ctx *ctx, struct lysp_type *type)
David Sedlák6542aed2019-08-14 10:47:43 +0200852{
853 type->length = calloc(1, sizeof *type->length);
Michal Vaskob36053d2020-03-26 15:49:30 +0100854 LY_CHECK_ERR_RET(!type->length, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
855 LY_CHECK_RET(yin_parse_restriction(ctx, LY_STMT_LENGTH, type->length));
David Sedlák6542aed2019-08-14 10:47:43 +0200856 type->flags |= LYS_SET_LENGTH;
857
858 return LY_SUCCESS;
859}
860
861/**
David Sedlákbc9ec9c2019-07-11 15:53:55 +0200862 * @brief Parse must element.
863 *
864 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbc9ec9c2019-07-11 15:53:55 +0200865 * @param[in,out] restrs Restrictions to add to.
866 *
867 * @return LY_ERR values.
868 */
869static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100870yin_parse_must(struct lys_yin_parser_ctx *ctx, struct lysp_restr **restrs)
David Sedlákbc9ec9c2019-07-11 15:53:55 +0200871{
872 struct lysp_restr *restr;
873
Michal Vaskob36053d2020-03-26 15:49:30 +0100874 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *restrs, restr, LY_EMEM);
875 return yin_parse_restriction(ctx, LY_STMT_MUST, restr);
David Sedlákbc9ec9c2019-07-11 15:53:55 +0200876}
877
878/**
Michal Vasko7f45cf22020-10-01 12:49:44 +0200879 * @brief Parse a node id into an array.
880 *
881 * @param[in,out] ctx YIN parser context for logging and to store current state.
882 * @param[in] kw Type of current element.
883 * @param[in] subinfo Information about subelement, is used to determin which function should be called and where to store parsed value.
884 * @param[in,out] exts Extension instances to add to.
885 *
886 * @return LY_ERR values.
887 */
888static LY_ERR
889yin_parse_qname(struct lys_yin_parser_ctx *ctx, enum ly_stmt kw, struct yin_subelement *subinfo,
890 struct lysp_ext_instance **exts)
891{
892 struct lysp_qname *qname, **qnames;
893
894 switch (kw) {
895 case LY_STMT_DEFAULT:
896 if (subinfo->flags & YIN_SUBELEM_TEXT) {
897 if (subinfo->flags & YIN_SUBELEM_UNIQUE) {
898 return yin_parse_simple_element(ctx, kw, (const char **)subinfo->dest, YIN_ARG_VALUE, Y_STR_ARG, exts);
899 } else {
900 return yin_parse_simple_elements(ctx, kw, (const char ***)subinfo->dest, YIN_ARG_VALUE, Y_STR_ARG, exts);
901 }
902 } else {
903 if (subinfo->flags & YIN_SUBELEM_UNIQUE) {
904 qname = (struct lysp_qname *)subinfo->dest;
905 } else {
906 qnames = (struct lysp_qname **)subinfo->dest;
907 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *qnames, qname, LY_EMEM);
908 }
909 qname->mod = ctx->main_mod;
910 return yin_parse_simple_element(ctx, kw, &qname->str, YIN_ARG_VALUE, Y_STR_ARG, exts);
911 }
912 case LY_STMT_IF_FEATURE:
913 assert(!(subinfo->flags & YIN_SUBELEM_UNIQUE));
914 if (subinfo->flags & YIN_SUBELEM_TEXT) {
915 return yin_parse_simple_elements(ctx, kw, (const char ***)subinfo->dest, YIN_ARG_NAME, Y_STR_ARG, exts);
916 } else {
917 qnames = (struct lysp_qname **)subinfo->dest;
918 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *qnames, qname, LY_EMEM);
919 qname->mod = ctx->main_mod;
920 return yin_parse_simple_element(ctx, kw, &qname->str, YIN_ARG_NAME, Y_STR_ARG, exts);
921 }
922 default:
923 break;
924 }
925
926 LOGINT(ctx->xmlctx->ctx);
927 return LY_EINT;
928}
929
930/**
David Sedlák5545f5d2019-07-11 11:55:16 +0200931 * @brief Parse position or value element.
932 *
933 * @param[in,out] ctx YIN parser context for logging and to store current state.
Radek Krejcid6b76452019-09-03 17:03:03 +0200934 * @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 +0200935 * @param[out] enm Enum structure to save value, flags and extension instances.
David Sedlák5545f5d2019-07-11 11:55:16 +0200936 *
937 * @return LY_ERR values.
938 */
939static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100940yin_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 +0200941{
Radek Krejcid6b76452019-09-03 17:03:03 +0200942 assert(kw == LY_STMT_POSITION || kw == LY_STMT_VALUE);
David Sedlák5545f5d2019-07-11 11:55:16 +0200943 const char *temp_val = NULL;
944 char *ptr;
Michal Vaskoed4fcfe2020-07-08 10:38:56 +0200945 long int num = 0;
946 unsigned long int unum = 0;
David Sedlák5545f5d2019-07-11 11:55:16 +0200947
948 /* set value flag */
949 enm->flags |= LYS_SET_VALUE;
950
951 /* get attribute value */
Michal Vaskob36053d2020-03-26 15:49:30 +0100952 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
953 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &temp_val, Y_STR_ARG, kw));
David Sedlákae5378f2019-07-17 11:37:59 +0200954 if (!temp_val || temp_val[0] == '\0' || (temp_val[0] == '+') ||
Radek Krejci0f969882020-08-21 16:56:47 +0200955 ((temp_val[0] == '0') && (temp_val[1] != '\0')) || ((kw == LY_STMT_POSITION) && !strcmp(temp_val, "-0"))) {
David Sedlák1538a842019-08-08 15:38:51 +0200956 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 +0200957 goto error;
958 }
959
960 /* convert value */
961 errno = 0;
Radek Krejcid6b76452019-09-03 17:03:03 +0200962 if (kw == LY_STMT_VALUE) {
David Sedlák5545f5d2019-07-11 11:55:16 +0200963 num = strtol(temp_val, &ptr, 10);
964 if (num < INT64_C(-2147483648) || num > INT64_C(2147483647)) {
David Sedlák1538a842019-08-08 15:38:51 +0200965 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 +0200966 goto error;
967 }
968 } else {
969 unum = strtoul(temp_val, &ptr, 10);
970 if (unum > UINT64_C(4294967295)) {
David Sedlák1538a842019-08-08 15:38:51 +0200971 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 +0200972 goto error;
973 }
974 }
975 /* check if whole argument value was converted */
976 if (*ptr != '\0') {
David Sedlák1538a842019-08-08 15:38:51 +0200977 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 +0200978 goto error;
David Sedlák5545f5d2019-07-11 11:55:16 +0200979 }
980 if (errno == ERANGE) {
David Sedlák1538a842019-08-08 15:38:51 +0200981 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 +0200982 goto error;
983 }
984 /* save correctly ternary operator can't be used because num and unum have different signes */
Radek Krejcid6b76452019-09-03 17:03:03 +0200985 if (kw == LY_STMT_VALUE) {
David Sedlák5545f5d2019-07-11 11:55:16 +0200986 enm->value = num;
987 } else {
988 enm->value = unum;
989 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100990 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlák5545f5d2019-07-11 11:55:16 +0200991
992 /* parse subelements */
David Sedlák968ac342019-07-11 15:17:59 +0200993 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +0200994 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
995 };
Michal Vaskob36053d2020-03-26 15:49:30 +0100996 return yin_parse_content(ctx, subelems, 1, kw, NULL, &enm->exts);
David Sedlák5545f5d2019-07-11 11:55:16 +0200997
David Sedlákbf8a2b72019-08-14 16:48:10 +0200998error:
Michal Vaskob36053d2020-03-26 15:49:30 +0100999 FREE_STRING(ctx->xmlctx->ctx, temp_val);
1000 return LY_EVALID;
David Sedlák5545f5d2019-07-11 11:55:16 +02001001}
1002
David Sedlák05404f62019-07-24 14:11:53 +02001003/**
1004 * @brief Parse belongs-to element.
1005 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001006 * @param[in] ctx YIN parser context for logging and to store current state.
David Sedlák05404f62019-07-24 14:11:53 +02001007 * @param[out] submod Structure of submodule that is being parsed.
1008 * @param[in,out] exts Extension instances to add to.
1009 *
1010 * @return LY_ERR values
1011 */
1012static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001013yin_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 +02001014{
1015 struct yin_subelement subelems[2] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001016 {LY_STMT_PREFIX, &submod->prefix, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE},
1017 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1018 };
David Sedlák05404f62019-07-24 14:11:53 +02001019
Michal Vaskob36053d2020-03-26 15:49:30 +01001020 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1021 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_MODULE, &submod->belongsto, Y_IDENTIF_ARG, LY_STMT_BELONGS_TO));
1022
1023 return yin_parse_content(ctx, subelems, 2, LY_STMT_BELONGS_TO, NULL, exts);
David Sedlák05404f62019-07-24 14:11:53 +02001024}
1025
David Sedlák5545f5d2019-07-11 11:55:16 +02001026/**
David Sedlákc1771b12019-07-10 15:55:46 +02001027 * @brief Function to parse meta tags (description, contact, ...) eg. elements with
David Sedlákbf8a2b72019-08-14 16:48:10 +02001028 * text element as child.
David Sedlákb4e44562019-07-04 15:42:12 +02001029 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001030 * @param[in,out] ctx YIN parser context for logging and to store current state.
Radek Krejcid6b76452019-09-03 17:03:03 +02001031 * @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 +02001032 * @param[out] value Where the content of meta element should be stored.
David Sedlákbf8a2b72019-08-14 16:48:10 +02001033 * @param[in,out] exts Extension instances to add to.
David Sedlákb4e44562019-07-04 15:42:12 +02001034 *
1035 * @return LY_ERR values.
1036 */
1037static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001038yin_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 +02001039{
Radek Krejcid6b76452019-09-03 17:03:03 +02001040 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 +02001041
David Sedlák968ac342019-07-11 15:17:59 +02001042 struct yin_subelement subelems[2] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001043 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1044 {LY_STMT_ARG_TEXT, value, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE | YIN_SUBELEM_FIRST}
1045 };
David Sedlákdf2a9732019-08-07 13:23:16 +02001046 /* check attributes */
Michal Vaskob36053d2020-03-26 15:49:30 +01001047 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1048 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 +02001049
David Sedlákdf2a9732019-08-07 13:23:16 +02001050 /* parse content */
Michal Vaskob36053d2020-03-26 15:49:30 +01001051 return yin_parse_content(ctx, subelems, 2, elem_type, NULL, exts);
David Sedlákb4e44562019-07-04 15:42:12 +02001052}
1053
1054/**
David Sedlákc1771b12019-07-10 15:55:46 +02001055 * @brief Parse error-message element.
1056 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001057 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákc1771b12019-07-10 15:55:46 +02001058 * @param[out] value Where the content of error-message element should be stored.
David Sedlákbf8a2b72019-08-14 16:48:10 +02001059 * @param[in,out] exts Extension instances to add to.
David Sedlákc1771b12019-07-10 15:55:46 +02001060 *
1061 * @return LY_ERR values.
1062 */
1063static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001064yin_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 +02001065{
David Sedlák968ac342019-07-11 15:17:59 +02001066 struct yin_subelement subelems[2] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001067 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1068 {LY_STMT_ARG_VALUE, value, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE | YIN_SUBELEM_FIRST}
1069 };
David Sedlákc1771b12019-07-10 15:55:46 +02001070
David Sedlákdf2a9732019-08-07 13:23:16 +02001071 /* check attributes */
Michal Vaskob36053d2020-03-26 15:49:30 +01001072 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1073 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 +02001074
Michal Vaskob36053d2020-03-26 15:49:30 +01001075 return yin_parse_content(ctx, subelems, 2, LY_STMT_ERROR_MESSAGE, NULL, exts);
David Sedlákc1771b12019-07-10 15:55:46 +02001076}
1077
1078/**
David Sedlák6542aed2019-08-14 10:47:43 +02001079 * @brief Parse type element.
David Sedlák374d2b32019-07-17 15:06:55 +02001080 *
1081 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák6542aed2019-08-14 10:47:43 +02001082 * @param[in] parent Identification of parent element.
David Sedlákbf8a2b72019-08-14 16:48:10 +02001083 * @param[in,out] type Type to write to.
David Sedlák374d2b32019-07-17 15:06:55 +02001084 *
1085 * @return LY_ERR values.
1086 */
1087static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001088yin_parse_type(struct lys_yin_parser_ctx *ctx, enum ly_stmt parent, struct yin_subelement *subinfo)
David Sedlák374d2b32019-07-17 15:06:55 +02001089{
David Sedlák6542aed2019-08-14 10:47:43 +02001090 struct lysp_type *type = NULL;
Radek Krejcid6b76452019-09-03 17:03:03 +02001091 if (parent == LY_STMT_DEVIATE) {
David Sedlák6542aed2019-08-14 10:47:43 +02001092 *(struct lysp_type **)subinfo->dest = calloc(1, sizeof **(struct lysp_type **)subinfo->dest);
Michal Vaskob36053d2020-03-26 15:49:30 +01001093 LY_CHECK_ERR_RET(!(*(struct lysp_type **)subinfo->dest), LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
David Sedlák6542aed2019-08-14 10:47:43 +02001094 type = *((struct lysp_type **)subinfo->dest);
Michal Vaskod989ba02020-08-24 10:59:24 +02001095 } else {
David Sedlák6542aed2019-08-14 10:47:43 +02001096 type = (struct lysp_type *)subinfo->dest;
1097 }
1098 /* type as child of another type */
Radek Krejcid6b76452019-09-03 17:03:03 +02001099 if (parent == LY_STMT_TYPE) {
David Sedlák6542aed2019-08-14 10:47:43 +02001100 struct lysp_type *nested_type = NULL;
Michal Vaskob36053d2020-03-26 15:49:30 +01001101 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, type->types, nested_type, LY_EMEM);
David Sedlák6542aed2019-08-14 10:47:43 +02001102 type->flags |= LYS_SET_TYPE;
1103 type = nested_type;
1104 }
David Sedlák374d2b32019-07-17 15:06:55 +02001105 struct yin_subelement subelems[11] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001106 {LY_STMT_BASE, type, 0},
1107 {LY_STMT_BIT, type, 0},
1108 {LY_STMT_ENUM, type, 0},
1109 {LY_STMT_FRACTION_DIGITS, type, YIN_SUBELEM_UNIQUE},
1110 {LY_STMT_LENGTH, type, YIN_SUBELEM_UNIQUE},
1111 {LY_STMT_PATH, type, YIN_SUBELEM_UNIQUE},
1112 {LY_STMT_PATTERN, type, 0},
1113 {LY_STMT_RANGE, type, YIN_SUBELEM_UNIQUE},
1114 {LY_STMT_REQUIRE_INSTANCE, type, YIN_SUBELEM_UNIQUE},
1115 {LY_STMT_TYPE, type},
1116 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1117 };
Michal Vaskob36053d2020-03-26 15:49:30 +01001118
1119 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1120 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &type->name, Y_PREF_IDENTIF_ARG, LY_STMT_TYPE));
1121 return yin_parse_content(ctx, subelems, 11, LY_STMT_TYPE, NULL, &type->exts);
David Sedlák374d2b32019-07-17 15:06:55 +02001122}
1123
David Sedlák1af868e2019-07-17 17:03:14 +02001124/**
1125 * @brief Parse max-elements element.
1126 *
1127 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák1af868e2019-07-17 17:03:14 +02001128 * @param[in,out] max Value to write to.
David Sedláka2dad212019-07-18 12:45:19 +02001129 * @param[in] flags Flags to write to.
David Sedlák1af868e2019-07-17 17:03:14 +02001130 * @param[in,out] exts Extension instances to add to.
1131 *
1132 * @return LY_ERR values.
1133 */
1134static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001135yin_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 +02001136{
1137 const char *temp_val = NULL;
1138 char *ptr;
1139 unsigned long int num;
1140 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001141 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1142 };
David Sedlák374d2b32019-07-17 15:06:55 +02001143
David Sedlák1af868e2019-07-17 17:03:14 +02001144 *flags |= LYS_SET_MAX;
Michal Vaskob36053d2020-03-26 15:49:30 +01001145 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1146 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, &temp_val, Y_STR_ARG, LY_STMT_MAX_ELEMENTS));
David Sedlák1af868e2019-07-17 17:03:14 +02001147 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 +02001148 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", "max-elements");
Michal Vaskob36053d2020-03-26 15:49:30 +01001149 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlák1af868e2019-07-17 17:03:14 +02001150 return LY_EVALID;
1151 }
1152
1153 if (strcmp(temp_val, "unbounded")) {
1154 errno = 0;
1155 num = strtoul(temp_val, &ptr, 10);
1156 if (*ptr != '\0') {
David Sedlák1538a842019-08-08 15:38:51 +02001157 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", "max-elements");
Michal Vaskob36053d2020-03-26 15:49:30 +01001158 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlák1af868e2019-07-17 17:03:14 +02001159 return LY_EVALID;
1160 }
1161 if ((errno == ERANGE) || (num > UINT32_MAX)) {
David Sedlák1538a842019-08-08 15:38:51 +02001162 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_OOB_YIN, temp_val, "value", "max-elements");
Michal Vaskob36053d2020-03-26 15:49:30 +01001163 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlák1af868e2019-07-17 17:03:14 +02001164 return LY_EVALID;
1165 }
1166 *max = num;
1167 }
Michal Vaskob36053d2020-03-26 15:49:30 +01001168 FREE_STRING(ctx->xmlctx->ctx, temp_val);
1169 return yin_parse_content(ctx, subelems, 1, LY_STMT_MAX_ELEMENTS, NULL, exts);
David Sedlák1af868e2019-07-17 17:03:14 +02001170}
David Sedlák374d2b32019-07-17 15:06:55 +02001171
1172/**
David Sedlákbf8a2b72019-08-14 16:48:10 +02001173 * @brief Parse min-elements element.
David Sedlák09e18c92019-07-18 11:17:11 +02001174 *
1175 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák09e18c92019-07-18 11:17:11 +02001176 * @param[in,out] min Value to write to.
David Sedláka2dad212019-07-18 12:45:19 +02001177 * @param[in] flags Flags to write to.
David Sedlák09e18c92019-07-18 11:17:11 +02001178 * @param[in,out] exts Extension instances to add to.
1179 *
1180 * @return LY_ERR values.
1181 */
1182static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001183yin_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 +02001184{
1185 const char *temp_val = NULL;
1186 char *ptr;
1187 unsigned long int num;
1188 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001189 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1190 };
David Sedlák09e18c92019-07-18 11:17:11 +02001191
1192 *flags |= LYS_SET_MIN;
Michal Vaskob36053d2020-03-26 15:49:30 +01001193 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1194 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 +02001195
1196 if (!temp_val || temp_val[0] == '\0' || (temp_val[0] == '0' && temp_val[1] != '\0')) {
David Sedlák1538a842019-08-08 15:38:51 +02001197 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", "min-elements");
Michal Vaskob36053d2020-03-26 15:49:30 +01001198 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlák09e18c92019-07-18 11:17:11 +02001199 return LY_EVALID;
1200 }
1201
1202 errno = 0;
1203 num = strtoul(temp_val, &ptr, 10);
1204 if (ptr[0] != 0) {
David Sedlák1538a842019-08-08 15:38:51 +02001205 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN, temp_val, "value", "min-elements");
Michal Vaskob36053d2020-03-26 15:49:30 +01001206 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlák09e18c92019-07-18 11:17:11 +02001207 return LY_EVALID;
1208 }
1209 if (errno == ERANGE || num > UINT32_MAX) {
David Sedlák1538a842019-08-08 15:38:51 +02001210 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_OOB_YIN, temp_val, "value", "min-elements");
Michal Vaskob36053d2020-03-26 15:49:30 +01001211 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlák09e18c92019-07-18 11:17:11 +02001212 return LY_EVALID;
1213 }
1214 *min = num;
Michal Vaskob36053d2020-03-26 15:49:30 +01001215 FREE_STRING(ctx->xmlctx->ctx, temp_val);
1216 return yin_parse_content(ctx, subelems, 1, LY_STMT_MIN_ELEMENTS, NULL, exts);
David Sedlák09e18c92019-07-18 11:17:11 +02001217}
1218
David Sedláka2dad212019-07-18 12:45:19 +02001219/**
1220 * @brief Parse min-elements or max-elements element.
1221 *
1222 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedláka2dad212019-07-18 12:45:19 +02001223 * @param[in] parent Identification of parent element.
1224 * @param[in] current Identification of current element.
1225 * @param[in] dest Where the parsed value and flags should be stored.
1226 *
1227 * @return LY_ERR values.
1228 */
David Sedlák09e18c92019-07-18 11:17:11 +02001229static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001230yin_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 +02001231{
Radek Krejcid6b76452019-09-03 17:03:03 +02001232 assert(current == LY_STMT_MAX_ELEMENTS || current == LY_STMT_MIN_ELEMENTS);
1233 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 +02001234 uint32_t *lim;
1235 uint16_t *flags;
1236 struct lysp_ext_instance **exts;
1237
Radek Krejcid6b76452019-09-03 17:03:03 +02001238 if (parent == LY_STMT_LEAF_LIST) {
1239 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 +02001240 flags = &((struct lysp_node_leaflist *)dest)->flags;
1241 exts = &((struct lysp_node_leaflist *)dest)->exts;
Radek Krejcid6b76452019-09-03 17:03:03 +02001242 } else if (parent == LY_STMT_REFINE) {
1243 lim = (current == LY_STMT_MAX_ELEMENTS) ? &((struct lysp_refine *)dest)->max : &((struct lysp_refine *)dest)->min;
David Sedlák09e18c92019-07-18 11:17:11 +02001244 flags = &((struct lysp_refine *)dest)->flags;
1245 exts = &((struct lysp_refine *)dest)->exts;
Radek Krejcid6b76452019-09-03 17:03:03 +02001246 } else if (parent == LY_STMT_LIST) {
1247 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 +02001248 flags = &((struct lysp_node_list *)dest)->flags;
1249 exts = &((struct lysp_node_list *)dest)->exts;
David Sedlák4ffcec82019-07-25 15:10:21 +02001250 } else {
1251 lim = ((struct minmax_dev_meta *)dest)->lim;
1252 flags = ((struct minmax_dev_meta *)dest)->flags;
1253 exts = ((struct minmax_dev_meta *)dest)->exts;
David Sedlák09e18c92019-07-18 11:17:11 +02001254 }
1255
Radek Krejcid6b76452019-09-03 17:03:03 +02001256 if (current == LY_STMT_MAX_ELEMENTS) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001257 LY_CHECK_RET(yin_parse_maxelements(ctx, lim, flags, exts));
David Sedlák09e18c92019-07-18 11:17:11 +02001258 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +01001259 LY_CHECK_RET(yin_parse_minelements(ctx, lim, flags, exts));
David Sedlák09e18c92019-07-18 11:17:11 +02001260 }
1261
1262 return LY_SUCCESS;
1263}
1264
1265/**
David Sedlákbf8a2b72019-08-14 16:48:10 +02001266 * @brief Parse ordered-by element.
David Sedláka2dad212019-07-18 12:45:19 +02001267 *
1268 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedláka2dad212019-07-18 12:45:19 +02001269 * @param[out] flags Flags to write to.
David Sedlákbf8a2b72019-08-14 16:48:10 +02001270 * @param[in,out] exts Extension instances to add to.
David Sedláka2dad212019-07-18 12:45:19 +02001271 *
1272 * @return LY_ERR values.
1273 */
1274static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001275yin_parse_orderedby(struct lys_yin_parser_ctx *ctx, uint16_t *flags, struct lysp_ext_instance **exts)
David Sedláka2dad212019-07-18 12:45:19 +02001276{
1277 const char *temp_val;
1278 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001279 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1280 };
David Sedláka2dad212019-07-18 12:45:19 +02001281
Michal Vaskob36053d2020-03-26 15:49:30 +01001282 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1283 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 +02001284 if (strcmp(temp_val, "system") == 0) {
1285 *flags |= LYS_ORDBY_SYSTEM;
1286 } else if (strcmp(temp_val, "user") == 0) {
1287 *flags |= LYS_ORDBY_USER;
1288 } else {
David Sedlák26ea1432019-08-14 13:42:23 +02001289 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS2, temp_val, "value",
1290 "ordered-by", "system", "user");
Michal Vaskob36053d2020-03-26 15:49:30 +01001291 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedláka2dad212019-07-18 12:45:19 +02001292 return LY_EVALID;
1293 }
Michal Vaskob36053d2020-03-26 15:49:30 +01001294 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedláka2dad212019-07-18 12:45:19 +02001295
Michal Vaskob36053d2020-03-26 15:49:30 +01001296 return yin_parse_content(ctx, subelems, 1, LY_STMT_ORDERED_BY, NULL, exts);
David Sedláka2dad212019-07-18 12:45:19 +02001297}
1298
1299/**
David Sedlákbf8a2b72019-08-14 16:48:10 +02001300 * @brief Parse any-data or any-xml element.
David Sedlák8a83bbb2019-07-18 14:46:00 +02001301 *
1302 * @param[in,out] ctx YIN parser context for logging and to store current state.
Radek Krejcid6b76452019-09-03 17:03:03 +02001303 * @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 +02001304 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlák8a83bbb2019-07-18 14:46:00 +02001305 *
1306 * @return LY_ERR values.
1307 */
1308static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001309yin_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 +02001310{
David Sedlák8a83bbb2019-07-18 14:46:00 +02001311 struct lysp_node_anydata *any;
1312
David Sedlák8d552d62019-08-06 15:29:05 +02001313 /* create new sibling */
Michal Vaskob36053d2020-03-26 15:49:30 +01001314 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, any, next, LY_EMEM);
Radek Krejcid6b76452019-09-03 17:03:03 +02001315 any->nodetype = (any_kw == LY_STMT_ANYDATA) ? LYS_ANYDATA : LYS_ANYXML;
David Sedlák8a83bbb2019-07-18 14:46:00 +02001316 any->parent = node_meta->parent;
1317
David Sedlákbf8a2b72019-08-14 16:48:10 +02001318 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001319 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1320 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 +02001321
1322 struct yin_subelement subelems[9] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001323 {LY_STMT_CONFIG, &any->flags, YIN_SUBELEM_UNIQUE},
1324 {LY_STMT_DESCRIPTION, &any->dsc, YIN_SUBELEM_UNIQUE},
1325 {LY_STMT_IF_FEATURE, &any->iffeatures, 0},
1326 {LY_STMT_MANDATORY, &any->flags, YIN_SUBELEM_UNIQUE},
1327 {LY_STMT_MUST, &any->musts, 0},
1328 {LY_STMT_REFERENCE, &any->ref, YIN_SUBELEM_UNIQUE},
1329 {LY_STMT_STATUS, &any->flags, YIN_SUBELEM_UNIQUE},
1330 {LY_STMT_WHEN, &any->when, YIN_SUBELEM_UNIQUE},
1331 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1332 };
Michal Vaskob36053d2020-03-26 15:49:30 +01001333 return yin_parse_content(ctx, subelems, 9, any_kw, NULL, &any->exts);
David Sedlák8a83bbb2019-07-18 14:46:00 +02001334}
1335
1336/**
David Sedlák203ca3a2019-07-18 15:26:25 +02001337 * @brief parse leaf element.
1338 *
1339 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákad83cf92019-08-13 12:53:53 +02001340 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlák203ca3a2019-07-18 15:26:25 +02001341 *
1342 * @return LY_ERR values.
1343 */
1344static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001345yin_parse_leaf(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *node_meta)
David Sedlák203ca3a2019-07-18 15:26:25 +02001346{
David Sedlák203ca3a2019-07-18 15:26:25 +02001347 struct lysp_node_leaf *leaf;
1348
David Sedlák8d552d62019-08-06 15:29:05 +02001349 /* create structure new leaf */
Michal Vaskob36053d2020-03-26 15:49:30 +01001350 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, leaf, next, LY_EMEM);
David Sedlák203ca3a2019-07-18 15:26:25 +02001351 leaf->nodetype = LYS_LEAF;
1352 leaf->parent = node_meta->parent;
1353
David Sedlák203ca3a2019-07-18 15:26:25 +02001354 /* parser argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001355 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1356 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 +02001357
1358 /* parse content */
1359 struct yin_subelement subelems[12] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001360 {LY_STMT_CONFIG, &leaf->flags, YIN_SUBELEM_UNIQUE},
1361 {LY_STMT_DEFAULT, &leaf->dflt, YIN_SUBELEM_UNIQUE},
1362 {LY_STMT_DESCRIPTION, &leaf->dsc, YIN_SUBELEM_UNIQUE},
1363 {LY_STMT_IF_FEATURE, &leaf->iffeatures, 0},
1364 {LY_STMT_MANDATORY, &leaf->flags, YIN_SUBELEM_UNIQUE},
1365 {LY_STMT_MUST, &leaf->musts, 0},
1366 {LY_STMT_REFERENCE, &leaf->ref, YIN_SUBELEM_UNIQUE},
1367 {LY_STMT_STATUS, &leaf->flags, YIN_SUBELEM_UNIQUE},
1368 {LY_STMT_TYPE, &leaf->type, YIN_SUBELEM_UNIQUE | YIN_SUBELEM_MANDATORY},
1369 {LY_STMT_UNITS, &leaf->units, YIN_SUBELEM_UNIQUE},
1370 {LY_STMT_WHEN, &leaf->when, YIN_SUBELEM_UNIQUE},
1371 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1372 };
Michal Vaskob36053d2020-03-26 15:49:30 +01001373 return yin_parse_content(ctx, subelems, 12, LY_STMT_LEAF, NULL, &leaf->exts);
David Sedlák203ca3a2019-07-18 15:26:25 +02001374}
1375
1376/**
David Sedlákc3da3ef2019-07-19 12:56:08 +02001377 * @brief Parse leaf-list element.
1378 *
1379 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákad83cf92019-08-13 12:53:53 +02001380 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlákc3da3ef2019-07-19 12:56:08 +02001381 *
1382 * @return LY_ERR values.
1383 */
1384static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001385yin_parse_leaflist(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *node_meta)
David Sedlákc3da3ef2019-07-19 12:56:08 +02001386{
David Sedlákc3da3ef2019-07-19 12:56:08 +02001387 struct lysp_node_leaflist *llist;
David Sedlákc3da3ef2019-07-19 12:56:08 +02001388
Michal Vaskob36053d2020-03-26 15:49:30 +01001389 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, llist, next, LY_EMEM);
David Sedlák8d552d62019-08-06 15:29:05 +02001390
David Sedlákc3da3ef2019-07-19 12:56:08 +02001391 llist->nodetype = LYS_LEAFLIST;
1392 llist->parent = node_meta->parent;
1393
David Sedlákc3da3ef2019-07-19 12:56:08 +02001394 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001395 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1396 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 +02001397
1398 /* parse content */
1399 struct yin_subelement subelems[14] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001400 {LY_STMT_CONFIG, &llist->flags, YIN_SUBELEM_UNIQUE},
1401 {LY_STMT_DEFAULT, &llist->dflts, 0},
1402 {LY_STMT_DESCRIPTION, &llist->dsc, YIN_SUBELEM_UNIQUE},
1403 {LY_STMT_IF_FEATURE, &llist->iffeatures, 0},
1404 {LY_STMT_MAX_ELEMENTS, llist, YIN_SUBELEM_UNIQUE},
1405 {LY_STMT_MIN_ELEMENTS, llist, YIN_SUBELEM_UNIQUE},
1406 {LY_STMT_MUST, &llist->musts, 0},
1407 {LY_STMT_ORDERED_BY, &llist->flags, YIN_SUBELEM_UNIQUE},
1408 {LY_STMT_REFERENCE, &llist->ref, YIN_SUBELEM_UNIQUE},
1409 {LY_STMT_STATUS, &llist->flags, YIN_SUBELEM_UNIQUE},
1410 {LY_STMT_TYPE, &llist->type, YIN_SUBELEM_UNIQUE | YIN_SUBELEM_MANDATORY},
1411 {LY_STMT_UNITS, &llist->units, YIN_SUBELEM_UNIQUE},
1412 {LY_STMT_WHEN, &llist->when, YIN_SUBELEM_UNIQUE},
1413 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1414 };
Michal Vaskob36053d2020-03-26 15:49:30 +01001415 LY_CHECK_RET(yin_parse_content(ctx, subelems, 14, LY_STMT_LEAF_LIST, NULL, &llist->exts));
David Sedlákc3da3ef2019-07-19 12:56:08 +02001416
David Sedlákbf8a2b72019-08-14 16:48:10 +02001417 /* check invalid combination of subelements */
David Sedlákc3da3ef2019-07-19 12:56:08 +02001418 if ((llist->min) && (llist->dflts)) {
David Sedlák1538a842019-08-08 15:38:51 +02001419 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INCHILDSTMSCOMB_YIN, "min-elements", "default", "leaf-list");
David Sedlákc3da3ef2019-07-19 12:56:08 +02001420 return LY_EVALID;
1421 }
1422 if (llist->max && llist->min > llist->max) {
David Sedlák1538a842019-08-08 15:38:51 +02001423 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_MINMAX, llist->min, llist->max);
David Sedlákc3da3ef2019-07-19 12:56:08 +02001424 return LY_EVALID;
1425 }
1426
1427 return LY_SUCCESS;
1428}
1429
1430/**
David Sedlák04e17b22019-07-19 15:29:48 +02001431 * @brief Parse typedef element.
1432 *
1433 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák05404f62019-07-24 14:11:53 +02001434 * @param[in] typedef_meta Meta information about parent node and typedefs to add to.
David Sedlák04e17b22019-07-19 15:29:48 +02001435 *
1436 * @return LY_ERR values.
1437 */
1438static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001439yin_parse_typedef(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *typedef_meta)
David Sedlák04e17b22019-07-19 15:29:48 +02001440{
1441 struct lysp_tpdf *tpdf;
David Sedlákbf8a2b72019-08-14 16:48:10 +02001442 struct lysp_tpdf **tpdfs = (struct lysp_tpdf **)typedef_meta->nodes;
Michal Vaskob36053d2020-03-26 15:49:30 +01001443 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *tpdfs, tpdf, LY_EMEM);
David Sedlák04e17b22019-07-19 15:29:48 +02001444
1445 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001446 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1447 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 +02001448
1449 /* parse content */
1450 struct yin_subelement subelems[7] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001451 {LY_STMT_DEFAULT, &tpdf->dflt, YIN_SUBELEM_UNIQUE},
1452 {LY_STMT_DESCRIPTION, &tpdf->dsc, YIN_SUBELEM_UNIQUE},
1453 {LY_STMT_REFERENCE, &tpdf->ref, YIN_SUBELEM_UNIQUE},
1454 {LY_STMT_STATUS, &tpdf->flags, YIN_SUBELEM_UNIQUE},
1455 {LY_STMT_TYPE, &tpdf->type, YIN_SUBELEM_UNIQUE | YIN_SUBELEM_MANDATORY},
1456 {LY_STMT_UNITS, &tpdf->units, YIN_SUBELEM_UNIQUE},
1457 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1458 };
Michal Vaskob36053d2020-03-26 15:49:30 +01001459 LY_CHECK_RET(yin_parse_content(ctx, subelems, 7, LY_STMT_TYPEDEF, NULL, &tpdf->exts));
David Sedlák04e17b22019-07-19 15:29:48 +02001460
1461 /* store data for collision check */
Michal Vasko7f45cf22020-10-01 12:49:44 +02001462 if (typedef_meta->parent && !(typedef_meta->parent->nodetype & (LYS_GROUPING | LYS_RPC | LYS_ACTION | LYS_INPUT
1463 | LYS_OUTPUT | LYS_NOTIF))) {
Radek Krejciba03a5a2020-08-27 14:40:41 +02001464 LY_CHECK_RET(ly_set_add(&ctx->tpdfs_nodes, typedef_meta->parent, 0, NULL));
David Sedlák04e17b22019-07-19 15:29:48 +02001465 }
1466
1467 return LY_SUCCESS;
1468}
1469
1470/**
David Sedlákd2d676a2019-07-22 11:28:19 +02001471 * @brief Parse refine element.
1472 *
1473 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákd2d676a2019-07-22 11:28:19 +02001474 * @param[in,out] refines Refines to add to.
1475 *
1476 * @return LY_ERR values.
1477 */
1478static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001479yin_parse_refine(struct lys_yin_parser_ctx *ctx, struct lysp_refine **refines)
David Sedlákd2d676a2019-07-22 11:28:19 +02001480{
1481 struct lysp_refine *rf;
1482
1483 /* allocate new refine */
Michal Vaskob36053d2020-03-26 15:49:30 +01001484 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *refines, rf, LY_EMEM);
David Sedlákd2d676a2019-07-22 11:28:19 +02001485
1486 /* parse attribute */
Michal Vaskob36053d2020-03-26 15:49:30 +01001487 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1488 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_TARGET_NODE, &rf->nodeid, Y_STR_ARG, LY_STMT_REFINE));
1489 CHECK_NONEMPTY(ctx, strlen(rf->nodeid), "refine");
David Sedlákd2d676a2019-07-22 11:28:19 +02001490
1491 /* parse content */
1492 struct yin_subelement subelems[11] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001493 {LY_STMT_CONFIG, &rf->flags, YIN_SUBELEM_UNIQUE},
Michal Vasko7f45cf22020-10-01 12:49:44 +02001494 {LY_STMT_DEFAULT, &rf->dflts, YIN_SUBELEM_TEXT},
Radek Krejci0f969882020-08-21 16:56:47 +02001495 {LY_STMT_DESCRIPTION, &rf->dsc, YIN_SUBELEM_UNIQUE},
Michal Vasko7f45cf22020-10-01 12:49:44 +02001496 {LY_STMT_IF_FEATURE, &rf->iffeatures, YIN_SUBELEM_TEXT},
Radek Krejci0f969882020-08-21 16:56:47 +02001497 {LY_STMT_MANDATORY, &rf->flags, YIN_SUBELEM_UNIQUE},
1498 {LY_STMT_MAX_ELEMENTS, rf, YIN_SUBELEM_UNIQUE},
1499 {LY_STMT_MIN_ELEMENTS, rf, YIN_SUBELEM_UNIQUE},
1500 {LY_STMT_MUST, &rf->musts, 0},
1501 {LY_STMT_PRESENCE, &rf->presence, YIN_SUBELEM_UNIQUE},
1502 {LY_STMT_REFERENCE, &rf->ref, YIN_SUBELEM_UNIQUE},
1503 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1504 };
Michal Vaskob36053d2020-03-26 15:49:30 +01001505 return yin_parse_content(ctx, subelems, 11, LY_STMT_REFINE, NULL, &rf->exts);
David Sedlákd2d676a2019-07-22 11:28:19 +02001506}
1507
1508/**
David Sedlák0d6de5a2019-07-22 13:25:44 +02001509 * @brief Parse uses element.
1510 *
1511 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákad83cf92019-08-13 12:53:53 +02001512 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlák0d6de5a2019-07-22 13:25:44 +02001513 *
1514 * @return LY_ERR values.
1515 */
1516static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001517yin_parse_uses(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *node_meta)
David Sedlák0d6de5a2019-07-22 13:25:44 +02001518{
David Sedlák0d6de5a2019-07-22 13:25:44 +02001519 struct lysp_node_uses *uses;
1520
David Sedlák8d552d62019-08-06 15:29:05 +02001521 /* create new uses */
Michal Vaskob36053d2020-03-26 15:49:30 +01001522 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, uses, next, LY_EMEM);
David Sedlák0d6de5a2019-07-22 13:25:44 +02001523 uses->nodetype = LYS_USES;
1524 uses->parent = node_meta->parent;
1525
David Sedlák0d6de5a2019-07-22 13:25:44 +02001526 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001527 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1528 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 +02001529
1530 /* parse content */
David Sedlák6881b512019-08-13 12:52:00 +02001531 struct tree_node_meta augments = {(struct lysp_node *)uses, (struct lysp_node **)&uses->augments};
David Sedlák0d6de5a2019-07-22 13:25:44 +02001532 struct yin_subelement subelems[8] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001533 {LY_STMT_AUGMENT, &augments, 0},
1534 {LY_STMT_DESCRIPTION, &uses->dsc, YIN_SUBELEM_UNIQUE},
1535 {LY_STMT_IF_FEATURE, &uses->iffeatures, 0},
1536 {LY_STMT_REFERENCE, &uses->ref, YIN_SUBELEM_UNIQUE},
1537 {LY_STMT_REFINE, &uses->refines, 0},
1538 {LY_STMT_STATUS, &uses->flags, YIN_SUBELEM_UNIQUE},
1539 {LY_STMT_WHEN, &uses->when, YIN_SUBELEM_UNIQUE},
1540 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1541 };
Michal Vaskob36053d2020-03-26 15:49:30 +01001542 LY_CHECK_RET(yin_parse_content(ctx, subelems, 8, LY_STMT_USES, NULL, &uses->exts));
David Sedlák0d6de5a2019-07-22 13:25:44 +02001543 LY_CHECK_RET(lysp_parse_finalize_reallocated((struct lys_parser_ctx *)ctx, NULL, uses->augments, NULL, NULL));
1544
1545 return LY_SUCCESS;
1546}
1547
1548/**
David Sedlákaa854b02019-07-22 14:17:10 +02001549 * @brief Parse revision element.
1550 *
1551 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákaa854b02019-07-22 14:17:10 +02001552 * @param[in,out] revs Parsed revisions to add to.
1553 *
1554 * @return LY_ERR values.
1555 */
1556static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001557yin_parse_revision(struct lys_yin_parser_ctx *ctx, struct lysp_revision **revs)
David Sedlákaa854b02019-07-22 14:17:10 +02001558{
1559 struct lysp_revision *rev;
1560 const char *temp_date = NULL;
1561
1562 /* allocate new reivison */
Michal Vaskob36053d2020-03-26 15:49:30 +01001563 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *revs, rev, LY_EMEM);
David Sedlákaa854b02019-07-22 14:17:10 +02001564
1565 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001566 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1567 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 +02001568 /* check value */
1569 if (lysp_check_date((struct lys_parser_ctx *)ctx, temp_date, strlen(temp_date), "revision")) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001570 FREE_STRING(ctx->xmlctx->ctx, temp_date);
David Sedlákaa854b02019-07-22 14:17:10 +02001571 return LY_EVALID;
1572 }
1573 strcpy(rev->date, temp_date);
Michal Vaskob36053d2020-03-26 15:49:30 +01001574 FREE_STRING(ctx->xmlctx->ctx, temp_date);
David Sedlákaa854b02019-07-22 14:17:10 +02001575
1576 /* parse content */
1577 struct yin_subelement subelems[3] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001578 {LY_STMT_DESCRIPTION, &rev->dsc, YIN_SUBELEM_UNIQUE},
1579 {LY_STMT_REFERENCE, &rev->ref, YIN_SUBELEM_UNIQUE},
1580 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1581 };
Michal Vaskob36053d2020-03-26 15:49:30 +01001582 return yin_parse_content(ctx, subelems, 3, LY_STMT_REVISION, NULL, &rev->exts);
David Sedlákaa854b02019-07-22 14:17:10 +02001583}
1584
David Sedlák5e13dea2019-07-22 16:06:45 +02001585/**
1586 * @brief Parse include element.
1587 *
1588 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák5e13dea2019-07-22 16:06:45 +02001589 * @param[in,out] inc_meta Meta informatinou about module/submodule name and includes to add to.
1590 *
1591 * @return LY_ERR values.
1592 */
David Sedlák0c2bab92019-07-22 15:33:19 +02001593static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001594yin_parse_include(struct lys_yin_parser_ctx *ctx, struct include_meta *inc_meta)
David Sedlák0c2bab92019-07-22 15:33:19 +02001595{
1596 struct lysp_include *inc;
1597
1598 /* allocate new include */
Michal Vaskob36053d2020-03-26 15:49:30 +01001599 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *inc_meta->includes, inc, LY_EMEM);
David Sedlák0c2bab92019-07-22 15:33:19 +02001600
1601 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001602 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1603 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 +02001604
1605 /* submodules share the namespace with the module names, so there must not be
1606 * a module of the same name in the context, no need for revision matching */
Michal Vaskob36053d2020-03-26 15:49:30 +01001607 if (!strcmp(inc_meta->name, inc->name) || ly_ctx_get_module_latest(ctx->xmlctx->ctx, inc->name)) {
David Sedlák1538a842019-08-08 15:38:51 +02001608 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_NAME_COL, inc->name);
David Sedlák0c2bab92019-07-22 15:33:19 +02001609 return LY_EVALID;
1610 }
1611
1612 /* parse content */
1613 struct yin_subelement subelems[4] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001614 {LY_STMT_DESCRIPTION, &inc->dsc, YIN_SUBELEM_UNIQUE | YIN_SUBELEM_VER2},
1615 {LY_STMT_REFERENCE, &inc->ref, YIN_SUBELEM_UNIQUE | YIN_SUBELEM_VER2},
1616 {LY_STMT_REVISION_DATE, &inc->rev, YIN_SUBELEM_UNIQUE},
1617 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1618 };
Michal Vaskob36053d2020-03-26 15:49:30 +01001619 return yin_parse_content(ctx, subelems, 4, LY_STMT_INCLUDE, NULL, &inc->exts);
David Sedlák0c2bab92019-07-22 15:33:19 +02001620}
1621
David Sedlákaa854b02019-07-22 14:17:10 +02001622/**
David Sedlákbf8a2b72019-08-14 16:48:10 +02001623 * @brief Parse revision-date element.
David Sedlákdfbbb442019-08-06 16:33:21 +02001624 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001625 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001626 * @param[in,out] rev Array to store the parsed value in.
1627 * @param[in,out] exts Extension instances to add to.
1628 *
1629 * @return LY_ERR values.
1630 */
1631static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001632yin_parse_revision_date(struct lys_yin_parser_ctx *ctx, char *rev, struct lysp_ext_instance **exts)
David Sedlákdfbbb442019-08-06 16:33:21 +02001633{
1634 const char *temp_rev;
1635 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001636 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1637 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001638
Michal Vaskob36053d2020-03-26 15:49:30 +01001639 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1640 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 +02001641 LY_CHECK_ERR_RET(lysp_check_date((struct lys_parser_ctx *)ctx, temp_rev, strlen(temp_rev), "revision-date") != LY_SUCCESS,
Michal Vaskob36053d2020-03-26 15:49:30 +01001642 FREE_STRING(ctx->xmlctx->ctx, temp_rev), LY_EVALID);
David Sedlákdfbbb442019-08-06 16:33:21 +02001643
1644 strcpy(rev, temp_rev);
Michal Vaskob36053d2020-03-26 15:49:30 +01001645 FREE_STRING(ctx->xmlctx->ctx, temp_rev);
David Sedlákdfbbb442019-08-06 16:33:21 +02001646
Michal Vaskob36053d2020-03-26 15:49:30 +01001647 return yin_parse_content(ctx, subelems, 1, LY_STMT_REVISION_DATE, NULL, exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02001648}
1649
1650/**
1651 * @brief Parse config element.
1652 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001653 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001654 * @param[in,out] flags Flags to add to.
1655 * @param[in,out] exts Extension instances to add to.
1656 *
1657 * @return LY_ERR values.
1658 */
1659static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001660yin_parse_config(struct lys_yin_parser_ctx *ctx, uint16_t *flags, struct lysp_ext_instance **exts)
David Sedlákdfbbb442019-08-06 16:33:21 +02001661{
1662 const char *temp_val = NULL;
1663 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001664 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1665 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001666
Michal Vaskob36053d2020-03-26 15:49:30 +01001667 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1668 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 +02001669 if (strcmp(temp_val, "true") == 0) {
1670 *flags |= LYS_CONFIG_W;
1671 } else if (strcmp(temp_val, "false") == 0) {
1672 *flags |= LYS_CONFIG_R;
1673 } else {
David Sedlák26ea1432019-08-14 13:42:23 +02001674 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS2, temp_val, "value", "config",
1675 "true", "false");
Michal Vaskob36053d2020-03-26 15:49:30 +01001676 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlákdfbbb442019-08-06 16:33:21 +02001677 return LY_EVALID;
1678 }
Michal Vaskob36053d2020-03-26 15:49:30 +01001679 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlákdfbbb442019-08-06 16:33:21 +02001680
Michal Vaskob36053d2020-03-26 15:49:30 +01001681 return yin_parse_content(ctx, subelems, 1, LY_STMT_CONFIG, NULL, exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02001682}
1683
1684/**
1685 * @brief Parse yang-version element.
1686 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001687 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001688 * @param[out] version Storage for the parsed information.
David Sedlákbf8a2b72019-08-14 16:48:10 +02001689 * @param[in,out] exts Extension instances to add to.
David Sedlákdfbbb442019-08-06 16:33:21 +02001690 *
1691 * @return LY_ERR values.
1692 */
1693static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001694yin_parse_yangversion(struct lys_yin_parser_ctx *ctx, uint8_t *version, struct lysp_ext_instance **exts)
David Sedlákdfbbb442019-08-06 16:33:21 +02001695{
1696 const char *temp_version = NULL;
1697 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001698 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1699 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001700
Michal Vaskob36053d2020-03-26 15:49:30 +01001701 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1702 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 +02001703 if (strcmp(temp_version, "1") == 0) {
David Sedlákdfbbb442019-08-06 16:33:21 +02001704 *version = LYS_VERSION_1_0;
1705 } else if (strcmp(temp_version, "1.1") == 0) {
1706 *version = LYS_VERSION_1_1;
1707 } else {
David Sedlák26ea1432019-08-14 13:42:23 +02001708 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS2, temp_version, "value",
Radek Krejci96e48da2020-09-04 13:18:06 +02001709 "yang-version", "1", "1.1");
Michal Vaskob36053d2020-03-26 15:49:30 +01001710 FREE_STRING(ctx->xmlctx->ctx, temp_version);
David Sedlákdfbbb442019-08-06 16:33:21 +02001711 return LY_EVALID;
1712 }
Michal Vaskob36053d2020-03-26 15:49:30 +01001713 FREE_STRING(ctx->xmlctx->ctx, temp_version);
David Sedlákdfbbb442019-08-06 16:33:21 +02001714 ctx->mod_version = *version;
1715
Michal Vaskob36053d2020-03-26 15:49:30 +01001716 return yin_parse_content(ctx, subelems, 1, LY_STMT_YANG_VERSION, NULL, exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02001717}
1718
1719/**
1720 * @brief Parse import element.
1721 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001722 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001723 * @param[in,out] imp_meta Meta information about prefix and imports to add to.
1724 *
1725 * @return LY_ERR values.
1726 */
1727static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001728yin_parse_import(struct lys_yin_parser_ctx *ctx, struct import_meta *imp_meta)
David Sedlákdfbbb442019-08-06 16:33:21 +02001729{
1730 struct lysp_import *imp;
1731 /* allocate new element in sized array for import */
Michal Vaskob36053d2020-03-26 15:49:30 +01001732 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *imp_meta->imports, imp, LY_EMEM);
David Sedlákdfbbb442019-08-06 16:33:21 +02001733
1734 struct yin_subelement subelems[5] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001735 {LY_STMT_DESCRIPTION, &imp->dsc, YIN_SUBELEM_UNIQUE},
1736 {LY_STMT_PREFIX, &imp->prefix, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE},
1737 {LY_STMT_REFERENCE, &imp->ref, YIN_SUBELEM_UNIQUE},
1738 {LY_STMT_REVISION_DATE, imp->rev, YIN_SUBELEM_UNIQUE},
1739 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1740 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001741
1742 /* parse import attributes */
Michal Vaskob36053d2020-03-26 15:49:30 +01001743 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1744 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_MODULE, &imp->name, Y_IDENTIF_ARG, LY_STMT_IMPORT));
1745 LY_CHECK_RET(yin_parse_content(ctx, subelems, 5, LY_STMT_IMPORT, NULL, &imp->exts));
David Sedlákdfbbb442019-08-06 16:33:21 +02001746 /* check prefix validity */
1747 LY_CHECK_RET(lysp_check_prefix((struct lys_parser_ctx *)ctx, *imp_meta->imports, imp_meta->prefix, &imp->prefix), LY_EVALID);
1748
1749 return LY_SUCCESS;
1750}
1751
1752/**
1753 * @brief Parse mandatory element.
1754 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001755 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001756 * @param[in,out] flags Flags to add to.
1757 * @param[in,out] exts Extension instances to add to.
1758 *
1759 * @return LY_ERR values.
1760 */
1761static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001762yin_parse_mandatory(struct lys_yin_parser_ctx *ctx, uint16_t *flags, struct lysp_ext_instance **exts)
David Sedlákdfbbb442019-08-06 16:33:21 +02001763{
1764 const char *temp_val = NULL;
1765 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001766 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1767 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001768
Michal Vaskob36053d2020-03-26 15:49:30 +01001769 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1770 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 +02001771 if (strcmp(temp_val, "true") == 0) {
1772 *flags |= LYS_MAND_TRUE;
1773 } else if (strcmp(temp_val, "false") == 0) {
1774 *flags |= LYS_MAND_FALSE;
1775 } else {
David Sedlák26ea1432019-08-14 13:42:23 +02001776 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS2, temp_val, "value",
1777 "mandatory", "true", "false");
Michal Vaskob36053d2020-03-26 15:49:30 +01001778 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlákdfbbb442019-08-06 16:33:21 +02001779 return LY_EVALID;
1780 }
Michal Vaskob36053d2020-03-26 15:49:30 +01001781 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlákdfbbb442019-08-06 16:33:21 +02001782
Michal Vaskob36053d2020-03-26 15:49:30 +01001783 return yin_parse_content(ctx, subelems, 1, LY_STMT_MANDATORY, NULL, exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02001784}
1785
1786/**
1787 * @brief Parse status element.
1788 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001789 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001790 * @param[in,out] flags Flags to add to.
1791 * @param[in,out] exts Extension instances to add to.
1792 *
1793 * @return LY_ERR values.
1794 */
1795static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001796yin_parse_status(struct lys_yin_parser_ctx *ctx, uint16_t *flags, struct lysp_ext_instance **exts)
David Sedlákdfbbb442019-08-06 16:33:21 +02001797{
1798 const char *value = NULL;
1799 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001800 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1801 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001802
Michal Vaskob36053d2020-03-26 15:49:30 +01001803 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1804 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 +02001805 if (strcmp(value, "current") == 0) {
1806 *flags |= LYS_STATUS_CURR;
1807 } else if (strcmp(value, "deprecated") == 0) {
1808 *flags |= LYS_STATUS_DEPRC;
1809 } else if (strcmp(value, "obsolete") == 0) {
1810 *flags |= LYS_STATUS_OBSLT;
1811 } else {
David Sedlák26ea1432019-08-14 13:42:23 +02001812 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS3, value, "value",
1813 "status", "current", "deprecated", "obsolete");
Michal Vaskob36053d2020-03-26 15:49:30 +01001814 FREE_STRING(ctx->xmlctx->ctx, value);
David Sedlákdfbbb442019-08-06 16:33:21 +02001815 return LY_EVALID;
1816 }
Michal Vaskob36053d2020-03-26 15:49:30 +01001817 FREE_STRING(ctx->xmlctx->ctx, value);
David Sedlákdfbbb442019-08-06 16:33:21 +02001818
Michal Vaskob36053d2020-03-26 15:49:30 +01001819 return yin_parse_content(ctx, subelems, 1, LY_STMT_STATUS, NULL, exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02001820}
1821
1822/**
1823 * @brief Parse when element.
1824 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001825 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001826 * @param[out] when_p When pointer to parse to.
1827 */
1828static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001829yin_parse_when(struct lys_yin_parser_ctx *ctx, struct lysp_when **when_p)
David Sedlákdfbbb442019-08-06 16:33:21 +02001830{
1831 struct lysp_when *when;
David Sedláka56e0012019-08-15 13:21:25 +02001832 LY_ERR ret = LY_SUCCESS;
1833
David Sedlákdfbbb442019-08-06 16:33:21 +02001834 when = calloc(1, sizeof *when);
Michal Vaskob36053d2020-03-26 15:49:30 +01001835 LY_CHECK_ERR_RET(!when, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
Radek Krejcif6923e82020-07-02 16:36:53 +02001836
1837 ret = lyxml_ctx_next(ctx->xmlctx);
1838 LY_CHECK_ERR_RET(ret, free(when), ret);
1839
Michal Vaskob36053d2020-03-26 15:49:30 +01001840 ret = yin_parse_attribute(ctx, YIN_ARG_CONDITION, &when->cond, Y_STR_ARG, LY_STMT_WHEN);
David Sedláka56e0012019-08-15 13:21:25 +02001841 LY_CHECK_ERR_RET(ret, free(when), ret);
1842
David Sedlákdfbbb442019-08-06 16:33:21 +02001843 *when_p = when;
1844 struct yin_subelement subelems[3] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001845 {LY_STMT_DESCRIPTION, &when->dsc, YIN_SUBELEM_UNIQUE},
1846 {LY_STMT_REFERENCE, &when->ref, YIN_SUBELEM_UNIQUE},
1847 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1848 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001849
Michal Vaskob36053d2020-03-26 15:49:30 +01001850 return yin_parse_content(ctx, subelems, 3, LY_STMT_WHEN, NULL, &when->exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02001851}
1852
1853/**
1854 * @brief Parse yin-elemenet element.
1855 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001856 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001857 * @param[in,out] data Data to read from, always moved to currently handled position.
1858 * @param[in,out] flags Flags to add to.
David Sedlákbf8a2b72019-08-14 16:48:10 +02001859 * @prama[in,out] exts Extension instances to add to.
David Sedlákdfbbb442019-08-06 16:33:21 +02001860 *
1861 * @return LY_ERR values.
1862 */
1863static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001864yin_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 +02001865{
1866 const char *temp_val = NULL;
1867 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001868 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1869 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001870
Michal Vaskob36053d2020-03-26 15:49:30 +01001871 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1872 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 +02001873 if (strcmp(temp_val, "true") == 0) {
1874 *flags |= LYS_YINELEM_TRUE;
1875 } else if (strcmp(temp_val, "false") == 0) {
1876 *flags |= LYS_YINELEM_FALSE;
1877 } else {
David Sedlák26ea1432019-08-14 13:42:23 +02001878 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS2, temp_val, "value",
1879 "yin-element", "true", "false");
Michal Vaskob36053d2020-03-26 15:49:30 +01001880 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlákdfbbb442019-08-06 16:33:21 +02001881 return LY_EVALID;
1882 }
Michal Vaskob36053d2020-03-26 15:49:30 +01001883 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlákdfbbb442019-08-06 16:33:21 +02001884
Michal Vaskob36053d2020-03-26 15:49:30 +01001885 return yin_parse_content(ctx, subelems, 1, LY_STMT_YIN_ELEMENT, NULL, exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02001886}
1887
1888/**
1889 * @brief Parse argument element.
1890 *
Michal Vaskob36053d2020-03-26 15:49:30 +01001891 * @param[in,out] xmlctx Xml context.
David Sedlákbf8a2b72019-08-14 16:48:10 +02001892 * @param[in,out] arg_meta Meta information about destionation of parsed data.
1893 * @param[in,out] exts Extension instances to add to.
David Sedlákdfbbb442019-08-06 16:33:21 +02001894 *
1895 * @return LY_ERR values.
1896 */
1897static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001898yin_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 +02001899{
1900 struct yin_subelement subelems[2] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001901 {LY_STMT_YIN_ELEMENT, arg_meta->flags, YIN_SUBELEM_UNIQUE},
1902 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1903 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001904
Michal Vaskob36053d2020-03-26 15:49:30 +01001905 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1906 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 +02001907
Michal Vaskob36053d2020-03-26 15:49:30 +01001908 return yin_parse_content(ctx, subelems, 2, LY_STMT_ARGUMENT, NULL, exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02001909}
1910
1911/**
1912 * @brief Parse the extension statement.
1913 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02001914 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákdfbbb442019-08-06 16:33:21 +02001915 * @param[in,out] extensions Extensions to add to.
1916 *
1917 * @return LY_ERR values.
1918 */
1919static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001920yin_parse_extension(struct lys_yin_parser_ctx *ctx, struct lysp_ext **extensions)
David Sedlákdfbbb442019-08-06 16:33:21 +02001921{
1922 struct lysp_ext *ex;
Michal Vaskob36053d2020-03-26 15:49:30 +01001923 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *extensions, ex, LY_EMEM);
1924 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1925 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 +02001926
1927 struct yin_argument_meta arg_info = {&ex->flags, &ex->argument};
1928 struct yin_subelement subelems[5] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001929 {LY_STMT_ARGUMENT, &arg_info, YIN_SUBELEM_UNIQUE},
1930 {LY_STMT_DESCRIPTION, &ex->dsc, YIN_SUBELEM_UNIQUE},
1931 {LY_STMT_REFERENCE, &ex->ref, YIN_SUBELEM_UNIQUE},
1932 {LY_STMT_STATUS, &ex->flags, YIN_SUBELEM_UNIQUE},
1933 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
1934 };
David Sedlákdfbbb442019-08-06 16:33:21 +02001935
Michal Vaskob36053d2020-03-26 15:49:30 +01001936 return yin_parse_content(ctx, subelems, 5, LY_STMT_EXTENSION, NULL, &ex->exts);
David Sedlákdfbbb442019-08-06 16:33:21 +02001937}
1938
1939/**
David Sedlák5e13dea2019-07-22 16:06:45 +02001940 * @brief Parse feature element.
1941 *
1942 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák5e13dea2019-07-22 16:06:45 +02001943 * @param[in,out] features Features to add to.
1944 *
1945 * @return LY_ERR values.
1946 */
1947static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001948yin_parse_feature(struct lys_yin_parser_ctx *ctx, struct lysp_feature **features)
David Sedlák5e13dea2019-07-22 16:06:45 +02001949{
1950 struct lysp_feature *feat;
1951
1952 /* allocate new feature */
Michal Vaskob36053d2020-03-26 15:49:30 +01001953 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *features, feat, LY_EMEM);
David Sedlák5e13dea2019-07-22 16:06:45 +02001954
1955 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001956 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1957 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 +02001958
1959 /* parse content */
1960 struct yin_subelement subelems[5] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001961 {LY_STMT_DESCRIPTION, &feat->dsc, YIN_SUBELEM_UNIQUE},
1962 {LY_STMT_IF_FEATURE, &feat->iffeatures, 0},
1963 {LY_STMT_REFERENCE, &feat->ref, YIN_SUBELEM_UNIQUE},
1964 {LY_STMT_STATUS, &feat->flags, YIN_SUBELEM_UNIQUE},
1965 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1966 };
Michal Vaskob36053d2020-03-26 15:49:30 +01001967 return yin_parse_content(ctx, subelems, 5, LY_STMT_FEATURE, NULL, &feat->exts);
David Sedlák5e13dea2019-07-22 16:06:45 +02001968}
1969
1970/**
David Sedlák28794f22019-07-22 16:45:00 +02001971 * @brief Parse identity element.
1972 *
1973 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák28794f22019-07-22 16:45:00 +02001974 * @param[in,out] identities Identities to add to.
1975 *
1976 * @return LY_ERR values.
1977 */
1978static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01001979yin_parse_identity(struct lys_yin_parser_ctx *ctx, struct lysp_ident **identities)
David Sedlák28794f22019-07-22 16:45:00 +02001980{
1981 struct lysp_ident *ident;
1982
1983 /* allocate new identity */
Michal Vaskob36053d2020-03-26 15:49:30 +01001984 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *identities, ident, LY_EMEM);
David Sedlák28794f22019-07-22 16:45:00 +02001985
1986 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01001987 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
1988 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 +02001989
1990 /* parse content */
1991 struct yin_subelement subelems[6] = {
Radek Krejci0f969882020-08-21 16:56:47 +02001992 {LY_STMT_BASE, &ident->bases, 0},
1993 {LY_STMT_DESCRIPTION, &ident->dsc, YIN_SUBELEM_UNIQUE},
1994 {LY_STMT_IF_FEATURE, &ident->iffeatures, YIN_SUBELEM_VER2},
1995 {LY_STMT_REFERENCE, &ident->ref, YIN_SUBELEM_UNIQUE},
1996 {LY_STMT_STATUS, &ident->flags, YIN_SUBELEM_UNIQUE},
1997 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
1998 };
Michal Vaskob36053d2020-03-26 15:49:30 +01001999 return yin_parse_content(ctx, subelems, 6, LY_STMT_IDENTITY, NULL, &ident->exts);
David Sedlák28794f22019-07-22 16:45:00 +02002000}
2001
2002/**
David Sedlákaf536aa2019-07-23 13:42:23 +02002003 * @brief Parse list element.
2004 *
2005 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákad83cf92019-08-13 12:53:53 +02002006 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlákaf536aa2019-07-23 13:42:23 +02002007 *
2008 * @return LY_ERR values.
2009 */
2010static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002011yin_parse_list(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *node_meta)
David Sedlákaf536aa2019-07-23 13:42:23 +02002012{
David Sedlákaf536aa2019-07-23 13:42:23 +02002013 struct lysp_node_list *list;
David Sedlák81497a32019-08-13 16:56:26 +02002014 LY_ERR ret = LY_SUCCESS;
2015 struct yin_subelement *subelems = NULL;
David Sedlákaf536aa2019-07-23 13:42:23 +02002016
Michal Vaskob36053d2020-03-26 15:49:30 +01002017 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, list, next, LY_EMEM);
David Sedlákaf536aa2019-07-23 13:42:23 +02002018 list->nodetype = LYS_LIST;
2019 list->parent = node_meta->parent;
2020
David Sedlákaf536aa2019-07-23 13:42:23 +02002021 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002022 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2023 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 +02002024
2025 /* parse list content */
David Sedlák81497a32019-08-13 16:56:26 +02002026 LY_CHECK_RET(subelems_allocator(ctx, 25, (struct lysp_node *)list, &subelems,
Radek Krejcid6b76452019-09-03 17:03:03 +02002027 LY_STMT_ACTION, &list->actions, 0,
2028 LY_STMT_ANYDATA, &list->child, 0,
2029 LY_STMT_ANYXML, &list->child, 0,
2030 LY_STMT_CHOICE, &list->child, 0,
2031 LY_STMT_CONFIG, &list->flags, YIN_SUBELEM_UNIQUE,
2032 LY_STMT_CONTAINER, &list->child, 0,
2033 LY_STMT_DESCRIPTION, &list->dsc, YIN_SUBELEM_UNIQUE,
2034 LY_STMT_GROUPING, &list->groupings, 0,
2035 LY_STMT_IF_FEATURE, &list->iffeatures, 0,
2036 LY_STMT_KEY, &list->key, YIN_SUBELEM_UNIQUE,
2037 LY_STMT_LEAF, &list->child, 0,
2038 LY_STMT_LEAF_LIST, &list->child, 0,
2039 LY_STMT_LIST, &list->child, 0,
2040 LY_STMT_MAX_ELEMENTS, list, YIN_SUBELEM_UNIQUE,
2041 LY_STMT_MIN_ELEMENTS, list, YIN_SUBELEM_UNIQUE,
2042 LY_STMT_MUST, &list->musts, 0,
2043 LY_STMT_NOTIFICATION, &list->notifs, 0,
2044 LY_STMT_ORDERED_BY, &list->flags, YIN_SUBELEM_UNIQUE,
2045 LY_STMT_REFERENCE, &list->ref, YIN_SUBELEM_UNIQUE,
2046 LY_STMT_STATUS, &list->flags, YIN_SUBELEM_UNIQUE,
2047 LY_STMT_TYPEDEF, &list->typedefs, 0,
2048 LY_STMT_UNIQUE, &list->uniques, 0,
2049 LY_STMT_USES, &list->child, 0,
2050 LY_STMT_WHEN, &list->when, YIN_SUBELEM_UNIQUE,
2051 LY_STMT_EXTENSION_INSTANCE, NULL, 0
David Sedlák81497a32019-08-13 16:56:26 +02002052 ));
Michal Vaskob36053d2020-03-26 15:49:30 +01002053 ret = yin_parse_content(ctx, subelems, 25, LY_STMT_LIST, NULL, &list->exts);
David Sedlák81497a32019-08-13 16:56:26 +02002054 subelems_deallocator(25, subelems);
2055 LY_CHECK_RET(ret);
David Sedlákaf536aa2019-07-23 13:42:23 +02002056
2057 /* finalize parent pointers to the reallocated items */
2058 LY_CHECK_RET(lysp_parse_finalize_reallocated((struct lys_parser_ctx *)ctx, list->groupings, NULL, list->actions, list->notifs));
2059
2060 if (list->max && list->min > list->max) {
David Sedlák1538a842019-08-08 15:38:51 +02002061 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_MINMAX, list->min, list->max);
David Sedlákaf536aa2019-07-23 13:42:23 +02002062 return LY_EVALID;
2063 }
2064
2065 return LY_SUCCESS;
2066}
2067
2068/**
David Sedlák031b9e72019-07-23 15:19:37 +02002069 * @brief Parse notification element.
2070 *
2071 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák05404f62019-07-24 14:11:53 +02002072 * @param[in,out] notif_meta Meta information about parent node and notifications to add to.
David Sedlák031b9e72019-07-23 15:19:37 +02002073 *
2074 * @return LY_ERR values.
2075 */
2076static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002077yin_parse_notification(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *notif_meta)
David Sedlák031b9e72019-07-23 15:19:37 +02002078{
2079 struct lysp_notif *notif;
David Sedlákbf8a2b72019-08-14 16:48:10 +02002080 struct lysp_notif **notifs = (struct lysp_notif **)notif_meta->nodes;
David Sedlák81497a32019-08-13 16:56:26 +02002081 LY_ERR ret = LY_SUCCESS;
2082 struct yin_subelement *subelems = NULL;
David Sedlák031b9e72019-07-23 15:19:37 +02002083
2084 /* allocate new notification */
Michal Vaskob36053d2020-03-26 15:49:30 +01002085 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *notifs, notif, LY_EMEM);
David Sedlák031b9e72019-07-23 15:19:37 +02002086 notif->nodetype = LYS_NOTIF;
2087 notif->parent = notif_meta->parent;
2088
2089 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002090 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2091 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 +02002092
2093 /* parse notification content */
David Sedlák81497a32019-08-13 16:56:26 +02002094 LY_CHECK_RET(subelems_allocator(ctx, 16, (struct lysp_node *)notif, &subelems,
Radek Krejcid6b76452019-09-03 17:03:03 +02002095 LY_STMT_ANYDATA, &notif->data, 0,
2096 LY_STMT_ANYXML, &notif->data, 0,
2097 LY_STMT_CHOICE, &notif->data, 0,
2098 LY_STMT_CONTAINER, &notif->data, 0,
2099 LY_STMT_DESCRIPTION, &notif->dsc, YIN_SUBELEM_UNIQUE,
2100 LY_STMT_GROUPING, &notif->groupings, 0,
2101 LY_STMT_IF_FEATURE, &notif->iffeatures, 0,
2102 LY_STMT_LEAF, &notif->data, 0,
2103 LY_STMT_LEAF_LIST, &notif->data, 0,
2104 LY_STMT_LIST, &notif->data, 0,
2105 LY_STMT_MUST, &notif->musts, YIN_SUBELEM_VER2,
2106 LY_STMT_REFERENCE, &notif->ref, YIN_SUBELEM_UNIQUE,
2107 LY_STMT_STATUS, &notif->flags, YIN_SUBELEM_UNIQUE,
2108 LY_STMT_TYPEDEF, &notif->typedefs, 0,
2109 LY_STMT_USES, &notif->data, 0,
2110 LY_STMT_EXTENSION_INSTANCE, NULL, 0
David Sedlák81497a32019-08-13 16:56:26 +02002111 ));
2112
Michal Vaskob36053d2020-03-26 15:49:30 +01002113 ret = yin_parse_content(ctx, subelems, 16, LY_STMT_NOTIFICATION, NULL, &notif->exts);
David Sedlák81497a32019-08-13 16:56:26 +02002114 subelems_deallocator(16, subelems);
2115 LY_CHECK_RET(ret);
David Sedlák031b9e72019-07-23 15:19:37 +02002116
2117 /* finalize parent pointers to the reallocated items */
2118 LY_CHECK_RET(lysp_parse_finalize_reallocated((struct lys_parser_ctx *)ctx, notif->groupings, NULL, NULL, NULL));
2119
2120 return LY_SUCCESS;
2121}
2122
2123/**
David Sedlákbf8a2b72019-08-14 16:48:10 +02002124 * @brief Parse grouping element.
David Sedláke3ce9ef2019-07-23 16:34:30 +02002125 *
2126 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbf8a2b72019-08-14 16:48:10 +02002127 * @param[in,out] gr_meta Meta information about parent node and groupings to add to.
David Sedláke3ce9ef2019-07-23 16:34:30 +02002128 *
2129 * @return LY_ERR values.
2130 */
2131static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002132yin_parse_grouping(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *gr_meta)
David Sedláke3ce9ef2019-07-23 16:34:30 +02002133{
2134 struct lysp_grp *grp;
David Sedlákbf8a2b72019-08-14 16:48:10 +02002135 struct lysp_grp **grps = (struct lysp_grp **)gr_meta->nodes;
David Sedlák81497a32019-08-13 16:56:26 +02002136 LY_ERR ret = LY_SUCCESS;
2137 struct yin_subelement *subelems = NULL;
David Sedláke3ce9ef2019-07-23 16:34:30 +02002138
2139 /* create new grouping */
Michal Vaskob36053d2020-03-26 15:49:30 +01002140 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *grps, grp, LY_EMEM);
David Sedláke3ce9ef2019-07-23 16:34:30 +02002141 grp->nodetype = LYS_GROUPING;
2142 grp->parent = gr_meta->parent;
2143
2144 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002145 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2146 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 +02002147
2148 /* parse grouping content */
David Sedlák81497a32019-08-13 16:56:26 +02002149 LY_CHECK_RET(subelems_allocator(ctx, 16, (struct lysp_node *)grp, &subelems,
Radek Krejcid6b76452019-09-03 17:03:03 +02002150 LY_STMT_ACTION, &grp->actions, 0,
2151 LY_STMT_ANYDATA, &grp->data, 0,
2152 LY_STMT_ANYXML, &grp->data, 0,
2153 LY_STMT_CHOICE, &grp->data, 0,
2154 LY_STMT_CONTAINER, &grp->data, 0,
2155 LY_STMT_DESCRIPTION, &grp->dsc, YIN_SUBELEM_UNIQUE,
2156 LY_STMT_GROUPING, &grp->groupings, 0,
2157 LY_STMT_LEAF, &grp->data, 0,
2158 LY_STMT_LEAF_LIST, &grp->data, 0,
2159 LY_STMT_LIST, &grp->data, 0,
2160 LY_STMT_NOTIFICATION, &grp->notifs, 0,
2161 LY_STMT_REFERENCE, &grp->ref, YIN_SUBELEM_UNIQUE,
2162 LY_STMT_STATUS, &grp->flags, YIN_SUBELEM_UNIQUE,
2163 LY_STMT_TYPEDEF, &grp->typedefs, 0,
2164 LY_STMT_USES, &grp->data, 0,
2165 LY_STMT_EXTENSION_INSTANCE, NULL, 0
David Sedlák81497a32019-08-13 16:56:26 +02002166 ));
Michal Vaskob36053d2020-03-26 15:49:30 +01002167 ret = yin_parse_content(ctx, subelems, 16, LY_STMT_GROUPING, NULL, &grp->exts);
David Sedlák81497a32019-08-13 16:56:26 +02002168 subelems_deallocator(16, subelems);
2169 LY_CHECK_RET(ret);
2170
David Sedláke3ce9ef2019-07-23 16:34:30 +02002171 /* finalize parent pointers to the reallocated items */
2172 LY_CHECK_RET(lysp_parse_finalize_reallocated((struct lys_parser_ctx *)ctx, grp->groupings, NULL, grp->actions, grp->notifs));
2173
2174 return LY_SUCCESS;
2175}
2176
2177/**
David Sedlákbf8a2b72019-08-14 16:48:10 +02002178 * @brief Parse container element.
David Sedlákf111bcb2019-07-23 17:15:51 +02002179 *
2180 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákad83cf92019-08-13 12:53:53 +02002181 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlákf111bcb2019-07-23 17:15:51 +02002182 *
2183 * @return LY_ERR values.
2184 */
2185static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002186yin_parse_container(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *node_meta)
David Sedlákf111bcb2019-07-23 17:15:51 +02002187{
David Sedlákf111bcb2019-07-23 17:15:51 +02002188 struct lysp_node_container *cont;
David Sedlák81497a32019-08-13 16:56:26 +02002189 LY_ERR ret = LY_SUCCESS;
2190 struct yin_subelement *subelems = NULL;
David Sedlákf111bcb2019-07-23 17:15:51 +02002191
2192 /* create new container */
Michal Vaskob36053d2020-03-26 15:49:30 +01002193 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, cont, next, LY_EMEM);
David Sedlákf111bcb2019-07-23 17:15:51 +02002194 cont->nodetype = LYS_CONTAINER;
2195 cont->parent = node_meta->parent;
2196
David Sedlákf111bcb2019-07-23 17:15:51 +02002197 /* parse aegument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002198 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2199 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 +02002200
2201 /* parse container content */
David Sedlák81497a32019-08-13 16:56:26 +02002202 LY_CHECK_RET(subelems_allocator(ctx, 21, (struct lysp_node *)cont, &subelems,
Radek Krejcid6b76452019-09-03 17:03:03 +02002203 LY_STMT_ACTION, &cont->actions, YIN_SUBELEM_VER2,
2204 LY_STMT_ANYDATA, &cont->child, YIN_SUBELEM_VER2,
2205 LY_STMT_ANYXML, &cont->child, 0,
2206 LY_STMT_CHOICE, &cont->child, 0,
2207 LY_STMT_CONFIG, &cont->flags, YIN_SUBELEM_UNIQUE,
2208 LY_STMT_CONTAINER, &cont->child, 0,
2209 LY_STMT_DESCRIPTION, &cont->dsc, YIN_SUBELEM_UNIQUE,
2210 LY_STMT_GROUPING, &cont->groupings, 0,
2211 LY_STMT_IF_FEATURE, &cont->iffeatures, 0,
2212 LY_STMT_LEAF, &cont->child, 0,
2213 LY_STMT_LEAF_LIST, &cont->child, 0,
2214 LY_STMT_LIST, &cont->child, 0,
2215 LY_STMT_MUST, &cont->musts, 0,
2216 LY_STMT_NOTIFICATION, &cont->notifs, YIN_SUBELEM_VER2,
2217 LY_STMT_PRESENCE, &cont->presence, YIN_SUBELEM_UNIQUE,
2218 LY_STMT_REFERENCE, &cont->ref, YIN_SUBELEM_UNIQUE,
2219 LY_STMT_STATUS, &cont->flags, YIN_SUBELEM_UNIQUE,
2220 LY_STMT_TYPEDEF, &cont->typedefs, 0,
2221 LY_STMT_USES, &cont->child, 0,
2222 LY_STMT_WHEN, &cont->when, YIN_SUBELEM_UNIQUE,
2223 LY_STMT_EXTENSION_INSTANCE, NULL, 0
David Sedlák81497a32019-08-13 16:56:26 +02002224 ));
Michal Vaskob36053d2020-03-26 15:49:30 +01002225 ret = yin_parse_content(ctx, subelems, 21, LY_STMT_CONTAINER, NULL, &cont->exts);
David Sedlák81497a32019-08-13 16:56:26 +02002226 subelems_deallocator(21, subelems);
2227 LY_CHECK_RET(ret);
2228
David Sedlákf111bcb2019-07-23 17:15:51 +02002229 LY_CHECK_RET(lysp_parse_finalize_reallocated((struct lys_parser_ctx *)ctx, cont->groupings, NULL, cont->actions, cont->notifs));
2230
2231 return LY_SUCCESS;
2232}
2233
2234/**
David Sedlák5379d392019-07-24 10:42:03 +02002235 * @brief Parse case element.
2236 *
2237 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákad83cf92019-08-13 12:53:53 +02002238 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlák5379d392019-07-24 10:42:03 +02002239 *
2240 * @return LY_ERR values.
2241 */
2242static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002243yin_parse_case(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *node_meta)
David Sedlák5379d392019-07-24 10:42:03 +02002244{
David Sedlák5379d392019-07-24 10:42:03 +02002245 struct lysp_node_case *cas;
David Sedlák81497a32019-08-13 16:56:26 +02002246 LY_ERR ret = LY_SUCCESS;
2247 struct yin_subelement *subelems = NULL;;
David Sedlák5379d392019-07-24 10:42:03 +02002248
2249 /* create new case */
Michal Vaskob36053d2020-03-26 15:49:30 +01002250 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, cas, next, LY_EMEM);
David Sedlák5379d392019-07-24 10:42:03 +02002251 cas->nodetype = LYS_CASE;
2252 cas->parent = node_meta->parent;
2253
David Sedlák5379d392019-07-24 10:42:03 +02002254 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002255 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2256 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 +02002257
2258 /* parse case content */
David Sedlák81497a32019-08-13 16:56:26 +02002259 LY_CHECK_RET(subelems_allocator(ctx, 14, (struct lysp_node *)cas, &subelems,
Radek Krejcid6b76452019-09-03 17:03:03 +02002260 LY_STMT_ANYDATA, &cas->child, YIN_SUBELEM_VER2,
2261 LY_STMT_ANYXML, &cas->child, 0,
2262 LY_STMT_CHOICE, &cas->child, 0,
2263 LY_STMT_CONTAINER, &cas->child, 0,
2264 LY_STMT_DESCRIPTION, &cas->dsc, YIN_SUBELEM_UNIQUE,
2265 LY_STMT_IF_FEATURE, &cas->iffeatures, 0,
2266 LY_STMT_LEAF, &cas->child, 0,
2267 LY_STMT_LEAF_LIST, &cas->child, 0,
2268 LY_STMT_LIST, &cas->child, 0,
2269 LY_STMT_REFERENCE, &cas->ref, YIN_SUBELEM_UNIQUE,
2270 LY_STMT_STATUS, &cas->flags, YIN_SUBELEM_UNIQUE,
2271 LY_STMT_USES, &cas->child, 0,
2272 LY_STMT_WHEN, &cas->when, YIN_SUBELEM_UNIQUE,
2273 LY_STMT_EXTENSION_INSTANCE, NULL, 0
David Sedlák81497a32019-08-13 16:56:26 +02002274 ));
Michal Vaskob36053d2020-03-26 15:49:30 +01002275 ret = yin_parse_content(ctx, subelems, 14, LY_STMT_CASE, NULL, &cas->exts);
David Sedlák81497a32019-08-13 16:56:26 +02002276 subelems_deallocator(14, subelems);
2277
2278 return ret;
David Sedlák5379d392019-07-24 10:42:03 +02002279}
2280
2281/**
David Sedlák05404f62019-07-24 14:11:53 +02002282 * @brief Parse choice element.
David Sedlákb7abcfa2019-07-24 12:33:35 +02002283 *
2284 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákad83cf92019-08-13 12:53:53 +02002285 * @param[in] node_meta Meta information about parent node and siblings to add to.
David Sedlákb7abcfa2019-07-24 12:33:35 +02002286 *
2287 * @return LY_ERR values.
2288 */
2289LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002290yin_parse_choice(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *node_meta)
David Sedlákb7abcfa2019-07-24 12:33:35 +02002291{
David Sedlák81497a32019-08-13 16:56:26 +02002292 LY_ERR ret = LY_SUCCESS;
2293 struct yin_subelement *subelems = NULL;
David Sedlákb7abcfa2019-07-24 12:33:35 +02002294 struct lysp_node_choice *choice;
2295
2296 /* create new choice */
Michal Vaskob36053d2020-03-26 15:49:30 +01002297 LY_LIST_NEW_RET(ctx->xmlctx->ctx, node_meta->nodes, choice, next, LY_EMEM);
David Sedlák8d552d62019-08-06 15:29:05 +02002298
David Sedlákb7abcfa2019-07-24 12:33:35 +02002299 choice->nodetype = LYS_CHOICE;
2300 choice->parent = node_meta->parent;
2301
David Sedlákb7abcfa2019-07-24 12:33:35 +02002302 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002303 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2304 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 +02002305
2306 /* parse choice content */
David Sedlák81497a32019-08-13 16:56:26 +02002307 LY_CHECK_RET(subelems_allocator(ctx, 17, (struct lysp_node *)choice, &subelems,
Radek Krejcid6b76452019-09-03 17:03:03 +02002308 LY_STMT_ANYDATA, &choice->child, YIN_SUBELEM_VER2,
2309 LY_STMT_ANYXML, &choice->child, 0,
2310 LY_STMT_CASE, &choice->child, 0,
2311 LY_STMT_CHOICE, &choice->child, YIN_SUBELEM_VER2,
2312 LY_STMT_CONFIG, &choice->flags, YIN_SUBELEM_UNIQUE,
2313 LY_STMT_CONTAINER, &choice->child, 0,
2314 LY_STMT_DEFAULT, &choice->dflt, YIN_SUBELEM_UNIQUE,
2315 LY_STMT_DESCRIPTION, &choice->dsc, YIN_SUBELEM_UNIQUE,
2316 LY_STMT_IF_FEATURE, &choice->iffeatures, 0,
2317 LY_STMT_LEAF, &choice->child, 0,
2318 LY_STMT_LEAF_LIST, &choice->child, 0,
2319 LY_STMT_LIST, &choice->child, 0,
2320 LY_STMT_MANDATORY, &choice->flags, YIN_SUBELEM_UNIQUE,
2321 LY_STMT_REFERENCE, &choice->ref, YIN_SUBELEM_UNIQUE,
2322 LY_STMT_STATUS, &choice->flags, YIN_SUBELEM_UNIQUE,
2323 LY_STMT_WHEN, &choice->when, YIN_SUBELEM_UNIQUE,
2324 LY_STMT_EXTENSION_INSTANCE, NULL, 0
David Sedlák81497a32019-08-13 16:56:26 +02002325 ));
Michal Vaskob36053d2020-03-26 15:49:30 +01002326 ret = yin_parse_content(ctx, subelems, 17, LY_STMT_CHOICE, NULL, &choice->exts);
David Sedlák81497a32019-08-13 16:56:26 +02002327 subelems_deallocator(17, subelems);
2328 return ret;
David Sedlákb7abcfa2019-07-24 12:33:35 +02002329}
2330
2331/**
David Sedlák05404f62019-07-24 14:11:53 +02002332 * @brief Parse input or output element.
2333 *
2334 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlákbf8a2b72019-08-14 16:48:10 +02002335 * @param[in] inout_kw Identification of input/output element.
David Sedlák05404f62019-07-24 14:11:53 +02002336 * @param[in] inout_meta Meta information about parent node and siblings and input/output pointer to write to.
2337 *
2338 * @return LY_ERR values.
2339 */
2340static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002341yin_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 +02002342{
David Sedlák81497a32019-08-13 16:56:26 +02002343 LY_ERR ret = LY_SUCCESS;
2344 struct yin_subelement *subelems = NULL;
2345
David Sedlák05404f62019-07-24 14:11:53 +02002346 /* initiate structure */
Radek Krejcid6b76452019-09-03 17:03:03 +02002347 inout_meta->inout_p->nodetype = (inout_kw == LY_STMT_INPUT) ? LYS_INPUT : LYS_OUTPUT;
David Sedlák05404f62019-07-24 14:11:53 +02002348 inout_meta->inout_p->parent = inout_meta->parent;
2349
2350 /* check attributes */
Michal Vaskob36053d2020-03-26 15:49:30 +01002351 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2352 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 +02002353
2354 /* parser input/output content */
David Sedlák81497a32019-08-13 16:56:26 +02002355 LY_CHECK_RET(subelems_allocator(ctx, 12, (struct lysp_node *)inout_meta->inout_p, &subelems,
Radek Krejcid6b76452019-09-03 17:03:03 +02002356 LY_STMT_ANYDATA, &inout_meta->inout_p->data, YIN_SUBELEM_VER2,
2357 LY_STMT_ANYXML, &inout_meta->inout_p->data, 0,
2358 LY_STMT_CHOICE, &inout_meta->inout_p->data, 0,
2359 LY_STMT_CONTAINER, &inout_meta->inout_p->data, 0,
2360 LY_STMT_GROUPING, &inout_meta->inout_p->groupings, 0,
2361 LY_STMT_LEAF, &inout_meta->inout_p->data, 0,
2362 LY_STMT_LEAF_LIST, &inout_meta->inout_p->data, 0,
2363 LY_STMT_LIST, &inout_meta->inout_p->data, 0,
2364 LY_STMT_MUST, &inout_meta->inout_p->musts, YIN_SUBELEM_VER2,
2365 LY_STMT_TYPEDEF, &inout_meta->inout_p->typedefs, 0,
2366 LY_STMT_USES, &inout_meta->inout_p->data, 0,
2367 LY_STMT_EXTENSION_INSTANCE, NULL, 0
David Sedlák81497a32019-08-13 16:56:26 +02002368 ));
Michal Vaskob36053d2020-03-26 15:49:30 +01002369 ret = yin_parse_content(ctx, subelems, 12, inout_kw, NULL, &inout_meta->inout_p->exts);
David Sedlák81497a32019-08-13 16:56:26 +02002370 subelems_deallocator(12, subelems);
2371 LY_CHECK_RET(ret);
David Sedlák05404f62019-07-24 14:11:53 +02002372
Michal Vaskob83af8a2020-01-06 09:49:22 +01002373 if (!inout_meta->inout_p->data) {
2374 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_MISSTMT, "data-def-stmt", ly_stmt2str(inout_kw));
2375 return LY_EVALID;
2376 }
2377
David Sedlák05404f62019-07-24 14:11:53 +02002378 /* finalize parent pointers to the reallocated items */
David Sedlák81497a32019-08-13 16:56:26 +02002379 LY_CHECK_RET(lysp_parse_finalize_reallocated((struct lys_parser_ctx *)ctx, inout_meta->inout_p->groupings, NULL, NULL, NULL));
David Sedlák05404f62019-07-24 14:11:53 +02002380
2381 return LY_SUCCESS;
2382}
2383
David Sedlák992fb7c2019-07-24 16:51:01 +02002384/**
2385 * @brief Parse action element.
2386 *
2387 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák992fb7c2019-07-24 16:51:01 +02002388 * @param[in] act_meta Meta information about parent node and actions to add to.
2389 *
2390 * @return LY_ERR values.
2391 */
David Sedlák85d0eca2019-07-24 15:15:21 +02002392static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002393yin_parse_action(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *act_meta)
David Sedlák85d0eca2019-07-24 15:15:21 +02002394{
David Sedlákbf8a2b72019-08-14 16:48:10 +02002395 struct lysp_action *act, **acts = (struct lysp_action **)act_meta->nodes;
David Sedlák81497a32019-08-13 16:56:26 +02002396 LY_ERR ret = LY_SUCCESS;
2397 struct yin_subelement *subelems = NULL;
David Sedlák85d0eca2019-07-24 15:15:21 +02002398
2399 /* create new action */
Michal Vaskob36053d2020-03-26 15:49:30 +01002400 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *acts, act, LY_EMEM);
Michal Vasko1bf09392020-03-27 12:38:10 +01002401 act->nodetype = act_meta->parent ? LYS_ACTION : LYS_RPC;
David Sedlák85d0eca2019-07-24 15:15:21 +02002402 act->parent = act_meta->parent;
2403
2404 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002405 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2406 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &act->name, Y_IDENTIF_ARG, LY_STMT_ACTION));
David Sedlák85d0eca2019-07-24 15:15:21 +02002407
2408 /* parse content */
David Sedlák81497a32019-08-13 16:56:26 +02002409 LY_CHECK_RET(subelems_allocator(ctx, 9, (struct lysp_node *)act, &subelems,
Radek Krejcid6b76452019-09-03 17:03:03 +02002410 LY_STMT_DESCRIPTION, &act->dsc, YIN_SUBELEM_UNIQUE,
2411 LY_STMT_GROUPING, &act->groupings, 0,
2412 LY_STMT_IF_FEATURE, &act->iffeatures, 0,
2413 LY_STMT_INPUT, &act->input, YIN_SUBELEM_UNIQUE,
2414 LY_STMT_OUTPUT, &act->output, YIN_SUBELEM_UNIQUE,
2415 LY_STMT_REFERENCE, &act->ref, YIN_SUBELEM_UNIQUE,
2416 LY_STMT_STATUS, &act->flags, YIN_SUBELEM_UNIQUE,
2417 LY_STMT_TYPEDEF, &act->typedefs, 0,
2418 LY_STMT_EXTENSION_INSTANCE, NULL, 0
David Sedlák81497a32019-08-13 16:56:26 +02002419 ));
Michal Vaskob36053d2020-03-26 15:49:30 +01002420 ret = (yin_parse_content(ctx, subelems, 9, LY_STMT_ACTION, NULL, &act->exts));
David Sedlák81497a32019-08-13 16:56:26 +02002421 subelems_deallocator(9, subelems);
2422 LY_CHECK_RET(ret);
2423
Michal Vasko7f45cf22020-10-01 12:49:44 +02002424 /* always initialize inout, they are technically present (needed for later deviations/refines) */
2425 if (!act->input.nodetype) {
2426 act->input.nodetype = LYS_INPUT;
2427 act->input.parent = (struct lysp_node *)act;
2428 }
2429 if (!act->output.nodetype) {
2430 act->output.nodetype = LYS_OUTPUT;
2431 act->output.parent = (struct lysp_node *)act;
2432 }
2433
David Sedlák85d0eca2019-07-24 15:15:21 +02002434 LY_CHECK_RET(lysp_parse_finalize_reallocated((struct lys_parser_ctx *)ctx, act->groupings, NULL, NULL, NULL));
2435
2436 return LY_SUCCESS;
2437}
2438
David Sedlák05404f62019-07-24 14:11:53 +02002439/**
David Sedlák992fb7c2019-07-24 16:51:01 +02002440 * @brief Parse augment element.
2441 *
2442 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák992fb7c2019-07-24 16:51:01 +02002443 * @param[in] aug_meta Meta information about parent node and augments to add to.
2444 *
2445 * @return LY_ERR values.
2446 */
2447static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002448yin_parse_augment(struct lys_yin_parser_ctx *ctx, struct tree_node_meta *aug_meta)
David Sedlák992fb7c2019-07-24 16:51:01 +02002449{
2450 struct lysp_augment *aug;
David Sedlákbf8a2b72019-08-14 16:48:10 +02002451 struct lysp_augment **augs = (struct lysp_augment **)aug_meta->nodes;
David Sedlák81497a32019-08-13 16:56:26 +02002452 LY_ERR ret = LY_SUCCESS;
2453 struct yin_subelement *subelems = NULL;
David Sedlák992fb7c2019-07-24 16:51:01 +02002454
2455 /* create new augment */
Michal Vaskob36053d2020-03-26 15:49:30 +01002456 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *augs, aug, LY_EMEM);
David Sedlák992fb7c2019-07-24 16:51:01 +02002457 aug->nodetype = LYS_AUGMENT;
2458 aug->parent = aug_meta->parent;
2459
2460 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002461 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2462 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_TARGET_NODE, &aug->nodeid, Y_STR_ARG, LY_STMT_AUGMENT));
2463 CHECK_NONEMPTY((struct lys_parser_ctx *)ctx, strlen(aug->nodeid), "augment");
David Sedlák992fb7c2019-07-24 16:51:01 +02002464
2465 /* parser augment content */
David Sedlák81497a32019-08-13 16:56:26 +02002466 LY_CHECK_RET(subelems_allocator(ctx, 17, (struct lysp_node *)aug, &subelems,
Radek Krejcid6b76452019-09-03 17:03:03 +02002467 LY_STMT_ACTION, &aug->actions, YIN_SUBELEM_VER2,
2468 LY_STMT_ANYDATA, &aug->child, YIN_SUBELEM_VER2,
2469 LY_STMT_ANYXML, &aug->child, 0,
2470 LY_STMT_CASE, &aug->child, 0,
2471 LY_STMT_CHOICE, &aug->child, 0,
2472 LY_STMT_CONTAINER, &aug->child, 0,
2473 LY_STMT_DESCRIPTION, &aug->dsc, YIN_SUBELEM_UNIQUE,
Michal Vasko7f45cf22020-10-01 12:49:44 +02002474 LY_STMT_IF_FEATURE, &aug->iffeatures, YIN_SUBELEM_TEXT,
Radek Krejcid6b76452019-09-03 17:03:03 +02002475 LY_STMT_LEAF, &aug->child, 0,
2476 LY_STMT_LEAF_LIST, &aug->child, 0,
2477 LY_STMT_LIST, &aug->child, 0,
2478 LY_STMT_NOTIFICATION, &aug->notifs, YIN_SUBELEM_VER2,
2479 LY_STMT_REFERENCE, &aug->ref, YIN_SUBELEM_UNIQUE,
2480 LY_STMT_STATUS, &aug->flags, YIN_SUBELEM_UNIQUE,
2481 LY_STMT_USES, &aug->child, 0,
2482 LY_STMT_WHEN, &aug->when, YIN_SUBELEM_UNIQUE,
2483 LY_STMT_EXTENSION_INSTANCE, NULL, 0
David Sedlák81497a32019-08-13 16:56:26 +02002484 ));
Michal Vaskob36053d2020-03-26 15:49:30 +01002485 ret = yin_parse_content(ctx, subelems, 17, LY_STMT_AUGMENT, NULL, &aug->exts);
David Sedlák81497a32019-08-13 16:56:26 +02002486 subelems_deallocator(17, subelems);
2487 LY_CHECK_RET(ret);
David Sedlák992fb7c2019-07-24 16:51:01 +02002488
2489 LY_CHECK_RET(lysp_parse_finalize_reallocated((struct lys_parser_ctx *)ctx, NULL, NULL, aug->actions, aug->notifs));
2490
2491 return LY_SUCCESS;
2492}
2493
David Sedlák8b754462019-07-25 16:22:13 +02002494/**
2495 * @brief Parse deviate element.
2496 *
2497 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák8b754462019-07-25 16:22:13 +02002498 * @param[in] deviates Deviates to add to.
2499 *
2500 * @return LY_ERR values.
2501 */
David Sedlák4ffcec82019-07-25 15:10:21 +02002502static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002503yin_parse_deviate(struct lys_yin_parser_ctx *ctx, struct lysp_deviate **deviates)
David Sedlák4ffcec82019-07-25 15:10:21 +02002504{
2505 LY_ERR ret = LY_SUCCESS;
2506 uint8_t dev_mod;
2507 const char *temp_val;
David Sedlák8d552d62019-08-06 15:29:05 +02002508 struct lysp_deviate *d;
David Sedlák4ffcec82019-07-25 15:10:21 +02002509 struct lysp_deviate_add *d_add = NULL;
2510 struct lysp_deviate_rpl *d_rpl = NULL;
2511 struct lysp_deviate_del *d_del = NULL;
2512
2513 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002514 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2515 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 +02002516
2517 if (strcmp(temp_val, "not-supported") == 0) {
2518 dev_mod = LYS_DEV_NOT_SUPPORTED;
2519 } else if (strcmp(temp_val, "add") == 0) {
2520 dev_mod = LYS_DEV_ADD;
2521 } else if (strcmp(temp_val, "replace") == 0) {
2522 dev_mod = LYS_DEV_REPLACE;
2523 } else if (strcmp(temp_val, "delete") == 0) {
2524 dev_mod = LYS_DEV_DELETE;
2525 } else {
David Sedlák26ea1432019-08-14 13:42:23 +02002526 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INVAL_YIN VALID_VALS4, temp_val, "value", "deviate",
2527 "not-supported", "add", "replace", "delete");
Michal Vaskob36053d2020-03-26 15:49:30 +01002528 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlák4ffcec82019-07-25 15:10:21 +02002529 return LY_EVALID;
2530 }
Michal Vaskob36053d2020-03-26 15:49:30 +01002531 FREE_STRING(ctx->xmlctx->ctx, temp_val);
David Sedlák4ffcec82019-07-25 15:10:21 +02002532
2533 if (dev_mod == LYS_DEV_NOT_SUPPORTED) {
2534 d = calloc(1, sizeof *d);
Michal Vaskob36053d2020-03-26 15:49:30 +01002535 LY_CHECK_ERR_RET(!d, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
David Sedlák4ffcec82019-07-25 15:10:21 +02002536 struct yin_subelement subelems[1] = {
Radek Krejci0f969882020-08-21 16:56:47 +02002537 {LY_STMT_EXTENSION_INSTANCE, NULL, 0}
2538 };
Michal Vaskob36053d2020-03-26 15:49:30 +01002539 ret = yin_parse_content(ctx, subelems, 1, LY_STMT_DEVIATE, NULL, &d->exts);
David Sedlák4ffcec82019-07-25 15:10:21 +02002540
2541 } else if (dev_mod == LYS_DEV_ADD) {
2542 d_add = calloc(1, sizeof *d_add);
Michal Vaskob36053d2020-03-26 15:49:30 +01002543 LY_CHECK_ERR_RET(!d_add, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
David Sedlák4ffcec82019-07-25 15:10:21 +02002544 d = (struct lysp_deviate *)d_add;
2545 struct minmax_dev_meta min = {&d_add->min, &d_add->flags, &d_add->exts};
2546 struct minmax_dev_meta max = {&d_add->max, &d_add->flags, &d_add->exts};
2547 struct yin_subelement subelems[9] = {
Radek Krejci0f969882020-08-21 16:56:47 +02002548 {LY_STMT_CONFIG, &d_add->flags, YIN_SUBELEM_UNIQUE},
Michal Vasko7f45cf22020-10-01 12:49:44 +02002549 {LY_STMT_DEFAULT, &d_add->dflts, YIN_SUBELEM_TEXT},
Radek Krejci0f969882020-08-21 16:56:47 +02002550 {LY_STMT_MANDATORY, &d_add->flags, YIN_SUBELEM_UNIQUE},
2551 {LY_STMT_MAX_ELEMENTS, &max, YIN_SUBELEM_UNIQUE},
2552 {LY_STMT_MIN_ELEMENTS, &min, YIN_SUBELEM_UNIQUE},
2553 {LY_STMT_MUST, &d_add->musts, 0},
2554 {LY_STMT_UNIQUE, &d_add->uniques, 0},
2555 {LY_STMT_UNITS, &d_add->units, YIN_SUBELEM_UNIQUE},
2556 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
2557 };
Michal Vaskob36053d2020-03-26 15:49:30 +01002558 ret = yin_parse_content(ctx, subelems, 9, LY_STMT_DEVIATE, NULL, &d_add->exts);
David Sedlák4ffcec82019-07-25 15:10:21 +02002559
2560 } else if (dev_mod == LYS_DEV_REPLACE) {
2561 d_rpl = calloc(1, sizeof *d_rpl);
Michal Vaskob36053d2020-03-26 15:49:30 +01002562 LY_CHECK_ERR_RET(!d_rpl, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
David Sedlák4ffcec82019-07-25 15:10:21 +02002563 d = (struct lysp_deviate *)d_rpl;
2564 struct minmax_dev_meta min = {&d_rpl->min, &d_rpl->flags, &d_rpl->exts};
2565 struct minmax_dev_meta max = {&d_rpl->max, &d_rpl->flags, &d_rpl->exts};
2566 struct yin_subelement subelems[8] = {
Radek Krejci0f969882020-08-21 16:56:47 +02002567 {LY_STMT_CONFIG, &d_rpl->flags, YIN_SUBELEM_UNIQUE},
Michal Vasko7f45cf22020-10-01 12:49:44 +02002568 {LY_STMT_DEFAULT, &d_rpl->dflt, YIN_SUBELEM_UNIQUE | YIN_SUBELEM_TEXT},
Radek Krejci0f969882020-08-21 16:56:47 +02002569 {LY_STMT_MANDATORY, &d_rpl->flags, YIN_SUBELEM_UNIQUE},
2570 {LY_STMT_MAX_ELEMENTS, &max, YIN_SUBELEM_UNIQUE},
2571 {LY_STMT_MIN_ELEMENTS, &min, YIN_SUBELEM_UNIQUE},
2572 {LY_STMT_TYPE, &d_rpl->type, YIN_SUBELEM_UNIQUE},
2573 {LY_STMT_UNITS, &d_rpl->units, YIN_SUBELEM_UNIQUE},
2574 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
2575 };
Michal Vaskob36053d2020-03-26 15:49:30 +01002576 ret = yin_parse_content(ctx, subelems, 8, LY_STMT_DEVIATE, NULL, &d_rpl->exts);
David Sedlák4ffcec82019-07-25 15:10:21 +02002577
2578 } else {
2579 d_del = calloc(1, sizeof *d_del);
Michal Vaskob36053d2020-03-26 15:49:30 +01002580 LY_CHECK_ERR_RET(!d_del, LOGMEM(ctx->xmlctx->ctx), LY_EMEM);
David Sedlák4ffcec82019-07-25 15:10:21 +02002581 d = (struct lysp_deviate *)d_del;
2582 struct yin_subelement subelems[5] = {
Michal Vasko7f45cf22020-10-01 12:49:44 +02002583 {LY_STMT_DEFAULT, &d_del->dflts, YIN_SUBELEM_TEXT},
Radek Krejci0f969882020-08-21 16:56:47 +02002584 {LY_STMT_MUST, &d_del->musts, 0},
2585 {LY_STMT_UNIQUE, &d_del->uniques, 0},
2586 {LY_STMT_UNITS, &d_del->units, YIN_SUBELEM_UNIQUE},
2587 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
2588 };
Michal Vaskob36053d2020-03-26 15:49:30 +01002589 ret = yin_parse_content(ctx, subelems, 5, LY_STMT_DEVIATE, NULL, &d_del->exts);
David Sedlák4ffcec82019-07-25 15:10:21 +02002590 }
2591 LY_CHECK_GOTO(ret, cleanup);
2592
2593 d->mod = dev_mod;
2594 /* insert into siblings */
David Sedlák8d552d62019-08-06 15:29:05 +02002595 LY_LIST_INSERT(deviates, d, next);
David Sedlák4ffcec82019-07-25 15:10:21 +02002596
2597 return ret;
2598
2599cleanup:
2600 free(d);
David Sedlák4ffcec82019-07-25 15:10:21 +02002601 return ret;
2602}
2603
David Sedlák992fb7c2019-07-24 16:51:01 +02002604/**
David Sedlák8b754462019-07-25 16:22:13 +02002605 * @brief Parse deviation element.
2606 *
2607 * @param[in,out] ctx YIN parser context for logging and to store current state.
David Sedlák8b754462019-07-25 16:22:13 +02002608 * @param[in] deviations Deviations to add to.
2609 *
2610 * @return LY_ERR values.
2611 */
2612static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002613yin_parse_deviation(struct lys_yin_parser_ctx *ctx, struct lysp_deviation **deviations)
David Sedlák8b754462019-07-25 16:22:13 +02002614{
2615 struct lysp_deviation *dev;
2616
2617 /* create new deviation */
Michal Vaskob36053d2020-03-26 15:49:30 +01002618 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *deviations, dev, LY_EMEM);
David Sedlák8b754462019-07-25 16:22:13 +02002619
2620 /* parse argument */
Michal Vaskob36053d2020-03-26 15:49:30 +01002621 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
2622 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_TARGET_NODE, &dev->nodeid, Y_STR_ARG, LY_STMT_DEVIATION));
2623 CHECK_NONEMPTY((struct lys_parser_ctx *)ctx, strlen(dev->nodeid), "deviation");
David Sedlák8b754462019-07-25 16:22:13 +02002624 struct yin_subelement subelems[4] = {
Radek Krejci0f969882020-08-21 16:56:47 +02002625 {LY_STMT_DESCRIPTION, &dev->dsc, YIN_SUBELEM_UNIQUE},
2626 {LY_STMT_DEVIATE, &dev->deviates, YIN_SUBELEM_MANDATORY},
2627 {LY_STMT_REFERENCE, &dev->ref, YIN_SUBELEM_UNIQUE},
2628 {LY_STMT_EXTENSION_INSTANCE, NULL, 0},
2629 };
Michal Vaskob36053d2020-03-26 15:49:30 +01002630 return yin_parse_content(ctx, subelems, 4, LY_STMT_DEVIATION, NULL, &dev->exts);
David Sedlák8b754462019-07-25 16:22:13 +02002631}
2632
2633/**
David Sedlákb4e44562019-07-04 15:42:12 +02002634 * @brief Map keyword type to substatement info.
2635 *
2636 * @param[in] kw Keyword type.
2637 *
2638 * @return correct LYEXT_SUBSTMT information.
2639 */
2640static LYEXT_SUBSTMT
Radek Krejcid6b76452019-09-03 17:03:03 +02002641kw2lyext_substmt(enum ly_stmt kw)
David Sedlákb4e44562019-07-04 15:42:12 +02002642{
2643 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002644 case LY_STMT_ARGUMENT:
David Sedlákb4e44562019-07-04 15:42:12 +02002645 return LYEXT_SUBSTMT_ARGUMENT;
Radek Krejcid6b76452019-09-03 17:03:03 +02002646 case LY_STMT_BASE:
David Sedlákb4e44562019-07-04 15:42:12 +02002647 return LYEXT_SUBSTMT_BASE;
Radek Krejcid6b76452019-09-03 17:03:03 +02002648 case LY_STMT_BELONGS_TO:
David Sedlákb4e44562019-07-04 15:42:12 +02002649 return LYEXT_SUBSTMT_BELONGSTO;
Radek Krejcid6b76452019-09-03 17:03:03 +02002650 case LY_STMT_CONTACT:
David Sedlákb4e44562019-07-04 15:42:12 +02002651 return LYEXT_SUBSTMT_CONTACT;
Radek Krejcid6b76452019-09-03 17:03:03 +02002652 case LY_STMT_DEFAULT:
David Sedlákb4e44562019-07-04 15:42:12 +02002653 return LYEXT_SUBSTMT_DEFAULT;
Radek Krejcid6b76452019-09-03 17:03:03 +02002654 case LY_STMT_DESCRIPTION:
David Sedlákb4e44562019-07-04 15:42:12 +02002655 return LYEXT_SUBSTMT_DESCRIPTION;
Radek Krejcid6b76452019-09-03 17:03:03 +02002656 case LY_STMT_ERROR_APP_TAG:
David Sedlákb4e44562019-07-04 15:42:12 +02002657 return LYEXT_SUBSTMT_ERRTAG;
Radek Krejcid6b76452019-09-03 17:03:03 +02002658 case LY_STMT_ERROR_MESSAGE:
David Sedlákb4e44562019-07-04 15:42:12 +02002659 return LYEXT_SUBSTMT_ERRMSG;
Radek Krejcid6b76452019-09-03 17:03:03 +02002660 case LY_STMT_KEY:
David Sedlákb4e44562019-07-04 15:42:12 +02002661 return LYEXT_SUBSTMT_KEY;
Radek Krejcid6b76452019-09-03 17:03:03 +02002662 case LY_STMT_NAMESPACE:
David Sedlákb4e44562019-07-04 15:42:12 +02002663 return LYEXT_SUBSTMT_NAMESPACE;
Radek Krejcid6b76452019-09-03 17:03:03 +02002664 case LY_STMT_ORGANIZATION:
David Sedlákb4e44562019-07-04 15:42:12 +02002665 return LYEXT_SUBSTMT_ORGANIZATION;
Radek Krejcid6b76452019-09-03 17:03:03 +02002666 case LY_STMT_PATH:
David Sedlákb4e44562019-07-04 15:42:12 +02002667 return LYEXT_SUBSTMT_PATH;
Radek Krejcid6b76452019-09-03 17:03:03 +02002668 case LY_STMT_PREFIX:
David Sedlákb4e44562019-07-04 15:42:12 +02002669 return LYEXT_SUBSTMT_PREFIX;
Radek Krejcid6b76452019-09-03 17:03:03 +02002670 case LY_STMT_PRESENCE:
David Sedlákb4e44562019-07-04 15:42:12 +02002671 return LYEXT_SUBSTMT_PRESENCE;
Radek Krejcid6b76452019-09-03 17:03:03 +02002672 case LY_STMT_REFERENCE:
David Sedlákb4e44562019-07-04 15:42:12 +02002673 return LYEXT_SUBSTMT_REFERENCE;
Radek Krejcid6b76452019-09-03 17:03:03 +02002674 case LY_STMT_REVISION_DATE:
David Sedlákb4e44562019-07-04 15:42:12 +02002675 return LYEXT_SUBSTMT_REVISIONDATE;
Radek Krejcid6b76452019-09-03 17:03:03 +02002676 case LY_STMT_UNITS:
David Sedlákb4e44562019-07-04 15:42:12 +02002677 return LYEXT_SUBSTMT_UNITS;
Radek Krejcid6b76452019-09-03 17:03:03 +02002678 case LY_STMT_VALUE:
David Sedlákb4e44562019-07-04 15:42:12 +02002679 return LYEXT_SUBSTMT_VALUE;
Radek Krejcid6b76452019-09-03 17:03:03 +02002680 case LY_STMT_YANG_VERSION:
David Sedlákb4e44562019-07-04 15:42:12 +02002681 return LYEXT_SUBSTMT_VERSION;
Radek Krejcid6b76452019-09-03 17:03:03 +02002682 case LY_STMT_MODIFIER:
David Sedlákb4e44562019-07-04 15:42:12 +02002683 return LYEXT_SUBSTMT_MODIFIER;
Radek Krejcid6b76452019-09-03 17:03:03 +02002684 case LY_STMT_REQUIRE_INSTANCE:
David Sedlákb4e44562019-07-04 15:42:12 +02002685 return LYEXT_SUBSTMT_REQINSTANCE;
Radek Krejcid6b76452019-09-03 17:03:03 +02002686 case LY_STMT_YIN_ELEMENT:
David Sedlákb4e44562019-07-04 15:42:12 +02002687 return LYEXT_SUBSTMT_YINELEM;
Radek Krejcid6b76452019-09-03 17:03:03 +02002688 case LY_STMT_CONFIG:
David Sedlákb4e44562019-07-04 15:42:12 +02002689 return LYEXT_SUBSTMT_CONFIG;
Radek Krejcid6b76452019-09-03 17:03:03 +02002690 case LY_STMT_MANDATORY:
David Sedlákb4e44562019-07-04 15:42:12 +02002691 return LYEXT_SUBSTMT_MANDATORY;
Radek Krejcid6b76452019-09-03 17:03:03 +02002692 case LY_STMT_ORDERED_BY:
David Sedlákb4e44562019-07-04 15:42:12 +02002693 return LYEXT_SUBSTMT_ORDEREDBY;
Radek Krejcid6b76452019-09-03 17:03:03 +02002694 case LY_STMT_STATUS:
David Sedlákb4e44562019-07-04 15:42:12 +02002695 return LYEXT_SUBSTMT_STATUS;
Radek Krejcid6b76452019-09-03 17:03:03 +02002696 case LY_STMT_FRACTION_DIGITS:
David Sedlákb4e44562019-07-04 15:42:12 +02002697 return LYEXT_SUBSTMT_FRACDIGITS;
Radek Krejcid6b76452019-09-03 17:03:03 +02002698 case LY_STMT_MAX_ELEMENTS:
David Sedlákb4e44562019-07-04 15:42:12 +02002699 return LYEXT_SUBSTMT_MAX;
Radek Krejcid6b76452019-09-03 17:03:03 +02002700 case LY_STMT_MIN_ELEMENTS:
David Sedlákb4e44562019-07-04 15:42:12 +02002701 return LYEXT_SUBSTMT_MIN;
Radek Krejcid6b76452019-09-03 17:03:03 +02002702 case LY_STMT_POSITION:
David Sedlákb4e44562019-07-04 15:42:12 +02002703 return LYEXT_SUBSTMT_POSITION;
Radek Krejcid6b76452019-09-03 17:03:03 +02002704 case LY_STMT_UNIQUE:
David Sedlákb4e44562019-07-04 15:42:12 +02002705 return LYEXT_SUBSTMT_UNIQUE;
Radek Krejcid6b76452019-09-03 17:03:03 +02002706 case LY_STMT_IF_FEATURE:
David Sedlákb4e44562019-07-04 15:42:12 +02002707 return LYEXT_SUBSTMT_IFFEATURE;
2708 default:
2709 return LYEXT_SUBSTMT_SELF;
2710 }
2711}
2712
David Sedlákc5b20842019-08-13 10:18:31 +02002713/**
2714 * @brief map keyword to keyword-group.
2715 *
2716 * @param[in] ctx YIN parser context used for logging.
2717 * @param[in] kw Keyword that is child of module or submodule.
2718 * @param[out] group Group of keyword.
2719 *
2720 * @return LY_SUCCESS on success LY_EINT if kw can't be mapped to kw_group, should not happen if called correctly.
2721 */
David Sedláke6cd89e2019-08-07 12:46:02 +02002722static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002723kw2kw_group(struct lys_yin_parser_ctx *ctx, enum ly_stmt kw, enum yang_module_stmt *group)
David Sedláke6cd89e2019-08-07 12:46:02 +02002724{
2725 switch (kw) {
Radek Krejci0f969882020-08-21 16:56:47 +02002726 /* module header */
2727 case LY_STMT_NONE:
2728 case LY_STMT_NAMESPACE:
2729 case LY_STMT_PREFIX:
2730 case LY_STMT_BELONGS_TO:
2731 case LY_STMT_YANG_VERSION:
2732 *group = Y_MOD_MODULE_HEADER;
2733 break;
2734 /* linkage */
2735 case LY_STMT_INCLUDE:
2736 case LY_STMT_IMPORT:
2737 *group = Y_MOD_LINKAGE;
2738 break;
2739 /* meta */
2740 case LY_STMT_ORGANIZATION:
2741 case LY_STMT_CONTACT:
2742 case LY_STMT_DESCRIPTION:
2743 case LY_STMT_REFERENCE:
2744 *group = Y_MOD_META;
2745 break;
2746 /* revision */
2747 case LY_STMT_REVISION:
2748 *group = Y_MOD_REVISION;
2749 break;
2750 /* body */
2751 case LY_STMT_ANYDATA:
2752 case LY_STMT_ANYXML:
2753 case LY_STMT_AUGMENT:
2754 case LY_STMT_CHOICE:
2755 case LY_STMT_CONTAINER:
2756 case LY_STMT_DEVIATION:
2757 case LY_STMT_EXTENSION:
2758 case LY_STMT_FEATURE:
2759 case LY_STMT_GROUPING:
2760 case LY_STMT_IDENTITY:
2761 case LY_STMT_LEAF:
2762 case LY_STMT_LEAF_LIST:
2763 case LY_STMT_LIST:
2764 case LY_STMT_NOTIFICATION:
2765 case LY_STMT_RPC:
2766 case LY_STMT_TYPEDEF:
2767 case LY_STMT_USES:
2768 case LY_STMT_EXTENSION_INSTANCE:
2769 *group = Y_MOD_BODY;
2770 break;
2771 default:
2772 LOGINT(ctx->xmlctx->ctx);
2773 return LY_EINT;
David Sedláke6cd89e2019-08-07 12:46:02 +02002774 }
2775
2776 return LY_SUCCESS;
2777}
2778
David Sedlákc5b20842019-08-13 10:18:31 +02002779/**
2780 * @brief Check if relative order of two keywords is valid.
2781 *
2782 * @param[in] ctx YIN parser context used for logging.
2783 * @param[in] kw Current keyword.
2784 * @param[in] next_kw Next keyword.
Radek Krejcid6b76452019-09-03 17:03:03 +02002785 * @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 +02002786 * because relative order is required only in module and submodule sub-elements, used for logging.
2787 *
David Sedlákbf8a2b72019-08-14 16:48:10 +02002788 * @return LY_SUCCESS on success and LY_EVALID if relative order is invalid.
David Sedlákc5b20842019-08-13 10:18:31 +02002789 */
David Sedláke6cd89e2019-08-07 12:46:02 +02002790static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002791yin_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 +02002792{
Radek Krejcid6b76452019-09-03 17:03:03 +02002793 assert(parrent == LY_STMT_MODULE || parrent == LY_STMT_SUBMODULE);
David Sedláke6cd89e2019-08-07 12:46:02 +02002794 enum yang_module_stmt gr, next_gr;
2795
2796 LY_CHECK_RET(kw2kw_group(ctx, kw, &gr));
2797 LY_CHECK_RET(kw2kw_group(ctx, next_kw, &next_gr));
2798
2799 if (gr > next_gr) {
2800 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INORDER_YIN, ly_stmt2str(parrent), ly_stmt2str(next_kw), ly_stmt2str(kw));
2801 return LY_EVALID;
2802 }
2803
2804 return LY_SUCCESS;
2805}
2806
David Sedlákc5dd0942019-09-13 10:23:59 +02002807/**
2808 * @brief Get element name prefixed by full URI of xml namespace.
2809 *
2810 * @param[in] ctx YIN parser context used for logging and to get inormation about xml namespaces.
2811 * @param[in] name Name of element.
2812 * @param[in] name_len Length of element name.
2813 * @param[in] prefix Prefix of element.
2814 * @param[in] prefix_len Length of element prefix.
2815 *
2816 * @return Element name prefixed by URI on success, NULL on failure.
2817 */
2818static const char *
Michal Vaskob36053d2020-03-26 15:49:30 +01002819name2nsname(struct lys_yin_parser_ctx *ctx, const char *name, size_t name_len, const char *prefix, size_t prefix_len)
David Sedlák068dd352019-09-13 09:08:22 +02002820{
Radek Krejci011e4aa2020-09-04 15:22:31 +02002821 const char *ename = NULL;
Michal Vaskoc8a230d2020-08-14 12:17:10 +02002822 const struct lyxml_ns *ns = lyxml_ns_get(&ctx->xmlctx->ns, prefix, prefix_len);
Radek Krejci011e4aa2020-09-04 15:22:31 +02002823
Michal Vaskob36053d2020-03-26 15:49:30 +01002824 LY_CHECK_ERR_RET(!ns, LOGINT(ctx->xmlctx->ctx), NULL);
David Sedlák068dd352019-09-13 09:08:22 +02002825
Radek Krejci02728562019-09-18 14:13:05 +02002826 if (!strcmp(ns->uri, YIN_NS_URI)) {
2827 /* standard YANG statement in YIN namespace - keep it unprefixed as in case of YANG */
Radek Krejci011e4aa2020-09-04 15:22:31 +02002828 lydict_insert(ctx->xmlctx->ctx, name, name_len, &ename);
2829 return ename;
Radek Krejci02728562019-09-18 14:13:05 +02002830 }
2831 /* some statement in special namespace (extension instance) */
David Sedláke0ef1c62019-09-13 10:05:55 +02002832 size_t ns_len = strlen(ns->uri);
2833 size_t len = ns_len + name_len + 1; /* +1 because of ':' delimiter between ns and actual name */
2834
2835 char *result;
2836 char *temp;
2837 temp = result = malloc(sizeof(*temp) * (len + 1)); /* +1 for '\0' terminator */
Michal Vaskob36053d2020-03-26 15:49:30 +01002838 LY_CHECK_ERR_RET(!temp, LOGMEM(ctx->xmlctx->ctx), NULL);
David Sedláke0ef1c62019-09-13 10:05:55 +02002839
2840 strcpy(result, ns->uri);
2841 result[ns_len] = ':';
2842 temp = &result[ns_len + 1];
2843 strncpy(temp, name, name_len);
2844 result[len] = '\0';
2845
Radek Krejci011e4aa2020-09-04 15:22:31 +02002846 lydict_insert_zc(ctx->xmlctx->ctx, result, &ename);
2847 return ename;
David Sedlák068dd352019-09-13 09:08:22 +02002848}
2849
David Sedlákd6e56892019-07-01 15:40:24 +02002850LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01002851yin_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 +02002852 enum ly_stmt current_element, const char **text_content, struct lysp_ext_instance **exts)
David Sedlákd6e56892019-07-01 15:40:24 +02002853{
2854 LY_ERR ret = LY_SUCCESS;
Michal Vaskob36053d2020-03-26 15:49:30 +01002855 enum LYXML_PARSER_STATUS next_status;
Radek Krejcid6b76452019-09-03 17:03:03 +02002856 enum ly_stmt kw = LY_STMT_NONE, last_kw = LY_STMT_NONE;
David Sedlák1af868e2019-07-17 17:03:14 +02002857 struct yin_subelement *subelem = NULL;
David Sedlák09e18c92019-07-18 11:17:11 +02002858
Michal Vaskob36053d2020-03-26 15:49:30 +01002859 assert(ctx->xmlctx->status == LYXML_ELEM_CONTENT);
David Sedlákd6e56892019-07-01 15:40:24 +02002860
Michal Vaskob36053d2020-03-26 15:49:30 +01002861 if (ctx->xmlctx->ws_only) {
2862 /* check whether there are any children */
2863 LY_CHECK_GOTO(ret = lyxml_ctx_peek(ctx->xmlctx, &next_status), cleanup);
2864 } else {
2865 /* we want to parse the value */
2866 next_status = LYXML_ELEM_CLOSE;
2867 }
2868
2869 if (next_status == LYXML_ELEMENT) {
2870 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
2871
2872 /* current element has subelements as content */
2873 while (ctx->xmlctx->status == LYXML_ELEMENT) {
2874 /* match keyword */
2875 last_kw = kw;
2876 kw = yin_match_keyword(ctx, ctx->xmlctx->name, ctx->xmlctx->name_len, ctx->xmlctx->prefix,
2877 ctx->xmlctx->prefix_len, current_element);
2878
2879 /* check if this element can be child of current element */
2880 subelem = get_record(kw, subelem_info_size, subelem_info);
2881 if (!subelem) {
2882 if (current_element == LY_STMT_DEVIATE && isdevsub(kw)) {
2883 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_INDEV_YIN, ly_stmt2str(kw));
2884 } else {
2885 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_UNEXP_SUBELEM, ctx->xmlctx->name_len,
2886 ctx->xmlctx->name, ly_stmt2str(current_element));
2887 }
2888 ret = LY_EVALID;
2889 goto cleanup;
2890 }
2891
2892 /* relative order is required only in module and submodule sub-elements */
2893 if (current_element == LY_STMT_MODULE || current_element == LY_STMT_SUBMODULE) {
2894 ret = yin_check_relative_order(ctx, last_kw, kw, current_element);
2895 LY_CHECK_GOTO(ret, cleanup);
2896 }
2897
2898 /* flag check */
2899 if ((subelem->flags & YIN_SUBELEM_UNIQUE) && (subelem->flags & YIN_SUBELEM_PARSED)) {
2900 /* subelement uniquenes */
2901 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_SUBELEM_REDEF, ly_stmt2str(kw), ly_stmt2str(current_element));
2902 return LY_EVALID;
2903 }
2904 if (subelem->flags & YIN_SUBELEM_FIRST) {
2905 /* subelement is supposed to be defined as first subelement */
2906 ret = yin_check_subelem_first_constraint(ctx, subelem_info, subelem_info_size, current_element, subelem);
2907 LY_CHECK_GOTO(ret, cleanup);
2908 }
2909 if (subelem->flags & YIN_SUBELEM_VER2) {
2910 /* subelement is supported only in version 1.1 or higher */
2911 if (ctx->mod_version < 2) {
2912 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 +02002913 ret = LY_EVALID;
2914 goto cleanup;
2915 }
David Sedlákd6e56892019-07-01 15:40:24 +02002916 }
Michal Vaskob36053d2020-03-26 15:49:30 +01002917 /* note that element was parsed for easy uniqueness check in next iterations */
2918 subelem->flags |= YIN_SUBELEM_PARSED;
2919
2920 switch (kw) {
2921 /* call responsible function */
2922 case LY_STMT_EXTENSION_INSTANCE:
2923 ret = yin_parse_extension_instance(ctx, kw2lyext_substmt(current_element),
Michal Vasko22df3f02020-08-24 13:29:22 +02002924 (subelem->dest) ? *((LY_ARRAY_COUNT_TYPE *)subelem->dest) : 0, exts);
Michal Vaskob36053d2020-03-26 15:49:30 +01002925 break;
2926 case LY_STMT_ACTION:
2927 case LY_STMT_RPC:
2928 ret = yin_parse_action(ctx, (struct tree_node_meta *)subelem->dest);
2929 break;
2930 case LY_STMT_ANYDATA:
2931 case LY_STMT_ANYXML:
2932 ret = yin_parse_any(ctx, kw, (struct tree_node_meta *)subelem->dest);
2933 break;
2934 case LY_STMT_ARGUMENT:
2935 ret = yin_parse_argument(ctx, (struct yin_argument_meta *)subelem->dest, exts);
2936 break;
2937 case LY_STMT_AUGMENT:
2938 ret = yin_parse_augment(ctx, (struct tree_node_meta *)subelem->dest);
2939 break;
2940 case LY_STMT_BASE:
2941 ret = yin_parse_base(ctx, current_element, subelem->dest, exts);
2942 break;
2943 case LY_STMT_BELONGS_TO:
2944 ret = yin_parse_belongs_to(ctx, (struct lysp_submodule *)subelem->dest, exts);
2945 break;
2946 case LY_STMT_BIT:
2947 ret = yin_parse_bit(ctx, (struct lysp_type *)subelem->dest);
2948 break;
2949 case LY_STMT_CASE:
2950 ret = yin_parse_case(ctx, (struct tree_node_meta *)subelem->dest);
2951 break;
2952 case LY_STMT_CHOICE:
2953 ret = yin_parse_choice(ctx, (struct tree_node_meta *)subelem->dest);
2954 break;
2955 case LY_STMT_CONFIG:
2956 ret = yin_parse_config(ctx, (uint16_t *)subelem->dest, exts);
2957 break;
2958 case LY_STMT_CONTACT:
2959 case LY_STMT_DESCRIPTION:
2960 case LY_STMT_ORGANIZATION:
2961 case LY_STMT_REFERENCE:
2962 ret = yin_parse_meta(ctx, kw, (const char **)subelem->dest, exts);
2963 break;
2964 case LY_STMT_CONTAINER:
2965 ret = yin_parse_container(ctx, (struct tree_node_meta *)subelem->dest);
2966 break;
2967 case LY_STMT_DEFAULT:
Michal Vasko7f45cf22020-10-01 12:49:44 +02002968 ret = yin_parse_qname(ctx, kw, subelem, exts);
2969 break;
Michal Vaskob36053d2020-03-26 15:49:30 +01002970 case LY_STMT_ERROR_APP_TAG:
2971 case LY_STMT_KEY:
2972 case LY_STMT_PRESENCE:
2973 ret = yin_parse_simple_elem(ctx, kw, subelem, YIN_ARG_VALUE, Y_STR_ARG, exts);
2974 break;
2975 case LY_STMT_DEVIATE:
2976 ret = yin_parse_deviate(ctx, (struct lysp_deviate **)subelem->dest);
2977 break;
2978 case LY_STMT_DEVIATION:
2979 ret = yin_parse_deviation(ctx, (struct lysp_deviation **)subelem->dest);
2980 break;
2981 case LY_STMT_ENUM:
2982 ret = yin_parse_enum(ctx, (struct lysp_type *)subelem->dest);
2983 break;
2984 case LY_STMT_ERROR_MESSAGE:
2985 ret = yin_parse_err_msg(ctx, (const char **)subelem->dest, exts);
2986 break;
2987 case LY_STMT_EXTENSION:
2988 ret = yin_parse_extension(ctx, (struct lysp_ext **)subelem->dest);
2989 break;
2990 case LY_STMT_FEATURE:
2991 ret = yin_parse_feature(ctx, (struct lysp_feature **)subelem->dest);
2992 break;
2993 case LY_STMT_FRACTION_DIGITS:
2994 ret = yin_parse_fracdigits(ctx, (struct lysp_type *)subelem->dest);
2995 break;
2996 case LY_STMT_GROUPING:
2997 ret = yin_parse_grouping(ctx, (struct tree_node_meta *)subelem->dest);
2998 break;
2999 case LY_STMT_IDENTITY:
3000 ret = yin_parse_identity(ctx, (struct lysp_ident **)subelem->dest);
3001 break;
3002 case LY_STMT_IF_FEATURE:
Michal Vasko7f45cf22020-10-01 12:49:44 +02003003 ret = yin_parse_qname(ctx, kw, subelem, exts);
3004 break;
Michal Vaskob36053d2020-03-26 15:49:30 +01003005 case LY_STMT_UNITS:
3006 ret = yin_parse_simple_elem(ctx, kw, subelem, YIN_ARG_NAME, Y_STR_ARG, exts);
3007 break;
3008 case LY_STMT_IMPORT:
3009 ret = yin_parse_import(ctx, (struct import_meta *)subelem->dest);
3010 break;
3011 case LY_STMT_INCLUDE:
3012 ret = yin_parse_include(ctx, (struct include_meta *)subelem->dest);
3013 break;
3014 case LY_STMT_INPUT:
3015 case LY_STMT_OUTPUT:
3016 ret = yin_parse_inout(ctx, kw, (struct inout_meta *)subelem->dest);
3017 break;
3018 case LY_STMT_LEAF:
3019 ret = yin_parse_leaf(ctx, (struct tree_node_meta *)subelem->dest);
3020 break;
3021 case LY_STMT_LEAF_LIST:
3022 ret = yin_parse_leaflist(ctx, (struct tree_node_meta *)subelem->dest);
3023 break;
3024 case LY_STMT_LENGTH:
3025 ret = yin_parse_length(ctx, (struct lysp_type *)subelem->dest);
3026 break;
3027 case LY_STMT_LIST:
3028 ret = yin_parse_list(ctx, (struct tree_node_meta *)subelem->dest);
3029 break;
3030 case LY_STMT_MANDATORY:
3031 ret = yin_parse_mandatory(ctx, (uint16_t *)subelem->dest, exts);
3032 break;
3033 case LY_STMT_MAX_ELEMENTS:
3034 case LY_STMT_MIN_ELEMENTS:
3035 ret = yin_parse_minmax(ctx, current_element, kw, subelem->dest);
3036 break;
3037 case LY_STMT_MODIFIER:
3038 ret = yin_parse_modifier(ctx, (const char **)subelem->dest, exts);
3039 break;
3040 case LY_STMT_MUST:
3041 ret = yin_parse_must(ctx, (struct lysp_restr **)subelem->dest);
3042 break;
3043 case LY_STMT_NAMESPACE:
3044 ret = yin_parse_simple_elem(ctx, kw, subelem, YIN_ARG_URI, Y_STR_ARG, exts);
3045 break;
3046 case LY_STMT_NOTIFICATION:
3047 ret = yin_parse_notification(ctx, (struct tree_node_meta *)subelem->dest);
3048 break;
3049 case LY_STMT_ORDERED_BY:
3050 ret = yin_parse_orderedby(ctx, (uint16_t *)subelem->dest, exts);
3051 break;
3052 case LY_STMT_PATH:
3053 ret = yin_parse_path(ctx, kw, (struct lysp_type *)subelem->dest);
3054 break;
3055 case LY_STMT_PATTERN:
3056 ret = yin_parse_pattern(ctx, (struct lysp_type *)subelem->dest);
3057 break;
3058 case LY_STMT_VALUE:
3059 case LY_STMT_POSITION:
3060 ret = yin_parse_value_pos(ctx, kw, (struct lysp_type_enum *)subelem->dest);
3061 break;
3062 case LY_STMT_PREFIX:
3063 ret = yin_parse_simple_elem(ctx, kw, subelem, YIN_ARG_VALUE, Y_IDENTIF_ARG, exts);
3064 break;
3065 case LY_STMT_RANGE:
3066 ret = yin_parse_range(ctx, (struct lysp_type *)subelem->dest);
3067 break;
3068 case LY_STMT_REFINE:
3069 ret = yin_parse_refine(ctx, (struct lysp_refine **)subelem->dest);
3070 break;
3071 case LY_STMT_REQUIRE_INSTANCE:
3072 ret = yin_pasrse_reqinstance(ctx, (struct lysp_type *)subelem->dest);
3073 break;
3074 case LY_STMT_REVISION:
3075 ret = yin_parse_revision(ctx, (struct lysp_revision **)subelem->dest);
3076 break;
3077 case LY_STMT_REVISION_DATE:
3078 ret = yin_parse_revision_date(ctx, (char *)subelem->dest, exts);
3079 break;
3080 case LY_STMT_STATUS:
3081 ret = yin_parse_status(ctx, (uint16_t *)subelem->dest, exts);
3082 break;
3083 case LY_STMT_TYPE:
3084 ret = yin_parse_type(ctx, current_element, subelem);
3085 break;
3086 case LY_STMT_TYPEDEF:
3087 ret = yin_parse_typedef(ctx, (struct tree_node_meta *)subelem->dest);
3088 break;
3089 case LY_STMT_UNIQUE:
3090 ret = yin_parse_simple_elem(ctx, kw, subelem, YIN_ARG_TAG, Y_STR_ARG, exts);
3091 break;
3092 case LY_STMT_USES:
3093 ret = yin_parse_uses(ctx, (struct tree_node_meta *)subelem->dest);
3094 break;
3095 case LY_STMT_WHEN:
3096 ret = yin_parse_when(ctx, (struct lysp_when **)subelem->dest);
3097 break;
3098 case LY_STMT_YANG_VERSION:
3099 ret = yin_parse_yangversion(ctx, (uint8_t *)subelem->dest, exts);
3100 break;
3101 case LY_STMT_YIN_ELEMENT:
3102 ret = yin_parse_yin_element(ctx, (uint16_t *)subelem->dest, exts);
3103 break;
3104 case LY_STMT_ARG_TEXT:
3105 case LY_STMT_ARG_VALUE:
3106 /* TODO what to do with content/attributes? */
3107 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3108 while (ctx->xmlctx->status == LYXML_ATTRIBUTE) {
3109 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3110 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3111 }
3112 ret = yin_parse_content(ctx, NULL, 0, kw, (const char **)subelem->dest, NULL);
3113 break;
3114 default:
3115 LOGINT(ctx->xmlctx->ctx);
3116 ret = LY_EINT;
David Sedlák3ffbc522019-07-02 17:49:28 +02003117 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003118 LY_CHECK_GOTO(ret, cleanup);
3119 subelem = NULL;
3120
3121 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
David Sedlákd6e56892019-07-01 15:40:24 +02003122 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003123 } else {
3124 LY_CHECK_RET(ret);
3125 /* elements with text or none content */
3126 /* save text content, if text_content isn't set, it's just ignored */
3127 /* no resources are allocated in this branch, no need to use cleanup label */
3128 LY_CHECK_RET(yin_validate_value(ctx, Y_STR_ARG));
3129 if (text_content) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02003130 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 +01003131 LY_CHECK_RET(!*text_content, LY_EMEM);
3132 }
3133
3134 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
David Sedlákd6e56892019-07-01 15:40:24 +02003135 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003136
David Sedlák8b754462019-07-25 16:22:13 +02003137 /* mandatory subelemnts are checked only after whole element was succesfully parsed */
3138 LY_CHECK_RET(yin_check_subelem_mandatory_constraint(ctx, subelem_info, subelem_info_size, current_element));
David Sedlákd6e56892019-07-01 15:40:24 +02003139
3140cleanup:
David Sedlákd6e56892019-07-01 15:40:24 +02003141 return ret;
3142}
3143
David Sedlák619db942019-07-03 14:47:30 +02003144LY_ERR
Michal Vaskofd69e1d2020-07-03 11:57:17 +02003145yin_parse_extension_instance(struct lys_yin_parser_ctx *ctx, LYEXT_SUBSTMT subelem, LY_ARRAY_COUNT_TYPE subelem_index,
Radek Krejci0f969882020-08-21 16:56:47 +02003146 struct lysp_ext_instance **exts)
David Sedlák1e2cdd02019-06-27 14:17:43 +02003147{
David Sedlák1e2cdd02019-06-27 14:17:43 +02003148 struct lysp_ext_instance *e;
David Sedlákb1a78352019-06-28 16:16:29 +02003149 struct lysp_stmt *last_subelem = NULL, *new_subelem = NULL;
David Sedlák1e2cdd02019-06-27 14:17:43 +02003150
Michal Vaskob36053d2020-03-26 15:49:30 +01003151 assert(ctx->xmlctx->status == LYXML_ELEMENT);
3152
3153 LY_ARRAY_NEW_RET(ctx->xmlctx->ctx, *exts, e, LY_EMEM);
David Sedlák1e2cdd02019-06-27 14:17:43 +02003154
3155 e->yin = 0;
3156 /* store name and insubstmt info */
Michal Vaskob36053d2020-03-26 15:49:30 +01003157 e->name = name2nsname(ctx, ctx->xmlctx->name, ctx->xmlctx->name_len, ctx->xmlctx->prefix, ctx->xmlctx->prefix_len);
David Sedláke0ef1c62019-09-13 10:05:55 +02003158 LY_CHECK_RET(!e->name, LY_EMEM);
David Sedlák619db942019-07-03 14:47:30 +02003159 e->insubstmt = subelem;
3160 e->insubstmt_index = subelem_index;
David Sedlák1e2cdd02019-06-27 14:17:43 +02003161 e->yin |= LYS_YIN;
Michal Vaskob36053d2020-03-26 15:49:30 +01003162 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
David Sedlák1e2cdd02019-06-27 14:17:43 +02003163
David Sedlákb1a78352019-06-28 16:16:29 +02003164 /* store attributes as subelements */
Michal Vaskob36053d2020-03-26 15:49:30 +01003165 while (ctx->xmlctx->status == LYXML_ATTRIBUTE) {
3166 if (!ctx->xmlctx->prefix) {
David Sedlákb1a78352019-06-28 16:16:29 +02003167 new_subelem = calloc(1, sizeof(*new_subelem));
3168 if (!e->child) {
3169 e->child = new_subelem;
David Sedlák1e2cdd02019-06-27 14:17:43 +02003170 } else {
David Sedlákb1a78352019-06-28 16:16:29 +02003171 last_subelem->next = new_subelem;
3172 }
3173 last_subelem = new_subelem;
3174
3175 last_subelem->flags |= LYS_YIN_ATTR;
Radek Krejci011e4aa2020-09-04 15:22:31 +02003176 LY_CHECK_RET(lydict_insert(ctx->xmlctx->ctx, ctx->xmlctx->name, ctx->xmlctx->name_len, &last_subelem->stmt));
David Sedlák169cc522019-08-15 13:23:45 +02003177 LY_CHECK_RET(!last_subelem->stmt, LY_EMEM);
Michal Vaskob36053d2020-03-26 15:49:30 +01003178 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
David Sedlák169cc522019-08-15 13:23:45 +02003179
Radek Krejci011e4aa2020-09-04 15:22:31 +02003180 INSERT_STRING_RET(ctx->xmlctx->ctx, ctx->xmlctx->value, ctx->xmlctx->value_len, ctx->xmlctx->dynamic, last_subelem->arg);
David Sedlák169cc522019-08-15 13:23:45 +02003181 LY_CHECK_RET(!last_subelem->arg, LY_EMEM);
Michal Vaskob36053d2020-03-26 15:49:30 +01003182 } else {
3183 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
David Sedlák1e2cdd02019-06-27 14:17:43 +02003184 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003185
3186 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
David Sedlák1e2cdd02019-06-27 14:17:43 +02003187 }
David Sedlák1e2cdd02019-06-27 14:17:43 +02003188
David Sedlákf250ecf2019-07-01 11:02:05 +02003189 /* parse subelements */
Michal Vaskob36053d2020-03-26 15:49:30 +01003190 assert(ctx->xmlctx->status == LYXML_ELEM_CONTENT);
3191 if (ctx->xmlctx->ws_only) {
3192 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3193 while (ctx->xmlctx->status == LYXML_ELEMENT) {
3194 LY_CHECK_RET(yin_parse_element_generic(ctx, LY_STMT_EXTENSION_INSTANCE, &new_subelem));
3195 if (!e->child) {
3196 e->child = new_subelem;
3197 } else {
3198 last_subelem->next = new_subelem;
David Sedlákb1a78352019-06-28 16:16:29 +02003199 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003200 last_subelem = new_subelem;
David Sedlák169cc522019-08-15 13:23:45 +02003201
Michal Vaskob36053d2020-03-26 15:49:30 +01003202 assert(ctx->xmlctx->status == LYXML_ELEM_CLOSE);
3203 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
David Sedlákb1a78352019-06-28 16:16:29 +02003204 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003205 } else if (ctx->xmlctx->value_len) {
3206 /* save text content */
Radek Krejci011e4aa2020-09-04 15:22:31 +02003207 INSERT_STRING_RET(ctx->xmlctx->ctx, ctx->xmlctx->value, ctx->xmlctx->value_len, ctx->xmlctx->dynamic, e->argument);
Michal Vaskob36053d2020-03-26 15:49:30 +01003208 LY_CHECK_RET(!e->argument, LY_EMEM);
3209
3210 /* parser next */
3211 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
David Sedlákb1a78352019-06-28 16:16:29 +02003212 }
3213
3214 return LY_SUCCESS;
3215}
3216
David Sedlákaa98bba2019-09-12 11:52:14 +02003217/**
3218 * @brief Parse argument of extension subelement that is classic yang keyword and not another instance of extension.
3219 *
3220 * @param[in,out] ctx Yin parser context for logging and to store current state.
David Sedlákaa98bba2019-09-12 11:52:14 +02003221 * @param[in] elem_type Type of element that is currently being parsed.
3222 * @param[out] arg Value to write to.
3223 *
3224 * @return LY_ERR values.
3225 */
3226static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01003227yin_parse_extension_instance_arg(struct lys_yin_parser_ctx *ctx, enum ly_stmt elem_type, const char **arg)
David Sedláke6284fc2019-09-10 11:57:02 +02003228{
David Sedlák071f7662019-09-12 02:02:51 +02003229 enum ly_stmt child;
David Sedláke6284fc2019-09-10 11:57:02 +02003230
Michal Vaskob36053d2020-03-26 15:49:30 +01003231 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3232
David Sedláke6284fc2019-09-10 11:57:02 +02003233 switch (elem_type) {
3234 case LY_STMT_ACTION:
3235 case LY_STMT_ANYDATA:
3236 case LY_STMT_ANYXML:
3237 case LY_STMT_ARGUMENT:
3238 case LY_STMT_BASE:
3239 case LY_STMT_BIT:
3240 case LY_STMT_CASE:
3241 case LY_STMT_CHOICE:
3242 case LY_STMT_CONTAINER:
3243 case LY_STMT_ENUM:
3244 case LY_STMT_EXTENSION:
3245 case LY_STMT_FEATURE:
3246 case LY_STMT_GROUPING:
3247 case LY_STMT_IDENTITY:
3248 case LY_STMT_IF_FEATURE:
3249 case LY_STMT_LEAF:
3250 case LY_STMT_LEAF_LIST:
3251 case LY_STMT_LIST:
3252 case LY_STMT_MODULE:
3253 case LY_STMT_NOTIFICATION:
3254 case LY_STMT_RPC:
3255 case LY_STMT_SUBMODULE:
3256 case LY_STMT_TYPE:
3257 case LY_STMT_TYPEDEF:
3258 case LY_STMT_UNITS:
3259 case LY_STMT_USES:
Michal Vaskob36053d2020-03-26 15:49:30 +01003260 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, arg, Y_MAYBE_STR_ARG, elem_type));
David Sedláke6284fc2019-09-10 11:57:02 +02003261 break;
3262 case LY_STMT_AUGMENT:
3263 case LY_STMT_DEVIATION:
3264 case LY_STMT_REFINE:
Michal Vaskob36053d2020-03-26 15:49:30 +01003265 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_TARGET_NODE, arg, Y_MAYBE_STR_ARG, elem_type));
David Sedláke6284fc2019-09-10 11:57:02 +02003266 break;
3267 case LY_STMT_CONFIG:
3268 case LY_STMT_DEFAULT:
3269 case LY_STMT_DEVIATE:
3270 case LY_STMT_ERROR_APP_TAG:
David Sedláke6284fc2019-09-10 11:57:02 +02003271 case LY_STMT_FRACTION_DIGITS:
3272 case LY_STMT_KEY:
3273 case LY_STMT_LENGTH:
3274 case LY_STMT_MANDATORY:
3275 case LY_STMT_MAX_ELEMENTS:
3276 case LY_STMT_MIN_ELEMENTS:
3277 case LY_STMT_MODIFIER:
3278 case LY_STMT_ORDERED_BY:
3279 case LY_STMT_PATH:
3280 case LY_STMT_PATTERN:
3281 case LY_STMT_POSITION:
3282 case LY_STMT_PREFIX:
3283 case LY_STMT_PRESENCE:
3284 case LY_STMT_RANGE:
3285 case LY_STMT_REQUIRE_INSTANCE:
3286 case LY_STMT_STATUS:
3287 case LY_STMT_VALUE:
3288 case LY_STMT_YANG_VERSION:
3289 case LY_STMT_YIN_ELEMENT:
Michal Vaskob36053d2020-03-26 15:49:30 +01003290 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_VALUE, arg, Y_MAYBE_STR_ARG, elem_type));
David Sedláke6284fc2019-09-10 11:57:02 +02003291 break;
3292 case LY_STMT_IMPORT:
3293 case LY_STMT_INCLUDE:
3294 case LY_STMT_BELONGS_TO:
Michal Vaskob36053d2020-03-26 15:49:30 +01003295 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_MODULE, arg, Y_MAYBE_STR_ARG, elem_type));
David Sedláke6284fc2019-09-10 11:57:02 +02003296 break;
3297 case LY_STMT_INPUT:
3298 case LY_STMT_OUTPUT:
Michal Vaskob36053d2020-03-26 15:49:30 +01003299 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NONE, arg, Y_MAYBE_STR_ARG, elem_type));
David Sedláke6284fc2019-09-10 11:57:02 +02003300 break;
3301 case LY_STMT_MUST:
3302 case LY_STMT_WHEN:
Michal Vaskob36053d2020-03-26 15:49:30 +01003303 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_CONDITION, arg, Y_MAYBE_STR_ARG, elem_type));
David Sedláke6284fc2019-09-10 11:57:02 +02003304 break;
3305 case LY_STMT_NAMESPACE:
Michal Vaskob36053d2020-03-26 15:49:30 +01003306 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_URI, arg, Y_MAYBE_STR_ARG, elem_type));
David Sedláke6284fc2019-09-10 11:57:02 +02003307 break;
3308 case LY_STMT_REVISION:
3309 case LY_STMT_REVISION_DATE:
Michal Vaskob36053d2020-03-26 15:49:30 +01003310 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_DATE, arg, Y_MAYBE_STR_ARG, elem_type));
David Sedláke6284fc2019-09-10 11:57:02 +02003311 break;
3312 case LY_STMT_UNIQUE:
Michal Vaskob36053d2020-03-26 15:49:30 +01003313 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_TAG, arg, Y_MAYBE_STR_ARG, elem_type));
David Sedláke6284fc2019-09-10 11:57:02 +02003314 break;
David Sedlák071f7662019-09-12 02:02:51 +02003315 /* argument is mapped to yin element */
3316 case LY_STMT_CONTACT:
3317 case LY_STMT_DESCRIPTION:
3318 case LY_STMT_ORGANIZATION:
3319 case LY_STMT_REFERENCE:
3320 case LY_STMT_ERROR_MESSAGE:
David Sedlákaa98bba2019-09-12 11:52:14 +02003321 /* there shouldn't be any attribute, argument is supposed to be first subelement */
Michal Vaskob36053d2020-03-26 15:49:30 +01003322 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NONE, arg, Y_MAYBE_STR_ARG, elem_type));
3323
3324 /* no content */
3325 assert(ctx->xmlctx->status == LYXML_ELEM_CONTENT);
3326 if (ctx->xmlctx->ws_only) {
3327 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3328 }
3329 if (((ctx->xmlctx->status == LYXML_ELEM_CONTENT) && !ctx->xmlctx->ws_only) || (ctx->xmlctx->status != LYXML_ELEMENT)) {
3330 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_FIRT_SUBELEM,
3331 elem_type == LY_STMT_ERROR_MESSAGE ? "value" : "text", ly_stmt2str(elem_type));
David Sedlák071f7662019-09-12 02:02:51 +02003332 return LY_EVALID;
3333 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003334
3335 /* parse child element */
3336 child = yin_match_keyword(ctx, ctx->xmlctx->name, ctx->xmlctx->name_len, ctx->xmlctx->prefix, ctx->xmlctx->prefix_len, elem_type);
3337 if ((elem_type == LY_STMT_ERROR_MESSAGE && child != LY_STMT_ARG_VALUE) ||
Radek Krejci0f969882020-08-21 16:56:47 +02003338 (elem_type != LY_STMT_ERROR_MESSAGE && child != LY_STMT_ARG_TEXT)) {
Michal Vaskob36053d2020-03-26 15:49:30 +01003339 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_UNEXP_SUBELEM, ctx->xmlctx->name_len, ctx->xmlctx->name,
3340 ly_stmt2str(elem_type));
3341 return LY_EVALID;
David Sedlákaa98bba2019-09-12 11:52:14 +02003342 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003343 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3344
3345 /* no attributes expected? TODO */
3346 while (ctx->xmlctx->status == LYXML_ATTRIBUTE) {
3347 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3348 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3349 }
3350
3351 /* load and save content */
Radek Krejci011e4aa2020-09-04 15:22:31 +02003352 INSERT_STRING_RET(ctx->xmlctx->ctx, ctx->xmlctx->value, ctx->xmlctx->value_len, ctx->xmlctx->dynamic, *arg);
Michal Vaskob36053d2020-03-26 15:49:30 +01003353 LY_CHECK_RET(!*arg, LY_EMEM);
3354
3355 /* load closing tag of subelement */
3356 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3357
3358 /* if only subelement was parsed as argument, load also closing tag TODO what? */
3359 /*if (ctx->xmlctx->status == LYXML_ELEMENT) {
3360 LY_CHECK_RET(lyxml_get_element(&ctx->xmlctx, data, &prefix, &prefix_len, &name, &name_len));
3361 }*/
David Sedlákb0ca07d2019-09-11 11:54:05 +02003362 break;
David Sedláke6284fc2019-09-10 11:57:02 +02003363 default:
Michal Vaskob36053d2020-03-26 15:49:30 +01003364 LOGINT(ctx->xmlctx->ctx);
David Sedlák071f7662019-09-12 02:02:51 +02003365 return LY_EINT;
David Sedláke6284fc2019-09-10 11:57:02 +02003366 }
3367
David Sedlák071f7662019-09-12 02:02:51 +02003368 return LY_SUCCESS;
David Sedláke6284fc2019-09-10 11:57:02 +02003369}
3370
3371LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01003372yin_parse_element_generic(struct lys_yin_parser_ctx *ctx, enum ly_stmt parent, struct lysp_stmt **element)
David Sedlákb1a78352019-06-28 16:16:29 +02003373{
3374 LY_ERR ret = LY_SUCCESS;
David Sedlákb1a78352019-06-28 16:16:29 +02003375 struct lysp_stmt *last = NULL, *new = NULL;
3376
Michal Vaskob36053d2020-03-26 15:49:30 +01003377 assert(ctx->xmlctx->status == LYXML_ELEMENT);
David Sedláke0ef1c62019-09-13 10:05:55 +02003378
3379 /* allocate new structure for element */
3380 *element = calloc(1, sizeof(**element));
Michal Vaskob36053d2020-03-26 15:49:30 +01003381 LY_CHECK_ERR_GOTO(!(*element), LOGMEM(ctx->xmlctx->ctx); ret = LY_EMEM, cleanup);
3382 (*element)->stmt = name2nsname(ctx, ctx->xmlctx->name, ctx->xmlctx->name_len, ctx->xmlctx->prefix, ctx->xmlctx->prefix_len);
David Sedláke0ef1c62019-09-13 10:05:55 +02003383 LY_CHECK_ERR_GOTO(!(*element)->stmt, ret = LY_EMEM, cleanup);
David Sedláke0ef1c62019-09-13 10:05:55 +02003384
Michal Vaskob36053d2020-03-26 15:49:30 +01003385 (*element)->kw = yin_match_keyword(ctx, ctx->xmlctx->name, ctx->xmlctx->name_len, ctx->xmlctx->prefix,
3386 ctx->xmlctx->prefix_len, parent);
David Sedlákb1a78352019-06-28 16:16:29 +02003387
3388 last = (*element)->child;
David Sedláke6284fc2019-09-10 11:57:02 +02003389 if ((*element)->kw == LY_STMT_NONE) {
3390 /* unrecognized element */
Michal Vaskob36053d2020-03-26 15:49:30 +01003391 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LY_VCODE_UNEXP_SUBELEM, ctx->xmlctx->name_len, ctx->xmlctx->name,
3392 ly_stmt2str(parent));
David Sedlákaa98bba2019-09-12 11:52:14 +02003393 ret = LY_EVALID;
3394 goto cleanup;
David Sedláke6284fc2019-09-10 11:57:02 +02003395 } else if ((*element)->kw != LY_STMT_EXTENSION_INSTANCE) {
3396 /* element is known yang keyword, which means argument can be parsed correctly. */
Michal Vaskob36053d2020-03-26 15:49:30 +01003397 ret = yin_parse_extension_instance_arg(ctx, (*element)->kw, &(*element)->arg);
David Sedlákaa98bba2019-09-12 11:52:14 +02003398 LY_CHECK_GOTO(ret, cleanup);
David Sedláke6284fc2019-09-10 11:57:02 +02003399 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +01003400 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3401
David Sedlákaa98bba2019-09-12 11:52:14 +02003402 /* load attributes in generic way, save all attributes in linked list */
Michal Vaskob36053d2020-03-26 15:49:30 +01003403 while (ctx->xmlctx->status == LYXML_ATTRIBUTE) {
David Sedláke6284fc2019-09-10 11:57:02 +02003404 new = calloc(1, sizeof(*last));
Michal Vaskob36053d2020-03-26 15:49:30 +01003405 LY_CHECK_ERR_GOTO(!new, LOGMEM(ctx->xmlctx->ctx); ret = LY_EMEM, cleanup);
David Sedláke6284fc2019-09-10 11:57:02 +02003406 if (!(*element)->child) {
3407 /* save first */
3408 (*element)->child = new;
3409 } else {
3410 last->next = new;
3411 }
3412 last = new;
David Sedlákb1a78352019-06-28 16:16:29 +02003413
David Sedláke6284fc2019-09-10 11:57:02 +02003414 last->flags |= LYS_YIN_ATTR;
Radek Krejci011e4aa2020-09-04 15:22:31 +02003415 LY_CHECK_GOTO(ret = lydict_insert(ctx->xmlctx->ctx, ctx->xmlctx->name, ctx->xmlctx->name_len, &last->stmt), cleanup);
David Sedlákb0ca07d2019-09-11 11:54:05 +02003416 last->kw = LY_STMT_NONE;
David Sedláke6284fc2019-09-10 11:57:02 +02003417 /* attributes with prefix are ignored */
Michal Vaskob36053d2020-03-26 15:49:30 +01003418 if (!ctx->xmlctx->prefix) {
3419 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3420
Radek Krejci011e4aa2020-09-04 15:22:31 +02003421 INSERT_STRING_RET(ctx->xmlctx->ctx, ctx->xmlctx->value, ctx->xmlctx->value_len, ctx->xmlctx->dynamic, last->arg);
David Sedlákaa98bba2019-09-12 11:52:14 +02003422 LY_CHECK_ERR_GOTO(!last->arg, ret = LY_EMEM, cleanup);
Michal Vaskob36053d2020-03-26 15:49:30 +01003423 } else {
3424 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
David Sedláka82ecff2019-08-16 10:51:48 +02003425 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003426 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
David Sedlákb1a78352019-06-28 16:16:29 +02003427 }
3428 }
3429
Michal Vaskob36053d2020-03-26 15:49:30 +01003430 if ((ctx->xmlctx->status != LYXML_ELEM_CONTENT) || ctx->xmlctx->ws_only) {
3431 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
3432 while (ctx->xmlctx->status == LYXML_ELEMENT) {
3433 /* parse subelements */
3434 ret = yin_parse_element_generic(ctx, (*element)->kw, &new);
David Sedlákaa98bba2019-09-12 11:52:14 +02003435 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob36053d2020-03-26 15:49:30 +01003436 if (!(*element)->child) {
3437 /* save first */
3438 (*element)->child = new;
3439 } else {
3440 last->next = new;
David Sedláka82ecff2019-08-16 10:51:48 +02003441 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003442 last = new;
David Sedlák169cc522019-08-15 13:23:45 +02003443
Michal Vaskob36053d2020-03-26 15:49:30 +01003444 assert(ctx->xmlctx->status == LYXML_ELEM_CLOSE);
3445 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
David Sedláka82ecff2019-08-16 10:51:48 +02003446 }
Michal Vaskob36053d2020-03-26 15:49:30 +01003447 } else {
3448 /* save element content */
3449 if (ctx->xmlctx->value_len) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02003450 INSERT_STRING_RET(ctx->xmlctx->ctx, ctx->xmlctx->value, ctx->xmlctx->value_len, ctx->xmlctx->dynamic, (*element)->arg);
Michal Vaskob36053d2020-03-26 15:49:30 +01003451 LY_CHECK_ERR_GOTO(!(*element)->arg, ret = LY_EMEM, cleanup);
3452 }
3453
3454 /* read closing tag */
3455 LY_CHECK_GOTO(ret = lyxml_ctx_next(ctx->xmlctx), cleanup);
David Sedlákb1a78352019-06-28 16:16:29 +02003456 }
3457
David Sedlákb0ca07d2019-09-11 11:54:05 +02003458cleanup:
David Sedlákb0ca07d2019-09-11 11:54:05 +02003459 return ret;
David Sedlák1e2cdd02019-06-27 14:17:43 +02003460}
3461
3462LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01003463yin_parse_mod(struct lys_yin_parser_ctx *ctx, struct lysp_module *mod)
David Sedlák3b4db242018-10-19 16:11:01 +02003464{
David Sedlák81497a32019-08-13 16:56:26 +02003465 LY_ERR ret = LY_SUCCESS;
3466 struct yin_subelement *subelems = NULL;
David Sedláked809f12019-09-13 10:15:11 +02003467 struct lysp_submodule *dup;
David Sedlák3b4db242018-10-19 16:11:01 +02003468
Michal Vaskob36053d2020-03-26 15:49:30 +01003469 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3470 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &mod->mod->name, Y_IDENTIF_ARG, LY_STMT_MODULE));
David Sedlák81497a32019-08-13 16:56:26 +02003471 LY_CHECK_RET(subelems_allocator(ctx, 28, NULL, &subelems,
Radek Krejcid6b76452019-09-03 17:03:03 +02003472 LY_STMT_ANYDATA, &mod->data, YIN_SUBELEM_VER2,
3473 LY_STMT_ANYXML, &mod->data, 0,
3474 LY_STMT_AUGMENT, &mod->augments, 0,
3475 LY_STMT_CHOICE, &mod->data, 0,
3476 LY_STMT_CONTACT, &mod->mod->contact, YIN_SUBELEM_UNIQUE,
3477 LY_STMT_CONTAINER, &mod->data, 0,
3478 LY_STMT_DESCRIPTION, &mod->mod->dsc, YIN_SUBELEM_UNIQUE,
3479 LY_STMT_DEVIATION, &mod->deviations, 0,
3480 LY_STMT_EXTENSION, &mod->extensions, 0,
3481 LY_STMT_FEATURE, &mod->features, 0,
3482 LY_STMT_GROUPING, &mod->groupings, 0,
3483 LY_STMT_IDENTITY, &mod->identities, 0,
3484 LY_STMT_IMPORT, mod->mod->prefix, &mod->imports, 0,
3485 LY_STMT_INCLUDE, mod->mod->name, &mod->includes, 0,
3486 LY_STMT_LEAF, &mod->data, 0,
3487 LY_STMT_LEAF_LIST, &mod->data, 0,
3488 LY_STMT_LIST, &mod->data, 0,
3489 LY_STMT_NAMESPACE, &mod->mod->ns, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE,
3490 LY_STMT_NOTIFICATION, &mod->notifs, 0,
3491 LY_STMT_ORGANIZATION, &mod->mod->org, YIN_SUBELEM_UNIQUE,
3492 LY_STMT_PREFIX, &mod->mod->prefix, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE,
3493 LY_STMT_REFERENCE, &mod->mod->ref, YIN_SUBELEM_UNIQUE,
3494 LY_STMT_REVISION, &mod->revs, 0,
3495 LY_STMT_RPC, &mod->rpcs, 0,
3496 LY_STMT_TYPEDEF, &mod->typedefs, 0,
3497 LY_STMT_USES, &mod->data, 0,
Radek Krejcicd1c5e32019-09-06 16:28:42 +02003498 LY_STMT_YANG_VERSION, &mod->mod->version, YIN_SUBELEM_UNIQUE,
Radek Krejcid6b76452019-09-03 17:03:03 +02003499 LY_STMT_EXTENSION_INSTANCE, NULL, 0
David Sedlák81497a32019-08-13 16:56:26 +02003500 ));
3501
Michal Vaskob36053d2020-03-26 15:49:30 +01003502 ret = yin_parse_content(ctx, subelems, 28, LY_STMT_MODULE, NULL, &mod->exts);
David Sedlák81497a32019-08-13 16:56:26 +02003503 subelems_deallocator(28, subelems);
David Sedláked809f12019-09-13 10:15:11 +02003504 LY_CHECK_RET(ret);
David Sedlák81497a32019-08-13 16:56:26 +02003505
David Sedláked809f12019-09-13 10:15:11 +02003506 /* finalize parent pointers to the reallocated items */
3507 LY_CHECK_RET(lysp_parse_finalize_reallocated((struct lys_parser_ctx *)ctx, mod->groupings, mod->augments, mod->rpcs, mod->notifs));
3508
3509 /* submodules share the namespace with the module names, so there must not be
3510 * a submodule of the same name in the context, no need for revision matching */
Michal Vaskob36053d2020-03-26 15:49:30 +01003511 dup = ly_ctx_get_submodule(ctx->xmlctx->ctx, NULL, mod->mod->name, NULL);
David Sedláked809f12019-09-13 10:15:11 +02003512 if (dup) {
3513 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LYVE_SYNTAX_YANG, "Name collision between module and submodule of name \"%s\".", mod->mod->name);
3514 return LY_EVALID;
3515 }
3516
3517 return LY_SUCCESS;
David Sedlák3b4db242018-10-19 16:11:01 +02003518}
3519
3520LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01003521yin_parse_submod(struct lys_yin_parser_ctx *ctx, struct lysp_submodule *submod)
David Sedlák298ff6d2019-07-26 14:29:03 +02003522{
David Sedlák81497a32019-08-13 16:56:26 +02003523 LY_ERR ret = LY_SUCCESS;
3524 struct yin_subelement *subelems = NULL;
David Sedláked809f12019-09-13 10:15:11 +02003525 struct lysp_submodule *dup;
David Sedlák298ff6d2019-07-26 14:29:03 +02003526
Michal Vaskob36053d2020-03-26 15:49:30 +01003527 LY_CHECK_RET(lyxml_ctx_next(ctx->xmlctx));
3528 LY_CHECK_RET(yin_parse_attribute(ctx, YIN_ARG_NAME, &submod->name, Y_IDENTIF_ARG, LY_STMT_SUBMODULE));
David Sedlák81497a32019-08-13 16:56:26 +02003529 LY_CHECK_RET(subelems_allocator(ctx, 27, NULL, &subelems,
Radek Krejcid6b76452019-09-03 17:03:03 +02003530 LY_STMT_ANYDATA, &submod->data, YIN_SUBELEM_VER2,
3531 LY_STMT_ANYXML, &submod->data, 0,
3532 LY_STMT_AUGMENT, &submod->augments, 0,
3533 LY_STMT_BELONGS_TO, submod, YIN_SUBELEM_MANDATORY | YIN_SUBELEM_UNIQUE,
3534 LY_STMT_CHOICE, &submod->data, 0,
3535 LY_STMT_CONTACT, &submod->contact, YIN_SUBELEM_UNIQUE,
3536 LY_STMT_CONTAINER, &submod->data, 0,
3537 LY_STMT_DESCRIPTION, &submod->dsc, YIN_SUBELEM_UNIQUE,
3538 LY_STMT_DEVIATION, &submod->deviations, 0,
3539 LY_STMT_EXTENSION, &submod->extensions, 0,
3540 LY_STMT_FEATURE, &submod->features, 0,
3541 LY_STMT_GROUPING, &submod->groupings, 0,
3542 LY_STMT_IDENTITY, &submod->identities, 0,
3543 LY_STMT_IMPORT, submod->prefix, &submod->imports, 0,
3544 LY_STMT_INCLUDE, submod->name, &submod->includes, 0,
3545 LY_STMT_LEAF, &submod->data, 0,
3546 LY_STMT_LEAF_LIST, &submod->data, 0,
3547 LY_STMT_LIST, &submod->data, 0,
3548 LY_STMT_NOTIFICATION, &submod->notifs, 0,
3549 LY_STMT_ORGANIZATION, &submod->org, YIN_SUBELEM_UNIQUE,
3550 LY_STMT_REFERENCE, &submod->ref, YIN_SUBELEM_UNIQUE,
3551 LY_STMT_REVISION, &submod->revs, 0,
3552 LY_STMT_RPC, &submod->rpcs, 0,
3553 LY_STMT_TYPEDEF, &submod->typedefs, 0,
3554 LY_STMT_USES, &submod->data, 0,
Radek Krejcicd1c5e32019-09-06 16:28:42 +02003555 LY_STMT_YANG_VERSION, &submod->version, YIN_SUBELEM_UNIQUE,
Radek Krejcid6b76452019-09-03 17:03:03 +02003556 LY_STMT_EXTENSION_INSTANCE, NULL, 0
David Sedlák81497a32019-08-13 16:56:26 +02003557 ));
3558
Michal Vaskob36053d2020-03-26 15:49:30 +01003559 ret = yin_parse_content(ctx, subelems, 27, LY_STMT_SUBMODULE, NULL, &submod->exts);
David Sedlák81497a32019-08-13 16:56:26 +02003560 subelems_deallocator(27, subelems);
David Sedláked809f12019-09-13 10:15:11 +02003561 LY_CHECK_RET(ret);
David Sedlák81497a32019-08-13 16:56:26 +02003562
David Sedláked809f12019-09-13 10:15:11 +02003563 /* finalize parent pointers to the reallocated items */
3564 LY_CHECK_RET(lysp_parse_finalize_reallocated((struct lys_parser_ctx *)ctx, submod->groupings, submod->augments, submod->rpcs, submod->notifs));
3565
3566 /* submodules share the namespace with the module names, so there must not be
3567 * a submodule of the same name in the context, no need for revision matching */
Michal Vaskob36053d2020-03-26 15:49:30 +01003568 dup = ly_ctx_get_submodule(ctx->xmlctx->ctx, NULL, submod->name, NULL);
David Sedláked809f12019-09-13 10:15:11 +02003569 if (dup && strcmp(dup->belongsto, submod->belongsto)) {
3570 LOGVAL_PARSER((struct lys_parser_ctx *)ctx, LYVE_SYNTAX_YANG, "Name collision between submodules of name \"%s\".", dup->name);
3571 return LY_EVALID;
3572 }
3573
3574 return LY_SUCCESS;
David Sedlák298ff6d2019-07-26 14:29:03 +02003575}
3576
3577LY_ERR
Michal Vasko63f3d842020-07-08 10:10:14 +02003578yin_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 +02003579 struct ly_in *in, struct lysp_submodule **submod)
David Sedlák8985a142019-07-31 16:43:06 +02003580{
Radek Krejcid6b76452019-09-03 17:03:03 +02003581 enum ly_stmt kw = LY_STMT_NONE;
David Sedlák8985a142019-07-31 16:43:06 +02003582 LY_ERR ret = LY_SUCCESS;
David Sedlák8985a142019-07-31 16:43:06 +02003583 struct lysp_submodule *mod_p = NULL;
3584
3585 /* create context */
3586 *yin_ctx = calloc(1, sizeof **yin_ctx);
David Sedlák1b623122019-08-05 15:27:49 +02003587 LY_CHECK_ERR_RET(!(*yin_ctx), LOGMEM(ctx), LY_EMEM);
Michal Vaskob36053d2020-03-26 15:49:30 +01003588 (*yin_ctx)->format = LYS_IN_YIN;
Michal Vasko7c8439f2020-08-05 13:25:19 +02003589 (*yin_ctx)->main_mod = main_ctx->main_mod;
Michal Vasko63f3d842020-07-08 10:10:14 +02003590 LY_CHECK_RET(lyxml_ctx_new(ctx, in, &(*yin_ctx)->xmlctx));
David Sedlák8985a142019-07-31 16:43:06 +02003591
David Sedlák1b623122019-08-05 15:27:49 +02003592 /* map the typedefs and groupings list from main context to the submodule's context */
3593 memcpy(&(*yin_ctx)->tpdfs_nodes, &main_ctx->tpdfs_nodes, sizeof main_ctx->tpdfs_nodes);
3594 memcpy(&(*yin_ctx)->grps_nodes, &main_ctx->grps_nodes, sizeof main_ctx->grps_nodes);
3595
David Sedlák8985a142019-07-31 16:43:06 +02003596 /* check submodule */
Michal Vaskob36053d2020-03-26 15:49:30 +01003597 kw = yin_match_keyword(*yin_ctx, (*yin_ctx)->xmlctx->name, (*yin_ctx)->xmlctx->name_len, (*yin_ctx)->xmlctx->prefix,
Radek Krejci0f969882020-08-21 16:56:47 +02003598 (*yin_ctx)->xmlctx->prefix_len, LY_STMT_NONE);
Radek Krejcid6b76452019-09-03 17:03:03 +02003599 if (kw == LY_STMT_MODULE) {
David Sedlák8985a142019-07-31 16:43:06 +02003600 LOGERR(ctx, LY_EDENIED, "Input data contains module in situation when a submodule is expected.");
3601 ret = LY_EINVAL;
3602 goto cleanup;
Radek Krejcid6b76452019-09-03 17:03:03 +02003603 } else if (kw != LY_STMT_SUBMODULE) {
David Sedlák1538a842019-08-08 15:38:51 +02003604 LOGVAL_PARSER((struct lys_parser_ctx *)*yin_ctx, LY_VCODE_MOD_SUBOMD, ly_stmt2str(kw));
David Sedlák8985a142019-07-31 16:43:06 +02003605 ret = LY_EVALID;
3606 goto cleanup;
3607 }
3608
3609 mod_p = calloc(1, sizeof *mod_p);
Radek Krejcif027df72020-09-15 13:00:28 +02003610 LY_CHECK_ERR_GOTO(!mod_p, LOGMEM(ctx); ret = LY_EMEM, cleanup);
David Sedlák8985a142019-07-31 16:43:06 +02003611 mod_p->parsing = 1;
3612
Michal Vaskob36053d2020-03-26 15:49:30 +01003613 ret = yin_parse_submod(*yin_ctx, mod_p);
David Sedlák8985a142019-07-31 16:43:06 +02003614 LY_CHECK_GOTO(ret, cleanup);
3615
David Sedlákbf8a2b72019-08-14 16:48:10 +02003616 /* skip possible trailing whitespaces at end of the input */
Michal Vasko63f3d842020-07-08 10:10:14 +02003617 while (isspace(in->current[0])) {
3618 ly_in_skip(in, 1);
David Sedlák6d781b62019-08-02 15:22:52 +02003619 }
Michal Vasko63f3d842020-07-08 10:10:14 +02003620 if (in->current[0]) {
3621 LOGVAL_PARSER((struct lys_parser_ctx *)*yin_ctx, LY_VCODE_TRAILING_SUBMOD, 15, in->current,
3622 strlen(in->current) > 15 ? "..." : "");
David Sedlák6d781b62019-08-02 15:22:52 +02003623 ret = LY_EVALID;
3624 goto cleanup;
3625 }
3626
David Sedlák8985a142019-07-31 16:43:06 +02003627 mod_p->parsing = 0;
3628 *submod = mod_p;
3629
3630cleanup:
3631 if (ret) {
3632 lysp_submodule_free(ctx, mod_p);
David Sedlák1b623122019-08-05 15:27:49 +02003633 yin_parser_ctx_free(*yin_ctx);
3634 *yin_ctx = NULL;
David Sedlák8985a142019-07-31 16:43:06 +02003635 }
David Sedlák8985a142019-07-31 16:43:06 +02003636 return ret;
3637}
3638
3639LY_ERR
Michal Vasko63f3d842020-07-08 10:10:14 +02003640yin_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 +02003641{
David Sedláke4889912018-11-02 09:52:40 +01003642 LY_ERR ret = LY_SUCCESS;
Radek Krejcid6b76452019-09-03 17:03:03 +02003643 enum ly_stmt kw = LY_STMT_NONE;
David Sedlák3017da42019-02-15 09:48:04 +01003644 struct lysp_module *mod_p = NULL;
David Sedlák3b4db242018-10-19 16:11:01 +02003645
David Sedlák8985a142019-07-31 16:43:06 +02003646 /* create context */
3647 *yin_ctx = calloc(1, sizeof **yin_ctx);
David Sedlák1b623122019-08-05 15:27:49 +02003648 LY_CHECK_ERR_RET(!(*yin_ctx), LOGMEM(mod->ctx), LY_EMEM);
Michal Vaskob36053d2020-03-26 15:49:30 +01003649 (*yin_ctx)->format = LYS_IN_YIN;
Michal Vasko7c8439f2020-08-05 13:25:19 +02003650 (*yin_ctx)->main_mod = mod;
Michal Vasko63f3d842020-07-08 10:10:14 +02003651 LY_CHECK_RET(lyxml_ctx_new(mod->ctx, in, &(*yin_ctx)->xmlctx));
David Sedlákda8ffa32019-07-08 14:17:10 +02003652
David Sedlák8985a142019-07-31 16:43:06 +02003653 /* check module */
Michal Vaskob36053d2020-03-26 15:49:30 +01003654 kw = yin_match_keyword(*yin_ctx, (*yin_ctx)->xmlctx->name, (*yin_ctx)->xmlctx->name_len, (*yin_ctx)->xmlctx->prefix,
Radek Krejci0f969882020-08-21 16:56:47 +02003655 (*yin_ctx)->xmlctx->prefix_len, LY_STMT_NONE);
Radek Krejcid6b76452019-09-03 17:03:03 +02003656 if (kw == LY_STMT_SUBMODULE) {
David Sedlák8985a142019-07-31 16:43:06 +02003657 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 +01003658 ret = LY_EINVAL;
3659 goto cleanup;
Radek Krejcid6b76452019-09-03 17:03:03 +02003660 } else if (kw != LY_STMT_MODULE) {
David Sedlák1538a842019-08-08 15:38:51 +02003661 LOGVAL_PARSER((struct lys_parser_ctx *)*yin_ctx, LY_VCODE_MOD_SUBOMD, ly_stmt2str(kw));
David Sedlák3017da42019-02-15 09:48:04 +01003662 ret = LY_EVALID;
3663 goto cleanup;
David Sedláke4889912018-11-02 09:52:40 +01003664 }
3665
David Sedlák3017da42019-02-15 09:48:04 +01003666 /* allocate module */
3667 mod_p = calloc(1, sizeof *mod_p);
David Sedlák8985a142019-07-31 16:43:06 +02003668 LY_CHECK_ERR_GOTO(!mod_p, LOGMEM(mod->ctx), cleanup);
David Sedlák3017da42019-02-15 09:48:04 +01003669 mod_p->mod = mod;
3670 mod_p->parsing = 1;
David Sedláke4889912018-11-02 09:52:40 +01003671
David Sedlák00250342019-06-21 14:19:39 +02003672 /* parse module substatements */
Michal Vaskob36053d2020-03-26 15:49:30 +01003673 ret = yin_parse_mod(*yin_ctx, mod_p);
David Sedlák3017da42019-02-15 09:48:04 +01003674 LY_CHECK_GOTO(ret, cleanup);
David Sedlák2e411422018-12-17 02:35:39 +01003675
David Sedlákbf8a2b72019-08-14 16:48:10 +02003676 /* skip possible trailing whitespaces at end of the input */
Michal Vasko63f3d842020-07-08 10:10:14 +02003677 while (isspace(in->current[0])) {
3678 ly_in_skip(in, 1);
David Sedlák6d781b62019-08-02 15:22:52 +02003679 }
Michal Vasko63f3d842020-07-08 10:10:14 +02003680 if (in->current[0]) {
3681 LOGVAL_PARSER((struct lys_parser_ctx *)*yin_ctx, LY_VCODE_TRAILING_MOD, 15, in->current,
3682 strlen(in->current) > 15 ? "..." : "");
David Sedlák6d781b62019-08-02 15:22:52 +02003683 ret = LY_EVALID;
3684 goto cleanup;
3685 }
3686
David Sedlák3017da42019-02-15 09:48:04 +01003687 mod_p->parsing = 0;
3688 mod->parsed = mod_p;
3689
3690cleanup:
David Sedlák8f7a1172019-06-20 14:42:18 +02003691 if (ret != LY_SUCCESS) {
David Sedlák3017da42019-02-15 09:48:04 +01003692 lysp_module_free(mod_p);
David Sedlák1b623122019-08-05 15:27:49 +02003693 yin_parser_ctx_free(*yin_ctx);
3694 *yin_ctx = NULL;
David Sedlák3017da42019-02-15 09:48:04 +01003695 }
David Sedlák2e411422018-12-17 02:35:39 +01003696 return ret;
David Sedlák3b4db242018-10-19 16:11:01 +02003697}