blob: 9cc2bac486dc81e8bd7ef269a65eb33af96c7b0f [file] [log] [blame]
Michal Vasko7fbc8162018-09-17 10:35:16 +02001/**
2 * @file parser_yang.c
3 * @author Michal Vasko <mvasko@cesnet.cz>
4 * @brief YANG parser
5 *
6 * Copyright (c) 2018 CESNET, z.s.p.o.
7 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
Michal Vasko7fbc8162018-09-17 10:35:16 +020014
15#include "common.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020016
17#include <assert.h>
18#include <ctype.h>
19#include <errno.h>
20#include <stdint.h>
21#include <stdio.h>
22#include <stdlib.h>
23#include <string.h>
24
Michal Vasko7fbc8162018-09-17 10:35:16 +020025#include "context.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020026#include "dict.h"
27#include "extensions.h"
28#include "log.h"
29#include "set.h"
30#include "tree.h"
31#include "tree_schema.h"
Radek Krejci70853c52018-10-15 14:46:16 +020032#include "tree_schema_internal.h"
Radek Krejci44ceedc2018-10-02 15:54:31 +020033
34/* Macro to check YANG's yang-char grammar rule */
35#define is_yangutf8char(c) ((c >= 0x20 && c <= 0xd77) || c == 0x09 || c == 0x0a || c == 0x0d || \
36 (c >= 0xe000 && c <= 0xfdcf) || (c >= 0xfdf0 && c <= 0xfffd) || \
37 (c >= 0x10000 && c <= 0x1fffd) || (c >= 0x20000 && c <= 0x2fffd) || \
38 (c >= 0x30000 && c <= 0x3fffd) || (c >= 0x40000 && c <= 0x2fffd) || \
39 (c >= 0x50000 && c <= 0x5fffd) || (c >= 0x60000 && c <= 0x6fffd) || \
40 (c >= 0x70000 && c <= 0x7fffd) || (c >= 0x80000 && c <= 0x8fffd) || \
41 (c >= 0x90000 && c <= 0x9fffd) || (c >= 0xa0000 && c <= 0xafffd) || \
42 (c >= 0xb0000 && c <= 0xbfffd) || (c >= 0xc0000 && c <= 0xcfffd) || \
43 (c >= 0xd0000 && c <= 0xdfffd) || (c >= 0xe0000 && c <= 0xefffd) || \
44 (c >= 0xf0000 && c <= 0xffffd) || (c >= 0x100000 && c <= 0x10fffd))
45
Radek Krejciceaf2122019-01-02 15:03:26 +010046/**
47 * @brief Try to find object with MEMBER string matching the IDENT in the given ARRAY.
48 * Macro logs an error message and returns LY_EVALID in case of existence of a matching object.
49 *
50 * @param[in] CTX yang parser context for logging.
51 * @param[in] ARRAY [sized array](@ref sizedarrays) of a generic objects with member named MEMBER to search.
52 * @param[in] MEMBER Name of the member of the objects in the ARRAY to compare.
53 * @param[in] STMT Name of the compared YANG statements for logging.
54 * @param[in] IDENT String trying to find in the ARRAY's objects inside the MEMBER member.
55 */
Radek Krejcifaa1eac2018-10-30 14:34:55 +010056#define CHECK_UNIQUENESS(CTX, ARRAY, MEMBER, STMT, IDENT) \
57 if (ARRAY) { \
58 for (unsigned int u = 0; u < LY_ARRAY_SIZE(ARRAY) - 1; ++u) { \
59 if (!strcmp((ARRAY)[u].MEMBER, IDENT)) { \
60 LOGVAL_YANG(CTX, LY_VCODE_DUPIDENT, IDENT, STMT); \
61 return LY_EVALID; \
62 } \
63 } \
64 }
65
Radek Krejciceaf2122019-01-02 15:03:26 +010066/**
67 * @brief Insert WORD into the libyang context's dictionary and store as TARGET.
68 * @param[in] CTX yang parser context to access libyang context.
69 * @param[in] BUF buffer in case the word is not a constant and can be inserted directly (zero-copy)
70 * @param[out] TARGET variable where to store the pointer to the inserted value.
71 * @param[in] WORD string to store.
72 * @param[in] LEN length of the string in WORD to store.
73 */
Radek Krejci9fcacc12018-10-11 15:59:11 +020074#define INSERT_WORD(CTX, BUF, TARGET, WORD, LEN) \
75 if (BUF) {(TARGET) = lydict_insert_zc((CTX)->ctx, WORD);}\
76 else {(TARGET) = lydict_insert((CTX)->ctx, WORD, LEN);}
Radek Krejci44ceedc2018-10-02 15:54:31 +020077
Radek Krejciceaf2122019-01-02 15:03:26 +010078/**
79 * @brief Move the DATA pointer by COUNT items. Also updates the indent value in yang parser context
80 * @param[in] CTX yang parser context to update its indent value.
81 * @param[in,out] DATA pointer to move
82 * @param[in] COUNT number of items for which the DATA pointer is supposed to move on.
83 */
Radek Krejci2b610482019-01-02 13:36:09 +010084#define MOVE_INPUT(CTX, DATA, COUNT) (*(DATA))+=COUNT;(CTX)->indent+=COUNT
Radek Krejcid5f2b5f2018-10-11 10:54:36 +020085
Michal Vaskoea5abea2018-09-18 13:10:54 +020086/**
87 * @brief Loop through all substatements providing, return if there are none.
88 *
Radek Krejci44ceedc2018-10-02 15:54:31 +020089 * @param[in] CTX yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +020090 * @param[in] DATA Raw data to read from.
91 * @param[out] KW YANG keyword read.
92 * @param[out] WORD Pointer to the keyword itself.
93 * @param[out] WORD_LEN Length of the keyword.
94 * @param[out] ERR Variable for error storing.
95 *
96 * @return In case there are no substatements or a fatal error encountered.
97 */
Radek Krejci6d6556c2018-11-08 09:37:45 +010098#define YANG_READ_SUBSTMT_FOR(CTX, DATA, KW, WORD, WORD_LEN, ERR, CHECKGOTO) \
Radek Krejci6d9b9b52018-11-02 12:43:39 +010099 LY_CHECK_RET(get_keyword(CTX, DATA, &KW, &WORD, &WORD_LEN)); \
Michal Vasko7fbc8162018-09-17 10:35:16 +0200100 if (KW == YANG_SEMICOLON) { \
Radek Krejci6d6556c2018-11-08 09:37:45 +0100101 CHECKGOTO; \
Radek Krejci6d9b9b52018-11-02 12:43:39 +0100102 return LY_SUCCESS; \
Michal Vasko7fbc8162018-09-17 10:35:16 +0200103 } \
104 if (KW != YANG_LEFT_BRACE) { \
Radek Krejci44ceedc2018-10-02 15:54:31 +0200105 LOGVAL_YANG(CTX, LYVE_SYNTAX_YANG, "Invalid keyword \"%s\", expected \";\" or \"{\".", ly_stmt2str(KW)); \
Michal Vasko7fbc8162018-09-17 10:35:16 +0200106 return LY_EVALID; \
107 } \
108 for (ERR = get_keyword(CTX, DATA, &KW, &WORD, &WORD_LEN); \
109 !ERR && (KW != YANG_RIGHT_BRACE); \
110 ERR = get_keyword(CTX, DATA, &KW, &WORD, &WORD_LEN))
111
Radek Krejciceaf2122019-01-02 15:03:26 +0100112/**
113 * @brief Check module version is at least 2 (YANG 1.1) because of the keyword presence.
114 * Logs error message and returns LY_EVALID in case of module in YANG version 1.0.
115 * @param[in] CTX yang parser context to get current module and for logging.
116 * @param[in] KW keyword allowed only in YANG version 1.1 (or later) - for logging.
117 * @param[in] PARENT parent statement where the KW is present - for logging.
118 */
119#define YANG_CHECK_STMTVER2_RET(CTX, KW, PARENT) \
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100120 if ((CTX)->mod_version < 2) {LOGVAL_YANG((CTX), LY_VCODE_INCHILDSTMT2, KW, PARENT); return LY_EVALID;}
Radek Krejci10113652018-11-14 16:56:50 +0100121
Radek Krejci2d7a47b2019-05-16 13:34:10 +0200122LY_ERR parse_container(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_node **siblings);
123LY_ERR parse_uses(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_node **siblings);
124LY_ERR parse_choice(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_node **siblings);
125LY_ERR parse_case(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_node **siblings);
126LY_ERR parse_list(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_node **siblings);
127LY_ERR parse_grouping(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_grp **groupings);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200128
Michal Vaskoea5abea2018-09-18 13:10:54 +0200129/**
130 * @brief Add another character to dynamic buffer, a low-level function.
131 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200132 * Enlarge if needed. Updates \p input as well as \p buf_used.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200133 *
Radek Krejci404251e2018-10-09 12:06:44 +0200134 * @param[in] ctx libyang context for logging.
Radek Krejci44ceedc2018-10-02 15:54:31 +0200135 * @param[in, out] input Input string to process.
136 * @param[in] len Number of bytes to get from the input string and copy into the buffer.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200137 * @param[in,out] buf Buffer to use, can be moved by realloc().
138 * @param[in,out] buf_len Current size of the buffer.
Radek Krejci44ceedc2018-10-02 15:54:31 +0200139 * @param[in,out] buf_used Currently used characters of the buffer.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200140 *
141 * @return LY_ERR values.
142 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +0200143LY_ERR
Radek Krejci44ceedc2018-10-02 15:54:31 +0200144buf_add_char(struct ly_ctx *ctx, const char **input, size_t len, char **buf, size_t *buf_len, size_t *buf_used)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200145{
Radek Krejci44ceedc2018-10-02 15:54:31 +0200146 if (*buf_len <= (*buf_used) + len) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200147 *buf_len += 16;
148 *buf = ly_realloc(*buf, *buf_len);
149 LY_CHECK_ERR_RET(!*buf, LOGMEM(ctx), LY_EMEM);
150 }
Radek Krejcic0917392019-04-10 13:04:04 +0200151 if (*buf_used) {
152 memcpy(&(*buf)[*buf_used], *input, len);
153 } else {
154 memcpy(*buf, *input, len);
155 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200156
Radek Krejci44ceedc2018-10-02 15:54:31 +0200157 (*buf_used) += len;
158 (*input) += len;
159
Michal Vasko7fbc8162018-09-17 10:35:16 +0200160 return LY_SUCCESS;
161}
162
Michal Vaskoea5abea2018-09-18 13:10:54 +0200163/**
Radek Krejci44ceedc2018-10-02 15:54:31 +0200164 * @brief Check that \p c is valid UTF8 code point for YANG string.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200165 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200166 * @param[in] ctx yang parser context for logging.
167 * @param[in] c UTF8 code point of a character to check.
168 * @return LY_ERR values.
169 */
170static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +0200171check_stringchar(struct lys_parser_ctx *ctx, unsigned int c)
Radek Krejci44ceedc2018-10-02 15:54:31 +0200172{
173 if (!is_yangutf8char(c)) {
174 LOGVAL_YANG(ctx, LY_VCODE_INCHAR, c);
175 return LY_EVALID;
176 }
177 return LY_SUCCESS;
178}
179
180/**
181 * @brief Check that \p c is valid UTF8 code point for YANG identifier.
182 *
183 * @param[in] ctx yang parser context for logging.
184 * @param[in] c UTF8 code point of a character to check.
185 * @param[in] first Flag to check the first character of an identifier, which is more restricted.
Radek Krejcidcc7b322018-10-11 14:24:02 +0200186 * @param[in,out] prefix Storage for internally used flag in case of possible prefixed identifiers:
187 * 0 - colon not yet found (no prefix)
188 * 1 - \p c is the colon character
189 * 2 - prefix already processed, now processing the identifier
190 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200191 * If the identifier cannot be prefixed, NULL is expected.
192 * @return LY_ERR values.
193 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +0200194LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +0200195check_identifierchar(struct lys_parser_ctx *ctx, unsigned int c, int first, int *prefix)
Radek Krejci44ceedc2018-10-02 15:54:31 +0200196{
197 if (first || (prefix && (*prefix) == 1)) {
198 if (!is_yangidentstartchar(c)) {
199 LOGVAL_YANG(ctx, LYVE_SYNTAX_YANG, "Invalid identifier first character '%c'.", c);
200 return LY_EVALID;
201 }
Radek Krejci9fcacc12018-10-11 15:59:11 +0200202 if (prefix) {
203 if (first) {
204 (*prefix) = 0;
205 } else {
206 (*prefix) = 2;
207 }
Radek Krejci44ceedc2018-10-02 15:54:31 +0200208 }
209 } else if (c == ':' && prefix && (*prefix) == 0) {
210 (*prefix) = 1;
211 } else if (!is_yangidentchar(c)) {
212 LOGVAL_YANG(ctx, LYVE_SYNTAX_YANG, "Invalid identifier character '%c'.", c);
213 return LY_EVALID;
214 }
215
216 return LY_SUCCESS;
217}
218
219/**
220 * @brief Store a single UTF8 character. It depends whether in a dynamically-allocated buffer or just as a pointer to the data.
221 *
222 * @param[in] ctx yang parser context for logging.
223 * @param[in,out] input Pointer to the string where to get the character to store. Automatically moved to the next character
224 * when function returns.
225 * @param[in] arg Type of the input string to select method of checking character validity.
226 * @param[in,out] word_p Word pointer. If buffer (\p word_b) was not yet needed, it is just a pointer to the first
Michal Vaskoea5abea2018-09-18 13:10:54 +0200227 * stored character. If buffer was needed (\p word_b is non-NULL or \p need_buf is set), it is pointing to the buffer.
Radek Krejci44ceedc2018-10-02 15:54:31 +0200228 * @param[in,out] word_len Current length of the word pointed to by \p word_p.
229 * @param[in,out] word_b Word buffer. Is kept NULL as long as it is not requested (word is a substring of the data).
Michal Vaskoea5abea2018-09-18 13:10:54 +0200230 * @param[in,out] buf_len Current length of \p word_b.
Radek Krejci44ceedc2018-10-02 15:54:31 +0200231 * @param[in] need_buf Flag if the dynamically allocated buffer is required.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200232 *
233 * @return LY_ERR values.
234 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +0200235LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +0200236buf_store_char(struct lys_parser_ctx *ctx, const char **input, enum yang_arg arg,
Radek Krejci44ceedc2018-10-02 15:54:31 +0200237 char **word_p, size_t *word_len, char **word_b, size_t *buf_len, int need_buf)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200238{
Radek Krejci404251e2018-10-09 12:06:44 +0200239 int prefix = 0;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200240 unsigned int c;
241 size_t len;
242
Radek Krejcif29b7c32019-04-09 16:17:49 +0200243 /* check valid combination of input paremeters - if need_buf specified, word_b must be provided */
244 assert(!need_buf || (need_buf && word_b));
245
Radek Krejci44ceedc2018-10-02 15:54:31 +0200246 /* get UTF8 code point (and number of bytes coding the character) */
247 LY_CHECK_ERR_RET(ly_getutf8(input, &c, &len),
248 LOGVAL_YANG(ctx, LY_VCODE_INCHAR, (*input)[-len]), LY_EVALID);
249 (*input) -= len;
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200250 if (c == '\n') {
251 ctx->indent = 0;
252 } else {
253 /* note - even the multibyte character is count as 1 */
254 ++ctx->indent;
255 }
256
Radek Krejci44ceedc2018-10-02 15:54:31 +0200257 /* check character validity */
258 switch (arg) {
259 case Y_IDENTIF_ARG:
260 LY_CHECK_RET(check_identifierchar(ctx, c, !(*word_len), NULL));
261 break;
262 case Y_PREF_IDENTIF_ARG:
263 LY_CHECK_RET(check_identifierchar(ctx, c, !(*word_len), &prefix));
264 break;
265 case Y_STR_ARG:
266 case Y_MAYBE_STR_ARG:
267 LY_CHECK_RET(check_stringchar(ctx, c));
268 break;
269 }
270
Michal Vasko7fbc8162018-09-17 10:35:16 +0200271 if (word_b && *word_b) {
272 /* add another character into buffer */
Radek Krejci44ceedc2018-10-02 15:54:31 +0200273 if (buf_add_char(ctx->ctx, input, len, word_b, buf_len, word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200274 return LY_EMEM;
275 }
276
277 /* in case of realloc */
278 *word_p = *word_b;
Radek Krejcif29b7c32019-04-09 16:17:49 +0200279 } else if (word_b && need_buf) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200280 /* first time we need a buffer, copy everything read up to now */
281 if (*word_len) {
282 *word_b = malloc(*word_len);
Radek Krejci44ceedc2018-10-02 15:54:31 +0200283 LY_CHECK_ERR_RET(!*word_b, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200284 *buf_len = *word_len;
285 memcpy(*word_b, *word_p, *word_len);
286 }
287
288 /* add this new character into buffer */
Radek Krejci44ceedc2018-10-02 15:54:31 +0200289 if (buf_add_char(ctx->ctx, input, len, word_b, buf_len, word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200290 return LY_EMEM;
291 }
292
293 /* in case of realloc */
294 *word_p = *word_b;
295 } else {
296 /* just remember the first character pointer */
297 if (!*word_p) {
Radek Krejci44ceedc2018-10-02 15:54:31 +0200298 *word_p = (char *)(*input);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200299 }
Radek Krejci44ceedc2018-10-02 15:54:31 +0200300 /* ... and update the word's length */
301 (*word_len) += len;
302 (*input) += len;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200303 }
304
305 return LY_SUCCESS;
306}
307
Michal Vaskoea5abea2018-09-18 13:10:54 +0200308/**
309 * @brief Skip YANG comment in data.
310 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200311 * @param[in] ctx yang parser context for logging.
312 * @param[in,out] data Data to read from, automatically moved after the comment.
313 * @param[in] comment Type of the comment to process:
314 * 1 for a one-line comment,
315 * 2 for a block comment.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200316 *
317 * @return LY_ERR values.
318 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +0200319LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +0200320skip_comment(struct lys_parser_ctx *ctx, const char **data, int comment)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200321{
Radek Krejci80dd33e2018-09-26 15:57:18 +0200322 /* internal statuses: 0 - comment ended,
323 * 1 - in line comment,
324 * 2 - in block comment,
325 * 3 - in block comment with last read character '*'
326 */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200327 while (**data && comment) {
328 switch (comment) {
329 case 1:
330 if (**data == '\n') {
331 comment = 0;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200332 ++ctx->line;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200333 }
334 break;
335 case 2:
336 if (**data == '*') {
Radek Krejci15c80ca2018-10-09 11:01:31 +0200337 comment = 3;
338 } else if (**data == '\n') {
339 ++ctx->line;
340 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200341 break;
342 case 3:
343 if (**data == '/') {
344 comment = 0;
Radek Krejci5b930492019-06-11 14:54:08 +0200345 } else if (**data != '*') {
Radek Krejci44ceedc2018-10-02 15:54:31 +0200346 if (**data == '\n') {
347 ++ctx->line;
348 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200349 comment = 2;
350 }
351 break;
352 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +0200353 LOGINT_RET(ctx->ctx);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200354 }
355
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200356 if (**data == '\n') {
357 ctx->indent = 0;
358 } else {
359 ++ctx->indent;
360 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200361 ++(*data);
362 }
363
364 if (!**data && (comment > 1)) {
Radek Krejci0a1d0d42019-05-16 15:14:51 +0200365 LOGVAL_YANG(ctx, LYVE_SYNTAX, "Unexpected end-of-input, non-terminated comment.");
Michal Vasko7fbc8162018-09-17 10:35:16 +0200366 return LY_EVALID;
367 }
368
369 return LY_SUCCESS;
370}
371
Michal Vaskoea5abea2018-09-18 13:10:54 +0200372/**
373 * @brief Read a quoted string from data.
374 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200375 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200376 * @param[in,out] data Data to read from, always moved to currently handled character.
377 * @param[in] arg Type of YANG keyword argument expected.
378 * @param[out] word_p Pointer to the read quoted string.
379 * @param[out] word_b Pointer to a dynamically-allocated buffer holding the read quoted string. If not needed,
380 * set to NULL. Otherwise equal to \p word_p.
381 * @param[out] word_len Length of the read quoted string.
382 * @param[out] buf_len Length of the dynamically-allocated buffer \p word_b.
383 * @param[in] indent Current indent (number of YANG spaces). Needed for correct multi-line string
384 * indenation in the final quoted string.
385 *
386 * @return LY_ERR values.
387 */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200388static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +0200389read_qstring(struct lys_parser_ctx *ctx, const char **data, enum yang_arg arg, char **word_p, char **word_b, size_t *word_len,
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200390 size_t *buf_len)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200391{
392 /* string: 0 - string ended, 1 - string with ', 2 - string with ", 3 - string with " with last character \,
393 * 4 - string finished, now skipping whitespaces looking for +,
394 * 5 - string continues after +, skipping whitespaces */
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200395 unsigned int string, block_indent = 0, current_indent = 0, need_buf = 0;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200396 const char *c;
397
398 if (**data == '\"') {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200399 string = 2;
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200400 current_indent = block_indent = ctx->indent + 1;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200401 } else {
402 assert(**data == '\'');
403 string = 1;
404 }
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200405 MOVE_INPUT(ctx, data, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200406
407 while (**data && string) {
408 switch (string) {
409 case 1:
410 switch (**data) {
411 case '\'':
412 /* string may be finished, but check for + */
413 string = 4;
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200414 MOVE_INPUT(ctx, data, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200415 break;
416 default:
417 /* check and store character */
Radek Krejci44ceedc2018-10-02 15:54:31 +0200418 LY_CHECK_RET(buf_store_char(ctx, data, arg, word_p, word_len, word_b, buf_len, need_buf));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200419 break;
420 }
421 break;
422 case 2:
423 switch (**data) {
424 case '\"':
425 /* string may be finished, but check for + */
426 string = 4;
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200427 MOVE_INPUT(ctx, data, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200428 break;
429 case '\\':
430 /* special character following */
431 string = 3;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200432 ++(*data);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200433 break;
434 case ' ':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200435 if (current_indent < block_indent) {
436 ++current_indent;
437 MOVE_INPUT(ctx, data, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200438 } else {
439 /* check and store character */
Radek Krejci44ceedc2018-10-02 15:54:31 +0200440 LY_CHECK_RET(buf_store_char(ctx, data, arg, word_p, word_len, word_b, buf_len, need_buf));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200441 }
442 break;
443 case '\t':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200444 if (current_indent < block_indent) {
445 assert(need_buf);
446 current_indent += 8;
447 ctx->indent += 8;
448 for (; current_indent > block_indent; --current_indent, --ctx->indent) {
449 /* store leftover spaces from the tab */
450 c = " ";
451 LY_CHECK_RET(buf_store_char(ctx, &c, arg, word_p, word_len, word_b, buf_len, need_buf));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200452 }
Radek Krejci44ceedc2018-10-02 15:54:31 +0200453 ++(*data);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200454 } else {
455 /* check and store character */
Radek Krejci44ceedc2018-10-02 15:54:31 +0200456 LY_CHECK_RET(buf_store_char(ctx, data, arg, word_p, word_len, word_b, buf_len, need_buf));
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200457 /* additional characters for indentation - only 1 was count in buf_store_char */
458 ctx->indent += 7;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200459 }
460 break;
461 case '\n':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200462 if (block_indent) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200463 /* we will be removing the indents so we need our own buffer */
464 need_buf = 1;
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200465
466 /* remove trailing tabs and spaces */
467 while ((*word_len) && ((*word_p)[(*word_len) - 1] == '\t' || (*word_p)[(*word_len) - 1] == ' ')) {
468 --(*word_len);
469 }
470
471 /* start indentation */
472 current_indent = 0;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200473 }
474
475 /* check and store character */
Radek Krejci44ceedc2018-10-02 15:54:31 +0200476 LY_CHECK_RET(buf_store_char(ctx, data, arg, word_p, word_len, word_b, buf_len, need_buf));
477
478 /* maintain line number */
479 ++ctx->line;
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200480
481 /* reset context indentation counter for possible string after this one */
482 ctx->indent = 0;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200483 break;
484 default:
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200485 /* first non-whitespace character, stop eating indentation */
486 current_indent = block_indent;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200487
488 /* check and store character */
Radek Krejci44ceedc2018-10-02 15:54:31 +0200489 LY_CHECK_RET(buf_store_char(ctx, data, arg, word_p, word_len, word_b, buf_len, need_buf));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200490 break;
491 }
492 break;
493 case 3:
494 /* string encoded characters */
495 switch (**data) {
496 case 'n':
497 c = "\n";
498 break;
499 case 't':
500 c = "\t";
501 break;
502 case '\"':
503 c = *data;
504 break;
505 case '\\':
506 c = *data;
507 break;
508 default:
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200509 LOGVAL_YANG(ctx, LYVE_SYNTAX_YANG, "Double-quoted string unknown special character '\\%c'.", **data);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200510 return LY_EVALID;
511 }
512
513 /* check and store character */
Radek Krejci44ceedc2018-10-02 15:54:31 +0200514 LY_CHECK_RET(buf_store_char(ctx, &c, arg, word_p, word_len, word_b, buf_len, need_buf));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200515
516 string = 2;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200517 ++(*data);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200518 break;
519 case 4:
520 switch (**data) {
521 case '+':
522 /* string continues */
523 string = 5;
Radek Krejciefd22f62018-09-27 11:47:58 +0200524 need_buf = 1;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200525 break;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200526 case '\n':
527 ++ctx->line;
528 /* fallthrough */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200529 case ' ':
530 case '\t':
Michal Vasko7fbc8162018-09-17 10:35:16 +0200531 /* just skip */
532 break;
533 default:
534 /* string is finished */
535 goto string_end;
536 }
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200537 MOVE_INPUT(ctx, data, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200538 break;
539 case 5:
540 switch (**data) {
Radek Krejci44ceedc2018-10-02 15:54:31 +0200541 case '\n':
542 ++ctx->line;
543 /* fallthrough */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200544 case ' ':
545 case '\t':
Michal Vasko7fbc8162018-09-17 10:35:16 +0200546 /* skip */
547 break;
548 case '\'':
549 string = 1;
550 break;
551 case '\"':
552 string = 2;
553 break;
554 default:
555 /* it must be quoted again */
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200556 LOGVAL_YANG(ctx, LYVE_SYNTAX_YANG, "Both string parts divided by '+' must be quoted.");
Michal Vasko7fbc8162018-09-17 10:35:16 +0200557 return LY_EVALID;
558 }
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200559 MOVE_INPUT(ctx, data, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200560 break;
561 default:
562 return LY_EINT;
563 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200564 }
565
566string_end:
Radek Krejci4e199f52019-05-28 09:09:28 +0200567 if (arg <= Y_PREF_IDENTIF_ARG && !(*word_len)) {
568 /* empty identifier */
569 LOGVAL_YANG(ctx, LYVE_SYNTAX_YANG, "Statement argument is required.");
570 return LY_EVALID;
571 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200572 return LY_SUCCESS;
573}
574
Michal Vaskoea5abea2018-09-18 13:10:54 +0200575/**
576 * @brief Get another YANG string from the raw data.
577 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200578 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200579 * @param[in,out] data Data to read from, always moved to currently handled character.
580 * @param[in] arg Type of YANG keyword argument expected.
Radek Krejcid3ca0632019-04-16 16:54:54 +0200581 * @param[out] flags optional output argument to get flag of the argument's quoting (LYS_*QOUTED - see [schema node flags](@ref snodeflags))
Michal Vasko2ca70f52018-09-27 11:04:51 +0200582 * @param[out] word_p Pointer to the read string. Can return NULL if \p arg is #Y_MAYBE_STR_ARG.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200583 * @param[out] word_b Pointer to a dynamically-allocated buffer holding the read string. If not needed,
584 * set to NULL. Otherwise equal to \p word_p.
585 * @param[out] word_len Length of the read string.
586 *
587 * @return LY_ERR values.
Michal Vasko7fbc8162018-09-17 10:35:16 +0200588 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +0200589LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +0200590get_argument(struct lys_parser_ctx *ctx, const char **data, enum yang_arg arg,
Radek Krejcid3ca0632019-04-16 16:54:54 +0200591 uint16_t *flags, char **word_p, char **word_b, size_t *word_len)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200592{
Radek Krejci44ceedc2018-10-02 15:54:31 +0200593 size_t buf_len = 0;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200594
595 /* word buffer - dynamically allocated */
596 *word_b = NULL;
597
598 /* word pointer - just a pointer to data */
599 *word_p = NULL;
600
601 *word_len = 0;
602 while (**data) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200603 switch (**data) {
604 case '\'':
605 case '\"':
606 if (*word_len) {
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200607 /* invalid - quotes cannot be in unquoted string and only optsep, ; or { can follow it */
608 LOGVAL_YANG(ctx, LY_VCODE_INSTREXP, 1, *data,
609 "unquoted string character, optsep, semicolon or opening brace");
610 return LY_EVALID;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200611 }
Radek Krejcid3ca0632019-04-16 16:54:54 +0200612 if (flags) {
613 (*flags) |= (**data) == '\'' ? LYS_SINGLEQUOTED : LYS_DOUBLEQUOTED;
614 }
Radek Krejci6d9b9b52018-11-02 12:43:39 +0100615 LY_CHECK_RET(read_qstring(ctx, data, arg, word_p, word_b, word_len, &buf_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200616 goto str_end;
617 case '/':
Radek Krejci44ceedc2018-10-02 15:54:31 +0200618 if ((*data)[1] == '/') {
619 /* one-line comment */
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200620 MOVE_INPUT(ctx, data, 2);
Radek Krejci6d9b9b52018-11-02 12:43:39 +0100621 LY_CHECK_RET(skip_comment(ctx, data, 1));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200622 } else if ((*data)[1] == '*') {
623 /* block comment */
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200624 MOVE_INPUT(ctx, data, 2);
Radek Krejci6d9b9b52018-11-02 12:43:39 +0100625 LY_CHECK_RET(skip_comment(ctx, data, 2));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200626 } else {
627 /* not a comment after all */
Radek Krejci6d9b9b52018-11-02 12:43:39 +0100628 LY_CHECK_RET(buf_store_char(ctx, data, arg, word_p, word_len, word_b, &buf_len, 0));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200629 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200630 break;
631 case ' ':
632 if (*word_len) {
633 /* word is finished */
634 goto str_end;
635 }
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200636 MOVE_INPUT(ctx, data, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200637 break;
638 case '\t':
639 if (*word_len) {
640 /* word is finished */
641 goto str_end;
642 }
643 /* tabs count for 8 spaces */
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200644 ctx->indent += 8;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200645
646 ++(*data);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200647 break;
648 case '\n':
649 if (*word_len) {
650 /* word is finished */
651 goto str_end;
652 }
653 /* reset indent */
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200654 ctx->indent = 0;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200655
656 /* track line numbers */
657 ++ctx->line;
658
659 ++(*data);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200660 break;
661 case ';':
662 case '{':
663 if (*word_len || (arg == Y_MAYBE_STR_ARG)) {
664 /* word is finished */
665 goto str_end;
666 }
667
Radek Krejci44ceedc2018-10-02 15:54:31 +0200668 LOGVAL_YANG(ctx, LY_VCODE_INSTREXP, 1, *data, "an argument");
Michal Vasko7fbc8162018-09-17 10:35:16 +0200669 return LY_EVALID;
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200670 case '}':
671 /* invalid - braces cannot be in unquoted string (opening braces terminates the string and can follow it) */
672 LOGVAL_YANG(ctx, LY_VCODE_INSTREXP, 1, *data,
673 "unquoted string character, optsep, semicolon or opening brace");
674 return LY_EVALID;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200675 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +0200676 LY_CHECK_RET(buf_store_char(ctx, data, arg, word_p, word_len, word_b, &buf_len, 0));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200677 break;
678 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200679 }
680
Radek Krejci0a1d0d42019-05-16 15:14:51 +0200681 /* unexpected end of loop */
682 LOGVAL_YANG(ctx, LY_VCODE_EOF);
683 return LY_EVALID;
684
Michal Vasko7fbc8162018-09-17 10:35:16 +0200685str_end:
Radek Krejci44ceedc2018-10-02 15:54:31 +0200686 /* terminating NULL byte for buf */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200687 if (*word_b) {
Radek Krejci44ceedc2018-10-02 15:54:31 +0200688 (*word_b) = ly_realloc(*word_b, (*word_len) + 1);
689 LY_CHECK_ERR_RET(!(*word_b), LOGMEM(ctx->ctx), LY_EMEM);
690 (*word_b)[*word_len] = '\0';
Michal Vasko7fbc8162018-09-17 10:35:16 +0200691 *word_p = *word_b;
692 }
693
694 return LY_SUCCESS;
695}
696
Michal Vaskoea5abea2018-09-18 13:10:54 +0200697/**
698 * @brief Get another YANG keyword from the raw data.
699 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200700 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200701 * @param[in,out] data Data to read from, always moved to currently handled character.
702 * @param[out] kw YANG keyword read.
703 * @param[out] word_p Pointer to the keyword in the data. Useful for extension instances.
704 * @param[out] word_len Length of the keyword in the data. Useful for extension instances.
705 *
706 * @return LY_ERR values.
707 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +0200708LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +0200709get_keyword(struct lys_parser_ctx *ctx, const char **data, enum yang_keyword *kw, char **word_p, size_t *word_len)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200710{
Michal Vasko7fbc8162018-09-17 10:35:16 +0200711 int prefix;
712 const char *word_start;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200713 unsigned int c;
714 size_t len;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200715
716 if (word_p) {
717 *word_p = NULL;
718 *word_len = 0;
719 }
720
721 /* first skip "optsep", comments */
722 while (**data) {
Radek Krejcidcc7b322018-10-11 14:24:02 +0200723 switch (**data) {
724 case '/':
725 if ((*data)[1] == '/') {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200726 /* one-line comment */
Radek Krejcidcc7b322018-10-11 14:24:02 +0200727 MOVE_INPUT(ctx, data, 2);
Radek Krejci6d9b9b52018-11-02 12:43:39 +0100728 LY_CHECK_RET(skip_comment(ctx, data, 1));
Radek Krejcidcc7b322018-10-11 14:24:02 +0200729 } else if ((*data)[1] == '*') {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200730 /* block comment */
Radek Krejcidcc7b322018-10-11 14:24:02 +0200731 MOVE_INPUT(ctx, data, 2);
Radek Krejci6d9b9b52018-11-02 12:43:39 +0100732 LY_CHECK_RET(skip_comment(ctx, data, 2));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200733 } else {
Radek Krejcidcc7b322018-10-11 14:24:02 +0200734 /* error - not a comment after all, keyword cannot start with slash */
735 LOGVAL_YANG(ctx, LYVE_SYNTAX_YANG, "Invalid identifier first character '/'.");
736 return LY_EVALID;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200737 }
Radek Krejci13028282019-06-11 14:56:48 +0200738 continue;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200739 case '\n':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200740 /* skip whitespaces (optsep) */
Radek Krejci44ceedc2018-10-02 15:54:31 +0200741 ++ctx->line;
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200742 ctx->indent = 0;
743 break;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200744 case ' ':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200745 /* skip whitespaces (optsep) */
746 ++ctx->indent;
747 break;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200748 case '\t':
Michal Vasko7fbc8162018-09-17 10:35:16 +0200749 /* skip whitespaces (optsep) */
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200750 ctx->indent += 8;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200751 break;
752 default:
753 /* either a keyword start or an invalid character */
754 goto keyword_start;
755 }
756
757 ++(*data);
758 }
759
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200760#define IF_KW(STR, LEN, STMT) if (!strncmp(*(data), STR, LEN)) {MOVE_INPUT(ctx, data, LEN);*kw=STMT;}
761#define IF_KW_PREFIX(STR, LEN) if (!strncmp(*(data), STR, LEN)) {MOVE_INPUT(ctx, data, LEN);
762#define IF_KW_PREFIX_END }
763
Michal Vasko7fbc8162018-09-17 10:35:16 +0200764keyword_start:
765 word_start = *data;
766 *kw = YANG_NONE;
767
768 /* read the keyword itself */
769 switch (**data) {
770 case 'a':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200771 MOVE_INPUT(ctx, data, 1);
772 IF_KW("rgument", 7, YANG_ARGUMENT)
773 else IF_KW("ugment", 6, YANG_AUGMENT)
774 else IF_KW("ction", 5, YANG_ACTION)
775 else IF_KW_PREFIX("ny", 2)
776 IF_KW("data", 4, YANG_ANYDATA)
777 else IF_KW("xml", 3, YANG_ANYXML)
778 IF_KW_PREFIX_END
Michal Vasko7fbc8162018-09-17 10:35:16 +0200779 break;
780 case 'b':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200781 MOVE_INPUT(ctx, data, 1);
782 IF_KW("ase", 3, YANG_BASE)
783 else IF_KW("elongs-to", 9, YANG_BELONGS_TO)
784 else IF_KW("it", 2, YANG_BIT)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200785 break;
786 case 'c':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200787 MOVE_INPUT(ctx, data, 1);
788 IF_KW("ase", 3, YANG_CASE)
789 else IF_KW("hoice", 5, YANG_CHOICE)
790 else IF_KW_PREFIX("on", 2)
791 IF_KW("fig", 3, YANG_CONFIG)
792 else IF_KW_PREFIX("ta", 2)
793 IF_KW("ct", 2, YANG_CONTACT)
794 else IF_KW("iner", 4, YANG_CONTAINER)
795 IF_KW_PREFIX_END
796 IF_KW_PREFIX_END
Michal Vasko7fbc8162018-09-17 10:35:16 +0200797 break;
798 case 'd':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200799 MOVE_INPUT(ctx, data, 1);
800 IF_KW_PREFIX("e", 1)
801 IF_KW("fault", 5, YANG_DEFAULT)
802 else IF_KW("scription", 9, YANG_DESCRIPTION)
803 else IF_KW_PREFIX("viat", 4)
804 IF_KW("e", 1, YANG_DEVIATE)
805 else IF_KW("ion", 3, YANG_DEVIATION)
806 IF_KW_PREFIX_END
807 IF_KW_PREFIX_END
Michal Vasko7fbc8162018-09-17 10:35:16 +0200808 break;
809 case 'e':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200810 MOVE_INPUT(ctx, data, 1);
811 IF_KW("num", 3, YANG_ENUM)
812 else IF_KW_PREFIX("rror-", 5)
813 IF_KW("app-tag", 7, YANG_ERROR_APP_TAG)
814 else IF_KW("message", 7, YANG_ERROR_MESSAGE)
815 IF_KW_PREFIX_END
816 else IF_KW("xtension", 8, YANG_EXTENSION)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200817 break;
818 case 'f':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200819 MOVE_INPUT(ctx, data, 1);
820 IF_KW("eature", 6, YANG_FEATURE)
821 else IF_KW("raction-digits", 14, YANG_FRACTION_DIGITS)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200822 break;
823 case 'g':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200824 MOVE_INPUT(ctx, data, 1);
825 IF_KW("rouping", 7, YANG_GROUPING)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200826 break;
827 case 'i':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200828 MOVE_INPUT(ctx, data, 1);
829 IF_KW("dentity", 7, YANG_IDENTITY)
830 else IF_KW("f-feature", 9, YANG_IF_FEATURE)
831 else IF_KW("mport", 5, YANG_IMPORT)
832 else IF_KW_PREFIX("n", 1)
833 IF_KW("clude", 5, YANG_INCLUDE)
834 else IF_KW("put", 3, YANG_INPUT)
835 IF_KW_PREFIX_END
Michal Vasko7fbc8162018-09-17 10:35:16 +0200836 break;
837 case 'k':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200838 MOVE_INPUT(ctx, data, 1);
839 IF_KW("ey", 2, YANG_KEY)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200840 break;
841 case 'l':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200842 MOVE_INPUT(ctx, data, 1);
843 IF_KW_PREFIX("e", 1)
844 IF_KW("af-list", 7, YANG_LEAF_LIST)
845 else IF_KW("af", 2, YANG_LEAF)
846 else IF_KW("ngth", 4, YANG_LENGTH)
847 IF_KW_PREFIX_END
848 else IF_KW("ist", 3, YANG_LIST)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200849 break;
850 case 'm':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200851 MOVE_INPUT(ctx, data, 1);
852 IF_KW_PREFIX("a", 1)
853 IF_KW("ndatory", 7, YANG_MANDATORY)
854 else IF_KW("x-elements", 10, YANG_MAX_ELEMENTS)
855 IF_KW_PREFIX_END
856 else IF_KW("in-elements", 11, YANG_MIN_ELEMENTS)
857 else IF_KW("ust", 3, YANG_MUST)
858 else IF_KW_PREFIX("od", 2)
859 IF_KW("ule", 3, YANG_MODULE)
860 else IF_KW("ifier", 5, YANG_MODIFIER)
861 IF_KW_PREFIX_END
Michal Vasko7fbc8162018-09-17 10:35:16 +0200862 break;
863 case 'n':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200864 MOVE_INPUT(ctx, data, 1);
865 IF_KW("amespace", 8, YANG_NAMESPACE)
866 else IF_KW("otification", 11, YANG_NOTIFICATION)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200867 break;
868 case 'o':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200869 MOVE_INPUT(ctx, data, 1);
870 IF_KW_PREFIX("r", 1)
871 IF_KW("dered-by", 8, YANG_ORDERED_BY)
872 else IF_KW("ganization", 10, YANG_ORGANIZATION)
873 IF_KW_PREFIX_END
874 else IF_KW("utput", 5, YANG_OUTPUT)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200875 break;
876 case 'p':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200877 MOVE_INPUT(ctx, data, 1);
878 IF_KW("ath", 3, YANG_PATH)
879 else IF_KW("attern", 6, YANG_PATTERN)
880 else IF_KW("osition", 7, YANG_POSITION)
881 else IF_KW_PREFIX("re", 2)
882 IF_KW("fix", 3, YANG_PREFIX)
883 else IF_KW("sence", 5, YANG_PRESENCE)
884 IF_KW_PREFIX_END
Michal Vasko7fbc8162018-09-17 10:35:16 +0200885 break;
886 case 'r':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200887 MOVE_INPUT(ctx, data, 1);
888 IF_KW("ange", 4, YANG_RANGE)
889 else IF_KW_PREFIX("e", 1)
890 IF_KW_PREFIX("f", 1)
891 IF_KW("erence", 6, YANG_REFERENCE)
892 else IF_KW("ine", 3, YANG_REFINE)
893 IF_KW_PREFIX_END
894 else IF_KW("quire-instance", 14, YANG_REQUIRE_INSTANCE)
895 else IF_KW("vision-date", 11, YANG_REVISION_DATE)
896 else IF_KW("vision", 6, YANG_REVISION)
897 IF_KW_PREFIX_END
898 else IF_KW("pc", 2, YANG_RPC)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200899 break;
900 case 's':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200901 MOVE_INPUT(ctx, data, 1);
902 IF_KW("tatus", 5, YANG_STATUS)
903 else IF_KW("ubmodule", 8, YANG_SUBMODULE)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200904 break;
905 case 't':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200906 MOVE_INPUT(ctx, data, 1);
907 IF_KW("ypedef", 6, YANG_TYPEDEF)
908 else IF_KW("ype", 3, YANG_TYPE)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200909 break;
910 case 'u':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200911 MOVE_INPUT(ctx, data, 1);
912 IF_KW_PREFIX("ni", 2)
913 IF_KW("que", 3, YANG_UNIQUE)
914 else IF_KW("ts", 2, YANG_UNITS)
915 IF_KW_PREFIX_END
916 else IF_KW("ses", 3, YANG_USES)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200917 break;
918 case 'v':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200919 MOVE_INPUT(ctx, data, 1);
920 IF_KW("alue", 4, YANG_VALUE)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200921 break;
922 case 'w':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200923 MOVE_INPUT(ctx, data, 1);
924 IF_KW("hen", 3, YANG_WHEN)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200925 break;
926 case 'y':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200927 MOVE_INPUT(ctx, data, 1);
928 IF_KW("ang-version", 11, YANG_YANG_VERSION)
929 else IF_KW("in-element", 10, YANG_YIN_ELEMENT)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200930 break;
931 case ';':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200932 MOVE_INPUT(ctx, data, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200933 *kw = YANG_SEMICOLON;
Radek Krejci626df482018-10-11 15:06:31 +0200934 goto success;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200935 case '{':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200936 MOVE_INPUT(ctx, data, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200937 *kw = YANG_LEFT_BRACE;
Radek Krejci626df482018-10-11 15:06:31 +0200938 goto success;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200939 case '}':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200940 MOVE_INPUT(ctx, data, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200941 *kw = YANG_RIGHT_BRACE;
Radek Krejci626df482018-10-11 15:06:31 +0200942 goto success;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200943 default:
944 break;
945 }
946
Radek Krejci0904c162019-01-02 15:03:59 +0100947#undef IF_KW
948#undef IF_KW_PREFIX
949#undef IF_KW_PREFIX_END
950
Michal Vasko7fbc8162018-09-17 10:35:16 +0200951 if (*kw != YANG_NONE) {
952 /* make sure we have the whole keyword */
953 switch (**data) {
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200954 case '\n':
Michal Vasko7fbc8162018-09-17 10:35:16 +0200955 case '\t':
Radek Krejciabdd8062019-06-11 16:44:19 +0200956 case ' ':
957 /* mandatory "sep" is just checked, not eaten so nothing in the context is updated */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200958 break;
Radek Krejci156ccaf2018-10-15 15:49:17 +0200959 case ':':
960 /* keyword is not actually a keyword, but prefix of an extension.
961 * To avoid repeated check of the prefix syntax, move to the point where the colon was read
962 * and we will be checking the keyword (extension instance) itself */
963 prefix = 1;
964 MOVE_INPUT(ctx, data, 1);
965 goto extension;
Radek Krejcidcc7b322018-10-11 14:24:02 +0200966 case '{':
967 /* allowed only for input and output statements which can be without arguments */
968 if (*kw == YANG_INPUT || *kw == YANG_OUTPUT) {
969 break;
970 }
971 /* fallthrough */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200972 default:
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200973 MOVE_INPUT(ctx, data, 1);
Radek Krejci44ceedc2018-10-02 15:54:31 +0200974 LOGVAL_YANG(ctx, LY_VCODE_INSTREXP, (int)(*data - word_start), word_start,
975 "a keyword followed by a separator");
Michal Vasko7fbc8162018-09-17 10:35:16 +0200976 return LY_EVALID;
977 }
978 } else {
979 /* still can be an extension */
980 prefix = 0;
Radek Krejci156ccaf2018-10-15 15:49:17 +0200981extension:
Michal Vasko7fbc8162018-09-17 10:35:16 +0200982 while (**data && (**data != ' ') && (**data != '\t') && (**data != '\n') && (**data != '{') && (**data != ';')) {
Radek Krejci44ceedc2018-10-02 15:54:31 +0200983 LY_CHECK_ERR_RET(ly_getutf8(data, &c, &len),
984 LOGVAL_YANG(ctx, LY_VCODE_INCHAR, (*data)[-len]), LY_EVALID);
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200985 ++ctx->indent;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200986 /* check character validity */
987 LY_CHECK_RET(check_identifierchar(ctx, c, *data - len == word_start ? 1 : 0, &prefix));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200988 }
989 if (!**data) {
Radek Krejci44ceedc2018-10-02 15:54:31 +0200990 LOGVAL_YANG(ctx, LY_VCODE_EOF);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200991 return LY_EVALID;
992 }
993
994 /* prefix is mandatory for extension instances */
Radek Krejcidcc7b322018-10-11 14:24:02 +0200995 if (prefix != 2) {
Radek Krejci44ceedc2018-10-02 15:54:31 +0200996 LOGVAL_YANG(ctx, LY_VCODE_INSTREXP, (int)(*data - word_start), word_start, "a keyword");
Michal Vasko7fbc8162018-09-17 10:35:16 +0200997 return LY_EVALID;
998 }
999
1000 *kw = YANG_CUSTOM;
1001 }
Radek Krejci626df482018-10-11 15:06:31 +02001002success:
Michal Vasko7fbc8162018-09-17 10:35:16 +02001003 if (word_p) {
1004 *word_p = (char *)word_start;
1005 *word_len = *data - word_start;
1006 }
1007
1008 return LY_SUCCESS;
1009}
1010
Michal Vaskoea5abea2018-09-18 13:10:54 +02001011/**
1012 * @brief Parse extension instance substatements.
1013 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001014 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001015 * @param[in,out] data Data to read from, always moved to currently handled character.
1016 * @param[in] word Extension instance substatement name (keyword).
1017 * @param[in] word_len Extension instance substatement name length.
1018 * @param[in,out] child Children of this extension instance to add to.
1019 *
1020 * @return LY_ERR values.
1021 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001022static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001023parse_ext_substmt(struct lys_parser_ctx *ctx, const char **data, char *word, size_t word_len,
Michal Vasko7fbc8162018-09-17 10:35:16 +02001024 struct lysp_stmt **child)
1025{
1026 char *buf;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001027 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001028 enum yang_keyword kw;
1029 struct lysp_stmt *stmt, *par_child;
1030
1031 stmt = calloc(1, sizeof *stmt);
1032 LY_CHECK_ERR_RET(!stmt, LOGMEM(NULL), LY_EMEM);
1033
Radek Krejcibb9b1982019-04-08 14:24:59 +02001034 /* insert into parent statements */
1035 if (!*child) {
1036 *child = stmt;
1037 } else {
1038 for (par_child = *child; par_child->next; par_child = par_child->next);
1039 par_child->next = stmt;
1040 }
1041
Radek Krejci44ceedc2018-10-02 15:54:31 +02001042 stmt->stmt = lydict_insert(ctx->ctx, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001043
1044 /* get optional argument */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001045 LY_CHECK_RET(get_argument(ctx, data, Y_MAYBE_STR_ARG, &stmt->flags, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001046
Radek Krejci0ae092d2018-09-20 16:43:19 +02001047 if (word) {
1048 if (buf) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001049 stmt->arg = lydict_insert_zc(ctx->ctx, word);
Radek Krejci0ae092d2018-09-20 16:43:19 +02001050 } else {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001051 stmt->arg = lydict_insert(ctx->ctx, word, word_len);
Radek Krejci0ae092d2018-09-20 16:43:19 +02001052 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001053 }
1054
Radek Krejci6d6556c2018-11-08 09:37:45 +01001055 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret, ) {
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001056 LY_CHECK_RET(parse_ext_substmt(ctx, data, word, word_len, &stmt->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001057 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001058 return ret;
1059}
1060
Michal Vaskoea5abea2018-09-18 13:10:54 +02001061/**
1062 * @brief Parse extension instance.
1063 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001064 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001065 * @param[in,out] data Data to read from, always moved to currently handled character.
1066 * @param[in] ext_name Extension instance substatement name (keyword).
1067 * @param[in] ext_name_len Extension instance substatement name length.
1068 * @param[in] insubstmt Type of the keyword this extension instance is a substatement of.
1069 * @param[in] insubstmt_index Index of the keyword instance this extension instance is a substatement of.
1070 * @param[in,out] exts Extension instances to add to.
1071 *
1072 * @return LY_ERR values.
1073 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001074static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001075parse_ext(struct lys_parser_ctx *ctx, const char **data, const char *ext_name, int ext_name_len, LYEXT_SUBSTMT insubstmt,
Michal Vasko7fbc8162018-09-17 10:35:16 +02001076 uint32_t insubstmt_index, struct lysp_ext_instance **exts)
1077{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001078 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001079 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001080 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001081 struct lysp_ext_instance *e;
1082 enum yang_keyword kw;
1083
Radek Krejci2c4e7172018-10-19 15:56:26 +02001084 LY_ARRAY_NEW_RET(ctx->ctx, *exts, e, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001085
1086 /* store name and insubstmt info */
Radek Krejci44ceedc2018-10-02 15:54:31 +02001087 e->name = lydict_insert(ctx->ctx, ext_name, ext_name_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001088 e->insubstmt = insubstmt;
1089 e->insubstmt_index = insubstmt_index;
1090
1091 /* get optional argument */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001092 LY_CHECK_RET(get_argument(ctx, data, Y_MAYBE_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001093
Radek Krejci0ae092d2018-09-20 16:43:19 +02001094 if (word) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001095 INSERT_WORD(ctx, buf, e->argument, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001096 }
1097
Radek Krejci6d6556c2018-11-08 09:37:45 +01001098 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001099 LY_CHECK_RET(parse_ext_substmt(ctx, data, word, word_len, &e->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001100 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001101 return ret;
1102}
1103
Michal Vaskoea5abea2018-09-18 13:10:54 +02001104/**
1105 * @brief Parse a generic text field without specific constraints. Those are contact, organization,
1106 * description, etc...
1107 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001108 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001109 * @param[in,out] data Data to read from, always moved to currently handled character.
1110 * @param[in] substmt Type of this substatement.
1111 * @param[in] substmt_index Index of this substatement.
1112 * @param[in,out] value Place to store the parsed value.
1113 * @param[in] arg Type of the YANG keyword argument (of the value).
1114 * @param[in,out] exts Extension instances to add to.
1115 *
1116 * @return LY_ERR values.
1117 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001118static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001119parse_text_field(struct lys_parser_ctx *ctx, const char **data, LYEXT_SUBSTMT substmt, uint32_t substmt_index,
Michal Vasko7fbc8162018-09-17 10:35:16 +02001120 const char **value, enum yang_arg arg, struct lysp_ext_instance **exts)
1121{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001122 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001123 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001124 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001125 enum yang_keyword kw;
1126
1127 if (*value) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001128 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, lyext_substmt2str(substmt));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001129 return LY_EVALID;
1130 }
1131
1132 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001133 LY_CHECK_RET(get_argument(ctx, data, arg, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001134
Radek Krejci9006a4e2019-06-11 14:56:56 +02001135 if (!word_len) {
1136 /* empty value */
1137 word = "";
1138 }
1139
Michal Vasko7fbc8162018-09-17 10:35:16 +02001140 /* store value and spend buf if allocated */
Radek Krejci44ceedc2018-10-02 15:54:31 +02001141 INSERT_WORD(ctx, buf, *value, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001142
Radek Krejci6d6556c2018-11-08 09:37:45 +01001143 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001144 switch (kw) {
1145 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001146 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, substmt, substmt_index, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001147 break;
1148 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001149 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), lyext_substmt2str(substmt));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001150 return LY_EVALID;
1151 }
1152 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001153 return ret;
1154}
1155
Michal Vaskoea5abea2018-09-18 13:10:54 +02001156/**
1157 * @brief Parse the yang-version statement.
1158 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001159 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001160 * @param[in,out] data Data to read from, always moved to currently handled character.
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001161 * @param[out] version Storage for the parsed information.
1162 * @param[in, out] exts Extension instances to add to.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001163 *
1164 * @return LY_ERR values.
1165 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001166static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001167parse_yangversion(struct lys_parser_ctx *ctx, const char **data, uint8_t *version, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001168{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001169 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001170 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001171 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001172 enum yang_keyword kw;
1173
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001174 if (*version) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001175 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "yang-version");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001176 return LY_EVALID;
1177 }
1178
1179 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001180 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001181
1182 if ((word_len == 3) && !strncmp(word, "1.0", word_len)) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001183 *version = LYS_VERSION_1_0;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001184 } else if ((word_len == 3) && !strncmp(word, "1.1", word_len)) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001185 *version = LYS_VERSION_1_1;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001186 } else {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001187 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "yang-version");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001188 free(buf);
1189 return LY_EVALID;
1190 }
1191 free(buf);
1192
Radek Krejci6d6556c2018-11-08 09:37:45 +01001193 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001194 switch (kw) {
1195 case YANG_CUSTOM:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001196 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_VERSION, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001197 break;
1198 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001199 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "yang-version");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001200 return LY_EVALID;
1201 }
1202 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001203 return ret;
1204}
1205
Michal Vaskoea5abea2018-09-18 13:10:54 +02001206/**
1207 * @brief Parse the belongs-to statement.
1208 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001209 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001210 * @param[in,out] data Data to read from, always moved to currently handled character.
1211 * @param[in,out] belongsto Place to store the parsed value.
1212 * @param[in,out] prefix Place to store the parsed belongs-to prefix value.
1213 * @param[in,out] exts Extension instances to add to.
1214 *
1215 * @return LY_ERR values.
1216 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001217static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001218parse_belongsto(struct lys_parser_ctx *ctx, const char **data, const char **belongsto, const char **prefix, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001219{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001220 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001221 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001222 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001223 enum yang_keyword kw;
1224
1225 if (*belongsto) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001226 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "belongs-to");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001227 return LY_EVALID;
1228 }
1229
1230 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001231 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001232
Radek Krejci44ceedc2018-10-02 15:54:31 +02001233 INSERT_WORD(ctx, buf, *belongsto, word, word_len);
Radek Krejci6d6556c2018-11-08 09:37:45 +01001234 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret, goto checks) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001235 switch (kw) {
1236 case YANG_PREFIX:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001237 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_PREFIX, 0, prefix, Y_IDENTIF_ARG, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001238 break;
1239 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001240 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_BELONGSTO, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001241 break;
1242 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001243 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "belongs-to");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001244 return LY_EVALID;
1245 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001246 }
Radek Krejcic59bc972018-09-17 16:13:06 +02001247 LY_CHECK_RET(ret);
Radek Krejci6d6556c2018-11-08 09:37:45 +01001248checks:
Michal Vasko7fbc8162018-09-17 10:35:16 +02001249 /* mandatory substatements */
1250 if (!*prefix) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001251 LOGVAL_YANG(ctx, LY_VCODE_MISSTMT, "prefix", "belongs-to");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001252 return LY_EVALID;
1253 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001254 return ret;
1255}
1256
Michal Vaskoea5abea2018-09-18 13:10:54 +02001257/**
1258 * @brief Parse the revision-date statement.
1259 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001260 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001261 * @param[in,out] data Data to read from, always moved to currently handled character.
1262 * @param[in,out] rev Array to store the parsed value in.
1263 * @param[in,out] exts Extension instances to add to.
1264 *
1265 * @return LY_ERR values.
1266 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001267static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001268parse_revisiondate(struct lys_parser_ctx *ctx, const char **data, char *rev, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001269{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001270 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001271 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001272 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001273 enum yang_keyword kw;
1274
1275 if (rev[0]) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001276 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "revision-date");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001277 return LY_EVALID;
1278 }
1279
1280 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001281 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001282
1283 /* check value */
Radek Krejcibbe09a92018-11-08 09:36:54 +01001284 if (lysp_check_date(ctx, word, word_len, "revision-date")) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001285 free(buf);
1286 return LY_EVALID;
1287 }
1288
1289 /* store value and spend buf if allocated */
1290 strncpy(rev, word, word_len);
1291 free(buf);
1292
Radek Krejci6d6556c2018-11-08 09:37:45 +01001293 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001294 switch (kw) {
1295 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001296 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_REVISIONDATE, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001297 break;
1298 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001299 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "revision-date");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001300 return LY_EVALID;
1301 }
1302 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001303 return ret;
1304}
1305
Michal Vaskoea5abea2018-09-18 13:10:54 +02001306/**
1307 * @brief Parse the include statement.
1308 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001309 * @param[in] ctx yang parser context for logging.
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001310 * @param[in] module_name Name of the module to check name collisions.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001311 * @param[in,out] data Data to read from, always moved to currently handled character.
1312 * @param[in,out] includes Parsed includes to add to.
1313 *
1314 * @return LY_ERR values.
1315 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001316static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001317parse_include(struct lys_parser_ctx *ctx, const char *module_name, const char **data, struct lysp_include **includes)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001318{
Radek Krejcid33273d2018-10-25 14:55:52 +02001319 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001320 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001321 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001322 enum yang_keyword kw;
1323 struct lysp_include *inc;
1324
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001325 LY_ARRAY_NEW_RET(ctx->ctx, *includes, inc, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001326
1327 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001328 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001329
Radek Krejci086c7132018-10-26 15:29:04 +02001330 INSERT_WORD(ctx, buf, inc->name, word, word_len);
1331
Radek Krejcifaa1eac2018-10-30 14:34:55 +01001332 /* submodules share the namespace with the module names, so there must not be
1333 * a module of the same name in the context, no need for revision matching */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001334 if (!strcmp(module_name, inc->name) || ly_ctx_get_module_latest(ctx->ctx, inc->name)) {
Radek Krejcifaa1eac2018-10-30 14:34:55 +01001335 LOGVAL_YANG(ctx, LYVE_SYNTAX_YANG, "Name collision between module and submodule of name \"%s\".", inc->name);
1336 return LY_EVALID;
1337 }
1338
Radek Krejci6d6556c2018-11-08 09:37:45 +01001339 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001340 switch (kw) {
1341 case YANG_DESCRIPTION:
Radek Krejciceaf2122019-01-02 15:03:26 +01001342 YANG_CHECK_STMTVER2_RET(ctx, "description", "include");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001343 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &inc->dsc, Y_STR_ARG, &inc->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001344 break;
1345 case YANG_REFERENCE:
Radek Krejciceaf2122019-01-02 15:03:26 +01001346 YANG_CHECK_STMTVER2_RET(ctx, "reference", "include");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001347 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &inc->ref, Y_STR_ARG, &inc->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001348 break;
1349 case YANG_REVISION_DATE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001350 LY_CHECK_RET(parse_revisiondate(ctx, data, inc->rev, &inc->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001351 break;
1352 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001353 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &inc->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001354 break;
1355 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001356 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "include");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001357 return LY_EVALID;
1358 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001359 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001360 return ret;
1361}
1362
Michal Vaskoea5abea2018-09-18 13:10:54 +02001363/**
1364 * @brief Parse the import statement.
1365 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001366 * @param[in] ctx yang parser context for logging.
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001367 * @param[in] module_prefix Prefix of the module to check prefix collisions.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001368 * @param[in,out] data Data to read from, always moved to currently handled character.
1369 * @param[in,out] imports Parsed imports to add to.
1370 *
1371 * @return LY_ERR values.
1372 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001373static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001374parse_import(struct lys_parser_ctx *ctx, const char *module_prefix, const char **data, struct lysp_import **imports)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001375{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001376 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001377 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001378 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001379 enum yang_keyword kw;
1380 struct lysp_import *imp;
1381
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001382 LY_ARRAY_NEW_RET(ctx->ctx, *imports, imp, LY_EVALID);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001383
1384 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001385 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02001386 INSERT_WORD(ctx, buf, imp->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001387
Radek Krejci6d6556c2018-11-08 09:37:45 +01001388 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret, goto checks) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001389 switch (kw) {
1390 case YANG_PREFIX:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001391 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_PREFIX, 0, &imp->prefix, Y_IDENTIF_ARG, &imp->exts));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001392 LY_CHECK_RET(lysp_check_prefix(ctx, *imports, module_prefix, &imp->prefix), LY_EVALID);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001393 break;
1394 case YANG_DESCRIPTION:
Radek Krejciceaf2122019-01-02 15:03:26 +01001395 YANG_CHECK_STMTVER2_RET(ctx, "description", "import");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001396 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &imp->dsc, Y_STR_ARG, &imp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001397 break;
1398 case YANG_REFERENCE:
Radek Krejciceaf2122019-01-02 15:03:26 +01001399 YANG_CHECK_STMTVER2_RET(ctx, "reference", "import");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001400 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &imp->ref, Y_STR_ARG, &imp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001401 break;
1402 case YANG_REVISION_DATE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001403 LY_CHECK_RET(parse_revisiondate(ctx, data, imp->rev, &imp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001404 break;
1405 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001406 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &imp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001407 break;
1408 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001409 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "import");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001410 return LY_EVALID;
1411 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001412 }
Radek Krejcic59bc972018-09-17 16:13:06 +02001413 LY_CHECK_RET(ret);
Radek Krejci6d6556c2018-11-08 09:37:45 +01001414checks:
Michal Vasko7fbc8162018-09-17 10:35:16 +02001415 /* mandatory substatements */
Radek Krejci086c7132018-10-26 15:29:04 +02001416 LY_CHECK_ERR_RET(!imp->prefix, LOGVAL_YANG(ctx, LY_VCODE_MISSTMT, "prefix", "import"), LY_EVALID);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001417
1418 return ret;
1419}
1420
Michal Vaskoea5abea2018-09-18 13:10:54 +02001421/**
1422 * @brief Parse the revision statement.
1423 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001424 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001425 * @param[in,out] data Data to read from, always moved to currently handled character.
1426 * @param[in,out] revs Parsed revisions to add to.
1427 *
1428 * @return LY_ERR values.
1429 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001430static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001431parse_revision(struct lys_parser_ctx *ctx, const char **data, struct lysp_revision **revs)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001432{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001433 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001434 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001435 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001436 enum yang_keyword kw;
1437 struct lysp_revision *rev;
1438
Radek Krejci2c4e7172018-10-19 15:56:26 +02001439 LY_ARRAY_NEW_RET(ctx->ctx, *revs, rev, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001440
1441 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001442 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001443
1444 /* check value */
Radek Krejcibbe09a92018-11-08 09:36:54 +01001445 if (lysp_check_date(ctx, word, word_len, "revision")) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001446 return LY_EVALID;
1447 }
1448
Radek Krejcib7db73a2018-10-24 14:18:40 +02001449 strncpy(rev->date, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001450 free(buf);
1451
Radek Krejci6d6556c2018-11-08 09:37:45 +01001452 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001453 switch (kw) {
1454 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001455 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &rev->dsc, Y_STR_ARG, &rev->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001456 break;
1457 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001458 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &rev->ref, Y_STR_ARG, &rev->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001459 break;
1460 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001461 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &rev->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001462 break;
1463 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001464 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "revision");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001465 return LY_EVALID;
1466 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001467 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001468 return ret;
1469}
1470
Michal Vaskoea5abea2018-09-18 13:10:54 +02001471/**
1472 * @brief Parse a generic text field that can have more instances such as base.
1473 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001474 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001475 * @param[in,out] data Data to read from, always moved to currently handled character.
1476 * @param[in] substmt Type of this substatement.
1477 * @param[in,out] texts Parsed values to add to.
1478 * @param[in] arg Type of the expected argument.
1479 * @param[in,out] exts Extension instances to add to.
1480 *
1481 * @return LY_ERR values.
1482 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001483static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001484parse_text_fields(struct lys_parser_ctx *ctx, const char **data, LYEXT_SUBSTMT substmt, const char ***texts, enum yang_arg arg,
Michal Vasko7fbc8162018-09-17 10:35:16 +02001485 struct lysp_ext_instance **exts)
1486{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001487 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001488 char *buf, *word;
Radek Krejci151a5b72018-10-19 14:21:44 +02001489 const char **item;
1490 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001491 enum yang_keyword kw;
1492
1493 /* allocate new pointer */
Radek Krejci2c4e7172018-10-19 15:56:26 +02001494 LY_ARRAY_NEW_RET(ctx->ctx, *texts, item, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001495
1496 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001497 LY_CHECK_RET(get_argument(ctx, data, arg, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001498
Radek Krejci151a5b72018-10-19 14:21:44 +02001499 INSERT_WORD(ctx, buf, *item, word, word_len);
Radek Krejci6d6556c2018-11-08 09:37:45 +01001500 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001501 switch (kw) {
1502 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001503 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, substmt, LY_ARRAY_SIZE(*texts) - 1, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001504 break;
1505 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001506 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), lyext_substmt2str(substmt));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001507 return LY_EVALID;
1508 }
1509 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001510 return ret;
1511}
1512
Michal Vaskoea5abea2018-09-18 13:10:54 +02001513/**
1514 * @brief Parse the config statement.
1515 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001516 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001517 * @param[in,out] data Data to read from, always moved to currently handled character.
1518 * @param[in,out] flags Flags to add to.
1519 * @param[in,out] exts Extension instances to add to.
1520 *
1521 * @return LY_ERR values.
1522 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001523static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001524parse_config(struct lys_parser_ctx *ctx, const char **data, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001525{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001526 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001527 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001528 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001529 enum yang_keyword kw;
1530
1531 if (*flags & LYS_CONFIG_MASK) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001532 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "config");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001533 return LY_EVALID;
1534 }
1535
1536 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001537 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001538
1539 if ((word_len == 4) && !strncmp(word, "true", word_len)) {
1540 *flags |= LYS_CONFIG_W;
1541 } else if ((word_len == 5) && !strncmp(word, "false", word_len)) {
1542 *flags |= LYS_CONFIG_R;
1543 } else {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001544 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "config");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001545 free(buf);
1546 return LY_EVALID;
1547 }
1548 free(buf);
1549
Radek Krejci6d6556c2018-11-08 09:37:45 +01001550 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001551 switch (kw) {
1552 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001553 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_CONFIG, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001554 break;
1555 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001556 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "config");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001557 return LY_EVALID;
1558 }
1559 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001560 return ret;
1561}
1562
Michal Vaskoea5abea2018-09-18 13:10:54 +02001563/**
1564 * @brief Parse the mandatory statement.
1565 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001566 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001567 * @param[in,out] data Data to read from, always moved to currently handled character.
1568 * @param[in,out] flags Flags to add to.
1569 * @param[in,out] exts Extension instances to add to.
1570 *
1571 * @return LY_ERR values.
1572 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001573static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001574parse_mandatory(struct lys_parser_ctx *ctx, const char **data, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001575{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001576 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001577 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001578 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001579 enum yang_keyword kw;
1580
1581 if (*flags & LYS_MAND_MASK) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001582 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "mandatory");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001583 return LY_EVALID;
1584 }
1585
1586 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001587 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001588
1589 if ((word_len == 4) && !strncmp(word, "true", word_len)) {
1590 *flags |= LYS_MAND_TRUE;
1591 } else if ((word_len == 5) && !strncmp(word, "false", word_len)) {
1592 *flags |= LYS_MAND_FALSE;
1593 } else {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001594 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "mandatory");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001595 free(buf);
1596 return LY_EVALID;
1597 }
1598 free(buf);
1599
Radek Krejci6d6556c2018-11-08 09:37:45 +01001600 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001601 switch (kw) {
1602 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001603 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_MANDATORY, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001604 break;
1605 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001606 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "mandatory");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001607 return LY_EVALID;
1608 }
1609 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001610 return ret;
1611}
1612
Michal Vaskoea5abea2018-09-18 13:10:54 +02001613/**
1614 * @brief Parse a restriction such as range or length.
1615 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001616 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001617 * @param[in,out] data Data to read from, always moved to currently handled character.
1618 * @param[in] restr_kw Type of this particular restriction.
1619 * @param[in,out] exts Extension instances to add to.
1620 *
1621 * @return LY_ERR values.
1622 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001623static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001624parse_restr(struct lys_parser_ctx *ctx, const char **data, enum yang_keyword restr_kw, struct lysp_restr *restr)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001625{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001626 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001627 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001628 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001629 enum yang_keyword kw;
1630
1631 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001632 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001633
Radek Krejci44ceedc2018-10-02 15:54:31 +02001634 INSERT_WORD(ctx, buf, restr->arg, word, word_len);
Radek Krejci6d6556c2018-11-08 09:37:45 +01001635 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001636 switch (kw) {
1637 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001638 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &restr->dsc, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001639 break;
1640 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001641 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &restr->ref, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001642 break;
1643 case YANG_ERROR_APP_TAG:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001644 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_ERRTAG, 0, &restr->eapptag, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001645 break;
1646 case YANG_ERROR_MESSAGE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001647 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_ERRMSG, 0, &restr->emsg, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001648 break;
1649 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001650 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001651 break;
1652 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001653 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(restr_kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001654 return LY_EVALID;
1655 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001656 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001657 return ret;
1658}
1659
Michal Vaskoea5abea2018-09-18 13:10:54 +02001660/**
1661 * @brief Parse a restriction that can have more instances such as must.
1662 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001663 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001664 * @param[in,out] data Data to read from, always moved to currently handled character.
1665 * @param[in] restr_kw Type of this particular restriction.
1666 * @param[in,out] restrs Restrictions to add to.
1667 *
1668 * @return LY_ERR values.
1669 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001670static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001671parse_restrs(struct lys_parser_ctx *ctx, const char **data, enum yang_keyword restr_kw, struct lysp_restr **restrs)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001672{
1673 struct lysp_restr *restr;
1674
Radek Krejci2c4e7172018-10-19 15:56:26 +02001675 LY_ARRAY_NEW_RET(ctx->ctx, *restrs, restr, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001676 return parse_restr(ctx, data, restr_kw, restr);
1677}
1678
Michal Vaskoea5abea2018-09-18 13:10:54 +02001679/**
1680 * @brief Parse the status statement.
1681 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001682 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001683 * @param[in,out] data Data to read from, always moved to currently handled character.
1684 * @param[in,out] flags Flags to add to.
1685 * @param[in,out] exts Extension instances to add to.
1686 *
1687 * @return LY_ERR values.
1688 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001689static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001690parse_status(struct lys_parser_ctx *ctx, const char **data, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001691{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001692 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001693 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001694 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001695 enum yang_keyword kw;
1696
1697 if (*flags & LYS_STATUS_MASK) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001698 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "status");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001699 return LY_EVALID;
1700 }
1701
1702 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001703 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001704
1705 if ((word_len == 7) && !strncmp(word, "current", word_len)) {
1706 *flags |= LYS_STATUS_CURR;
1707 } else if ((word_len == 10) && !strncmp(word, "deprecated", word_len)) {
1708 *flags |= LYS_STATUS_DEPRC;
1709 } else if ((word_len == 8) && !strncmp(word, "obsolete", word_len)) {
1710 *flags |= LYS_STATUS_OBSLT;
1711 } else {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001712 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "status");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001713 free(buf);
1714 return LY_EVALID;
1715 }
1716 free(buf);
1717
Radek Krejci6d6556c2018-11-08 09:37:45 +01001718 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001719 switch (kw) {
1720 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001721 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_STATUS, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001722 break;
1723 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001724 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "status");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001725 return LY_EVALID;
1726 }
1727 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001728 return ret;
1729}
1730
Michal Vaskoea5abea2018-09-18 13:10:54 +02001731/**
1732 * @brief Parse the when statement.
1733 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001734 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001735 * @param[in,out] data Data to read from, always moved to currently handled character.
1736 * @param[in,out] when_p When pointer to parse to.
1737 *
1738 * @return LY_ERR values.
1739 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001740static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001741parse_when(struct lys_parser_ctx *ctx, const char **data, struct lysp_when **when_p)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001742{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001743 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001744 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001745 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001746 enum yang_keyword kw;
1747 struct lysp_when *when;
1748
1749 if (*when_p) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001750 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "when");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001751 return LY_EVALID;
1752 }
1753
1754 when = calloc(1, sizeof *when);
Radek Krejci44ceedc2018-10-02 15:54:31 +02001755 LY_CHECK_ERR_RET(!when, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001756 *when_p = when;
1757
1758 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001759 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02001760 INSERT_WORD(ctx, buf, when->cond, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001761
Radek Krejci6d6556c2018-11-08 09:37:45 +01001762 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001763 switch (kw) {
1764 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001765 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &when->dsc, Y_STR_ARG, &when->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001766 break;
1767 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001768 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &when->ref, Y_STR_ARG, &when->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001769 break;
1770 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001771 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &when->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001772 break;
1773 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001774 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "when");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001775 return LY_EVALID;
1776 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001777 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001778 return ret;
1779}
1780
Michal Vaskoea5abea2018-09-18 13:10:54 +02001781/**
1782 * @brief Parse the anydata or anyxml statement.
1783 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001784 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001785 * @param[in,out] data Data to read from, always moved to currently handled character.
1786 * @param[in] kw Type of this particular keyword.
1787 * @param[in,out] siblings Siblings to add to.
1788 *
1789 * @return LY_ERR values.
1790 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02001791LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001792parse_any(struct lys_parser_ctx *ctx, const char **data, enum yang_keyword kw, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001793{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001794 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001795 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001796 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001797 struct lysp_node *iter;
1798 struct lysp_node_anydata *any;
1799
1800 /* create structure */
1801 any = calloc(1, sizeof *any);
Radek Krejci44ceedc2018-10-02 15:54:31 +02001802 LY_CHECK_ERR_RET(!any, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001803 any->nodetype = kw == YANG_ANYDATA ? LYS_ANYDATA : LYS_ANYXML;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001804 any->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001805
1806 /* insert into siblings */
1807 if (!*siblings) {
1808 *siblings = (struct lysp_node *)any;
1809 } else {
1810 for (iter = *siblings; iter->next; iter = iter->next);
1811 iter->next = (struct lysp_node *)any;
1812 }
1813
1814 /* get name */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001815 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02001816 INSERT_WORD(ctx, buf, any->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001817
1818 /* parse substatements */
Radek Krejci6d6556c2018-11-08 09:37:45 +01001819 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001820 switch (kw) {
1821 case YANG_CONFIG:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001822 LY_CHECK_RET(parse_config(ctx, data, &any->flags, &any->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001823 break;
1824 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001825 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &any->dsc, Y_STR_ARG, &any->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001826 break;
1827 case YANG_IF_FEATURE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001828 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &any->iffeatures, Y_STR_ARG, &any->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001829 break;
1830 case YANG_MANDATORY:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001831 LY_CHECK_RET(parse_mandatory(ctx, data, &any->flags, &any->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001832 break;
1833 case YANG_MUST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001834 LY_CHECK_RET(parse_restrs(ctx, data, kw, &any->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001835 break;
1836 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001837 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &any->ref, Y_STR_ARG, &any->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001838 break;
1839 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001840 LY_CHECK_RET(parse_status(ctx, data, &any->flags, &any->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001841 break;
1842 case YANG_WHEN:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001843 LY_CHECK_RET(parse_when(ctx, data, &any->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001844 break;
1845 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001846 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &any->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001847 break;
1848 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001849 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw),
Radek Krejcic59bc972018-09-17 16:13:06 +02001850 (any->nodetype & LYS_ANYDATA) == LYS_ANYDATA ? ly_stmt2str(YANG_ANYDATA) : ly_stmt2str(YANG_ANYXML));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001851 return LY_EVALID;
1852 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001853 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001854 return ret;
1855}
1856
Michal Vaskoea5abea2018-09-18 13:10:54 +02001857/**
1858 * @brief Parse the value or position statement. Substatement of type enum statement.
1859 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001860 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001861 * @param[in,out] data Data to read from, always moved to currently handled character.
1862 * @param[in] val_kw Type of this particular keyword.
1863 * @param[in,out] value Value to write to.
1864 * @param[in,out] flags Flags to write to.
1865 * @param[in,out] exts Extension instances to add to.
1866 *
1867 * @return LY_ERR values.
1868 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001869static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001870parse_type_enum_value_pos(struct lys_parser_ctx *ctx, const char **data, enum yang_keyword val_kw, int64_t *value, uint16_t *flags,
Michal Vasko7fbc8162018-09-17 10:35:16 +02001871 struct lysp_ext_instance **exts)
1872{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001873 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001874 char *buf, *word, *ptr;
Radek Krejciefd22f62018-09-27 11:47:58 +02001875 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001876 long int num;
1877 unsigned long int unum;
1878 enum yang_keyword kw;
1879
1880 if (*flags & LYS_SET_VALUE) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001881 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, ly_stmt2str(val_kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001882 return LY_EVALID;
1883 }
1884 *flags |= LYS_SET_VALUE;
1885
1886 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001887 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001888
1889 if (!word_len || (word[0] == '+') || ((word[0] == '0') && (word_len > 1)) || ((val_kw == YANG_VALUE) && !strncmp(word, "-0", 2))) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001890 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, ly_stmt2str(val_kw));
Radek Krejci8b764662018-11-14 14:15:13 +01001891 goto error;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001892 }
1893
1894 errno = 0;
1895 if (val_kw == YANG_VALUE) {
1896 num = strtol(word, &ptr, 10);
Radek Krejci8b764662018-11-14 14:15:13 +01001897 if (num < INT64_C(-2147483648) || num > INT64_C(2147483647)) {
1898 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, ly_stmt2str(val_kw));
1899 goto error;
1900 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001901 } else {
1902 unum = strtoul(word, &ptr, 10);
Radek Krejci8b764662018-11-14 14:15:13 +01001903 if (unum > UINT64_C(4294967295)) {
1904 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, ly_stmt2str(val_kw));
1905 goto error;
1906 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001907 }
1908 /* we have not parsed the whole argument */
Radek Krejciefd22f62018-09-27 11:47:58 +02001909 if ((size_t)(ptr - word) != word_len) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001910 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, ly_stmt2str(val_kw));
Radek Krejci8b764662018-11-14 14:15:13 +01001911 goto error;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001912 }
1913 if (errno == ERANGE) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02001914 LOGVAL_YANG(ctx, LY_VCODE_OOB, word_len, word, ly_stmt2str(val_kw));
Radek Krejci8b764662018-11-14 14:15:13 +01001915 goto error;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001916 }
1917 if (val_kw == YANG_VALUE) {
1918 *value = num;
1919 } else {
1920 *value = unum;
1921 }
1922 free(buf);
1923
Radek Krejci6d6556c2018-11-08 09:37:45 +01001924 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001925 switch (kw) {
1926 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001927 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, val_kw == YANG_VALUE ? LYEXT_SUBSTMT_VALUE : LYEXT_SUBSTMT_POSITION, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001928 break;
1929 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02001930 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(val_kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001931 return LY_EVALID;
1932 }
1933 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001934 return ret;
Radek Krejci8b764662018-11-14 14:15:13 +01001935
1936error:
1937 free(buf);
1938 return LY_EVALID;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001939}
1940
Michal Vaskoea5abea2018-09-18 13:10:54 +02001941/**
1942 * @brief Parse the enum or bit statement. Substatement of type statement.
1943 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001944 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001945 * @param[in,out] data Data to read from, always moved to currently handled character.
1946 * @param[in] enum_kw Type of this particular keyword.
1947 * @param[in,out] enums Enums or bits to add to.
1948 *
1949 * @return LY_ERR values.
1950 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001951static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02001952parse_type_enum(struct lys_parser_ctx *ctx, const char **data, enum yang_keyword enum_kw, struct lysp_type_enum **enums)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001953{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001954 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001955 char *buf, *word;
Radek Krejci8b764662018-11-14 14:15:13 +01001956 size_t word_len, u;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001957 enum yang_keyword kw;
1958 struct lysp_type_enum *enm;
1959
Radek Krejci2c4e7172018-10-19 15:56:26 +02001960 LY_ARRAY_NEW_RET(ctx->ctx, *enums, enm, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001961
1962 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001963 LY_CHECK_RET(get_argument(ctx, data, enum_kw == YANG_ENUM ? Y_STR_ARG : Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci8b764662018-11-14 14:15:13 +01001964 if (enum_kw == YANG_ENUM) {
1965 if (!word_len) {
1966 LOGVAL_YANG(ctx, LYVE_SYNTAX_YANG, "Enum name must not be zero-length.");
1967 free(buf);
1968 return LY_EVALID;
1969 } else if (isspace(word[0]) || isspace(word[word_len - 1])) {
1970 LOGVAL_YANG(ctx, LYVE_SYNTAX_YANG, "Enum name must not have any leading or trailing whitespaces (\"%.*s\").",
1971 word_len, word);
1972 free(buf);
1973 return LY_EVALID;
1974 } else {
1975 for (u = 0; u < word_len; ++u) {
1976 if (iscntrl(word[u])) {
1977 LOGWRN(ctx->ctx, "Control characters in enum name should be avoided (\"%.*s\", character number %d).",
1978 word_len, word, u + 1);
1979 break;
1980 }
1981 }
1982 }
1983 } else { /* YANG_BIT */
1984
1985 }
Radek Krejci44ceedc2018-10-02 15:54:31 +02001986 INSERT_WORD(ctx, buf, enm->name, word, word_len);
Radek Krejci8b764662018-11-14 14:15:13 +01001987 CHECK_UNIQUENESS(ctx, *enums, name, ly_stmt2str(enum_kw), enm->name);
1988
Radek Krejci6d6556c2018-11-08 09:37:45 +01001989 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001990 switch (kw) {
1991 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001992 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &enm->dsc, Y_STR_ARG, &enm->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001993 break;
1994 case YANG_IF_FEATURE:
Radek Krejciceaf2122019-01-02 15:03:26 +01001995 YANG_CHECK_STMTVER2_RET(ctx, "if-feature", ly_stmt2str(enum_kw));
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001996 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &enm->iffeatures, Y_STR_ARG, &enm->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001997 break;
1998 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001999 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &enm->ref, Y_STR_ARG, &enm->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002000 break;
2001 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002002 LY_CHECK_RET(parse_status(ctx, data, &enm->flags, &enm->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002003 break;
2004 case YANG_VALUE:
2005 case YANG_POSITION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002006 LY_CHECK_RET(parse_type_enum_value_pos(ctx, data, kw, &enm->value, &enm->flags, &enm->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002007 break;
2008 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002009 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &enm->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002010 break;
2011 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02002012 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(enum_kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002013 return LY_EVALID;
2014 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002015 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002016 return ret;
2017}
2018
Michal Vaskoea5abea2018-09-18 13:10:54 +02002019/**
2020 * @brief Parse the fraction-digits statement. Substatement of type statement.
2021 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002022 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002023 * @param[in,out] data Data to read from, always moved to currently handled character.
2024 * @param[in,out] fracdig Value to write to.
2025 * @param[in,out] exts Extension instances to add to.
2026 *
2027 * @return LY_ERR values.
2028 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002029static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02002030parse_type_fracdigits(struct lys_parser_ctx *ctx, const char **data, uint8_t *fracdig, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002031{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002032 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002033 char *buf, *word, *ptr;
Radek Krejciefd22f62018-09-27 11:47:58 +02002034 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002035 unsigned long int num;
2036 enum yang_keyword kw;
2037
2038 if (*fracdig) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002039 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "fraction-digits");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002040 return LY_EVALID;
2041 }
2042
2043 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02002044 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002045
2046 if (!word_len || (word[0] == '0') || !isdigit(word[0])) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002047 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "fraction-digits");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002048 free(buf);
2049 return LY_EVALID;
2050 }
2051
2052 errno = 0;
2053 num = strtoul(word, &ptr, 10);
2054 /* we have not parsed the whole argument */
Radek Krejciefd22f62018-09-27 11:47:58 +02002055 if ((size_t)(ptr - word) != word_len) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002056 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "fraction-digits");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002057 free(buf);
2058 return LY_EVALID;
2059 }
2060 if ((errno == ERANGE) || (num > 18)) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002061 LOGVAL_YANG(ctx, LY_VCODE_OOB, word_len, word, "fraction-digits");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002062 free(buf);
2063 return LY_EVALID;
2064 }
2065 *fracdig = num;
2066 free(buf);
2067
Radek Krejci6d6556c2018-11-08 09:37:45 +01002068 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002069 switch (kw) {
2070 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002071 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_FRACDIGITS, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002072 break;
2073 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02002074 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "fraction-digits");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002075 return LY_EVALID;
2076 }
2077 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002078 return ret;
2079}
2080
Michal Vaskoea5abea2018-09-18 13:10:54 +02002081/**
2082 * @brief Parse the require-instance statement. Substatement of type statement.
2083 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002084 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002085 * @param[in,out] data Data to read from, always moved to currently handled character.
2086 * @param[in,out] reqinst Value to write to.
2087 * @param[in,out] flags Flags to write to.
2088 * @param[in,out] exts Extension instances to add to.
2089 *
2090 * @return LY_ERR values.
2091 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002092static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02002093parse_type_reqinstance(struct lys_parser_ctx *ctx, const char **data, uint8_t *reqinst, uint16_t *flags,
Michal Vasko7fbc8162018-09-17 10:35:16 +02002094 struct lysp_ext_instance **exts)
2095{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002096 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002097 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002098 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002099 enum yang_keyword kw;
2100
2101 if (*flags & LYS_SET_REQINST) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002102 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "require-instance");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002103 return LY_EVALID;
2104 }
2105 *flags |= LYS_SET_REQINST;
2106
2107 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02002108 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002109
2110 if ((word_len == 4) && !strncmp(word, "true", word_len)) {
2111 *reqinst = 1;
2112 } else if ((word_len != 5) || strncmp(word, "false", word_len)) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002113 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "require-instance");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002114 free(buf);
2115 return LY_EVALID;
2116 }
2117 free(buf);
2118
Radek Krejci6d6556c2018-11-08 09:37:45 +01002119 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002120 switch (kw) {
2121 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002122 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_REQINSTANCE, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002123 break;
2124 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02002125 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "require-instance");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002126 return LY_EVALID;
2127 }
2128 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002129 return ret;
2130}
2131
Michal Vaskoea5abea2018-09-18 13:10:54 +02002132/**
2133 * @brief Parse the modifier statement. Substatement of type pattern statement.
2134 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002135 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002136 * @param[in,out] data Data to read from, always moved to currently handled character.
2137 * @param[in,out] pat Value to write to.
2138 * @param[in,out] exts Extension instances to add to.
2139 *
2140 * @return LY_ERR values.
2141 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002142static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02002143parse_type_pattern_modifier(struct lys_parser_ctx *ctx, const char **data, const char **pat, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002144{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002145 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002146 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002147 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002148 enum yang_keyword kw;
2149
2150 if ((*pat)[0] == 0x15) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002151 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "modifier");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002152 return LY_EVALID;
2153 }
2154
2155 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02002156 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002157
2158 if ((word_len != 12) || strncmp(word, "invert-match", word_len)) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002159 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "modifier");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002160 free(buf);
2161 return LY_EVALID;
2162 }
2163 free(buf);
2164
2165 /* replace the value in the dictionary */
2166 buf = malloc(strlen(*pat) + 1);
Radek Krejci44ceedc2018-10-02 15:54:31 +02002167 LY_CHECK_ERR_RET(!buf, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002168 strcpy(buf, *pat);
Radek Krejci44ceedc2018-10-02 15:54:31 +02002169 lydict_remove(ctx->ctx, *pat);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002170
2171 assert(buf[0] == 0x06);
2172 buf[0] = 0x15;
Radek Krejci44ceedc2018-10-02 15:54:31 +02002173 *pat = lydict_insert_zc(ctx->ctx, buf);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002174
Radek Krejci6d6556c2018-11-08 09:37:45 +01002175 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002176 switch (kw) {
2177 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002178 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_MODIFIER, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002179 break;
2180 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02002181 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "modifier");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002182 return LY_EVALID;
2183 }
2184 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002185 return ret;
2186}
2187
Michal Vaskoea5abea2018-09-18 13:10:54 +02002188/**
2189 * @brief Parse the pattern statement. Substatement of type statement.
2190 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002191 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002192 * @param[in,out] data Data to read from, always moved to currently handled character.
2193 * @param[in,out] patterns Restrictions to add to.
2194 *
2195 * @return LY_ERR values.
2196 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002197static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02002198parse_type_pattern(struct lys_parser_ctx *ctx, const char **data, struct lysp_restr **patterns)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002199{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002200 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002201 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002202 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002203 enum yang_keyword kw;
2204 struct lysp_restr *restr;
2205
Radek Krejci2c4e7172018-10-19 15:56:26 +02002206 LY_ARRAY_NEW_RET(ctx->ctx, *patterns, restr, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002207
2208 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02002209 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002210
2211 /* add special meaning first byte */
2212 if (buf) {
2213 buf = realloc(buf, word_len + 2);
2214 word = buf;
2215 } else {
2216 buf = malloc(word_len + 2);
2217 }
Radek Krejci44ceedc2018-10-02 15:54:31 +02002218 LY_CHECK_ERR_RET(!buf, LOGMEM(ctx->ctx), LY_EMEM);
Radek Krejci86d106e2018-10-18 09:53:19 +02002219 memmove(buf + 1, word, word_len);
2220 buf[0] = 0x06; /* pattern's default regular-match flag */
2221 buf[word_len + 1] = '\0'; /* terminating NULL byte */
2222 restr->arg = lydict_insert_zc(ctx->ctx, buf);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002223
Radek Krejci6d6556c2018-11-08 09:37:45 +01002224 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002225 switch (kw) {
2226 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002227 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &restr->dsc, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002228 break;
2229 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002230 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &restr->ref, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002231 break;
2232 case YANG_ERROR_APP_TAG:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002233 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_ERRTAG, 0, &restr->eapptag, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002234 break;
2235 case YANG_ERROR_MESSAGE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002236 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_ERRMSG, 0, &restr->emsg, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002237 break;
2238 case YANG_MODIFIER:
Radek Krejciceaf2122019-01-02 15:03:26 +01002239 YANG_CHECK_STMTVER2_RET(ctx, "modifier", "pattern");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002240 LY_CHECK_RET(parse_type_pattern_modifier(ctx, data, &restr->arg, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002241 break;
2242 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002243 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002244 break;
2245 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02002246 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "pattern");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002247 return LY_EVALID;
2248 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002249 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002250 return ret;
2251}
2252
Michal Vaskoea5abea2018-09-18 13:10:54 +02002253/**
2254 * @brief Parse the type statement.
2255 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002256 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002257 * @param[in,out] data Data to read from, always moved to currently handled character.
2258 * @param[in,out] type Type to wrote to.
2259 *
2260 * @return LY_ERR values.
2261 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002262static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02002263parse_type(struct lys_parser_ctx *ctx, const char **data, struct lysp_type *type)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002264{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002265 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002266 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002267 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002268 enum yang_keyword kw;
2269 struct lysp_type *nest_type;
2270
2271 if (type->name) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002272 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "type");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002273 return LY_EVALID;
2274 }
2275
2276 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02002277 LY_CHECK_RET(get_argument(ctx, data, Y_PREF_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02002278 INSERT_WORD(ctx, buf, type->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002279
Radek Krejci6d6556c2018-11-08 09:37:45 +01002280 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002281 switch (kw) {
2282 case YANG_BASE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002283 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_BASE, &type->bases, Y_PREF_IDENTIF_ARG, &type->exts));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002284 type->flags |= LYS_SET_BASE;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002285 break;
2286 case YANG_BIT:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002287 LY_CHECK_RET(parse_type_enum(ctx, data, kw, &type->bits));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002288 type->flags |= LYS_SET_BIT;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002289 break;
2290 case YANG_ENUM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002291 LY_CHECK_RET(parse_type_enum(ctx, data, kw, &type->enums));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002292 type->flags |= LYS_SET_ENUM;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002293 break;
2294 case YANG_FRACTION_DIGITS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002295 LY_CHECK_RET(parse_type_fracdigits(ctx, data, &type->fraction_digits, &type->exts));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002296 type->flags |= LYS_SET_FRDIGITS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002297 break;
2298 case YANG_LENGTH:
2299 if (type->length) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002300 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002301 return LY_EVALID;
2302 }
2303 type->length = calloc(1, sizeof *type->length);
Radek Krejci44ceedc2018-10-02 15:54:31 +02002304 LY_CHECK_ERR_RET(!type->length, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002305
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002306 LY_CHECK_RET(parse_restr(ctx, data, kw, type->length));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002307 type->flags |= LYS_SET_LENGTH;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002308 break;
2309 case YANG_PATH:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002310 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_PATH, 0, &type->path, Y_STR_ARG, &type->exts));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002311 type->flags |= LYS_SET_PATH;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002312 break;
2313 case YANG_PATTERN:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002314 LY_CHECK_RET(parse_type_pattern(ctx, data, &type->patterns));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002315 type->flags |= LYS_SET_PATTERN;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002316 break;
2317 case YANG_RANGE:
2318 if (type->range) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002319 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002320 return LY_EVALID;
2321 }
2322 type->range = calloc(1, sizeof *type->range);
Radek Krejci44ceedc2018-10-02 15:54:31 +02002323 LY_CHECK_ERR_RET(!type->range, LOGMEM(ctx->ctx), LY_EVALID);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002324
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002325 LY_CHECK_RET(parse_restr(ctx, data, kw, type->range));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002326 type->flags |= LYS_SET_RANGE;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002327 break;
2328 case YANG_REQUIRE_INSTANCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002329 LY_CHECK_RET(parse_type_reqinstance(ctx, data, &type->require_instance, &type->flags, &type->exts));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002330 /* LYS_SET_REQINST checked and set inside parse_type_reqinstance() */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002331 break;
2332 case YANG_TYPE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002333 LY_ARRAY_NEW_RET(ctx->ctx, type->types, nest_type, LY_EMEM);
2334 LY_CHECK_RET(parse_type(ctx, data, nest_type));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002335 type->flags |= LYS_SET_TYPE;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002336 break;
2337 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002338 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &type->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002339 break;
2340 default:
Radek Krejci8b764662018-11-14 14:15:13 +01002341 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "type");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002342 return LY_EVALID;
2343 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002344 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002345 return ret;
2346}
2347
Michal Vaskoea5abea2018-09-18 13:10:54 +02002348/**
2349 * @brief Parse the leaf statement.
2350 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002351 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002352 * @param[in,out] data Data to read from, always moved to currently handled character.
2353 * @param[in,out] siblings Siblings to add to.
2354 *
2355 * @return LY_ERR values.
2356 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02002357LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02002358parse_leaf(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002359{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002360 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002361 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002362 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002363 enum yang_keyword kw;
2364 struct lysp_node *iter;
2365 struct lysp_node_leaf *leaf;
2366
2367 /* create structure */
2368 leaf = calloc(1, sizeof *leaf);
Radek Krejci44ceedc2018-10-02 15:54:31 +02002369 LY_CHECK_ERR_RET(!leaf, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002370 leaf->nodetype = LYS_LEAF;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002371 leaf->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002372
2373 /* insert into siblings */
2374 if (!*siblings) {
2375 *siblings = (struct lysp_node *)leaf;
2376 } else {
2377 for (iter = *siblings; iter->next; iter = iter->next);
2378 iter->next = (struct lysp_node *)leaf;
2379 }
2380
2381 /* get name */
Radek Krejcid3ca0632019-04-16 16:54:54 +02002382 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02002383 INSERT_WORD(ctx, buf, leaf->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002384
2385 /* parse substatements */
Radek Krejci6d6556c2018-11-08 09:37:45 +01002386 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret, goto checks) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002387 switch (kw) {
2388 case YANG_CONFIG:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002389 LY_CHECK_RET(parse_config(ctx, data, &leaf->flags, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002390 break;
2391 case YANG_DEFAULT:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002392 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DEFAULT, 0, &leaf->dflt, Y_STR_ARG, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002393 break;
2394 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002395 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &leaf->dsc, Y_STR_ARG, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002396 break;
2397 case YANG_IF_FEATURE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002398 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &leaf->iffeatures, Y_STR_ARG, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002399 break;
2400 case YANG_MANDATORY:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002401 LY_CHECK_RET(parse_mandatory(ctx, data, &leaf->flags, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002402 break;
2403 case YANG_MUST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002404 LY_CHECK_RET(parse_restrs(ctx, data, kw, &leaf->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002405 break;
2406 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002407 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &leaf->ref, Y_STR_ARG, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002408 break;
2409 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002410 LY_CHECK_RET(parse_status(ctx, data, &leaf->flags, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002411 break;
2412 case YANG_TYPE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002413 LY_CHECK_RET(parse_type(ctx, data, &leaf->type));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002414 break;
2415 case YANG_UNITS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002416 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_UNITS, 0, &leaf->units, Y_STR_ARG, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002417 break;
2418 case YANG_WHEN:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002419 LY_CHECK_RET(parse_when(ctx, data, &leaf->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002420 break;
2421 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002422 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002423 break;
2424 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02002425 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "leaf");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002426 return LY_EVALID;
2427 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002428 }
Radek Krejcic59bc972018-09-17 16:13:06 +02002429 LY_CHECK_RET(ret);
Radek Krejci6d6556c2018-11-08 09:37:45 +01002430checks:
Michal Vasko7fbc8162018-09-17 10:35:16 +02002431 /* mandatory substatements */
2432 if (!leaf->type.name) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002433 LOGVAL_YANG(ctx, LY_VCODE_MISSTMT, "type", "leaf");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002434 return LY_EVALID;
2435 }
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01002436 if ((leaf->flags & LYS_MAND_TRUE) && (leaf->dflt)) {
2437 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMSCOMB, "mandatory", "default", "leaf");
2438 return LY_EVALID;
2439 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002440
2441 return ret;
2442}
2443
Michal Vaskoea5abea2018-09-18 13:10:54 +02002444/**
2445 * @brief Parse the max-elements statement.
2446 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002447 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002448 * @param[in,out] data Data to read from, always moved to currently handled character.
2449 * @param[in,out] max Value to write to.
2450 * @param[in,out] flags Flags to write to.
2451 * @param[in,out] exts Extension instances to add to.
2452 *
2453 * @return LY_ERR values.
2454 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02002455LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02002456parse_maxelements(struct lys_parser_ctx *ctx, const char **data, uint32_t *max, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002457{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002458 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002459 char *buf, *word, *ptr;
Radek Krejciefd22f62018-09-27 11:47:58 +02002460 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002461 unsigned long int num;
2462 enum yang_keyword kw;
2463
2464 if (*flags & LYS_SET_MAX) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002465 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "max-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002466 return LY_EVALID;
2467 }
2468 *flags |= LYS_SET_MAX;
2469
2470 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02002471 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002472
2473 if (!word_len || (word[0] == '0') || ((word[0] != 'u') && !isdigit(word[0]))) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002474 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "max-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002475 free(buf);
2476 return LY_EVALID;
2477 }
2478
2479 if (strncmp(word, "unbounded", word_len)) {
2480 errno = 0;
2481 num = strtoul(word, &ptr, 10);
2482 /* we have not parsed the whole argument */
Radek Krejciefd22f62018-09-27 11:47:58 +02002483 if ((size_t)(ptr - word) != word_len) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002484 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "max-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002485 free(buf);
2486 return LY_EVALID;
2487 }
2488 if ((errno == ERANGE) || (num > UINT32_MAX)) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002489 LOGVAL_YANG(ctx, LY_VCODE_OOB, word_len, word, "max-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002490 free(buf);
2491 return LY_EVALID;
2492 }
2493
2494 *max = num;
2495 }
2496 free(buf);
2497
Radek Krejci6d6556c2018-11-08 09:37:45 +01002498 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002499 switch (kw) {
2500 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002501 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_MAX, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002502 break;
2503 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02002504 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "max-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002505 return LY_EVALID;
2506 }
2507 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002508 return ret;
2509}
2510
Michal Vaskoea5abea2018-09-18 13:10:54 +02002511/**
2512 * @brief Parse the min-elements statement.
2513 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002514 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002515 * @param[in,out] data Data to read from, always moved to currently handled character.
2516 * @param[in,out] min Value to write to.
2517 * @param[in,out] flags Flags to write to.
2518 * @param[in,out] exts Extension instances to add to.
2519 *
2520 * @return LY_ERR values.
2521 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02002522LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02002523parse_minelements(struct lys_parser_ctx *ctx, const char **data, uint32_t *min, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002524{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002525 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002526 char *buf, *word, *ptr;
Radek Krejciefd22f62018-09-27 11:47:58 +02002527 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002528 unsigned long int num;
2529 enum yang_keyword kw;
2530
2531 if (*flags & LYS_SET_MIN) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002532 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "min-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002533 return LY_EVALID;
2534 }
2535 *flags |= LYS_SET_MIN;
2536
2537 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02002538 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002539
2540 if (!word_len || !isdigit(word[0]) || ((word[0] == '0') && (word_len > 1))) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002541 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "min-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002542 free(buf);
2543 return LY_EVALID;
2544 }
2545
2546 errno = 0;
2547 num = strtoul(word, &ptr, 10);
2548 /* we have not parsed the whole argument */
Radek Krejciefd22f62018-09-27 11:47:58 +02002549 if ((size_t)(ptr - word) != word_len) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002550 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "min-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002551 free(buf);
2552 return LY_EVALID;
2553 }
2554 if ((errno == ERANGE) || (num > UINT32_MAX)) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002555 LOGVAL_YANG(ctx, LY_VCODE_OOB, word_len, word, "min-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002556 free(buf);
2557 return LY_EVALID;
2558 }
2559 *min = num;
2560 free(buf);
2561
Radek Krejci6d6556c2018-11-08 09:37:45 +01002562 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002563 switch (kw) {
2564 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002565 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_MIN, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002566 break;
2567 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02002568 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "min-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002569 return LY_EVALID;
2570 }
2571 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002572 return ret;
2573}
2574
Michal Vaskoea5abea2018-09-18 13:10:54 +02002575/**
2576 * @brief Parse the ordered-by statement.
2577 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002578 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002579 * @param[in,out] data Data to read from, always moved to currently handled character.
2580 * @param[in,out] flags Flags to write to.
2581 * @param[in,out] exts Extension instances to add to.
2582 *
2583 * @return LY_ERR values.
2584 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002585static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02002586parse_orderedby(struct lys_parser_ctx *ctx, const char **data, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002587{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002588 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002589 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002590 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002591 enum yang_keyword kw;
2592
2593 if (*flags & LYS_ORDBY_MASK) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002594 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "ordered-by");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002595 return LY_EVALID;
2596 }
2597
2598 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02002599 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002600
2601 if ((word_len == 6) && !strncmp(word, "system", word_len)) {
2602 *flags |= LYS_ORDBY_SYSTEM;
2603 } else if ((word_len == 4) && !strncmp(word, "user", word_len)) {
2604 *flags |= LYS_ORDBY_USER;
2605 } else {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002606 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "ordered-by");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002607 free(buf);
2608 return LY_EVALID;
2609 }
2610 free(buf);
2611
Radek Krejci6d6556c2018-11-08 09:37:45 +01002612 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002613 switch (kw) {
2614 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002615 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_ORDEREDBY, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002616 break;
2617 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02002618 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "ordered-by");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002619 return LY_EVALID;
2620 }
2621 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002622 return ret;
2623}
2624
Michal Vaskoea5abea2018-09-18 13:10:54 +02002625/**
2626 * @brief Parse the leaf-list statement.
2627 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002628 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002629 * @param[in,out] data Data to read from, always moved to currently handled character.
2630 * @param[in,out] siblings Siblings to add to.
2631 *
2632 * @return LY_ERR values.
2633 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02002634LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02002635parse_leaflist(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002636{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002637 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002638 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002639 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002640 enum yang_keyword kw;
2641 struct lysp_node *iter;
2642 struct lysp_node_leaflist *llist;
2643
2644 /* create structure */
2645 llist = calloc(1, sizeof *llist);
Radek Krejci44ceedc2018-10-02 15:54:31 +02002646 LY_CHECK_ERR_RET(!llist, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002647 llist->nodetype = LYS_LEAFLIST;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002648 llist->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002649
2650 /* insert into siblings */
2651 if (!*siblings) {
2652 *siblings = (struct lysp_node *)llist;
2653 } else {
2654 for (iter = *siblings; iter->next; iter = iter->next);
2655 iter->next = (struct lysp_node *)llist;
2656 }
2657
2658 /* get name */
Radek Krejcid3ca0632019-04-16 16:54:54 +02002659 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02002660 INSERT_WORD(ctx, buf, llist->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002661
2662 /* parse substatements */
Radek Krejci6d6556c2018-11-08 09:37:45 +01002663 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret, goto checks) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002664 switch (kw) {
2665 case YANG_CONFIG:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002666 LY_CHECK_RET(parse_config(ctx, data, &llist->flags, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002667 break;
2668 case YANG_DEFAULT:
Radek Krejciceaf2122019-01-02 15:03:26 +01002669 YANG_CHECK_STMTVER2_RET(ctx, "default", "leaf-list");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002670 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_DEFAULT, &llist->dflts, Y_STR_ARG, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002671 break;
2672 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002673 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &llist->dsc, Y_STR_ARG, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002674 break;
2675 case YANG_IF_FEATURE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002676 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &llist->iffeatures, Y_STR_ARG, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002677 break;
2678 case YANG_MAX_ELEMENTS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002679 LY_CHECK_RET(parse_maxelements(ctx, data, &llist->max, &llist->flags, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002680 break;
2681 case YANG_MIN_ELEMENTS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002682 LY_CHECK_RET(parse_minelements(ctx, data, &llist->min, &llist->flags, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002683 break;
2684 case YANG_MUST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002685 LY_CHECK_RET(parse_restrs(ctx, data, kw, &llist->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002686 break;
2687 case YANG_ORDERED_BY:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002688 LY_CHECK_RET(parse_orderedby(ctx, data, &llist->flags, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002689 break;
2690 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002691 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &llist->ref, Y_STR_ARG, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002692 break;
2693 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002694 LY_CHECK_RET(parse_status(ctx, data, &llist->flags, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002695 break;
2696 case YANG_TYPE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002697 LY_CHECK_RET(parse_type(ctx, data, &llist->type));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002698 break;
2699 case YANG_UNITS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002700 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_UNITS, 0, &llist->units, Y_STR_ARG, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002701 break;
2702 case YANG_WHEN:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002703 LY_CHECK_RET(parse_when(ctx, data, &llist->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002704 break;
2705 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002706 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002707 break;
2708 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02002709 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "llist");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002710 return LY_EVALID;
2711 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002712 }
Radek Krejcic59bc972018-09-17 16:13:06 +02002713 LY_CHECK_RET(ret);
Radek Krejci6d6556c2018-11-08 09:37:45 +01002714checks:
Michal Vasko7fbc8162018-09-17 10:35:16 +02002715 /* mandatory substatements */
2716 if (!llist->type.name) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002717 LOGVAL_YANG(ctx, LY_VCODE_MISSTMT, "type", "leaf-list");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002718 return LY_EVALID;
2719 }
Radek Krejci0e5d8382018-11-28 16:37:53 +01002720 if ((llist->min) && (llist->dflts)) {
2721 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMSCOMB, "min-elements", "default", "leaf-list");
2722 return LY_EVALID;
2723 }
Radek Krejcidf6cad12018-11-28 17:10:55 +01002724 if (llist->max && llist->min > llist->max) {
2725 LOGVAL_YANG(ctx, LYVE_SEMANTICS,
2726 "Invalid combination of min-elements and max-elements: min value %u is bigger than the max value %u.",
2727 llist->min, llist->max);
2728 return LY_EVALID;
2729 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002730
2731 return ret;
2732}
2733
Michal Vaskoea5abea2018-09-18 13:10:54 +02002734/**
2735 * @brief Parse the refine statement.
2736 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002737 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002738 * @param[in,out] data Data to read from, always moved to currently handled character.
2739 * @param[in,out] refines Refines to add to.
2740 *
2741 * @return LY_ERR values.
2742 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002743static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02002744parse_refine(struct lys_parser_ctx *ctx, const char **data, struct lysp_refine **refines)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002745{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002746 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002747 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002748 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002749 enum yang_keyword kw;
2750 struct lysp_refine *rf;
2751
Radek Krejci2c4e7172018-10-19 15:56:26 +02002752 LY_ARRAY_NEW_RET(ctx->ctx, *refines, rf, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002753
2754 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02002755 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02002756 INSERT_WORD(ctx, buf, rf->nodeid, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002757
Radek Krejci6d6556c2018-11-08 09:37:45 +01002758 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002759 switch (kw) {
2760 case YANG_CONFIG:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002761 LY_CHECK_RET(parse_config(ctx, data, &rf->flags, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002762 break;
2763 case YANG_DEFAULT:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002764 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_DEFAULT, &rf->dflts, Y_STR_ARG, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002765 break;
2766 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002767 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &rf->dsc, Y_STR_ARG, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002768 break;
2769 case YANG_IF_FEATURE:
Radek Krejciceaf2122019-01-02 15:03:26 +01002770 YANG_CHECK_STMTVER2_RET(ctx, "if-feature", "refine");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002771 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &rf->iffeatures, Y_STR_ARG, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002772 break;
2773 case YANG_MAX_ELEMENTS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002774 LY_CHECK_RET(parse_maxelements(ctx, data, &rf->max, &rf->flags, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002775 break;
2776 case YANG_MIN_ELEMENTS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002777 LY_CHECK_RET(parse_minelements(ctx, data, &rf->min, &rf->flags, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002778 break;
2779 case YANG_MUST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002780 LY_CHECK_RET(parse_restrs(ctx, data, kw, &rf->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002781 break;
2782 case YANG_MANDATORY:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002783 LY_CHECK_RET(parse_mandatory(ctx, data, &rf->flags, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002784 break;
2785 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002786 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &rf->ref, Y_STR_ARG, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002787 break;
2788 case YANG_PRESENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002789 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_PRESENCE, 0, &rf->presence, Y_STR_ARG, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002790 break;
2791 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002792 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002793 break;
2794 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02002795 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "refine");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002796 return LY_EVALID;
2797 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002798 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002799 return ret;
2800}
2801
Michal Vaskoea5abea2018-09-18 13:10:54 +02002802/**
2803 * @brief Parse the typedef statement.
2804 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002805 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002806 * @param[in,out] data Data to read from, always moved to currently handled character.
2807 * @param[in,out] typedefs Typedefs to add to.
2808 *
2809 * @return LY_ERR values.
2810 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002811static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02002812parse_typedef(struct lys_parser_ctx *ctx, struct lysp_node *parent, const char **data, struct lysp_tpdf **typedefs)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002813{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002814 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002815 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002816 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002817 enum yang_keyword kw;
2818 struct lysp_tpdf *tpdf;
2819
Radek Krejci2c4e7172018-10-19 15:56:26 +02002820 LY_ARRAY_NEW_RET(ctx->ctx, *typedefs, tpdf, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002821
2822 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02002823 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02002824 INSERT_WORD(ctx, buf, tpdf->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002825
2826 /* parse substatements */
Radek Krejci6d6556c2018-11-08 09:37:45 +01002827 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret, goto checks) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002828 switch (kw) {
2829 case YANG_DEFAULT:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002830 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DEFAULT, 0, &tpdf->dflt, Y_STR_ARG, &tpdf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002831 break;
2832 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002833 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &tpdf->dsc, Y_STR_ARG, &tpdf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002834 break;
2835 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002836 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &tpdf->ref, Y_STR_ARG, &tpdf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002837 break;
2838 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002839 LY_CHECK_RET(parse_status(ctx, data, &tpdf->flags, &tpdf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002840 break;
2841 case YANG_TYPE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002842 LY_CHECK_RET(parse_type(ctx, data, &tpdf->type));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002843 break;
2844 case YANG_UNITS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002845 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_UNITS, 0, &tpdf->units, Y_STR_ARG, &tpdf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002846 break;
2847 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002848 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &tpdf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002849 break;
2850 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02002851 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "typedef");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002852 return LY_EVALID;
2853 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002854 }
Radek Krejcic59bc972018-09-17 16:13:06 +02002855 LY_CHECK_RET(ret);
Radek Krejcibbe09a92018-11-08 09:36:54 +01002856checks:
Michal Vasko7fbc8162018-09-17 10:35:16 +02002857 /* mandatory substatements */
2858 if (!tpdf->type.name) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02002859 LOGVAL_YANG(ctx, LY_VCODE_MISSTMT, "type", "typedef");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002860 return LY_EVALID;
2861 }
2862
Radek Krejcibbe09a92018-11-08 09:36:54 +01002863 /* store data for collision check */
2864 if (parent) {
2865 ly_set_add(&ctx->tpdfs_nodes, parent, 0);
2866 }
2867
Michal Vasko7fbc8162018-09-17 10:35:16 +02002868 return ret;
2869}
2870
Michal Vaskoea5abea2018-09-18 13:10:54 +02002871/**
2872 * @brief Parse the input or output statement.
2873 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002874 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002875 * @param[in,out] data Data to read from, always moved to currently handled character.
2876 * @param[in] kw Type of this particular keyword
2877 * @param[in,out] inout_p Input/output pointer to write to.
2878 *
2879 * @return LY_ERR values.
2880 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002881static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02002882parse_inout(struct lys_parser_ctx *ctx, const char **data, enum yang_keyword inout_kw, struct lysp_node *parent, struct lysp_action_inout *inout_p)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002883{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002884 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002885 char *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002886 size_t word_len;
Radek Krejci10113652018-11-14 16:56:50 +01002887 enum yang_keyword kw;
Radek Krejcie86bf772018-12-14 11:39:53 +01002888 unsigned int u;
2889 struct lysp_node *child;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002890
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002891 if (inout_p->nodetype) {
Radek Krejci10113652018-11-14 16:56:50 +01002892 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, ly_stmt2str(inout_kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002893 return LY_EVALID;
2894 }
2895
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002896 /* initiate structure */
Radek Krejcid3ca0632019-04-16 16:54:54 +02002897 inout_p->nodetype = &((struct lysp_action*)parent)->input == inout_p ? LYS_INPUT : LYS_OUTPUT;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002898 inout_p->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002899
2900 /* parse substatements */
Radek Krejci6d6556c2018-11-08 09:37:45 +01002901 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002902 switch (kw) {
2903 case YANG_ANYDATA:
Radek Krejciceaf2122019-01-02 15:03:26 +01002904 YANG_CHECK_STMTVER2_RET(ctx, "anydata", ly_stmt2str(inout_kw));
Radek Krejci10113652018-11-14 16:56:50 +01002905 /* fall through */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002906 case YANG_ANYXML:
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002907 LY_CHECK_RET(parse_any(ctx, data, kw, (struct lysp_node*)inout_p, &inout_p->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002908 break;
2909 case YANG_CHOICE:
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002910 LY_CHECK_RET(parse_choice(ctx, data, (struct lysp_node*)inout_p, &inout_p->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002911 break;
2912 case YANG_CONTAINER:
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002913 LY_CHECK_RET(parse_container(ctx, data, (struct lysp_node*)inout_p, &inout_p->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002914 break;
2915 case YANG_LEAF:
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002916 LY_CHECK_RET(parse_leaf(ctx, data, (struct lysp_node*)inout_p, &inout_p->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002917 break;
2918 case YANG_LEAF_LIST:
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002919 LY_CHECK_RET(parse_leaflist(ctx, data, (struct lysp_node*)inout_p, &inout_p->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002920 break;
2921 case YANG_LIST:
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002922 LY_CHECK_RET(parse_list(ctx, data, (struct lysp_node*)inout_p, &inout_p->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002923 break;
2924 case YANG_USES:
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002925 LY_CHECK_RET(parse_uses(ctx, data, (struct lysp_node*)inout_p, &inout_p->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002926 break;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002927 case YANG_TYPEDEF:
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002928 LY_CHECK_RET(parse_typedef(ctx, (struct lysp_node*)inout_p, data, &inout_p->typedefs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002929 break;
2930 case YANG_MUST:
Radek Krejciceaf2122019-01-02 15:03:26 +01002931 YANG_CHECK_STMTVER2_RET(ctx, "must", ly_stmt2str(inout_kw));
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002932 LY_CHECK_RET(parse_restrs(ctx, data, kw, &inout_p->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002933 break;
2934 case YANG_GROUPING:
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002935 LY_CHECK_RET(parse_grouping(ctx, data, (struct lysp_node*)inout_p, &inout_p->groupings));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002936 break;
2937 case YANG_CUSTOM:
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002938 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &inout_p->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002939 break;
2940 default:
Radek Krejci10113652018-11-14 16:56:50 +01002941 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(inout_kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002942 return LY_EVALID;
2943 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002944 }
Radek Krejcie86bf772018-12-14 11:39:53 +01002945 /* finalize parent pointers to the reallocated items */
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002946 LY_ARRAY_FOR(inout_p->groupings, u) {
2947 LY_LIST_FOR(inout_p->groupings[u].data, child) {
2948 child->parent = (struct lysp_node*)&inout_p->groupings[u];
Radek Krejcie86bf772018-12-14 11:39:53 +01002949 }
2950 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002951 return ret;
2952}
2953
Michal Vaskoea5abea2018-09-18 13:10:54 +02002954/**
2955 * @brief Parse the action statement.
2956 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002957 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002958 * @param[in,out] data Data to read from, always moved to currently handled character.
2959 * @param[in,out] actions Actions to add to.
2960 *
2961 * @return LY_ERR values.
2962 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02002963LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02002964parse_action(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_action **actions)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002965{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002966 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002967 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002968 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002969 enum yang_keyword kw;
2970 struct lysp_action *act;
Radek Krejcie86bf772018-12-14 11:39:53 +01002971 struct lysp_node *child;
2972 unsigned int u;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002973
Radek Krejci2c4e7172018-10-19 15:56:26 +02002974 LY_ARRAY_NEW_RET(ctx->ctx, *actions, act, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002975
2976 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02002977 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02002978 INSERT_WORD(ctx, buf, act->name, word, word_len);
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002979 act->nodetype = LYS_ACTION;
2980 act->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002981
Radek Krejci6d6556c2018-11-08 09:37:45 +01002982 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002983 switch (kw) {
2984 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002985 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &act->dsc, Y_STR_ARG, &act->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002986 break;
2987 case YANG_IF_FEATURE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002988 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &act->iffeatures, Y_STR_ARG, &act->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002989 break;
2990 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002991 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &act->ref, Y_STR_ARG, &act->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002992 break;
2993 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002994 LY_CHECK_RET(parse_status(ctx, data, &act->flags, &act->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002995 break;
2996
2997 case YANG_INPUT:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002998 LY_CHECK_RET(parse_inout(ctx, data, kw, (struct lysp_node*)act, &act->input));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002999 break;
3000 case YANG_OUTPUT:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003001 LY_CHECK_RET(parse_inout(ctx, data, kw, (struct lysp_node*)act, &act->output));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003002 break;
3003
3004 case YANG_TYPEDEF:
Radek Krejcibbe09a92018-11-08 09:36:54 +01003005 LY_CHECK_RET(parse_typedef(ctx, (struct lysp_node*)act, data, &act->typedefs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003006 break;
3007 case YANG_GROUPING:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003008 LY_CHECK_RET(parse_grouping(ctx, data, (struct lysp_node*)act, &act->groupings));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003009 break;
3010 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003011 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &act->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003012 break;
3013 default:
Radek Krejcif538ce52019-03-05 10:46:14 +01003014 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), parent ? "action" : "rpc");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003015 return LY_EVALID;
3016 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003017 }
Radek Krejcie86bf772018-12-14 11:39:53 +01003018 /* finalize parent pointers to the reallocated items */
3019 LY_ARRAY_FOR(act->groupings, u) {
3020 LY_LIST_FOR(act->groupings[u].data, child) {
3021 child->parent = (struct lysp_node*)&act->groupings[u];
3022 }
3023 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003024 return ret;
3025}
3026
Michal Vaskoea5abea2018-09-18 13:10:54 +02003027/**
3028 * @brief Parse the notification statement.
3029 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003030 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003031 * @param[in,out] data Data to read from, always moved to currently handled character.
3032 * @param[in,out] notifs Notifications to add to.
3033 *
3034 * @return LY_ERR values.
3035 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003036LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02003037parse_notif(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_notif **notifs)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003038{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003039 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003040 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003041 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003042 enum yang_keyword kw;
3043 struct lysp_notif *notif;
Radek Krejcie86bf772018-12-14 11:39:53 +01003044 struct lysp_node *child;
3045 unsigned int u;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003046
Radek Krejci2c4e7172018-10-19 15:56:26 +02003047 LY_ARRAY_NEW_RET(ctx->ctx, *notifs, notif, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003048
3049 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02003050 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02003051 INSERT_WORD(ctx, buf, notif->name, word, word_len);
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003052 notif->nodetype = LYS_NOTIF;
3053 notif->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003054
Radek Krejci6d6556c2018-11-08 09:37:45 +01003055 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003056 switch (kw) {
3057 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003058 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &notif->dsc, Y_STR_ARG, &notif->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003059 break;
3060 case YANG_IF_FEATURE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003061 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &notif->iffeatures, Y_STR_ARG, &notif->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003062 break;
3063 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003064 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &notif->ref, Y_STR_ARG, &notif->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003065 break;
3066 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003067 LY_CHECK_RET(parse_status(ctx, data, &notif->flags, &notif->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003068 break;
3069
3070 case YANG_ANYDATA:
Radek Krejciceaf2122019-01-02 15:03:26 +01003071 YANG_CHECK_STMTVER2_RET(ctx, "anydata", "notification");
Radek Krejci10113652018-11-14 16:56:50 +01003072 /* fall through */
Michal Vasko7fbc8162018-09-17 10:35:16 +02003073 case YANG_ANYXML:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003074 LY_CHECK_RET(parse_any(ctx, data, kw, (struct lysp_node*)notif, &notif->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003075 break;
3076 case YANG_CHOICE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003077 LY_CHECK_RET(parse_case(ctx, data, (struct lysp_node*)notif, &notif->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003078 break;
3079 case YANG_CONTAINER:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003080 LY_CHECK_RET(parse_container(ctx, data, (struct lysp_node*)notif, &notif->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003081 break;
3082 case YANG_LEAF:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003083 LY_CHECK_RET(parse_leaf(ctx, data, (struct lysp_node*)notif, &notif->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003084 break;
3085 case YANG_LEAF_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003086 LY_CHECK_RET(parse_leaflist(ctx, data, (struct lysp_node*)notif, &notif->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003087 break;
3088 case YANG_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003089 LY_CHECK_RET(parse_list(ctx, data, (struct lysp_node*)notif, &notif->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003090 break;
3091 case YANG_USES:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003092 LY_CHECK_RET(parse_uses(ctx, data, (struct lysp_node*)notif, &notif->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003093 break;
3094
3095 case YANG_MUST:
Radek Krejciceaf2122019-01-02 15:03:26 +01003096 YANG_CHECK_STMTVER2_RET(ctx, "must", "notification");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003097 LY_CHECK_RET(parse_restrs(ctx, data, kw, &notif->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003098 break;
3099 case YANG_TYPEDEF:
Radek Krejcibbe09a92018-11-08 09:36:54 +01003100 LY_CHECK_RET(parse_typedef(ctx, (struct lysp_node*)notif, data, &notif->typedefs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003101 break;
3102 case YANG_GROUPING:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003103 LY_CHECK_RET(parse_grouping(ctx, data, (struct lysp_node*)notif, &notif->groupings));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003104 break;
3105 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003106 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &notif->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003107 break;
3108 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02003109 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "notification");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003110 return LY_EVALID;
3111 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003112 }
Radek Krejcie86bf772018-12-14 11:39:53 +01003113 /* finalize parent pointers to the reallocated items */
3114 LY_ARRAY_FOR(notif->groupings, u) {
3115 LY_LIST_FOR(notif->groupings[u].data, child) {
3116 child->parent = (struct lysp_node*)&notif->groupings[u];
3117 }
3118 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003119 return ret;
3120}
3121
Michal Vaskoea5abea2018-09-18 13:10:54 +02003122/**
3123 * @brief Parse the grouping statement.
3124 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003125 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003126 * @param[in,out] data Data to read from, always moved to currently handled character.
3127 * @param[in,out] groupings Groupings to add to.
3128 *
3129 * @return LY_ERR values.
3130 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003131LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02003132parse_grouping(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_grp **groupings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003133{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003134 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003135 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003136 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003137 enum yang_keyword kw;
3138 struct lysp_grp *grp;
Radek Krejcie86bf772018-12-14 11:39:53 +01003139 struct lysp_node *child;
3140 unsigned int u;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003141
Radek Krejci2c4e7172018-10-19 15:56:26 +02003142 LY_ARRAY_NEW_RET(ctx->ctx, *groupings, grp, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003143
3144 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02003145 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02003146 INSERT_WORD(ctx, buf, grp->name, word, word_len);
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003147 grp->nodetype = LYS_GROUPING;
3148 grp->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003149
Radek Krejci6d6556c2018-11-08 09:37:45 +01003150 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003151 switch (kw) {
3152 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003153 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &grp->dsc, Y_STR_ARG, &grp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003154 break;
3155 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003156 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &grp->ref, Y_STR_ARG, &grp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003157 break;
3158 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003159 LY_CHECK_RET(parse_status(ctx, data, &grp->flags, &grp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003160 break;
3161
3162 case YANG_ANYDATA:
Radek Krejciceaf2122019-01-02 15:03:26 +01003163 YANG_CHECK_STMTVER2_RET(ctx, "anydata", "grouping");
Radek Krejci10113652018-11-14 16:56:50 +01003164 /* fall through */
Michal Vasko7fbc8162018-09-17 10:35:16 +02003165 case YANG_ANYXML:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003166 LY_CHECK_RET(parse_any(ctx, data, kw, (struct lysp_node*)grp, &grp->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003167 break;
3168 case YANG_CHOICE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003169 LY_CHECK_RET(parse_choice(ctx, data, (struct lysp_node*)grp, &grp->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003170 break;
3171 case YANG_CONTAINER:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003172 LY_CHECK_RET(parse_container(ctx, data, (struct lysp_node*)grp, &grp->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003173 break;
3174 case YANG_LEAF:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003175 LY_CHECK_RET(parse_leaf(ctx, data, (struct lysp_node*)grp, &grp->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003176 break;
3177 case YANG_LEAF_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003178 LY_CHECK_RET(parse_leaflist(ctx, data, (struct lysp_node*)grp, &grp->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003179 break;
3180 case YANG_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003181 LY_CHECK_RET(parse_list(ctx, data, (struct lysp_node*)grp, &grp->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003182 break;
3183 case YANG_USES:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003184 LY_CHECK_RET(parse_uses(ctx, data, (struct lysp_node*)grp, &grp->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003185 break;
3186
3187 case YANG_TYPEDEF:
Radek Krejcibbe09a92018-11-08 09:36:54 +01003188 LY_CHECK_RET(parse_typedef(ctx, (struct lysp_node*)grp, data, &grp->typedefs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003189 break;
3190 case YANG_ACTION:
Radek Krejciceaf2122019-01-02 15:03:26 +01003191 YANG_CHECK_STMTVER2_RET(ctx, "action", "grouping");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003192 LY_CHECK_RET(parse_action(ctx, data, (struct lysp_node*)grp, &grp->actions));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003193 break;
3194 case YANG_GROUPING:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003195 LY_CHECK_RET(parse_grouping(ctx, data, (struct lysp_node*)grp, &grp->groupings));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003196 break;
3197 case YANG_NOTIFICATION:
Radek Krejciceaf2122019-01-02 15:03:26 +01003198 YANG_CHECK_STMTVER2_RET(ctx, "notification", "grouping");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003199 LY_CHECK_RET(parse_notif(ctx, data, (struct lysp_node*)grp, &grp->notifs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003200 break;
3201 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003202 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &grp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003203 break;
3204 default:
Radek Krejci10113652018-11-14 16:56:50 +01003205 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "grouping");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003206 return LY_EVALID;
3207 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003208 }
Radek Krejcie86bf772018-12-14 11:39:53 +01003209 /* finalize parent pointers to the reallocated items */
3210 LY_ARRAY_FOR(grp->groupings, u) {
3211 LY_LIST_FOR(grp->groupings[u].data, child) {
3212 child->parent = (struct lysp_node*)&grp->groupings[u];
3213 }
3214 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003215 return ret;
3216}
3217
Michal Vaskoea5abea2018-09-18 13:10:54 +02003218/**
3219 * @brief Parse the refine statement.
3220 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003221 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003222 * @param[in,out] data Data to read from, always moved to currently handled character.
3223 * @param[in,out] augments Augments to add to.
3224 *
3225 * @return LY_ERR values.
3226 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003227LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02003228parse_augment(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_augment **augments)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003229{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003230 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003231 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003232 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003233 enum yang_keyword kw;
3234 struct lysp_augment *aug;
3235
Radek Krejci2c4e7172018-10-19 15:56:26 +02003236 LY_ARRAY_NEW_RET(ctx->ctx, *augments, aug, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003237
3238 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02003239 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02003240 INSERT_WORD(ctx, buf, aug->nodeid, word, word_len);
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003241 aug->nodetype = LYS_AUGMENT;
3242 aug->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003243
Radek Krejci6d6556c2018-11-08 09:37:45 +01003244 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003245 switch (kw) {
3246 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003247 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &aug->dsc, Y_STR_ARG, &aug->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003248 break;
3249 case YANG_IF_FEATURE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003250 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &aug->iffeatures, Y_STR_ARG, &aug->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003251 break;
3252 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003253 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &aug->ref, Y_STR_ARG, &aug->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003254 break;
3255 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003256 LY_CHECK_RET(parse_status(ctx, data, &aug->flags, &aug->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003257 break;
3258 case YANG_WHEN:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003259 LY_CHECK_RET(parse_when(ctx, data, &aug->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003260 break;
3261
3262 case YANG_ANYDATA:
Radek Krejciceaf2122019-01-02 15:03:26 +01003263 YANG_CHECK_STMTVER2_RET(ctx, "anydata", "augment");
Radek Krejci10113652018-11-14 16:56:50 +01003264 /* fall through */
Michal Vasko7fbc8162018-09-17 10:35:16 +02003265 case YANG_ANYXML:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003266 LY_CHECK_RET(parse_any(ctx, data, kw, (struct lysp_node*)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003267 break;
3268 case YANG_CASE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003269 LY_CHECK_RET(parse_case(ctx, data, (struct lysp_node*)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003270 break;
3271 case YANG_CHOICE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003272 LY_CHECK_RET(parse_choice(ctx, data, (struct lysp_node*)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003273 break;
3274 case YANG_CONTAINER:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003275 LY_CHECK_RET(parse_container(ctx, data, (struct lysp_node*)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003276 break;
3277 case YANG_LEAF:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003278 LY_CHECK_RET(parse_leaf(ctx, data, (struct lysp_node*)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003279 break;
3280 case YANG_LEAF_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003281 LY_CHECK_RET(parse_leaflist(ctx, data, (struct lysp_node*)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003282 break;
3283 case YANG_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003284 LY_CHECK_RET(parse_list(ctx, data, (struct lysp_node*)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003285 break;
3286 case YANG_USES:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003287 LY_CHECK_RET(parse_uses(ctx, data, (struct lysp_node*)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003288 break;
3289
3290 case YANG_ACTION:
Radek Krejciceaf2122019-01-02 15:03:26 +01003291 YANG_CHECK_STMTVER2_RET(ctx, "action", "augment");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003292 LY_CHECK_RET(parse_action(ctx, data, (struct lysp_node*)aug, &aug->actions));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003293 break;
3294 case YANG_NOTIFICATION:
Radek Krejciceaf2122019-01-02 15:03:26 +01003295 YANG_CHECK_STMTVER2_RET(ctx, "notification", "augment");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003296 LY_CHECK_RET(parse_notif(ctx, data, (struct lysp_node*)aug, &aug->notifs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003297 break;
3298 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003299 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &aug->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003300 break;
3301 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02003302 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "augment");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003303 return LY_EVALID;
3304 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003305 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003306 return ret;
3307}
3308
Michal Vaskoea5abea2018-09-18 13:10:54 +02003309/**
3310 * @brief Parse the uses statement.
3311 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003312 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003313 * @param[in,out] data Data to read from, always moved to currently handled character.
3314 * @param[in,out] siblings Siblings to add to.
3315 *
3316 * @return LY_ERR values.
3317 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003318LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02003319parse_uses(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003320{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003321 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003322 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003323 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003324 enum yang_keyword kw;
3325 struct lysp_node *iter;
3326 struct lysp_node_uses *uses;
3327
3328 /* create structure */
3329 uses = calloc(1, sizeof *uses);
Radek Krejci44ceedc2018-10-02 15:54:31 +02003330 LY_CHECK_ERR_RET(!uses, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003331 uses->nodetype = LYS_USES;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003332 uses->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003333
3334 /* insert into siblings */
3335 if (!*siblings) {
3336 *siblings = (struct lysp_node *)uses;
3337 } else {
3338 for (iter = *siblings; iter->next; iter = iter->next);
3339 iter->next = (struct lysp_node *)uses;
3340 }
3341
3342 /* get name */
Radek Krejcid3ca0632019-04-16 16:54:54 +02003343 LY_CHECK_RET(get_argument(ctx, data, Y_PREF_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02003344 INSERT_WORD(ctx, buf, uses->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003345
3346 /* parse substatements */
Radek Krejci6d6556c2018-11-08 09:37:45 +01003347 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003348 switch (kw) {
3349 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003350 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &uses->dsc, Y_STR_ARG, &uses->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003351 break;
3352 case YANG_IF_FEATURE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003353 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &uses->iffeatures, Y_STR_ARG, &uses->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003354 break;
3355 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003356 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &uses->ref, Y_STR_ARG, &uses->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003357 break;
3358 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003359 LY_CHECK_RET(parse_status(ctx, data, &uses->flags, &uses->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003360 break;
3361 case YANG_WHEN:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003362 LY_CHECK_RET(parse_when(ctx, data, &uses->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003363 break;
3364
3365 case YANG_REFINE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003366 LY_CHECK_RET(parse_refine(ctx, data, &uses->refines));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003367 break;
3368 case YANG_AUGMENT:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003369 LY_CHECK_RET(parse_augment(ctx, data, (struct lysp_node*)uses, &uses->augments));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003370 break;
3371 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003372 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &uses->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003373 break;
3374 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02003375 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "uses");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003376 return LY_EVALID;
3377 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003378 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003379 return ret;
3380}
3381
Michal Vaskoea5abea2018-09-18 13:10:54 +02003382/**
3383 * @brief Parse the case statement.
3384 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003385 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003386 * @param[in,out] data Data to read from, always moved to currently handled character.
3387 * @param[in,out] siblings Siblings to add to.
3388 *
3389 * @return LY_ERR values.
3390 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003391LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02003392parse_case(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003393{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003394 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003395 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003396 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003397 enum yang_keyword kw;
3398 struct lysp_node *iter;
3399 struct lysp_node_case *cas;
3400
3401 /* create structure */
3402 cas = calloc(1, sizeof *cas);
Radek Krejci44ceedc2018-10-02 15:54:31 +02003403 LY_CHECK_ERR_RET(!cas, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003404 cas->nodetype = LYS_CASE;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003405 cas->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003406
3407 /* insert into siblings */
3408 if (!*siblings) {
3409 *siblings = (struct lysp_node *)cas;
3410 } else {
3411 for (iter = *siblings; iter->next; iter = iter->next);
3412 iter->next = (struct lysp_node *)cas;
3413 }
3414
3415 /* get name */
Radek Krejcid3ca0632019-04-16 16:54:54 +02003416 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02003417 INSERT_WORD(ctx, buf, cas->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003418
3419 /* parse substatements */
Radek Krejci6d6556c2018-11-08 09:37:45 +01003420 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003421 switch (kw) {
3422 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003423 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &cas->dsc, Y_STR_ARG, &cas->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003424 break;
3425 case YANG_IF_FEATURE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003426 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &cas->iffeatures, Y_STR_ARG, &cas->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003427 break;
3428 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003429 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &cas->ref, Y_STR_ARG, &cas->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003430 break;
3431 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003432 LY_CHECK_RET(parse_status(ctx, data, &cas->flags, &cas->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003433 break;
3434 case YANG_WHEN:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003435 LY_CHECK_RET(parse_when(ctx, data, &cas->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003436 break;
3437
3438 case YANG_ANYDATA:
Radek Krejciceaf2122019-01-02 15:03:26 +01003439 YANG_CHECK_STMTVER2_RET(ctx, "anydata", "case");
Radek Krejci10113652018-11-14 16:56:50 +01003440 /* fall through */
Michal Vasko7fbc8162018-09-17 10:35:16 +02003441 case YANG_ANYXML:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003442 LY_CHECK_RET(parse_any(ctx, data, kw, (struct lysp_node*)cas, &cas->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003443 break;
3444 case YANG_CHOICE:
Radek Krejcia9026eb2018-12-12 16:04:47 +01003445 LY_CHECK_RET(parse_choice(ctx, data, (struct lysp_node*)cas, &cas->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003446 break;
3447 case YANG_CONTAINER:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003448 LY_CHECK_RET(parse_container(ctx, data, (struct lysp_node*)cas, &cas->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003449 break;
3450 case YANG_LEAF:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003451 LY_CHECK_RET(parse_leaf(ctx, data, (struct lysp_node*)cas, &cas->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003452 break;
3453 case YANG_LEAF_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003454 LY_CHECK_RET(parse_leaflist(ctx, data, (struct lysp_node*)cas, &cas->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003455 break;
3456 case YANG_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003457 LY_CHECK_RET(parse_list(ctx, data, (struct lysp_node*)cas, &cas->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003458 break;
3459 case YANG_USES:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003460 LY_CHECK_RET(parse_uses(ctx, data, (struct lysp_node*)cas, &cas->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003461 break;
3462 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003463 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &cas->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003464 break;
3465 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02003466 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "case");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003467 return LY_EVALID;
3468 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003469 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003470 return ret;
3471}
3472
Michal Vaskoea5abea2018-09-18 13:10:54 +02003473/**
3474 * @brief Parse the choice statement.
3475 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003476 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003477 * @param[in,out] data Data to read from, always moved to currently handled character.
3478 * @param[in,out] siblings Siblings to add to.
3479 *
3480 * @return LY_ERR values.
3481 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003482LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02003483parse_choice(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003484{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003485 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003486 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003487 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003488 enum yang_keyword kw;
3489 struct lysp_node *iter;
Radek Krejci44ceedc2018-10-02 15:54:31 +02003490 struct lysp_node_choice *choice;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003491
3492 /* create structure */
Radek Krejci44ceedc2018-10-02 15:54:31 +02003493 choice = calloc(1, sizeof *choice);
3494 LY_CHECK_ERR_RET(!choice, LOGMEM(ctx->ctx), LY_EMEM);
3495 choice->nodetype = LYS_CHOICE;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003496 choice->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003497
3498 /* insert into siblings */
3499 if (!*siblings) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02003500 *siblings = (struct lysp_node *)choice;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003501 } else {
3502 for (iter = *siblings; iter->next; iter = iter->next);
Radek Krejci44ceedc2018-10-02 15:54:31 +02003503 iter->next = (struct lysp_node *)choice;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003504 }
3505
3506 /* get name */
Radek Krejcid3ca0632019-04-16 16:54:54 +02003507 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02003508 INSERT_WORD(ctx, buf, choice->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003509
3510 /* parse substatements */
Radek Krejcia9026eb2018-12-12 16:04:47 +01003511 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret, goto checks) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003512 switch (kw) {
3513 case YANG_CONFIG:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003514 LY_CHECK_RET(parse_config(ctx, data, &choice->flags, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003515 break;
3516 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003517 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &choice->dsc, Y_STR_ARG, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003518 break;
3519 case YANG_IF_FEATURE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003520 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &choice->iffeatures, Y_STR_ARG, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003521 break;
3522 case YANG_MANDATORY:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003523 LY_CHECK_RET(parse_mandatory(ctx, data, &choice->flags, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003524 break;
3525 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003526 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &choice->ref, Y_STR_ARG, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003527 break;
3528 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003529 LY_CHECK_RET(parse_status(ctx, data, &choice->flags, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003530 break;
3531 case YANG_WHEN:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003532 LY_CHECK_RET(parse_when(ctx, data, &choice->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003533 break;
3534 case YANG_DEFAULT:
Radek Krejcia9026eb2018-12-12 16:04:47 +01003535 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DEFAULT, 0, &choice->dflt, Y_PREF_IDENTIF_ARG, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003536 break;
3537
3538 case YANG_ANYDATA:
Radek Krejciceaf2122019-01-02 15:03:26 +01003539 YANG_CHECK_STMTVER2_RET(ctx, "anydata", "choice");
Radek Krejci10113652018-11-14 16:56:50 +01003540 /* fall through */
Michal Vasko7fbc8162018-09-17 10:35:16 +02003541 case YANG_ANYXML:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003542 LY_CHECK_RET(parse_any(ctx, data, kw, (struct lysp_node*)choice, &choice->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003543 break;
3544 case YANG_CASE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003545 LY_CHECK_RET(parse_case(ctx, data, (struct lysp_node*)choice, &choice->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003546 break;
3547 case YANG_CHOICE:
Radek Krejciceaf2122019-01-02 15:03:26 +01003548 YANG_CHECK_STMTVER2_RET(ctx, "choice", "choice");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003549 LY_CHECK_RET(parse_choice(ctx, data, (struct lysp_node*)choice, &choice->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003550 break;
3551 case YANG_CONTAINER:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003552 LY_CHECK_RET(parse_container(ctx, data, (struct lysp_node*)choice, &choice->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003553 break;
3554 case YANG_LEAF:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003555 LY_CHECK_RET(parse_leaf(ctx, data, (struct lysp_node*)choice, &choice->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003556 break;
3557 case YANG_LEAF_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003558 LY_CHECK_RET(parse_leaflist(ctx, data, (struct lysp_node*)choice, &choice->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003559 break;
3560 case YANG_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003561 LY_CHECK_RET(parse_list(ctx, data, (struct lysp_node*)choice, &choice->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003562 break;
3563 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003564 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003565 break;
3566 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02003567 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "choice");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003568 return LY_EVALID;
3569 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003570 }
Radek Krejcia9026eb2018-12-12 16:04:47 +01003571 LY_CHECK_RET(ret);
3572checks:
3573 if ((choice->flags & LYS_MAND_TRUE) && choice->dflt) {
3574 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMSCOMB, "mandatory", "default", "choice");
3575 return LY_EVALID;
3576 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003577 return ret;
3578}
3579
Michal Vaskoea5abea2018-09-18 13:10:54 +02003580/**
3581 * @brief Parse the container statement.
3582 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003583 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003584 * @param[in,out] data Data to read from, always moved to currently handled character.
3585 * @param[in,out] siblings Siblings to add to.
3586 *
3587 * @return LY_ERR values.
3588 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003589LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02003590parse_container(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003591{
3592 LY_ERR ret = 0;
3593 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003594 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003595 enum yang_keyword kw;
3596 struct lysp_node *iter;
3597 struct lysp_node_container *cont;
Radek Krejcie86bf772018-12-14 11:39:53 +01003598 unsigned int u;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003599
3600 /* create structure */
3601 cont = calloc(1, sizeof *cont);
Radek Krejci44ceedc2018-10-02 15:54:31 +02003602 LY_CHECK_ERR_RET(!cont, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003603 cont->nodetype = LYS_CONTAINER;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003604 cont->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003605
3606 /* insert into siblings */
3607 if (!*siblings) {
3608 *siblings = (struct lysp_node *)cont;
3609 } else {
3610 for (iter = *siblings; iter->next; iter = iter->next);
3611 iter->next = (struct lysp_node *)cont;
3612 }
3613
3614 /* get name */
Radek Krejcid3ca0632019-04-16 16:54:54 +02003615 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02003616 INSERT_WORD(ctx, buf, cont->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003617
3618 /* parse substatements */
Radek Krejci6d6556c2018-11-08 09:37:45 +01003619 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003620 switch (kw) {
3621 case YANG_CONFIG:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003622 LY_CHECK_RET(parse_config(ctx, data, &cont->flags, &cont->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003623 break;
3624 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003625 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &cont->dsc, Y_STR_ARG, &cont->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003626 break;
3627 case YANG_IF_FEATURE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003628 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &cont->iffeatures, Y_STR_ARG, &cont->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003629 break;
3630 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003631 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &cont->ref, Y_STR_ARG, &cont->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003632 break;
3633 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003634 LY_CHECK_RET(parse_status(ctx, data, &cont->flags, &cont->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003635 break;
3636 case YANG_WHEN:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003637 LY_CHECK_RET(parse_when(ctx, data, &cont->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003638 break;
3639 case YANG_PRESENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003640 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_PRESENCE, 0, &cont->presence, Y_STR_ARG, &cont->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003641 break;
3642
3643 case YANG_ANYDATA:
Radek Krejciceaf2122019-01-02 15:03:26 +01003644 YANG_CHECK_STMTVER2_RET(ctx, "anydata", "container");
Radek Krejci10113652018-11-14 16:56:50 +01003645 /* fall through */
Michal Vasko7fbc8162018-09-17 10:35:16 +02003646 case YANG_ANYXML:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003647 LY_CHECK_RET(parse_any(ctx, data, kw, (struct lysp_node*)cont, &cont->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003648 break;
3649 case YANG_CHOICE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003650 LY_CHECK_RET(parse_choice(ctx, data, (struct lysp_node*)cont, &cont->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003651 break;
3652 case YANG_CONTAINER:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003653 LY_CHECK_RET(parse_container(ctx, data, (struct lysp_node*)cont, &cont->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003654 break;
3655 case YANG_LEAF:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003656 LY_CHECK_RET(parse_leaf(ctx, data, (struct lysp_node*)cont, &cont->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003657 break;
3658 case YANG_LEAF_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003659 LY_CHECK_RET(parse_leaflist(ctx, data, (struct lysp_node*)cont, &cont->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003660 break;
3661 case YANG_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003662 LY_CHECK_RET(parse_list(ctx, data, (struct lysp_node*)cont, &cont->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003663 break;
3664 case YANG_USES:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003665 LY_CHECK_RET(parse_uses(ctx, data, (struct lysp_node*)cont, &cont->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003666 break;
3667
3668 case YANG_TYPEDEF:
Radek Krejcibbe09a92018-11-08 09:36:54 +01003669 LY_CHECK_RET(parse_typedef(ctx, (struct lysp_node*)cont, data, &cont->typedefs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003670 break;
3671 case YANG_MUST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003672 LY_CHECK_RET(parse_restrs(ctx, data, kw, &cont->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003673 break;
3674 case YANG_ACTION:
Radek Krejciceaf2122019-01-02 15:03:26 +01003675 YANG_CHECK_STMTVER2_RET(ctx, "action", "container");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003676 LY_CHECK_RET(parse_action(ctx, data, (struct lysp_node*)cont, &cont->actions));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003677 break;
3678 case YANG_GROUPING:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003679 LY_CHECK_RET(parse_grouping(ctx, data, (struct lysp_node*)cont, &cont->groupings));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003680 break;
3681 case YANG_NOTIFICATION:
Radek Krejciceaf2122019-01-02 15:03:26 +01003682 YANG_CHECK_STMTVER2_RET(ctx, "notification", "container");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003683 LY_CHECK_RET(parse_notif(ctx, data, (struct lysp_node*)cont, &cont->notifs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003684 break;
3685 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003686 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &cont->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003687 break;
3688 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02003689 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "container");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003690 return LY_EVALID;
3691 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003692 }
Radek Krejcie86bf772018-12-14 11:39:53 +01003693 /* finalize parent pointers to the reallocated items */
3694 LY_ARRAY_FOR(cont->groupings, u) {
3695 LY_LIST_FOR(cont->groupings[u].data, iter) {
3696 iter->parent = (struct lysp_node*)&cont->groupings[u];
3697 }
3698 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003699 return ret;
3700}
3701
Michal Vaskoea5abea2018-09-18 13:10:54 +02003702/**
3703 * @brief Parse the list statement.
3704 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003705 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003706 * @param[in,out] data Data to read from, always moved to currently handled character.
3707 * @param[in,out] siblings Siblings to add to.
3708 *
3709 * @return LY_ERR values.
3710 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003711LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02003712parse_list(struct lys_parser_ctx *ctx, const char **data, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003713{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003714 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003715 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003716 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003717 enum yang_keyword kw;
3718 struct lysp_node *iter;
3719 struct lysp_node_list *list;
Radek Krejcie86bf772018-12-14 11:39:53 +01003720 unsigned int u;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003721
3722 /* create structure */
3723 list = calloc(1, sizeof *list);
Radek Krejci44ceedc2018-10-02 15:54:31 +02003724 LY_CHECK_ERR_RET(!list, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003725 list->nodetype = LYS_LIST;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003726 list->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003727
3728 /* insert into siblings */
3729 if (!*siblings) {
3730 *siblings = (struct lysp_node *)list;
3731 } else {
3732 for (iter = *siblings; iter->next; iter = iter->next);
3733 iter->next = (struct lysp_node *)list;
3734 }
3735
3736 /* get name */
Radek Krejcid3ca0632019-04-16 16:54:54 +02003737 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02003738 INSERT_WORD(ctx, buf, list->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003739
3740 /* parse substatements */
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003741 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret, goto checks) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003742 switch (kw) {
3743 case YANG_CONFIG:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003744 LY_CHECK_RET(parse_config(ctx, data, &list->flags, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003745 break;
3746 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003747 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &list->dsc, Y_STR_ARG, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003748 break;
3749 case YANG_IF_FEATURE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003750 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &list->iffeatures, Y_STR_ARG, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003751 break;
3752 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003753 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &list->ref, Y_STR_ARG, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003754 break;
3755 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003756 LY_CHECK_RET(parse_status(ctx, data, &list->flags, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003757 break;
3758 case YANG_WHEN:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003759 LY_CHECK_RET(parse_when(ctx, data, &list->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003760 break;
3761 case YANG_KEY:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003762 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_KEY, 0, &list->key, Y_STR_ARG, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003763 break;
3764 case YANG_MAX_ELEMENTS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003765 LY_CHECK_RET(parse_maxelements(ctx, data, &list->max, &list->flags, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003766 break;
3767 case YANG_MIN_ELEMENTS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003768 LY_CHECK_RET(parse_minelements(ctx, data, &list->min, &list->flags, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003769 break;
3770 case YANG_ORDERED_BY:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003771 LY_CHECK_RET(parse_orderedby(ctx, data, &list->flags, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003772 break;
3773 case YANG_UNIQUE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003774 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_UNIQUE, &list->uniques, Y_STR_ARG, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003775 break;
3776
3777 case YANG_ANYDATA:
Radek Krejciceaf2122019-01-02 15:03:26 +01003778 YANG_CHECK_STMTVER2_RET(ctx, "anydata", "list");
Radek Krejci10113652018-11-14 16:56:50 +01003779 /* fall through */
Michal Vasko7fbc8162018-09-17 10:35:16 +02003780 case YANG_ANYXML:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003781 LY_CHECK_RET(parse_any(ctx, data, kw, (struct lysp_node*)list, &list->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003782 break;
3783 case YANG_CHOICE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003784 LY_CHECK_RET(parse_choice(ctx, data, (struct lysp_node*)list, &list->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003785 break;
3786 case YANG_CONTAINER:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003787 LY_CHECK_RET(parse_container(ctx, data, (struct lysp_node*)list, &list->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003788 break;
3789 case YANG_LEAF:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003790 LY_CHECK_RET(parse_leaf(ctx, data, (struct lysp_node*)list, &list->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003791 break;
3792 case YANG_LEAF_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003793 LY_CHECK_RET(parse_leaflist(ctx, data, (struct lysp_node*)list, &list->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003794 break;
3795 case YANG_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003796 LY_CHECK_RET(parse_list(ctx, data, (struct lysp_node*)list, &list->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003797 break;
3798 case YANG_USES:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003799 LY_CHECK_RET(parse_uses(ctx, data, (struct lysp_node*)list, &list->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003800 break;
3801
3802 case YANG_TYPEDEF:
Radek Krejcibbe09a92018-11-08 09:36:54 +01003803 LY_CHECK_RET(parse_typedef(ctx, (struct lysp_node*)list, data, &list->typedefs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003804 break;
3805 case YANG_MUST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003806 LY_CHECK_RET(parse_restrs(ctx, data, kw, &list->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003807 break;
3808 case YANG_ACTION:
Radek Krejciceaf2122019-01-02 15:03:26 +01003809 YANG_CHECK_STMTVER2_RET(ctx, "action", "list");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003810 LY_CHECK_RET(parse_action(ctx, data, (struct lysp_node*)list, &list->actions));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003811 break;
3812 case YANG_GROUPING:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003813 LY_CHECK_RET(parse_grouping(ctx, data, (struct lysp_node*)list, &list->groupings));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003814 break;
3815 case YANG_NOTIFICATION:
Radek Krejciceaf2122019-01-02 15:03:26 +01003816 YANG_CHECK_STMTVER2_RET(ctx, "notification", "list");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003817 LY_CHECK_RET(parse_notif(ctx, data, (struct lysp_node*)list, &list->notifs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003818 break;
3819 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003820 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003821 break;
3822 default:
Radek Krejci10113652018-11-14 16:56:50 +01003823 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "list");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003824 return LY_EVALID;
3825 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003826 }
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003827 LY_CHECK_RET(ret);
Radek Krejcie86bf772018-12-14 11:39:53 +01003828 /* finalize parent pointers to the reallocated items */
3829 LY_ARRAY_FOR(list->groupings, u) {
3830 LY_LIST_FOR(list->groupings[u].data, iter) {
3831 iter->parent = (struct lysp_node*)&list->groupings[u];
3832 }
3833 }
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003834checks:
3835 if (list->max && list->min > list->max) {
3836 LOGVAL_YANG(ctx, LYVE_SEMANTICS,
3837 "Invalid combination of min-elements and max-elements: min value %u is bigger than the max value %u.",
3838 list->min, list->max);
3839 return LY_EVALID;
3840 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003841
3842 return ret;
3843}
3844
Michal Vaskoea5abea2018-09-18 13:10:54 +02003845/**
3846 * @brief Parse the yin-element statement.
3847 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003848 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003849 * @param[in,out] data Data to read from, always moved to currently handled character.
3850 * @param[in,out] flags Flags to write to.
3851 * @param[in,out] exts Extension instances to add to.
3852 *
3853 * @return LY_ERR values.
3854 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02003855static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02003856parse_yinelement(struct lys_parser_ctx *ctx, const char **data, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003857{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003858 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003859 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003860 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003861 enum yang_keyword kw;
3862
3863 if (*flags & LYS_YINELEM_MASK) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02003864 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "yin-element");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003865 return LY_EVALID;
3866 }
3867
3868 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02003869 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003870
3871 if ((word_len == 4) && !strncmp(word, "true", word_len)) {
3872 *flags |= LYS_YINELEM_TRUE;
3873 } else if ((word_len == 5) && !strncmp(word, "false", word_len)) {
3874 *flags |= LYS_YINELEM_FALSE;
3875 } else {
Radek Krejci44ceedc2018-10-02 15:54:31 +02003876 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "yin-element");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003877 free(buf);
3878 return LY_EVALID;
3879 }
3880 free(buf);
3881
Radek Krejci6d6556c2018-11-08 09:37:45 +01003882 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003883 switch (kw) {
3884 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003885 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_YINELEM, 0, exts));
3886 LY_CHECK_RET(ret); break;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003887 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02003888 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "yin-element");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003889 return LY_EVALID;
3890 }
3891 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003892 return ret;
3893}
3894
Michal Vaskoea5abea2018-09-18 13:10:54 +02003895/**
3896 * @brief Parse the yin-element statement.
3897 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003898 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003899 * @param[in,out] data Data to read from, always moved to currently handled character.
3900 * @param[in,out] argument Value to write to.
3901 * @param[in,out] flags Flags to write to.
3902 * @param[in,out] exts Extension instances to add to.
3903 *
3904 * @return LY_ERR values.
3905 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02003906static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02003907parse_argument(struct lys_parser_ctx *ctx, const char **data, const char **argument, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003908{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003909 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003910 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003911 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003912 enum yang_keyword kw;
3913
3914 if (*argument) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02003915 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, "argument");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003916 return LY_EVALID;
3917 }
3918
3919 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02003920 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02003921 INSERT_WORD(ctx, buf, *argument, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003922
Radek Krejci6d6556c2018-11-08 09:37:45 +01003923 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003924 switch (kw) {
3925 case YANG_YIN_ELEMENT:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003926 LY_CHECK_RET(parse_yinelement(ctx, data, flags, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003927 break;
3928 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003929 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_ARGUMENT, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003930 break;
3931 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02003932 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "argument");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003933 return LY_EVALID;
3934 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003935 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003936 return ret;
3937}
3938
Michal Vaskoea5abea2018-09-18 13:10:54 +02003939/**
3940 * @brief Parse the extension statement.
3941 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003942 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003943 * @param[in,out] data Data to read from, always moved to currently handled character.
3944 * @param[in,out] extensions Extensions to add to.
3945 *
3946 * @return LY_ERR values.
3947 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02003948static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02003949parse_extension(struct lys_parser_ctx *ctx, const char **data, struct lysp_ext **extensions)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003950{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003951 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003952 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003953 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003954 enum yang_keyword kw;
3955 struct lysp_ext *ex;
3956
Radek Krejci2c4e7172018-10-19 15:56:26 +02003957 LY_ARRAY_NEW_RET(ctx->ctx, *extensions, ex, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003958
3959 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02003960 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02003961 INSERT_WORD(ctx, buf, ex->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003962
Radek Krejci6d6556c2018-11-08 09:37:45 +01003963 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003964 switch (kw) {
3965 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003966 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &ex->dsc, Y_STR_ARG, &ex->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003967 break;
3968 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003969 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &ex->ref, Y_STR_ARG, &ex->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003970 break;
3971 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003972 LY_CHECK_RET(parse_status(ctx, data, &ex->flags, &ex->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003973 break;
3974 case YANG_ARGUMENT:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003975 LY_CHECK_RET(parse_argument(ctx, data, &ex->argument, &ex->flags, &ex->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003976 break;
3977 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003978 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &ex->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003979 break;
3980 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02003981 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "extension");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003982 return LY_EVALID;
3983 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003984 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003985 return ret;
3986}
3987
Michal Vaskoea5abea2018-09-18 13:10:54 +02003988/**
3989 * @brief Parse the deviate statement.
3990 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003991 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003992 * @param[in,out] data Data to read from, always moved to currently handled character.
3993 * @param[in,out] deviates Deviates to add to.
3994 *
3995 * @return LY_ERR values.
3996 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003997LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02003998parse_deviate(struct lys_parser_ctx *ctx, const char **data, struct lysp_deviate **deviates)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003999{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004000 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004001 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02004002 size_t word_len, dev_mod;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004003 enum yang_keyword kw;
4004 struct lysp_deviate *iter, *d;
4005 struct lysp_deviate_add *d_add = NULL;
4006 struct lysp_deviate_rpl *d_rpl = NULL;
4007 struct lysp_deviate_del *d_del = NULL;
4008 const char **d_units, ***d_uniques, ***d_dflts;
4009 struct lysp_restr **d_musts;
4010 uint16_t *d_flags;
4011 uint32_t *d_min, *d_max;
4012
4013 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02004014 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004015
4016 if ((word_len == 13) && !strncmp(word, "not-supported", word_len)) {
4017 dev_mod = LYS_DEV_NOT_SUPPORTED;
4018 } else if ((word_len == 3) && !strncmp(word, "add", word_len)) {
4019 dev_mod = LYS_DEV_ADD;
4020 } else if ((word_len == 7) && !strncmp(word, "replace", word_len)) {
4021 dev_mod = LYS_DEV_REPLACE;
4022 } else if ((word_len == 6) && !strncmp(word, "delete", word_len)) {
4023 dev_mod = LYS_DEV_DELETE;
4024 } else {
Radek Krejci44ceedc2018-10-02 15:54:31 +02004025 LOGVAL_YANG(ctx, LY_VCODE_INVAL, word_len, word, "deviate");
Michal Vasko7fbc8162018-09-17 10:35:16 +02004026 free(buf);
4027 return LY_EVALID;
4028 }
4029 free(buf);
4030
4031 /* create structure */
4032 switch (dev_mod) {
4033 case LYS_DEV_NOT_SUPPORTED:
4034 d = calloc(1, sizeof *d);
Radek Krejci44ceedc2018-10-02 15:54:31 +02004035 LY_CHECK_ERR_RET(!d, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004036 break;
4037 case LYS_DEV_ADD:
4038 d_add = calloc(1, sizeof *d_add);
Radek Krejci44ceedc2018-10-02 15:54:31 +02004039 LY_CHECK_ERR_RET(!d_add, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004040 d = (struct lysp_deviate *)d_add;
4041 d_units = &d_add->units;
4042 d_uniques = &d_add->uniques;
4043 d_dflts = &d_add->dflts;
4044 d_musts = &d_add->musts;
4045 d_flags = &d_add->flags;
4046 d_min = &d_add->min;
4047 d_max = &d_add->max;
4048 break;
4049 case LYS_DEV_REPLACE:
4050 d_rpl = calloc(1, sizeof *d_rpl);
Radek Krejci44ceedc2018-10-02 15:54:31 +02004051 LY_CHECK_ERR_RET(!d_rpl, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004052 d = (struct lysp_deviate *)d_rpl;
4053 d_units = &d_rpl->units;
4054 d_flags = &d_rpl->flags;
4055 d_min = &d_rpl->min;
4056 d_max = &d_rpl->max;
4057 break;
4058 case LYS_DEV_DELETE:
4059 d_del = calloc(1, sizeof *d_del);
Radek Krejci44ceedc2018-10-02 15:54:31 +02004060 LY_CHECK_ERR_RET(!d_del, LOGMEM(ctx->ctx), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004061 d = (struct lysp_deviate *)d_del;
4062 d_units = &d_del->units;
4063 d_uniques = &d_del->uniques;
4064 d_dflts = &d_del->dflts;
4065 d_musts = &d_del->musts;
4066 d_flags = &d_del->flags;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004067 break;
4068 default:
4069 assert(0);
Radek Krejci44ceedc2018-10-02 15:54:31 +02004070 LOGINT_RET(ctx->ctx);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004071 }
4072 d->mod = dev_mod;
4073
4074 /* insert into siblings */
4075 if (!*deviates) {
4076 *deviates = d;
4077 } else {
4078 for (iter = *deviates; iter->next; iter = iter->next);
4079 iter->next = d;
4080 }
4081
Radek Krejci6d6556c2018-11-08 09:37:45 +01004082 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02004083 switch (kw) {
4084 case YANG_CONFIG:
4085 switch (dev_mod) {
4086 case LYS_DEV_NOT_SUPPORTED:
Michal Vasko492bec72018-09-18 13:11:10 +02004087 case LYS_DEV_DELETE:
Radek Krejci44ceedc2018-10-02 15:54:31 +02004088 LOGVAL_YANG(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004089 return LY_EVALID;
4090 default:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004091 LY_CHECK_RET(parse_config(ctx, data, d_flags, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004092 break;
4093 }
4094 break;
4095 case YANG_DEFAULT:
4096 switch (dev_mod) {
4097 case LYS_DEV_NOT_SUPPORTED:
Radek Krejci44ceedc2018-10-02 15:54:31 +02004098 LOGVAL_YANG(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004099 return LY_EVALID;
4100 case LYS_DEV_REPLACE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004101 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DEFAULT, 0, &d_rpl->dflt, Y_STR_ARG, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004102 break;
4103 default:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004104 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_DEFAULT, d_dflts, Y_STR_ARG, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004105 break;
4106 }
4107 break;
4108 case YANG_MANDATORY:
4109 switch (dev_mod) {
4110 case LYS_DEV_NOT_SUPPORTED:
Michal Vasko492bec72018-09-18 13:11:10 +02004111 case LYS_DEV_DELETE:
Radek Krejci44ceedc2018-10-02 15:54:31 +02004112 LOGVAL_YANG(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004113 return LY_EVALID;
4114 default:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004115 LY_CHECK_RET(parse_mandatory(ctx, data, d_flags, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004116 break;
4117 }
4118 break;
4119 case YANG_MAX_ELEMENTS:
4120 switch (dev_mod) {
4121 case LYS_DEV_NOT_SUPPORTED:
Michal Vasko492bec72018-09-18 13:11:10 +02004122 case LYS_DEV_DELETE:
Radek Krejci44ceedc2018-10-02 15:54:31 +02004123 LOGVAL_YANG(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004124 return LY_EVALID;
4125 default:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004126 LY_CHECK_RET(parse_maxelements(ctx, data, d_max, d_flags, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004127 break;
4128 }
4129 break;
4130 case YANG_MIN_ELEMENTS:
4131 switch (dev_mod) {
4132 case LYS_DEV_NOT_SUPPORTED:
Michal Vasko492bec72018-09-18 13:11:10 +02004133 case LYS_DEV_DELETE:
Radek Krejci44ceedc2018-10-02 15:54:31 +02004134 LOGVAL_YANG(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004135 return LY_EVALID;
4136 default:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004137 LY_CHECK_RET(parse_minelements(ctx, data, d_min, d_flags, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004138 break;
4139 }
4140 break;
4141 case YANG_MUST:
4142 switch (dev_mod) {
4143 case LYS_DEV_NOT_SUPPORTED:
Michal Vasko492bec72018-09-18 13:11:10 +02004144 case LYS_DEV_REPLACE:
Radek Krejci44ceedc2018-10-02 15:54:31 +02004145 LOGVAL_YANG(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004146 return LY_EVALID;
4147 default:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004148 LY_CHECK_RET(parse_restrs(ctx, data, kw, d_musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004149 break;
4150 }
4151 break;
4152 case YANG_TYPE:
4153 switch (dev_mod) {
4154 case LYS_DEV_NOT_SUPPORTED:
4155 case LYS_DEV_ADD:
4156 case LYS_DEV_DELETE:
Radek Krejci44ceedc2018-10-02 15:54:31 +02004157 LOGVAL_YANG(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004158 return LY_EVALID;
4159 default:
Radek Krejci2c02f3e2018-10-16 10:54:38 +02004160 if (d_rpl->type) {
4161 LOGVAL_YANG(ctx, LY_VCODE_DUPSTMT, ly_stmt2str(kw));
4162 return LY_EVALID;
4163 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004164 d_rpl->type = calloc(1, sizeof *d_rpl->type);
Radek Krejci44ceedc2018-10-02 15:54:31 +02004165 LY_CHECK_ERR_RET(!d_rpl->type, LOGMEM(ctx->ctx), LY_EMEM);
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004166 LY_CHECK_RET(parse_type(ctx, data, d_rpl->type));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004167 break;
4168 }
4169 break;
4170 case YANG_UNIQUE:
4171 switch (dev_mod) {
4172 case LYS_DEV_NOT_SUPPORTED:
4173 case LYS_DEV_REPLACE:
Radek Krejci44ceedc2018-10-02 15:54:31 +02004174 LOGVAL_YANG(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004175 return LY_EVALID;
4176 default:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004177 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_UNIQUE, d_uniques, Y_STR_ARG, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004178 break;
4179 }
4180 break;
4181 case YANG_UNITS:
4182 switch (dev_mod) {
4183 case LYS_DEV_NOT_SUPPORTED:
Radek Krejci44ceedc2018-10-02 15:54:31 +02004184 LOGVAL_YANG(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004185 return LY_EVALID;
4186 default:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004187 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_UNITS, 0, d_units, Y_STR_ARG, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004188 break;
4189 }
4190 break;
4191 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004192 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004193 break;
4194 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02004195 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "deviate");
Michal Vasko7fbc8162018-09-17 10:35:16 +02004196 return LY_EVALID;
4197 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004198 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004199 return ret;
4200}
4201
Michal Vaskoea5abea2018-09-18 13:10:54 +02004202/**
4203 * @brief Parse the deviation statement.
4204 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02004205 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02004206 * @param[in,out] data Data to read from, always moved to currently handled character.
4207 * @param[in,out] deviations Deviations to add to.
4208 *
4209 * @return LY_ERR values.
4210 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02004211LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02004212parse_deviation(struct lys_parser_ctx *ctx, const char **data, struct lysp_deviation **deviations)
Michal Vasko7fbc8162018-09-17 10:35:16 +02004213{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004214 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004215 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02004216 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004217 enum yang_keyword kw;
4218 struct lysp_deviation *dev;
4219
Radek Krejci2c4e7172018-10-19 15:56:26 +02004220 LY_ARRAY_NEW_RET(ctx->ctx, *deviations, dev, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004221
4222 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02004223 LY_CHECK_RET(get_argument(ctx, data, Y_STR_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02004224 INSERT_WORD(ctx, buf, dev->nodeid, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004225
Radek Krejci6d6556c2018-11-08 09:37:45 +01004226 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret, goto checks) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02004227 switch (kw) {
4228 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004229 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &dev->dsc, Y_STR_ARG, &dev->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004230 break;
4231 case YANG_DEVIATE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004232 LY_CHECK_RET(parse_deviate(ctx, data, &dev->deviates));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004233 break;
4234 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004235 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &dev->ref, Y_STR_ARG, &dev->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004236 break;
4237 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004238 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &dev->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004239 break;
4240 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02004241 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "deviation");
Michal Vasko7fbc8162018-09-17 10:35:16 +02004242 return LY_EVALID;
4243 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004244 }
Radek Krejcic59bc972018-09-17 16:13:06 +02004245 LY_CHECK_RET(ret);
Radek Krejci6d6556c2018-11-08 09:37:45 +01004246checks:
Michal Vasko7fbc8162018-09-17 10:35:16 +02004247 /* mandatory substatements */
4248 if (!dev->deviates) {
Radek Krejci44ceedc2018-10-02 15:54:31 +02004249 LOGVAL_YANG(ctx, LY_VCODE_MISSTMT, "deviate", "deviation");
Michal Vasko7fbc8162018-09-17 10:35:16 +02004250 return LY_EVALID;
4251 }
4252
4253 return ret;
4254}
4255
Michal Vaskoea5abea2018-09-18 13:10:54 +02004256/**
4257 * @brief Parse the feature statement.
4258 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02004259 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02004260 * @param[in,out] data Data to read from, always moved to currently handled character.
4261 * @param[in,out] features Features to add to.
4262 *
4263 * @return LY_ERR values.
4264 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02004265LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02004266parse_feature(struct lys_parser_ctx *ctx, const char **data, struct lysp_feature **features)
Michal Vasko7fbc8162018-09-17 10:35:16 +02004267{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004268 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004269 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02004270 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004271 enum yang_keyword kw;
4272 struct lysp_feature *feat;
4273
Radek Krejci2c4e7172018-10-19 15:56:26 +02004274 LY_ARRAY_NEW_RET(ctx->ctx, *features, feat, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004275
4276 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02004277 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02004278 INSERT_WORD(ctx, buf, feat->name, word, word_len);
Radek Krejcifaa1eac2018-10-30 14:34:55 +01004279
Radek Krejci6d6556c2018-11-08 09:37:45 +01004280 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02004281 switch (kw) {
4282 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004283 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &feat->dsc, Y_STR_ARG, &feat->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004284 break;
4285 case YANG_IF_FEATURE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004286 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &feat->iffeatures, Y_STR_ARG, &feat->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004287 break;
4288 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004289 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &feat->ref, Y_STR_ARG, &feat->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004290 break;
4291 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004292 LY_CHECK_RET(parse_status(ctx, data, &feat->flags, &feat->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004293 break;
4294 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004295 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &feat->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004296 break;
4297 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02004298 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "feature");
Radek Krejci2c02f3e2018-10-16 10:54:38 +02004299 return LY_EVALID;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004300 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004301 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004302 return ret;
4303}
4304
Michal Vaskoea5abea2018-09-18 13:10:54 +02004305/**
4306 * @brief Parse the identity statement.
4307 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02004308 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02004309 * @param[in,out] data Data to read from, always moved to currently handled character.
4310 * @param[in,out] identities Identities to add to.
4311 *
4312 * @return LY_ERR values.
4313 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02004314LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02004315parse_identity(struct lys_parser_ctx *ctx, const char **data, struct lysp_ident **identities)
Michal Vasko7fbc8162018-09-17 10:35:16 +02004316{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004317 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004318 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02004319 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004320 enum yang_keyword kw;
4321 struct lysp_ident *ident;
4322
Radek Krejci2c4e7172018-10-19 15:56:26 +02004323 LY_ARRAY_NEW_RET(ctx->ctx, *identities, ident, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004324
4325 /* get value */
Radek Krejcid3ca0632019-04-16 16:54:54 +02004326 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci44ceedc2018-10-02 15:54:31 +02004327 INSERT_WORD(ctx, buf, ident->name, word, word_len);
Radek Krejcifaa1eac2018-10-30 14:34:55 +01004328
Radek Krejci6d6556c2018-11-08 09:37:45 +01004329 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret,) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02004330 switch (kw) {
4331 case YANG_DESCRIPTION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004332 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &ident->dsc, Y_STR_ARG, &ident->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004333 break;
4334 case YANG_IF_FEATURE:
Radek Krejciceaf2122019-01-02 15:03:26 +01004335 YANG_CHECK_STMTVER2_RET(ctx, "if-feature", "identity");
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004336 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_IFFEATURE, &ident->iffeatures, Y_STR_ARG, &ident->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004337 break;
4338 case YANG_REFERENCE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004339 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &ident->ref, Y_STR_ARG, &ident->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004340 break;
4341 case YANG_STATUS:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004342 LY_CHECK_RET(parse_status(ctx, data, &ident->flags, &ident->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004343 break;
4344 case YANG_BASE:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004345 if (ident->bases && ctx->mod_version < 2) {
Radek Krejci10113652018-11-14 16:56:50 +01004346 LOGVAL_YANG(ctx, LYVE_SYNTAX_YANG, "Identity can be derived from multiple base identities only in YANG 1.1 modules");
4347 return LY_EVALID;
4348 }
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004349 LY_CHECK_RET(parse_text_fields(ctx, data, LYEXT_SUBSTMT_BASE, &ident->bases, Y_PREF_IDENTIF_ARG, &ident->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004350 break;
4351 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004352 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &ident->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004353 break;
4354 default:
Radek Krejci44ceedc2018-10-02 15:54:31 +02004355 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "identity");
Michal Vasko7fbc8162018-09-17 10:35:16 +02004356 return LY_EVALID;
4357 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004358 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004359 return ret;
4360}
4361
Michal Vaskoea5abea2018-09-18 13:10:54 +02004362/**
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004363 * @brief Finalize some of the (sub)module structure after parsing.
4364 *
4365 * Update parent pointers in the nodes inside grouping/RPC/Notification, which could be reallocated.
4366 *
4367 * @param[in] mod Parsed module to be updated.
4368 * @return LY_ERR value (currently only LY_SUCCESS, but it can change in future).
4369 */
4370static LY_ERR
4371parse_sub_module_finalize(struct lysp_module *mod)
4372{
4373 unsigned int u;
4374 struct lysp_node *child;
4375
4376 /* finalize parent pointers to the reallocated items */
4377 LY_ARRAY_FOR(mod->groupings, u) {
4378 LY_LIST_FOR(mod->groupings[u].data, child) {
4379 child->parent = (struct lysp_node*)&mod->groupings[u];
4380 }
4381 }
4382
4383 /* TODO the same finalization for rpcs and notifications, do also in the relevant nodes */
4384
4385 return LY_SUCCESS;
4386}
4387
4388/**
4389 * @brief Parse module substatements.
Michal Vaskoea5abea2018-09-18 13:10:54 +02004390 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02004391 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02004392 * @param[in,out] data Data to read from, always moved to currently handled character.
4393 * @param[in,out] mod Module to write to.
4394 *
4395 * @return LY_ERR values.
4396 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02004397LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02004398parse_module(struct lys_parser_ctx *ctx, const char **data, struct lysp_module *mod)
Michal Vasko7fbc8162018-09-17 10:35:16 +02004399{
4400 LY_ERR ret = 0;
4401 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02004402 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004403 enum yang_keyword kw, prev_kw = 0;
4404 enum yang_module_stmt mod_stmt = Y_MOD_MODULE_HEADER;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004405 struct lysp_submodule *dup;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004406
4407 /* (sub)module name */
Radek Krejcid3ca0632019-04-16 16:54:54 +02004408 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004409 INSERT_WORD(ctx, buf, mod->mod->name, word, word_len);
Radek Krejcifaa1eac2018-10-30 14:34:55 +01004410
Radek Krejci6d6556c2018-11-08 09:37:45 +01004411 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret, goto checks) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02004412
Radek Krejcie3846472018-10-15 15:24:51 +02004413#define CHECK_ORDER(SECTION) \
4414 if (mod_stmt > SECTION) {LOGVAL_YANG(ctx, LY_VCODE_INORD, ly_stmt2str(kw), ly_stmt2str(prev_kw)); return LY_EVALID;}mod_stmt = SECTION
4415
Michal Vasko7fbc8162018-09-17 10:35:16 +02004416 switch (kw) {
4417 /* module header */
4418 case YANG_NAMESPACE:
4419 case YANG_PREFIX:
Radek Krejcie3846472018-10-15 15:24:51 +02004420 CHECK_ORDER(Y_MOD_MODULE_HEADER);
4421 break;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004422 case YANG_YANG_VERSION:
Radek Krejcie3846472018-10-15 15:24:51 +02004423 CHECK_ORDER(Y_MOD_MODULE_HEADER);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004424 break;
4425 /* linkage */
4426 case YANG_INCLUDE:
4427 case YANG_IMPORT:
Radek Krejcie3846472018-10-15 15:24:51 +02004428 CHECK_ORDER(Y_MOD_LINKAGE);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004429 break;
4430 /* meta */
4431 case YANG_ORGANIZATION:
4432 case YANG_CONTACT:
4433 case YANG_DESCRIPTION:
4434 case YANG_REFERENCE:
Radek Krejcie3846472018-10-15 15:24:51 +02004435 CHECK_ORDER(Y_MOD_META);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004436 break;
4437
4438 /* revision */
4439 case YANG_REVISION:
Radek Krejcie3846472018-10-15 15:24:51 +02004440 CHECK_ORDER(Y_MOD_REVISION);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004441 break;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004442 /* body */
4443 case YANG_ANYDATA:
4444 case YANG_ANYXML:
4445 case YANG_AUGMENT:
4446 case YANG_CHOICE:
4447 case YANG_CONTAINER:
4448 case YANG_DEVIATION:
4449 case YANG_EXTENSION:
4450 case YANG_FEATURE:
4451 case YANG_GROUPING:
4452 case YANG_IDENTITY:
4453 case YANG_LEAF:
4454 case YANG_LEAF_LIST:
4455 case YANG_LIST:
4456 case YANG_NOTIFICATION:
4457 case YANG_RPC:
4458 case YANG_TYPEDEF:
4459 case YANG_USES:
4460 case YANG_CUSTOM:
4461 mod_stmt = Y_MOD_BODY;
4462 break;
4463 default:
4464 /* error handled in the next switch */
4465 break;
4466 }
Radek Krejcie3846472018-10-15 15:24:51 +02004467#undef CHECK_ORDER
Michal Vasko7fbc8162018-09-17 10:35:16 +02004468
Radek Krejcie3846472018-10-15 15:24:51 +02004469 prev_kw = kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004470 switch (kw) {
4471 /* module header */
4472 case YANG_YANG_VERSION:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004473 LY_CHECK_RET(parse_yangversion(ctx, data, &mod->mod->version, &mod->exts));
4474 ctx->mod_version = mod->mod->version;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004475 break;
4476 case YANG_NAMESPACE:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004477 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_NAMESPACE, 0, &mod->mod->ns, Y_STR_ARG, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004478 break;
4479 case YANG_PREFIX:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004480 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_PREFIX, 0, &mod->mod->prefix, Y_IDENTIF_ARG, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004481 break;
4482
4483 /* linkage */
4484 case YANG_INCLUDE:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004485 LY_CHECK_RET(parse_include(ctx, mod->mod->name, data, &mod->includes));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004486 break;
4487 case YANG_IMPORT:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004488 LY_CHECK_RET(parse_import(ctx, mod->mod->prefix, data, &mod->imports));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004489 break;
4490
4491 /* meta */
4492 case YANG_ORGANIZATION:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004493 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_ORGANIZATION, 0, &mod->mod->org, Y_STR_ARG, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004494 break;
4495 case YANG_CONTACT:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004496 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_CONTACT, 0, &mod->mod->contact, Y_STR_ARG, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004497 break;
4498 case YANG_DESCRIPTION:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004499 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &mod->mod->dsc, Y_STR_ARG, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004500 break;
4501 case YANG_REFERENCE:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004502 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &mod->mod->ref, Y_STR_ARG, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004503 break;
4504
4505 /* revision */
4506 case YANG_REVISION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004507 LY_CHECK_RET(parse_revision(ctx, data, &mod->revs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004508 break;
4509
4510 /* body */
4511 case YANG_ANYDATA:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004512 YANG_CHECK_STMTVER2_RET(ctx, "anydata", "module");
Radek Krejci10113652018-11-14 16:56:50 +01004513 /* fall through */
Michal Vasko7fbc8162018-09-17 10:35:16 +02004514 case YANG_ANYXML:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004515 LY_CHECK_RET(parse_any(ctx, data, kw, NULL, &mod->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004516 break;
4517 case YANG_CHOICE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004518 LY_CHECK_RET(parse_choice(ctx, data, NULL, &mod->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004519 break;
4520 case YANG_CONTAINER:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004521 LY_CHECK_RET(parse_container(ctx, data, NULL, &mod->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004522 break;
4523 case YANG_LEAF:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004524 LY_CHECK_RET(parse_leaf(ctx, data, NULL, &mod->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004525 break;
4526 case YANG_LEAF_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004527 LY_CHECK_RET(parse_leaflist(ctx, data, NULL, &mod->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004528 break;
4529 case YANG_LIST:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004530 LY_CHECK_RET(parse_list(ctx, data, NULL, &mod->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004531 break;
4532 case YANG_USES:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004533 LY_CHECK_RET(parse_uses(ctx, data, NULL, &mod->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004534 break;
4535
4536 case YANG_AUGMENT:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004537 LY_CHECK_RET(parse_augment(ctx, data, NULL, &mod->augments));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004538 break;
4539 case YANG_DEVIATION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004540 LY_CHECK_RET(parse_deviation(ctx, data, &mod->deviations));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004541 break;
4542 case YANG_EXTENSION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004543 LY_CHECK_RET(parse_extension(ctx, data, &mod->extensions));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004544 break;
4545 case YANG_FEATURE:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004546 LY_CHECK_RET(parse_feature(ctx, data, &mod->features));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004547 break;
4548 case YANG_GROUPING:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004549 LY_CHECK_RET(parse_grouping(ctx, data, NULL, &mod->groupings));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004550 break;
4551 case YANG_IDENTITY:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004552 LY_CHECK_RET(parse_identity(ctx, data, &mod->identities));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004553 break;
4554 case YANG_NOTIFICATION:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004555 LY_CHECK_RET(parse_notif(ctx, data, NULL, &mod->notifs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004556 break;
4557 case YANG_RPC:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004558 LY_CHECK_RET(parse_action(ctx, data, NULL, &mod->rpcs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004559 break;
4560 case YANG_TYPEDEF:
Radek Krejcibbe09a92018-11-08 09:36:54 +01004561 LY_CHECK_RET(parse_typedef(ctx, NULL, data, &mod->typedefs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004562 break;
4563 case YANG_CUSTOM:
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004564 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004565 break;
4566
4567 default:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004568 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "module");
Michal Vasko7fbc8162018-09-17 10:35:16 +02004569 return LY_EVALID;
4570 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004571 }
Radek Krejcic59bc972018-09-17 16:13:06 +02004572 LY_CHECK_RET(ret);
Radek Krejcie86bf772018-12-14 11:39:53 +01004573
Radek Krejci6d6556c2018-11-08 09:37:45 +01004574checks:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004575 /* finalize parent pointers to the reallocated items */
4576 LY_CHECK_RET(parse_sub_module_finalize(mod));
4577
Michal Vasko7fbc8162018-09-17 10:35:16 +02004578 /* mandatory substatements */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004579 if (!mod->mod->ns) {
4580 LOGVAL_YANG(ctx, LY_VCODE_MISSTMT, "namespace", "module");
4581 return LY_EVALID;
4582 } else if (!mod->mod->prefix) {
4583 LOGVAL_YANG(ctx, LY_VCODE_MISSTMT, "prefix", "module");
4584 return LY_EVALID;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004585 }
4586
Radek Krejcie9e987e2018-10-31 12:50:27 +01004587 /* submodules share the namespace with the module names, so there must not be
4588 * a submodule of the same name in the context, no need for revision matching */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004589 dup = ly_ctx_get_submodule(ctx->ctx, NULL, mod->mod->name, NULL);
4590 if (dup) {
4591 LOGVAL_YANG(ctx, LYVE_SYNTAX_YANG, "Name collision between module and submodule of name \"%s\".", mod->mod->name);
4592 return LY_EVALID;
4593 }
4594
4595 return ret;
4596}
4597
4598/**
4599 * @brief Parse submodule substatements.
4600 *
4601 * @param[in] ctx yang parser context for logging.
4602 * @param[in,out] data Data to read from, always moved to currently handled character.
4603 * @param[out] submod Parsed submodule structure.
4604 *
4605 * @return LY_ERR values.
4606 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02004607LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02004608parse_submodule(struct lys_parser_ctx *ctx, const char **data, struct lysp_submodule *submod)
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004609{
4610 LY_ERR ret = 0;
4611 char *buf, *word;
4612 size_t word_len;
4613 enum yang_keyword kw, prev_kw = 0;
4614 enum yang_module_stmt mod_stmt = Y_MOD_MODULE_HEADER;
4615 struct lysp_submodule *dup;
4616
4617 /* submodule name */
Radek Krejcid3ca0632019-04-16 16:54:54 +02004618 LY_CHECK_RET(get_argument(ctx, data, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004619 INSERT_WORD(ctx, buf, submod->name, word, word_len);
4620
4621 YANG_READ_SUBSTMT_FOR(ctx, data, kw, word, word_len, ret, goto checks) {
4622
4623#define CHECK_ORDER(SECTION) \
4624 if (mod_stmt > SECTION) {LOGVAL_YANG(ctx, LY_VCODE_INORD, ly_stmt2str(kw), ly_stmt2str(prev_kw)); return LY_EVALID;}mod_stmt = SECTION
4625
4626 switch (kw) {
4627 /* module header */
4628 case YANG_BELONGS_TO:
4629 CHECK_ORDER(Y_MOD_MODULE_HEADER);
4630 break;
4631 case YANG_YANG_VERSION:
4632 CHECK_ORDER(Y_MOD_MODULE_HEADER);
4633 break;
4634 /* linkage */
4635 case YANG_INCLUDE:
4636 case YANG_IMPORT:
4637 CHECK_ORDER(Y_MOD_LINKAGE);
4638 break;
4639 /* meta */
4640 case YANG_ORGANIZATION:
4641 case YANG_CONTACT:
4642 case YANG_DESCRIPTION:
4643 case YANG_REFERENCE:
4644 CHECK_ORDER(Y_MOD_META);
4645 break;
4646
4647 /* revision */
4648 case YANG_REVISION:
4649 CHECK_ORDER(Y_MOD_REVISION);
4650 break;
4651 /* body */
4652 case YANG_ANYDATA:
4653 case YANG_ANYXML:
4654 case YANG_AUGMENT:
4655 case YANG_CHOICE:
4656 case YANG_CONTAINER:
4657 case YANG_DEVIATION:
4658 case YANG_EXTENSION:
4659 case YANG_FEATURE:
4660 case YANG_GROUPING:
4661 case YANG_IDENTITY:
4662 case YANG_LEAF:
4663 case YANG_LEAF_LIST:
4664 case YANG_LIST:
4665 case YANG_NOTIFICATION:
4666 case YANG_RPC:
4667 case YANG_TYPEDEF:
4668 case YANG_USES:
4669 case YANG_CUSTOM:
4670 mod_stmt = Y_MOD_BODY;
4671 break;
4672 default:
4673 /* error handled in the next switch */
4674 break;
4675 }
4676#undef CHECK_ORDER
4677
4678 prev_kw = kw;
4679 switch (kw) {
4680 /* module header */
4681 case YANG_YANG_VERSION:
4682 LY_CHECK_RET(parse_yangversion(ctx, data, &submod->version, &submod->exts));
4683 ctx->mod_version = submod->version;
4684 break;
4685 case YANG_BELONGS_TO:
4686 LY_CHECK_RET(parse_belongsto(ctx, data, &submod->belongsto, &submod->prefix, &submod->exts));
4687 break;
4688
4689 /* linkage */
4690 case YANG_INCLUDE:
4691 LY_CHECK_RET(parse_include(ctx, submod->name, data, &submod->includes));
4692 break;
4693 case YANG_IMPORT:
4694 LY_CHECK_RET(parse_import(ctx, submod->prefix, data, &submod->imports));
4695 break;
4696
4697 /* meta */
4698 case YANG_ORGANIZATION:
4699 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_ORGANIZATION, 0, &submod->org, Y_STR_ARG, &submod->exts));
4700 break;
4701 case YANG_CONTACT:
4702 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_CONTACT, 0, &submod->contact, Y_STR_ARG, &submod->exts));
4703 break;
4704 case YANG_DESCRIPTION:
4705 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_DESCRIPTION, 0, &submod->dsc, Y_STR_ARG, &submod->exts));
4706 break;
4707 case YANG_REFERENCE:
4708 LY_CHECK_RET(parse_text_field(ctx, data, LYEXT_SUBSTMT_REFERENCE, 0, &submod->ref, Y_STR_ARG, &submod->exts));
4709 break;
4710
4711 /* revision */
4712 case YANG_REVISION:
4713 LY_CHECK_RET(parse_revision(ctx, data, &submod->revs));
4714 break;
4715
4716 /* body */
4717 case YANG_ANYDATA:
4718 YANG_CHECK_STMTVER2_RET(ctx, "anydata", "submodule");
4719 /* fall through */
4720 case YANG_ANYXML:
4721 LY_CHECK_RET(parse_any(ctx, data, kw, NULL, &submod->data));
4722 break;
4723 case YANG_CHOICE:
4724 LY_CHECK_RET(parse_choice(ctx, data, NULL, &submod->data));
4725 break;
4726 case YANG_CONTAINER:
4727 LY_CHECK_RET(parse_container(ctx, data, NULL, &submod->data));
4728 break;
4729 case YANG_LEAF:
4730 LY_CHECK_RET(parse_leaf(ctx, data, NULL, &submod->data));
4731 break;
4732 case YANG_LEAF_LIST:
4733 LY_CHECK_RET(parse_leaflist(ctx, data, NULL, &submod->data));
4734 break;
4735 case YANG_LIST:
4736 LY_CHECK_RET(parse_list(ctx, data, NULL, &submod->data));
4737 break;
4738 case YANG_USES:
4739 LY_CHECK_RET(parse_uses(ctx, data, NULL, &submod->data));
4740 break;
4741
4742 case YANG_AUGMENT:
4743 LY_CHECK_RET(parse_augment(ctx, data, NULL, &submod->augments));
4744 break;
4745 case YANG_DEVIATION:
4746 LY_CHECK_RET(parse_deviation(ctx, data, &submod->deviations));
4747 break;
4748 case YANG_EXTENSION:
4749 LY_CHECK_RET(parse_extension(ctx, data, &submod->extensions));
4750 break;
4751 case YANG_FEATURE:
4752 LY_CHECK_RET(parse_feature(ctx, data, &submod->features));
4753 break;
4754 case YANG_GROUPING:
4755 LY_CHECK_RET(parse_grouping(ctx, data, NULL, &submod->groupings));
4756 break;
4757 case YANG_IDENTITY:
4758 LY_CHECK_RET(parse_identity(ctx, data, &submod->identities));
4759 break;
4760 case YANG_NOTIFICATION:
4761 LY_CHECK_RET(parse_notif(ctx, data, NULL, &submod->notifs));
4762 break;
4763 case YANG_RPC:
4764 LY_CHECK_RET(parse_action(ctx, data, NULL, &submod->rpcs));
4765 break;
4766 case YANG_TYPEDEF:
4767 LY_CHECK_RET(parse_typedef(ctx, NULL, data, &submod->typedefs));
4768 break;
4769 case YANG_CUSTOM:
4770 LY_CHECK_RET(parse_ext(ctx, data, word, word_len, LYEXT_SUBSTMT_SELF, 0, &submod->exts));
4771 break;
4772
4773 default:
4774 LOGVAL_YANG(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "submodule");
4775 return LY_EVALID;
4776 }
4777 }
4778 LY_CHECK_RET(ret);
4779
4780checks:
4781 /* finalize parent pointers to the reallocated items */
4782 LY_CHECK_RET(parse_sub_module_finalize((struct lysp_module*)submod));
4783
4784 /* mandatory substatements */
4785 if (!submod->belongsto) {
4786 LOGVAL_YANG(ctx, LY_VCODE_MISSTMT, "belongs-to", "submodule");
4787 return LY_EVALID;
4788 }
4789
4790 /* submodules share the namespace with the module names, so there must not be
4791 * a submodule of the same name in the context, no need for revision matching */
4792 dup = ly_ctx_get_submodule(ctx->ctx, NULL, submod->name, NULL);
4793 if (dup && strcmp(dup->belongsto, submod->belongsto)) {
4794 LOGVAL_YANG(ctx, LYVE_SYNTAX_YANG, "Name collision between submodules of name \"%s\".", dup->name);
Radek Krejcie9e987e2018-10-31 12:50:27 +01004795 return LY_EVALID;
4796 }
4797
Michal Vasko7fbc8162018-09-17 10:35:16 +02004798 return ret;
4799}
4800
Radek Krejcid4557c62018-09-17 11:42:09 +02004801LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02004802yang_parse_submodule(struct lys_parser_ctx *context, const char *data, struct lysp_submodule **submod)
Michal Vasko7fbc8162018-09-17 10:35:16 +02004803{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004804 LY_ERR ret = LY_SUCCESS;
Radek Krejci0a1d0d42019-05-16 15:14:51 +02004805 char *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02004806 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004807 enum yang_keyword kw;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004808 struct lysp_submodule *mod_p = NULL;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004809
4810 /* "module"/"submodule" */
Radek Krejcibbe09a92018-11-08 09:36:54 +01004811 ret = get_keyword(context, &data, &kw, &word, &word_len);
4812 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004813
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004814 if (kw == YANG_MODULE) {
4815 LOGERR(context->ctx, LY_EDENIED, "Input data contains module in situation when a submodule is expected.");
4816 ret = LY_EINVAL;
4817 goto cleanup;
4818 } else if (kw != YANG_SUBMODULE) {
Radek Krejcibbe09a92018-11-08 09:36:54 +01004819 LOGVAL_YANG(context, LYVE_SYNTAX, "Invalid keyword \"%s\", expected \"module\" or \"submodule\".",
Radek Krejcic59bc972018-09-17 16:13:06 +02004820 ly_stmt2str(kw));
Radek Krejci40544fa2019-01-11 09:38:37 +01004821 ret = LY_EVALID;
Radek Krejcibbe09a92018-11-08 09:36:54 +01004822 goto cleanup;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004823 }
4824
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004825 mod_p = calloc(1, sizeof *mod_p);
4826 LY_CHECK_ERR_GOTO(!mod_p, LOGMEM(context->ctx), cleanup);
4827 mod_p->parsing = 1;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004828
4829 /* substatements */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004830 ret = parse_submodule(context, &data, mod_p);
Radek Krejcibbe09a92018-11-08 09:36:54 +01004831 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004832
4833 /* read some trailing spaces or new lines */
Radek Krejci0a1d0d42019-05-16 15:14:51 +02004834 while(*data && isspace(*data)) {
4835 data++;
4836 }
4837 if (*data) {
4838 LOGVAL_YANG(context, LYVE_SYNTAX, "Trailing garbage \"%.*s%s\" after submodule, expected end-of-input.",
4839 15, data, strlen(data) > 15 ? "..." : "");
Radek Krejci40544fa2019-01-11 09:38:37 +01004840 ret = LY_EVALID;
Radek Krejcibbe09a92018-11-08 09:36:54 +01004841 goto cleanup;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004842 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004843
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004844 mod_p->parsing = 0;
4845 *submod = mod_p;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004846
Radek Krejcibbe09a92018-11-08 09:36:54 +01004847cleanup:
4848 if (ret) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004849 lysp_submodule_free(context->ctx, mod_p);
4850 }
4851
4852 return ret;
4853}
4854
4855LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +02004856yang_parse_module(struct lys_parser_ctx *context, const char *data, struct lys_module *mod)
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004857{
4858 LY_ERR ret = LY_SUCCESS;
Radek Krejci0a1d0d42019-05-16 15:14:51 +02004859 char *word;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004860 size_t word_len;
4861 enum yang_keyword kw;
4862 struct lysp_module *mod_p = NULL;
4863
4864 /* "module"/"submodule" */
4865 ret = get_keyword(context, &data, &kw, &word, &word_len);
4866 LY_CHECK_GOTO(ret, cleanup);
4867
4868 if (kw == YANG_SUBMODULE) {
4869 LOGERR(context->ctx, LY_EDENIED, "Input data contains submodule which cannot be parsed directly without its main module.");
4870 ret = LY_EINVAL;
4871 goto cleanup;
4872 } else if (kw != YANG_MODULE) {
4873 LOGVAL_YANG(context, LYVE_SYNTAX, "Invalid keyword \"%s\", expected \"module\" or \"submodule\".",
4874 ly_stmt2str(kw));
Radek Krejci40544fa2019-01-11 09:38:37 +01004875 ret = LY_EVALID;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004876 goto cleanup;
4877 }
4878
4879 mod_p = calloc(1, sizeof *mod_p);
4880 LY_CHECK_ERR_GOTO(!mod_p, LOGMEM(context->ctx), cleanup);
4881 mod_p->mod = mod;
4882 mod_p->parsing = 1;
4883
4884 /* substatements */
4885 ret = parse_module(context, &data, mod_p);
4886 LY_CHECK_GOTO(ret, cleanup);
4887
4888 /* read some trailing spaces or new lines */
Radek Krejci0a1d0d42019-05-16 15:14:51 +02004889 while(*data && isspace(*data)) {
4890 data++;
4891 }
4892 if (*data) {
4893 LOGVAL_YANG(context, LYVE_SYNTAX, "Trailing garbage \"%.*s%s\" after module, expected end-of-input.",
4894 15, data, strlen(data) > 15 ? "..." : "");
Radek Krejci40544fa2019-01-11 09:38:37 +01004895 ret = LY_EVALID;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004896 goto cleanup;
4897 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004898
4899 mod_p->parsing = 0;
4900 mod->parsed = mod_p;
4901
4902cleanup:
4903 if (ret) {
4904 lysp_module_free(mod_p);
Radek Krejcibbe09a92018-11-08 09:36:54 +01004905 }
4906
Michal Vasko7fbc8162018-09-17 10:35:16 +02004907 return ret;
4908}