blob: f885b434c73f4d7229ed020d317611874ef35407 [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 Vasko63f3d842020-07-08 10:10:14 +020014#include "parser_internal.h"
Michal Vasko7fbc8162018-09-17 10:35:16 +020015
Radek Krejcie7b95092019-05-15 11:03:07 +020016#include <assert.h>
17#include <ctype.h>
18#include <errno.h>
19#include <stdint.h>
20#include <stdio.h>
21#include <stdlib.h>
22#include <string.h>
23
Radek Krejci535ea9f2020-05-29 16:01:05 +020024#include "common.h"
Michal Vasko7fbc8162018-09-17 10:35:16 +020025#include "context.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020026#include "dict.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020027#include "in_internal.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020028#include "log.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020029#include "parser_schema.h"
Michal Vasko69730152020-10-09 16:30:07 +020030#include "path.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020031#include "set.h"
32#include "tree.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010033#include "tree_edit.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020034#include "tree_schema.h"
Radek Krejci70853c52018-10-15 14:46:16 +020035#include "tree_schema_internal.h"
Radek Krejci44ceedc2018-10-02 15:54:31 +020036
Radek Krejci77114102021-03-10 15:21:57 +010037struct lys_glob_unres;
38
Radek Krejciceaf2122019-01-02 15:03:26 +010039/**
40 * @brief Insert WORD into the libyang context's dictionary and store as TARGET.
41 * @param[in] CTX yang parser context to access libyang context.
42 * @param[in] BUF buffer in case the word is not a constant and can be inserted directly (zero-copy)
43 * @param[out] TARGET variable where to store the pointer to the inserted value.
44 * @param[in] WORD string to store.
45 * @param[in] LEN length of the string in WORD to store.
46 */
Radek Krejci011e4aa2020-09-04 15:22:31 +020047#define INSERT_WORD_RET(CTX, BUF, TARGET, WORD, LEN) \
Michal Vasko5d24f6c2020-10-13 13:49:06 +020048 if (BUF) {LY_CHECK_RET(lydict_insert_zc(PARSER_CTX(CTX), WORD, &(TARGET)));}\
49 else {LY_CHECK_RET(lydict_insert(PARSER_CTX(CTX), LEN ? WORD : "", LEN, &(TARGET)));}
Radek Krejci44ceedc2018-10-02 15:54:31 +020050
Radek Krejciceaf2122019-01-02 15:03:26 +010051/**
Michal Vasko63f3d842020-07-08 10:10:14 +020052 * @brief Read from the IN structure COUNT items. Also updates the indent value in yang parser context
Radek Krejciceaf2122019-01-02 15:03:26 +010053 * @param[in] CTX yang parser context to update its indent value.
Radek Krejciceaf2122019-01-02 15:03:26 +010054 * @param[in] COUNT number of items for which the DATA pointer is supposed to move on.
55 */
Radek Krejcid54412f2020-12-17 20:25:35 +010056#define MOVE_INPUT(CTX, COUNT) ly_in_skip((CTX)->in, COUNT);(CTX)->indent+=COUNT
Radek Krejcid5f2b5f2018-10-11 10:54:36 +020057
Michal Vaskoea5abea2018-09-18 13:10:54 +020058/**
aPieceka24a2252021-05-07 10:52:31 +020059 * @brief Loop through all substatements.
Michal Vaskoea5abea2018-09-18 13:10:54 +020060 *
Radek Krejci44ceedc2018-10-02 15:54:31 +020061 * @param[in] CTX yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +020062 * @param[out] KW YANG keyword read.
63 * @param[out] WORD Pointer to the keyword itself.
64 * @param[out] WORD_LEN Length of the keyword.
65 * @param[out] ERR Variable for error storing.
aPieceka24a2252021-05-07 10:52:31 +020066 * @param[in] SUC_CMD Command is applied if a semicolon is found, so no
67 * substatements are available. It is expected to contain a return or goto command.
68 * @param[in] ERR_CMD Command is applied if an error occurs before loop through
69 * substatements. It is expected to contain return or goto command.
Michal Vaskoea5abea2018-09-18 13:10:54 +020070 *
71 * @return In case there are no substatements or a fatal error encountered.
72 */
aPieceka24a2252021-05-07 10:52:31 +020073#define YANG_READ_SUBSTMT_FOR(CTX, KW, WORD, WORD_LEN, ERR, SUC_CMD, ERR_CMD) \
74 if ((ERR = get_keyword(CTX, &KW, &WORD, &WORD_LEN))) { \
75 ERR_CMD; \
76 } \
Radek Krejcid6b76452019-09-03 17:03:03 +020077 if (KW == LY_STMT_SYNTAX_SEMICOLON) { \
aPieceka24a2252021-05-07 10:52:31 +020078 SUC_CMD; \
Michal Vasko7fbc8162018-09-17 10:35:16 +020079 } \
Radek Krejcid6b76452019-09-03 17:03:03 +020080 if (KW != LY_STMT_SYNTAX_LEFT_BRACE) { \
David Sedlákb3077192019-06-19 10:55:37 +020081 LOGVAL_PARSER(CTX, LYVE_SYNTAX_YANG, "Invalid keyword \"%s\", expected \";\" or \"{\".", ly_stmt2str(KW)); \
aPieceka24a2252021-05-07 10:52:31 +020082 ERR = LY_EVALID; \
83 ERR_CMD; \
Michal Vasko7fbc8162018-09-17 10:35:16 +020084 } \
Radek Krejci33090f92020-12-17 20:12:46 +010085 for (ERR = get_keyword(CTX, &KW, &WORD, &WORD_LEN); \
Radek Krejcid6b76452019-09-03 17:03:03 +020086 !ERR && (KW != LY_STMT_SYNTAX_RIGHT_BRACE); \
Radek Krejci33090f92020-12-17 20:12:46 +010087 ERR = get_keyword(CTX, &KW, &WORD, &WORD_LEN))
Michal Vasko7fbc8162018-09-17 10:35:16 +020088
Radek Krejci33090f92020-12-17 20:12:46 +010089LY_ERR parse_container(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent,
Radek Krejci0f969882020-08-21 16:56:47 +020090 struct lysp_node **siblings);
Radek Krejci33090f92020-12-17 20:12:46 +010091LY_ERR parse_uses(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings);
92LY_ERR parse_choice(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings);
93LY_ERR parse_case(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings);
94LY_ERR parse_list(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings);
Radek Krejci2a9fc652021-01-22 17:44:34 +010095LY_ERR parse_grouping(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node_grp **groupings);
Michal Vasko7fbc8162018-09-17 10:35:16 +020096
Michal Vaskoea5abea2018-09-18 13:10:54 +020097/**
98 * @brief Add another character to dynamic buffer, a low-level function.
99 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200100 * Enlarge if needed. Updates \p input as well as \p buf_used.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200101 *
Radek Krejci404251e2018-10-09 12:06:44 +0200102 * @param[in] ctx libyang context for logging.
Michal Vasko63f3d842020-07-08 10:10:14 +0200103 * @param[in,out] in Input structure.
Radek Krejci44ceedc2018-10-02 15:54:31 +0200104 * @param[in] len Number of bytes to get from the input string and copy into the buffer.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200105 * @param[in,out] buf Buffer to use, can be moved by realloc().
106 * @param[in,out] buf_len Current size of the buffer.
Radek Krejci44ceedc2018-10-02 15:54:31 +0200107 * @param[in,out] buf_used Currently used characters of the buffer.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200108 *
109 * @return LY_ERR values.
110 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +0200111LY_ERR
Michal Vasko63f3d842020-07-08 10:10:14 +0200112buf_add_char(struct ly_ctx *ctx, struct ly_in *in, size_t len, char **buf, size_t *buf_len, size_t *buf_used)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200113{
Radek Krejcif13b87b2020-12-01 22:02:17 +0100114#define BUF_STEP 16;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200115 if (*buf_len <= (*buf_used) + len) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100116 *buf_len += BUF_STEP;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200117 *buf = ly_realloc(*buf, *buf_len);
118 LY_CHECK_ERR_RET(!*buf, LOGMEM(ctx), LY_EMEM);
119 }
Radek Krejcic0917392019-04-10 13:04:04 +0200120 if (*buf_used) {
Michal Vasko63f3d842020-07-08 10:10:14 +0200121 ly_in_read(in, &(*buf)[*buf_used], len);
Radek Krejcic0917392019-04-10 13:04:04 +0200122 } else {
Michal Vasko63f3d842020-07-08 10:10:14 +0200123 ly_in_read(in, *buf, len);
Radek Krejcic0917392019-04-10 13:04:04 +0200124 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200125
Radek Krejci44ceedc2018-10-02 15:54:31 +0200126 (*buf_used) += len;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200127 return LY_SUCCESS;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100128#undef BUF_STEP
Michal Vasko7fbc8162018-09-17 10:35:16 +0200129}
130
Michal Vaskoea5abea2018-09-18 13:10:54 +0200131/**
Radek Krejci44ceedc2018-10-02 15:54:31 +0200132 * @brief Store a single UTF8 character. It depends whether in a dynamically-allocated buffer or just as a pointer to the data.
133 *
134 * @param[in] ctx yang parser context for logging.
Radek Krejci44ceedc2018-10-02 15:54:31 +0200135 * @param[in] arg Type of the input string to select method of checking character validity.
136 * @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 +0200137 * 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 +0200138 * @param[in,out] word_len Current length of the word pointed to by \p word_p.
139 * @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 +0200140 * @param[in,out] buf_len Current length of \p word_b.
Radek Krejci44ceedc2018-10-02 15:54:31 +0200141 * @param[in] need_buf Flag if the dynamically allocated buffer is required.
David Sedlák40bb13b2019-07-10 14:34:18 +0200142 * @param[in,out] prefix Storage for internally used flag in case of possible prefixed identifiers:
143 * 0 - colon not yet found (no prefix)
144 * 1 - \p c is the colon character
145 * 2 - prefix already processed, now processing the identifier
Michal Vaskoea5abea2018-09-18 13:10:54 +0200146 *
147 * @return LY_ERR values.
148 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +0200149LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +0100150buf_store_char(struct lys_yang_parser_ctx *ctx, enum yang_arg arg, char **word_p, size_t *word_len,
Radek Krejci857189e2020-09-01 13:26:36 +0200151 char **word_b, size_t *buf_len, ly_bool need_buf, uint8_t *prefix)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200152{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200153 uint32_t c;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200154 size_t len;
155
Radek Krejcif29b7c32019-04-09 16:17:49 +0200156 /* check valid combination of input paremeters - if need_buf specified, word_b must be provided */
157 assert(!need_buf || (need_buf && word_b));
158
Radek Krejci44ceedc2018-10-02 15:54:31 +0200159 /* get UTF8 code point (and number of bytes coding the character) */
Radek Krejci33090f92020-12-17 20:12:46 +0100160 LY_CHECK_ERR_RET(ly_getutf8(&ctx->in->current, &c, &len),
161 LOGVAL_PARSER(ctx, LY_VCODE_INCHAR, ctx->in->current[-len]), LY_EVALID);
162 ctx->in->current -= len;
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200163 if (c == '\n') {
164 ctx->indent = 0;
Radek Krejcidd713ce2021-01-04 23:12:12 +0100165 LY_IN_NEW_LINE(ctx->in);
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200166 } else {
167 /* note - even the multibyte character is count as 1 */
168 ++ctx->indent;
169 }
170
Radek Krejci44ceedc2018-10-02 15:54:31 +0200171 /* check character validity */
172 switch (arg) {
173 case Y_IDENTIF_ARG:
Michal Vaskob36053d2020-03-26 15:49:30 +0100174 LY_CHECK_RET(lysp_check_identifierchar((struct lys_parser_ctx *)ctx, c, !(*word_len), NULL));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200175 break;
176 case Y_PREF_IDENTIF_ARG:
Michal Vaskob36053d2020-03-26 15:49:30 +0100177 LY_CHECK_RET(lysp_check_identifierchar((struct lys_parser_ctx *)ctx, c, !(*word_len), prefix));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200178 break;
179 case Y_STR_ARG:
180 case Y_MAYBE_STR_ARG:
Michal Vaskob36053d2020-03-26 15:49:30 +0100181 LY_CHECK_RET(lysp_check_stringchar((struct lys_parser_ctx *)ctx, c));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200182 break;
183 }
184
Michal Vasko7fbc8162018-09-17 10:35:16 +0200185 if (word_b && *word_b) {
186 /* add another character into buffer */
Radek Krejci33090f92020-12-17 20:12:46 +0100187 if (buf_add_char(PARSER_CTX(ctx), ctx->in, len, word_b, buf_len, word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200188 return LY_EMEM;
189 }
190
191 /* in case of realloc */
192 *word_p = *word_b;
Radek Krejcif29b7c32019-04-09 16:17:49 +0200193 } else if (word_b && need_buf) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200194 /* first time we need a buffer, copy everything read up to now */
195 if (*word_len) {
196 *word_b = malloc(*word_len);
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200197 LY_CHECK_ERR_RET(!*word_b, LOGMEM(PARSER_CTX(ctx)), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200198 *buf_len = *word_len;
199 memcpy(*word_b, *word_p, *word_len);
200 }
201
202 /* add this new character into buffer */
Radek Krejci33090f92020-12-17 20:12:46 +0100203 if (buf_add_char(PARSER_CTX(ctx), ctx->in, len, word_b, buf_len, word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200204 return LY_EMEM;
205 }
206
207 /* in case of realloc */
208 *word_p = *word_b;
209 } else {
210 /* just remember the first character pointer */
211 if (!*word_p) {
Radek Krejci33090f92020-12-17 20:12:46 +0100212 *word_p = (char *)ctx->in->current;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200213 }
Radek Krejci44ceedc2018-10-02 15:54:31 +0200214 /* ... and update the word's length */
215 (*word_len) += len;
Radek Krejci33090f92020-12-17 20:12:46 +0100216 ly_in_skip(ctx->in, len);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200217 }
218
219 return LY_SUCCESS;
220}
221
Michal Vaskoea5abea2018-09-18 13:10:54 +0200222/**
223 * @brief Skip YANG comment in data.
224 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200225 * @param[in] ctx yang parser context for logging.
Radek Krejci44ceedc2018-10-02 15:54:31 +0200226 * @param[in] comment Type of the comment to process:
227 * 1 for a one-line comment,
228 * 2 for a block comment.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200229 * @return LY_ERR values.
230 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +0200231LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +0100232skip_comment(struct lys_yang_parser_ctx *ctx, uint8_t comment)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200233{
Radek Krejcif13b87b2020-12-01 22:02:17 +0100234 /* internal statuses: */
235#define COMMENT_NO 0 /* comment ended */
236#define COMMENT_LINE 1 /* in line comment */
237#define COMMENT_BLOCK 2 /* in block comment */
238#define COMMENT_BLOCK_END 3 /* in block comment with last read character '*' */
239
Radek Krejci33090f92020-12-17 20:12:46 +0100240 while (ctx->in->current[0] && comment) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200241 switch (comment) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100242 case COMMENT_LINE:
Radek Krejci33090f92020-12-17 20:12:46 +0100243 if (ctx->in->current[0] == '\n') {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100244 comment = COMMENT_NO;
Radek Krejcid54412f2020-12-17 20:25:35 +0100245 LY_IN_NEW_LINE(ctx->in);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200246 }
247 break;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100248 case COMMENT_BLOCK:
Radek Krejci33090f92020-12-17 20:12:46 +0100249 if (ctx->in->current[0] == '*') {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100250 comment = COMMENT_BLOCK_END;
Radek Krejci33090f92020-12-17 20:12:46 +0100251 } else if (ctx->in->current[0] == '\n') {
Radek Krejcid54412f2020-12-17 20:25:35 +0100252 LY_IN_NEW_LINE(ctx->in);
Radek Krejci15c80ca2018-10-09 11:01:31 +0200253 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200254 break;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100255 case COMMENT_BLOCK_END:
Radek Krejci33090f92020-12-17 20:12:46 +0100256 if (ctx->in->current[0] == '/') {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100257 comment = COMMENT_NO;
Radek Krejci33090f92020-12-17 20:12:46 +0100258 } else if (ctx->in->current[0] != '*') {
259 if (ctx->in->current[0] == '\n') {
Radek Krejcid54412f2020-12-17 20:25:35 +0100260 LY_IN_NEW_LINE(ctx->in);
Radek Krejci44ceedc2018-10-02 15:54:31 +0200261 }
Radek Krejcif13b87b2020-12-01 22:02:17 +0100262 comment = COMMENT_BLOCK;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200263 }
264 break;
265 default:
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200266 LOGINT_RET(PARSER_CTX(ctx));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200267 }
268
Radek Krejci33090f92020-12-17 20:12:46 +0100269 if (ctx->in->current[0] == '\n') {
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200270 ctx->indent = 0;
271 } else {
272 ++ctx->indent;
273 }
Radek Krejci33090f92020-12-17 20:12:46 +0100274 ++ctx->in->current;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200275 }
276
Radek Krejci33090f92020-12-17 20:12:46 +0100277 if (!ctx->in->current[0] && (comment >= COMMENT_BLOCK)) {
David Sedlákb3077192019-06-19 10:55:37 +0200278 LOGVAL_PARSER(ctx, LYVE_SYNTAX, "Unexpected end-of-input, non-terminated comment.");
Michal Vasko7fbc8162018-09-17 10:35:16 +0200279 return LY_EVALID;
280 }
281
282 return LY_SUCCESS;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100283
284#undef COMMENT_NO
285#undef COMMENT_LINE
286#undef COMMENT_BLOCK
287#undef COMMENT_BLOCK_END
Michal Vasko7fbc8162018-09-17 10:35:16 +0200288}
289
Michal Vaskoea5abea2018-09-18 13:10:54 +0200290/**
291 * @brief Read a quoted string from data.
292 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200293 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200294 * @param[in] arg Type of YANG keyword argument expected.
295 * @param[out] word_p Pointer to the read quoted string.
296 * @param[out] word_b Pointer to a dynamically-allocated buffer holding the read quoted string. If not needed,
297 * set to NULL. Otherwise equal to \p word_p.
298 * @param[out] word_len Length of the read quoted string.
299 * @param[out] buf_len Length of the dynamically-allocated buffer \p word_b.
300 * @param[in] indent Current indent (number of YANG spaces). Needed for correct multi-line string
301 * indenation in the final quoted string.
302 *
303 * @return LY_ERR values.
304 */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200305static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +0100306read_qstring(struct lys_yang_parser_ctx *ctx, enum yang_arg arg, char **word_p, char **word_b,
Radek Krejci0f969882020-08-21 16:56:47 +0200307 size_t *word_len, size_t *buf_len)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200308{
Radek Krejcif13b87b2020-12-01 22:02:17 +0100309 /* string parsing status: */
310#define STRING_ENDED 0 /* string ended */
311#define STRING_SINGLE_QUOTED 1 /* string with ' */
312#define STRING_DOUBLE_QUOTED 2 /* string with " */
313#define STRING_DOUBLE_QUOTED_ESCAPED 3 /* string with " with last character \ */
314#define STRING_PAUSED_NEXTSTRING 4 /* string finished, now skipping whitespaces looking for + */
315#define STRING_PAUSED_CONTINUE 5 /* string continues after +, skipping whitespaces */
316
Radek Krejci1deb5be2020-08-26 16:43:36 +0200317 uint8_t string;
318 uint64_t block_indent = 0, current_indent = 0;
Radek Krejci857189e2020-09-01 13:26:36 +0200319 ly_bool need_buf = 0;
320 uint8_t prefix = 0;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200321 const char *c;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200322 uint64_t trailing_ws = 0; /* current number of stored trailing whitespace characters */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200323
Radek Krejci33090f92020-12-17 20:12:46 +0100324 if (ctx->in->current[0] == '\"') {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100325 string = STRING_DOUBLE_QUOTED;
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200326 current_indent = block_indent = ctx->indent + 1;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200327 } else {
Radek Krejci33090f92020-12-17 20:12:46 +0100328 assert(ctx->in->current[0] == '\'');
Radek Krejcif13b87b2020-12-01 22:02:17 +0100329 string = STRING_SINGLE_QUOTED;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200330 }
Radek Krejci33090f92020-12-17 20:12:46 +0100331 MOVE_INPUT(ctx, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200332
Radek Krejci33090f92020-12-17 20:12:46 +0100333 while (ctx->in->current[0] && string) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200334 switch (string) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100335 case STRING_SINGLE_QUOTED:
Radek Krejci33090f92020-12-17 20:12:46 +0100336 switch (ctx->in->current[0]) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200337 case '\'':
338 /* string may be finished, but check for + */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100339 string = STRING_PAUSED_NEXTSTRING;
Radek Krejci33090f92020-12-17 20:12:46 +0100340 MOVE_INPUT(ctx, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200341 break;
342 default:
343 /* check and store character */
Radek Krejci33090f92020-12-17 20:12:46 +0100344 LY_CHECK_RET(buf_store_char(ctx, arg, word_p, word_len, word_b, buf_len, need_buf, &prefix));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200345 break;
346 }
347 break;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100348 case STRING_DOUBLE_QUOTED:
Radek Krejci33090f92020-12-17 20:12:46 +0100349 switch (ctx->in->current[0]) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200350 case '\"':
351 /* string may be finished, but check for + */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100352 string = STRING_PAUSED_NEXTSTRING;
Radek Krejci33090f92020-12-17 20:12:46 +0100353 MOVE_INPUT(ctx, 1);
Radek Krejciff13cd12019-10-25 15:34:24 +0200354 trailing_ws = 0;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200355 break;
356 case '\\':
357 /* special character following */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100358 string = STRING_DOUBLE_QUOTED_ESCAPED;
Radek Krejciff13cd12019-10-25 15:34:24 +0200359
360 /* the backslash sequence is substituted, so we will need a buffer to store the result */
361 need_buf = 1;
362
363 /* move forward to the escaped character */
Radek Krejci33090f92020-12-17 20:12:46 +0100364 ++ctx->in->current;
Radek Krejciff13cd12019-10-25 15:34:24 +0200365
366 /* note that the trailing whitespaces are supposed to be trimmed before substitution of
367 * backslash-escaped characters (RFC 7950, 6.1.3), so we have to zero the trailing whitespaces counter */
368 trailing_ws = 0;
369
370 /* since the backslash-escaped character is handled as first non-whitespace character, stop eating indentation */
371 current_indent = block_indent;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200372 break;
373 case ' ':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200374 if (current_indent < block_indent) {
375 ++current_indent;
Radek Krejci33090f92020-12-17 20:12:46 +0100376 MOVE_INPUT(ctx, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200377 } else {
Michal Vasko90edde42019-11-25 15:25:07 +0100378 /* check and store whitespace character */
Radek Krejci33090f92020-12-17 20:12:46 +0100379 LY_CHECK_RET(buf_store_char(ctx, arg, word_p, word_len, word_b, buf_len, need_buf, &prefix));
Michal Vasko90edde42019-11-25 15:25:07 +0100380 trailing_ws++;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200381 }
382 break;
383 case '\t':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200384 if (current_indent < block_indent) {
385 assert(need_buf);
Radek Krejcif13b87b2020-12-01 22:02:17 +0100386 current_indent += Y_TAB_SPACES;
387 ctx->indent += Y_TAB_SPACES;
Michal Vaskod989ba02020-08-24 10:59:24 +0200388 for ( ; current_indent > block_indent; --current_indent, --ctx->indent) {
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200389 /* store leftover spaces from the tab */
Radek Krejci33090f92020-12-17 20:12:46 +0100390 c = ctx->in->current;
391 ctx->in->current = " ";
392 LY_CHECK_RET(buf_store_char(ctx, arg, word_p, word_len, word_b, buf_len, need_buf, &prefix));
393 ctx->in->current = c;
Michal Vasko90edde42019-11-25 15:25:07 +0100394 trailing_ws++;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200395 }
Radek Krejci33090f92020-12-17 20:12:46 +0100396 ++ctx->in->current;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200397 } else {
Michal Vasko90edde42019-11-25 15:25:07 +0100398 /* check and store whitespace character */
Radek Krejci33090f92020-12-17 20:12:46 +0100399 LY_CHECK_RET(buf_store_char(ctx, arg, word_p, word_len, word_b, buf_len, need_buf, &prefix));
Michal Vasko90edde42019-11-25 15:25:07 +0100400 trailing_ws++;
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200401 /* additional characters for indentation - only 1 was count in buf_store_char */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100402 ctx->indent += Y_TAB_SPACES - 1;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200403 }
404 break;
Michal Vaskoa6ecd0c2021-04-09 11:58:26 +0200405 case '\r':
406 if (ctx->in->current[1] != '\n') {
407 LOGVAL_PARSER(ctx, LY_VCODE_INCHAR, ctx->in->current[0]);
408 return LY_EVALID;
409 }
410 /* fallthrough */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200411 case '\n':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200412 if (block_indent) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200413 /* we will be removing the indents so we need our own buffer */
414 need_buf = 1;
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200415
416 /* remove trailing tabs and spaces */
Radek Krejciff13cd12019-10-25 15:34:24 +0200417 (*word_len) = *word_len - trailing_ws;
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200418
Radek Krejciff13cd12019-10-25 15:34:24 +0200419 /* restart indentation */
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200420 current_indent = 0;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200421 }
422
423 /* check and store character */
Radek Krejci33090f92020-12-17 20:12:46 +0100424 LY_CHECK_RET(buf_store_char(ctx, arg, word_p, word_len, word_b, buf_len, need_buf, &prefix));
Radek Krejci44ceedc2018-10-02 15:54:31 +0200425
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200426 /* reset context indentation counter for possible string after this one */
427 ctx->indent = 0;
Radek Krejciff13cd12019-10-25 15:34:24 +0200428 trailing_ws = 0;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200429 break;
430 default:
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200431 /* first non-whitespace character, stop eating indentation */
432 current_indent = block_indent;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200433
434 /* check and store character */
Radek Krejci33090f92020-12-17 20:12:46 +0100435 LY_CHECK_RET(buf_store_char(ctx, arg, word_p, word_len, word_b, buf_len, need_buf, &prefix));
Radek Krejciff13cd12019-10-25 15:34:24 +0200436 trailing_ws = 0;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200437 break;
438 }
439 break;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100440 case STRING_DOUBLE_QUOTED_ESCAPED:
Michal Vasko7fbc8162018-09-17 10:35:16 +0200441 /* string encoded characters */
Radek Krejci33090f92020-12-17 20:12:46 +0100442 c = ctx->in->current;
443 switch (ctx->in->current[0]) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200444 case 'n':
Radek Krejci33090f92020-12-17 20:12:46 +0100445 ctx->in->current = "\n";
Radek Krejcidd713ce2021-01-04 23:12:12 +0100446 /* fix false newline count in buf_store_char() */
447 ctx->in->line--;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200448 break;
449 case 't':
Radek Krejci33090f92020-12-17 20:12:46 +0100450 ctx->in->current = "\t";
Michal Vasko7fbc8162018-09-17 10:35:16 +0200451 break;
452 case '\"':
Michal Vasko7fbc8162018-09-17 10:35:16 +0200453 case '\\':
Michal Vasko63f3d842020-07-08 10:10:14 +0200454 /* ok as is */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200455 break;
456 default:
Michal Vasko63f3d842020-07-08 10:10:14 +0200457 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Double-quoted string unknown special character '\\%c'.",
Radek Krejci33090f92020-12-17 20:12:46 +0100458 ctx->in->current[0]);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200459 return LY_EVALID;
460 }
461
462 /* check and store character */
Radek Krejci33090f92020-12-17 20:12:46 +0100463 LY_CHECK_RET(buf_store_char(ctx, arg, word_p, word_len, word_b, buf_len, need_buf, &prefix));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200464
Radek Krejcif13b87b2020-12-01 22:02:17 +0100465 string = STRING_DOUBLE_QUOTED;
Radek Krejci33090f92020-12-17 20:12:46 +0100466 ctx->in->current = c + 1;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200467 break;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100468 case STRING_PAUSED_NEXTSTRING:
Radek Krejci33090f92020-12-17 20:12:46 +0100469 switch (ctx->in->current[0]) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200470 case '+':
471 /* string continues */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100472 string = STRING_PAUSED_CONTINUE;
Radek Krejciefd22f62018-09-27 11:47:58 +0200473 need_buf = 1;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200474 break;
Michal Vaskoa6ecd0c2021-04-09 11:58:26 +0200475 case '\r':
476 if (ctx->in->current[1] != '\n') {
477 LOGVAL_PARSER(ctx, LY_VCODE_INCHAR, ctx->in->current[0]);
478 return LY_EVALID;
479 }
480 MOVE_INPUT(ctx, 1);
481 /* fallthrough */
Radek Krejci44ceedc2018-10-02 15:54:31 +0200482 case '\n':
Radek Krejcidd713ce2021-01-04 23:12:12 +0100483 LY_IN_NEW_LINE(ctx->in);
Radek Krejcicb3e6472021-01-06 08:19:01 +0100484 /* fall through */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200485 case ' ':
486 case '\t':
Michal Vasko7fbc8162018-09-17 10:35:16 +0200487 /* just skip */
488 break;
489 default:
490 /* string is finished */
491 goto string_end;
492 }
Radek Krejci33090f92020-12-17 20:12:46 +0100493 MOVE_INPUT(ctx, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200494 break;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100495 case STRING_PAUSED_CONTINUE:
Radek Krejci33090f92020-12-17 20:12:46 +0100496 switch (ctx->in->current[0]) {
Michal Vaskoa6ecd0c2021-04-09 11:58:26 +0200497 case '\r':
498 if (ctx->in->current[1] != '\n') {
499 LOGVAL_PARSER(ctx, LY_VCODE_INCHAR, ctx->in->current[0]);
500 return LY_EVALID;
501 }
502 MOVE_INPUT(ctx, 1);
503 /* fallthrough */
Radek Krejci44ceedc2018-10-02 15:54:31 +0200504 case '\n':
Radek Krejcidd713ce2021-01-04 23:12:12 +0100505 LY_IN_NEW_LINE(ctx->in);
Radek Krejcicb3e6472021-01-06 08:19:01 +0100506 /* fall through */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200507 case ' ':
508 case '\t':
Michal Vasko7fbc8162018-09-17 10:35:16 +0200509 /* skip */
510 break;
511 case '\'':
Radek Krejcif13b87b2020-12-01 22:02:17 +0100512 string = STRING_SINGLE_QUOTED;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200513 break;
514 case '\"':
Radek Krejcif13b87b2020-12-01 22:02:17 +0100515 string = STRING_DOUBLE_QUOTED;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200516 break;
517 default:
518 /* it must be quoted again */
David Sedlákb3077192019-06-19 10:55:37 +0200519 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Both string parts divided by '+' must be quoted.");
Michal Vasko7fbc8162018-09-17 10:35:16 +0200520 return LY_EVALID;
521 }
Radek Krejci33090f92020-12-17 20:12:46 +0100522 MOVE_INPUT(ctx, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200523 break;
524 default:
525 return LY_EINT;
526 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200527 }
528
529string_end:
Michal Vasko69730152020-10-09 16:30:07 +0200530 if ((arg <= Y_PREF_IDENTIF_ARG) && !(*word_len)) {
Radek Krejci4e199f52019-05-28 09:09:28 +0200531 /* empty identifier */
David Sedlákb3077192019-06-19 10:55:37 +0200532 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Statement argument is required.");
Radek Krejci4e199f52019-05-28 09:09:28 +0200533 return LY_EVALID;
534 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200535 return LY_SUCCESS;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100536
537#undef STRING_ENDED
538#undef STRING_SINGLE_QUOTED
539#undef STRING_DOUBLE_QUOTED
540#undef STRING_DOUBLE_QUOTED_ESCAPED
541#undef STRING_PAUSED_NEXTSTRING
542#undef STRING_PAUSED_CONTINUE
Michal Vasko7fbc8162018-09-17 10:35:16 +0200543}
544
Michal Vaskoea5abea2018-09-18 13:10:54 +0200545/**
546 * @brief Get another YANG string from the raw data.
547 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200548 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200549 * @param[in] arg Type of YANG keyword argument expected.
Michal Vaskob68ea142021-04-26 13:46:00 +0200550 * @param[out] flags optional output argument to get flag of the argument's quoting (LYS_*QUOTED - see
551 * [schema node flags](@ref snodeflags))
Michal Vasko2ca70f52018-09-27 11:04:51 +0200552 * @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 +0200553 * @param[out] word_b Pointer to a dynamically-allocated buffer holding the read string. If not needed,
554 * set to NULL. Otherwise equal to \p word_p.
555 * @param[out] word_len Length of the read string.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200556 * @return LY_ERR values.
Michal Vasko7fbc8162018-09-17 10:35:16 +0200557 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +0200558LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +0100559get_argument(struct lys_yang_parser_ctx *ctx, enum yang_arg arg, uint16_t *flags, char **word_p,
Radek Krejci0f969882020-08-21 16:56:47 +0200560 char **word_b, size_t *word_len)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200561{
Michal Vaskob68ea142021-04-26 13:46:00 +0200562 LY_ERR ret;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200563 size_t buf_len = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200564 uint8_t prefix = 0;
Michal Vasko69730152020-10-09 16:30:07 +0200565
Michal Vasko7fbc8162018-09-17 10:35:16 +0200566 /* word buffer - dynamically allocated */
567 *word_b = NULL;
568
569 /* word pointer - just a pointer to data */
570 *word_p = NULL;
571
572 *word_len = 0;
Radek Krejci33090f92020-12-17 20:12:46 +0100573 while (ctx->in->current[0]) {
574 switch (ctx->in->current[0]) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200575 case '\'':
576 case '\"':
577 if (*word_len) {
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200578 /* invalid - quotes cannot be in unquoted string and only optsep, ; or { can follow it */
Radek Krejci33090f92020-12-17 20:12:46 +0100579 LOGVAL_PARSER(ctx, LY_VCODE_INSTREXP, 1, ctx->in->current,
Michal Vasko69730152020-10-09 16:30:07 +0200580 "unquoted string character, optsep, semicolon or opening brace");
Michal Vaskob68ea142021-04-26 13:46:00 +0200581 ret = LY_EVALID;
582 goto error;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200583 }
Radek Krejcid3ca0632019-04-16 16:54:54 +0200584 if (flags) {
Radek Krejci33090f92020-12-17 20:12:46 +0100585 (*flags) |= ctx->in->current[0] == '\'' ? LYS_SINGLEQUOTED : LYS_DOUBLEQUOTED;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200586 }
Michal Vaskob68ea142021-04-26 13:46:00 +0200587 LY_CHECK_GOTO(ret = read_qstring(ctx, arg, word_p, word_b, word_len, &buf_len), error);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200588 goto str_end;
589 case '/':
Radek Krejci33090f92020-12-17 20:12:46 +0100590 if (ctx->in->current[1] == '/') {
Radek Krejci44ceedc2018-10-02 15:54:31 +0200591 /* one-line comment */
Radek Krejci33090f92020-12-17 20:12:46 +0100592 MOVE_INPUT(ctx, 2);
Michal Vaskob68ea142021-04-26 13:46:00 +0200593 LY_CHECK_GOTO(ret = skip_comment(ctx, 1), error);
Radek Krejci33090f92020-12-17 20:12:46 +0100594 } else if (ctx->in->current[1] == '*') {
Radek Krejci44ceedc2018-10-02 15:54:31 +0200595 /* block comment */
Radek Krejci33090f92020-12-17 20:12:46 +0100596 MOVE_INPUT(ctx, 2);
Michal Vaskob68ea142021-04-26 13:46:00 +0200597 LY_CHECK_GOTO(ret = skip_comment(ctx, 2), error);
Radek Krejci44ceedc2018-10-02 15:54:31 +0200598 } else {
599 /* not a comment after all */
Michal Vaskob68ea142021-04-26 13:46:00 +0200600 LY_CHECK_GOTO(ret = buf_store_char(ctx, arg, word_p, word_len, word_b, &buf_len, 0, &prefix), error);
Radek Krejci44ceedc2018-10-02 15:54:31 +0200601 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200602 break;
603 case ' ':
604 if (*word_len) {
605 /* word is finished */
606 goto str_end;
607 }
Radek Krejci33090f92020-12-17 20:12:46 +0100608 MOVE_INPUT(ctx, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200609 break;
610 case '\t':
611 if (*word_len) {
612 /* word is finished */
613 goto str_end;
614 }
615 /* tabs count for 8 spaces */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100616 ctx->indent += Y_TAB_SPACES;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200617
Radek Krejci33090f92020-12-17 20:12:46 +0100618 ++ctx->in->current;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200619 break;
Michal Vaskoa6ecd0c2021-04-09 11:58:26 +0200620 case '\r':
621 if (ctx->in->current[1] != '\n') {
622 LOGVAL_PARSER(ctx, LY_VCODE_INCHAR, ctx->in->current[0]);
Michal Vaskob68ea142021-04-26 13:46:00 +0200623 ret = LY_EVALID;
624 goto error;
Michal Vaskoa6ecd0c2021-04-09 11:58:26 +0200625 }
626 MOVE_INPUT(ctx, 1);
627 /* fallthrough */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200628 case '\n':
629 if (*word_len) {
630 /* word is finished */
631 goto str_end;
632 }
Radek Krejcidd713ce2021-01-04 23:12:12 +0100633 LY_IN_NEW_LINE(ctx->in);
Radek Krejcid54412f2020-12-17 20:25:35 +0100634 MOVE_INPUT(ctx, 1);
635
Michal Vasko7fbc8162018-09-17 10:35:16 +0200636 /* reset indent */
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200637 ctx->indent = 0;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200638 break;
639 case ';':
640 case '{':
641 if (*word_len || (arg == Y_MAYBE_STR_ARG)) {
642 /* word is finished */
643 goto str_end;
644 }
645
Radek Krejci33090f92020-12-17 20:12:46 +0100646 LOGVAL_PARSER(ctx, LY_VCODE_INSTREXP, 1, ctx->in->current, "an argument");
Michal Vaskob68ea142021-04-26 13:46:00 +0200647 ret = LY_EVALID;
648 goto error;
Radek Krejcifc62d7e2018-10-11 12:56:42 +0200649 case '}':
650 /* invalid - braces cannot be in unquoted string (opening braces terminates the string and can follow it) */
Radek Krejci33090f92020-12-17 20:12:46 +0100651 LOGVAL_PARSER(ctx, LY_VCODE_INSTREXP, 1, ctx->in->current,
Michal Vasko69730152020-10-09 16:30:07 +0200652 "unquoted string character, optsep, semicolon or opening brace");
Michal Vaskob68ea142021-04-26 13:46:00 +0200653 ret = LY_EVALID;
654 goto error;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200655 default:
Michal Vaskob68ea142021-04-26 13:46:00 +0200656 LY_CHECK_GOTO(ret = buf_store_char(ctx, arg, word_p, word_len, word_b, &buf_len, 0, &prefix), error);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200657 break;
658 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200659 }
660
Radek Krejci0a1d0d42019-05-16 15:14:51 +0200661 /* unexpected end of loop */
David Sedlákb3077192019-06-19 10:55:37 +0200662 LOGVAL_PARSER(ctx, LY_VCODE_EOF);
Michal Vaskob68ea142021-04-26 13:46:00 +0200663 ret = LY_EVALID;
664 goto error;
Radek Krejci0a1d0d42019-05-16 15:14:51 +0200665
Michal Vasko7fbc8162018-09-17 10:35:16 +0200666str_end:
Radek Krejci44ceedc2018-10-02 15:54:31 +0200667 /* terminating NULL byte for buf */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200668 if (*word_b) {
Radek Krejci44ceedc2018-10-02 15:54:31 +0200669 (*word_b) = ly_realloc(*word_b, (*word_len) + 1);
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200670 LY_CHECK_ERR_RET(!(*word_b), LOGMEM(PARSER_CTX(ctx)), LY_EMEM);
Radek Krejci44ceedc2018-10-02 15:54:31 +0200671 (*word_b)[*word_len] = '\0';
Michal Vasko7fbc8162018-09-17 10:35:16 +0200672 *word_p = *word_b;
673 }
674
675 return LY_SUCCESS;
Michal Vaskob68ea142021-04-26 13:46:00 +0200676
677error:
678 free(*word_b);
679 *word_b = NULL;
680 return ret;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200681}
682
Michal Vaskoea5abea2018-09-18 13:10:54 +0200683/**
684 * @brief Get another YANG keyword from the raw data.
685 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200686 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200687 * @param[out] kw YANG keyword read.
688 * @param[out] word_p Pointer to the keyword in the data. Useful for extension instances.
689 * @param[out] word_len Length of the keyword in the data. Useful for extension instances.
690 *
691 * @return LY_ERR values.
692 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +0200693LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +0100694get_keyword(struct lys_yang_parser_ctx *ctx, enum ly_stmt *kw, char **word_p, size_t *word_len)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200695{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200696 uint8_t prefix;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200697 const char *word_start;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200698 size_t len;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200699
700 if (word_p) {
701 *word_p = NULL;
702 *word_len = 0;
703 }
704
705 /* first skip "optsep", comments */
Radek Krejci33090f92020-12-17 20:12:46 +0100706 while (ctx->in->current[0]) {
707 switch (ctx->in->current[0]) {
Radek Krejcidcc7b322018-10-11 14:24:02 +0200708 case '/':
Radek Krejci33090f92020-12-17 20:12:46 +0100709 if (ctx->in->current[1] == '/') {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200710 /* one-line comment */
Radek Krejci33090f92020-12-17 20:12:46 +0100711 MOVE_INPUT(ctx, 2);
712 LY_CHECK_RET(skip_comment(ctx, 1));
713 } else if (ctx->in->current[1] == '*') {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200714 /* block comment */
Radek Krejci33090f92020-12-17 20:12:46 +0100715 MOVE_INPUT(ctx, 2);
716 LY_CHECK_RET(skip_comment(ctx, 2));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200717 } else {
Radek Krejcidcc7b322018-10-11 14:24:02 +0200718 /* error - not a comment after all, keyword cannot start with slash */
David Sedlákb3077192019-06-19 10:55:37 +0200719 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid identifier first character '/'.");
Radek Krejcidcc7b322018-10-11 14:24:02 +0200720 return LY_EVALID;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200721 }
Radek Krejci13028282019-06-11 14:56:48 +0200722 continue;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200723 case '\n':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200724 /* skip whitespaces (optsep) */
Radek Krejcidd713ce2021-01-04 23:12:12 +0100725 LY_IN_NEW_LINE(ctx->in);
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200726 ctx->indent = 0;
727 break;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200728 case ' ':
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200729 /* skip whitespaces (optsep) */
730 ++ctx->indent;
731 break;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200732 case '\t':
Michal Vasko7fbc8162018-09-17 10:35:16 +0200733 /* skip whitespaces (optsep) */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100734 ctx->indent += Y_TAB_SPACES;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200735 break;
Michal Vasko50dcbc22021-03-25 12:21:20 +0100736 case '\r':
737 /* possible CRLF endline */
738 if (ctx->in->current[1] == '\n') {
739 break;
740 }
Radek Krejcid43298b2021-03-25 16:17:15 +0100741 /* fallthrough */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200742 default:
743 /* either a keyword start or an invalid character */
744 goto keyword_start;
745 }
746
Radek Krejci33090f92020-12-17 20:12:46 +0100747 ly_in_skip(ctx->in, 1);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200748 }
749
750keyword_start:
Radek Krejci33090f92020-12-17 20:12:46 +0100751 word_start = ctx->in->current;
Radek Krejcid54412f2020-12-17 20:25:35 +0100752 *kw = lysp_match_kw(ctx->in, &ctx->indent);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200753
aPiecek93582ed2021-05-25 14:49:06 +0200754 if (*kw == LY_STMT_SYNTAX_SEMICOLON) {
755 goto success;
756 } else if (*kw == LY_STMT_SYNTAX_LEFT_BRACE) {
757 ctx->depth++;
758 if (ctx->depth > LY_MAX_BLOCK_DEPTH) {
759 LOGERR(ctx->parsed_mod->mod->ctx, LY_EINVAL,
760 "The maximum number of block nestings has been exceeded.");
761 return LY_EINVAL;
762 }
763 goto success;
764 } else if (*kw == LY_STMT_SYNTAX_RIGHT_BRACE) {
765 ctx->depth--;
Radek Krejci626df482018-10-11 15:06:31 +0200766 goto success;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200767 }
768
Radek Krejcid6b76452019-09-03 17:03:03 +0200769 if (*kw != LY_STMT_NONE) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200770 /* make sure we have the whole keyword */
Radek Krejci33090f92020-12-17 20:12:46 +0100771 switch (ctx->in->current[0]) {
Michal Vaskoa6ecd0c2021-04-09 11:58:26 +0200772 case '\r':
773 if (ctx->in->current[1] != '\n') {
774 LOGVAL_PARSER(ctx, LY_VCODE_INCHAR, ctx->in->current[0]);
775 return LY_EVALID;
776 }
777 MOVE_INPUT(ctx, 1);
778 /* fallthrough */
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200779 case '\n':
Michal Vasko7fbc8162018-09-17 10:35:16 +0200780 case '\t':
Radek Krejciabdd8062019-06-11 16:44:19 +0200781 case ' ':
782 /* mandatory "sep" is just checked, not eaten so nothing in the context is updated */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200783 break;
Radek Krejci156ccaf2018-10-15 15:49:17 +0200784 case ':':
785 /* keyword is not actually a keyword, but prefix of an extension.
786 * To avoid repeated check of the prefix syntax, move to the point where the colon was read
787 * and we will be checking the keyword (extension instance) itself */
788 prefix = 1;
Radek Krejci33090f92020-12-17 20:12:46 +0100789 MOVE_INPUT(ctx, 1);
Radek Krejci156ccaf2018-10-15 15:49:17 +0200790 goto extension;
Radek Krejcidcc7b322018-10-11 14:24:02 +0200791 case '{':
792 /* allowed only for input and output statements which can be without arguments */
Michal Vasko69730152020-10-09 16:30:07 +0200793 if ((*kw == LY_STMT_INPUT) || (*kw == LY_STMT_OUTPUT)) {
Radek Krejcidcc7b322018-10-11 14:24:02 +0200794 break;
795 }
Radek Krejcif13b87b2020-12-01 22:02:17 +0100796 /* fall through */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200797 default:
Radek Krejci33090f92020-12-17 20:12:46 +0100798 MOVE_INPUT(ctx, 1);
799 LOGVAL_PARSER(ctx, LY_VCODE_INSTREXP, (int)(ctx->in->current - word_start), word_start,
Michal Vasko69730152020-10-09 16:30:07 +0200800 "a keyword followed by a separator");
Michal Vasko7fbc8162018-09-17 10:35:16 +0200801 return LY_EVALID;
802 }
803 } else {
804 /* still can be an extension */
805 prefix = 0;
Michal Vaskoa6ecd0c2021-04-09 11:58:26 +0200806
Radek Krejci156ccaf2018-10-15 15:49:17 +0200807extension:
Radek Krejcid54412f2020-12-17 20:25:35 +0100808 while (ctx->in->current[0] && (ctx->in->current[0] != ' ') && (ctx->in->current[0] != '\t') &&
Michal Vaskoa6ecd0c2021-04-09 11:58:26 +0200809 (ctx->in->current[0] != '\n') && (ctx->in->current[0] != '\r') && (ctx->in->current[0] != '{') &&
810 (ctx->in->current[0] != ';')) {
Radek Krejci1deb5be2020-08-26 16:43:36 +0200811 uint32_t c = 0;
812
Radek Krejci33090f92020-12-17 20:12:46 +0100813 LY_CHECK_ERR_RET(ly_getutf8(&ctx->in->current, &c, &len),
814 LOGVAL_PARSER(ctx, LY_VCODE_INCHAR, ctx->in->current[-len]), LY_EVALID);
Radek Krejcid5f2b5f2018-10-11 10:54:36 +0200815 ++ctx->indent;
Radek Krejci44ceedc2018-10-02 15:54:31 +0200816 /* check character validity */
Michal Vasko63f3d842020-07-08 10:10:14 +0200817 LY_CHECK_RET(lysp_check_identifierchar((struct lys_parser_ctx *)ctx, c,
Radek Krejci33090f92020-12-17 20:12:46 +0100818 ctx->in->current - len == word_start ? 1 : 0, &prefix));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200819 }
Radek Krejci33090f92020-12-17 20:12:46 +0100820 if (!ctx->in->current[0]) {
David Sedlákb3077192019-06-19 10:55:37 +0200821 LOGVAL_PARSER(ctx, LY_VCODE_EOF);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200822 return LY_EVALID;
823 }
824
825 /* prefix is mandatory for extension instances */
Radek Krejcidcc7b322018-10-11 14:24:02 +0200826 if (prefix != 2) {
Radek Krejci33090f92020-12-17 20:12:46 +0100827 LOGVAL_PARSER(ctx, LY_VCODE_INSTREXP, (int)(ctx->in->current - word_start), word_start, "a keyword");
Michal Vasko7fbc8162018-09-17 10:35:16 +0200828 return LY_EVALID;
829 }
830
Radek Krejcid6b76452019-09-03 17:03:03 +0200831 *kw = LY_STMT_EXTENSION_INSTANCE;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200832 }
Michal Vaskoa6ecd0c2021-04-09 11:58:26 +0200833
Radek Krejci626df482018-10-11 15:06:31 +0200834success:
Michal Vasko7fbc8162018-09-17 10:35:16 +0200835 if (word_p) {
836 *word_p = (char *)word_start;
Radek Krejci33090f92020-12-17 20:12:46 +0100837 *word_len = ctx->in->current - word_start;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200838 }
839
840 return LY_SUCCESS;
841}
842
Michal Vaskoea5abea2018-09-18 13:10:54 +0200843/**
844 * @brief Parse extension instance substatements.
845 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200846 * @param[in] ctx yang parser context for logging.
Radek Krejci335332a2019-09-05 13:03:35 +0200847 * @param[in] kw Statement keyword value matching @p word value.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200848 * @param[in] word Extension instance substatement name (keyword).
849 * @param[in] word_len Extension instance substatement name length.
850 * @param[in,out] child Children of this extension instance to add to.
851 *
852 * @return LY_ERR values.
853 */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200854static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +0100855parse_ext_substmt(struct lys_yang_parser_ctx *ctx, enum ly_stmt kw, char *word, size_t word_len,
Radek Krejci0f969882020-08-21 16:56:47 +0200856 struct lysp_stmt **child)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200857{
858 char *buf;
Radek Krejci6d9b9b52018-11-02 12:43:39 +0100859 LY_ERR ret = LY_SUCCESS;
Radek Krejci335332a2019-09-05 13:03:35 +0200860 enum ly_stmt child_kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200861 struct lysp_stmt *stmt, *par_child;
862
863 stmt = calloc(1, sizeof *stmt);
864 LY_CHECK_ERR_RET(!stmt, LOGMEM(NULL), LY_EMEM);
865
Radek Krejcibb9b1982019-04-08 14:24:59 +0200866 /* insert into parent statements */
867 if (!*child) {
868 *child = stmt;
869 } else {
Radek Krejci1e008d22020-08-17 11:37:37 +0200870 for (par_child = *child; par_child->next; par_child = par_child->next) {}
Radek Krejcibb9b1982019-04-08 14:24:59 +0200871 par_child->next = stmt;
872 }
873
Michal Vaskofc2cd072021-02-24 13:17:17 +0100874 /* statement */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200875 LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), word, word_len, &stmt->stmt));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200876
877 /* get optional argument */
Radek Krejci33090f92020-12-17 20:12:46 +0100878 LY_CHECK_RET(get_argument(ctx, Y_MAYBE_STR_ARG, &stmt->flags, &word, &buf, &word_len));
Radek Krejci0ae092d2018-09-20 16:43:19 +0200879 if (word) {
aPieceka24a2252021-05-07 10:52:31 +0200880 INSERT_WORD_RET(ctx, buf, stmt->arg, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200881 }
882
Radek Krejci8df109d2021-04-23 12:19:08 +0200883 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +0100884 stmt->prefix_data = ctx->parsed_mod;
885 stmt->kw = kw;
886
aPieceka24a2252021-05-07 10:52:31 +0200887 YANG_READ_SUBSTMT_FOR(ctx, child_kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Radek Krejci33090f92020-12-17 20:12:46 +0100888 LY_CHECK_RET(parse_ext_substmt(ctx, child_kw, word, word_len, &stmt->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200889 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200890 return ret;
891}
892
Michal Vaskoea5abea2018-09-18 13:10:54 +0200893/**
894 * @brief Parse extension instance.
895 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200896 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200897 * @param[in] ext_name Extension instance substatement name (keyword).
898 * @param[in] ext_name_len Extension instance substatement name length.
Radek Krejcifc596f92021-02-26 22:40:26 +0100899 * @param[in] insubstmt The statement this extension instance is a substatement of.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200900 * @param[in] insubstmt_index Index of the keyword instance this extension instance is a substatement of.
901 * @param[in,out] exts Extension instances to add to.
902 *
903 * @return LY_ERR values.
904 */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200905static LY_ERR
Radek Krejcifc596f92021-02-26 22:40:26 +0100906parse_ext(struct lys_yang_parser_ctx *ctx, const char *ext_name, size_t ext_name_len, enum ly_stmt insubstmt,
Radek Krejci0f969882020-08-21 16:56:47 +0200907 LY_ARRAY_COUNT_TYPE insubstmt_index, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200908{
Radek Krejci6d9b9b52018-11-02 12:43:39 +0100909 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200910 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +0200911 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200912 struct lysp_ext_instance *e;
Radek Krejcid6b76452019-09-03 17:03:03 +0200913 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200914
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200915 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *exts, e, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200916
Michal Vaskofc2cd072021-02-24 13:17:17 +0100917 if (!ly_strnchr(ext_name, ':', ext_name_len)) {
918 LOGVAL_PARSER(ctx, LYVE_SYNTAX, "Extension instance \"%*.s\" without the mandatory prefix.", ext_name_len, ext_name);
919 return LY_EVALID;
920 }
921
922 /* store name */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200923 LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), ext_name, ext_name_len, &e->name));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200924
925 /* get optional argument */
Radek Krejci33090f92020-12-17 20:12:46 +0100926 LY_CHECK_RET(get_argument(ctx, Y_MAYBE_STR_ARG, NULL, &word, &buf, &word_len));
Radek Krejci0ae092d2018-09-20 16:43:19 +0200927 if (word) {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200928 INSERT_WORD_RET(ctx, buf, e->argument, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200929 }
930
Michal Vaskofc2cd072021-02-24 13:17:17 +0100931 /* store the rest of information */
Radek Krejci8df109d2021-04-23 12:19:08 +0200932 e->format = LY_VALUE_SCHEMA;
aPiecek60d9d672021-04-27 15:49:57 +0200933 e->parsed = NULL;
Michal Vaskofc2cd072021-02-24 13:17:17 +0100934 e->prefix_data = ctx->parsed_mod;
Radek Krejciab430862021-03-02 20:13:40 +0100935 e->parent_stmt = insubstmt;
936 e->parent_stmt_index = insubstmt_index;
Michal Vaskofc2cd072021-02-24 13:17:17 +0100937
aPieceka24a2252021-05-07 10:52:31 +0200938 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Radek Krejci33090f92020-12-17 20:12:46 +0100939 LY_CHECK_RET(parse_ext_substmt(ctx, kw, word, word_len, &e->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200940 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200941 return ret;
942}
943
Michal Vaskoea5abea2018-09-18 13:10:54 +0200944/**
945 * @brief Parse a generic text field without specific constraints. Those are contact, organization,
946 * description, etc...
947 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200948 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200949 * @param[in] substmt Type of this substatement.
950 * @param[in] substmt_index Index of this substatement.
951 * @param[in,out] value Place to store the parsed value.
952 * @param[in] arg Type of the YANG keyword argument (of the value).
953 * @param[in,out] exts Extension instances to add to.
954 *
955 * @return LY_ERR values.
956 */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200957static LY_ERR
Radek Krejcifc596f92021-02-26 22:40:26 +0100958parse_text_field(struct lys_yang_parser_ctx *ctx, enum ly_stmt substmt, uint32_t substmt_index,
Radek Krejci0f969882020-08-21 16:56:47 +0200959 const char **value, enum yang_arg arg, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +0200960{
Radek Krejci6d9b9b52018-11-02 12:43:39 +0100961 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200962 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +0200963 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +0200964 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +0200965
966 if (*value) {
Radek Krejci3972b332021-03-02 16:34:31 +0100967 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, ly_stmt2str(substmt));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200968 return LY_EVALID;
969 }
970
971 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +0100972 LY_CHECK_RET(get_argument(ctx, arg, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200973
974 /* store value and spend buf if allocated */
Radek Krejci011e4aa2020-09-04 15:22:31 +0200975 INSERT_WORD_RET(ctx, buf, *value, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +0200976
aPieceka24a2252021-05-07 10:52:31 +0200977 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +0200978 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +0200979 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci33090f92020-12-17 20:12:46 +0100980 LY_CHECK_RET(parse_ext(ctx, word, word_len, substmt, substmt_index, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200981 break;
982 default:
Radek Krejci3972b332021-03-02 16:34:31 +0100983 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(substmt));
Michal Vasko7fbc8162018-09-17 10:35:16 +0200984 return LY_EVALID;
985 }
986 }
Michal Vasko7fbc8162018-09-17 10:35:16 +0200987 return ret;
988}
989
Michal Vaskoea5abea2018-09-18 13:10:54 +0200990/**
991 * @brief Parse the yang-version statement.
992 *
Radek Krejci44ceedc2018-10-02 15:54:31 +0200993 * @param[in] ctx yang parser context for logging.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100994 * @param[out] version Storage for the parsed information.
Michal Vasko63f3d842020-07-08 10:10:14 +0200995 * @param[in,out] exts Extension instances to add to.
Michal Vaskoea5abea2018-09-18 13:10:54 +0200996 *
997 * @return LY_ERR values.
998 */
Michal Vasko7fbc8162018-09-17 10:35:16 +0200999static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001000parse_yangversion(struct lys_yang_parser_ctx *ctx, uint8_t *version, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001001{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001002 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001003 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001004 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001005 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001006
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001007 if (*version) {
David Sedlákb3077192019-06-19 10:55:37 +02001008 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "yang-version");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001009 return LY_EVALID;
1010 }
1011
1012 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001013 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001014
Radek Krejci96e48da2020-09-04 13:18:06 +02001015 if ((word_len == 1) && !strncmp(word, "1", word_len)) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001016 *version = LYS_VERSION_1_0;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001017 } else if ((word_len == ly_strlen_const("1.1")) && !strncmp(word, "1.1", word_len)) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001018 *version = LYS_VERSION_1_1;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001019 } else {
David Sedlákb3077192019-06-19 10:55:37 +02001020 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "yang-version");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001021 free(buf);
1022 return LY_EVALID;
1023 }
1024 free(buf);
1025
aPieceka24a2252021-05-07 10:52:31 +02001026 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001027 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001028 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001029 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_YANG_VERSION, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001030 break;
1031 default:
David Sedlákb3077192019-06-19 10:55:37 +02001032 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "yang-version");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001033 return LY_EVALID;
1034 }
1035 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001036 return ret;
1037}
1038
Michal Vaskoea5abea2018-09-18 13:10:54 +02001039/**
1040 * @brief Parse the belongs-to statement.
1041 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001042 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001043 * @param[in,out] prefix Place to store the parsed belongs-to prefix value.
1044 * @param[in,out] exts Extension instances to add to.
1045 *
1046 * @return LY_ERR values.
1047 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001048static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001049parse_belongsto(struct lys_yang_parser_ctx *ctx, const char **prefix, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001050{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001051 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001052 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001053 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001054 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001055
Michal Vaskoc3781c32020-10-06 14:04:08 +02001056 if (*prefix) {
David Sedlákb3077192019-06-19 10:55:37 +02001057 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "belongs-to");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001058 return LY_EVALID;
1059 }
1060
Michal Vaskoc3781c32020-10-06 14:04:08 +02001061 /* get value, it must match the main module */
Radek Krejci33090f92020-12-17 20:12:46 +01001062 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001063 if (ly_strncmp(ctx->parsed_mod->mod->name, word, word_len)) {
Michal Vaskoc3781c32020-10-06 14:04:08 +02001064 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Submodule \"belongs-to\" value \"%.*s\" does not match its module name \"%s\".",
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001065 (int)word_len, word, ctx->parsed_mod->mod->name);
Michal Vaskoc3781c32020-10-06 14:04:08 +02001066 free(buf);
1067 return LY_EVALID;
1068 }
1069 free(buf);
Radek Krejcif09e4e82019-06-14 15:08:11 +02001070
aPieceka24a2252021-05-07 10:52:31 +02001071 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001072 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001073 case LY_STMT_PREFIX:
Radek Krejcifc596f92021-02-26 22:40:26 +01001074 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_PREFIX, 0, prefix, Y_IDENTIF_ARG, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001075 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001076 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001077 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_BELONGS_TO, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001078 break;
1079 default:
David Sedlákb3077192019-06-19 10:55:37 +02001080 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "belongs-to");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001081 return LY_EVALID;
1082 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001083 }
Radek Krejcic59bc972018-09-17 16:13:06 +02001084 LY_CHECK_RET(ret);
Radek Krejci6d6556c2018-11-08 09:37:45 +01001085checks:
Michal Vasko7fbc8162018-09-17 10:35:16 +02001086 /* mandatory substatements */
1087 if (!*prefix) {
David Sedlákb3077192019-06-19 10:55:37 +02001088 LOGVAL_PARSER(ctx, LY_VCODE_MISSTMT, "prefix", "belongs-to");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001089 return LY_EVALID;
1090 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001091 return ret;
1092}
1093
Michal Vaskoea5abea2018-09-18 13:10:54 +02001094/**
1095 * @brief Parse the revision-date statement.
1096 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001097 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001098 * @param[in,out] rev Array to store the parsed value in.
1099 * @param[in,out] exts Extension instances to add to.
1100 *
1101 * @return LY_ERR values.
1102 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001103static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001104parse_revisiondate(struct lys_yang_parser_ctx *ctx, char *rev, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001105{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001106 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001107 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001108 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001109 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001110
1111 if (rev[0]) {
David Sedlákb3077192019-06-19 10:55:37 +02001112 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "revision-date");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001113 return LY_EVALID;
1114 }
1115
1116 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001117 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001118
1119 /* check value */
Michal Vaskob36053d2020-03-26 15:49:30 +01001120 if (lysp_check_date((struct lys_parser_ctx *)ctx, word, word_len, "revision-date")) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001121 free(buf);
1122 return LY_EVALID;
1123 }
1124
1125 /* store value and spend buf if allocated */
1126 strncpy(rev, word, word_len);
1127 free(buf);
1128
aPieceka24a2252021-05-07 10:52:31 +02001129 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001130 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001131 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001132 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_REVISION_DATE, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001133 break;
1134 default:
David Sedlákb3077192019-06-19 10:55:37 +02001135 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "revision-date");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001136 return LY_EVALID;
1137 }
1138 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001139 return ret;
1140}
1141
Michal Vaskoea5abea2018-09-18 13:10:54 +02001142/**
1143 * @brief Parse the include statement.
1144 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001145 * @param[in] ctx yang parser context for logging.
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001146 * @param[in] module_name Name of the module to check name collisions.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001147 * @param[in,out] includes Parsed includes to add to.
1148 *
1149 * @return LY_ERR values.
1150 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001151static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001152parse_include(struct lys_yang_parser_ctx *ctx, const char *module_name, struct lysp_include **includes)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001153{
Radek Krejcid33273d2018-10-25 14:55:52 +02001154 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001155 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001156 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001157 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001158 struct lysp_include *inc;
1159
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001160 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *includes, inc, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001161
1162 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001163 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001164
Radek Krejci011e4aa2020-09-04 15:22:31 +02001165 INSERT_WORD_RET(ctx, buf, inc->name, word, word_len);
Radek Krejci086c7132018-10-26 15:29:04 +02001166
Radek Krejcifaa1eac2018-10-30 14:34:55 +01001167 /* submodules share the namespace with the module names, so there must not be
1168 * a module of the same name in the context, no need for revision matching */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001169 if (!strcmp(module_name, inc->name) || ly_ctx_get_module_latest(PARSER_CTX(ctx), inc->name)) {
Radek Krejci854e1552020-12-21 15:05:23 +01001170 LOGVAL_PARSER(ctx, LY_VCODE_NAME2_COL, "module", "submodule", inc->name);
Radek Krejcifaa1eac2018-10-30 14:34:55 +01001171 return LY_EVALID;
1172 }
1173
aPieceka24a2252021-05-07 10:52:31 +02001174 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001175 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001176 case LY_STMT_DESCRIPTION:
Radek Krejci335332a2019-09-05 13:03:35 +02001177 PARSER_CHECK_STMTVER2_RET(ctx, "description", "include");
Radek Krejcifc596f92021-02-26 22:40:26 +01001178 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &inc->dsc, Y_STR_ARG, &inc->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001179 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001180 case LY_STMT_REFERENCE:
Radek Krejci335332a2019-09-05 13:03:35 +02001181 PARSER_CHECK_STMTVER2_RET(ctx, "reference", "include");
Radek Krejcifc596f92021-02-26 22:40:26 +01001182 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &inc->ref, Y_STR_ARG, &inc->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001183 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001184 case LY_STMT_REVISION_DATE:
Radek Krejci33090f92020-12-17 20:12:46 +01001185 LY_CHECK_RET(parse_revisiondate(ctx, inc->rev, &inc->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001186 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001187 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01001188 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_INCLUDE, 0, &inc->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001189 break;
1190 default:
David Sedlákb3077192019-06-19 10:55:37 +02001191 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "include");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001192 return LY_EVALID;
1193 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001194 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001195 return ret;
1196}
1197
Michal Vaskoea5abea2018-09-18 13:10:54 +02001198/**
1199 * @brief Parse the import statement.
1200 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001201 * @param[in] ctx yang parser context for logging.
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001202 * @param[in] module_prefix Prefix of the module to check prefix collisions.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001203 * @param[in,out] imports Parsed imports to add to.
1204 *
1205 * @return LY_ERR values.
1206 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001207static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001208parse_import(struct lys_yang_parser_ctx *ctx, const char *module_prefix, struct lysp_import **imports)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001209{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001210 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001211 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001212 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001213 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001214 struct lysp_import *imp;
1215
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001216 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *imports, imp, LY_EVALID);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001217
1218 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001219 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02001220 INSERT_WORD_RET(ctx, buf, imp->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001221
aPieceka24a2252021-05-07 10:52:31 +02001222 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001223 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001224 case LY_STMT_PREFIX:
Radek Krejcifc596f92021-02-26 22:40:26 +01001225 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_PREFIX, 0, &imp->prefix, Y_IDENTIF_ARG, &imp->exts));
Michal Vaskob36053d2020-03-26 15:49:30 +01001226 LY_CHECK_RET(lysp_check_prefix((struct lys_parser_ctx *)ctx, *imports, module_prefix, &imp->prefix), LY_EVALID);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001227 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001228 case LY_STMT_DESCRIPTION:
Radek Krejci335332a2019-09-05 13:03:35 +02001229 PARSER_CHECK_STMTVER2_RET(ctx, "description", "import");
Radek Krejcifc596f92021-02-26 22:40:26 +01001230 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &imp->dsc, Y_STR_ARG, &imp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001231 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001232 case LY_STMT_REFERENCE:
Radek Krejci335332a2019-09-05 13:03:35 +02001233 PARSER_CHECK_STMTVER2_RET(ctx, "reference", "import");
Radek Krejcifc596f92021-02-26 22:40:26 +01001234 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &imp->ref, Y_STR_ARG, &imp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001235 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001236 case LY_STMT_REVISION_DATE:
Radek Krejci33090f92020-12-17 20:12:46 +01001237 LY_CHECK_RET(parse_revisiondate(ctx, imp->rev, &imp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001238 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001239 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01001240 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_IMPORT, 0, &imp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001241 break;
1242 default:
David Sedlákb3077192019-06-19 10:55:37 +02001243 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "import");
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 */
David Sedlákb3077192019-06-19 10:55:37 +02001250 LY_CHECK_ERR_RET(!imp->prefix, LOGVAL_PARSER(ctx, LY_VCODE_MISSTMT, "prefix", "import"), LY_EVALID);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001251
1252 return ret;
1253}
1254
Michal Vaskoea5abea2018-09-18 13:10:54 +02001255/**
1256 * @brief Parse the revision statement.
1257 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001258 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001259 * @param[in,out] revs Parsed revisions to add to.
1260 *
1261 * @return LY_ERR values.
1262 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001263static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001264parse_revision(struct lys_yang_parser_ctx *ctx, struct lysp_revision **revs)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001265{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001266 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001267 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001268 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001269 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001270 struct lysp_revision *rev;
1271
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001272 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *revs, rev, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001273
1274 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001275 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001276
1277 /* check value */
Michal Vaskob36053d2020-03-26 15:49:30 +01001278 if (lysp_check_date((struct lys_parser_ctx *)ctx, word, word_len, "revision")) {
David Sedlák68ef3dc2019-07-22 13:40:19 +02001279 free(buf);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001280 return LY_EVALID;
1281 }
1282
Radek Krejcib7db73a2018-10-24 14:18:40 +02001283 strncpy(rev->date, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001284 free(buf);
1285
aPieceka24a2252021-05-07 10:52:31 +02001286 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001287 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001288 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01001289 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &rev->dsc, Y_STR_ARG, &rev->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001290 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001291 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001292 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &rev->ref, Y_STR_ARG, &rev->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001293 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001294 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01001295 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_REVISION, 0, &rev->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001296 break;
1297 default:
David Sedlákb3077192019-06-19 10:55:37 +02001298 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "revision");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001299 return LY_EVALID;
1300 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001301 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001302 return ret;
1303}
1304
Michal Vaskoea5abea2018-09-18 13:10:54 +02001305/**
1306 * @brief Parse a generic text field that can have more instances such as base.
1307 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001308 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001309 * @param[in] substmt Type of this substatement.
1310 * @param[in,out] texts Parsed values to add to.
1311 * @param[in] arg Type of the expected argument.
1312 * @param[in,out] exts Extension instances to add to.
1313 *
1314 * @return LY_ERR values.
1315 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001316static LY_ERR
Radek Krejcifc596f92021-02-26 22:40:26 +01001317parse_text_fields(struct lys_yang_parser_ctx *ctx, enum ly_stmt substmt, const char ***texts, enum yang_arg arg,
Radek Krejci0f969882020-08-21 16:56:47 +02001318 struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001319{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001320 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001321 char *buf, *word;
Radek Krejci151a5b72018-10-19 14:21:44 +02001322 const char **item;
1323 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001324 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001325
1326 /* allocate new pointer */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001327 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *texts, item, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001328
1329 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001330 LY_CHECK_RET(get_argument(ctx, arg, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001331
Radek Krejci011e4aa2020-09-04 15:22:31 +02001332 INSERT_WORD_RET(ctx, buf, *item, word, word_len);
aPieceka24a2252021-05-07 10:52:31 +02001333 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001334 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001335 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci33090f92020-12-17 20:12:46 +01001336 LY_CHECK_RET(parse_ext(ctx, word, word_len, substmt, LY_ARRAY_COUNT(*texts) - 1, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001337 break;
1338 default:
Radek Krejci3972b332021-03-02 16:34:31 +01001339 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(substmt));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001340 return LY_EVALID;
1341 }
1342 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001343 return ret;
1344}
1345
Michal Vaskoea5abea2018-09-18 13:10:54 +02001346/**
Michal Vasko7f45cf22020-10-01 12:49:44 +02001347 * @brief Parse a generic text field that can have more instances such as base.
1348 *
1349 * @param[in] ctx yang parser context for logging.
Michal Vasko7f45cf22020-10-01 12:49:44 +02001350 * @param[in] substmt Type of this substatement.
1351 * @param[in,out] qnames Parsed qnames to add to.
1352 * @param[in] arg Type of the expected argument.
1353 * @param[in,out] exts Extension instances to add to.
1354 *
1355 * @return LY_ERR values.
1356 */
1357static LY_ERR
Radek Krejcifc596f92021-02-26 22:40:26 +01001358parse_qnames(struct lys_yang_parser_ctx *ctx, enum ly_stmt substmt, struct lysp_qname **qnames,
Michal Vasko7f45cf22020-10-01 12:49:44 +02001359 enum yang_arg arg, struct lysp_ext_instance **exts)
1360{
1361 LY_ERR ret = LY_SUCCESS;
1362 char *buf, *word;
1363 struct lysp_qname *item;
1364 size_t word_len;
1365 enum ly_stmt kw;
1366
1367 /* allocate new pointer */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001368 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *qnames, item, LY_EMEM);
Michal Vasko7f45cf22020-10-01 12:49:44 +02001369
1370 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001371 LY_CHECK_RET(get_argument(ctx, arg, NULL, &word, &buf, &word_len));
Michal Vasko7f45cf22020-10-01 12:49:44 +02001372
1373 INSERT_WORD_RET(ctx, buf, item->str, word, word_len);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001374 item->mod = ctx->parsed_mod;
aPieceka24a2252021-05-07 10:52:31 +02001375 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7f45cf22020-10-01 12:49:44 +02001376 switch (kw) {
1377 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci33090f92020-12-17 20:12:46 +01001378 LY_CHECK_RET(parse_ext(ctx, word, word_len, substmt, LY_ARRAY_COUNT(*qnames) - 1, exts));
Michal Vasko7f45cf22020-10-01 12:49:44 +02001379 break;
1380 default:
Radek Krejci3972b332021-03-02 16:34:31 +01001381 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(substmt));
Michal Vasko7f45cf22020-10-01 12:49:44 +02001382 return LY_EVALID;
1383 }
1384 }
1385 return ret;
1386}
1387
1388/**
Michal Vaskoea5abea2018-09-18 13:10:54 +02001389 * @brief Parse the config statement.
1390 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001391 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001392 * @param[in,out] flags Flags to add to.
1393 * @param[in,out] exts Extension instances to add to.
1394 *
1395 * @return LY_ERR values.
1396 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001397static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001398parse_config(struct lys_yang_parser_ctx *ctx, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001399{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001400 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001401 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001402 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001403 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001404
1405 if (*flags & LYS_CONFIG_MASK) {
David Sedlákb3077192019-06-19 10:55:37 +02001406 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "config");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001407 return LY_EVALID;
1408 }
1409
1410 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001411 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001412
Radek Krejcif13b87b2020-12-01 22:02:17 +01001413 if ((word_len == ly_strlen_const("true")) && !strncmp(word, "true", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001414 *flags |= LYS_CONFIG_W;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001415 } else if ((word_len == ly_strlen_const("false")) && !strncmp(word, "false", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001416 *flags |= LYS_CONFIG_R;
1417 } else {
David Sedlákb3077192019-06-19 10:55:37 +02001418 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "config");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001419 free(buf);
1420 return LY_EVALID;
1421 }
1422 free(buf);
1423
aPieceka24a2252021-05-07 10:52:31 +02001424 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001425 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001426 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001427 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_CONFIG, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001428 break;
1429 default:
David Sedlákb3077192019-06-19 10:55:37 +02001430 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "config");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001431 return LY_EVALID;
1432 }
1433 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001434 return ret;
1435}
1436
Michal Vaskoea5abea2018-09-18 13:10:54 +02001437/**
1438 * @brief Parse the mandatory statement.
1439 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001440 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001441 * @param[in,out] flags Flags to add to.
1442 * @param[in,out] exts Extension instances to add to.
1443 *
1444 * @return LY_ERR values.
1445 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001446static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001447parse_mandatory(struct lys_yang_parser_ctx *ctx, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001448{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001449 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001450 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001451 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001452 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001453
1454 if (*flags & LYS_MAND_MASK) {
David Sedlákb3077192019-06-19 10:55:37 +02001455 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "mandatory");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001456 return LY_EVALID;
1457 }
1458
1459 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001460 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001461
Radek Krejcif13b87b2020-12-01 22:02:17 +01001462 if ((word_len == ly_strlen_const("true")) && !strncmp(word, "true", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001463 *flags |= LYS_MAND_TRUE;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001464 } else if ((word_len == ly_strlen_const("false")) && !strncmp(word, "false", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001465 *flags |= LYS_MAND_FALSE;
1466 } else {
David Sedlákb3077192019-06-19 10:55:37 +02001467 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "mandatory");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001468 free(buf);
1469 return LY_EVALID;
1470 }
1471 free(buf);
1472
aPieceka24a2252021-05-07 10:52:31 +02001473 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001474 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001475 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001476 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_MANDATORY, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001477 break;
1478 default:
David Sedlákb3077192019-06-19 10:55:37 +02001479 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "mandatory");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001480 return LY_EVALID;
1481 }
1482 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001483 return ret;
1484}
1485
Michal Vaskoea5abea2018-09-18 13:10:54 +02001486/**
1487 * @brief Parse a restriction such as range or length.
1488 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001489 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001490 * @param[in] restr_kw Type of this particular restriction.
1491 * @param[in,out] exts Extension instances to add to.
1492 *
1493 * @return LY_ERR values.
1494 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001495static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001496parse_restr(struct lys_yang_parser_ctx *ctx, enum ly_stmt restr_kw, struct lysp_restr *restr)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001497{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001498 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001499 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001500 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001501 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001502
1503 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001504 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001505
Michal Vaskob36053d2020-03-26 15:49:30 +01001506 CHECK_NONEMPTY(ctx, word_len, ly_stmt2str(restr_kw));
Michal Vasko7f45cf22020-10-01 12:49:44 +02001507 INSERT_WORD_RET(ctx, buf, restr->arg.str, word, word_len);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001508 restr->arg.mod = ctx->parsed_mod;
aPieceka24a2252021-05-07 10:52:31 +02001509 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001510 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001511 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01001512 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &restr->dsc, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001513 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001514 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001515 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &restr->ref, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001516 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001517 case LY_STMT_ERROR_APP_TAG:
Radek Krejcifc596f92021-02-26 22:40:26 +01001518 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_ERROR_APP_TAG, 0, &restr->eapptag, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001519 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001520 case LY_STMT_ERROR_MESSAGE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001521 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_ERROR_MESSAGE, 0, &restr->emsg, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001522 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001523 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01001524 LY_CHECK_RET(parse_ext(ctx, word, word_len, restr_kw, 0, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001525 break;
1526 default:
David Sedlákb3077192019-06-19 10:55:37 +02001527 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(restr_kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001528 return LY_EVALID;
1529 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001530 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001531 return ret;
1532}
1533
Michal Vaskoea5abea2018-09-18 13:10:54 +02001534/**
1535 * @brief Parse a restriction that can have more instances such as must.
1536 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001537 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001538 * @param[in] restr_kw Type of this particular restriction.
1539 * @param[in,out] restrs Restrictions to add to.
1540 *
1541 * @return LY_ERR values.
1542 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001543static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001544parse_restrs(struct lys_yang_parser_ctx *ctx, enum ly_stmt restr_kw, struct lysp_restr **restrs)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001545{
1546 struct lysp_restr *restr;
1547
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001548 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *restrs, restr, LY_EMEM);
Radek Krejci33090f92020-12-17 20:12:46 +01001549 return parse_restr(ctx, restr_kw, restr);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001550}
1551
Michal Vaskoea5abea2018-09-18 13:10:54 +02001552/**
1553 * @brief Parse the status statement.
1554 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001555 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001556 * @param[in,out] flags Flags to add to.
1557 * @param[in,out] exts Extension instances to add to.
1558 *
1559 * @return LY_ERR values.
1560 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001561static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001562parse_status(struct lys_yang_parser_ctx *ctx, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001563{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001564 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001565 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001566 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001567 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001568
1569 if (*flags & LYS_STATUS_MASK) {
David Sedlákb3077192019-06-19 10:55:37 +02001570 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "status");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001571 return LY_EVALID;
1572 }
1573
1574 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001575 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001576
Radek Krejcif13b87b2020-12-01 22:02:17 +01001577 if ((word_len == ly_strlen_const("current")) && !strncmp(word, "current", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001578 *flags |= LYS_STATUS_CURR;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001579 } else if ((word_len == ly_strlen_const("deprecated")) && !strncmp(word, "deprecated", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001580 *flags |= LYS_STATUS_DEPRC;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001581 } else if ((word_len == ly_strlen_const("obsolete")) && !strncmp(word, "obsolete", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001582 *flags |= LYS_STATUS_OBSLT;
1583 } else {
David Sedlákb3077192019-06-19 10:55:37 +02001584 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "status");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001585 free(buf);
1586 return LY_EVALID;
1587 }
1588 free(buf);
1589
aPieceka24a2252021-05-07 10:52:31 +02001590 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001591 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001592 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001593 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_STATUS, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001594 break;
1595 default:
David Sedlákb3077192019-06-19 10:55:37 +02001596 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "status");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001597 return LY_EVALID;
1598 }
1599 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001600 return ret;
1601}
1602
Michal Vaskoea5abea2018-09-18 13:10:54 +02001603/**
1604 * @brief Parse the when statement.
1605 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001606 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001607 * @param[in,out] when_p When pointer to parse to.
1608 *
1609 * @return LY_ERR values.
1610 */
Radek Krejcif09e4e82019-06-14 15:08:11 +02001611LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001612parse_when(struct lys_yang_parser_ctx *ctx, struct lysp_when **when_p)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001613{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001614 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001615 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001616 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001617 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001618 struct lysp_when *when;
1619
1620 if (*when_p) {
David Sedlákb3077192019-06-19 10:55:37 +02001621 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "when");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001622 return LY_EVALID;
1623 }
1624
1625 when = calloc(1, sizeof *when);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001626 LY_CHECK_ERR_RET(!when, LOGMEM(PARSER_CTX(ctx)), LY_EMEM);
Radek Krejci011e4aa2020-09-04 15:22:31 +02001627 *when_p = when;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001628
1629 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001630 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vaskob36053d2020-03-26 15:49:30 +01001631 CHECK_NONEMPTY(ctx, word_len, "when");
Radek Krejci011e4aa2020-09-04 15:22:31 +02001632 INSERT_WORD_RET(ctx, buf, when->cond, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001633
aPieceka24a2252021-05-07 10:52:31 +02001634 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001635 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001636 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01001637 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &when->dsc, Y_STR_ARG, &when->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001638 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001639 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001640 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &when->ref, Y_STR_ARG, &when->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001641 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001642 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01001643 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_WHEN, 0, &when->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001644 break;
1645 default:
David Sedlákb3077192019-06-19 10:55:37 +02001646 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "when");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001647 return LY_EVALID;
1648 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001649 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001650 return ret;
1651}
1652
Michal Vaskoea5abea2018-09-18 13:10:54 +02001653/**
1654 * @brief Parse the anydata or anyxml statement.
1655 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001656 * @param[in] ctx yang parser context for logging.
Radek Krejci39b7fc22021-02-26 23:29:18 +01001657 * @param[in] any_kw Type of this particular keyword.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001658 * @param[in,out] siblings Siblings to add to.
1659 *
1660 * @return LY_ERR values.
1661 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02001662LY_ERR
Radek Krejci39b7fc22021-02-26 23:29:18 +01001663parse_any(struct lys_yang_parser_ctx *ctx, enum ly_stmt any_kw, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001664{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001665 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001666 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001667 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001668 struct lysp_node_anydata *any;
Radek Krejci39b7fc22021-02-26 23:29:18 +01001669 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001670
David Sedlák60adc092019-08-06 15:57:02 +02001671 /* create new structure and insert into siblings */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001672 LY_LIST_NEW_RET(PARSER_CTX(ctx), siblings, any, next, LY_EMEM);
David Sedlák60adc092019-08-06 15:57:02 +02001673
Radek Krejci39b7fc22021-02-26 23:29:18 +01001674 any->nodetype = any_kw == LY_STMT_ANYDATA ? LYS_ANYDATA : LYS_ANYXML;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001675 any->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001676
Michal Vasko7fbc8162018-09-17 10:35:16 +02001677 /* get name */
Radek Krejci33090f92020-12-17 20:12:46 +01001678 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02001679 INSERT_WORD_RET(ctx, buf, any->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001680
1681 /* parse substatements */
aPieceka24a2252021-05-07 10:52:31 +02001682 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001683 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001684 case LY_STMT_CONFIG:
Radek Krejci33090f92020-12-17 20:12:46 +01001685 LY_CHECK_RET(parse_config(ctx, &any->flags, &any->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001686 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001687 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01001688 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &any->dsc, Y_STR_ARG, &any->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001689 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001690 case LY_STMT_IF_FEATURE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001691 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &any->iffeatures, Y_STR_ARG, &any->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001692 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001693 case LY_STMT_MANDATORY:
Radek Krejci33090f92020-12-17 20:12:46 +01001694 LY_CHECK_RET(parse_mandatory(ctx, &any->flags, &any->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001695 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001696 case LY_STMT_MUST:
Radek Krejci33090f92020-12-17 20:12:46 +01001697 LY_CHECK_RET(parse_restrs(ctx, kw, &any->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001698 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001699 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001700 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &any->ref, Y_STR_ARG, &any->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001701 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001702 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01001703 LY_CHECK_RET(parse_status(ctx, &any->flags, &any->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001704 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001705 case LY_STMT_WHEN:
Radek Krejci33090f92020-12-17 20:12:46 +01001706 LY_CHECK_RET(parse_when(ctx, &any->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001707 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001708 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01001709 LY_CHECK_RET(parse_ext(ctx, word, word_len, any_kw, 0, &any->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001710 break;
1711 default:
Radek Krejci39b7fc22021-02-26 23:29:18 +01001712 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(any_kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001713 return LY_EVALID;
1714 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001715 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001716 return ret;
1717}
1718
Michal Vaskoea5abea2018-09-18 13:10:54 +02001719/**
1720 * @brief Parse the value or position statement. Substatement of type enum statement.
1721 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001722 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001723 * @param[in] val_kw Type of this particular keyword.
1724 * @param[in,out] value Value to write to.
1725 * @param[in,out] flags Flags to write to.
1726 * @param[in,out] exts Extension instances to add to.
1727 *
1728 * @return LY_ERR values.
1729 */
David Sedlákd6ce6d72019-07-16 17:30:18 +02001730LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001731parse_type_enum_value_pos(struct lys_yang_parser_ctx *ctx, enum ly_stmt val_kw, int64_t *value, uint16_t *flags,
Radek Krejci0f969882020-08-21 16:56:47 +02001732 struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001733{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001734 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001735 char *buf, *word, *ptr;
Radek Krejciefd22f62018-09-27 11:47:58 +02001736 size_t word_len;
Radek Krejci4ad42aa2019-07-23 16:55:58 +02001737 long int num = 0;
1738 unsigned long int unum = 0;
Radek Krejcid6b76452019-09-03 17:03:03 +02001739 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001740
1741 if (*flags & LYS_SET_VALUE) {
David Sedlákb3077192019-06-19 10:55:37 +02001742 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, ly_stmt2str(val_kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001743 return LY_EVALID;
1744 }
1745 *flags |= LYS_SET_VALUE;
1746
1747 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001748 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001749
Radek Krejcid6b76452019-09-03 17:03:03 +02001750 if (!word_len || (word[0] == '+') || ((word[0] == '0') && (word_len > 1)) || ((val_kw == LY_STMT_POSITION) && !strncmp(word, "-0", 2))) {
David Sedlákb3077192019-06-19 10:55:37 +02001751 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, ly_stmt2str(val_kw));
Radek Krejci8b764662018-11-14 14:15:13 +01001752 goto error;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001753 }
1754
1755 errno = 0;
Radek Krejcid6b76452019-09-03 17:03:03 +02001756 if (val_kw == LY_STMT_VALUE) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01001757 num = strtol(word, &ptr, LY_BASE_DEC);
Michal Vasko69730152020-10-09 16:30:07 +02001758 if ((num < INT64_C(-2147483648)) || (num > INT64_C(2147483647))) {
David Sedlákb3077192019-06-19 10:55:37 +02001759 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, ly_stmt2str(val_kw));
Radek Krejci8b764662018-11-14 14:15:13 +01001760 goto error;
1761 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001762 } else {
Radek Krejcif13b87b2020-12-01 22:02:17 +01001763 unum = strtoul(word, &ptr, LY_BASE_DEC);
Radek Krejci8b764662018-11-14 14:15:13 +01001764 if (unum > UINT64_C(4294967295)) {
David Sedlákb3077192019-06-19 10:55:37 +02001765 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, ly_stmt2str(val_kw));
Radek Krejci8b764662018-11-14 14:15:13 +01001766 goto error;
1767 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001768 }
1769 /* we have not parsed the whole argument */
Radek Krejciefd22f62018-09-27 11:47:58 +02001770 if ((size_t)(ptr - word) != word_len) {
David Sedlákb3077192019-06-19 10:55:37 +02001771 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, ly_stmt2str(val_kw));
Radek Krejci8b764662018-11-14 14:15:13 +01001772 goto error;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001773 }
1774 if (errno == ERANGE) {
David Sedlákb3077192019-06-19 10:55:37 +02001775 LOGVAL_PARSER(ctx, LY_VCODE_OOB, word_len, word, ly_stmt2str(val_kw));
Radek Krejci8b764662018-11-14 14:15:13 +01001776 goto error;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001777 }
Radek Krejcid6b76452019-09-03 17:03:03 +02001778 if (val_kw == LY_STMT_VALUE) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001779 *value = num;
1780 } else {
1781 *value = unum;
1782 }
1783 free(buf);
1784
aPieceka24a2252021-05-07 10:52:31 +02001785 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001786 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001787 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001788 LY_CHECK_RET(parse_ext(ctx, word, word_len, val_kw == LY_STMT_VALUE ? LY_STMT_VALUE : LY_STMT_POSITION, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001789 break;
1790 default:
David Sedlákb3077192019-06-19 10:55:37 +02001791 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(val_kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001792 return LY_EVALID;
1793 }
1794 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001795 return ret;
Radek Krejci8b764662018-11-14 14:15:13 +01001796
1797error:
1798 free(buf);
1799 return LY_EVALID;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001800}
1801
Michal Vaskoea5abea2018-09-18 13:10:54 +02001802/**
1803 * @brief Parse the enum or bit statement. Substatement of type statement.
1804 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001805 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001806 * @param[in] enum_kw Type of this particular keyword.
1807 * @param[in,out] enums Enums or bits to add to.
1808 *
1809 * @return LY_ERR values.
1810 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001811static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001812parse_type_enum(struct lys_yang_parser_ctx *ctx, enum ly_stmt enum_kw, struct lysp_type_enum **enums)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001813{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001814 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001815 char *buf, *word;
David Sedlák6544c182019-07-12 13:17:33 +02001816 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001817 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001818 struct lysp_type_enum *enm;
1819
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001820 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *enums, enm, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001821
1822 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001823 LY_CHECK_RET(get_argument(ctx, enum_kw == LY_STMT_ENUM ? Y_STR_ARG : Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejcid6b76452019-09-03 17:03:03 +02001824 if (enum_kw == LY_STMT_ENUM) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001825 ret = lysp_check_enum_name((struct lys_parser_ctx *)ctx, (const char *)word, word_len);
David Sedlák6544c182019-07-12 13:17:33 +02001826 LY_CHECK_ERR_RET(ret, free(buf), ret);
Radek Krejci335332a2019-09-05 13:03:35 +02001827 } /* else nothing specific for YANG_BIT */
Radek Krejci8b764662018-11-14 14:15:13 +01001828
Radek Krejci011e4aa2020-09-04 15:22:31 +02001829 INSERT_WORD_RET(ctx, buf, enm->name, word, word_len);
Radek Krejci8b764662018-11-14 14:15:13 +01001830 CHECK_UNIQUENESS(ctx, *enums, name, ly_stmt2str(enum_kw), enm->name);
1831
aPieceka24a2252021-05-07 10:52:31 +02001832 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001833 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001834 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01001835 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &enm->dsc, Y_STR_ARG, &enm->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001836 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001837 case LY_STMT_IF_FEATURE:
Radek Krejci335332a2019-09-05 13:03:35 +02001838 PARSER_CHECK_STMTVER2_RET(ctx, "if-feature", ly_stmt2str(enum_kw));
Radek Krejcifc596f92021-02-26 22:40:26 +01001839 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &enm->iffeatures, Y_STR_ARG, &enm->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001840 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001841 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001842 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &enm->ref, Y_STR_ARG, &enm->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001843 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001844 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01001845 LY_CHECK_RET(parse_status(ctx, &enm->flags, &enm->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001846 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001847 case LY_STMT_VALUE:
1848 LY_CHECK_ERR_RET(enum_kw == LY_STMT_BIT, LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw),
Michal Vasko69730152020-10-09 16:30:07 +02001849 ly_stmt2str(enum_kw)), LY_EVALID);
Radek Krejci33090f92020-12-17 20:12:46 +01001850 LY_CHECK_RET(parse_type_enum_value_pos(ctx, kw, &enm->value, &enm->flags, &enm->exts));
David Sedlák9fb515f2019-07-11 10:33:58 +02001851 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001852 case LY_STMT_POSITION:
1853 LY_CHECK_ERR_RET(enum_kw == LY_STMT_ENUM, LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw),
Michal Vasko69730152020-10-09 16:30:07 +02001854 ly_stmt2str(enum_kw)), LY_EVALID);
Radek Krejci33090f92020-12-17 20:12:46 +01001855 LY_CHECK_RET(parse_type_enum_value_pos(ctx, kw, &enm->value, &enm->flags, &enm->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001856 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02001857 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01001858 LY_CHECK_RET(parse_ext(ctx, word, word_len, enum_kw, 0, &enm->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001859 break;
1860 default:
David Sedlákb3077192019-06-19 10:55:37 +02001861 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(enum_kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001862 return LY_EVALID;
1863 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001864 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001865 return ret;
1866}
1867
Michal Vaskoea5abea2018-09-18 13:10:54 +02001868/**
1869 * @brief Parse the fraction-digits statement. Substatement of type statement.
1870 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001871 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001872 * @param[in,out] fracdig Value to write to.
1873 * @param[in,out] exts Extension instances to add to.
1874 *
1875 * @return LY_ERR values.
1876 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001877static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001878parse_type_fracdigits(struct lys_yang_parser_ctx *ctx, uint8_t *fracdig, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001879{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001880 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001881 char *buf, *word, *ptr;
Radek Krejciefd22f62018-09-27 11:47:58 +02001882 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001883 unsigned long int num;
Radek Krejcid6b76452019-09-03 17:03:03 +02001884 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001885
1886 if (*fracdig) {
David Sedlákb3077192019-06-19 10:55:37 +02001887 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "fraction-digits");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001888 return LY_EVALID;
1889 }
1890
1891 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001892 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001893
1894 if (!word_len || (word[0] == '0') || !isdigit(word[0])) {
David Sedlákb3077192019-06-19 10:55:37 +02001895 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "fraction-digits");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001896 free(buf);
1897 return LY_EVALID;
1898 }
1899
1900 errno = 0;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001901 num = strtoul(word, &ptr, LY_BASE_DEC);
Michal Vasko7fbc8162018-09-17 10:35:16 +02001902 /* we have not parsed the whole argument */
Radek Krejciefd22f62018-09-27 11:47:58 +02001903 if ((size_t)(ptr - word) != word_len) {
David Sedlákb3077192019-06-19 10:55:37 +02001904 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "fraction-digits");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001905 free(buf);
1906 return LY_EVALID;
1907 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01001908 if ((errno == ERANGE) || (num > LY_TYPE_DEC64_FD_MAX)) {
David Sedlákb3077192019-06-19 10:55:37 +02001909 LOGVAL_PARSER(ctx, LY_VCODE_OOB, word_len, word, "fraction-digits");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001910 free(buf);
1911 return LY_EVALID;
1912 }
1913 *fracdig = num;
1914 free(buf);
1915
aPieceka24a2252021-05-07 10:52:31 +02001916 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001917 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001918 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001919 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_FRACTION_DIGITS, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001920 break;
1921 default:
David Sedlákb3077192019-06-19 10:55:37 +02001922 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "fraction-digits");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001923 return LY_EVALID;
1924 }
1925 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001926 return ret;
1927}
1928
Michal Vaskoea5abea2018-09-18 13:10:54 +02001929/**
1930 * @brief Parse the require-instance statement. Substatement of type statement.
1931 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001932 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001933 * @param[in,out] reqinst Value to write to.
1934 * @param[in,out] flags Flags to write to.
1935 * @param[in,out] exts Extension instances to add to.
1936 *
1937 * @return LY_ERR values.
1938 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001939static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001940parse_type_reqinstance(struct lys_yang_parser_ctx *ctx, uint8_t *reqinst, uint16_t *flags,
Radek Krejci0f969882020-08-21 16:56:47 +02001941 struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001942{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001943 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001944 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001945 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001946 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001947
1948 if (*flags & LYS_SET_REQINST) {
David Sedlákb3077192019-06-19 10:55:37 +02001949 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "require-instance");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001950 return LY_EVALID;
1951 }
1952 *flags |= LYS_SET_REQINST;
1953
1954 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01001955 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001956
Radek Krejcif13b87b2020-12-01 22:02:17 +01001957 if ((word_len == ly_strlen_const("true")) && !strncmp(word, "true", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001958 *reqinst = 1;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001959 } else if ((word_len != ly_strlen_const("false")) || strncmp(word, "false", word_len)) {
David Sedlákb3077192019-06-19 10:55:37 +02001960 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "require-instance");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001961 free(buf);
1962 return LY_EVALID;
1963 }
1964 free(buf);
1965
aPieceka24a2252021-05-07 10:52:31 +02001966 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02001967 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02001968 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01001969 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_REQUIRE_INSTANCE, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02001970 break;
1971 default:
David Sedlákb3077192019-06-19 10:55:37 +02001972 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "require-instance");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001973 return LY_EVALID;
1974 }
1975 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02001976 return ret;
1977}
1978
Michal Vaskoea5abea2018-09-18 13:10:54 +02001979/**
1980 * @brief Parse the modifier statement. Substatement of type pattern statement.
1981 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02001982 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02001983 * @param[in,out] pat Value to write to.
1984 * @param[in,out] exts Extension instances to add to.
1985 *
1986 * @return LY_ERR values.
1987 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02001988static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01001989parse_type_pattern_modifier(struct lys_yang_parser_ctx *ctx, const char **pat, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02001990{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01001991 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001992 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02001993 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02001994 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02001995
Radek Krejcif13b87b2020-12-01 22:02:17 +01001996 if ((*pat)[0] == LYSP_RESTR_PATTERN_NACK) {
David Sedlákb3077192019-06-19 10:55:37 +02001997 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "modifier");
Michal Vasko7fbc8162018-09-17 10:35:16 +02001998 return LY_EVALID;
1999 }
2000
2001 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01002002 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002003
Radek Krejcif13b87b2020-12-01 22:02:17 +01002004 if ((word_len != ly_strlen_const("invert-match")) || strncmp(word, "invert-match", word_len)) {
David Sedlákb3077192019-06-19 10:55:37 +02002005 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "modifier");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002006 free(buf);
2007 return LY_EVALID;
2008 }
2009 free(buf);
2010
2011 /* replace the value in the dictionary */
2012 buf = malloc(strlen(*pat) + 1);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002013 LY_CHECK_ERR_RET(!buf, LOGMEM(PARSER_CTX(ctx)), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002014 strcpy(buf, *pat);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002015 lydict_remove(PARSER_CTX(ctx), *pat);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002016
Radek Krejcif13b87b2020-12-01 22:02:17 +01002017 assert(buf[0] == LYSP_RESTR_PATTERN_ACK);
2018 buf[0] = LYSP_RESTR_PATTERN_NACK;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002019 LY_CHECK_RET(lydict_insert_zc(PARSER_CTX(ctx), buf, pat));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002020
aPieceka24a2252021-05-07 10:52:31 +02002021 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002022 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002023 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002024 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_MODIFIER, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002025 break;
2026 default:
David Sedlákb3077192019-06-19 10:55:37 +02002027 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "modifier");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002028 return LY_EVALID;
2029 }
2030 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002031 return ret;
2032}
2033
Michal Vaskoea5abea2018-09-18 13:10:54 +02002034/**
2035 * @brief Parse the pattern statement. Substatement of type statement.
2036 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002037 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002038 * @param[in,out] patterns Restrictions to add to.
2039 *
2040 * @return LY_ERR values.
2041 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002042static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01002043parse_type_pattern(struct lys_yang_parser_ctx *ctx, struct lysp_restr **patterns)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002044{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002045 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002046 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002047 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02002048 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002049 struct lysp_restr *restr;
2050
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002051 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *patterns, restr, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002052
2053 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01002054 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002055
2056 /* add special meaning first byte */
2057 if (buf) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01002058 buf = ly_realloc(buf, word_len + 2);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002059 word = buf;
2060 } else {
2061 buf = malloc(word_len + 2);
2062 }
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002063 LY_CHECK_ERR_RET(!buf, LOGMEM(PARSER_CTX(ctx)), LY_EMEM);
Michal Vasko54720192021-06-11 13:55:59 +02002064 if (word_len) {
2065 memmove(buf + 1, word, word_len);
2066 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01002067 buf[0] = LYSP_RESTR_PATTERN_ACK; /* pattern's default regular-match flag */
Radek Krejci86d106e2018-10-18 09:53:19 +02002068 buf[word_len + 1] = '\0'; /* terminating NULL byte */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002069 LY_CHECK_RET(lydict_insert_zc(PARSER_CTX(ctx), buf, &restr->arg.str));
2070 restr->arg.mod = ctx->parsed_mod;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002071
aPieceka24a2252021-05-07 10:52:31 +02002072 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002073 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002074 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01002075 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &restr->dsc, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002076 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002077 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002078 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &restr->ref, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002079 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002080 case LY_STMT_ERROR_APP_TAG:
Radek Krejcifc596f92021-02-26 22:40:26 +01002081 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_ERROR_APP_TAG, 0, &restr->eapptag, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002082 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002083 case LY_STMT_ERROR_MESSAGE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002084 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_ERROR_MESSAGE, 0, &restr->emsg, Y_STR_ARG, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002085 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002086 case LY_STMT_MODIFIER:
Radek Krejci335332a2019-09-05 13:03:35 +02002087 PARSER_CHECK_STMTVER2_RET(ctx, "modifier", "pattern");
Radek Krejci33090f92020-12-17 20:12:46 +01002088 LY_CHECK_RET(parse_type_pattern_modifier(ctx, &restr->arg.str, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002089 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002090 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01002091 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_PATTERN, 0, &restr->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002092 break;
2093 default:
David Sedlákb3077192019-06-19 10:55:37 +02002094 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "pattern");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002095 return LY_EVALID;
2096 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002097 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002098 return ret;
2099}
2100
Michal Vaskoea5abea2018-09-18 13:10:54 +02002101/**
2102 * @brief Parse the type statement.
2103 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002104 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002105 * @param[in,out] type Type to wrote to.
2106 *
2107 * @return LY_ERR values.
2108 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002109static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01002110parse_type(struct lys_yang_parser_ctx *ctx, struct lysp_type *type)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002111{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002112 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002113 char *buf, *word;
Michal Vasko004d3152020-06-11 19:59:22 +02002114 const char *str_path = NULL;
Radek Krejciefd22f62018-09-27 11:47:58 +02002115 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02002116 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002117 struct lysp_type *nest_type;
2118
2119 if (type->name) {
David Sedlákb3077192019-06-19 10:55:37 +02002120 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "type");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002121 return LY_EVALID;
2122 }
2123
2124 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01002125 LY_CHECK_RET(get_argument(ctx, Y_PREF_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02002126 INSERT_WORD_RET(ctx, buf, type->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002127
Michal Vaskoe9c050f2020-10-06 14:01:23 +02002128 /* set module */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002129 type->pmod = ctx->parsed_mod;
Michal Vaskoe9c050f2020-10-06 14:01:23 +02002130
aPieceka24a2252021-05-07 10:52:31 +02002131 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002132 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002133 case LY_STMT_BASE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002134 LY_CHECK_RET(parse_text_fields(ctx, LY_STMT_BASE, &type->bases, Y_PREF_IDENTIF_ARG, &type->exts));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002135 type->flags |= LYS_SET_BASE;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002136 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002137 case LY_STMT_BIT:
Radek Krejci33090f92020-12-17 20:12:46 +01002138 LY_CHECK_RET(parse_type_enum(ctx, kw, &type->bits));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002139 type->flags |= LYS_SET_BIT;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002140 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002141 case LY_STMT_ENUM:
Radek Krejci33090f92020-12-17 20:12:46 +01002142 LY_CHECK_RET(parse_type_enum(ctx, kw, &type->enums));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002143 type->flags |= LYS_SET_ENUM;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002144 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002145 case LY_STMT_FRACTION_DIGITS:
Radek Krejci33090f92020-12-17 20:12:46 +01002146 LY_CHECK_RET(parse_type_fracdigits(ctx, &type->fraction_digits, &type->exts));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002147 type->flags |= LYS_SET_FRDIGITS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002148 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002149 case LY_STMT_LENGTH:
Michal Vasko7fbc8162018-09-17 10:35:16 +02002150 if (type->length) {
David Sedlákb3077192019-06-19 10:55:37 +02002151 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002152 return LY_EVALID;
2153 }
2154 type->length = calloc(1, sizeof *type->length);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002155 LY_CHECK_ERR_RET(!type->length, LOGMEM(PARSER_CTX(ctx)), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002156
Radek Krejci33090f92020-12-17 20:12:46 +01002157 LY_CHECK_RET(parse_restr(ctx, kw, type->length));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002158 type->flags |= LYS_SET_LENGTH;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002159 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002160 case LY_STMT_PATH:
Michal Vasko004d3152020-06-11 19:59:22 +02002161 if (type->path) {
Radek Krejci3972b332021-03-02 16:34:31 +01002162 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, ly_stmt2str(LY_STMT_PATH));
Michal Vasko004d3152020-06-11 19:59:22 +02002163 return LY_EVALID;
2164 }
2165
aPiecek4bb1e372021-05-07 11:01:00 +02002166 /* Usually, in the parser_yang.c, the result of the parsing is stored directly in the
2167 * corresponding structure, so in case of failure, the lysp_module_free function will take
2168 * care of removing the parsed value from the dictionary. But in this case, it is not possible
2169 * to rely on lysp_module_free because the result of the parsing is stored in a local variable.
2170 */
2171 LY_CHECK_ERR_RET(ret = parse_text_field(ctx, LY_STMT_PATH, 0, &str_path, Y_STR_ARG, &type->exts),
2172 lydict_remove(PARSER_CTX(ctx), str_path), ret);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002173 ret = ly_path_parse(PARSER_CTX(ctx), NULL, str_path, 0, LY_PATH_BEGIN_EITHER, LY_PATH_LREF_TRUE,
Michal Vasko69730152020-10-09 16:30:07 +02002174 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_LEAFREF, &type->path);
aPiecek4bb1e372021-05-07 11:01:00 +02002175 /* Moreover, even if successful, the string is removed from the dictionary. */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002176 lydict_remove(PARSER_CTX(ctx), str_path);
Michal Vasko004d3152020-06-11 19:59:22 +02002177 LY_CHECK_RET(ret);
Radek Krejcid505e3d2018-11-13 09:04:17 +01002178 type->flags |= LYS_SET_PATH;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002179 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002180 case LY_STMT_PATTERN:
Radek Krejci33090f92020-12-17 20:12:46 +01002181 LY_CHECK_RET(parse_type_pattern(ctx, &type->patterns));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002182 type->flags |= LYS_SET_PATTERN;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002183 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002184 case LY_STMT_RANGE:
Michal Vasko7fbc8162018-09-17 10:35:16 +02002185 if (type->range) {
David Sedlákb3077192019-06-19 10:55:37 +02002186 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002187 return LY_EVALID;
2188 }
2189 type->range = calloc(1, sizeof *type->range);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002190 LY_CHECK_ERR_RET(!type->range, LOGMEM(PARSER_CTX(ctx)), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002191
Radek Krejci33090f92020-12-17 20:12:46 +01002192 LY_CHECK_RET(parse_restr(ctx, kw, type->range));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002193 type->flags |= LYS_SET_RANGE;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002194 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002195 case LY_STMT_REQUIRE_INSTANCE:
Radek Krejci33090f92020-12-17 20:12:46 +01002196 LY_CHECK_RET(parse_type_reqinstance(ctx, &type->require_instance, &type->flags, &type->exts));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002197 /* LYS_SET_REQINST checked and set inside parse_type_reqinstance() */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002198 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002199 case LY_STMT_TYPE:
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002200 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), type->types, nest_type, LY_EMEM);
Radek Krejci33090f92020-12-17 20:12:46 +01002201 LY_CHECK_RET(parse_type(ctx, nest_type));
Radek Krejcid505e3d2018-11-13 09:04:17 +01002202 type->flags |= LYS_SET_TYPE;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002203 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002204 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01002205 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_TYPE, 0, &type->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002206 break;
2207 default:
David Sedlákb3077192019-06-19 10:55:37 +02002208 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "type");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002209 return LY_EVALID;
2210 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002211 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002212 return ret;
2213}
2214
Michal Vaskoea5abea2018-09-18 13:10:54 +02002215/**
2216 * @brief Parse the leaf statement.
2217 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002218 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002219 * @param[in,out] siblings Siblings to add to.
2220 *
2221 * @return LY_ERR values.
2222 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02002223LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01002224parse_leaf(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002225{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002226 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002227 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002228 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02002229 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002230 struct lysp_node_leaf *leaf;
2231
David Sedlák60adc092019-08-06 15:57:02 +02002232 /* create new leaf structure */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002233 LY_LIST_NEW_RET(PARSER_CTX(ctx), siblings, leaf, next, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002234 leaf->nodetype = LYS_LEAF;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002235 leaf->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002236
Michal Vasko7fbc8162018-09-17 10:35:16 +02002237 /* get name */
Radek Krejci33090f92020-12-17 20:12:46 +01002238 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02002239 INSERT_WORD_RET(ctx, buf, leaf->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002240
2241 /* parse substatements */
aPieceka24a2252021-05-07 10:52:31 +02002242 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002243 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002244 case LY_STMT_CONFIG:
Radek Krejci33090f92020-12-17 20:12:46 +01002245 LY_CHECK_RET(parse_config(ctx, &leaf->flags, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002246 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002247 case LY_STMT_DEFAULT:
Radek Krejcifc596f92021-02-26 22:40:26 +01002248 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DEFAULT, 0, &leaf->dflt.str, Y_STR_ARG, &leaf->exts));
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002249 leaf->dflt.mod = ctx->parsed_mod;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002250 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002251 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01002252 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &leaf->dsc, Y_STR_ARG, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002253 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002254 case LY_STMT_IF_FEATURE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002255 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &leaf->iffeatures, Y_STR_ARG, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002256 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002257 case LY_STMT_MANDATORY:
Radek Krejci33090f92020-12-17 20:12:46 +01002258 LY_CHECK_RET(parse_mandatory(ctx, &leaf->flags, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002259 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002260 case LY_STMT_MUST:
Radek Krejci33090f92020-12-17 20:12:46 +01002261 LY_CHECK_RET(parse_restrs(ctx, kw, &leaf->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002262 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002263 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002264 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &leaf->ref, Y_STR_ARG, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002265 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002266 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01002267 LY_CHECK_RET(parse_status(ctx, &leaf->flags, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002268 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002269 case LY_STMT_TYPE:
Radek Krejci33090f92020-12-17 20:12:46 +01002270 LY_CHECK_RET(parse_type(ctx, &leaf->type));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002271 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002272 case LY_STMT_UNITS:
Radek Krejcifc596f92021-02-26 22:40:26 +01002273 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_UNITS, 0, &leaf->units, Y_STR_ARG, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002274 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002275 case LY_STMT_WHEN:
Radek Krejci33090f92020-12-17 20:12:46 +01002276 LY_CHECK_RET(parse_when(ctx, &leaf->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002277 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002278 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01002279 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_LEAF, 0, &leaf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002280 break;
2281 default:
David Sedlákb3077192019-06-19 10:55:37 +02002282 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "leaf");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002283 return LY_EVALID;
2284 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002285 }
Radek Krejcic59bc972018-09-17 16:13:06 +02002286 LY_CHECK_RET(ret);
Radek Krejci6d6556c2018-11-08 09:37:45 +01002287checks:
Michal Vasko7fbc8162018-09-17 10:35:16 +02002288 /* mandatory substatements */
2289 if (!leaf->type.name) {
David Sedlákb3077192019-06-19 10:55:37 +02002290 LOGVAL_PARSER(ctx, LY_VCODE_MISSTMT, "type", "leaf");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002291 return LY_EVALID;
2292 }
2293
2294 return ret;
2295}
2296
Michal Vaskoea5abea2018-09-18 13:10:54 +02002297/**
2298 * @brief Parse the max-elements statement.
2299 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002300 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002301 * @param[in,out] max Value to write to.
2302 * @param[in,out] flags Flags to write to.
2303 * @param[in,out] exts Extension instances to add to.
2304 *
2305 * @return LY_ERR values.
2306 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02002307LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01002308parse_maxelements(struct lys_yang_parser_ctx *ctx, uint32_t *max, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002309{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002310 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002311 char *buf, *word, *ptr;
Radek Krejciefd22f62018-09-27 11:47:58 +02002312 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002313 unsigned long int num;
Radek Krejcid6b76452019-09-03 17:03:03 +02002314 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002315
2316 if (*flags & LYS_SET_MAX) {
David Sedlákb3077192019-06-19 10:55:37 +02002317 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "max-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002318 return LY_EVALID;
2319 }
2320 *flags |= LYS_SET_MAX;
2321
2322 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01002323 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002324
2325 if (!word_len || (word[0] == '0') || ((word[0] != 'u') && !isdigit(word[0]))) {
David Sedlákb3077192019-06-19 10:55:37 +02002326 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "max-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002327 free(buf);
2328 return LY_EVALID;
2329 }
2330
Radek Krejci7f9b6512019-09-18 13:11:09 +02002331 if (ly_strncmp("unbounded", word, word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002332 errno = 0;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002333 num = strtoul(word, &ptr, LY_BASE_DEC);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002334 /* we have not parsed the whole argument */
Radek Krejciefd22f62018-09-27 11:47:58 +02002335 if ((size_t)(ptr - word) != word_len) {
David Sedlákb3077192019-06-19 10:55:37 +02002336 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "max-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002337 free(buf);
2338 return LY_EVALID;
2339 }
2340 if ((errno == ERANGE) || (num > UINT32_MAX)) {
David Sedlákb3077192019-06-19 10:55:37 +02002341 LOGVAL_PARSER(ctx, LY_VCODE_OOB, word_len, word, "max-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002342 free(buf);
2343 return LY_EVALID;
2344 }
2345
2346 *max = num;
Radek Krejcid6315102021-02-02 15:26:34 +01002347 } else {
2348 /* unbounded */
2349 *max = 0;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002350 }
2351 free(buf);
2352
aPieceka24a2252021-05-07 10:52:31 +02002353 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002354 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002355 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002356 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_MAX_ELEMENTS, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002357 break;
2358 default:
David Sedlákb3077192019-06-19 10:55:37 +02002359 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "max-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002360 return LY_EVALID;
2361 }
2362 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002363 return ret;
2364}
2365
Michal Vaskoea5abea2018-09-18 13:10:54 +02002366/**
2367 * @brief Parse the min-elements statement.
2368 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002369 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002370 * @param[in,out] min Value to write to.
2371 * @param[in,out] flags Flags to write to.
2372 * @param[in,out] exts Extension instances to add to.
2373 *
2374 * @return LY_ERR values.
2375 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02002376LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01002377parse_minelements(struct lys_yang_parser_ctx *ctx, uint32_t *min, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002378{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002379 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002380 char *buf, *word, *ptr;
Radek Krejciefd22f62018-09-27 11:47:58 +02002381 size_t word_len;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002382 unsigned long int num;
Radek Krejcid6b76452019-09-03 17:03:03 +02002383 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002384
2385 if (*flags & LYS_SET_MIN) {
David Sedlákb3077192019-06-19 10:55:37 +02002386 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "min-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002387 return LY_EVALID;
2388 }
2389 *flags |= LYS_SET_MIN;
2390
2391 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01002392 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002393
2394 if (!word_len || !isdigit(word[0]) || ((word[0] == '0') && (word_len > 1))) {
David Sedlákb3077192019-06-19 10:55:37 +02002395 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "min-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002396 free(buf);
2397 return LY_EVALID;
2398 }
2399
2400 errno = 0;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002401 num = strtoul(word, &ptr, LY_BASE_DEC);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002402 /* we have not parsed the whole argument */
Radek Krejciefd22f62018-09-27 11:47:58 +02002403 if ((size_t)(ptr - word) != word_len) {
David Sedlákb3077192019-06-19 10:55:37 +02002404 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "min-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002405 free(buf);
2406 return LY_EVALID;
2407 }
2408 if ((errno == ERANGE) || (num > UINT32_MAX)) {
David Sedlákb3077192019-06-19 10:55:37 +02002409 LOGVAL_PARSER(ctx, LY_VCODE_OOB, word_len, word, "min-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002410 free(buf);
2411 return LY_EVALID;
2412 }
2413 *min = num;
2414 free(buf);
2415
aPieceka24a2252021-05-07 10:52:31 +02002416 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002417 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002418 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002419 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_MIN_ELEMENTS, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002420 break;
2421 default:
David Sedlákb3077192019-06-19 10:55:37 +02002422 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "min-elements");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002423 return LY_EVALID;
2424 }
2425 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002426 return ret;
2427}
2428
Michal Vaskoea5abea2018-09-18 13:10:54 +02002429/**
2430 * @brief Parse the ordered-by statement.
2431 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002432 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002433 * @param[in,out] flags Flags to write to.
2434 * @param[in,out] exts Extension instances to add to.
2435 *
2436 * @return LY_ERR values.
2437 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002438static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01002439parse_orderedby(struct lys_yang_parser_ctx *ctx, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002440{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002441 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002442 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002443 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02002444 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002445
2446 if (*flags & LYS_ORDBY_MASK) {
David Sedlákb3077192019-06-19 10:55:37 +02002447 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "ordered-by");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002448 return LY_EVALID;
2449 }
2450
2451 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01002452 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002453
Radek Krejcif13b87b2020-12-01 22:02:17 +01002454 if ((word_len == ly_strlen_const("system")) && !strncmp(word, "system", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002455 *flags |= LYS_ORDBY_SYSTEM;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002456 } else if ((word_len == ly_strlen_const("user")) && !strncmp(word, "user", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002457 *flags |= LYS_ORDBY_USER;
2458 } else {
David Sedlákb3077192019-06-19 10:55:37 +02002459 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "ordered-by");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002460 free(buf);
2461 return LY_EVALID;
2462 }
2463 free(buf);
2464
aPieceka24a2252021-05-07 10:52:31 +02002465 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002466 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002467 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002468 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_ORDERED_BY, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002469 break;
2470 default:
David Sedlákb3077192019-06-19 10:55:37 +02002471 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "ordered-by");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002472 return LY_EVALID;
2473 }
2474 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002475 return ret;
2476}
2477
Michal Vaskoea5abea2018-09-18 13:10:54 +02002478/**
2479 * @brief Parse the leaf-list statement.
2480 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002481 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002482 * @param[in,out] siblings Siblings to add to.
2483 *
2484 * @return LY_ERR values.
2485 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02002486LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01002487parse_leaflist(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002488{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002489 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002490 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002491 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02002492 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002493 struct lysp_node_leaflist *llist;
2494
David Sedlák60adc092019-08-06 15:57:02 +02002495 /* create new leaf-list structure */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002496 LY_LIST_NEW_RET(PARSER_CTX(ctx), siblings, llist, next, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002497 llist->nodetype = LYS_LEAFLIST;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002498 llist->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002499
Michal Vasko7fbc8162018-09-17 10:35:16 +02002500 /* get name */
Radek Krejci33090f92020-12-17 20:12:46 +01002501 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02002502 INSERT_WORD_RET(ctx, buf, llist->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002503
2504 /* parse substatements */
aPieceka24a2252021-05-07 10:52:31 +02002505 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002506 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002507 case LY_STMT_CONFIG:
Radek Krejci33090f92020-12-17 20:12:46 +01002508 LY_CHECK_RET(parse_config(ctx, &llist->flags, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002509 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002510 case LY_STMT_DEFAULT:
Radek Krejci335332a2019-09-05 13:03:35 +02002511 PARSER_CHECK_STMTVER2_RET(ctx, "default", "leaf-list");
Radek Krejcifc596f92021-02-26 22:40:26 +01002512 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_DEFAULT, &llist->dflts, Y_STR_ARG, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002513 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002514 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01002515 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &llist->dsc, Y_STR_ARG, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002516 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002517 case LY_STMT_IF_FEATURE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002518 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &llist->iffeatures, Y_STR_ARG, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002519 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002520 case LY_STMT_MAX_ELEMENTS:
Radek Krejci33090f92020-12-17 20:12:46 +01002521 LY_CHECK_RET(parse_maxelements(ctx, &llist->max, &llist->flags, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002522 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002523 case LY_STMT_MIN_ELEMENTS:
Radek Krejci33090f92020-12-17 20:12:46 +01002524 LY_CHECK_RET(parse_minelements(ctx, &llist->min, &llist->flags, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002525 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002526 case LY_STMT_MUST:
Radek Krejci33090f92020-12-17 20:12:46 +01002527 LY_CHECK_RET(parse_restrs(ctx, kw, &llist->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002528 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002529 case LY_STMT_ORDERED_BY:
Radek Krejci33090f92020-12-17 20:12:46 +01002530 LY_CHECK_RET(parse_orderedby(ctx, &llist->flags, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002531 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002532 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002533 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &llist->ref, Y_STR_ARG, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002534 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002535 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01002536 LY_CHECK_RET(parse_status(ctx, &llist->flags, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002537 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002538 case LY_STMT_TYPE:
Radek Krejci33090f92020-12-17 20:12:46 +01002539 LY_CHECK_RET(parse_type(ctx, &llist->type));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002540 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002541 case LY_STMT_UNITS:
Radek Krejcifc596f92021-02-26 22:40:26 +01002542 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_UNITS, 0, &llist->units, Y_STR_ARG, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002543 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002544 case LY_STMT_WHEN:
Radek Krejci33090f92020-12-17 20:12:46 +01002545 LY_CHECK_RET(parse_when(ctx, &llist->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002546 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002547 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01002548 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_LEAF_LIST, 0, &llist->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002549 break;
2550 default:
David Sedlákb3077192019-06-19 10:55:37 +02002551 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "llist");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002552 return LY_EVALID;
2553 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002554 }
Radek Krejcic59bc972018-09-17 16:13:06 +02002555 LY_CHECK_RET(ret);
Radek Krejci6d6556c2018-11-08 09:37:45 +01002556checks:
Michal Vasko7fbc8162018-09-17 10:35:16 +02002557 /* mandatory substatements */
2558 if (!llist->type.name) {
David Sedlákb3077192019-06-19 10:55:37 +02002559 LOGVAL_PARSER(ctx, LY_VCODE_MISSTMT, "type", "leaf-list");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002560 return LY_EVALID;
2561 }
2562
2563 return ret;
2564}
2565
Michal Vaskoea5abea2018-09-18 13:10:54 +02002566/**
2567 * @brief Parse the refine statement.
2568 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002569 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002570 * @param[in,out] refines Refines to add to.
2571 *
2572 * @return LY_ERR values.
2573 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002574static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01002575parse_refine(struct lys_yang_parser_ctx *ctx, struct lysp_refine **refines)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002576{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002577 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002578 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002579 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02002580 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002581 struct lysp_refine *rf;
2582
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002583 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *refines, rf, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002584
2585 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01002586 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vaskob36053d2020-03-26 15:49:30 +01002587 CHECK_NONEMPTY(ctx, word_len, "refine");
Radek Krejci011e4aa2020-09-04 15:22:31 +02002588 INSERT_WORD_RET(ctx, buf, rf->nodeid, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002589
aPieceka24a2252021-05-07 10:52:31 +02002590 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002591 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002592 case LY_STMT_CONFIG:
Radek Krejci33090f92020-12-17 20:12:46 +01002593 LY_CHECK_RET(parse_config(ctx, &rf->flags, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002594 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002595 case LY_STMT_DEFAULT:
Radek Krejcifc596f92021-02-26 22:40:26 +01002596 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_DEFAULT, &rf->dflts, Y_STR_ARG, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002597 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002598 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01002599 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &rf->dsc, Y_STR_ARG, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002600 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002601 case LY_STMT_IF_FEATURE:
Radek Krejci335332a2019-09-05 13:03:35 +02002602 PARSER_CHECK_STMTVER2_RET(ctx, "if-feature", "refine");
Radek Krejcifc596f92021-02-26 22:40:26 +01002603 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &rf->iffeatures, Y_STR_ARG, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002604 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002605 case LY_STMT_MAX_ELEMENTS:
Radek Krejci33090f92020-12-17 20:12:46 +01002606 LY_CHECK_RET(parse_maxelements(ctx, &rf->max, &rf->flags, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002607 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002608 case LY_STMT_MIN_ELEMENTS:
Radek Krejci33090f92020-12-17 20:12:46 +01002609 LY_CHECK_RET(parse_minelements(ctx, &rf->min, &rf->flags, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002610 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002611 case LY_STMT_MUST:
Radek Krejci33090f92020-12-17 20:12:46 +01002612 LY_CHECK_RET(parse_restrs(ctx, kw, &rf->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002613 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002614 case LY_STMT_MANDATORY:
Radek Krejci33090f92020-12-17 20:12:46 +01002615 LY_CHECK_RET(parse_mandatory(ctx, &rf->flags, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002616 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002617 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002618 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &rf->ref, Y_STR_ARG, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002619 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002620 case LY_STMT_PRESENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002621 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_PRESENCE, 0, &rf->presence, Y_STR_ARG, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002622 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002623 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01002624 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_REFINE, 0, &rf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002625 break;
2626 default:
David Sedlákb3077192019-06-19 10:55:37 +02002627 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "refine");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002628 return LY_EVALID;
2629 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002630 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002631 return ret;
2632}
2633
Michal Vaskoea5abea2018-09-18 13:10:54 +02002634/**
2635 * @brief Parse the typedef statement.
2636 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002637 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002638 * @param[in,out] typedefs Typedefs to add to.
2639 *
2640 * @return LY_ERR values.
2641 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002642static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01002643parse_typedef(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_tpdf **typedefs)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002644{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002645 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002646 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002647 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02002648 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002649 struct lysp_tpdf *tpdf;
2650
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002651 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *typedefs, tpdf, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002652
2653 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01002654 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02002655 INSERT_WORD_RET(ctx, buf, tpdf->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002656
2657 /* parse substatements */
aPieceka24a2252021-05-07 10:52:31 +02002658 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002659 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002660 case LY_STMT_DEFAULT:
Radek Krejcifc596f92021-02-26 22:40:26 +01002661 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DEFAULT, 0, &tpdf->dflt.str, Y_STR_ARG, &tpdf->exts));
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002662 tpdf->dflt.mod = ctx->parsed_mod;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002663 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002664 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01002665 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &tpdf->dsc, Y_STR_ARG, &tpdf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002666 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002667 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002668 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &tpdf->ref, Y_STR_ARG, &tpdf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002669 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002670 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01002671 LY_CHECK_RET(parse_status(ctx, &tpdf->flags, &tpdf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002672 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002673 case LY_STMT_TYPE:
Radek Krejci33090f92020-12-17 20:12:46 +01002674 LY_CHECK_RET(parse_type(ctx, &tpdf->type));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002675 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002676 case LY_STMT_UNITS:
Radek Krejcifc596f92021-02-26 22:40:26 +01002677 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_UNITS, 0, &tpdf->units, Y_STR_ARG, &tpdf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002678 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002679 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01002680 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_TYPEDEF, 0, &tpdf->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002681 break;
2682 default:
David Sedlákb3077192019-06-19 10:55:37 +02002683 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "typedef");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002684 return LY_EVALID;
2685 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002686 }
Radek Krejcic59bc972018-09-17 16:13:06 +02002687 LY_CHECK_RET(ret);
Radek Krejcibbe09a92018-11-08 09:36:54 +01002688checks:
Michal Vasko7fbc8162018-09-17 10:35:16 +02002689 /* mandatory substatements */
2690 if (!tpdf->type.name) {
David Sedlákb3077192019-06-19 10:55:37 +02002691 LOGVAL_PARSER(ctx, LY_VCODE_MISSTMT, "type", "typedef");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002692 return LY_EVALID;
2693 }
2694
Radek Krejcibbe09a92018-11-08 09:36:54 +01002695 /* store data for collision check */
Michal Vasko7f45cf22020-10-01 12:49:44 +02002696 if (parent && !(parent->nodetype & (LYS_GROUPING | LYS_RPC | LYS_ACTION | LYS_INPUT | LYS_OUTPUT | LYS_NOTIF))) {
Radek Krejciba03a5a2020-08-27 14:40:41 +02002697 LY_CHECK_RET(ly_set_add(&ctx->tpdfs_nodes, parent, 0, NULL));
Radek Krejcibbe09a92018-11-08 09:36:54 +01002698 }
2699
Michal Vasko7fbc8162018-09-17 10:35:16 +02002700 return ret;
2701}
2702
Michal Vaskoea5abea2018-09-18 13:10:54 +02002703/**
2704 * @brief Parse the input or output statement.
2705 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002706 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002707 * @param[in] kw Type of this particular keyword
2708 * @param[in,out] inout_p Input/output pointer to write to.
2709 *
2710 * @return LY_ERR values.
2711 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02002712static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01002713parse_inout(struct lys_yang_parser_ctx *ctx, enum ly_stmt inout_kw, struct lysp_node *parent,
Radek Krejci2a9fc652021-01-22 17:44:34 +01002714 struct lysp_node_action_inout *inout_p)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002715{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002716 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002717 char *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002718 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02002719 enum ly_stmt kw;
Radek Krejci2a9fc652021-01-22 17:44:34 +01002720 ly_bool input = &((struct lysp_node_action *)parent)->input == inout_p ? 1 : 0;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002721
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002722 if (inout_p->nodetype) {
David Sedlákb3077192019-06-19 10:55:37 +02002723 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, ly_stmt2str(inout_kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002724 return LY_EVALID;
2725 }
2726
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002727 /* initiate structure */
Radek Krejci2a9fc652021-01-22 17:44:34 +01002728 LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), input ? "input" : "output", 0, &inout_p->name));
2729 inout_p->nodetype = input ? LYS_INPUT : LYS_OUTPUT;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01002730 inout_p->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002731
2732 /* parse substatements */
aPieceka24a2252021-05-07 10:52:31 +02002733 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002734 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002735 case LY_STMT_ANYDATA:
Radek Krejci335332a2019-09-05 13:03:35 +02002736 PARSER_CHECK_STMTVER2_RET(ctx, "anydata", ly_stmt2str(inout_kw));
Radek Krejci0f969882020-08-21 16:56:47 +02002737 /* fall through */
Radek Krejcid6b76452019-09-03 17:03:03 +02002738 case LY_STMT_ANYXML:
Radek Krejci01180ac2021-01-27 08:48:22 +01002739 LY_CHECK_RET(parse_any(ctx, kw, (struct lysp_node *)inout_p, &inout_p->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002740 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002741 case LY_STMT_CHOICE:
Radek Krejci01180ac2021-01-27 08:48:22 +01002742 LY_CHECK_RET(parse_choice(ctx, (struct lysp_node *)inout_p, &inout_p->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002743 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002744 case LY_STMT_CONTAINER:
Radek Krejci01180ac2021-01-27 08:48:22 +01002745 LY_CHECK_RET(parse_container(ctx, (struct lysp_node *)inout_p, &inout_p->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002746 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002747 case LY_STMT_LEAF:
Radek Krejci01180ac2021-01-27 08:48:22 +01002748 LY_CHECK_RET(parse_leaf(ctx, (struct lysp_node *)inout_p, &inout_p->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002749 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002750 case LY_STMT_LEAF_LIST:
Radek Krejci01180ac2021-01-27 08:48:22 +01002751 LY_CHECK_RET(parse_leaflist(ctx, (struct lysp_node *)inout_p, &inout_p->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002752 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002753 case LY_STMT_LIST:
Radek Krejci01180ac2021-01-27 08:48:22 +01002754 LY_CHECK_RET(parse_list(ctx, (struct lysp_node *)inout_p, &inout_p->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002755 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002756 case LY_STMT_USES:
Radek Krejci01180ac2021-01-27 08:48:22 +01002757 LY_CHECK_RET(parse_uses(ctx, (struct lysp_node *)inout_p, &inout_p->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002758 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002759 case LY_STMT_TYPEDEF:
Radek Krejci33090f92020-12-17 20:12:46 +01002760 LY_CHECK_RET(parse_typedef(ctx, (struct lysp_node *)inout_p, &inout_p->typedefs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002761 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002762 case LY_STMT_MUST:
Radek Krejci335332a2019-09-05 13:03:35 +02002763 PARSER_CHECK_STMTVER2_RET(ctx, "must", ly_stmt2str(inout_kw));
Radek Krejci33090f92020-12-17 20:12:46 +01002764 LY_CHECK_RET(parse_restrs(ctx, kw, &inout_p->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002765 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002766 case LY_STMT_GROUPING:
Radek Krejci33090f92020-12-17 20:12:46 +01002767 LY_CHECK_RET(parse_grouping(ctx, (struct lysp_node *)inout_p, &inout_p->groupings));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002768 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002769 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01002770 LY_CHECK_RET(parse_ext(ctx, word, word_len, inout_kw, 0, &inout_p->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002771 break;
2772 default:
David Sedlákb3077192019-06-19 10:55:37 +02002773 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(inout_kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002774 return LY_EVALID;
2775 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002776 }
Radek Krejci7fc68292019-06-12 13:51:09 +02002777 LY_CHECK_RET(ret);
Michal Vaskob83af8a2020-01-06 09:49:22 +01002778
Radek Krejci7fc68292019-06-12 13:51:09 +02002779checks:
Radek Krejci01180ac2021-01-27 08:48:22 +01002780 if (!inout_p->child) {
Michal Vaskob83af8a2020-01-06 09:49:22 +01002781 LOGVAL_PARSER(ctx, LY_VCODE_MISSTMT, "data-def-stmt", ly_stmt2str(inout_kw));
2782 return LY_EVALID;
2783 }
2784
Michal Vasko7fbc8162018-09-17 10:35:16 +02002785 return ret;
2786}
2787
Michal Vaskoea5abea2018-09-18 13:10:54 +02002788/**
2789 * @brief Parse the action statement.
2790 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002791 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002792 * @param[in,out] actions Actions to add to.
2793 *
2794 * @return LY_ERR values.
2795 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02002796LY_ERR
Radek Krejci2a9fc652021-01-22 17:44:34 +01002797parse_action(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node_action **actions)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002798{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002799 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002800 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002801 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02002802 enum ly_stmt kw;
Radek Krejci2a9fc652021-01-22 17:44:34 +01002803 struct lysp_node_action *act;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002804
Radek Krejci2a9fc652021-01-22 17:44:34 +01002805 LY_LIST_NEW_RET(PARSER_CTX(ctx), actions, act, next, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002806
2807 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01002808 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02002809 INSERT_WORD_RET(ctx, buf, act->name, word, word_len);
Michal Vasko1bf09392020-03-27 12:38:10 +01002810 act->nodetype = parent ? LYS_ACTION : LYS_RPC;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002811 act->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002812
aPieceka24a2252021-05-07 10:52:31 +02002813 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002814 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002815 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01002816 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &act->dsc, Y_STR_ARG, &act->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002817 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002818 case LY_STMT_IF_FEATURE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002819 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &act->iffeatures, Y_STR_ARG, &act->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002820 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002821 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002822 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &act->ref, Y_STR_ARG, &act->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002823 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002824 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01002825 LY_CHECK_RET(parse_status(ctx, &act->flags, &act->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002826 break;
2827
Radek Krejcid6b76452019-09-03 17:03:03 +02002828 case LY_STMT_INPUT:
Radek Krejci33090f92020-12-17 20:12:46 +01002829 LY_CHECK_RET(parse_inout(ctx, kw, (struct lysp_node *)act, &act->input));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002830 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002831 case LY_STMT_OUTPUT:
Radek Krejci33090f92020-12-17 20:12:46 +01002832 LY_CHECK_RET(parse_inout(ctx, kw, (struct lysp_node *)act, &act->output));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002833 break;
2834
Radek Krejcid6b76452019-09-03 17:03:03 +02002835 case LY_STMT_TYPEDEF:
Radek Krejci33090f92020-12-17 20:12:46 +01002836 LY_CHECK_RET(parse_typedef(ctx, (struct lysp_node *)act, &act->typedefs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002837 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002838 case LY_STMT_GROUPING:
Radek Krejci33090f92020-12-17 20:12:46 +01002839 LY_CHECK_RET(parse_grouping(ctx, (struct lysp_node *)act, &act->groupings));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002840 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002841 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01002842 LY_CHECK_RET(parse_ext(ctx, word, word_len, parent ? LY_STMT_ACTION : LY_STMT_RPC, 0, &act->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002843 break;
2844 default:
David Sedlákb3077192019-06-19 10:55:37 +02002845 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), parent ? "action" : "rpc");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002846 return LY_EVALID;
2847 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002848 }
Radek Krejci7fc68292019-06-12 13:51:09 +02002849 LY_CHECK_RET(ret);
Michal Vasko7f45cf22020-10-01 12:49:44 +02002850
Radek Krejci2a9fc652021-01-22 17:44:34 +01002851checks:
Michal Vasko7f45cf22020-10-01 12:49:44 +02002852 /* always initialize inout, they are technically present (needed for later deviations/refines) */
2853 if (!act->input.nodetype) {
2854 act->input.nodetype = LYS_INPUT;
2855 act->input.parent = (struct lysp_node *)act;
Radek Krejci2a9fc652021-01-22 17:44:34 +01002856 LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), "input", 0, &act->input.name));
Michal Vasko7f45cf22020-10-01 12:49:44 +02002857 }
2858 if (!act->output.nodetype) {
2859 act->output.nodetype = LYS_OUTPUT;
2860 act->output.parent = (struct lysp_node *)act;
Radek Krejci2a9fc652021-01-22 17:44:34 +01002861 LY_CHECK_RET(lydict_insert(PARSER_CTX(ctx), "output", 0, &act->output.name));
Michal Vasko7f45cf22020-10-01 12:49:44 +02002862 }
2863
Michal Vasko7fbc8162018-09-17 10:35:16 +02002864 return ret;
2865}
2866
Michal Vaskoea5abea2018-09-18 13:10:54 +02002867/**
2868 * @brief Parse the notification statement.
2869 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02002870 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02002871 * @param[in,out] notifs Notifications to add to.
2872 *
2873 * @return LY_ERR values.
2874 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02002875LY_ERR
Radek Krejci2a9fc652021-01-22 17:44:34 +01002876parse_notif(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node_notif **notifs)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002877{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002878 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002879 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002880 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02002881 enum ly_stmt kw;
Radek Krejci2a9fc652021-01-22 17:44:34 +01002882 struct lysp_node_notif *notif;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002883
Radek Krejci2a9fc652021-01-22 17:44:34 +01002884 LY_LIST_NEW_RET(PARSER_CTX(ctx), notifs, notif, next, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002885
2886 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01002887 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02002888 INSERT_WORD_RET(ctx, buf, notif->name, word, word_len);
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002889 notif->nodetype = LYS_NOTIF;
2890 notif->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002891
aPieceka24a2252021-05-07 10:52:31 +02002892 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002893 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002894 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01002895 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &notif->dsc, Y_STR_ARG, &notif->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002896 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002897 case LY_STMT_IF_FEATURE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002898 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &notif->iffeatures, Y_STR_ARG, &notif->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002899 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002900 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002901 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &notif->ref, Y_STR_ARG, &notif->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002902 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002903 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01002904 LY_CHECK_RET(parse_status(ctx, &notif->flags, &notif->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002905 break;
2906
Radek Krejcid6b76452019-09-03 17:03:03 +02002907 case LY_STMT_ANYDATA:
Radek Krejci335332a2019-09-05 13:03:35 +02002908 PARSER_CHECK_STMTVER2_RET(ctx, "anydata", "notification");
Radek Krejci0f969882020-08-21 16:56:47 +02002909 /* fall through */
Radek Krejcid6b76452019-09-03 17:03:03 +02002910 case LY_STMT_ANYXML:
Radek Krejci01180ac2021-01-27 08:48:22 +01002911 LY_CHECK_RET(parse_any(ctx, kw, (struct lysp_node *)notif, &notif->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002912 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002913 case LY_STMT_CHOICE:
Michal Vasko5ae1e1a2021-02-08 09:53:26 +01002914 LY_CHECK_RET(parse_choice(ctx, (struct lysp_node *)notif, &notif->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002915 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002916 case LY_STMT_CONTAINER:
Radek Krejci01180ac2021-01-27 08:48:22 +01002917 LY_CHECK_RET(parse_container(ctx, (struct lysp_node *)notif, &notif->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002918 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002919 case LY_STMT_LEAF:
Radek Krejci01180ac2021-01-27 08:48:22 +01002920 LY_CHECK_RET(parse_leaf(ctx, (struct lysp_node *)notif, &notif->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002921 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002922 case LY_STMT_LEAF_LIST:
Radek Krejci01180ac2021-01-27 08:48:22 +01002923 LY_CHECK_RET(parse_leaflist(ctx, (struct lysp_node *)notif, &notif->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002924 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002925 case LY_STMT_LIST:
Radek Krejci01180ac2021-01-27 08:48:22 +01002926 LY_CHECK_RET(parse_list(ctx, (struct lysp_node *)notif, &notif->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002927 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002928 case LY_STMT_USES:
Radek Krejci01180ac2021-01-27 08:48:22 +01002929 LY_CHECK_RET(parse_uses(ctx, (struct lysp_node *)notif, &notif->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002930 break;
2931
Radek Krejcid6b76452019-09-03 17:03:03 +02002932 case LY_STMT_MUST:
Radek Krejci335332a2019-09-05 13:03:35 +02002933 PARSER_CHECK_STMTVER2_RET(ctx, "must", "notification");
Radek Krejci33090f92020-12-17 20:12:46 +01002934 LY_CHECK_RET(parse_restrs(ctx, kw, &notif->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002935 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002936 case LY_STMT_TYPEDEF:
Radek Krejci33090f92020-12-17 20:12:46 +01002937 LY_CHECK_RET(parse_typedef(ctx, (struct lysp_node *)notif, &notif->typedefs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002938 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002939 case LY_STMT_GROUPING:
Radek Krejci33090f92020-12-17 20:12:46 +01002940 LY_CHECK_RET(parse_grouping(ctx, (struct lysp_node *)notif, &notif->groupings));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002941 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002942 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01002943 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NOTIFICATION, 0, &notif->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002944 break;
2945 default:
David Sedlákb3077192019-06-19 10:55:37 +02002946 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "notification");
Michal Vasko7fbc8162018-09-17 10:35:16 +02002947 return LY_EVALID;
2948 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02002949 }
Radek Krejci7fc68292019-06-12 13:51:09 +02002950
Michal Vasko7fbc8162018-09-17 10:35:16 +02002951 return ret;
2952}
2953
Michal Vaskoea5abea2018-09-18 13:10:54 +02002954/**
2955 * @brief Parse the grouping 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] groupings Groupings to add to.
2959 *
2960 * @return LY_ERR values.
2961 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02002962LY_ERR
Radek Krejci2a9fc652021-01-22 17:44:34 +01002963parse_grouping(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node_grp **groupings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02002964{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002965 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002966 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02002967 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02002968 enum ly_stmt kw;
Radek Krejci2a9fc652021-01-22 17:44:34 +01002969 struct lysp_node_grp *grp;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002970
Radek Krejci2a9fc652021-01-22 17:44:34 +01002971 LY_LIST_NEW_RET(PARSER_CTX(ctx), groupings, grp, next, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02002972
2973 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01002974 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02002975 INSERT_WORD_RET(ctx, buf, grp->name, word, word_len);
Radek Krejci6d9b9b52018-11-02 12:43:39 +01002976 grp->nodetype = LYS_GROUPING;
2977 grp->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02002978
aPieceka24a2252021-05-07 10:52:31 +02002979 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02002980 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02002981 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01002982 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &grp->dsc, Y_STR_ARG, &grp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002983 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002984 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01002985 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &grp->ref, Y_STR_ARG, &grp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002986 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002987 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01002988 LY_CHECK_RET(parse_status(ctx, &grp->flags, &grp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002989 break;
2990
Radek Krejcid6b76452019-09-03 17:03:03 +02002991 case LY_STMT_ANYDATA:
Radek Krejci335332a2019-09-05 13:03:35 +02002992 PARSER_CHECK_STMTVER2_RET(ctx, "anydata", "grouping");
Radek Krejci0f969882020-08-21 16:56:47 +02002993 /* fall through */
Radek Krejcid6b76452019-09-03 17:03:03 +02002994 case LY_STMT_ANYXML:
Radek Krejci01180ac2021-01-27 08:48:22 +01002995 LY_CHECK_RET(parse_any(ctx, kw, &grp->node, &grp->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002996 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02002997 case LY_STMT_CHOICE:
Radek Krejci01180ac2021-01-27 08:48:22 +01002998 LY_CHECK_RET(parse_choice(ctx, &grp->node, &grp->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02002999 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003000 case LY_STMT_CONTAINER:
Radek Krejci01180ac2021-01-27 08:48:22 +01003001 LY_CHECK_RET(parse_container(ctx, &grp->node, &grp->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003002 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003003 case LY_STMT_LEAF:
Radek Krejci01180ac2021-01-27 08:48:22 +01003004 LY_CHECK_RET(parse_leaf(ctx, &grp->node, &grp->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003005 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003006 case LY_STMT_LEAF_LIST:
Radek Krejci01180ac2021-01-27 08:48:22 +01003007 LY_CHECK_RET(parse_leaflist(ctx, &grp->node, &grp->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003008 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003009 case LY_STMT_LIST:
Radek Krejci01180ac2021-01-27 08:48:22 +01003010 LY_CHECK_RET(parse_list(ctx, &grp->node, &grp->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003011 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003012 case LY_STMT_USES:
Radek Krejci01180ac2021-01-27 08:48:22 +01003013 LY_CHECK_RET(parse_uses(ctx, &grp->node, &grp->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003014 break;
3015
Radek Krejcid6b76452019-09-03 17:03:03 +02003016 case LY_STMT_TYPEDEF:
Radek Krejci2a9fc652021-01-22 17:44:34 +01003017 LY_CHECK_RET(parse_typedef(ctx, &grp->node, &grp->typedefs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003018 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003019 case LY_STMT_ACTION:
Radek Krejci335332a2019-09-05 13:03:35 +02003020 PARSER_CHECK_STMTVER2_RET(ctx, "action", "grouping");
Radek Krejci2a9fc652021-01-22 17:44:34 +01003021 LY_CHECK_RET(parse_action(ctx, &grp->node, &grp->actions));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003022 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003023 case LY_STMT_GROUPING:
Radek Krejci2a9fc652021-01-22 17:44:34 +01003024 LY_CHECK_RET(parse_grouping(ctx, &grp->node, &grp->groupings));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003025 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003026 case LY_STMT_NOTIFICATION:
Radek Krejci335332a2019-09-05 13:03:35 +02003027 PARSER_CHECK_STMTVER2_RET(ctx, "notification", "grouping");
Radek Krejci2a9fc652021-01-22 17:44:34 +01003028 LY_CHECK_RET(parse_notif(ctx, &grp->node, &grp->notifs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003029 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003030 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01003031 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_GROUPING, 0, &grp->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003032 break;
3033 default:
David Sedlákb3077192019-06-19 10:55:37 +02003034 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "grouping");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003035 return LY_EVALID;
3036 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003037 }
Radek Krejci7fc68292019-06-12 13:51:09 +02003038
Michal Vasko7fbc8162018-09-17 10:35:16 +02003039 return ret;
3040}
3041
Michal Vaskoea5abea2018-09-18 13:10:54 +02003042/**
David Sedlák0d6de5a2019-07-22 13:25:44 +02003043 * @brief Parse the augment statement.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003044 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003045 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003046 * @param[in,out] augments Augments to add to.
3047 *
3048 * @return LY_ERR values.
3049 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003050LY_ERR
Radek Krejci2a9fc652021-01-22 17:44:34 +01003051parse_augment(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node_augment **augments)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003052{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003053 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003054 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003055 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02003056 enum ly_stmt kw;
Radek Krejci2a9fc652021-01-22 17:44:34 +01003057 struct lysp_node_augment *aug;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003058
Radek Krejci2a9fc652021-01-22 17:44:34 +01003059 LY_LIST_NEW_RET(PARSER_CTX(ctx), augments, aug, next, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003060
3061 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01003062 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vaskob36053d2020-03-26 15:49:30 +01003063 CHECK_NONEMPTY(ctx, word_len, "augment");
Radek Krejci011e4aa2020-09-04 15:22:31 +02003064 INSERT_WORD_RET(ctx, buf, aug->nodeid, word, word_len);
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003065 aug->nodetype = LYS_AUGMENT;
3066 aug->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003067
aPieceka24a2252021-05-07 10:52:31 +02003068 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003069 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02003070 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01003071 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &aug->dsc, Y_STR_ARG, &aug->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003072 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003073 case LY_STMT_IF_FEATURE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003074 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &aug->iffeatures, Y_STR_ARG, &aug->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003075 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003076 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003077 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &aug->ref, Y_STR_ARG, &aug->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003078 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003079 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01003080 LY_CHECK_RET(parse_status(ctx, &aug->flags, &aug->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003081 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003082 case LY_STMT_WHEN:
Radek Krejci33090f92020-12-17 20:12:46 +01003083 LY_CHECK_RET(parse_when(ctx, &aug->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003084 break;
3085
Radek Krejcid6b76452019-09-03 17:03:03 +02003086 case LY_STMT_ANYDATA:
Radek Krejci335332a2019-09-05 13:03:35 +02003087 PARSER_CHECK_STMTVER2_RET(ctx, "anydata", "augment");
Radek Krejci0f969882020-08-21 16:56:47 +02003088 /* fall through */
Radek Krejcid6b76452019-09-03 17:03:03 +02003089 case LY_STMT_ANYXML:
Radek Krejci33090f92020-12-17 20:12:46 +01003090 LY_CHECK_RET(parse_any(ctx, kw, (struct lysp_node *)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003091 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003092 case LY_STMT_CASE:
Radek Krejci33090f92020-12-17 20:12:46 +01003093 LY_CHECK_RET(parse_case(ctx, (struct lysp_node *)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003094 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003095 case LY_STMT_CHOICE:
Radek Krejci33090f92020-12-17 20:12:46 +01003096 LY_CHECK_RET(parse_choice(ctx, (struct lysp_node *)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003097 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003098 case LY_STMT_CONTAINER:
Radek Krejci33090f92020-12-17 20:12:46 +01003099 LY_CHECK_RET(parse_container(ctx, (struct lysp_node *)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003100 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003101 case LY_STMT_LEAF:
Radek Krejci33090f92020-12-17 20:12:46 +01003102 LY_CHECK_RET(parse_leaf(ctx, (struct lysp_node *)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003103 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003104 case LY_STMT_LEAF_LIST:
Radek Krejci33090f92020-12-17 20:12:46 +01003105 LY_CHECK_RET(parse_leaflist(ctx, (struct lysp_node *)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003106 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003107 case LY_STMT_LIST:
Radek Krejci33090f92020-12-17 20:12:46 +01003108 LY_CHECK_RET(parse_list(ctx, (struct lysp_node *)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003109 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003110 case LY_STMT_USES:
Radek Krejci33090f92020-12-17 20:12:46 +01003111 LY_CHECK_RET(parse_uses(ctx, (struct lysp_node *)aug, &aug->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003112 break;
3113
Radek Krejcid6b76452019-09-03 17:03:03 +02003114 case LY_STMT_ACTION:
Radek Krejci335332a2019-09-05 13:03:35 +02003115 PARSER_CHECK_STMTVER2_RET(ctx, "action", "augment");
Radek Krejci33090f92020-12-17 20:12:46 +01003116 LY_CHECK_RET(parse_action(ctx, (struct lysp_node *)aug, &aug->actions));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003117 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003118 case LY_STMT_NOTIFICATION:
Radek Krejci335332a2019-09-05 13:03:35 +02003119 PARSER_CHECK_STMTVER2_RET(ctx, "notification", "augment");
Radek Krejci33090f92020-12-17 20:12:46 +01003120 LY_CHECK_RET(parse_notif(ctx, (struct lysp_node *)aug, &aug->notifs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003121 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003122 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01003123 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_AUGMENT, 0, &aug->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003124 break;
3125 default:
David Sedlákb3077192019-06-19 10:55:37 +02003126 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "augment");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003127 return LY_EVALID;
3128 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003129 }
Radek Krejci7fc68292019-06-12 13:51:09 +02003130
Michal Vasko7fbc8162018-09-17 10:35:16 +02003131 return ret;
3132}
3133
Michal Vaskoea5abea2018-09-18 13:10:54 +02003134/**
3135 * @brief Parse the uses statement.
3136 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003137 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003138 * @param[in,out] siblings Siblings to add to.
3139 *
3140 * @return LY_ERR values.
3141 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003142LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01003143parse_uses(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003144{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003145 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003146 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003147 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02003148 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003149 struct lysp_node_uses *uses;
3150
David Sedlák60adc092019-08-06 15:57:02 +02003151 /* create uses structure */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003152 LY_LIST_NEW_RET(PARSER_CTX(ctx), siblings, uses, next, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003153 uses->nodetype = LYS_USES;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003154 uses->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003155
Michal Vasko7fbc8162018-09-17 10:35:16 +02003156 /* get name */
Radek Krejci33090f92020-12-17 20:12:46 +01003157 LY_CHECK_RET(get_argument(ctx, Y_PREF_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02003158 INSERT_WORD_RET(ctx, buf, uses->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003159
3160 /* parse substatements */
aPieceka24a2252021-05-07 10:52:31 +02003161 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003162 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02003163 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01003164 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &uses->dsc, Y_STR_ARG, &uses->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003165 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003166 case LY_STMT_IF_FEATURE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003167 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &uses->iffeatures, Y_STR_ARG, &uses->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003168 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003169 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003170 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &uses->ref, Y_STR_ARG, &uses->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003171 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003172 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01003173 LY_CHECK_RET(parse_status(ctx, &uses->flags, &uses->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003174 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003175 case LY_STMT_WHEN:
Radek Krejci33090f92020-12-17 20:12:46 +01003176 LY_CHECK_RET(parse_when(ctx, &uses->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003177 break;
3178
Radek Krejcid6b76452019-09-03 17:03:03 +02003179 case LY_STMT_REFINE:
Radek Krejci33090f92020-12-17 20:12:46 +01003180 LY_CHECK_RET(parse_refine(ctx, &uses->refines));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003181 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003182 case LY_STMT_AUGMENT:
Radek Krejci33090f92020-12-17 20:12:46 +01003183 LY_CHECK_RET(parse_augment(ctx, (struct lysp_node *)uses, &uses->augments));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003184 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003185 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01003186 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_USES, 0, &uses->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003187 break;
3188 default:
David Sedlákb3077192019-06-19 10:55:37 +02003189 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "uses");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003190 return LY_EVALID;
3191 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003192 }
Radek Krejci7fc68292019-06-12 13:51:09 +02003193
Michal Vasko7fbc8162018-09-17 10:35:16 +02003194 return ret;
3195}
3196
Michal Vaskoea5abea2018-09-18 13:10:54 +02003197/**
3198 * @brief Parse the case statement.
3199 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003200 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003201 * @param[in,out] siblings Siblings to add to.
3202 *
3203 * @return LY_ERR values.
3204 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003205LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01003206parse_case(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003207{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003208 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003209 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003210 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02003211 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003212 struct lysp_node_case *cas;
3213
David Sedlák60adc092019-08-06 15:57:02 +02003214 /* create new case structure */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003215 LY_LIST_NEW_RET(PARSER_CTX(ctx), siblings, cas, next, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003216 cas->nodetype = LYS_CASE;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003217 cas->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003218
Michal Vasko7fbc8162018-09-17 10:35:16 +02003219 /* get name */
Radek Krejci33090f92020-12-17 20:12:46 +01003220 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02003221 INSERT_WORD_RET(ctx, buf, cas->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003222
3223 /* parse substatements */
aPieceka24a2252021-05-07 10:52:31 +02003224 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003225 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02003226 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01003227 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &cas->dsc, Y_STR_ARG, &cas->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003228 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003229 case LY_STMT_IF_FEATURE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003230 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &cas->iffeatures, Y_STR_ARG, &cas->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003231 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003232 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003233 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &cas->ref, Y_STR_ARG, &cas->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003234 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003235 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01003236 LY_CHECK_RET(parse_status(ctx, &cas->flags, &cas->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003237 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003238 case LY_STMT_WHEN:
Radek Krejci33090f92020-12-17 20:12:46 +01003239 LY_CHECK_RET(parse_when(ctx, &cas->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003240 break;
3241
Radek Krejcid6b76452019-09-03 17:03:03 +02003242 case LY_STMT_ANYDATA:
Radek Krejci335332a2019-09-05 13:03:35 +02003243 PARSER_CHECK_STMTVER2_RET(ctx, "anydata", "case");
Radek Krejci0f969882020-08-21 16:56:47 +02003244 /* fall through */
Radek Krejcid6b76452019-09-03 17:03:03 +02003245 case LY_STMT_ANYXML:
Radek Krejci33090f92020-12-17 20:12:46 +01003246 LY_CHECK_RET(parse_any(ctx, kw, (struct lysp_node *)cas, &cas->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003247 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003248 case LY_STMT_CHOICE:
Radek Krejci33090f92020-12-17 20:12:46 +01003249 LY_CHECK_RET(parse_choice(ctx, (struct lysp_node *)cas, &cas->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003250 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003251 case LY_STMT_CONTAINER:
Radek Krejci33090f92020-12-17 20:12:46 +01003252 LY_CHECK_RET(parse_container(ctx, (struct lysp_node *)cas, &cas->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003253 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003254 case LY_STMT_LEAF:
Radek Krejci33090f92020-12-17 20:12:46 +01003255 LY_CHECK_RET(parse_leaf(ctx, (struct lysp_node *)cas, &cas->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003256 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003257 case LY_STMT_LEAF_LIST:
Radek Krejci33090f92020-12-17 20:12:46 +01003258 LY_CHECK_RET(parse_leaflist(ctx, (struct lysp_node *)cas, &cas->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003259 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003260 case LY_STMT_LIST:
Radek Krejci33090f92020-12-17 20:12:46 +01003261 LY_CHECK_RET(parse_list(ctx, (struct lysp_node *)cas, &cas->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003262 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003263 case LY_STMT_USES:
Radek Krejci33090f92020-12-17 20:12:46 +01003264 LY_CHECK_RET(parse_uses(ctx, (struct lysp_node *)cas, &cas->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003265 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003266 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01003267 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_CASE, 0, &cas->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003268 break;
3269 default:
David Sedlákb3077192019-06-19 10:55:37 +02003270 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "case");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003271 return LY_EVALID;
3272 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003273 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003274 return ret;
3275}
3276
Michal Vaskoea5abea2018-09-18 13:10:54 +02003277/**
3278 * @brief Parse the choice statement.
3279 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003280 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003281 * @param[in,out] siblings Siblings to add to.
3282 *
3283 * @return LY_ERR values.
3284 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003285LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01003286parse_choice(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003287{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003288 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003289 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003290 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02003291 enum ly_stmt kw;
Radek Krejci44ceedc2018-10-02 15:54:31 +02003292 struct lysp_node_choice *choice;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003293
David Sedlák60adc092019-08-06 15:57:02 +02003294 /* create new choice structure */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003295 LY_LIST_NEW_RET(PARSER_CTX(ctx), siblings, choice, next, LY_EMEM);
Radek Krejci44ceedc2018-10-02 15:54:31 +02003296 choice->nodetype = LYS_CHOICE;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003297 choice->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003298
Michal Vasko7fbc8162018-09-17 10:35:16 +02003299 /* get name */
Radek Krejci33090f92020-12-17 20:12:46 +01003300 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02003301 INSERT_WORD_RET(ctx, buf, choice->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003302
3303 /* parse substatements */
aPieceka24a2252021-05-07 10:52:31 +02003304 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003305 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02003306 case LY_STMT_CONFIG:
Radek Krejci33090f92020-12-17 20:12:46 +01003307 LY_CHECK_RET(parse_config(ctx, &choice->flags, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003308 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003309 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01003310 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &choice->dsc, Y_STR_ARG, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003311 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003312 case LY_STMT_IF_FEATURE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003313 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &choice->iffeatures, Y_STR_ARG, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003314 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003315 case LY_STMT_MANDATORY:
Radek Krejci33090f92020-12-17 20:12:46 +01003316 LY_CHECK_RET(parse_mandatory(ctx, &choice->flags, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003317 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003318 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003319 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &choice->ref, Y_STR_ARG, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003320 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003321 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01003322 LY_CHECK_RET(parse_status(ctx, &choice->flags, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003323 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003324 case LY_STMT_WHEN:
Radek Krejci33090f92020-12-17 20:12:46 +01003325 LY_CHECK_RET(parse_when(ctx, &choice->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003326 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003327 case LY_STMT_DEFAULT:
Radek Krejcifc596f92021-02-26 22:40:26 +01003328 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DEFAULT, 0, &choice->dflt.str, Y_PREF_IDENTIF_ARG,
Michal Vasko7f45cf22020-10-01 12:49:44 +02003329 &choice->exts));
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003330 choice->dflt.mod = ctx->parsed_mod;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003331 break;
3332
Radek Krejcid6b76452019-09-03 17:03:03 +02003333 case LY_STMT_ANYDATA:
Radek Krejci335332a2019-09-05 13:03:35 +02003334 PARSER_CHECK_STMTVER2_RET(ctx, "anydata", "choice");
Radek Krejci0f969882020-08-21 16:56:47 +02003335 /* fall through */
Radek Krejcid6b76452019-09-03 17:03:03 +02003336 case LY_STMT_ANYXML:
Radek Krejci33090f92020-12-17 20:12:46 +01003337 LY_CHECK_RET(parse_any(ctx, kw, (struct lysp_node *)choice, &choice->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003338 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003339 case LY_STMT_CASE:
Radek Krejci33090f92020-12-17 20:12:46 +01003340 LY_CHECK_RET(parse_case(ctx, (struct lysp_node *)choice, &choice->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003341 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003342 case LY_STMT_CHOICE:
Radek Krejci335332a2019-09-05 13:03:35 +02003343 PARSER_CHECK_STMTVER2_RET(ctx, "choice", "choice");
Radek Krejci33090f92020-12-17 20:12:46 +01003344 LY_CHECK_RET(parse_choice(ctx, (struct lysp_node *)choice, &choice->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003345 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003346 case LY_STMT_CONTAINER:
Radek Krejci33090f92020-12-17 20:12:46 +01003347 LY_CHECK_RET(parse_container(ctx, (struct lysp_node *)choice, &choice->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003348 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003349 case LY_STMT_LEAF:
Radek Krejci33090f92020-12-17 20:12:46 +01003350 LY_CHECK_RET(parse_leaf(ctx, (struct lysp_node *)choice, &choice->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003351 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003352 case LY_STMT_LEAF_LIST:
Radek Krejci33090f92020-12-17 20:12:46 +01003353 LY_CHECK_RET(parse_leaflist(ctx, (struct lysp_node *)choice, &choice->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003354 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003355 case LY_STMT_LIST:
Radek Krejci33090f92020-12-17 20:12:46 +01003356 LY_CHECK_RET(parse_list(ctx, (struct lysp_node *)choice, &choice->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003357 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003358 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01003359 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_CHOICE, 0, &choice->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003360 break;
3361 default:
David Sedlákb3077192019-06-19 10:55:37 +02003362 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "choice");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003363 return LY_EVALID;
3364 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003365 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003366 return ret;
3367}
3368
Michal Vaskoea5abea2018-09-18 13:10:54 +02003369/**
3370 * @brief Parse the container statement.
3371 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003372 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003373 * @param[in,out] siblings Siblings to add to.
3374 *
3375 * @return LY_ERR values.
3376 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003377LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01003378parse_container(struct lys_yang_parser_ctx *ctx, struct lysp_node *parent, struct lysp_node **siblings)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003379{
3380 LY_ERR ret = 0;
3381 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003382 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02003383 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003384 struct lysp_node_container *cont;
3385
David Sedlák60adc092019-08-06 15:57:02 +02003386 /* create new container structure */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003387 LY_LIST_NEW_RET(PARSER_CTX(ctx), siblings, cont, next, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003388 cont->nodetype = LYS_CONTAINER;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003389 cont->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003390
Michal Vasko7fbc8162018-09-17 10:35:16 +02003391 /* get name */
Radek Krejci33090f92020-12-17 20:12:46 +01003392 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02003393 INSERT_WORD_RET(ctx, buf, cont->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003394
3395 /* parse substatements */
aPieceka24a2252021-05-07 10:52:31 +02003396 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003397 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02003398 case LY_STMT_CONFIG:
Radek Krejci33090f92020-12-17 20:12:46 +01003399 LY_CHECK_RET(parse_config(ctx, &cont->flags, &cont->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003400 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003401 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01003402 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &cont->dsc, Y_STR_ARG, &cont->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003403 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003404 case LY_STMT_IF_FEATURE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003405 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &cont->iffeatures, Y_STR_ARG, &cont->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003406 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003407 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003408 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &cont->ref, Y_STR_ARG, &cont->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003409 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003410 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01003411 LY_CHECK_RET(parse_status(ctx, &cont->flags, &cont->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003412 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003413 case LY_STMT_WHEN:
Radek Krejci33090f92020-12-17 20:12:46 +01003414 LY_CHECK_RET(parse_when(ctx, &cont->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003415 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003416 case LY_STMT_PRESENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003417 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_PRESENCE, 0, &cont->presence, Y_STR_ARG, &cont->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003418 break;
3419
Radek Krejcid6b76452019-09-03 17:03:03 +02003420 case LY_STMT_ANYDATA:
Radek Krejci335332a2019-09-05 13:03:35 +02003421 PARSER_CHECK_STMTVER2_RET(ctx, "anydata", "container");
Radek Krejci0f969882020-08-21 16:56:47 +02003422 /* fall through */
Radek Krejcid6b76452019-09-03 17:03:03 +02003423 case LY_STMT_ANYXML:
Radek Krejci33090f92020-12-17 20:12:46 +01003424 LY_CHECK_RET(parse_any(ctx, kw, (struct lysp_node *)cont, &cont->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003425 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003426 case LY_STMT_CHOICE:
Radek Krejci33090f92020-12-17 20:12:46 +01003427 LY_CHECK_RET(parse_choice(ctx, (struct lysp_node *)cont, &cont->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003428 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003429 case LY_STMT_CONTAINER:
Radek Krejci33090f92020-12-17 20:12:46 +01003430 LY_CHECK_RET(parse_container(ctx, (struct lysp_node *)cont, &cont->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003431 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003432 case LY_STMT_LEAF:
Radek Krejci33090f92020-12-17 20:12:46 +01003433 LY_CHECK_RET(parse_leaf(ctx, (struct lysp_node *)cont, &cont->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003434 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003435 case LY_STMT_LEAF_LIST:
Radek Krejci33090f92020-12-17 20:12:46 +01003436 LY_CHECK_RET(parse_leaflist(ctx, (struct lysp_node *)cont, &cont->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003437 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003438 case LY_STMT_LIST:
Radek Krejci33090f92020-12-17 20:12:46 +01003439 LY_CHECK_RET(parse_list(ctx, (struct lysp_node *)cont, &cont->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003440 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003441 case LY_STMT_USES:
Radek Krejci33090f92020-12-17 20:12:46 +01003442 LY_CHECK_RET(parse_uses(ctx, (struct lysp_node *)cont, &cont->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003443 break;
3444
Radek Krejcid6b76452019-09-03 17:03:03 +02003445 case LY_STMT_TYPEDEF:
Radek Krejci33090f92020-12-17 20:12:46 +01003446 LY_CHECK_RET(parse_typedef(ctx, (struct lysp_node *)cont, &cont->typedefs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003447 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003448 case LY_STMT_MUST:
Radek Krejci33090f92020-12-17 20:12:46 +01003449 LY_CHECK_RET(parse_restrs(ctx, kw, &cont->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003450 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003451 case LY_STMT_ACTION:
Radek Krejci335332a2019-09-05 13:03:35 +02003452 PARSER_CHECK_STMTVER2_RET(ctx, "action", "container");
Radek Krejci33090f92020-12-17 20:12:46 +01003453 LY_CHECK_RET(parse_action(ctx, (struct lysp_node *)cont, &cont->actions));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003454 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003455 case LY_STMT_GROUPING:
Radek Krejci33090f92020-12-17 20:12:46 +01003456 LY_CHECK_RET(parse_grouping(ctx, (struct lysp_node *)cont, &cont->groupings));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003457 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003458 case LY_STMT_NOTIFICATION:
Radek Krejci335332a2019-09-05 13:03:35 +02003459 PARSER_CHECK_STMTVER2_RET(ctx, "notification", "container");
Radek Krejci33090f92020-12-17 20:12:46 +01003460 LY_CHECK_RET(parse_notif(ctx, (struct lysp_node *)cont, &cont->notifs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003461 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003462 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01003463 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_CONTAINER, 0, &cont->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003464 break;
3465 default:
David Sedlákb3077192019-06-19 10:55:37 +02003466 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "container");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003467 return LY_EVALID;
3468 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003469 }
Radek Krejci2a9fc652021-01-22 17:44:34 +01003470
Michal Vasko7fbc8162018-09-17 10:35:16 +02003471 return ret;
3472}
3473
Michal Vaskoea5abea2018-09-18 13:10:54 +02003474/**
3475 * @brief Parse the list statement.
3476 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003477 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003478 * @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 Krejci33090f92020-12-17 20:12:46 +01003483parse_list(struct lys_yang_parser_ctx *ctx, 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;
Radek Krejcid6b76452019-09-03 17:03:03 +02003488 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003489 struct lysp_node_list *list;
3490
David Sedlák60adc092019-08-06 15:57:02 +02003491 /* create new list structure */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003492 LY_LIST_NEW_RET(PARSER_CTX(ctx), siblings, list, next, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003493 list->nodetype = LYS_LIST;
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003494 list->parent = parent;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003495
Michal Vasko7fbc8162018-09-17 10:35:16 +02003496 /* get name */
Radek Krejci33090f92020-12-17 20:12:46 +01003497 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02003498 INSERT_WORD_RET(ctx, buf, list->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003499
3500 /* parse substatements */
aPieceka24a2252021-05-07 10:52:31 +02003501 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003502 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02003503 case LY_STMT_CONFIG:
Radek Krejci33090f92020-12-17 20:12:46 +01003504 LY_CHECK_RET(parse_config(ctx, &list->flags, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003505 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003506 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01003507 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &list->dsc, Y_STR_ARG, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003508 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003509 case LY_STMT_IF_FEATURE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003510 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &list->iffeatures, Y_STR_ARG, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003511 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003512 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003513 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &list->ref, Y_STR_ARG, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003514 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003515 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01003516 LY_CHECK_RET(parse_status(ctx, &list->flags, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003517 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003518 case LY_STMT_WHEN:
Radek Krejci33090f92020-12-17 20:12:46 +01003519 LY_CHECK_RET(parse_when(ctx, &list->when));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003520 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003521 case LY_STMT_KEY:
Radek Krejcifc596f92021-02-26 22:40:26 +01003522 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_KEY, 0, &list->key, Y_STR_ARG, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003523 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003524 case LY_STMT_MAX_ELEMENTS:
Radek Krejci33090f92020-12-17 20:12:46 +01003525 LY_CHECK_RET(parse_maxelements(ctx, &list->max, &list->flags, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003526 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003527 case LY_STMT_MIN_ELEMENTS:
Radek Krejci33090f92020-12-17 20:12:46 +01003528 LY_CHECK_RET(parse_minelements(ctx, &list->min, &list->flags, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003529 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003530 case LY_STMT_ORDERED_BY:
Radek Krejci33090f92020-12-17 20:12:46 +01003531 LY_CHECK_RET(parse_orderedby(ctx, &list->flags, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003532 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003533 case LY_STMT_UNIQUE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003534 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_UNIQUE, &list->uniques, Y_STR_ARG, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003535 break;
3536
Radek Krejcid6b76452019-09-03 17:03:03 +02003537 case LY_STMT_ANYDATA:
Radek Krejci335332a2019-09-05 13:03:35 +02003538 PARSER_CHECK_STMTVER2_RET(ctx, "anydata", "list");
Radek Krejci0f969882020-08-21 16:56:47 +02003539 /* fall through */
Radek Krejcid6b76452019-09-03 17:03:03 +02003540 case LY_STMT_ANYXML:
Radek Krejci33090f92020-12-17 20:12:46 +01003541 LY_CHECK_RET(parse_any(ctx, kw, (struct lysp_node *)list, &list->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003542 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003543 case LY_STMT_CHOICE:
Radek Krejci33090f92020-12-17 20:12:46 +01003544 LY_CHECK_RET(parse_choice(ctx, (struct lysp_node *)list, &list->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003545 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003546 case LY_STMT_CONTAINER:
Radek Krejci33090f92020-12-17 20:12:46 +01003547 LY_CHECK_RET(parse_container(ctx, (struct lysp_node *)list, &list->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003548 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003549 case LY_STMT_LEAF:
Radek Krejci33090f92020-12-17 20:12:46 +01003550 LY_CHECK_RET(parse_leaf(ctx, (struct lysp_node *)list, &list->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003551 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003552 case LY_STMT_LEAF_LIST:
Radek Krejci33090f92020-12-17 20:12:46 +01003553 LY_CHECK_RET(parse_leaflist(ctx, (struct lysp_node *)list, &list->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003554 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003555 case LY_STMT_LIST:
Radek Krejci33090f92020-12-17 20:12:46 +01003556 LY_CHECK_RET(parse_list(ctx, (struct lysp_node *)list, &list->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003557 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003558 case LY_STMT_USES:
Radek Krejci33090f92020-12-17 20:12:46 +01003559 LY_CHECK_RET(parse_uses(ctx, (struct lysp_node *)list, &list->child));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003560 break;
3561
Radek Krejcid6b76452019-09-03 17:03:03 +02003562 case LY_STMT_TYPEDEF:
Radek Krejci33090f92020-12-17 20:12:46 +01003563 LY_CHECK_RET(parse_typedef(ctx, (struct lysp_node *)list, &list->typedefs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003564 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003565 case LY_STMT_MUST:
Radek Krejci33090f92020-12-17 20:12:46 +01003566 LY_CHECK_RET(parse_restrs(ctx, kw, &list->musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003567 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003568 case LY_STMT_ACTION:
Radek Krejci335332a2019-09-05 13:03:35 +02003569 PARSER_CHECK_STMTVER2_RET(ctx, "action", "list");
Radek Krejci33090f92020-12-17 20:12:46 +01003570 LY_CHECK_RET(parse_action(ctx, (struct lysp_node *)list, &list->actions));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003571 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003572 case LY_STMT_GROUPING:
Radek Krejci33090f92020-12-17 20:12:46 +01003573 LY_CHECK_RET(parse_grouping(ctx, (struct lysp_node *)list, &list->groupings));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003574 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003575 case LY_STMT_NOTIFICATION:
Radek Krejci335332a2019-09-05 13:03:35 +02003576 PARSER_CHECK_STMTVER2_RET(ctx, "notification", "list");
Radek Krejci33090f92020-12-17 20:12:46 +01003577 LY_CHECK_RET(parse_notif(ctx, (struct lysp_node *)list, &list->notifs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003578 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003579 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01003580 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_LIST, 0, &list->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003581 break;
3582 default:
David Sedlákb3077192019-06-19 10:55:37 +02003583 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "list");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003584 return LY_EVALID;
3585 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003586 }
Radek Krejci7fc68292019-06-12 13:51:09 +02003587
Michal Vasko7fbc8162018-09-17 10:35:16 +02003588 return ret;
3589}
3590
Michal Vaskoea5abea2018-09-18 13:10:54 +02003591/**
3592 * @brief Parse the yin-element statement.
3593 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003594 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003595 * @param[in,out] flags Flags to write to.
3596 * @param[in,out] exts Extension instances to add to.
3597 *
3598 * @return LY_ERR values.
3599 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02003600static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01003601parse_yinelement(struct lys_yang_parser_ctx *ctx, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003602{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003603 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003604 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003605 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02003606 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003607
3608 if (*flags & LYS_YINELEM_MASK) {
David Sedlákb3077192019-06-19 10:55:37 +02003609 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "yin-element");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003610 return LY_EVALID;
3611 }
3612
3613 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01003614 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003615
Radek Krejcif13b87b2020-12-01 22:02:17 +01003616 if ((word_len == ly_strlen_const("true")) && !strncmp(word, "true", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003617 *flags |= LYS_YINELEM_TRUE;
Radek Krejcif13b87b2020-12-01 22:02:17 +01003618 } else if ((word_len == ly_strlen_const("false")) && !strncmp(word, "false", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003619 *flags |= LYS_YINELEM_FALSE;
3620 } else {
David Sedlákb3077192019-06-19 10:55:37 +02003621 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "yin-element");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003622 free(buf);
3623 return LY_EVALID;
3624 }
3625 free(buf);
3626
aPieceka24a2252021-05-07 10:52:31 +02003627 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003628 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02003629 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003630 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_YIN_ELEMENT, 0, exts));
Michal Vaskod989ba02020-08-24 10:59:24 +02003631 LY_CHECK_RET(ret);
3632 break;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003633 default:
David Sedlákb3077192019-06-19 10:55:37 +02003634 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "yin-element");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003635 return LY_EVALID;
3636 }
3637 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003638 return ret;
3639}
3640
Michal Vaskoea5abea2018-09-18 13:10:54 +02003641/**
David Sedlák2444f8f2019-07-09 11:02:47 +02003642 * @brief Parse the argument statement.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003643 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003644 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003645 * @param[in,out] argument Value to write to.
3646 * @param[in,out] flags Flags to write to.
3647 * @param[in,out] exts Extension instances to add to.
3648 *
3649 * @return LY_ERR values.
3650 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02003651static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01003652parse_argument(struct lys_yang_parser_ctx *ctx, const char **argument, uint16_t *flags, struct lysp_ext_instance **exts)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003653{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003654 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003655 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003656 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02003657 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003658
3659 if (*argument) {
David Sedlákb3077192019-06-19 10:55:37 +02003660 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, "argument");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003661 return LY_EVALID;
3662 }
3663
3664 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01003665 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02003666 INSERT_WORD_RET(ctx, buf, *argument, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003667
aPieceka24a2252021-05-07 10:52:31 +02003668 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003669 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02003670 case LY_STMT_YIN_ELEMENT:
Radek Krejci33090f92020-12-17 20:12:46 +01003671 LY_CHECK_RET(parse_yinelement(ctx, flags, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003672 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003673 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003674 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_ARGUMENT, 0, exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003675 break;
3676 default:
David Sedlákb3077192019-06-19 10:55:37 +02003677 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "argument");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003678 return LY_EVALID;
3679 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003680 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003681 return ret;
3682}
3683
Michal Vaskoea5abea2018-09-18 13:10:54 +02003684/**
3685 * @brief Parse the extension statement.
3686 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003687 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003688 * @param[in,out] extensions Extensions to add to.
3689 *
3690 * @return LY_ERR values.
3691 */
Michal Vasko7fbc8162018-09-17 10:35:16 +02003692static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01003693parse_extension(struct lys_yang_parser_ctx *ctx, struct lysp_ext **extensions)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003694{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003695 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003696 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003697 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02003698 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003699 struct lysp_ext *ex;
3700
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003701 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *extensions, ex, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003702
3703 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01003704 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02003705 INSERT_WORD_RET(ctx, buf, ex->name, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003706
aPieceka24a2252021-05-07 10:52:31 +02003707 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003708 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02003709 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01003710 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &ex->dsc, Y_STR_ARG, &ex->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003711 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003712 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003713 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &ex->ref, Y_STR_ARG, &ex->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003714 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003715 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01003716 LY_CHECK_RET(parse_status(ctx, &ex->flags, &ex->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003717 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003718 case LY_STMT_ARGUMENT:
Radek Krejci9f87b0c2021-03-05 14:45:26 +01003719 LY_CHECK_RET(parse_argument(ctx, &ex->argname, &ex->flags, &ex->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003720 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003721 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01003722 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_EXTENSION, 0, &ex->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003723 break;
3724 default:
David Sedlákb3077192019-06-19 10:55:37 +02003725 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "extension");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003726 return LY_EVALID;
3727 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003728 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003729 return ret;
3730}
3731
Michal Vaskoea5abea2018-09-18 13:10:54 +02003732/**
3733 * @brief Parse the deviate statement.
3734 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003735 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003736 * @param[in,out] deviates Deviates to add to.
3737 *
3738 * @return LY_ERR values.
3739 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003740LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01003741parse_deviate(struct lys_yang_parser_ctx *ctx, struct lysp_deviate **deviates)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003742{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003743 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003744 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003745 size_t word_len, dev_mod;
Radek Krejcid6b76452019-09-03 17:03:03 +02003746 enum ly_stmt kw;
David Sedlák60adc092019-08-06 15:57:02 +02003747 struct lysp_deviate *d;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003748 struct lysp_deviate_add *d_add = NULL;
3749 struct lysp_deviate_rpl *d_rpl = NULL;
3750 struct lysp_deviate_del *d_del = NULL;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003751 const char **d_units = NULL;
3752 struct lysp_qname **d_uniques = NULL, **d_dflts = NULL;
Radek Krejci4ad42aa2019-07-23 16:55:58 +02003753 struct lysp_restr **d_musts = NULL;
3754 uint16_t *d_flags = 0;
3755 uint32_t *d_min = 0, *d_max = 0;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003756
3757 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01003758 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003759
Radek Krejcif13b87b2020-12-01 22:02:17 +01003760 if ((word_len == ly_strlen_const("not-supported")) && !strncmp(word, "not-supported", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003761 dev_mod = LYS_DEV_NOT_SUPPORTED;
Radek Krejcif13b87b2020-12-01 22:02:17 +01003762 } else if ((word_len == ly_strlen_const("add")) && !strncmp(word, "add", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003763 dev_mod = LYS_DEV_ADD;
Radek Krejcif13b87b2020-12-01 22:02:17 +01003764 } else if ((word_len == ly_strlen_const("replace")) && !strncmp(word, "replace", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003765 dev_mod = LYS_DEV_REPLACE;
Radek Krejcif13b87b2020-12-01 22:02:17 +01003766 } else if ((word_len == ly_strlen_const("delete")) && !strncmp(word, "delete", word_len)) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003767 dev_mod = LYS_DEV_DELETE;
3768 } else {
David Sedlákb3077192019-06-19 10:55:37 +02003769 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, word_len, word, "deviate");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003770 free(buf);
3771 return LY_EVALID;
3772 }
3773 free(buf);
3774
3775 /* create structure */
3776 switch (dev_mod) {
3777 case LYS_DEV_NOT_SUPPORTED:
3778 d = calloc(1, sizeof *d);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003779 LY_CHECK_ERR_RET(!d, LOGMEM(PARSER_CTX(ctx)), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003780 break;
3781 case LYS_DEV_ADD:
3782 d_add = calloc(1, sizeof *d_add);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003783 LY_CHECK_ERR_RET(!d_add, LOGMEM(PARSER_CTX(ctx)), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003784 d = (struct lysp_deviate *)d_add;
3785 d_units = &d_add->units;
3786 d_uniques = &d_add->uniques;
3787 d_dflts = &d_add->dflts;
3788 d_musts = &d_add->musts;
3789 d_flags = &d_add->flags;
3790 d_min = &d_add->min;
3791 d_max = &d_add->max;
3792 break;
3793 case LYS_DEV_REPLACE:
3794 d_rpl = calloc(1, sizeof *d_rpl);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003795 LY_CHECK_ERR_RET(!d_rpl, LOGMEM(PARSER_CTX(ctx)), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003796 d = (struct lysp_deviate *)d_rpl;
3797 d_units = &d_rpl->units;
3798 d_flags = &d_rpl->flags;
3799 d_min = &d_rpl->min;
3800 d_max = &d_rpl->max;
3801 break;
3802 case LYS_DEV_DELETE:
3803 d_del = calloc(1, sizeof *d_del);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003804 LY_CHECK_ERR_RET(!d_del, LOGMEM(PARSER_CTX(ctx)), LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003805 d = (struct lysp_deviate *)d_del;
3806 d_units = &d_del->units;
3807 d_uniques = &d_del->uniques;
3808 d_dflts = &d_del->dflts;
3809 d_musts = &d_del->musts;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003810 break;
3811 default:
3812 assert(0);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003813 LOGINT_RET(PARSER_CTX(ctx));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003814 }
3815 d->mod = dev_mod;
3816
3817 /* insert into siblings */
David Sedlák60adc092019-08-06 15:57:02 +02003818 LY_LIST_INSERT(deviates, d, next);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003819
aPieceka24a2252021-05-07 10:52:31 +02003820 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003821 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02003822 case LY_STMT_CONFIG:
Michal Vasko7fbc8162018-09-17 10:35:16 +02003823 switch (dev_mod) {
3824 case LYS_DEV_NOT_SUPPORTED:
Michal Vasko492bec72018-09-18 13:11:10 +02003825 case LYS_DEV_DELETE:
David Sedlákb3077192019-06-19 10:55:37 +02003826 LOGVAL_PARSER(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003827 return LY_EVALID;
3828 default:
Radek Krejci33090f92020-12-17 20:12:46 +01003829 LY_CHECK_RET(parse_config(ctx, d_flags, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003830 break;
3831 }
3832 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003833 case LY_STMT_DEFAULT:
Michal Vasko7fbc8162018-09-17 10:35:16 +02003834 switch (dev_mod) {
3835 case LYS_DEV_NOT_SUPPORTED:
David Sedlákb3077192019-06-19 10:55:37 +02003836 LOGVAL_PARSER(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003837 return LY_EVALID;
3838 case LYS_DEV_REPLACE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003839 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DEFAULT, 0, &d_rpl->dflt.str, Y_STR_ARG, &d->exts));
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003840 d_rpl->dflt.mod = ctx->parsed_mod;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003841 break;
3842 default:
Radek Krejcifc596f92021-02-26 22:40:26 +01003843 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_DEFAULT, d_dflts, Y_STR_ARG, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003844 break;
3845 }
3846 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003847 case LY_STMT_MANDATORY:
Michal Vasko7fbc8162018-09-17 10:35:16 +02003848 switch (dev_mod) {
3849 case LYS_DEV_NOT_SUPPORTED:
Michal Vasko492bec72018-09-18 13:11:10 +02003850 case LYS_DEV_DELETE:
David Sedlákb3077192019-06-19 10:55:37 +02003851 LOGVAL_PARSER(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003852 return LY_EVALID;
3853 default:
Radek Krejci33090f92020-12-17 20:12:46 +01003854 LY_CHECK_RET(parse_mandatory(ctx, d_flags, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003855 break;
3856 }
3857 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003858 case LY_STMT_MAX_ELEMENTS:
Michal Vasko7fbc8162018-09-17 10:35:16 +02003859 switch (dev_mod) {
3860 case LYS_DEV_NOT_SUPPORTED:
Michal Vasko492bec72018-09-18 13:11:10 +02003861 case LYS_DEV_DELETE:
David Sedlákb3077192019-06-19 10:55:37 +02003862 LOGVAL_PARSER(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003863 return LY_EVALID;
3864 default:
Radek Krejci33090f92020-12-17 20:12:46 +01003865 LY_CHECK_RET(parse_maxelements(ctx, d_max, d_flags, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003866 break;
3867 }
3868 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003869 case LY_STMT_MIN_ELEMENTS:
Michal Vasko7fbc8162018-09-17 10:35:16 +02003870 switch (dev_mod) {
3871 case LYS_DEV_NOT_SUPPORTED:
Michal Vasko492bec72018-09-18 13:11:10 +02003872 case LYS_DEV_DELETE:
David Sedlákb3077192019-06-19 10:55:37 +02003873 LOGVAL_PARSER(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003874 return LY_EVALID;
3875 default:
Radek Krejci33090f92020-12-17 20:12:46 +01003876 LY_CHECK_RET(parse_minelements(ctx, d_min, d_flags, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003877 break;
3878 }
3879 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003880 case LY_STMT_MUST:
Michal Vasko7fbc8162018-09-17 10:35:16 +02003881 switch (dev_mod) {
3882 case LYS_DEV_NOT_SUPPORTED:
Michal Vasko492bec72018-09-18 13:11:10 +02003883 case LYS_DEV_REPLACE:
David Sedlákb3077192019-06-19 10:55:37 +02003884 LOGVAL_PARSER(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003885 return LY_EVALID;
3886 default:
Radek Krejci33090f92020-12-17 20:12:46 +01003887 LY_CHECK_RET(parse_restrs(ctx, kw, d_musts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003888 break;
3889 }
3890 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003891 case LY_STMT_TYPE:
Michal Vasko7fbc8162018-09-17 10:35:16 +02003892 switch (dev_mod) {
3893 case LYS_DEV_NOT_SUPPORTED:
3894 case LYS_DEV_ADD:
3895 case LYS_DEV_DELETE:
David Sedlákb3077192019-06-19 10:55:37 +02003896 LOGVAL_PARSER(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003897 return LY_EVALID;
3898 default:
Radek Krejci2c02f3e2018-10-16 10:54:38 +02003899 if (d_rpl->type) {
David Sedlákb3077192019-06-19 10:55:37 +02003900 LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, ly_stmt2str(kw));
Radek Krejci2c02f3e2018-10-16 10:54:38 +02003901 return LY_EVALID;
3902 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003903 d_rpl->type = calloc(1, sizeof *d_rpl->type);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003904 LY_CHECK_ERR_RET(!d_rpl->type, LOGMEM(PARSER_CTX(ctx)), LY_EMEM);
Radek Krejci33090f92020-12-17 20:12:46 +01003905 LY_CHECK_RET(parse_type(ctx, d_rpl->type));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003906 break;
3907 }
3908 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003909 case LY_STMT_UNIQUE:
Michal Vasko7fbc8162018-09-17 10:35:16 +02003910 switch (dev_mod) {
3911 case LYS_DEV_NOT_SUPPORTED:
3912 case LYS_DEV_REPLACE:
David Sedlákb3077192019-06-19 10:55:37 +02003913 LOGVAL_PARSER(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003914 return LY_EVALID;
3915 default:
Radek Krejcifc596f92021-02-26 22:40:26 +01003916 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_UNIQUE, d_uniques, Y_STR_ARG, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003917 break;
3918 }
3919 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003920 case LY_STMT_UNITS:
Michal Vasko7fbc8162018-09-17 10:35:16 +02003921 switch (dev_mod) {
3922 case LYS_DEV_NOT_SUPPORTED:
David Sedlákb3077192019-06-19 10:55:37 +02003923 LOGVAL_PARSER(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003924 return LY_EVALID;
3925 default:
Radek Krejcifc596f92021-02-26 22:40:26 +01003926 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_UNITS, 0, d_units, Y_STR_ARG, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003927 break;
3928 }
3929 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003930 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01003931 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_DEVIATE, 0, &d->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003932 break;
3933 default:
David Sedlákb3077192019-06-19 10:55:37 +02003934 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "deviate");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003935 return LY_EVALID;
3936 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003937 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003938 return ret;
3939}
3940
Michal Vaskoea5abea2018-09-18 13:10:54 +02003941/**
3942 * @brief Parse the deviation statement.
3943 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003944 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003945 * @param[in,out] deviations Deviations to add to.
3946 *
3947 * @return LY_ERR values.
3948 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02003949LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01003950parse_deviation(struct lys_yang_parser_ctx *ctx, struct lysp_deviation **deviations)
Michal Vasko7fbc8162018-09-17 10:35:16 +02003951{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01003952 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003953 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02003954 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02003955 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02003956 struct lysp_deviation *dev;
3957
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003958 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *deviations, dev, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003959
3960 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01003961 LY_CHECK_RET(get_argument(ctx, Y_STR_ARG, NULL, &word, &buf, &word_len));
Michal Vaskob36053d2020-03-26 15:49:30 +01003962 CHECK_NONEMPTY(ctx, word_len, "deviation");
Radek Krejci011e4aa2020-09-04 15:22:31 +02003963 INSERT_WORD_RET(ctx, buf, dev->nodeid, word, word_len);
Michal Vasko7fbc8162018-09-17 10:35:16 +02003964
aPieceka24a2252021-05-07 10:52:31 +02003965 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02003966 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02003967 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01003968 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &dev->dsc, Y_STR_ARG, &dev->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003969 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003970 case LY_STMT_DEVIATE:
Radek Krejci33090f92020-12-17 20:12:46 +01003971 LY_CHECK_RET(parse_deviate(ctx, &dev->deviates));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003972 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003973 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01003974 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &dev->ref, Y_STR_ARG, &dev->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003975 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02003976 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01003977 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_DEVIATION, 0, &dev->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02003978 break;
3979 default:
David Sedlákb3077192019-06-19 10:55:37 +02003980 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "deviation");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003981 return LY_EVALID;
3982 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02003983 }
Radek Krejcic59bc972018-09-17 16:13:06 +02003984 LY_CHECK_RET(ret);
Radek Krejci6d6556c2018-11-08 09:37:45 +01003985checks:
Michal Vasko7fbc8162018-09-17 10:35:16 +02003986 /* mandatory substatements */
3987 if (!dev->deviates) {
David Sedlákb3077192019-06-19 10:55:37 +02003988 LOGVAL_PARSER(ctx, LY_VCODE_MISSTMT, "deviate", "deviation");
Michal Vasko7fbc8162018-09-17 10:35:16 +02003989 return LY_EVALID;
3990 }
3991
3992 return ret;
3993}
3994
Michal Vaskoea5abea2018-09-18 13:10:54 +02003995/**
3996 * @brief Parse the feature statement.
3997 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02003998 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02003999 * @param[in,out] features Features to add to.
4000 *
4001 * @return LY_ERR values.
4002 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02004003LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01004004parse_feature(struct lys_yang_parser_ctx *ctx, struct lysp_feature **features)
Michal Vasko7fbc8162018-09-17 10:35:16 +02004005{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004006 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004007 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02004008 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02004009 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004010 struct lysp_feature *feat;
4011
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004012 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *features, feat, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004013
4014 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01004015 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02004016 INSERT_WORD_RET(ctx, buf, feat->name, word, word_len);
Radek Krejcifaa1eac2018-10-30 14:34:55 +01004017
aPieceka24a2252021-05-07 10:52:31 +02004018 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02004019 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02004020 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01004021 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &feat->dsc, Y_STR_ARG, &feat->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004022 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004023 case LY_STMT_IF_FEATURE:
Radek Krejcifc596f92021-02-26 22:40:26 +01004024 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &feat->iffeatures, Y_STR_ARG, &feat->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004025 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004026 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01004027 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &feat->ref, Y_STR_ARG, &feat->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004028 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004029 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01004030 LY_CHECK_RET(parse_status(ctx, &feat->flags, &feat->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004031 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004032 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01004033 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_FEATURE, 0, &feat->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004034 break;
4035 default:
David Sedlákb3077192019-06-19 10:55:37 +02004036 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "feature");
Radek Krejci2c02f3e2018-10-16 10:54:38 +02004037 return LY_EVALID;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004038 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004039 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004040 return ret;
4041}
4042
Michal Vaskoea5abea2018-09-18 13:10:54 +02004043/**
4044 * @brief Parse the identity statement.
4045 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02004046 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02004047 * @param[in,out] identities Identities to add to.
4048 *
4049 * @return LY_ERR values.
4050 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02004051LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01004052parse_identity(struct lys_yang_parser_ctx *ctx, struct lysp_ident **identities)
Michal Vasko7fbc8162018-09-17 10:35:16 +02004053{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004054 LY_ERR ret = LY_SUCCESS;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004055 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02004056 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02004057 enum ly_stmt kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004058 struct lysp_ident *ident;
4059
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004060 LY_ARRAY_NEW_RET(PARSER_CTX(ctx), *identities, ident, LY_EMEM);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004061
4062 /* get value */
Radek Krejci33090f92020-12-17 20:12:46 +01004063 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02004064 INSERT_WORD_RET(ctx, buf, ident->name, word, word_len);
Radek Krejcifaa1eac2018-10-30 14:34:55 +01004065
aPieceka24a2252021-05-07 10:52:31 +02004066 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, return LY_SUCCESS, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02004067 switch (kw) {
Radek Krejcid6b76452019-09-03 17:03:03 +02004068 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01004069 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &ident->dsc, Y_STR_ARG, &ident->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004070 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004071 case LY_STMT_IF_FEATURE:
Radek Krejci335332a2019-09-05 13:03:35 +02004072 PARSER_CHECK_STMTVER2_RET(ctx, "if-feature", "identity");
Radek Krejcifc596f92021-02-26 22:40:26 +01004073 LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &ident->iffeatures, Y_STR_ARG, &ident->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004074 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004075 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01004076 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &ident->ref, Y_STR_ARG, &ident->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004077 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004078 case LY_STMT_STATUS:
Radek Krejci33090f92020-12-17 20:12:46 +01004079 LY_CHECK_RET(parse_status(ctx, &ident->flags, &ident->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004080 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004081 case LY_STMT_BASE:
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004082 if (ident->bases && (ctx->parsed_mod->version < LYS_VERSION_1_1)) {
David Sedlákb3077192019-06-19 10:55:37 +02004083 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Identity can be derived from multiple base identities only in YANG 1.1 modules");
Radek Krejci10113652018-11-14 16:56:50 +01004084 return LY_EVALID;
4085 }
Radek Krejcifc596f92021-02-26 22:40:26 +01004086 LY_CHECK_RET(parse_text_fields(ctx, LY_STMT_BASE, &ident->bases, Y_PREF_IDENTIF_ARG, &ident->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004087 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004088 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01004089 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_IDENTITY, 0, &ident->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004090 break;
4091 default:
David Sedlákb3077192019-06-19 10:55:37 +02004092 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "identity");
Michal Vasko7fbc8162018-09-17 10:35:16 +02004093 return LY_EVALID;
4094 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004095 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004096 return ret;
4097}
4098
Michal Vaskoea5abea2018-09-18 13:10:54 +02004099/**
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004100 * @brief Parse module substatements.
Michal Vaskoea5abea2018-09-18 13:10:54 +02004101 *
Radek Krejci44ceedc2018-10-02 15:54:31 +02004102 * @param[in] ctx yang parser context for logging.
Michal Vaskoea5abea2018-09-18 13:10:54 +02004103 * @param[in,out] mod Module to write to.
4104 *
4105 * @return LY_ERR values.
4106 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02004107LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01004108parse_module(struct lys_yang_parser_ctx *ctx, struct lysp_module *mod)
Michal Vasko7fbc8162018-09-17 10:35:16 +02004109{
4110 LY_ERR ret = 0;
4111 char *buf, *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02004112 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02004113 enum ly_stmt kw, prev_kw = 0;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004114 enum yang_module_stmt mod_stmt = Y_MOD_MODULE_HEADER;
Michal Vasko8dc31992021-02-22 10:30:47 +01004115 const struct lysp_submodule *dup;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004116
Michal Vaskoc3781c32020-10-06 14:04:08 +02004117 mod->is_submod = 0;
4118
4119 /* module name */
Radek Krejci33090f92020-12-17 20:12:46 +01004120 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02004121 INSERT_WORD_RET(ctx, buf, mod->mod->name, word, word_len);
Radek Krejcifaa1eac2018-10-30 14:34:55 +01004122
aPieceka24a2252021-05-07 10:52:31 +02004123 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks, return ret) {
Michal Vasko7fbc8162018-09-17 10:35:16 +02004124
Radek Krejcie3846472018-10-15 15:24:51 +02004125#define CHECK_ORDER(SECTION) \
David Sedlákb3077192019-06-19 10:55:37 +02004126 if (mod_stmt > SECTION) {LOGVAL_PARSER(ctx, LY_VCODE_INORD, ly_stmt2str(kw), ly_stmt2str(prev_kw)); return LY_EVALID;}mod_stmt = SECTION
Radek Krejcie3846472018-10-15 15:24:51 +02004127
Michal Vasko7fbc8162018-09-17 10:35:16 +02004128 switch (kw) {
4129 /* module header */
Radek Krejcid6b76452019-09-03 17:03:03 +02004130 case LY_STMT_NAMESPACE:
4131 case LY_STMT_PREFIX:
Radek Krejcie3846472018-10-15 15:24:51 +02004132 CHECK_ORDER(Y_MOD_MODULE_HEADER);
4133 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004134 case LY_STMT_YANG_VERSION:
Radek Krejcie3846472018-10-15 15:24:51 +02004135 CHECK_ORDER(Y_MOD_MODULE_HEADER);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004136 break;
4137 /* linkage */
Radek Krejcid6b76452019-09-03 17:03:03 +02004138 case LY_STMT_INCLUDE:
4139 case LY_STMT_IMPORT:
Radek Krejcie3846472018-10-15 15:24:51 +02004140 CHECK_ORDER(Y_MOD_LINKAGE);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004141 break;
4142 /* meta */
Radek Krejcid6b76452019-09-03 17:03:03 +02004143 case LY_STMT_ORGANIZATION:
4144 case LY_STMT_CONTACT:
4145 case LY_STMT_DESCRIPTION:
4146 case LY_STMT_REFERENCE:
Radek Krejcie3846472018-10-15 15:24:51 +02004147 CHECK_ORDER(Y_MOD_META);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004148 break;
4149
4150 /* revision */
Radek Krejcid6b76452019-09-03 17:03:03 +02004151 case LY_STMT_REVISION:
Radek Krejcie3846472018-10-15 15:24:51 +02004152 CHECK_ORDER(Y_MOD_REVISION);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004153 break;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004154 /* body */
Radek Krejcid6b76452019-09-03 17:03:03 +02004155 case LY_STMT_ANYDATA:
4156 case LY_STMT_ANYXML:
4157 case LY_STMT_AUGMENT:
4158 case LY_STMT_CHOICE:
4159 case LY_STMT_CONTAINER:
4160 case LY_STMT_DEVIATION:
4161 case LY_STMT_EXTENSION:
4162 case LY_STMT_FEATURE:
4163 case LY_STMT_GROUPING:
4164 case LY_STMT_IDENTITY:
4165 case LY_STMT_LEAF:
4166 case LY_STMT_LEAF_LIST:
4167 case LY_STMT_LIST:
4168 case LY_STMT_NOTIFICATION:
4169 case LY_STMT_RPC:
4170 case LY_STMT_TYPEDEF:
4171 case LY_STMT_USES:
4172 case LY_STMT_EXTENSION_INSTANCE:
Michal Vasko7fbc8162018-09-17 10:35:16 +02004173 mod_stmt = Y_MOD_BODY;
4174 break;
4175 default:
4176 /* error handled in the next switch */
4177 break;
4178 }
Radek Krejcie3846472018-10-15 15:24:51 +02004179#undef CHECK_ORDER
Michal Vasko7fbc8162018-09-17 10:35:16 +02004180
Radek Krejcie3846472018-10-15 15:24:51 +02004181 prev_kw = kw;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004182 switch (kw) {
4183 /* module header */
Radek Krejcid6b76452019-09-03 17:03:03 +02004184 case LY_STMT_YANG_VERSION:
Radek Krejci33090f92020-12-17 20:12:46 +01004185 LY_CHECK_RET(parse_yangversion(ctx, &mod->version, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004186 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004187 case LY_STMT_NAMESPACE:
Radek Krejcifc596f92021-02-26 22:40:26 +01004188 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_NAMESPACE, 0, &mod->mod->ns, Y_STR_ARG, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004189 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004190 case LY_STMT_PREFIX:
Radek Krejcifc596f92021-02-26 22:40:26 +01004191 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_PREFIX, 0, &mod->mod->prefix, Y_IDENTIF_ARG, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004192 break;
4193
4194 /* linkage */
Radek Krejcid6b76452019-09-03 17:03:03 +02004195 case LY_STMT_INCLUDE:
Radek Krejci33090f92020-12-17 20:12:46 +01004196 LY_CHECK_RET(parse_include(ctx, mod->mod->name, &mod->includes));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004197 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004198 case LY_STMT_IMPORT:
Radek Krejci33090f92020-12-17 20:12:46 +01004199 LY_CHECK_RET(parse_import(ctx, mod->mod->prefix, &mod->imports));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004200 break;
4201
4202 /* meta */
Radek Krejcid6b76452019-09-03 17:03:03 +02004203 case LY_STMT_ORGANIZATION:
Radek Krejcifc596f92021-02-26 22:40:26 +01004204 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_ORGANIZATION, 0, &mod->mod->org, Y_STR_ARG, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004205 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004206 case LY_STMT_CONTACT:
Radek Krejcifc596f92021-02-26 22:40:26 +01004207 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_CONTACT, 0, &mod->mod->contact, Y_STR_ARG, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004208 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004209 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01004210 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &mod->mod->dsc, Y_STR_ARG, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004211 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004212 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01004213 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &mod->mod->ref, Y_STR_ARG, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004214 break;
4215
4216 /* revision */
Radek Krejcid6b76452019-09-03 17:03:03 +02004217 case LY_STMT_REVISION:
Radek Krejci33090f92020-12-17 20:12:46 +01004218 LY_CHECK_RET(parse_revision(ctx, &mod->revs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004219 break;
4220
4221 /* body */
Radek Krejcid6b76452019-09-03 17:03:03 +02004222 case LY_STMT_ANYDATA:
Radek Krejci335332a2019-09-05 13:03:35 +02004223 PARSER_CHECK_STMTVER2_RET(ctx, "anydata", "module");
Radek Krejci0f969882020-08-21 16:56:47 +02004224 /* fall through */
Radek Krejcid6b76452019-09-03 17:03:03 +02004225 case LY_STMT_ANYXML:
Radek Krejci33090f92020-12-17 20:12:46 +01004226 LY_CHECK_RET(parse_any(ctx, kw, NULL, &mod->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004227 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004228 case LY_STMT_CHOICE:
Radek Krejci33090f92020-12-17 20:12:46 +01004229 LY_CHECK_RET(parse_choice(ctx, NULL, &mod->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004230 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004231 case LY_STMT_CONTAINER:
Radek Krejci33090f92020-12-17 20:12:46 +01004232 LY_CHECK_RET(parse_container(ctx, NULL, &mod->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004233 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004234 case LY_STMT_LEAF:
Radek Krejci33090f92020-12-17 20:12:46 +01004235 LY_CHECK_RET(parse_leaf(ctx, NULL, &mod->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004236 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004237 case LY_STMT_LEAF_LIST:
Radek Krejci33090f92020-12-17 20:12:46 +01004238 LY_CHECK_RET(parse_leaflist(ctx, NULL, &mod->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004239 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004240 case LY_STMT_LIST:
Radek Krejci33090f92020-12-17 20:12:46 +01004241 LY_CHECK_RET(parse_list(ctx, NULL, &mod->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004242 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004243 case LY_STMT_USES:
Radek Krejci33090f92020-12-17 20:12:46 +01004244 LY_CHECK_RET(parse_uses(ctx, NULL, &mod->data));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004245 break;
4246
Radek Krejcid6b76452019-09-03 17:03:03 +02004247 case LY_STMT_AUGMENT:
Radek Krejci33090f92020-12-17 20:12:46 +01004248 LY_CHECK_RET(parse_augment(ctx, NULL, &mod->augments));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004249 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004250 case LY_STMT_DEVIATION:
Radek Krejci33090f92020-12-17 20:12:46 +01004251 LY_CHECK_RET(parse_deviation(ctx, &mod->deviations));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004252 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004253 case LY_STMT_EXTENSION:
Radek Krejci33090f92020-12-17 20:12:46 +01004254 LY_CHECK_RET(parse_extension(ctx, &mod->extensions));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004255 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004256 case LY_STMT_FEATURE:
Radek Krejci33090f92020-12-17 20:12:46 +01004257 LY_CHECK_RET(parse_feature(ctx, &mod->features));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004258 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004259 case LY_STMT_GROUPING:
Radek Krejci33090f92020-12-17 20:12:46 +01004260 LY_CHECK_RET(parse_grouping(ctx, NULL, &mod->groupings));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004261 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004262 case LY_STMT_IDENTITY:
Radek Krejci33090f92020-12-17 20:12:46 +01004263 LY_CHECK_RET(parse_identity(ctx, &mod->identities));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004264 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004265 case LY_STMT_NOTIFICATION:
Radek Krejci33090f92020-12-17 20:12:46 +01004266 LY_CHECK_RET(parse_notif(ctx, NULL, &mod->notifs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004267 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004268 case LY_STMT_RPC:
Radek Krejci33090f92020-12-17 20:12:46 +01004269 LY_CHECK_RET(parse_action(ctx, NULL, &mod->rpcs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004270 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004271 case LY_STMT_TYPEDEF:
Radek Krejci33090f92020-12-17 20:12:46 +01004272 LY_CHECK_RET(parse_typedef(ctx, NULL, &mod->typedefs));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004273 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004274 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01004275 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_MODULE, 0, &mod->exts));
Michal Vasko7fbc8162018-09-17 10:35:16 +02004276 break;
4277
4278 default:
David Sedlákb3077192019-06-19 10:55:37 +02004279 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "module");
Michal Vasko7fbc8162018-09-17 10:35:16 +02004280 return LY_EVALID;
4281 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004282 }
Radek Krejcic59bc972018-09-17 16:13:06 +02004283 LY_CHECK_RET(ret);
Radek Krejcie86bf772018-12-14 11:39:53 +01004284
Radek Krejci6d6556c2018-11-08 09:37:45 +01004285checks:
Michal Vasko7fbc8162018-09-17 10:35:16 +02004286 /* mandatory substatements */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004287 if (!mod->mod->ns) {
David Sedlákb3077192019-06-19 10:55:37 +02004288 LOGVAL_PARSER(ctx, LY_VCODE_MISSTMT, "namespace", "module");
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004289 return LY_EVALID;
4290 } else if (!mod->mod->prefix) {
David Sedlákb3077192019-06-19 10:55:37 +02004291 LOGVAL_PARSER(ctx, LY_VCODE_MISSTMT, "prefix", "module");
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004292 return LY_EVALID;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004293 }
4294
Radek Krejcie9e987e2018-10-31 12:50:27 +01004295 /* submodules share the namespace with the module names, so there must not be
4296 * a submodule of the same name in the context, no need for revision matching */
Michal Vasko8dc31992021-02-22 10:30:47 +01004297 dup = ly_ctx_get_submodule_latest(PARSER_CTX(ctx), mod->mod->name);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004298 if (dup) {
Radek Krejci854e1552020-12-21 15:05:23 +01004299 LOGVAL_PARSER(ctx, LY_VCODE_NAME2_COL, "module", "submodule", mod->mod->name);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004300 return LY_EVALID;
4301 }
4302
4303 return ret;
4304}
4305
4306/**
4307 * @brief Parse submodule substatements.
4308 *
4309 * @param[in] ctx yang parser context for logging.
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004310 * @param[out] submod Parsed submodule structure.
4311 *
4312 * @return LY_ERR values.
4313 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02004314LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01004315parse_submodule(struct lys_yang_parser_ctx *ctx, struct lysp_submodule *submod)
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004316{
4317 LY_ERR ret = 0;
4318 char *buf, *word;
4319 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02004320 enum ly_stmt kw, prev_kw = 0;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004321 enum yang_module_stmt mod_stmt = Y_MOD_MODULE_HEADER;
Michal Vasko8dc31992021-02-22 10:30:47 +01004322 const struct lysp_submodule *dup;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004323
Michal Vaskoc3781c32020-10-06 14:04:08 +02004324 submod->is_submod = 1;
4325
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004326 /* submodule name */
Radek Krejci33090f92020-12-17 20:12:46 +01004327 LY_CHECK_RET(get_argument(ctx, Y_IDENTIF_ARG, NULL, &word, &buf, &word_len));
Radek Krejci011e4aa2020-09-04 15:22:31 +02004328 INSERT_WORD_RET(ctx, buf, submod->name, word, word_len);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004329
aPieceka24a2252021-05-07 10:52:31 +02004330 YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks, return ret) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004331
4332#define CHECK_ORDER(SECTION) \
David Sedlákb3077192019-06-19 10:55:37 +02004333 if (mod_stmt > SECTION) {LOGVAL_PARSER(ctx, LY_VCODE_INORD, ly_stmt2str(kw), ly_stmt2str(prev_kw)); return LY_EVALID;}mod_stmt = SECTION
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004334
4335 switch (kw) {
4336 /* module header */
Radek Krejcid6b76452019-09-03 17:03:03 +02004337 case LY_STMT_BELONGS_TO:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004338 CHECK_ORDER(Y_MOD_MODULE_HEADER);
4339 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004340 case LY_STMT_YANG_VERSION:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004341 CHECK_ORDER(Y_MOD_MODULE_HEADER);
4342 break;
4343 /* linkage */
Radek Krejcid6b76452019-09-03 17:03:03 +02004344 case LY_STMT_INCLUDE:
4345 case LY_STMT_IMPORT:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004346 CHECK_ORDER(Y_MOD_LINKAGE);
4347 break;
4348 /* meta */
Radek Krejcid6b76452019-09-03 17:03:03 +02004349 case LY_STMT_ORGANIZATION:
4350 case LY_STMT_CONTACT:
4351 case LY_STMT_DESCRIPTION:
4352 case LY_STMT_REFERENCE:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004353 CHECK_ORDER(Y_MOD_META);
4354 break;
4355
4356 /* revision */
Radek Krejcid6b76452019-09-03 17:03:03 +02004357 case LY_STMT_REVISION:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004358 CHECK_ORDER(Y_MOD_REVISION);
4359 break;
4360 /* body */
Radek Krejcid6b76452019-09-03 17:03:03 +02004361 case LY_STMT_ANYDATA:
4362 case LY_STMT_ANYXML:
4363 case LY_STMT_AUGMENT:
4364 case LY_STMT_CHOICE:
4365 case LY_STMT_CONTAINER:
4366 case LY_STMT_DEVIATION:
4367 case LY_STMT_EXTENSION:
4368 case LY_STMT_FEATURE:
4369 case LY_STMT_GROUPING:
4370 case LY_STMT_IDENTITY:
4371 case LY_STMT_LEAF:
4372 case LY_STMT_LEAF_LIST:
4373 case LY_STMT_LIST:
4374 case LY_STMT_NOTIFICATION:
4375 case LY_STMT_RPC:
4376 case LY_STMT_TYPEDEF:
4377 case LY_STMT_USES:
4378 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004379 mod_stmt = Y_MOD_BODY;
4380 break;
4381 default:
4382 /* error handled in the next switch */
4383 break;
4384 }
4385#undef CHECK_ORDER
4386
4387 prev_kw = kw;
4388 switch (kw) {
4389 /* module header */
Radek Krejcid6b76452019-09-03 17:03:03 +02004390 case LY_STMT_YANG_VERSION:
Radek Krejci33090f92020-12-17 20:12:46 +01004391 LY_CHECK_RET(parse_yangversion(ctx, &submod->version, &submod->exts));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004392 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004393 case LY_STMT_BELONGS_TO:
Radek Krejci33090f92020-12-17 20:12:46 +01004394 LY_CHECK_RET(parse_belongsto(ctx, &submod->prefix, &submod->exts));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004395 break;
4396
4397 /* linkage */
Radek Krejcid6b76452019-09-03 17:03:03 +02004398 case LY_STMT_INCLUDE:
Radek Krejcieeee95c2021-01-19 10:57:22 +01004399 if (submod->version == LYS_VERSION_1_1) {
4400 LOGWRN(PARSER_CTX(ctx), "YANG version 1.1 expects all includes in main module, includes in submodules (%s) are not necessary.",
4401 submod->name);
4402 }
Radek Krejci33090f92020-12-17 20:12:46 +01004403 LY_CHECK_RET(parse_include(ctx, submod->name, &submod->includes));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004404 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004405 case LY_STMT_IMPORT:
Radek Krejci33090f92020-12-17 20:12:46 +01004406 LY_CHECK_RET(parse_import(ctx, submod->prefix, &submod->imports));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004407 break;
4408
4409 /* meta */
Radek Krejcid6b76452019-09-03 17:03:03 +02004410 case LY_STMT_ORGANIZATION:
Radek Krejcifc596f92021-02-26 22:40:26 +01004411 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_ORGANIZATION, 0, &submod->org, Y_STR_ARG, &submod->exts));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004412 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004413 case LY_STMT_CONTACT:
Radek Krejcifc596f92021-02-26 22:40:26 +01004414 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_CONTACT, 0, &submod->contact, Y_STR_ARG, &submod->exts));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004415 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004416 case LY_STMT_DESCRIPTION:
Radek Krejcifc596f92021-02-26 22:40:26 +01004417 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &submod->dsc, Y_STR_ARG, &submod->exts));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004418 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004419 case LY_STMT_REFERENCE:
Radek Krejcifc596f92021-02-26 22:40:26 +01004420 LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &submod->ref, Y_STR_ARG, &submod->exts));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004421 break;
4422
4423 /* revision */
Radek Krejcid6b76452019-09-03 17:03:03 +02004424 case LY_STMT_REVISION:
Radek Krejci33090f92020-12-17 20:12:46 +01004425 LY_CHECK_RET(parse_revision(ctx, &submod->revs));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004426 break;
4427
4428 /* body */
Radek Krejcid6b76452019-09-03 17:03:03 +02004429 case LY_STMT_ANYDATA:
Radek Krejci335332a2019-09-05 13:03:35 +02004430 PARSER_CHECK_STMTVER2_RET(ctx, "anydata", "submodule");
Radek Krejci0f969882020-08-21 16:56:47 +02004431 /* fall through */
Radek Krejcid6b76452019-09-03 17:03:03 +02004432 case LY_STMT_ANYXML:
Radek Krejci33090f92020-12-17 20:12:46 +01004433 LY_CHECK_RET(parse_any(ctx, kw, NULL, &submod->data));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004434 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004435 case LY_STMT_CHOICE:
Radek Krejci33090f92020-12-17 20:12:46 +01004436 LY_CHECK_RET(parse_choice(ctx, NULL, &submod->data));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004437 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004438 case LY_STMT_CONTAINER:
Radek Krejci33090f92020-12-17 20:12:46 +01004439 LY_CHECK_RET(parse_container(ctx, NULL, &submod->data));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004440 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004441 case LY_STMT_LEAF:
Radek Krejci33090f92020-12-17 20:12:46 +01004442 LY_CHECK_RET(parse_leaf(ctx, NULL, &submod->data));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004443 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004444 case LY_STMT_LEAF_LIST:
Radek Krejci33090f92020-12-17 20:12:46 +01004445 LY_CHECK_RET(parse_leaflist(ctx, NULL, &submod->data));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004446 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004447 case LY_STMT_LIST:
Radek Krejci33090f92020-12-17 20:12:46 +01004448 LY_CHECK_RET(parse_list(ctx, NULL, &submod->data));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004449 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004450 case LY_STMT_USES:
Radek Krejci33090f92020-12-17 20:12:46 +01004451 LY_CHECK_RET(parse_uses(ctx, NULL, &submod->data));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004452 break;
4453
Radek Krejcid6b76452019-09-03 17:03:03 +02004454 case LY_STMT_AUGMENT:
Radek Krejci33090f92020-12-17 20:12:46 +01004455 LY_CHECK_RET(parse_augment(ctx, NULL, &submod->augments));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004456 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004457 case LY_STMT_DEVIATION:
Radek Krejci33090f92020-12-17 20:12:46 +01004458 LY_CHECK_RET(parse_deviation(ctx, &submod->deviations));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004459 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004460 case LY_STMT_EXTENSION:
Radek Krejci33090f92020-12-17 20:12:46 +01004461 LY_CHECK_RET(parse_extension(ctx, &submod->extensions));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004462 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004463 case LY_STMT_FEATURE:
Radek Krejci33090f92020-12-17 20:12:46 +01004464 LY_CHECK_RET(parse_feature(ctx, &submod->features));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004465 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004466 case LY_STMT_GROUPING:
Radek Krejci33090f92020-12-17 20:12:46 +01004467 LY_CHECK_RET(parse_grouping(ctx, NULL, &submod->groupings));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004468 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004469 case LY_STMT_IDENTITY:
Radek Krejci33090f92020-12-17 20:12:46 +01004470 LY_CHECK_RET(parse_identity(ctx, &submod->identities));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004471 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004472 case LY_STMT_NOTIFICATION:
Radek Krejci33090f92020-12-17 20:12:46 +01004473 LY_CHECK_RET(parse_notif(ctx, NULL, &submod->notifs));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004474 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004475 case LY_STMT_RPC:
Radek Krejci33090f92020-12-17 20:12:46 +01004476 LY_CHECK_RET(parse_action(ctx, NULL, &submod->rpcs));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004477 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004478 case LY_STMT_TYPEDEF:
Radek Krejci33090f92020-12-17 20:12:46 +01004479 LY_CHECK_RET(parse_typedef(ctx, NULL, &submod->typedefs));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004480 break;
Radek Krejcid6b76452019-09-03 17:03:03 +02004481 case LY_STMT_EXTENSION_INSTANCE:
Radek Krejci39b7fc22021-02-26 23:29:18 +01004482 LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_SUBMODULE, 0, &submod->exts));
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004483 break;
4484
4485 default:
David Sedlákb3077192019-06-19 10:55:37 +02004486 LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "submodule");
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004487 return LY_EVALID;
4488 }
4489 }
4490 LY_CHECK_RET(ret);
4491
4492checks:
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004493 /* mandatory substatements */
Michal Vaskoc3781c32020-10-06 14:04:08 +02004494 if (!submod->prefix) {
David Sedlákb3077192019-06-19 10:55:37 +02004495 LOGVAL_PARSER(ctx, LY_VCODE_MISSTMT, "belongs-to", "submodule");
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004496 return LY_EVALID;
4497 }
4498
4499 /* submodules share the namespace with the module names, so there must not be
4500 * a submodule of the same name in the context, no need for revision matching */
Michal Vasko8dc31992021-02-22 10:30:47 +01004501 dup = ly_ctx_get_submodule_latest(PARSER_CTX(ctx), submod->name);
Michal Vaskoc3781c32020-10-06 14:04:08 +02004502 /* main modules may have different revisions */
4503 if (dup && strcmp(dup->mod->name, submod->mod->name)) {
Radek Krejci854e1552020-12-21 15:05:23 +01004504 LOGVAL_PARSER(ctx, LY_VCODE_NAME_COL, "submodules", dup->name);
Radek Krejcie9e987e2018-10-31 12:50:27 +01004505 return LY_EVALID;
4506 }
4507
Michal Vasko7fbc8162018-09-17 10:35:16 +02004508 return ret;
4509}
4510
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004511/**
4512 * @brief Skip any redundant characters, namely whitespaces and comments.
4513 *
4514 * @param[in] ctx Yang parser context.
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004515 * @return LY_SUCCESS on success.
4516 * @return LY_EVALID on invalid comment.
4517 */
4518static LY_ERR
Radek Krejci33090f92020-12-17 20:12:46 +01004519skip_redundant_chars(struct lys_yang_parser_ctx *ctx)
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004520{
4521 /* read some trailing spaces, new lines, or comments */
Radek Krejci33090f92020-12-17 20:12:46 +01004522 while (ctx->in->current[0]) {
4523 if (!strncmp(ctx->in->current, "//", 2)) {
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004524 /* one-line comment */
Radek Krejci33090f92020-12-17 20:12:46 +01004525 ly_in_skip(ctx->in, 2);
4526 LY_CHECK_RET(skip_comment(ctx, 1));
4527 } else if (!strncmp(ctx->in->current, "/*", 2)) {
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004528 /* block comment */
Radek Krejci33090f92020-12-17 20:12:46 +01004529 ly_in_skip(ctx->in, 2);
4530 LY_CHECK_RET(skip_comment(ctx, 2));
4531 } else if (isspace(ctx->in->current[0])) {
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004532 /* whitespace */
Radek Krejcidd713ce2021-01-04 23:12:12 +01004533 if (ctx->in->current[0] == '\n') {
4534 LY_IN_NEW_LINE(ctx->in);
4535 }
Radek Krejci33090f92020-12-17 20:12:46 +01004536 ly_in_skip(ctx->in, 1);
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004537 } else {
4538 break;
4539 }
4540 }
4541
4542 return LY_SUCCESS;
4543}
4544
Radek Krejcid4557c62018-09-17 11:42:09 +02004545LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +01004546yang_parse_submodule(struct lys_yang_parser_ctx **context, struct ly_ctx *ly_ctx, struct lys_parser_ctx *main_ctx,
Radek Krejci0f969882020-08-21 16:56:47 +02004547 struct ly_in *in, struct lysp_submodule **submod)
Michal Vasko7fbc8162018-09-17 10:35:16 +02004548{
Radek Krejci6d9b9b52018-11-02 12:43:39 +01004549 LY_ERR ret = LY_SUCCESS;
Radek Krejci0a1d0d42019-05-16 15:14:51 +02004550 char *word;
Radek Krejciefd22f62018-09-27 11:47:58 +02004551 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02004552 enum ly_stmt kw;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004553 struct lysp_submodule *mod_p = NULL;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004554
David Sedlák1b623122019-08-05 15:27:49 +02004555 /* create context */
4556 *context = calloc(1, sizeof **context);
4557 LY_CHECK_ERR_RET(!(*context), LOGMEM(ly_ctx), LY_EMEM);
Michal Vaskob36053d2020-03-26 15:49:30 +01004558 (*context)->format = LYS_IN_YANG;
Michal Vasko405cc9e2020-12-01 12:01:27 +01004559 (*context)->unres = main_ctx->unres;
Radek Krejci33090f92020-12-17 20:12:46 +01004560 (*context)->in = in;
David Sedlák1b623122019-08-05 15:27:49 +02004561
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004562 mod_p = calloc(1, sizeof *mod_p);
4563 LY_CHECK_ERR_GOTO(!mod_p, LOGMEM(ly_ctx); ret = LY_EMEM, cleanup);
4564 mod_p->mod = main_ctx->parsed_mod->mod;
4565 mod_p->parsing = 1;
4566 (*context)->parsed_mod = (struct lysp_module *)mod_p;
4567
Radek Krejciddace2c2021-01-08 11:30:56 +01004568 LOG_LOCINIT(NULL, NULL, NULL, in);
Radek Krejci2efc45b2020-12-22 16:25:44 +01004569
David Sedlák1b623122019-08-05 15:27:49 +02004570 /* map the typedefs and groupings list from main context to the submodule's context */
4571 memcpy(&(*context)->tpdfs_nodes, &main_ctx->tpdfs_nodes, sizeof main_ctx->tpdfs_nodes);
4572 memcpy(&(*context)->grps_nodes, &main_ctx->grps_nodes, sizeof main_ctx->grps_nodes);
4573
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004574 /* skip redundant but valid characters at the beginning */
Radek Krejci33090f92020-12-17 20:12:46 +01004575 ret = skip_redundant_chars(*context);
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004576 LY_CHECK_GOTO(ret, cleanup);
4577
Michal Vasko7fbc8162018-09-17 10:35:16 +02004578 /* "module"/"submodule" */
Radek Krejci33090f92020-12-17 20:12:46 +01004579 ret = get_keyword(*context, &kw, &word, &word_len);
Radek Krejcibbe09a92018-11-08 09:36:54 +01004580 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004581
Radek Krejcid6b76452019-09-03 17:03:03 +02004582 if (kw == LY_STMT_MODULE) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004583 LOGERR(ly_ctx, LY_EDENIED, "Input data contains module in situation when a submodule is expected.");
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004584 ret = LY_EINVAL;
4585 goto cleanup;
Radek Krejcid6b76452019-09-03 17:03:03 +02004586 } else if (kw != LY_STMT_SUBMODULE) {
David Sedlák1538a842019-08-08 15:38:51 +02004587 LOGVAL_PARSER(*context, LY_VCODE_MOD_SUBOMD, ly_stmt2str(kw));
Radek Krejci40544fa2019-01-11 09:38:37 +01004588 ret = LY_EVALID;
Radek Krejcibbe09a92018-11-08 09:36:54 +01004589 goto cleanup;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004590 }
4591
Michal Vasko7fbc8162018-09-17 10:35:16 +02004592 /* substatements */
Radek Krejci33090f92020-12-17 20:12:46 +01004593 ret = parse_submodule(*context, mod_p);
Radek Krejcibbe09a92018-11-08 09:36:54 +01004594 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko7fbc8162018-09-17 10:35:16 +02004595
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004596 /* skip redundant but valid characters at the end */
Radek Krejci33090f92020-12-17 20:12:46 +01004597 ret = skip_redundant_chars(*context);
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004598 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko63f3d842020-07-08 10:10:14 +02004599 if (in->current[0]) {
4600 LOGVAL_PARSER(*context, LY_VCODE_TRAILING_SUBMOD, 15, in->current, strlen(in->current) > 15 ? "..." : "");
Radek Krejci40544fa2019-01-11 09:38:37 +01004601 ret = LY_EVALID;
Radek Krejcibbe09a92018-11-08 09:36:54 +01004602 goto cleanup;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004603 }
Michal Vasko7fbc8162018-09-17 10:35:16 +02004604
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004605 mod_p->parsing = 0;
4606 *submod = mod_p;
Michal Vasko7fbc8162018-09-17 10:35:16 +02004607
Radek Krejcibbe09a92018-11-08 09:36:54 +01004608cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +01004609 LOG_LOCBACK(0, 0, 0, 1);
Radek Krejcibbe09a92018-11-08 09:36:54 +01004610 if (ret) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004611 lysp_module_free((struct lysp_module *)mod_p);
Michal Vaskob36053d2020-03-26 15:49:30 +01004612 yang_parser_ctx_free(*context);
David Sedlák1b623122019-08-05 15:27:49 +02004613 *context = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004614 }
4615
4616 return ret;
4617}
4618
4619LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01004620yang_parse_module(struct lys_yang_parser_ctx **context, struct ly_in *in, struct lys_module *mod, struct lys_glob_unres *unres)
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004621{
4622 LY_ERR ret = LY_SUCCESS;
Radek Krejci0a1d0d42019-05-16 15:14:51 +02004623 char *word;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004624 size_t word_len;
Radek Krejcid6b76452019-09-03 17:03:03 +02004625 enum ly_stmt kw;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004626 struct lysp_module *mod_p = NULL;
4627
David Sedlák1b623122019-08-05 15:27:49 +02004628 /* create context */
4629 *context = calloc(1, sizeof **context);
4630 LY_CHECK_ERR_RET(!(*context), LOGMEM(mod->ctx), LY_EMEM);
Michal Vaskob36053d2020-03-26 15:49:30 +01004631 (*context)->format = LYS_IN_YANG;
Michal Vasko405cc9e2020-12-01 12:01:27 +01004632 (*context)->unres = unres;
Radek Krejci33090f92020-12-17 20:12:46 +01004633 (*context)->in = in;
David Sedlák1b623122019-08-05 15:27:49 +02004634
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004635 mod_p = calloc(1, sizeof *mod_p);
4636 LY_CHECK_ERR_GOTO(!mod_p, LOGMEM(mod->ctx), cleanup);
4637 mod_p->mod = mod;
4638 mod_p->parsing = 1;
4639 (*context)->parsed_mod = mod_p;
4640
Radek Krejciddace2c2021-01-08 11:30:56 +01004641 LOG_LOCINIT(NULL, NULL, NULL, in);
Radek Krejci2efc45b2020-12-22 16:25:44 +01004642
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004643 /* skip redundant but valid characters at the beginning */
Radek Krejci33090f92020-12-17 20:12:46 +01004644 ret = skip_redundant_chars(*context);
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004645 LY_CHECK_GOTO(ret, cleanup);
4646
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004647 /* "module"/"submodule" */
Radek Krejci33090f92020-12-17 20:12:46 +01004648 ret = get_keyword(*context, &kw, &word, &word_len);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004649 LY_CHECK_GOTO(ret, cleanup);
4650
Radek Krejcid6b76452019-09-03 17:03:03 +02004651 if (kw == LY_STMT_SUBMODULE) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02004652 LOGERR(mod->ctx, LY_EDENIED, "Input data contains submodule which cannot be parsed directly without its main module.");
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004653 ret = LY_EINVAL;
4654 goto cleanup;
Radek Krejcid6b76452019-09-03 17:03:03 +02004655 } else if (kw != LY_STMT_MODULE) {
David Sedlák1538a842019-08-08 15:38:51 +02004656 LOGVAL_PARSER((*context), LY_VCODE_MOD_SUBOMD, ly_stmt2str(kw));
Radek Krejci40544fa2019-01-11 09:38:37 +01004657 ret = LY_EVALID;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004658 goto cleanup;
4659 }
4660
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004661 /* substatements */
Radek Krejci33090f92020-12-17 20:12:46 +01004662 ret = parse_module(*context, mod_p);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004663 LY_CHECK_GOTO(ret, cleanup);
4664
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004665 /* skip redundant but valid characters at the end */
Radek Krejci33090f92020-12-17 20:12:46 +01004666 ret = skip_redundant_chars(*context);
Michal Vasko69e6bbb2020-11-04 17:11:46 +01004667 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko63f3d842020-07-08 10:10:14 +02004668 if (in->current[0]) {
4669 LOGVAL_PARSER(*context, LY_VCODE_TRAILING_MOD, 15, in->current, strlen(in->current) > 15 ? "..." : "");
Radek Krejci40544fa2019-01-11 09:38:37 +01004670 ret = LY_EVALID;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004671 goto cleanup;
4672 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004673
4674 mod_p->parsing = 0;
4675 mod->parsed = mod_p;
4676
4677cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +01004678 LOG_LOCBACK(0, 0, 0, 1);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004679 if (ret) {
4680 lysp_module_free(mod_p);
Michal Vaskob36053d2020-03-26 15:49:30 +01004681 yang_parser_ctx_free(*context);
David Sedlák1b623122019-08-05 15:27:49 +02004682 *context = NULL;
Radek Krejcibbe09a92018-11-08 09:36:54 +01004683 }
4684
Michal Vasko7fbc8162018-09-17 10:35:16 +02004685 return ret;
4686}