blob: 5d58e711f5110310e916a0f162bd7a12bed10ed4 [file] [log] [blame]
Radek Krejcid3ca0632019-04-16 16:54:54 +02001/**
2 * @file printer_yang.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief YANG printer
5 *
6 * Copyright (c) 2015 - 2019 CESNET, z.s.p.o.
7 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
14
Radek Krejci535ea9f2020-05-29 16:01:05 +020015#define _GNU_SOURCE
Radek Krejcid3ca0632019-04-16 16:54:54 +020016
Radek Krejci693262f2019-04-29 15:23:20 +020017#include <inttypes.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020018#include <stdint.h>
19#include <stdio.h>
20#include <stdlib.h>
21#include <string.h>
Radek Krejci47fab892020-11-05 17:02:41 +010022#include <sys/types.h>
Radek Krejci693262f2019-04-29 15:23:20 +020023
Radek Krejci535ea9f2020-05-29 16:01:05 +020024#include "common.h"
Radek Krejciaa45bda2020-07-20 07:43:38 +020025#include "compat.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020026#include "log.h"
Radek Krejci47fab892020-11-05 17:02:41 +010027#include "out.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020028#include "out_internal.h"
Radek Krejci47fab892020-11-05 17:02:41 +010029#include "plugins_types.h"
Radek Krejcid3ca0632019-04-16 16:54:54 +020030#include "printer_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020031#include "printer_schema.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020032#include "tree.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020033#include "tree_data.h"
Radek Krejcid3ca0632019-04-16 16:54:54 +020034#include "tree_schema.h"
35#include "tree_schema_internal.h"
Radek Krejci693262f2019-04-29 15:23:20 +020036#include "xpath.h"
Radek Krejcid3ca0632019-04-16 16:54:54 +020037
Radek Krejcie7b95092019-05-15 11:03:07 +020038/**
39 * @brief Types of the YANG printers
40 */
Radek Krejci693262f2019-04-29 15:23:20 +020041enum schema_type {
Radek Krejcie7b95092019-05-15 11:03:07 +020042 YPR_PARSED, /**< YANG printer of the parsed schema */
43 YPR_COMPILED /**< YANG printer of the compiled schema */
Radek Krejci693262f2019-04-29 15:23:20 +020044};
45
Radek Krejcie7b95092019-05-15 11:03:07 +020046/**
47 * @brief YANG printer context.
48 */
Radek Krejcid3ca0632019-04-16 16:54:54 +020049struct ypr_ctx {
Radek Krejci1deb5be2020-08-26 16:43:36 +020050 struct ly_out *out; /**< output specification */
51 uint16_t level; /**< current indentation level: 0 - no formatting, >= 1 indentation levels */
52 uint32_t options; /**< Schema output options (see @ref schemaprinterflags). */
Radek Krejcie7b95092019-05-15 11:03:07 +020053 const struct lys_module *module; /**< schema to print */
54 enum schema_type schema; /**< type of the schema to print */
Radek Krejcid3ca0632019-04-16 16:54:54 +020055};
56
Radek Krejcie7b95092019-05-15 11:03:07 +020057/**
58 * @brief Print the given text as content of a double quoted YANG string,
59 * including encoding characters that have special meanings. The quotation marks
60 * are not printed.
61 *
62 * Follows RFC 7950, section 6.1.3.
63 *
64 * @param[in] out Output specification.
65 * @param[in] text String to be printed.
Radek Krejcif56e2a42019-09-09 14:15:25 +020066 * @param[in] len Length of the string from @p text to be printed. In case of -1,
Radek Krejcie7b95092019-05-15 11:03:07 +020067 * the @p text is printed completely as a NULL-terminated string.
68 */
Radek Krejcid3ca0632019-04-16 16:54:54 +020069static void
Radek Krejci1deb5be2020-08-26 16:43:36 +020070ypr_encode(struct ly_out *out, const char *text, ssize_t len)
Radek Krejcid3ca0632019-04-16 16:54:54 +020071{
Radek Krejci1deb5be2020-08-26 16:43:36 +020072 size_t i, start_len;
Radek Krejcid3ca0632019-04-16 16:54:54 +020073 const char *start;
74 char special = 0;
75
76 if (!len) {
77 return;
78 }
79
80 if (len < 0) {
81 len = strlen(text);
82 }
83
84 start = text;
85 start_len = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +020086 for (i = 0; i < (size_t)len; ++i) {
Radek Krejcid3ca0632019-04-16 16:54:54 +020087 switch (text[i]) {
88 case '\n':
89 case '\t':
90 case '\"':
91 case '\\':
92 special = text[i];
93 break;
94 default:
95 ++start_len;
96 break;
97 }
98
99 if (special) {
Michal Vasko5233e962020-08-14 14:26:20 +0200100 ly_write_(out, start, start_len);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200101 switch (special) {
102 case '\n':
Michal Vasko5233e962020-08-14 14:26:20 +0200103 ly_write_(out, "\\n", 2);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200104 break;
105 case '\t':
Michal Vasko5233e962020-08-14 14:26:20 +0200106 ly_write_(out, "\\t", 2);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200107 break;
108 case '\"':
Michal Vasko5233e962020-08-14 14:26:20 +0200109 ly_write_(out, "\\\"", 2);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200110 break;
111 case '\\':
Michal Vasko5233e962020-08-14 14:26:20 +0200112 ly_write_(out, "\\\\", 2);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200113 break;
114 }
115
116 start += start_len + 1;
117 start_len = 0;
118
119 special = 0;
120 }
121 }
122
Michal Vasko5233e962020-08-14 14:26:20 +0200123 ly_write_(out, start, start_len);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200124}
125
126static void
Radek Krejci857189e2020-09-01 13:26:36 +0200127ypr_open(struct ly_out *out, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200128{
129 if (flag && !*flag) {
130 *flag = 1;
Michal Vasko5233e962020-08-14 14:26:20 +0200131 ly_print_(out, " {\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +0200132 }
133}
134
135static void
Radek Krejci857189e2020-09-01 13:26:36 +0200136ypr_close(struct ypr_ctx *ctx, ly_bool flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200137{
138 if (flag) {
Michal Vasko5233e962020-08-14 14:26:20 +0200139 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200140 } else {
Michal Vasko5233e962020-08-14 14:26:20 +0200141 ly_print_(ctx->out, ";\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +0200142 }
143}
144
145static void
Radek Krejci857189e2020-09-01 13:26:36 +0200146ypr_text(struct ypr_ctx *ctx, const char *name, const char *text, ly_bool singleline, ly_bool closed)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200147{
148 const char *s, *t;
149
150 if (singleline) {
Michal Vasko5233e962020-08-14 14:26:20 +0200151 ly_print_(ctx->out, "%*s%s \"", INDENT, name);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200152 } else {
Michal Vasko5233e962020-08-14 14:26:20 +0200153 ly_print_(ctx->out, "%*s%s\n", INDENT, name);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200154 LEVEL++;
155
Michal Vasko5233e962020-08-14 14:26:20 +0200156 ly_print_(ctx->out, "%*s\"", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200157 }
158 t = text;
159 while ((s = strchr(t, '\n'))) {
160 ypr_encode(ctx->out, t, s - t);
Michal Vasko5233e962020-08-14 14:26:20 +0200161 ly_print_(ctx->out, "\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +0200162 t = s + 1;
163 if (*t != '\n') {
Michal Vasko5233e962020-08-14 14:26:20 +0200164 ly_print_(ctx->out, "%*s ", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200165 }
166 }
167
168 ypr_encode(ctx->out, t, strlen(t));
169 if (closed) {
Michal Vasko5233e962020-08-14 14:26:20 +0200170 ly_print_(ctx->out, "\";\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +0200171 } else {
Michal Vasko5233e962020-08-14 14:26:20 +0200172 ly_print_(ctx->out, "\"");
Radek Krejcid3ca0632019-04-16 16:54:54 +0200173 }
174 if (!singleline) {
175 LEVEL--;
176 }
177}
178
179static void
Radek Krejci693262f2019-04-29 15:23:20 +0200180yprp_stmt(struct ypr_ctx *ctx, struct lysp_stmt *stmt)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200181{
182 struct lysp_stmt *childstmt;
183 const char *s, *t;
184
185 if (stmt->arg) {
186 if (stmt->flags) {
Michal Vasko5233e962020-08-14 14:26:20 +0200187 ly_print_(ctx->out, "%*s%s\n", INDENT, stmt->stmt);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200188 LEVEL++;
Michal Vasko5233e962020-08-14 14:26:20 +0200189 ly_print_(ctx->out, "%*s%c", INDENT, (stmt->flags & LYS_DOUBLEQUOTED) ? '\"' : '\'');
Radek Krejcid3ca0632019-04-16 16:54:54 +0200190 t = stmt->arg;
191 while ((s = strchr(t, '\n'))) {
192 ypr_encode(ctx->out, t, s - t);
Michal Vasko5233e962020-08-14 14:26:20 +0200193 ly_print_(ctx->out, "\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +0200194 t = s + 1;
195 if (*t != '\n') {
Michal Vasko5233e962020-08-14 14:26:20 +0200196 ly_print_(ctx->out, "%*s ", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200197 }
198 }
199 LEVEL--;
200 ypr_encode(ctx->out, t, strlen(t));
Michal Vasko5233e962020-08-14 14:26:20 +0200201 ly_print_(ctx->out, "%c%s", (stmt->flags & LYS_DOUBLEQUOTED) ? '\"' : '\'', stmt->child ? " {\n" : ";\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +0200202 } else {
Michal Vasko5233e962020-08-14 14:26:20 +0200203 ly_print_(ctx->out, "%*s%s %s%s", INDENT, stmt->stmt, stmt->arg, stmt->child ? " {\n" : ";\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +0200204 }
205 } else {
Michal Vasko5233e962020-08-14 14:26:20 +0200206 ly_print_(ctx->out, "%*s%s%s", INDENT, stmt->stmt, stmt->child ? " {\n" : ";\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +0200207 }
208
209 if (stmt->child) {
210 LEVEL++;
211 LY_LIST_FOR(stmt->child, childstmt) {
Radek Krejci693262f2019-04-29 15:23:20 +0200212 yprp_stmt(ctx, childstmt);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200213 }
214 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +0200215 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200216 }
217}
218
219/**
220 * @param[in] count Number of extensions to print, 0 to print them all.
221 */
222static void
Radek Krejci693262f2019-04-29 15:23:20 +0200223yprp_extension_instances(struct ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index,
Radek Krejci857189e2020-09-01 13:26:36 +0200224 struct lysp_ext_instance *ext, ly_bool *flag, LY_ARRAY_COUNT_TYPE count)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200225{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200226 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200227 struct lysp_stmt *stmt;
Radek Krejci857189e2020-09-01 13:26:36 +0200228 ly_bool child_presence;
Radek Krejcif56e2a42019-09-09 14:15:25 +0200229 const char *argument;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200230
231 if (!count && ext) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200232 count = LY_ARRAY_COUNT(ext);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200233 }
234 LY_ARRAY_FOR(ext, u) {
235 if (!count) {
236 break;
237 }
Radek Krejcid3ca0632019-04-16 16:54:54 +0200238
Radek Krejcid3ca0632019-04-16 16:54:54 +0200239 count--;
Michal Vasko3e9bc2f2020-11-04 17:13:56 +0100240 if ((ext->flags & LYS_INTERNAL) || (ext->insubstmt != substmt) || (ext->insubstmt_index != substmt_index)) {
Radek Krejcif56e2a42019-09-09 14:15:25 +0200241 continue;
242 }
243
244 if (!ext->compiled && ext->yin) {
Michal Vasko5233e962020-08-14 14:26:20 +0200245 ly_print_(ctx->out, "%*s%s; // Model comes from different input format, extensions must be resolved first.\n", INDENT, ext[u].name);
Radek Krejcif56e2a42019-09-09 14:15:25 +0200246 continue;
247 }
248
Radek Krejcif56e2a42019-09-09 14:15:25 +0200249 ypr_open(ctx->out, flag);
250 argument = NULL;
251 if (ext[u].compiled) {
252 argument = ext[u].compiled->argument;
253 } else {
254 argument = ext[u].argument;
255 }
256 if (argument) {
Michal Vasko5233e962020-08-14 14:26:20 +0200257 ly_print_(ctx->out, "%*s%s \"", INDENT, ext[u].name);
Radek Krejcif56e2a42019-09-09 14:15:25 +0200258 ypr_encode(ctx->out, argument, -1);
Michal Vasko5233e962020-08-14 14:26:20 +0200259 ly_print_(ctx->out, "\"");
Radek Krejcif56e2a42019-09-09 14:15:25 +0200260 } else {
Michal Vasko5233e962020-08-14 14:26:20 +0200261 ly_print_(ctx->out, "%*s%s", INDENT, ext[u].name);
Radek Krejcif56e2a42019-09-09 14:15:25 +0200262 }
263
264 child_presence = 0;
265 LEVEL++;
266 LY_LIST_FOR(ext[u].child, stmt) {
267 if (stmt->flags & (LYS_YIN_ATTR | LYS_YIN_ARGUMENT)) {
268 continue;
269 }
270 if (!child_presence) {
Michal Vasko5233e962020-08-14 14:26:20 +0200271 ly_print_(ctx->out, " {\n");
Radek Krejcif56e2a42019-09-09 14:15:25 +0200272 child_presence = 1;
273 }
274 yprp_stmt(ctx, stmt);
275 }
276 LEVEL--;
277 if (child_presence) {
Michal Vasko5233e962020-08-14 14:26:20 +0200278 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejcif56e2a42019-09-09 14:15:25 +0200279 } else {
Michal Vasko5233e962020-08-14 14:26:20 +0200280 ly_print_(ctx->out, ";\n");
Radek Krejcif56e2a42019-09-09 14:15:25 +0200281 }
Radek Krejcid3ca0632019-04-16 16:54:54 +0200282 }
283}
284
Radek Krejci693262f2019-04-29 15:23:20 +0200285/**
286 * @param[in] count Number of extensions to print, 0 to print them all.
287 */
Radek Krejcid3ca0632019-04-16 16:54:54 +0200288static void
Radek Krejci693262f2019-04-29 15:23:20 +0200289yprc_extension_instances(struct ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index,
Radek Krejci857189e2020-09-01 13:26:36 +0200290 struct lysc_ext_instance *ext, ly_bool *flag, LY_ARRAY_COUNT_TYPE count)
Radek Krejci693262f2019-04-29 15:23:20 +0200291{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200292 LY_ARRAY_COUNT_TYPE u;
Radek Krejci693262f2019-04-29 15:23:20 +0200293
294 if (!count && ext) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200295 count = LY_ARRAY_COUNT(ext);
Radek Krejci693262f2019-04-29 15:23:20 +0200296 }
297 LY_ARRAY_FOR(ext, u) {
298 if (!count) {
299 break;
300 }
301 /* TODO compiled extensions */
302 (void) ctx;
303 (void) substmt;
304 (void) substmt_index;
305 (void) flag;
306
307 count--;
308 }
309}
310
311static void
312ypr_substmt(struct ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index, const char *text, void *ext)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200313{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200314 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +0200315 ly_bool extflag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200316
317 if (!text) {
318 /* nothing to print */
319 return;
320 }
321
322 if (ext_substmt_info[substmt].flags & SUBST_FLAG_ID) {
Michal Vasko5233e962020-08-14 14:26:20 +0200323 ly_print_(ctx->out, "%*s%s %s", INDENT, ext_substmt_info[substmt].name, text);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200324 } else {
325 ypr_text(ctx, ext_substmt_info[substmt].name, text,
Radek Krejci0f969882020-08-21 16:56:47 +0200326 (ext_substmt_info[substmt].flags & SUBST_FLAG_YIN) ? 0 : 1, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200327 }
328
329 LEVEL++;
330 LY_ARRAY_FOR(ext, u) {
Michal Vasko69730152020-10-09 16:30:07 +0200331 if ((((struct lysp_ext_instance *)ext)[u].insubstmt != substmt) || (((struct lysp_ext_instance *)ext)[u].insubstmt_index != substmt_index)) {
Radek Krejcid3ca0632019-04-16 16:54:54 +0200332 continue;
333 }
Radek Krejci693262f2019-04-29 15:23:20 +0200334 if (ctx->schema == YPR_PARSED) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200335 yprp_extension_instances(ctx, substmt, substmt_index, &((struct lysp_ext_instance *)ext)[u], &extflag, 1);
Radek Krejci693262f2019-04-29 15:23:20 +0200336 } else {
Michal Vasko22df3f02020-08-24 13:29:22 +0200337 yprc_extension_instances(ctx, substmt, substmt_index, &((struct lysc_ext_instance *)ext)[u], &extflag, 1);
Radek Krejci693262f2019-04-29 15:23:20 +0200338 }
Radek Krejcid3ca0632019-04-16 16:54:54 +0200339 }
340 LEVEL--;
341 ypr_close(ctx, extflag);
342}
343
344static void
Radek Krejci857189e2020-09-01 13:26:36 +0200345ypr_unsigned(struct ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index, void *exts, unsigned long int attr_value, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200346{
347 char *str;
348
Radek Krejci1deb5be2020-08-26 16:43:36 +0200349 if (asprintf(&str, "%lu", attr_value) == -1) {
Radek Krejcid3ca0632019-04-16 16:54:54 +0200350 LOGMEM(ctx->module->ctx);
351 return;
352 }
353 ypr_open(ctx->out, flag);
Radek Krejci693262f2019-04-29 15:23:20 +0200354 ypr_substmt(ctx, substmt, substmt_index, str, exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200355 free(str);
356}
357
358static void
Radek Krejci857189e2020-09-01 13:26:36 +0200359ypr_signed(struct ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index, void *exts, signed long int attr_value, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200360{
361 char *str;
362
Radek Krejci1deb5be2020-08-26 16:43:36 +0200363 if (asprintf(&str, "%ld", attr_value) == -1) {
Radek Krejcid3ca0632019-04-16 16:54:54 +0200364 LOGMEM(ctx->module->ctx);
365 return;
366 }
367 ypr_open(ctx->out, flag);
Radek Krejci693262f2019-04-29 15:23:20 +0200368 ypr_substmt(ctx, substmt, substmt_index, str, exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200369 free(str);
370}
371
372static void
Radek Krejci693262f2019-04-29 15:23:20 +0200373yprp_revision(struct ypr_ctx *ctx, const struct lysp_revision *rev)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200374{
375 if (rev->dsc || rev->ref || rev->exts) {
Michal Vasko5233e962020-08-14 14:26:20 +0200376 ly_print_(ctx->out, "%*srevision %s {\n", INDENT, rev->date);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200377 LEVEL++;
Radek Krejci693262f2019-04-29 15:23:20 +0200378 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, rev->exts, NULL, 0);
379 ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, rev->dsc, rev->exts);
380 ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, rev->ref, rev->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200381 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +0200382 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200383 } else {
Michal Vasko5233e962020-08-14 14:26:20 +0200384 ly_print_(ctx->out, "%*srevision %s;\n", INDENT, rev->date);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200385 }
386}
387
388static void
Radek Krejci857189e2020-09-01 13:26:36 +0200389ypr_mandatory(struct ypr_ctx *ctx, uint16_t flags, void *exts, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200390{
391 if (flags & LYS_MAND_MASK) {
392 ypr_open(ctx->out, flag);
Radek Krejci693262f2019-04-29 15:23:20 +0200393 ypr_substmt(ctx, LYEXT_SUBSTMT_MANDATORY, 0, (flags & LYS_MAND_TRUE) ? "true" : "false", exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200394 }
395}
396
397static void
Radek Krejci857189e2020-09-01 13:26:36 +0200398ypr_config(struct ypr_ctx *ctx, uint16_t flags, void *exts, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200399{
400 if (flags & LYS_CONFIG_MASK) {
401 ypr_open(ctx->out, flag);
Radek Krejci693262f2019-04-29 15:23:20 +0200402 ypr_substmt(ctx, LYEXT_SUBSTMT_CONFIG, 0, (flags & LYS_CONFIG_W) ? "true" : "false", exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200403 }
404}
405
406static void
Radek Krejci857189e2020-09-01 13:26:36 +0200407ypr_status(struct ypr_ctx *ctx, uint16_t flags, void *exts, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200408{
409 const char *status = NULL;
410
411 if (flags & LYS_STATUS_CURR) {
412 ypr_open(ctx->out, flag);
413 status = "current";
414 } else if (flags & LYS_STATUS_DEPRC) {
415 ypr_open(ctx->out, flag);
416 status = "deprecated";
417 } else if (flags & LYS_STATUS_OBSLT) {
418 ypr_open(ctx->out, flag);
419 status = "obsolete";
420 }
Radek Krejci693262f2019-04-29 15:23:20 +0200421
422 ypr_substmt(ctx, LYEXT_SUBSTMT_STATUS, 0, status, exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200423}
424
425static void
Radek Krejci857189e2020-09-01 13:26:36 +0200426ypr_description(struct ypr_ctx *ctx, const char *dsc, void *exts, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200427{
428 if (dsc) {
429 ypr_open(ctx->out, flag);
Radek Krejci693262f2019-04-29 15:23:20 +0200430 ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, dsc, exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200431 }
432}
433
434static void
Radek Krejci857189e2020-09-01 13:26:36 +0200435ypr_reference(struct ypr_ctx *ctx, const char *ref, void *exts, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200436{
437 if (ref) {
438 ypr_open(ctx->out, flag);
Radek Krejci693262f2019-04-29 15:23:20 +0200439 ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, ref, exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200440 }
441}
442
443static void
Michal Vasko7f45cf22020-10-01 12:49:44 +0200444yprp_iffeatures(struct ypr_ctx *ctx, struct lysp_qname *iffs, struct lysp_ext_instance *exts, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200445{
Michal Vasko7f45cf22020-10-01 12:49:44 +0200446 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejci857189e2020-09-01 13:26:36 +0200447 ly_bool extflag;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200448
Michal Vasko7f45cf22020-10-01 12:49:44 +0200449 LY_ARRAY_FOR(iffs, u) {
Radek Krejcid3ca0632019-04-16 16:54:54 +0200450 ypr_open(ctx->out, flag);
451 extflag = 0;
452
Michal Vasko7f45cf22020-10-01 12:49:44 +0200453 ly_print_(ctx->out, "%*sif-feature \"%s\"", INDENT, iffs[u].str);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200454
455 /* extensions */
456 LEVEL++;
Michal Vasko7f45cf22020-10-01 12:49:44 +0200457 LY_ARRAY_FOR(exts, v) {
458 yprp_extension_instances(ctx, LYEXT_SUBSTMT_IFFEATURE, u, &exts[v], &extflag, 1);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200459 }
460 LEVEL--;
461 ypr_close(ctx, extflag);
462 }
463}
464
465static void
Radek Krejci693262f2019-04-29 15:23:20 +0200466yprp_extension(struct ypr_ctx *ctx, const struct lysp_ext *ext)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200467{
Radek Krejci857189e2020-09-01 13:26:36 +0200468 ly_bool flag = 0, flag2 = 0;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200469 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200470
Michal Vasko5233e962020-08-14 14:26:20 +0200471 ly_print_(ctx->out, "%*sextension %s", INDENT, ext->name);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200472 LEVEL++;
473
474 if (ext->exts) {
Radek Krejci693262f2019-04-29 15:23:20 +0200475 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, ext->exts, &flag, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200476 }
477
478 if (ext->argument) {
479 ypr_open(ctx->out, &flag);
Michal Vasko5233e962020-08-14 14:26:20 +0200480 ly_print_(ctx->out, "%*sargument %s", INDENT, ext->argument);
Radek Krejci38d2e9f2019-09-09 10:31:51 +0200481 LEVEL++;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200482 if (ext->exts) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200483 u = -1;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200484 while ((u = lysp_ext_instance_iter(ext->exts, u + 1, LYEXT_SUBSTMT_ARGUMENT)) != LY_ARRAY_COUNT(ext->exts)) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200485 yprp_extension_instances(ctx, LYEXT_SUBSTMT_ARGUMENT, 0, &ext->exts[u], &flag2, 1);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200486 }
Radek Krejcid3ca0632019-04-16 16:54:54 +0200487 }
488 if ((ext->flags & LYS_YINELEM_MASK) ||
Michal Vasko69730152020-10-09 16:30:07 +0200489 (ext->exts && (lysp_ext_instance_iter(ext->exts, 0, LYEXT_SUBSTMT_YINELEM) != LY_ARRAY_COUNT(ext->exts)))) {
Radek Krejcid3ca0632019-04-16 16:54:54 +0200490 ypr_open(ctx->out, &flag2);
Radek Krejci693262f2019-04-29 15:23:20 +0200491 ypr_substmt(ctx, LYEXT_SUBSTMT_YINELEM, 0, (ext->flags & LYS_YINELEM_TRUE) ? "true" : "false", ext->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200492 }
Radek Krejci38d2e9f2019-09-09 10:31:51 +0200493 LEVEL--;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200494 ypr_close(ctx, flag2);
495 }
496
Radek Krejci693262f2019-04-29 15:23:20 +0200497 ypr_status(ctx, ext->flags, ext->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200498 ypr_description(ctx, ext->dsc, ext->exts, &flag);
499 ypr_reference(ctx, ext->ref, ext->exts, &flag);
500
501 LEVEL--;
502 ypr_close(ctx, flag);
503}
504
505static void
Radek Krejci693262f2019-04-29 15:23:20 +0200506yprp_feature(struct ypr_ctx *ctx, const struct lysp_feature *feat)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200507{
Radek Krejci857189e2020-09-01 13:26:36 +0200508 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200509
Michal Vasko5233e962020-08-14 14:26:20 +0200510 ly_print_(ctx->out, "\n%*sfeature %s", INDENT, feat->name);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200511 LEVEL++;
Radek Krejci693262f2019-04-29 15:23:20 +0200512 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, feat->exts, &flag, 0);
513 yprp_iffeatures(ctx, feat->iffeatures, feat->exts, &flag);
514 ypr_status(ctx, feat->flags, feat->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200515 ypr_description(ctx, feat->dsc, feat->exts, &flag);
516 ypr_reference(ctx, feat->ref, feat->exts, &flag);
517 LEVEL--;
518 ypr_close(ctx, flag);
519}
520
521static void
Radek Krejci693262f2019-04-29 15:23:20 +0200522yprp_identity(struct ypr_ctx *ctx, const struct lysp_ident *ident)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200523{
Radek Krejci857189e2020-09-01 13:26:36 +0200524 ly_bool flag = 0;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200525 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200526
Michal Vasko5233e962020-08-14 14:26:20 +0200527 ly_print_(ctx->out, "\n%*sidentity %s", INDENT, ident->name);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200528 LEVEL++;
529
Radek Krejci693262f2019-04-29 15:23:20 +0200530 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, ident->exts, &flag, 0);
531 yprp_iffeatures(ctx, ident->iffeatures, ident->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200532
533 LY_ARRAY_FOR(ident->bases, u) {
534 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +0200535 ypr_substmt(ctx, LYEXT_SUBSTMT_BASE, u, ident->bases[u], ident->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200536 }
537
Radek Krejci693262f2019-04-29 15:23:20 +0200538 ypr_status(ctx, ident->flags, ident->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200539 ypr_description(ctx, ident->dsc, ident->exts, &flag);
540 ypr_reference(ctx, ident->ref, ident->exts, &flag);
541
542 LEVEL--;
543 ypr_close(ctx, flag);
544}
545
546static void
Radek Krejci693262f2019-04-29 15:23:20 +0200547yprc_identity(struct ypr_ctx *ctx, const struct lysc_ident *ident)
548{
Radek Krejci857189e2020-09-01 13:26:36 +0200549 ly_bool flag = 0;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200550 LY_ARRAY_COUNT_TYPE u;
Radek Krejci693262f2019-04-29 15:23:20 +0200551
Michal Vasko5233e962020-08-14 14:26:20 +0200552 ly_print_(ctx->out, "\n%*sidentity %s", INDENT, ident->name);
Radek Krejci693262f2019-04-29 15:23:20 +0200553 LEVEL++;
554
555 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, ident->exts, &flag, 0);
Radek Krejci693262f2019-04-29 15:23:20 +0200556
557 LY_ARRAY_FOR(ident->derived, u) {
558 ypr_open(ctx->out, &flag);
559 if (ctx->module != ident->derived[u]->module) {
Michal Vasko5233e962020-08-14 14:26:20 +0200560 ly_print_(ctx->out, "%*sderived %s:%s;\n", INDENT, ident->derived[u]->module->prefix, ident->derived[u]->name);
Radek Krejci693262f2019-04-29 15:23:20 +0200561 } else {
Michal Vasko5233e962020-08-14 14:26:20 +0200562 ly_print_(ctx->out, "%*sderived %s;\n", INDENT, ident->derived[u]->name);
Radek Krejci693262f2019-04-29 15:23:20 +0200563 }
564 }
565
566 ypr_status(ctx, ident->flags, ident->exts, &flag);
567 ypr_description(ctx, ident->dsc, ident->exts, &flag);
568 ypr_reference(ctx, ident->ref, ident->exts, &flag);
569
570 LEVEL--;
571 ypr_close(ctx, flag);
572}
573
574static void
Radek Krejci857189e2020-09-01 13:26:36 +0200575yprp_restr(struct ypr_ctx *ctx, const struct lysp_restr *restr, const char *name, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200576{
Radek Krejci857189e2020-09-01 13:26:36 +0200577 ly_bool inner_flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200578
579 if (!restr) {
580 return;
581 }
582
583 ypr_open(ctx->out, flag);
Michal Vasko5233e962020-08-14 14:26:20 +0200584 ly_print_(ctx->out, "%*s%s \"", INDENT, name);
Radek Krejcif13b87b2020-12-01 22:02:17 +0100585 ypr_encode(ctx->out,
586 (restr->arg.str[0] != LYSP_RESTR_PATTERN_NACK && restr->arg.str[0] != LYSP_RESTR_PATTERN_ACK) ?
587 restr->arg.str : &restr->arg.str[1], -1);
Michal Vasko5233e962020-08-14 14:26:20 +0200588 ly_print_(ctx->out, "\"");
Radek Krejcid3ca0632019-04-16 16:54:54 +0200589
590 LEVEL++;
Radek Krejci693262f2019-04-29 15:23:20 +0200591 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, restr->exts, &inner_flag, 0);
Radek Krejcif13b87b2020-12-01 22:02:17 +0100592 if (restr->arg.str[0] == LYSP_RESTR_PATTERN_NACK) {
Radek Krejcid3ca0632019-04-16 16:54:54 +0200593 /* special byte value in pattern's expression: 0x15 - invert-match, 0x06 - match */
594 ypr_open(ctx->out, &inner_flag);
Radek Krejci693262f2019-04-29 15:23:20 +0200595 ypr_substmt(ctx, LYEXT_SUBSTMT_MODIFIER, 0, "invert-match", restr->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200596 }
597 if (restr->emsg) {
598 ypr_open(ctx->out, &inner_flag);
Radek Krejci693262f2019-04-29 15:23:20 +0200599 ypr_substmt(ctx, LYEXT_SUBSTMT_ERRMSG, 0, restr->emsg, restr->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200600 }
601 if (restr->eapptag) {
602 ypr_open(ctx->out, &inner_flag);
Radek Krejci693262f2019-04-29 15:23:20 +0200603 ypr_substmt(ctx, LYEXT_SUBSTMT_ERRTAG, 0, restr->eapptag, restr->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200604 }
Radek Krejci693262f2019-04-29 15:23:20 +0200605 ypr_description(ctx, restr->dsc, restr->exts, &inner_flag);
606 ypr_reference(ctx, restr->ref, restr->exts, &inner_flag);
607
Radek Krejcid3ca0632019-04-16 16:54:54 +0200608 LEVEL--;
609 ypr_close(ctx, inner_flag);
610}
611
612static void
Radek Krejci857189e2020-09-01 13:26:36 +0200613yprc_must(struct ypr_ctx *ctx, const struct lysc_must *must, ly_bool *flag)
Radek Krejci693262f2019-04-29 15:23:20 +0200614{
Radek Krejci857189e2020-09-01 13:26:36 +0200615 ly_bool inner_flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +0200616
617 ypr_open(ctx->out, flag);
Michal Vasko5233e962020-08-14 14:26:20 +0200618 ly_print_(ctx->out, "%*smust \"", INDENT);
Radek Krejci693262f2019-04-29 15:23:20 +0200619 ypr_encode(ctx->out, must->cond->expr, -1);
Michal Vasko5233e962020-08-14 14:26:20 +0200620 ly_print_(ctx->out, "\"");
Radek Krejci693262f2019-04-29 15:23:20 +0200621
622 LEVEL++;
623 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, must->exts, &inner_flag, 0);
624 if (must->emsg) {
625 ypr_open(ctx->out, &inner_flag);
626 ypr_substmt(ctx, LYEXT_SUBSTMT_ERRMSG, 0, must->emsg, must->exts);
627 }
628 if (must->eapptag) {
629 ypr_open(ctx->out, &inner_flag);
630 ypr_substmt(ctx, LYEXT_SUBSTMT_ERRTAG, 0, must->eapptag, must->exts);
631 }
632 ypr_description(ctx, must->dsc, must->exts, &inner_flag);
633 ypr_reference(ctx, must->ref, must->exts, &inner_flag);
634
635 LEVEL--;
636 ypr_close(ctx, inner_flag);
637}
638
639static void
Radek Krejci857189e2020-09-01 13:26:36 +0200640yprc_range(struct ypr_ctx *ctx, const struct lysc_range *range, LY_DATA_TYPE basetype, ly_bool *flag)
Radek Krejci693262f2019-04-29 15:23:20 +0200641{
Radek Krejci857189e2020-09-01 13:26:36 +0200642 ly_bool inner_flag = 0;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200643 LY_ARRAY_COUNT_TYPE u;
Radek Krejci693262f2019-04-29 15:23:20 +0200644
Radek Krejci334ccc72019-06-12 13:49:29 +0200645 if (!range) {
646 return;
647 }
648
Radek Krejci693262f2019-04-29 15:23:20 +0200649 ypr_open(ctx->out, flag);
Michal Vasko5233e962020-08-14 14:26:20 +0200650 ly_print_(ctx->out, "%*s%s \"", INDENT, (basetype == LY_TYPE_STRING || basetype == LY_TYPE_BINARY) ? "length" : "range");
Radek Krejci693262f2019-04-29 15:23:20 +0200651 LY_ARRAY_FOR(range->parts, u) {
652 if (u > 0) {
Michal Vasko5233e962020-08-14 14:26:20 +0200653 ly_print_(ctx->out, " | ");
Radek Krejci693262f2019-04-29 15:23:20 +0200654 }
655 if (range->parts[u].max_64 == range->parts[u].min_64) {
656 if (basetype <= LY_TYPE_STRING) { /* unsigned values */
Radek Krejci0f969882020-08-21 16:56:47 +0200657 ly_print_(ctx->out, "%" PRIu64, range->parts[u].max_u64);
Radek Krejci693262f2019-04-29 15:23:20 +0200658 } else { /* signed values */
Radek Krejci0f969882020-08-21 16:56:47 +0200659 ly_print_(ctx->out, "%" PRId64, range->parts[u].max_64);
Radek Krejci693262f2019-04-29 15:23:20 +0200660 }
661 } else {
662 if (basetype <= LY_TYPE_STRING) { /* unsigned values */
Radek Krejci0f969882020-08-21 16:56:47 +0200663 ly_print_(ctx->out, "%" PRIu64 "..%" PRIu64, range->parts[u].min_u64, range->parts[u].max_u64);
Radek Krejci693262f2019-04-29 15:23:20 +0200664 } else { /* signed values */
Radek Krejci0f969882020-08-21 16:56:47 +0200665 ly_print_(ctx->out, "%" PRId64 "..%" PRId64, range->parts[u].min_64, range->parts[u].max_64);
Radek Krejci693262f2019-04-29 15:23:20 +0200666 }
667 }
668 }
Michal Vasko5233e962020-08-14 14:26:20 +0200669 ly_print_(ctx->out, "\"");
Radek Krejci693262f2019-04-29 15:23:20 +0200670
671 LEVEL++;
672 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, range->exts, &inner_flag, 0);
673 if (range->emsg) {
674 ypr_open(ctx->out, &inner_flag);
675 ypr_substmt(ctx, LYEXT_SUBSTMT_ERRMSG, 0, range->emsg, range->exts);
676 }
677 if (range->eapptag) {
678 ypr_open(ctx->out, &inner_flag);
679 ypr_substmt(ctx, LYEXT_SUBSTMT_ERRTAG, 0, range->eapptag, range->exts);
680 }
681 ypr_description(ctx, range->dsc, range->exts, &inner_flag);
682 ypr_reference(ctx, range->ref, range->exts, &inner_flag);
683
684 LEVEL--;
685 ypr_close(ctx, inner_flag);
686}
687
688static void
Radek Krejci857189e2020-09-01 13:26:36 +0200689yprc_pattern(struct ypr_ctx *ctx, const struct lysc_pattern *pattern, ly_bool *flag)
Radek Krejci693262f2019-04-29 15:23:20 +0200690{
Radek Krejci857189e2020-09-01 13:26:36 +0200691 ly_bool inner_flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +0200692
693 ypr_open(ctx->out, flag);
Michal Vasko5233e962020-08-14 14:26:20 +0200694 ly_print_(ctx->out, "%*spattern \"", INDENT);
Radek Krejci54579462019-04-30 12:47:06 +0200695 ypr_encode(ctx->out, pattern->expr, -1);
Michal Vasko5233e962020-08-14 14:26:20 +0200696 ly_print_(ctx->out, "\"");
Radek Krejci693262f2019-04-29 15:23:20 +0200697
698 LEVEL++;
699 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, pattern->exts, &inner_flag, 0);
700 if (pattern->inverted) {
701 /* special byte value in pattern's expression: 0x15 - invert-match, 0x06 - match */
702 ypr_open(ctx->out, &inner_flag);
703 ypr_substmt(ctx, LYEXT_SUBSTMT_MODIFIER, 0, "invert-match", pattern->exts);
704 }
705 if (pattern->emsg) {
706 ypr_open(ctx->out, &inner_flag);
707 ypr_substmt(ctx, LYEXT_SUBSTMT_ERRMSG, 0, pattern->emsg, pattern->exts);
708 }
709 if (pattern->eapptag) {
710 ypr_open(ctx->out, &inner_flag);
711 ypr_substmt(ctx, LYEXT_SUBSTMT_ERRTAG, 0, pattern->eapptag, pattern->exts);
712 }
713 ypr_description(ctx, pattern->dsc, pattern->exts, &inner_flag);
714 ypr_reference(ctx, pattern->ref, pattern->exts, &inner_flag);
715
716 LEVEL--;
717 ypr_close(ctx, inner_flag);
718}
719
720static void
Radek Krejci857189e2020-09-01 13:26:36 +0200721yprp_when(struct ypr_ctx *ctx, struct lysp_when *when, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200722{
Radek Krejci857189e2020-09-01 13:26:36 +0200723 ly_bool inner_flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200724
725 if (!when) {
726 return;
727 }
728 ypr_open(ctx->out, flag);
729
Michal Vasko5233e962020-08-14 14:26:20 +0200730 ly_print_(ctx->out, "%*swhen \"", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200731 ypr_encode(ctx->out, when->cond, -1);
Michal Vasko5233e962020-08-14 14:26:20 +0200732 ly_print_(ctx->out, "\"");
Radek Krejcid3ca0632019-04-16 16:54:54 +0200733
734 LEVEL++;
Radek Krejci693262f2019-04-29 15:23:20 +0200735 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, when->exts, &inner_flag, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200736 ypr_description(ctx, when->dsc, when->exts, &inner_flag);
737 ypr_reference(ctx, when->ref, when->exts, &inner_flag);
738 LEVEL--;
739 ypr_close(ctx, inner_flag);
740}
741
742static void
Radek Krejci857189e2020-09-01 13:26:36 +0200743yprc_when(struct ypr_ctx *ctx, struct lysc_when *when, ly_bool *flag)
Radek Krejci693262f2019-04-29 15:23:20 +0200744{
Radek Krejci857189e2020-09-01 13:26:36 +0200745 ly_bool inner_flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +0200746
747 if (!when) {
748 return;
749 }
750 ypr_open(ctx->out, flag);
751
Michal Vasko5233e962020-08-14 14:26:20 +0200752 ly_print_(ctx->out, "%*swhen \"", INDENT);
Radek Krejci693262f2019-04-29 15:23:20 +0200753 ypr_encode(ctx->out, when->cond->expr, -1);
Michal Vasko5233e962020-08-14 14:26:20 +0200754 ly_print_(ctx->out, "\"");
Radek Krejci693262f2019-04-29 15:23:20 +0200755
756 LEVEL++;
757 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, when->exts, &inner_flag, 0);
758 ypr_description(ctx, when->dsc, when->exts, &inner_flag);
759 ypr_reference(ctx, when->ref, when->exts, &inner_flag);
760 LEVEL--;
761 ypr_close(ctx, inner_flag);
762}
763
764static void
Radek Krejci857189e2020-09-01 13:26:36 +0200765yprp_enum(struct ypr_ctx *ctx, const struct lysp_type_enum *items, LY_DATA_TYPE type, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200766{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200767 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +0200768 ly_bool inner_flag;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200769
770 LY_ARRAY_FOR(items, u) {
771 ypr_open(ctx->out, flag);
Radek Krejci7871ce52019-06-11 16:44:56 +0200772 if (type == LY_TYPE_BITS) {
Michal Vasko5233e962020-08-14 14:26:20 +0200773 ly_print_(ctx->out, "%*sbit %s", INDENT, items[u].name);
Radek Krejci7871ce52019-06-11 16:44:56 +0200774 } else { /* LY_TYPE_ENUM */
Michal Vasko5233e962020-08-14 14:26:20 +0200775 ly_print_(ctx->out, "%*senum \"", INDENT);
Radek Krejci7871ce52019-06-11 16:44:56 +0200776 ypr_encode(ctx->out, items[u].name, -1);
Michal Vasko5233e962020-08-14 14:26:20 +0200777 ly_print_(ctx->out, "\"");
Radek Krejci7871ce52019-06-11 16:44:56 +0200778 }
Radek Krejcid3ca0632019-04-16 16:54:54 +0200779 inner_flag = 0;
780 LEVEL++;
Radek Krejci693262f2019-04-29 15:23:20 +0200781 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, items[u].exts, &inner_flag, 0);
782 yprp_iffeatures(ctx, items[u].iffeatures, items[u].exts, &inner_flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200783 if (items[u].flags & LYS_SET_VALUE) {
784 if (type == LY_TYPE_BITS) {
Radek Krejci693262f2019-04-29 15:23:20 +0200785 ypr_unsigned(ctx, LYEXT_SUBSTMT_POSITION, 0, items[u].exts, items[u].value, &inner_flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200786 } else { /* LY_TYPE_ENUM */
Radek Krejci693262f2019-04-29 15:23:20 +0200787 ypr_signed(ctx, LYEXT_SUBSTMT_VALUE, 0, items[u].exts, items[u].value, &inner_flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200788 }
789 }
Radek Krejci693262f2019-04-29 15:23:20 +0200790 ypr_status(ctx, items[u].flags, items[u].exts, &inner_flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200791 ypr_description(ctx, items[u].dsc, items[u].exts, &inner_flag);
792 ypr_reference(ctx, items[u].ref, items[u].exts, &inner_flag);
793 LEVEL--;
794 ypr_close(ctx, inner_flag);
795 }
796}
797
798static void
Radek Krejci693262f2019-04-29 15:23:20 +0200799yprp_type(struct ypr_ctx *ctx, const struct lysp_type *type)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200800{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200801 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +0200802 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200803
Michal Vasko5233e962020-08-14 14:26:20 +0200804 ly_print_(ctx->out, "%*stype %s", INDENT, type->name);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200805 LEVEL++;
806
Radek Krejci693262f2019-04-29 15:23:20 +0200807 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, type->exts, &flag, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200808
Radek Krejci693262f2019-04-29 15:23:20 +0200809 yprp_restr(ctx, type->range, "range", &flag);
810 yprp_restr(ctx, type->length, "length", &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200811 LY_ARRAY_FOR(type->patterns, u) {
Radek Krejci693262f2019-04-29 15:23:20 +0200812 yprp_restr(ctx, &type->patterns[u], "pattern", &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200813 }
Radek Krejci693262f2019-04-29 15:23:20 +0200814 yprp_enum(ctx, type->bits, LY_TYPE_BITS, &flag);
815 yprp_enum(ctx, type->enums, LY_TYPE_ENUM, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200816
817 if (type->path) {
818 ypr_open(ctx->out, &flag);
Michal Vasko004d3152020-06-11 19:59:22 +0200819 ypr_substmt(ctx, LYEXT_SUBSTMT_PATH, 0, type->path->expr, type->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200820 }
821 if (type->flags & LYS_SET_REQINST) {
822 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +0200823 ypr_substmt(ctx, LYEXT_SUBSTMT_REQINSTANCE, 0, type->require_instance ? "true" : "false", type->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200824 }
825 if (type->flags & LYS_SET_FRDIGITS) {
Radek Krejci693262f2019-04-29 15:23:20 +0200826 ypr_unsigned(ctx, LYEXT_SUBSTMT_FRACDIGITS, 0, type->exts, type->fraction_digits, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200827 }
828 LY_ARRAY_FOR(type->bases, u) {
829 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +0200830 ypr_substmt(ctx, LYEXT_SUBSTMT_BASE, u, type->bases[u], type->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200831 }
832 LY_ARRAY_FOR(type->types, u) {
833 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +0200834 yprp_type(ctx, &type->types[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200835 }
836
837 LEVEL--;
838 ypr_close(ctx, flag);
839}
840
841static void
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200842yprc_dflt_value(struct ypr_ctx *ctx, const struct lyd_value *value, struct lysc_ext_instance *exts)
Radek Krejcia1911222019-07-22 17:24:50 +0200843{
Radek Krejci857189e2020-09-01 13:26:36 +0200844 ly_bool dynamic;
Radek Krejcia1911222019-07-22 17:24:50 +0200845 const char *str;
846
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200847 str = value->realtype->plugin->print(value, LY_PREF_JSON, NULL, &dynamic);
Radek Krejcia1911222019-07-22 17:24:50 +0200848 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, str, exts);
849 if (dynamic) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200850 free((void *)str);
Radek Krejcia1911222019-07-22 17:24:50 +0200851 }
852}
853
854static void
Radek Krejci693262f2019-04-29 15:23:20 +0200855yprc_type(struct ypr_ctx *ctx, const struct lysc_type *type)
856{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200857 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +0200858 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +0200859
Michal Vasko5233e962020-08-14 14:26:20 +0200860 ly_print_(ctx->out, "%*stype %s", INDENT, lys_datatype2str(type->basetype));
Radek Krejci693262f2019-04-29 15:23:20 +0200861 LEVEL++;
862
863 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, type->exts, &flag, 0);
Radek Krejci693262f2019-04-29 15:23:20 +0200864
Michal Vasko2bb55bc2020-08-05 13:27:04 +0200865 switch (type->basetype) {
Radek Krejci693262f2019-04-29 15:23:20 +0200866 case LY_TYPE_BINARY: {
Michal Vasko22df3f02020-08-24 13:29:22 +0200867 struct lysc_type_bin *bin = (struct lysc_type_bin *)type;
Radek Krejci693262f2019-04-29 15:23:20 +0200868 yprc_range(ctx, bin->length, type->basetype, &flag);
869 break;
870 }
871 case LY_TYPE_UINT8:
872 case LY_TYPE_UINT16:
873 case LY_TYPE_UINT32:
874 case LY_TYPE_UINT64:
875 case LY_TYPE_INT8:
876 case LY_TYPE_INT16:
877 case LY_TYPE_INT32:
878 case LY_TYPE_INT64: {
Michal Vasko22df3f02020-08-24 13:29:22 +0200879 struct lysc_type_num *num = (struct lysc_type_num *)type;
Radek Krejci693262f2019-04-29 15:23:20 +0200880 yprc_range(ctx, num->range, type->basetype, &flag);
881 break;
882 }
883 case LY_TYPE_STRING: {
Michal Vasko22df3f02020-08-24 13:29:22 +0200884 struct lysc_type_str *str = (struct lysc_type_str *)type;
Radek Krejci693262f2019-04-29 15:23:20 +0200885 yprc_range(ctx, str->length, type->basetype, &flag);
886 LY_ARRAY_FOR(str->patterns, u) {
887 yprc_pattern(ctx, str->patterns[u], &flag);
888 }
889 break;
890 }
891 case LY_TYPE_BITS:
892 case LY_TYPE_ENUM: {
893 /* bits and enums structures are compatible */
Michal Vasko22df3f02020-08-24 13:29:22 +0200894 struct lysc_type_bits *bits = (struct lysc_type_bits *)type;
Radek Krejci693262f2019-04-29 15:23:20 +0200895 LY_ARRAY_FOR(bits->bits, u) {
896 struct lysc_type_bitenum_item *item = &bits->bits[u];
Radek Krejci857189e2020-09-01 13:26:36 +0200897 ly_bool inner_flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +0200898
899 ypr_open(ctx->out, &flag);
Michal Vasko5233e962020-08-14 14:26:20 +0200900 ly_print_(ctx->out, "%*s%s \"", INDENT, type->basetype == LY_TYPE_BITS ? "bit" : "enum");
Radek Krejci693262f2019-04-29 15:23:20 +0200901 ypr_encode(ctx->out, item->name, -1);
Michal Vasko5233e962020-08-14 14:26:20 +0200902 ly_print_(ctx->out, "\"");
Radek Krejci693262f2019-04-29 15:23:20 +0200903 LEVEL++;
904 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, item->exts, &inner_flag, 0);
Radek Krejci693262f2019-04-29 15:23:20 +0200905 if (type->basetype == LY_TYPE_BITS) {
906 ypr_unsigned(ctx, LYEXT_SUBSTMT_POSITION, 0, item->exts, item->position, &inner_flag);
907 } else { /* LY_TYPE_ENUM */
908 ypr_signed(ctx, LYEXT_SUBSTMT_VALUE, 0, item->exts, item->value, &inner_flag);
909 }
910 ypr_status(ctx, item->flags, item->exts, &inner_flag);
911 ypr_description(ctx, item->dsc, item->exts, &inner_flag);
912 ypr_reference(ctx, item->ref, item->exts, &inner_flag);
913 LEVEL--;
914 ypr_close(ctx, inner_flag);
915 }
916 break;
917 }
918 case LY_TYPE_BOOL:
919 case LY_TYPE_EMPTY:
920 /* nothing to do */
921 break;
922 case LY_TYPE_DEC64: {
Michal Vasko22df3f02020-08-24 13:29:22 +0200923 struct lysc_type_dec *dec = (struct lysc_type_dec *)type;
Radek Krejci693262f2019-04-29 15:23:20 +0200924 ypr_open(ctx->out, &flag);
925 ypr_unsigned(ctx, LYEXT_SUBSTMT_FRACDIGITS, 0, type->exts, dec->fraction_digits, &flag);
926 yprc_range(ctx, dec->range, dec->basetype, &flag);
927 break;
928 }
929 case LY_TYPE_IDENT: {
Michal Vasko22df3f02020-08-24 13:29:22 +0200930 struct lysc_type_identityref *ident = (struct lysc_type_identityref *)type;
Radek Krejci693262f2019-04-29 15:23:20 +0200931 LY_ARRAY_FOR(ident->bases, u) {
932 ypr_open(ctx->out, &flag);
933 ypr_substmt(ctx, LYEXT_SUBSTMT_BASE, u, ident->bases[u]->name, type->exts);
934 }
935 break;
936 }
937 case LY_TYPE_INST: {
Michal Vasko22df3f02020-08-24 13:29:22 +0200938 struct lysc_type_instanceid *inst = (struct lysc_type_instanceid *)type;
Radek Krejci693262f2019-04-29 15:23:20 +0200939 ypr_open(ctx->out, &flag);
940 ypr_substmt(ctx, LYEXT_SUBSTMT_REQINSTANCE, 0, inst->require_instance ? "true" : "false", inst->exts);
941 break;
942 }
943 case LY_TYPE_LEAFREF: {
Michal Vasko22df3f02020-08-24 13:29:22 +0200944 struct lysc_type_leafref *lr = (struct lysc_type_leafref *)type;
Radek Krejci693262f2019-04-29 15:23:20 +0200945 ypr_open(ctx->out, &flag);
Michal Vasko004d3152020-06-11 19:59:22 +0200946 ypr_substmt(ctx, LYEXT_SUBSTMT_PATH, 0, lr->path->expr, lr->exts);
Radek Krejci693262f2019-04-29 15:23:20 +0200947 ypr_substmt(ctx, LYEXT_SUBSTMT_REQINSTANCE, 0, lr->require_instance ? "true" : "false", lr->exts);
948 yprc_type(ctx, lr->realtype);
949 break;
950 }
951 case LY_TYPE_UNION: {
Michal Vasko22df3f02020-08-24 13:29:22 +0200952 struct lysc_type_union *un = (struct lysc_type_union *)type;
Radek Krejci693262f2019-04-29 15:23:20 +0200953 LY_ARRAY_FOR(un->types, u) {
954 ypr_open(ctx->out, &flag);
955 yprc_type(ctx, un->types[u]);
956 }
957 break;
958 }
959 default:
960 LOGINT(ctx->module->ctx);
961 }
962
963 LEVEL--;
964 ypr_close(ctx, flag);
965}
966
967static void
968yprp_typedef(struct ypr_ctx *ctx, const struct lysp_tpdf *tpdf)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200969{
Michal Vasko5233e962020-08-14 14:26:20 +0200970 ly_print_(ctx->out, "\n%*stypedef %s {\n", INDENT, tpdf->name);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200971 LEVEL++;
972
Radek Krejci693262f2019-04-29 15:23:20 +0200973 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, tpdf->exts, NULL, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200974
Radek Krejci693262f2019-04-29 15:23:20 +0200975 yprp_type(ctx, &tpdf->type);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200976
977 if (tpdf->units) {
Radek Krejci693262f2019-04-29 15:23:20 +0200978 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, tpdf->units, tpdf->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200979 }
Michal Vasko7f45cf22020-10-01 12:49:44 +0200980 if (tpdf->dflt.str) {
981 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, tpdf->dflt.str, tpdf->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200982 }
983
Radek Krejci693262f2019-04-29 15:23:20 +0200984 ypr_status(ctx, tpdf->flags, tpdf->exts, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200985 ypr_description(ctx, tpdf->dsc, tpdf->exts, NULL);
986 ypr_reference(ctx, tpdf->ref, tpdf->exts, NULL);
987
988 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +0200989 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200990}
991
Radek Krejci693262f2019-04-29 15:23:20 +0200992static void yprp_node(struct ypr_ctx *ctx, const struct lysp_node *node);
993static void yprc_node(struct ypr_ctx *ctx, const struct lysc_node *node);
Radek Krejci2a9fc652021-01-22 17:44:34 +0100994static void yprp_action(struct ypr_ctx *ctx, const struct lysp_node_action *action);
995static void yprp_notification(struct ypr_ctx *ctx, const struct lysp_node_notif *notif);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200996
997static void
Radek Krejci2a9fc652021-01-22 17:44:34 +0100998yprp_grouping(struct ypr_ctx *ctx, const struct lysp_node_grp *grp)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200999{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001000 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001001 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001002 struct lysp_node *data;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001003 struct lysp_node_action *action;
1004 struct lysp_node_notif *notif;
1005 struct lysp_node_grp *subgrp;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001006
Michal Vasko5233e962020-08-14 14:26:20 +02001007 ly_print_(ctx->out, "\n%*sgrouping %s", INDENT, grp->name);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001008 LEVEL++;
1009
Radek Krejci693262f2019-04-29 15:23:20 +02001010 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, grp->exts, &flag, 0);
1011 ypr_status(ctx, grp->flags, grp->exts, &flag);
Radek Krejcifc81ea82019-04-18 13:27:22 +02001012 ypr_description(ctx, grp->dsc, grp->exts, &flag);
1013 ypr_reference(ctx, grp->ref, grp->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001014
1015 LY_ARRAY_FOR(grp->typedefs, u) {
Radek Krejci59edcf72019-05-02 09:53:17 +02001016 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001017 yprp_typedef(ctx, &grp->typedefs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001018 }
1019
Radek Krejci2a9fc652021-01-22 17:44:34 +01001020 LY_LIST_FOR(grp->groupings, subgrp) {
Radek Krejci59edcf72019-05-02 09:53:17 +02001021 ypr_open(ctx->out, &flag);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001022 yprp_grouping(ctx, subgrp);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001023 }
1024
Radek Krejci01180ac2021-01-27 08:48:22 +01001025 LY_LIST_FOR(grp->child, data) {
Radek Krejcifc81ea82019-04-18 13:27:22 +02001026 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001027 yprp_node(ctx, data);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001028 }
1029
Radek Krejci2a9fc652021-01-22 17:44:34 +01001030 LY_LIST_FOR(grp->actions, action) {
1031 ypr_open(ctx->out, &flag);
1032 yprp_action(ctx, action);
1033 }
1034
1035 LY_LIST_FOR(grp->notifs, notif) {
1036 ypr_open(ctx->out, &flag);
1037 yprp_notification(ctx, notif);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001038 }
1039
1040 LEVEL--;
1041 ypr_close(ctx, flag);
1042}
1043
1044static void
Radek Krejci2a9fc652021-01-22 17:44:34 +01001045yprp_inout(struct ypr_ctx *ctx, const struct lysp_node_action_inout *inout, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001046{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001047 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001048 struct lysp_node *data;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001049 struct lysp_node_grp *grp;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001050
Radek Krejci01180ac2021-01-27 08:48:22 +01001051 if (!inout->child) {
Michal Vasko7f45cf22020-10-01 12:49:44 +02001052 /* no children */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001053 return;
1054 }
1055 ypr_open(ctx->out, flag);
1056
Michal Vasko544e58a2021-01-28 14:33:41 +01001057 ly_print_(ctx->out, "\n%*s%s {\n", INDENT, inout->name);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001058 LEVEL++;
1059
Radek Krejci693262f2019-04-29 15:23:20 +02001060 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, inout->exts, NULL, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001061 LY_ARRAY_FOR(inout->musts, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001062 yprp_restr(ctx, &inout->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001063 }
1064 LY_ARRAY_FOR(inout->typedefs, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001065 yprp_typedef(ctx, &inout->typedefs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001066 }
Radek Krejci2a9fc652021-01-22 17:44:34 +01001067 LY_LIST_FOR(inout->groupings, grp) {
1068 yprp_grouping(ctx, grp);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001069 }
1070
Radek Krejci01180ac2021-01-27 08:48:22 +01001071 LY_LIST_FOR(inout->child, data) {
Radek Krejci693262f2019-04-29 15:23:20 +02001072 yprp_node(ctx, data);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001073 }
1074
1075 LEVEL--;
1076 ypr_close(ctx, 1);
1077}
1078
1079static void
Michal Vasko544e58a2021-01-28 14:33:41 +01001080yprc_inout(struct ypr_ctx *ctx, const struct lysc_node_action_inout *inout, ly_bool *flag)
Radek Krejci693262f2019-04-29 15:23:20 +02001081{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001082 LY_ARRAY_COUNT_TYPE u;
Radek Krejci693262f2019-04-29 15:23:20 +02001083 struct lysc_node *data;
1084
Radek Krejci01180ac2021-01-27 08:48:22 +01001085 if (!inout->child) {
Radek Krejci693262f2019-04-29 15:23:20 +02001086 /* input/output is empty */
1087 return;
1088 }
1089 ypr_open(ctx->out, flag);
1090
Michal Vasko544e58a2021-01-28 14:33:41 +01001091 ly_print_(ctx->out, "\n%*s%s {\n", INDENT, inout->name);
Radek Krejci693262f2019-04-29 15:23:20 +02001092 LEVEL++;
1093
Michal Vasko544e58a2021-01-28 14:33:41 +01001094 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, inout->exts, NULL, 0);
Radek Krejci693262f2019-04-29 15:23:20 +02001095 LY_ARRAY_FOR(inout->musts, u) {
1096 yprc_must(ctx, &inout->musts[u], NULL);
1097 }
1098
Radek Krejci52f65552020-09-01 17:03:35 +02001099 if (!(ctx->options & LYS_PRINT_NO_SUBSTMT)) {
Radek Krejci01180ac2021-01-27 08:48:22 +01001100 LY_LIST_FOR(inout->child, data) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001101 yprc_node(ctx, data);
1102 }
Radek Krejci693262f2019-04-29 15:23:20 +02001103 }
1104
1105 LEVEL--;
1106 ypr_close(ctx, 1);
1107}
1108
1109static void
Radek Krejci2a9fc652021-01-22 17:44:34 +01001110yprp_notification(struct ypr_ctx *ctx, const struct lysp_node_notif *notif)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001111{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001112 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001113 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001114 struct lysp_node *data;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001115 struct lysp_node_grp *grp;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001116
Michal Vasko5233e962020-08-14 14:26:20 +02001117 ly_print_(ctx->out, "%*snotification %s", INDENT, notif->name);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001118
1119 LEVEL++;
Radek Krejci693262f2019-04-29 15:23:20 +02001120 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, notif->exts, &flag, 0);
1121 yprp_iffeatures(ctx, notif->iffeatures, notif->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001122
1123 LY_ARRAY_FOR(notif->musts, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001124 yprp_restr(ctx, &notif->musts[u], "must", &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001125 }
Radek Krejci693262f2019-04-29 15:23:20 +02001126 ypr_status(ctx, notif->flags, notif->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001127 ypr_description(ctx, notif->dsc, notif->exts, &flag);
1128 ypr_reference(ctx, notif->ref, notif->exts, &flag);
1129
1130 LY_ARRAY_FOR(notif->typedefs, u) {
1131 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001132 yprp_typedef(ctx, &notif->typedefs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001133 }
1134
Radek Krejci2a9fc652021-01-22 17:44:34 +01001135 LY_LIST_FOR(notif->groupings, grp) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001136 ypr_open(ctx->out, &flag);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001137 yprp_grouping(ctx, grp);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001138 }
1139
Radek Krejci01180ac2021-01-27 08:48:22 +01001140 LY_LIST_FOR(notif->child, data) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001141 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001142 yprp_node(ctx, data);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001143 }
1144
1145 LEVEL--;
1146 ypr_close(ctx, flag);
1147}
1148
1149static void
Radek Krejci2a9fc652021-01-22 17:44:34 +01001150yprc_notification(struct ypr_ctx *ctx, const struct lysc_node_notif *notif)
Radek Krejci693262f2019-04-29 15:23:20 +02001151{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001152 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001153 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02001154 struct lysc_node *data;
1155
Michal Vasko5233e962020-08-14 14:26:20 +02001156 ly_print_(ctx->out, "%*snotification %s", INDENT, notif->name);
Radek Krejci693262f2019-04-29 15:23:20 +02001157
1158 LEVEL++;
1159 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, notif->exts, &flag, 0);
Radek Krejci693262f2019-04-29 15:23:20 +02001160
1161 LY_ARRAY_FOR(notif->musts, u) {
1162 yprc_must(ctx, &notif->musts[u], &flag);
1163 }
1164 ypr_status(ctx, notif->flags, notif->exts, &flag);
1165 ypr_description(ctx, notif->dsc, notif->exts, &flag);
1166 ypr_reference(ctx, notif->ref, notif->exts, &flag);
1167
Radek Krejci52f65552020-09-01 17:03:35 +02001168 if (!(ctx->options & LYS_PRINT_NO_SUBSTMT)) {
Radek Krejci01180ac2021-01-27 08:48:22 +01001169 LY_LIST_FOR(notif->child, data) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001170 ypr_open(ctx->out, &flag);
1171 yprc_node(ctx, data);
1172 }
Radek Krejci693262f2019-04-29 15:23:20 +02001173 }
1174
1175 LEVEL--;
1176 ypr_close(ctx, flag);
1177}
1178
1179static void
Radek Krejci2a9fc652021-01-22 17:44:34 +01001180yprp_action(struct ypr_ctx *ctx, const struct lysp_node_action *action)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001181{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001182 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001183 ly_bool flag = 0;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001184 struct lysp_node_grp *grp;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001185
Michal Vasko5233e962020-08-14 14:26:20 +02001186 ly_print_(ctx->out, "%*s%s %s", INDENT, action->parent ? "action" : "rpc", action->name);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001187
1188 LEVEL++;
Radek Krejci693262f2019-04-29 15:23:20 +02001189 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, action->exts, &flag, 0);
1190 yprp_iffeatures(ctx, action->iffeatures, action->exts, &flag);
1191 ypr_status(ctx, action->flags, action->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001192 ypr_description(ctx, action->dsc, action->exts, &flag);
1193 ypr_reference(ctx, action->ref, action->exts, &flag);
1194
1195 LY_ARRAY_FOR(action->typedefs, u) {
1196 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001197 yprp_typedef(ctx, &action->typedefs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001198 }
1199
Radek Krejci2a9fc652021-01-22 17:44:34 +01001200 LY_LIST_FOR(action->groupings, grp) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001201 ypr_open(ctx->out, &flag);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001202 yprp_grouping(ctx, grp);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001203 }
1204
Radek Krejci693262f2019-04-29 15:23:20 +02001205 yprp_inout(ctx, &action->input, &flag);
1206 yprp_inout(ctx, &action->output, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001207
1208 LEVEL--;
1209 ypr_close(ctx, flag);
1210}
1211
1212static void
Radek Krejci2a9fc652021-01-22 17:44:34 +01001213yprc_action(struct ypr_ctx *ctx, const struct lysc_node_action *action)
Radek Krejci693262f2019-04-29 15:23:20 +02001214{
Radek Krejci857189e2020-09-01 13:26:36 +02001215 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02001216
Michal Vasko5233e962020-08-14 14:26:20 +02001217 ly_print_(ctx->out, "%*s%s %s", INDENT, action->parent ? "action" : "rpc", action->name);
Radek Krejci693262f2019-04-29 15:23:20 +02001218
1219 LEVEL++;
1220 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, action->exts, &flag, 0);
Radek Krejci693262f2019-04-29 15:23:20 +02001221 ypr_status(ctx, action->flags, action->exts, &flag);
1222 ypr_description(ctx, action->dsc, action->exts, &flag);
1223 ypr_reference(ctx, action->ref, action->exts, &flag);
1224
Michal Vasko544e58a2021-01-28 14:33:41 +01001225 yprc_inout(ctx, &action->input, &flag);
1226 yprc_inout(ctx, &action->output, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001227
1228 LEVEL--;
1229 ypr_close(ctx, flag);
1230}
1231
1232static void
Radek Krejci857189e2020-09-01 13:26:36 +02001233yprp_node_common1(struct ypr_ctx *ctx, const struct lysp_node *node, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001234{
Michal Vasko5233e962020-08-14 14:26:20 +02001235 ly_print_(ctx->out, "%*s%s %s%s", INDENT, lys_nodetype2str(node->nodetype), node->name, flag ? "" : " {\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +02001236 LEVEL++;
1237
Radek Krejci693262f2019-04-29 15:23:20 +02001238 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, node->exts, flag, 0);
Radek Krejci9a3823e2021-01-27 20:26:46 +01001239 yprp_when(ctx, lysp_node_when(node), flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001240 yprp_iffeatures(ctx, node->iffeatures, node->exts, flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001241}
1242
1243static void
Radek Krejci857189e2020-09-01 13:26:36 +02001244yprc_node_common1(struct ypr_ctx *ctx, const struct lysc_node *node, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001245{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001246 LY_ARRAY_COUNT_TYPE u;
Radek Krejci9a3823e2021-01-27 20:26:46 +01001247 struct lysc_when **when;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001248
Michal Vasko5233e962020-08-14 14:26:20 +02001249 ly_print_(ctx->out, "%*s%s %s%s", INDENT, lys_nodetype2str(node->nodetype), node->name, flag ? "" : " {\n");
Radek Krejci693262f2019-04-29 15:23:20 +02001250 LEVEL++;
1251
1252 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, node->exts, flag, 0);
Radek Krejci9a3823e2021-01-27 20:26:46 +01001253
1254 when = lysc_node_when(node);
1255 LY_ARRAY_FOR(when, u) {
1256 yprc_when(ctx, when[u], flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001257 }
Radek Krejci693262f2019-04-29 15:23:20 +02001258}
1259
1260/* macr oto unify the code */
1261#define YPR_NODE_COMMON2 \
1262 ypr_config(ctx, node->flags, node->exts, flag); \
1263 if (node->nodetype & (LYS_CHOICE | LYS_LEAF | LYS_ANYDATA)) { \
1264 ypr_mandatory(ctx, node->flags, node->exts, flag); \
1265 } \
1266 ypr_status(ctx, node->flags, node->exts, flag); \
1267 ypr_description(ctx, node->dsc, node->exts, flag); \
1268 ypr_reference(ctx, node->ref, node->exts, flag)
1269
1270static void
Radek Krejci857189e2020-09-01 13:26:36 +02001271yprp_node_common2(struct ypr_ctx *ctx, const struct lysp_node *node, ly_bool *flag)
Radek Krejci693262f2019-04-29 15:23:20 +02001272{
1273 YPR_NODE_COMMON2;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001274}
1275
1276static void
Radek Krejci857189e2020-09-01 13:26:36 +02001277yprc_node_common2(struct ypr_ctx *ctx, const struct lysc_node *node, ly_bool *flag)
Radek Krejci693262f2019-04-29 15:23:20 +02001278{
1279 YPR_NODE_COMMON2;
1280}
1281
1282#undef YPR_NODE_COMMON2
1283
1284static void
1285yprp_container(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001286{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001287 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001288 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001289 struct lysp_node *child;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001290 struct lysp_node_action *action;
1291 struct lysp_node_notif *notif;
1292 struct lysp_node_grp *grp;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001293 struct lysp_node_container *cont = (struct lysp_node_container *)node;
1294
Radek Krejci693262f2019-04-29 15:23:20 +02001295 yprp_node_common1(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001296
1297 LY_ARRAY_FOR(cont->musts, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001298 yprp_restr(ctx, &cont->musts[u], "must", &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001299 }
1300 if (cont->presence) {
1301 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001302 ypr_substmt(ctx, LYEXT_SUBSTMT_PRESENCE, 0, cont->presence, cont->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001303 }
1304
Radek Krejci693262f2019-04-29 15:23:20 +02001305 yprp_node_common2(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001306
1307 LY_ARRAY_FOR(cont->typedefs, u) {
1308 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001309 yprp_typedef(ctx, &cont->typedefs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001310 }
1311
Radek Krejci2a9fc652021-01-22 17:44:34 +01001312 LY_LIST_FOR(cont->groupings, grp) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001313 ypr_open(ctx->out, &flag);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001314 yprp_grouping(ctx, grp);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001315 }
1316
1317 LY_LIST_FOR(cont->child, child) {
1318 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001319 yprp_node(ctx, child);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001320 }
1321
Radek Krejci2a9fc652021-01-22 17:44:34 +01001322 LY_LIST_FOR(cont->actions, action) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001323 ypr_open(ctx->out, &flag);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001324 yprp_action(ctx, action);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001325 }
1326
Radek Krejci2a9fc652021-01-22 17:44:34 +01001327 LY_LIST_FOR(cont->notifs, notif) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001328 ypr_open(ctx->out, &flag);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001329 yprp_notification(ctx, notif);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001330 }
1331
1332 LEVEL--;
1333 ypr_close(ctx, flag);
1334}
1335
1336static void
Radek Krejci693262f2019-04-29 15:23:20 +02001337yprc_container(struct ypr_ctx *ctx, const struct lysc_node *node)
1338{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001339 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001340 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02001341 struct lysc_node *child;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001342 struct lysc_node_action *action;
1343 struct lysc_node_notif *notif;
Radek Krejci693262f2019-04-29 15:23:20 +02001344 struct lysc_node_container *cont = (struct lysc_node_container *)node;
1345
1346 yprc_node_common1(ctx, node, &flag);
1347
1348 LY_ARRAY_FOR(cont->musts, u) {
1349 yprc_must(ctx, &cont->musts[u], &flag);
1350 }
1351 if (cont->flags & LYS_PRESENCE) {
1352 ypr_open(ctx->out, &flag);
1353 ypr_substmt(ctx, LYEXT_SUBSTMT_PRESENCE, 0, "true", cont->exts);
1354 }
1355
1356 yprc_node_common2(ctx, node, &flag);
1357
Radek Krejci52f65552020-09-01 17:03:35 +02001358 if (!(ctx->options & LYS_PRINT_NO_SUBSTMT)) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001359 LY_LIST_FOR(cont->child, child) {
1360 ypr_open(ctx->out, &flag);
1361 yprc_node(ctx, child);
1362 }
Radek Krejci693262f2019-04-29 15:23:20 +02001363
Radek Krejci2a9fc652021-01-22 17:44:34 +01001364 LY_LIST_FOR(cont->actions, action) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001365 ypr_open(ctx->out, &flag);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001366 yprc_action(ctx, action);
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001367 }
Radek Krejci693262f2019-04-29 15:23:20 +02001368
Radek Krejci2a9fc652021-01-22 17:44:34 +01001369 LY_LIST_FOR(cont->notifs, notif) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001370 ypr_open(ctx->out, &flag);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001371 yprc_notification(ctx, notif);
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001372 }
Radek Krejci693262f2019-04-29 15:23:20 +02001373 }
1374
1375 LEVEL--;
1376 ypr_close(ctx, flag);
1377}
1378
1379static void
1380yprp_case(struct ypr_ctx *ctx, const struct lysp_node *node)
1381{
Radek Krejci857189e2020-09-01 13:26:36 +02001382 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02001383 struct lysp_node *child;
1384 struct lysp_node_case *cas = (struct lysp_node_case *)node;
1385
1386 yprp_node_common1(ctx, node, &flag);
1387 yprp_node_common2(ctx, node, &flag);
1388
1389 LY_LIST_FOR(cas->child, child) {
1390 ypr_open(ctx->out, &flag);
1391 yprp_node(ctx, child);
1392 }
1393
1394 LEVEL--;
1395 ypr_close(ctx, flag);
1396}
1397
1398static void
1399yprc_case(struct ypr_ctx *ctx, const struct lysc_node_case *cs)
1400{
Radek Krejci857189e2020-09-01 13:26:36 +02001401 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02001402 struct lysc_node *child;
1403
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001404 yprc_node_common1(ctx, &cs->node, &flag);
1405 yprc_node_common2(ctx, &cs->node, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001406
Radek Krejci52f65552020-09-01 17:03:35 +02001407 if (!(ctx->options & LYS_PRINT_NO_SUBSTMT)) {
Michal Vasko22df3f02020-08-24 13:29:22 +02001408 for (child = cs->child; child && child->parent == (struct lysc_node *)cs; child = child->next) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001409 ypr_open(ctx->out, &flag);
1410 yprc_node(ctx, child);
1411 }
Radek Krejci693262f2019-04-29 15:23:20 +02001412 }
1413
1414 LEVEL--;
1415 ypr_close(ctx, flag);
1416}
1417
1418static void
1419yprp_choice(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001420{
Radek Krejci857189e2020-09-01 13:26:36 +02001421 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001422 struct lysp_node *child;
1423 struct lysp_node_choice *choice = (struct lysp_node_choice *)node;
1424
Radek Krejci693262f2019-04-29 15:23:20 +02001425 yprp_node_common1(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001426
Michal Vasko7f45cf22020-10-01 12:49:44 +02001427 if (choice->dflt.str) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001428 ypr_open(ctx->out, &flag);
Michal Vasko7f45cf22020-10-01 12:49:44 +02001429 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, choice->dflt.str, choice->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001430 }
1431
Radek Krejci693262f2019-04-29 15:23:20 +02001432 yprp_node_common2(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001433
1434 LY_LIST_FOR(choice->child, child) {
1435 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001436 yprp_node(ctx, child);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001437 }
1438
1439 LEVEL--;
1440 ypr_close(ctx, flag);
1441}
1442
1443static void
Radek Krejci693262f2019-04-29 15:23:20 +02001444yprc_choice(struct ypr_ctx *ctx, const struct lysc_node *node)
1445{
Radek Krejci857189e2020-09-01 13:26:36 +02001446 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02001447 struct lysc_node_case *cs;
1448 struct lysc_node_choice *choice = (struct lysc_node_choice *)node;
1449
1450 yprc_node_common1(ctx, node, &flag);
1451
1452 if (choice->dflt) {
1453 ypr_open(ctx->out, &flag);
1454 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, choice->dflt->name, choice->exts);
1455 }
1456
1457 yprc_node_common2(ctx, node, &flag);
1458
Michal Vasko22df3f02020-08-24 13:29:22 +02001459 for (cs = choice->cases; cs; cs = (struct lysc_node_case *)cs->next) {
Radek Krejci693262f2019-04-29 15:23:20 +02001460 ypr_open(ctx->out, &flag);
1461 yprc_case(ctx, cs);
1462 }
1463
1464 LEVEL--;
1465 ypr_close(ctx, flag);
1466}
1467
1468static void
1469yprp_leaf(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001470{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001471 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001472 struct lysp_node_leaf *leaf = (struct lysp_node_leaf *)node;
1473
Radek Krejci693262f2019-04-29 15:23:20 +02001474 yprp_node_common1(ctx, node, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001475
Radek Krejci693262f2019-04-29 15:23:20 +02001476 yprp_type(ctx, &leaf->type);
1477 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, leaf->units, leaf->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001478 LY_ARRAY_FOR(leaf->musts, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001479 yprp_restr(ctx, &leaf->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001480 }
Michal Vasko7f45cf22020-10-01 12:49:44 +02001481 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, leaf->dflt.str, leaf->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001482
Radek Krejci693262f2019-04-29 15:23:20 +02001483 yprp_node_common2(ctx, node, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001484
1485 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02001486 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001487}
1488
1489static void
Radek Krejci693262f2019-04-29 15:23:20 +02001490yprc_leaf(struct ypr_ctx *ctx, const struct lysc_node *node)
1491{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001492 LY_ARRAY_COUNT_TYPE u;
Radek Krejci693262f2019-04-29 15:23:20 +02001493 struct lysc_node_leaf *leaf = (struct lysc_node_leaf *)node;
1494
1495 yprc_node_common1(ctx, node, NULL);
1496
1497 yprc_type(ctx, leaf->type);
1498 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, leaf->units, leaf->exts);
1499 LY_ARRAY_FOR(leaf->musts, u) {
1500 yprc_must(ctx, &leaf->musts[u], NULL);
1501 }
Radek Krejcia1911222019-07-22 17:24:50 +02001502
1503 if (leaf->dflt) {
Michal Vaskoba99a3e2020-08-18 15:50:05 +02001504 yprc_dflt_value(ctx, leaf->dflt, leaf->exts);
Radek Krejcia1911222019-07-22 17:24:50 +02001505 }
Radek Krejci693262f2019-04-29 15:23:20 +02001506
1507 yprc_node_common2(ctx, node, NULL);
1508
1509 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02001510 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejci693262f2019-04-29 15:23:20 +02001511}
1512
1513static void
1514yprp_leaflist(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001515{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001516 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001517 struct lysp_node_leaflist *llist = (struct lysp_node_leaflist *)node;
1518
Radek Krejci693262f2019-04-29 15:23:20 +02001519 yprp_node_common1(ctx, node, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001520
Radek Krejci693262f2019-04-29 15:23:20 +02001521 yprp_type(ctx, &llist->type);
1522 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, llist->units, llist->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001523 LY_ARRAY_FOR(llist->musts, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001524 yprp_restr(ctx, &llist->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001525 }
1526 LY_ARRAY_FOR(llist->dflts, u) {
Michal Vasko7f45cf22020-10-01 12:49:44 +02001527 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, llist->dflts[u].str, llist->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001528 }
1529
Radek Krejci693262f2019-04-29 15:23:20 +02001530 ypr_config(ctx, node->flags, node->exts, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001531
1532 if (llist->flags & LYS_SET_MIN) {
Radek Krejci693262f2019-04-29 15:23:20 +02001533 ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN, 0, llist->exts, llist->min, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001534 }
1535 if (llist->flags & LYS_SET_MAX) {
1536 if (llist->max) {
Radek Krejci693262f2019-04-29 15:23:20 +02001537 ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX, 0, llist->exts, llist->max, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001538 } else {
Radek Krejci693262f2019-04-29 15:23:20 +02001539 ypr_substmt(ctx, LYEXT_SUBSTMT_MAX, 0, "unbounded", llist->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001540 }
1541 }
1542
1543 if (llist->flags & LYS_ORDBY_MASK) {
Radek Krejci693262f2019-04-29 15:23:20 +02001544 ypr_substmt(ctx, LYEXT_SUBSTMT_ORDEREDBY, 0, (llist->flags & LYS_ORDBY_USER) ? "user" : "system", llist->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001545 }
1546
Radek Krejci693262f2019-04-29 15:23:20 +02001547 ypr_status(ctx, node->flags, node->exts, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001548 ypr_description(ctx, node->dsc, node->exts, NULL);
1549 ypr_reference(ctx, node->ref, node->exts, NULL);
1550
1551 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02001552 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001553}
1554
1555static void
Radek Krejci693262f2019-04-29 15:23:20 +02001556yprc_leaflist(struct ypr_ctx *ctx, const struct lysc_node *node)
1557{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001558 LY_ARRAY_COUNT_TYPE u;
Radek Krejci693262f2019-04-29 15:23:20 +02001559 struct lysc_node_leaflist *llist = (struct lysc_node_leaflist *)node;
1560
1561 yprc_node_common1(ctx, node, NULL);
1562
1563 yprc_type(ctx, llist->type);
1564 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, llist->units, llist->exts);
1565 LY_ARRAY_FOR(llist->musts, u) {
1566 yprc_must(ctx, &llist->musts[u], NULL);
1567 }
1568 LY_ARRAY_FOR(llist->dflts, u) {
Michal Vaskoba99a3e2020-08-18 15:50:05 +02001569 yprc_dflt_value(ctx, llist->dflts[u], llist->exts);
Radek Krejci693262f2019-04-29 15:23:20 +02001570 }
1571
1572 ypr_config(ctx, node->flags, node->exts, NULL);
1573
1574 ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN, 0, llist->exts, llist->min, NULL);
1575 if (llist->max) {
1576 ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX, 0, llist->exts, llist->max, NULL);
1577 } else {
1578 ypr_substmt(ctx, LYEXT_SUBSTMT_MAX, 0, "unbounded", llist->exts);
1579 }
1580
1581 ypr_substmt(ctx, LYEXT_SUBSTMT_ORDEREDBY, 0, (llist->flags & LYS_ORDBY_USER) ? "user" : "system", llist->exts);
1582
1583 ypr_status(ctx, node->flags, node->exts, NULL);
1584 ypr_description(ctx, node->dsc, node->exts, NULL);
1585 ypr_reference(ctx, node->ref, node->exts, NULL);
1586
1587 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02001588 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejci693262f2019-04-29 15:23:20 +02001589}
1590
1591static void
1592yprp_list(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001593{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001594 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001595 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001596 struct lysp_node *child;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001597 struct lysp_node_action *action;
1598 struct lysp_node_notif *notif;
1599 struct lysp_node_grp *grp;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001600 struct lysp_node_list *list = (struct lysp_node_list *)node;
1601
Radek Krejci693262f2019-04-29 15:23:20 +02001602 yprp_node_common1(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001603
1604 LY_ARRAY_FOR(list->musts, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001605 yprp_restr(ctx, &list->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001606 }
1607 if (list->key) {
1608 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001609 ypr_substmt(ctx, LYEXT_SUBSTMT_KEY, 0, list->key, list->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001610 }
1611 LY_ARRAY_FOR(list->uniques, u) {
1612 ypr_open(ctx->out, &flag);
Michal Vasko7f45cf22020-10-01 12:49:44 +02001613 ypr_substmt(ctx, LYEXT_SUBSTMT_UNIQUE, u, list->uniques[u].str, list->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001614 }
1615
Michal Vaskoacb8e742020-10-20 10:28:02 +02001616 ypr_config(ctx, node->flags, node->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001617
1618 if (list->flags & LYS_SET_MIN) {
Michal Vaskoacb8e742020-10-20 10:28:02 +02001619 ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN, 0, list->exts, list->min, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001620 }
1621 if (list->flags & LYS_SET_MAX) {
1622 if (list->max) {
Michal Vaskoacb8e742020-10-20 10:28:02 +02001623 ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX, 0, list->exts, list->max, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001624 } else {
Michal Vaskoacb8e742020-10-20 10:28:02 +02001625 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001626 ypr_substmt(ctx, LYEXT_SUBSTMT_MAX, 0, "unbounded", list->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001627 }
1628 }
1629
1630 if (list->flags & LYS_ORDBY_MASK) {
Michal Vaskoacb8e742020-10-20 10:28:02 +02001631 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001632 ypr_substmt(ctx, LYEXT_SUBSTMT_ORDEREDBY, 0, (list->flags & LYS_ORDBY_USER) ? "user" : "system", list->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001633 }
1634
Michal Vaskoacb8e742020-10-20 10:28:02 +02001635 ypr_status(ctx, node->flags, node->exts, &flag);
1636 ypr_description(ctx, node->dsc, node->exts, &flag);
1637 ypr_reference(ctx, node->ref, node->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001638
1639 LY_ARRAY_FOR(list->typedefs, u) {
1640 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001641 yprp_typedef(ctx, &list->typedefs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001642 }
1643
Radek Krejci2a9fc652021-01-22 17:44:34 +01001644 LY_LIST_FOR(list->groupings, grp) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001645 ypr_open(ctx->out, &flag);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001646 yprp_grouping(ctx, grp);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001647 }
1648
1649 LY_LIST_FOR(list->child, child) {
1650 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001651 yprp_node(ctx, child);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001652 }
1653
Radek Krejci2a9fc652021-01-22 17:44:34 +01001654 LY_LIST_FOR(list->actions, action) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001655 ypr_open(ctx->out, &flag);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001656 yprp_action(ctx, action);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001657 }
1658
Radek Krejci2a9fc652021-01-22 17:44:34 +01001659 LY_LIST_FOR(list->notifs, notif) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001660 ypr_open(ctx->out, &flag);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001661 yprp_notification(ctx, notif);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001662 }
1663
1664 LEVEL--;
1665 ypr_close(ctx, flag);
1666}
1667
1668static void
Radek Krejci693262f2019-04-29 15:23:20 +02001669yprc_list(struct ypr_ctx *ctx, const struct lysc_node *node)
1670{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001671 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejci693262f2019-04-29 15:23:20 +02001672 struct lysc_node_list *list = (struct lysc_node_list *)node;
1673
Michal Vaskoacb8e742020-10-20 10:28:02 +02001674 yprc_node_common1(ctx, node, NULL);
Radek Krejci693262f2019-04-29 15:23:20 +02001675
1676 LY_ARRAY_FOR(list->musts, u) {
1677 yprc_must(ctx, &list->musts[u], NULL);
1678 }
Radek Krejci0fe9b512019-07-26 17:51:05 +02001679 if (!(list->flags & LYS_KEYLESS)) {
Michal Vasko5233e962020-08-14 14:26:20 +02001680 ly_print_(ctx->out, "%*skey \"", INDENT);
Radek Krejci0fe9b512019-07-26 17:51:05 +02001681 for (struct lysc_node *key = list->child; key && key->nodetype == LYS_LEAF && (key->flags & LYS_KEY); key = key->next) {
Michal Vasko5233e962020-08-14 14:26:20 +02001682 ly_print_(ctx->out, "%s%s", u > 0 ? ", " : "", key->name);
Radek Krejci693262f2019-04-29 15:23:20 +02001683 }
Michal Vasko5233e962020-08-14 14:26:20 +02001684 ly_print_(ctx->out, "\";\n");
Radek Krejci693262f2019-04-29 15:23:20 +02001685 }
1686 LY_ARRAY_FOR(list->uniques, u) {
Michal Vasko5233e962020-08-14 14:26:20 +02001687 ly_print_(ctx->out, "%*sunique \"", INDENT);
Radek Krejci693262f2019-04-29 15:23:20 +02001688 LY_ARRAY_FOR(list->uniques[u], v) {
Michal Vasko5233e962020-08-14 14:26:20 +02001689 ly_print_(ctx->out, "%s%s", v > 0 ? ", " : "", list->uniques[u][v]->name);
Radek Krejci693262f2019-04-29 15:23:20 +02001690 }
1691 ypr_close(ctx, 0);
1692 }
1693
1694 ypr_config(ctx, node->flags, node->exts, NULL);
1695
1696 ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN, 0, list->exts, list->min, NULL);
1697 if (list->max) {
1698 ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX, 0, list->exts, list->max, NULL);
1699 } else {
1700 ypr_substmt(ctx, LYEXT_SUBSTMT_MAX, 0, "unbounded", list->exts);
1701 }
1702
1703 ypr_substmt(ctx, LYEXT_SUBSTMT_ORDEREDBY, 0, (list->flags & LYS_ORDBY_USER) ? "user" : "system", list->exts);
1704
1705 ypr_status(ctx, node->flags, node->exts, NULL);
1706 ypr_description(ctx, node->dsc, node->exts, NULL);
1707 ypr_reference(ctx, node->ref, node->exts, NULL);
1708
Radek Krejci52f65552020-09-01 17:03:35 +02001709 if (!(ctx->options & LYS_PRINT_NO_SUBSTMT)) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001710 struct lysc_node *child;
1711 struct lysc_node_action *action;
1712 struct lysc_node_notif *notif;
1713
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001714 LY_LIST_FOR(list->child, child) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001715 yprc_node(ctx, child);
1716 }
Radek Krejci693262f2019-04-29 15:23:20 +02001717
Radek Krejci2a9fc652021-01-22 17:44:34 +01001718 LY_LIST_FOR(list->actions, action) {
1719 yprc_action(ctx, action);
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001720 }
Radek Krejci693262f2019-04-29 15:23:20 +02001721
Radek Krejci2a9fc652021-01-22 17:44:34 +01001722 LY_LIST_FOR(list->notifs, notif) {
1723 yprc_notification(ctx, notif);
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001724 }
Radek Krejci693262f2019-04-29 15:23:20 +02001725 }
1726
1727 LEVEL--;
Michal Vaskoacb8e742020-10-20 10:28:02 +02001728 ypr_close(ctx, 1);
Radek Krejci693262f2019-04-29 15:23:20 +02001729}
1730
1731static void
1732yprp_refine(struct ypr_ctx *ctx, struct lysp_refine *refine)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001733{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001734 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001735 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001736
Michal Vasko5233e962020-08-14 14:26:20 +02001737 ly_print_(ctx->out, "%*srefine \"%s\"", INDENT, refine->nodeid);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001738 LEVEL++;
1739
Radek Krejci693262f2019-04-29 15:23:20 +02001740 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, refine->exts, &flag, 0);
1741 yprp_iffeatures(ctx, refine->iffeatures, refine->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001742
1743 LY_ARRAY_FOR(refine->musts, u) {
1744 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001745 yprp_restr(ctx, &refine->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001746 }
1747
1748 if (refine->presence) {
1749 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001750 ypr_substmt(ctx, LYEXT_SUBSTMT_PRESENCE, 0, refine->presence, refine->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001751 }
1752
1753 LY_ARRAY_FOR(refine->dflts, u) {
1754 ypr_open(ctx->out, &flag);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001755 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, refine->dflts[u].str, refine->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001756 }
1757
Radek Krejci693262f2019-04-29 15:23:20 +02001758 ypr_config(ctx, refine->flags, refine->exts, &flag);
1759 ypr_mandatory(ctx, refine->flags, refine->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001760
1761 if (refine->flags & LYS_SET_MIN) {
1762 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001763 ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN, 0, refine->exts, refine->min, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001764 }
1765 if (refine->flags & LYS_SET_MAX) {
1766 ypr_open(ctx->out, &flag);
1767 if (refine->max) {
Radek Krejci693262f2019-04-29 15:23:20 +02001768 ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX, 0, refine->exts, refine->max, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001769 } else {
Radek Krejci693262f2019-04-29 15:23:20 +02001770 ypr_substmt(ctx, LYEXT_SUBSTMT_MAX, 0, "unbounded", refine->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001771 }
1772 }
1773
1774 ypr_description(ctx, refine->dsc, refine->exts, &flag);
1775 ypr_reference(ctx, refine->ref, refine->exts, &flag);
1776
1777 LEVEL--;
1778 ypr_close(ctx, flag);
1779}
1780
1781static void
Radek Krejci2a9fc652021-01-22 17:44:34 +01001782yprp_augment(struct ypr_ctx *ctx, const struct lysp_node_augment *aug)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001783{
Radek Krejcid3ca0632019-04-16 16:54:54 +02001784 struct lysp_node *child;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001785 struct lysp_node_action *action;
1786 struct lysp_node_notif *notif;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001787
Michal Vasko5233e962020-08-14 14:26:20 +02001788 ly_print_(ctx->out, "%*saugment \"%s\" {\n", INDENT, aug->nodeid);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001789 LEVEL++;
1790
Radek Krejci693262f2019-04-29 15:23:20 +02001791 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, aug->exts, NULL, 0);
1792 yprp_when(ctx, aug->when, NULL);
1793 yprp_iffeatures(ctx, aug->iffeatures, aug->exts, NULL);
1794 ypr_status(ctx, aug->flags, aug->exts, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001795 ypr_description(ctx, aug->dsc, aug->exts, NULL);
1796 ypr_reference(ctx, aug->ref, aug->exts, NULL);
1797
1798 LY_LIST_FOR(aug->child, child) {
Radek Krejci693262f2019-04-29 15:23:20 +02001799 yprp_node(ctx, child);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001800 }
1801
Radek Krejci2a9fc652021-01-22 17:44:34 +01001802 LY_LIST_FOR(aug->actions, action) {
1803 yprp_action(ctx, action);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001804 }
1805
Radek Krejci2a9fc652021-01-22 17:44:34 +01001806 LY_LIST_FOR(aug->notifs, notif) {
1807 yprp_notification(ctx, notif);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001808 }
1809
1810 LEVEL--;
Radek Krejcifc81ea82019-04-18 13:27:22 +02001811 ypr_close(ctx, 1);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001812}
1813
Radek Krejcid3ca0632019-04-16 16:54:54 +02001814static void
Radek Krejci693262f2019-04-29 15:23:20 +02001815yprp_uses(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001816{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001817 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001818 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001819 struct lysp_node_uses *uses = (struct lysp_node_uses *)node;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001820 struct lysp_node_augment *aug;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001821
Radek Krejci693262f2019-04-29 15:23:20 +02001822 yprp_node_common1(ctx, node, &flag);
1823 yprp_node_common2(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001824
1825 LY_ARRAY_FOR(uses->refines, u) {
1826 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001827 yprp_refine(ctx, &uses->refines[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001828 }
1829
Radek Krejci2a9fc652021-01-22 17:44:34 +01001830 LY_LIST_FOR(uses->augments, aug) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001831 ypr_open(ctx->out, &flag);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001832 yprp_augment(ctx, aug);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001833 }
1834
1835 LEVEL--;
1836 ypr_close(ctx, flag);
1837}
1838
1839static void
Radek Krejci693262f2019-04-29 15:23:20 +02001840yprp_anydata(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001841{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001842 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001843 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001844 struct lysp_node_anydata *any = (struct lysp_node_anydata *)node;
1845
Radek Krejci693262f2019-04-29 15:23:20 +02001846 yprp_node_common1(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001847
1848 LY_ARRAY_FOR(any->musts, u) {
1849 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001850 yprp_restr(ctx, &any->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001851 }
1852
Radek Krejci693262f2019-04-29 15:23:20 +02001853 yprp_node_common2(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001854
1855 LEVEL--;
1856 ypr_close(ctx, flag);
1857}
1858
1859static void
Radek Krejci693262f2019-04-29 15:23:20 +02001860yprc_anydata(struct ypr_ctx *ctx, const struct lysc_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001861{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001862 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001863 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02001864 struct lysc_node_anydata *any = (struct lysc_node_anydata *)node;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001865
Radek Krejci693262f2019-04-29 15:23:20 +02001866 yprc_node_common1(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001867
Radek Krejci693262f2019-04-29 15:23:20 +02001868 LY_ARRAY_FOR(any->musts, u) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001869 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001870 yprc_must(ctx, &any->musts[u], NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001871 }
1872
Radek Krejci693262f2019-04-29 15:23:20 +02001873 yprc_node_common2(ctx, node, &flag);
1874
Radek Krejcid3ca0632019-04-16 16:54:54 +02001875 LEVEL--;
1876 ypr_close(ctx, flag);
1877}
1878
1879static void
Radek Krejci693262f2019-04-29 15:23:20 +02001880yprp_node(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001881{
1882 switch (node->nodetype) {
1883 case LYS_CONTAINER:
Radek Krejci693262f2019-04-29 15:23:20 +02001884 yprp_container(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001885 break;
1886 case LYS_CHOICE:
Radek Krejci693262f2019-04-29 15:23:20 +02001887 yprp_choice(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001888 break;
1889 case LYS_LEAF:
Radek Krejci693262f2019-04-29 15:23:20 +02001890 yprp_leaf(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001891 break;
1892 case LYS_LEAFLIST:
Radek Krejci693262f2019-04-29 15:23:20 +02001893 yprp_leaflist(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001894 break;
1895 case LYS_LIST:
Radek Krejci693262f2019-04-29 15:23:20 +02001896 yprp_list(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001897 break;
1898 case LYS_USES:
Radek Krejci693262f2019-04-29 15:23:20 +02001899 yprp_uses(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001900 break;
1901 case LYS_ANYXML:
1902 case LYS_ANYDATA:
Radek Krejci693262f2019-04-29 15:23:20 +02001903 yprp_anydata(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001904 break;
1905 case LYS_CASE:
Radek Krejci693262f2019-04-29 15:23:20 +02001906 yprp_case(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001907 break;
1908 default:
1909 break;
1910 }
1911}
1912
1913static void
Radek Krejci693262f2019-04-29 15:23:20 +02001914yprc_node(struct ypr_ctx *ctx, const struct lysc_node *node)
1915{
1916 switch (node->nodetype) {
1917 case LYS_CONTAINER:
1918 yprc_container(ctx, node);
1919 break;
1920 case LYS_CHOICE:
1921 yprc_choice(ctx, node);
1922 break;
1923 case LYS_LEAF:
1924 yprc_leaf(ctx, node);
1925 break;
1926 case LYS_LEAFLIST:
1927 yprc_leaflist(ctx, node);
1928 break;
1929 case LYS_LIST:
1930 yprc_list(ctx, node);
1931 break;
1932 case LYS_ANYXML:
1933 case LYS_ANYDATA:
1934 yprc_anydata(ctx, node);
1935 break;
1936 default:
1937 break;
1938 }
1939}
1940
1941static void
1942yprp_deviation(struct ypr_ctx *ctx, const struct lysp_deviation *deviation)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001943{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001944 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001945 struct lysp_deviate_add *add;
1946 struct lysp_deviate_rpl *rpl;
1947 struct lysp_deviate_del *del;
fredgan2b11ddb2019-10-21 11:03:39 +08001948 struct lysp_deviate *elem;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001949
Michal Vasko5233e962020-08-14 14:26:20 +02001950 ly_print_(ctx->out, "%*sdeviation \"%s\" {\n", INDENT, deviation->nodeid);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001951 LEVEL++;
1952
Radek Krejci693262f2019-04-29 15:23:20 +02001953 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, deviation->exts, NULL, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001954 ypr_description(ctx, deviation->dsc, deviation->exts, NULL);
1955 ypr_reference(ctx, deviation->ref, deviation->exts, NULL);
1956
fredgan2b11ddb2019-10-21 11:03:39 +08001957 LY_LIST_FOR(deviation->deviates, elem) {
Michal Vasko5233e962020-08-14 14:26:20 +02001958 ly_print_(ctx->out, "%*sdeviate ", INDENT);
fredgan2b11ddb2019-10-21 11:03:39 +08001959 if (elem->mod == LYS_DEV_NOT_SUPPORTED) {
1960 if (elem->exts) {
Michal Vasko5233e962020-08-14 14:26:20 +02001961 ly_print_(ctx->out, "not-supported {\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +02001962 LEVEL++;
1963
fredgan2b11ddb2019-10-21 11:03:39 +08001964 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, elem->exts, NULL, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001965 } else {
Michal Vasko5233e962020-08-14 14:26:20 +02001966 ly_print_(ctx->out, "not-supported;\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +02001967 continue;
1968 }
fredgan2b11ddb2019-10-21 11:03:39 +08001969 } else if (elem->mod == LYS_DEV_ADD) {
Michal Vasko22df3f02020-08-24 13:29:22 +02001970 add = (struct lysp_deviate_add *)elem;
Michal Vasko5233e962020-08-14 14:26:20 +02001971 ly_print_(ctx->out, "add {\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +02001972 LEVEL++;
1973
Radek Krejci693262f2019-04-29 15:23:20 +02001974 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, add->exts, NULL, 0);
1975 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, add->units, add->exts);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001976 LY_ARRAY_FOR(add->musts, u) {
1977 yprp_restr(ctx, &add->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001978 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001979 LY_ARRAY_FOR(add->uniques, u) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001980 ypr_substmt(ctx, LYEXT_SUBSTMT_UNIQUE, u, add->uniques[u].str, add->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001981 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001982 LY_ARRAY_FOR(add->dflts, u) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001983 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, add->dflts[u].str, add->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001984 }
Radek Krejci693262f2019-04-29 15:23:20 +02001985 ypr_config(ctx, add->flags, add->exts, NULL);
1986 ypr_mandatory(ctx, add->flags, add->exts, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001987 if (add->flags & LYS_SET_MIN) {
Radek Krejci693262f2019-04-29 15:23:20 +02001988 ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN, 0, add->exts, add->min, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001989 }
1990 if (add->flags & LYS_SET_MAX) {
1991 if (add->max) {
Radek Krejci693262f2019-04-29 15:23:20 +02001992 ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX, 0, add->exts, add->max, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001993 } else {
Radek Krejci693262f2019-04-29 15:23:20 +02001994 ypr_substmt(ctx, LYEXT_SUBSTMT_MAX, 0, "unbounded", add->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001995 }
1996 }
fredgan2b11ddb2019-10-21 11:03:39 +08001997 } else if (elem->mod == LYS_DEV_REPLACE) {
Michal Vasko22df3f02020-08-24 13:29:22 +02001998 rpl = (struct lysp_deviate_rpl *)elem;
Michal Vasko5233e962020-08-14 14:26:20 +02001999 ly_print_(ctx->out, "replace {\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +02002000 LEVEL++;
2001
Radek Krejci693262f2019-04-29 15:23:20 +02002002 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, rpl->exts, NULL, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002003 if (rpl->type) {
Radek Krejci693262f2019-04-29 15:23:20 +02002004 yprp_type(ctx, rpl->type);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002005 }
Radek Krejci693262f2019-04-29 15:23:20 +02002006 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, rpl->units, rpl->exts);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002007 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, rpl->dflt.str, rpl->exts);
Radek Krejci693262f2019-04-29 15:23:20 +02002008 ypr_config(ctx, rpl->flags, rpl->exts, NULL);
2009 ypr_mandatory(ctx, rpl->flags, rpl->exts, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002010 if (rpl->flags & LYS_SET_MIN) {
Radek Krejci693262f2019-04-29 15:23:20 +02002011 ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN, 0, rpl->exts, rpl->min, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002012 }
2013 if (rpl->flags & LYS_SET_MAX) {
2014 if (rpl->max) {
Radek Krejci693262f2019-04-29 15:23:20 +02002015 ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX, 0, rpl->exts, rpl->max, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002016 } else {
Radek Krejci693262f2019-04-29 15:23:20 +02002017 ypr_substmt(ctx, LYEXT_SUBSTMT_MAX, 0, "unbounded", rpl->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002018 }
2019 }
fredgan2b11ddb2019-10-21 11:03:39 +08002020 } else if (elem->mod == LYS_DEV_DELETE) {
Michal Vasko22df3f02020-08-24 13:29:22 +02002021 del = (struct lysp_deviate_del *)elem;
Michal Vasko5233e962020-08-14 14:26:20 +02002022 ly_print_(ctx->out, "delete {\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +02002023 LEVEL++;
2024
Radek Krejci693262f2019-04-29 15:23:20 +02002025 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, del->exts, NULL, 0);
2026 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, del->units, del->exts);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002027 LY_ARRAY_FOR(del->musts, u) {
2028 yprp_restr(ctx, &del->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002029 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002030 LY_ARRAY_FOR(del->uniques, u) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002031 ypr_substmt(ctx, LYEXT_SUBSTMT_UNIQUE, u, del->uniques[u].str, del->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002032 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002033 LY_ARRAY_FOR(del->dflts, u) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002034 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, del->dflts[u].str, del->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002035 }
2036 }
2037
2038 LEVEL--;
2039 ypr_close(ctx, 1);
2040 }
2041
2042 LEVEL--;
2043 ypr_close(ctx, 1);
2044}
2045
Michal Vasko7c8439f2020-08-05 13:25:19 +02002046static void
2047yang_print_parsed_linkage(struct ypr_ctx *ctx, const struct lysp_module *modp)
Radek Krejcid3ca0632019-04-16 16:54:54 +02002048{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002049 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid3ca0632019-04-16 16:54:54 +02002050
Radek Krejcid3ca0632019-04-16 16:54:54 +02002051 LY_ARRAY_FOR(modp->imports, u) {
Michal Vasko3e9bc2f2020-11-04 17:13:56 +01002052 if (modp->imports[u].flags & LYS_INTERNAL) {
2053 continue;
2054 }
2055
Michal Vasko5233e962020-08-14 14:26:20 +02002056 ly_print_(ctx->out, "%s%*simport %s {\n", u ? "" : "\n", INDENT, modp->imports[u].name);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002057 LEVEL++;
Radek Krejci693262f2019-04-29 15:23:20 +02002058 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, modp->imports[u].exts, NULL, 0);
2059 ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, modp->imports[u].prefix, modp->imports[u].exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002060 if (modp->imports[u].rev[0]) {
Radek Krejci693262f2019-04-29 15:23:20 +02002061 ypr_substmt(ctx, LYEXT_SUBSTMT_REVISIONDATE, 0, modp->imports[u].rev, modp->imports[u].exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002062 }
Radek Krejci693262f2019-04-29 15:23:20 +02002063 ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, modp->imports[u].dsc, modp->imports[u].exts);
2064 ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, modp->imports[u].ref, modp->imports[u].exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002065 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02002066 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002067 }
2068 LY_ARRAY_FOR(modp->includes, u) {
Radek Krejci771928a2021-01-19 13:42:36 +01002069 if (modp->includes[u].injected) {
2070 /* do not print the includes injected from submodules */
2071 continue;
2072 }
Radek Krejcid3ca0632019-04-16 16:54:54 +02002073 if (modp->includes[u].rev[0] || modp->includes[u].dsc || modp->includes[u].ref || modp->includes[u].exts) {
Michal Vasko5233e962020-08-14 14:26:20 +02002074 ly_print_(ctx->out, "%s%*sinclude %s {\n", u ? "" : "\n", INDENT, modp->includes[u].name);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002075 LEVEL++;
Radek Krejci693262f2019-04-29 15:23:20 +02002076 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, modp->includes[u].exts, NULL, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002077 if (modp->includes[u].rev[0]) {
Radek Krejci693262f2019-04-29 15:23:20 +02002078 ypr_substmt(ctx, LYEXT_SUBSTMT_REVISIONDATE, 0, modp->includes[u].rev, modp->includes[u].exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002079 }
Radek Krejci693262f2019-04-29 15:23:20 +02002080 ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, modp->includes[u].dsc, modp->includes[u].exts);
2081 ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, modp->includes[u].ref, modp->includes[u].exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002082 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02002083 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002084 } else {
Michal Vasko5233e962020-08-14 14:26:20 +02002085 ly_print_(ctx->out, "\n%*sinclude \"%s\";\n", INDENT, modp->includes[u].name);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002086 }
2087 }
Michal Vasko7c8439f2020-08-05 13:25:19 +02002088}
Radek Krejcid3ca0632019-04-16 16:54:54 +02002089
Michal Vasko7c8439f2020-08-05 13:25:19 +02002090static void
2091yang_print_parsed_body(struct ypr_ctx *ctx, const struct lysp_module *modp)
2092{
2093 LY_ARRAY_COUNT_TYPE u;
2094 struct lysp_node *data;
Radek Krejci2a9fc652021-01-22 17:44:34 +01002095 struct lysp_node_action *action;
2096 struct lysp_node_notif *notif;
2097 struct lysp_node_grp *grp;
2098 struct lysp_node_augment *aug;
Radek Krejcid3ca0632019-04-16 16:54:54 +02002099
Radek Krejcid3ca0632019-04-16 16:54:54 +02002100 LY_ARRAY_FOR(modp->extensions, u) {
Michal Vasko5233e962020-08-14 14:26:20 +02002101 ly_print_(ctx->out, "\n");
Radek Krejci693262f2019-04-29 15:23:20 +02002102 yprp_extension(ctx, &modp->extensions[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002103 }
2104 if (modp->exts) {
Michal Vasko5233e962020-08-14 14:26:20 +02002105 ly_print_(ctx->out, "\n");
Michal Vasko7c8439f2020-08-05 13:25:19 +02002106 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, modp->exts, NULL, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002107 }
2108
2109 LY_ARRAY_FOR(modp->features, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02002110 yprp_feature(ctx, &modp->features[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002111 }
2112
2113 LY_ARRAY_FOR(modp->identities, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02002114 yprp_identity(ctx, &modp->identities[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002115 }
2116
2117 LY_ARRAY_FOR(modp->typedefs, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02002118 yprp_typedef(ctx, &modp->typedefs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002119 }
2120
Radek Krejci2a9fc652021-01-22 17:44:34 +01002121 LY_LIST_FOR(modp->groupings, grp) {
2122 yprp_grouping(ctx, grp);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002123 }
2124
2125 LY_LIST_FOR(modp->data, data) {
Radek Krejci693262f2019-04-29 15:23:20 +02002126 yprp_node(ctx, data);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002127 }
2128
Radek Krejci2a9fc652021-01-22 17:44:34 +01002129 LY_LIST_FOR(modp->augments, aug) {
2130 yprp_augment(ctx, aug);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002131 }
2132
Radek Krejci2a9fc652021-01-22 17:44:34 +01002133 LY_LIST_FOR(modp->rpcs, action) {
2134 yprp_action(ctx, action);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002135 }
2136
Radek Krejci2a9fc652021-01-22 17:44:34 +01002137 LY_LIST_FOR(modp->notifs, notif) {
2138 yprp_notification(ctx, notif);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002139 }
2140
2141 LY_ARRAY_FOR(modp->deviations, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02002142 yprp_deviation(ctx, &modp->deviations[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002143 }
Michal Vasko7c8439f2020-08-05 13:25:19 +02002144}
2145
2146LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002147yang_print_parsed_module(struct ly_out *out, const struct lys_module *module, const struct lysp_module *modp, uint32_t options)
Michal Vasko7c8439f2020-08-05 13:25:19 +02002148{
2149 LY_ARRAY_COUNT_TYPE u;
Radek Krejci52f65552020-09-01 17:03:35 +02002150 struct ypr_ctx ctx_ = {.out = out, .level = 0, .module = module, .schema = YPR_PARSED, .options = options}, *ctx = &ctx_;
Michal Vasko7c8439f2020-08-05 13:25:19 +02002151
Michal Vasko5233e962020-08-14 14:26:20 +02002152 ly_print_(ctx->out, "%*smodule %s {\n", INDENT, module->name);
Michal Vasko7c8439f2020-08-05 13:25:19 +02002153 LEVEL++;
2154
2155 /* module-header-stmts */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002156 if (modp->version) {
2157 ypr_substmt(ctx, LYEXT_SUBSTMT_VERSION, 0, modp->version == LYS_VERSION_1_1 ? "1.1" : "1", modp->exts);
Michal Vasko7c8439f2020-08-05 13:25:19 +02002158 }
2159
2160 ypr_substmt(ctx, LYEXT_SUBSTMT_NAMESPACE, 0, module->ns, modp->exts);
2161 ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, module->prefix, modp->exts);
2162
2163 /* linkage-stmts (import/include) */
2164 yang_print_parsed_linkage(ctx, modp);
2165
2166 /* meta-stmts */
2167 if (module->org || module->contact || module->dsc || module->ref) {
Michal Vasko5233e962020-08-14 14:26:20 +02002168 ly_print_(out, "\n");
Michal Vasko7c8439f2020-08-05 13:25:19 +02002169 }
2170 ypr_substmt(ctx, LYEXT_SUBSTMT_ORGANIZATION, 0, module->org, modp->exts);
2171 ypr_substmt(ctx, LYEXT_SUBSTMT_CONTACT, 0, module->contact, modp->exts);
2172 ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, module->dsc, modp->exts);
2173 ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, module->ref, modp->exts);
2174
2175 /* revision-stmts */
2176 if (modp->revs) {
Michal Vasko5233e962020-08-14 14:26:20 +02002177 ly_print_(out, "\n");
Michal Vasko7c8439f2020-08-05 13:25:19 +02002178 }
2179 LY_ARRAY_FOR(modp->revs, u) {
2180 yprp_revision(ctx, &modp->revs[u]);
2181 }
2182 /* body-stmts */
2183 yang_print_parsed_body(ctx, modp);
2184
2185 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02002186 ly_print_(out, "%*s}\n", INDENT);
Michal Vasko7c8439f2020-08-05 13:25:19 +02002187 ly_print_flush(out);
2188
2189 return LY_SUCCESS;
2190}
2191
2192static void
2193yprp_belongsto(struct ypr_ctx *ctx, const struct lysp_submodule *submodp)
2194{
Michal Vaskoc3781c32020-10-06 14:04:08 +02002195 ly_print_(ctx->out, "%*sbelongs-to %s {\n", INDENT, submodp->mod->name);
Michal Vasko7c8439f2020-08-05 13:25:19 +02002196 LEVEL++;
2197 yprp_extension_instances(ctx, LYEXT_SUBSTMT_BELONGSTO, 0, submodp->exts, NULL, 0);
2198 ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, submodp->prefix, submodp->exts);
2199 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02002200 ly_print_(ctx->out, "%*s}\n", INDENT);
Michal Vasko7c8439f2020-08-05 13:25:19 +02002201}
2202
2203LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002204yang_print_parsed_submodule(struct ly_out *out, const struct lys_module *module, const struct lysp_submodule *submodp, uint32_t options)
Michal Vasko7c8439f2020-08-05 13:25:19 +02002205{
2206 LY_ARRAY_COUNT_TYPE u;
Radek Krejci52f65552020-09-01 17:03:35 +02002207 struct ypr_ctx ctx_ = {.out = out, .level = 0, .module = module, .schema = YPR_PARSED, .options = options}, *ctx = &ctx_;
Michal Vasko7c8439f2020-08-05 13:25:19 +02002208
Michal Vasko5233e962020-08-14 14:26:20 +02002209 ly_print_(ctx->out, "%*ssubmodule %s {\n", INDENT, submodp->name);
Michal Vasko7c8439f2020-08-05 13:25:19 +02002210 LEVEL++;
2211
2212 /* submodule-header-stmts */
2213 if (submodp->version) {
2214 ypr_substmt(ctx, LYEXT_SUBSTMT_VERSION, 0, submodp->version == LYS_VERSION_1_1 ? "1.1" : "1", submodp->exts);
2215 }
2216
2217 yprp_belongsto(ctx, submodp);
2218
2219 /* linkage-stmts (import/include) */
2220 yang_print_parsed_linkage(ctx, (struct lysp_module *)submodp);
2221
2222 /* meta-stmts */
2223 if (submodp->org || submodp->contact || submodp->dsc || submodp->ref) {
Michal Vasko5233e962020-08-14 14:26:20 +02002224 ly_print_(out, "\n");
Michal Vasko7c8439f2020-08-05 13:25:19 +02002225 }
2226 ypr_substmt(ctx, LYEXT_SUBSTMT_ORGANIZATION, 0, submodp->org, submodp->exts);
2227 ypr_substmt(ctx, LYEXT_SUBSTMT_CONTACT, 0, submodp->contact, submodp->exts);
2228 ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, submodp->dsc, submodp->exts);
2229 ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, submodp->ref, submodp->exts);
2230
2231 /* revision-stmts */
2232 if (submodp->revs) {
Michal Vasko5233e962020-08-14 14:26:20 +02002233 ly_print_(out, "\n");
Michal Vasko7c8439f2020-08-05 13:25:19 +02002234 }
2235 LY_ARRAY_FOR(submodp->revs, u) {
2236 yprp_revision(ctx, &submodp->revs[u]);
2237 }
2238 /* body-stmts */
2239 yang_print_parsed_body(ctx, (struct lysp_module *)submodp);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002240
2241 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02002242 ly_print_(out, "%*s}\n", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002243 ly_print_flush(out);
2244
2245 return LY_SUCCESS;
2246}
2247
2248LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002249yang_print_compiled_node(struct ly_out *out, const struct lysc_node *node, uint32_t options)
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08002250{
Radek Krejci52f65552020-09-01 17:03:35 +02002251 struct ypr_ctx ctx_ = {.out = out, .level = 0, .module = node->module, .options = options}, *ctx = &ctx_;
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08002252
2253 yprc_node(ctx, node);
2254
2255 ly_print_flush(out);
2256 return LY_SUCCESS;
2257}
2258
2259LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002260yang_print_compiled(struct ly_out *out, const struct lys_module *module, uint32_t options)
Radek Krejcid3ca0632019-04-16 16:54:54 +02002261{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002262 LY_ARRAY_COUNT_TYPE u;
Radek Krejci693262f2019-04-29 15:23:20 +02002263 struct lysc_module *modc = module->compiled;
Radek Krejci52f65552020-09-01 17:03:35 +02002264 struct ypr_ctx ctx_ = {.out = out, .level = 0, .module = module, .options = options}, *ctx = &ctx_;
Radek Krejci693262f2019-04-29 15:23:20 +02002265
Michal Vasko5233e962020-08-14 14:26:20 +02002266 ly_print_(ctx->out, "%*smodule %s {\n", INDENT, module->name);
Radek Krejci693262f2019-04-29 15:23:20 +02002267 LEVEL++;
2268
Radek Krejci693262f2019-04-29 15:23:20 +02002269 /* module-header-stmts */
Radek Krejci693262f2019-04-29 15:23:20 +02002270 ypr_substmt(ctx, LYEXT_SUBSTMT_NAMESPACE, 0, module->ns, modc->exts);
2271 ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, module->prefix, modc->exts);
2272
Michal Vasko7c8439f2020-08-05 13:25:19 +02002273 /* no linkage-stmts */
Radek Krejci693262f2019-04-29 15:23:20 +02002274
2275 /* meta-stmts */
2276 if (module->org || module->contact || module->dsc || module->ref) {
Michal Vasko5233e962020-08-14 14:26:20 +02002277 ly_print_(out, "\n");
Radek Krejci693262f2019-04-29 15:23:20 +02002278 }
2279 ypr_substmt(ctx, LYEXT_SUBSTMT_ORGANIZATION, 0, module->org, modc->exts);
2280 ypr_substmt(ctx, LYEXT_SUBSTMT_CONTACT, 0, module->contact, modc->exts);
2281 ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, module->dsc, modc->exts);
2282 ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, module->ref, modc->exts);
2283
2284 /* revision-stmts */
2285 if (module->revision) {
Michal Vasko5233e962020-08-14 14:26:20 +02002286 ly_print_(ctx->out, "\n%*srevision %s;\n", INDENT, module->revision);
Radek Krejci693262f2019-04-29 15:23:20 +02002287 }
2288
2289 /* body-stmts */
2290 if (modc->exts) {
Michal Vasko5233e962020-08-14 14:26:20 +02002291 ly_print_(out, "\n");
Radek Krejci693262f2019-04-29 15:23:20 +02002292 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, module->compiled->exts, NULL, 0);
2293 }
2294
Radek Krejci80d281e2020-09-14 17:42:54 +02002295 LY_ARRAY_FOR(module->identities, u) {
2296 yprc_identity(ctx, &module->identities[u]);
Radek Krejci693262f2019-04-29 15:23:20 +02002297 }
2298
Radek Krejci52f65552020-09-01 17:03:35 +02002299 if (!(ctx->options & LYS_PRINT_NO_SUBSTMT)) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01002300 struct lysc_node *data;
2301 struct lysc_node_action *rpc;
2302 struct lysc_node_notif *notif;
2303
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08002304 LY_LIST_FOR(modc->data, data) {
2305 yprc_node(ctx, data);
2306 }
Radek Krejci693262f2019-04-29 15:23:20 +02002307
Radek Krejci2a9fc652021-01-22 17:44:34 +01002308 LY_LIST_FOR(modc->rpcs, rpc) {
2309 yprc_action(ctx, rpc);
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08002310 }
Radek Krejci693262f2019-04-29 15:23:20 +02002311
Radek Krejci2a9fc652021-01-22 17:44:34 +01002312 LY_LIST_FOR(modc->notifs, notif) {
2313 yprc_notification(ctx, notif);
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08002314 }
Radek Krejci693262f2019-04-29 15:23:20 +02002315 }
2316
2317 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02002318 ly_print_(out, "%*s}\n", INDENT);
Radek Krejci693262f2019-04-29 15:23:20 +02002319 ly_print_flush(out);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002320
2321 return LY_SUCCESS;
2322}