blob: 4afc83dd3e2dcff757fa2cfa4f7da43f16b47b76 [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);
994static void yprp_action(struct ypr_ctx *ctx, const struct lysp_action *action);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200995
996static void
Radek Krejci693262f2019-04-29 15:23:20 +0200997yprp_grouping(struct ypr_ctx *ctx, const struct lysp_grp *grp)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200998{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200999 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001000 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001001 struct lysp_node *data;
1002
Michal Vasko5233e962020-08-14 14:26:20 +02001003 ly_print_(ctx->out, "\n%*sgrouping %s", INDENT, grp->name);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001004 LEVEL++;
1005
Radek Krejci693262f2019-04-29 15:23:20 +02001006 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, grp->exts, &flag, 0);
1007 ypr_status(ctx, grp->flags, grp->exts, &flag);
Radek Krejcifc81ea82019-04-18 13:27:22 +02001008 ypr_description(ctx, grp->dsc, grp->exts, &flag);
1009 ypr_reference(ctx, grp->ref, grp->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001010
1011 LY_ARRAY_FOR(grp->typedefs, u) {
Radek Krejci59edcf72019-05-02 09:53:17 +02001012 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001013 yprp_typedef(ctx, &grp->typedefs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001014 }
1015
1016 LY_ARRAY_FOR(grp->groupings, u) {
Radek Krejci59edcf72019-05-02 09:53:17 +02001017 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001018 yprp_grouping(ctx, &grp->groupings[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001019 }
1020
1021 LY_LIST_FOR(grp->data, data) {
Radek Krejcifc81ea82019-04-18 13:27:22 +02001022 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001023 yprp_node(ctx, data);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001024 }
1025
1026 LY_ARRAY_FOR(grp->actions, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001027 yprp_action(ctx, &grp->actions[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001028 }
1029
1030 LEVEL--;
1031 ypr_close(ctx, flag);
1032}
1033
1034static void
Radek Krejci857189e2020-09-01 13:26:36 +02001035yprp_inout(struct ypr_ctx *ctx, const struct lysp_action_inout *inout, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001036{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001037 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001038 struct lysp_node *data;
1039
Michal Vasko7f45cf22020-10-01 12:49:44 +02001040 if (!inout->data) {
1041 /* no children */
Radek Krejcid3ca0632019-04-16 16:54:54 +02001042 return;
1043 }
1044 ypr_open(ctx->out, flag);
1045
Michal Vasko5233e962020-08-14 14:26:20 +02001046 ly_print_(ctx->out, "\n%*s%s {\n", INDENT, (inout->nodetype == LYS_INPUT ? "input" : "output"));
Radek Krejcid3ca0632019-04-16 16:54:54 +02001047 LEVEL++;
1048
Radek Krejci693262f2019-04-29 15:23:20 +02001049 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, inout->exts, NULL, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001050 LY_ARRAY_FOR(inout->musts, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001051 yprp_restr(ctx, &inout->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001052 }
1053 LY_ARRAY_FOR(inout->typedefs, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001054 yprp_typedef(ctx, &inout->typedefs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001055 }
1056 LY_ARRAY_FOR(inout->groupings, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001057 yprp_grouping(ctx, &inout->groupings[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001058 }
1059
1060 LY_LIST_FOR(inout->data, data) {
Radek Krejci693262f2019-04-29 15:23:20 +02001061 yprp_node(ctx, data);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001062 }
1063
1064 LEVEL--;
1065 ypr_close(ctx, 1);
1066}
1067
1068static void
Radek Krejci857189e2020-09-01 13:26:36 +02001069yprc_inout(struct ypr_ctx *ctx, const struct lysc_action *action, const struct lysc_action_inout *inout, ly_bool *flag)
Radek Krejci693262f2019-04-29 15:23:20 +02001070{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001071 LY_ARRAY_COUNT_TYPE u;
Radek Krejci693262f2019-04-29 15:23:20 +02001072 struct lysc_node *data;
1073
1074 if (!inout->data) {
1075 /* input/output is empty */
1076 return;
1077 }
1078 ypr_open(ctx->out, flag);
1079
Michal Vasko5233e962020-08-14 14:26:20 +02001080 ly_print_(ctx->out, "\n%*s%s {\n", INDENT, (&action->input == inout) ? "input" : "output");
Radek Krejci693262f2019-04-29 15:23:20 +02001081 LEVEL++;
1082
1083 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, (&action->input == inout) ? action->input_exts : action->output_exts, NULL, 0);
1084 LY_ARRAY_FOR(inout->musts, u) {
1085 yprc_must(ctx, &inout->musts[u], NULL);
1086 }
1087
Radek Krejci52f65552020-09-01 17:03:35 +02001088 if (!(ctx->options & LYS_PRINT_NO_SUBSTMT)) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001089 LY_LIST_FOR(inout->data, data) {
1090 yprc_node(ctx, data);
1091 }
Radek Krejci693262f2019-04-29 15:23:20 +02001092 }
1093
1094 LEVEL--;
1095 ypr_close(ctx, 1);
1096}
1097
1098static void
1099yprp_notification(struct ypr_ctx *ctx, const struct lysp_notif *notif)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001100{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001101 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001102 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001103 struct lysp_node *data;
1104
Michal Vasko5233e962020-08-14 14:26:20 +02001105 ly_print_(ctx->out, "%*snotification %s", INDENT, notif->name);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001106
1107 LEVEL++;
Radek Krejci693262f2019-04-29 15:23:20 +02001108 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, notif->exts, &flag, 0);
1109 yprp_iffeatures(ctx, notif->iffeatures, notif->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001110
1111 LY_ARRAY_FOR(notif->musts, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001112 yprp_restr(ctx, &notif->musts[u], "must", &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001113 }
Radek Krejci693262f2019-04-29 15:23:20 +02001114 ypr_status(ctx, notif->flags, notif->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001115 ypr_description(ctx, notif->dsc, notif->exts, &flag);
1116 ypr_reference(ctx, notif->ref, notif->exts, &flag);
1117
1118 LY_ARRAY_FOR(notif->typedefs, u) {
1119 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001120 yprp_typedef(ctx, &notif->typedefs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001121 }
1122
1123 LY_ARRAY_FOR(notif->groupings, u) {
1124 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001125 yprp_grouping(ctx, &notif->groupings[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001126 }
1127
1128 LY_LIST_FOR(notif->data, data) {
1129 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001130 yprp_node(ctx, data);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001131 }
1132
1133 LEVEL--;
1134 ypr_close(ctx, flag);
1135}
1136
1137static void
Radek Krejci693262f2019-04-29 15:23:20 +02001138yprc_notification(struct ypr_ctx *ctx, const struct lysc_notif *notif)
1139{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001140 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001141 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02001142 struct lysc_node *data;
1143
Michal Vasko5233e962020-08-14 14:26:20 +02001144 ly_print_(ctx->out, "%*snotification %s", INDENT, notif->name);
Radek Krejci693262f2019-04-29 15:23:20 +02001145
1146 LEVEL++;
1147 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, notif->exts, &flag, 0);
Radek Krejci693262f2019-04-29 15:23:20 +02001148
1149 LY_ARRAY_FOR(notif->musts, u) {
1150 yprc_must(ctx, &notif->musts[u], &flag);
1151 }
1152 ypr_status(ctx, notif->flags, notif->exts, &flag);
1153 ypr_description(ctx, notif->dsc, notif->exts, &flag);
1154 ypr_reference(ctx, notif->ref, notif->exts, &flag);
1155
Radek Krejci52f65552020-09-01 17:03:35 +02001156 if (!(ctx->options & LYS_PRINT_NO_SUBSTMT)) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001157 LY_LIST_FOR(notif->data, data) {
1158 ypr_open(ctx->out, &flag);
1159 yprc_node(ctx, data);
1160 }
Radek Krejci693262f2019-04-29 15:23:20 +02001161 }
1162
1163 LEVEL--;
1164 ypr_close(ctx, flag);
1165}
1166
1167static void
1168yprp_action(struct ypr_ctx *ctx, const struct lysp_action *action)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001169{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001170 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001171 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001172
Michal Vasko5233e962020-08-14 14:26:20 +02001173 ly_print_(ctx->out, "%*s%s %s", INDENT, action->parent ? "action" : "rpc", action->name);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001174
1175 LEVEL++;
Radek Krejci693262f2019-04-29 15:23:20 +02001176 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, action->exts, &flag, 0);
1177 yprp_iffeatures(ctx, action->iffeatures, action->exts, &flag);
1178 ypr_status(ctx, action->flags, action->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001179 ypr_description(ctx, action->dsc, action->exts, &flag);
1180 ypr_reference(ctx, action->ref, action->exts, &flag);
1181
1182 LY_ARRAY_FOR(action->typedefs, u) {
1183 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001184 yprp_typedef(ctx, &action->typedefs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001185 }
1186
1187 LY_ARRAY_FOR(action->groupings, u) {
1188 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001189 yprp_grouping(ctx, &action->groupings[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001190 }
1191
Radek Krejci693262f2019-04-29 15:23:20 +02001192 yprp_inout(ctx, &action->input, &flag);
1193 yprp_inout(ctx, &action->output, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001194
1195 LEVEL--;
1196 ypr_close(ctx, flag);
1197}
1198
1199static void
Radek Krejci693262f2019-04-29 15:23:20 +02001200yprc_action(struct ypr_ctx *ctx, const struct lysc_action *action)
1201{
Radek Krejci857189e2020-09-01 13:26:36 +02001202 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02001203
Michal Vasko5233e962020-08-14 14:26:20 +02001204 ly_print_(ctx->out, "%*s%s %s", INDENT, action->parent ? "action" : "rpc", action->name);
Radek Krejci693262f2019-04-29 15:23:20 +02001205
1206 LEVEL++;
1207 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, action->exts, &flag, 0);
Radek Krejci693262f2019-04-29 15:23:20 +02001208 ypr_status(ctx, action->flags, action->exts, &flag);
1209 ypr_description(ctx, action->dsc, action->exts, &flag);
1210 ypr_reference(ctx, action->ref, action->exts, &flag);
1211
1212 yprc_inout(ctx, action, &action->input, &flag);
1213 yprc_inout(ctx, action, &action->output, &flag);
1214
1215 LEVEL--;
1216 ypr_close(ctx, flag);
1217}
1218
1219static void
Radek Krejci857189e2020-09-01 13:26:36 +02001220yprp_node_common1(struct ypr_ctx *ctx, const struct lysp_node *node, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001221{
Michal Vasko5233e962020-08-14 14:26:20 +02001222 ly_print_(ctx->out, "%*s%s %s%s", INDENT, lys_nodetype2str(node->nodetype), node->name, flag ? "" : " {\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +02001223 LEVEL++;
1224
Radek Krejci693262f2019-04-29 15:23:20 +02001225 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, node->exts, flag, 0);
1226 yprp_when(ctx, node->when, flag);
1227 yprp_iffeatures(ctx, node->iffeatures, node->exts, flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001228}
1229
1230static void
Radek Krejci857189e2020-09-01 13:26:36 +02001231yprc_node_common1(struct ypr_ctx *ctx, const struct lysc_node *node, ly_bool *flag)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001232{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001233 LY_ARRAY_COUNT_TYPE u;
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 Krejci693262f2019-04-29 15:23:20 +02001236 LEVEL++;
1237
1238 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, node->exts, flag, 0);
1239 LY_ARRAY_FOR(node->when, u) {
1240 yprc_when(ctx, node->when[u], flag);
1241 }
Radek Krejci693262f2019-04-29 15:23:20 +02001242}
1243
1244/* macr oto unify the code */
1245#define YPR_NODE_COMMON2 \
1246 ypr_config(ctx, node->flags, node->exts, flag); \
1247 if (node->nodetype & (LYS_CHOICE | LYS_LEAF | LYS_ANYDATA)) { \
1248 ypr_mandatory(ctx, node->flags, node->exts, flag); \
1249 } \
1250 ypr_status(ctx, node->flags, node->exts, flag); \
1251 ypr_description(ctx, node->dsc, node->exts, flag); \
1252 ypr_reference(ctx, node->ref, node->exts, flag)
1253
1254static void
Radek Krejci857189e2020-09-01 13:26:36 +02001255yprp_node_common2(struct ypr_ctx *ctx, const struct lysp_node *node, ly_bool *flag)
Radek Krejci693262f2019-04-29 15:23:20 +02001256{
1257 YPR_NODE_COMMON2;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001258}
1259
1260static void
Radek Krejci857189e2020-09-01 13:26:36 +02001261yprc_node_common2(struct ypr_ctx *ctx, const struct lysc_node *node, ly_bool *flag)
Radek Krejci693262f2019-04-29 15:23:20 +02001262{
1263 YPR_NODE_COMMON2;
1264}
1265
1266#undef YPR_NODE_COMMON2
1267
1268static void
1269yprp_container(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001270{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001271 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001272 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001273 struct lysp_node *child;
1274 struct lysp_node_container *cont = (struct lysp_node_container *)node;
1275
Radek Krejci693262f2019-04-29 15:23:20 +02001276 yprp_node_common1(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001277
1278 LY_ARRAY_FOR(cont->musts, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001279 yprp_restr(ctx, &cont->musts[u], "must", &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001280 }
1281 if (cont->presence) {
1282 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001283 ypr_substmt(ctx, LYEXT_SUBSTMT_PRESENCE, 0, cont->presence, cont->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001284 }
1285
Radek Krejci693262f2019-04-29 15:23:20 +02001286 yprp_node_common2(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001287
1288 LY_ARRAY_FOR(cont->typedefs, u) {
1289 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001290 yprp_typedef(ctx, &cont->typedefs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001291 }
1292
1293 LY_ARRAY_FOR(cont->groupings, u) {
1294 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001295 yprp_grouping(ctx, &cont->groupings[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001296 }
1297
1298 LY_LIST_FOR(cont->child, child) {
1299 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001300 yprp_node(ctx, child);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001301 }
1302
1303 LY_ARRAY_FOR(cont->actions, u) {
1304 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001305 yprp_action(ctx, &cont->actions[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001306 }
1307
1308 LY_ARRAY_FOR(cont->notifs, u) {
1309 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001310 yprp_notification(ctx, &cont->notifs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001311 }
1312
1313 LEVEL--;
1314 ypr_close(ctx, flag);
1315}
1316
1317static void
Radek Krejci693262f2019-04-29 15:23:20 +02001318yprc_container(struct ypr_ctx *ctx, const struct lysc_node *node)
1319{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001320 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001321 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02001322 struct lysc_node *child;
1323 struct lysc_node_container *cont = (struct lysc_node_container *)node;
1324
1325 yprc_node_common1(ctx, node, &flag);
1326
1327 LY_ARRAY_FOR(cont->musts, u) {
1328 yprc_must(ctx, &cont->musts[u], &flag);
1329 }
1330 if (cont->flags & LYS_PRESENCE) {
1331 ypr_open(ctx->out, &flag);
1332 ypr_substmt(ctx, LYEXT_SUBSTMT_PRESENCE, 0, "true", cont->exts);
1333 }
1334
1335 yprc_node_common2(ctx, node, &flag);
1336
Radek Krejci52f65552020-09-01 17:03:35 +02001337 if (!(ctx->options & LYS_PRINT_NO_SUBSTMT)) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001338 LY_LIST_FOR(cont->child, child) {
1339 ypr_open(ctx->out, &flag);
1340 yprc_node(ctx, child);
1341 }
Radek Krejci693262f2019-04-29 15:23:20 +02001342
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001343 LY_ARRAY_FOR(cont->actions, u) {
1344 ypr_open(ctx->out, &flag);
1345 yprc_action(ctx, &cont->actions[u]);
1346 }
Radek Krejci693262f2019-04-29 15:23:20 +02001347
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001348 LY_ARRAY_FOR(cont->notifs, u) {
1349 ypr_open(ctx->out, &flag);
1350 yprc_notification(ctx, &cont->notifs[u]);
1351 }
Radek Krejci693262f2019-04-29 15:23:20 +02001352 }
1353
1354 LEVEL--;
1355 ypr_close(ctx, flag);
1356}
1357
1358static void
1359yprp_case(struct ypr_ctx *ctx, const struct lysp_node *node)
1360{
Radek Krejci857189e2020-09-01 13:26:36 +02001361 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02001362 struct lysp_node *child;
1363 struct lysp_node_case *cas = (struct lysp_node_case *)node;
1364
1365 yprp_node_common1(ctx, node, &flag);
1366 yprp_node_common2(ctx, node, &flag);
1367
1368 LY_LIST_FOR(cas->child, child) {
1369 ypr_open(ctx->out, &flag);
1370 yprp_node(ctx, child);
1371 }
1372
1373 LEVEL--;
1374 ypr_close(ctx, flag);
1375}
1376
1377static void
1378yprc_case(struct ypr_ctx *ctx, const struct lysc_node_case *cs)
1379{
Radek Krejci857189e2020-09-01 13:26:36 +02001380 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02001381 struct lysc_node *child;
1382
Michal Vasko22df3f02020-08-24 13:29:22 +02001383 yprc_node_common1(ctx, (struct lysc_node *)cs, &flag);
1384 yprc_node_common2(ctx, (struct lysc_node *)cs, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001385
Radek Krejci52f65552020-09-01 17:03:35 +02001386 if (!(ctx->options & LYS_PRINT_NO_SUBSTMT)) {
Michal Vasko22df3f02020-08-24 13:29:22 +02001387 for (child = cs->child; child && child->parent == (struct lysc_node *)cs; child = child->next) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001388 ypr_open(ctx->out, &flag);
1389 yprc_node(ctx, child);
1390 }
Radek Krejci693262f2019-04-29 15:23:20 +02001391 }
1392
1393 LEVEL--;
1394 ypr_close(ctx, flag);
1395}
1396
1397static void
1398yprp_choice(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001399{
Radek Krejci857189e2020-09-01 13:26:36 +02001400 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001401 struct lysp_node *child;
1402 struct lysp_node_choice *choice = (struct lysp_node_choice *)node;
1403
Radek Krejci693262f2019-04-29 15:23:20 +02001404 yprp_node_common1(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001405
Michal Vasko7f45cf22020-10-01 12:49:44 +02001406 if (choice->dflt.str) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001407 ypr_open(ctx->out, &flag);
Michal Vasko7f45cf22020-10-01 12:49:44 +02001408 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, choice->dflt.str, choice->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001409 }
1410
Radek Krejci693262f2019-04-29 15:23:20 +02001411 yprp_node_common2(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001412
1413 LY_LIST_FOR(choice->child, child) {
1414 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001415 yprp_node(ctx, child);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001416 }
1417
1418 LEVEL--;
1419 ypr_close(ctx, flag);
1420}
1421
1422static void
Radek Krejci693262f2019-04-29 15:23:20 +02001423yprc_choice(struct ypr_ctx *ctx, const struct lysc_node *node)
1424{
Radek Krejci857189e2020-09-01 13:26:36 +02001425 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02001426 struct lysc_node_case *cs;
1427 struct lysc_node_choice *choice = (struct lysc_node_choice *)node;
1428
1429 yprc_node_common1(ctx, node, &flag);
1430
1431 if (choice->dflt) {
1432 ypr_open(ctx->out, &flag);
1433 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, choice->dflt->name, choice->exts);
1434 }
1435
1436 yprc_node_common2(ctx, node, &flag);
1437
Michal Vasko22df3f02020-08-24 13:29:22 +02001438 for (cs = choice->cases; cs; cs = (struct lysc_node_case *)cs->next) {
Radek Krejci693262f2019-04-29 15:23:20 +02001439 ypr_open(ctx->out, &flag);
1440 yprc_case(ctx, cs);
1441 }
1442
1443 LEVEL--;
1444 ypr_close(ctx, flag);
1445}
1446
1447static void
1448yprp_leaf(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001449{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001450 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001451 struct lysp_node_leaf *leaf = (struct lysp_node_leaf *)node;
1452
Radek Krejci693262f2019-04-29 15:23:20 +02001453 yprp_node_common1(ctx, node, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001454
Radek Krejci693262f2019-04-29 15:23:20 +02001455 yprp_type(ctx, &leaf->type);
1456 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, leaf->units, leaf->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001457 LY_ARRAY_FOR(leaf->musts, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001458 yprp_restr(ctx, &leaf->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001459 }
Michal Vasko7f45cf22020-10-01 12:49:44 +02001460 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, leaf->dflt.str, leaf->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001461
Radek Krejci693262f2019-04-29 15:23:20 +02001462 yprp_node_common2(ctx, node, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001463
1464 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02001465 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001466}
1467
1468static void
Radek Krejci693262f2019-04-29 15:23:20 +02001469yprc_leaf(struct ypr_ctx *ctx, const struct lysc_node *node)
1470{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001471 LY_ARRAY_COUNT_TYPE u;
Radek Krejci693262f2019-04-29 15:23:20 +02001472 struct lysc_node_leaf *leaf = (struct lysc_node_leaf *)node;
1473
1474 yprc_node_common1(ctx, node, NULL);
1475
1476 yprc_type(ctx, leaf->type);
1477 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, leaf->units, leaf->exts);
1478 LY_ARRAY_FOR(leaf->musts, u) {
1479 yprc_must(ctx, &leaf->musts[u], NULL);
1480 }
Radek Krejcia1911222019-07-22 17:24:50 +02001481
1482 if (leaf->dflt) {
Michal Vaskoba99a3e2020-08-18 15:50:05 +02001483 yprc_dflt_value(ctx, leaf->dflt, leaf->exts);
Radek Krejcia1911222019-07-22 17:24:50 +02001484 }
Radek Krejci693262f2019-04-29 15:23:20 +02001485
1486 yprc_node_common2(ctx, node, NULL);
1487
1488 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02001489 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejci693262f2019-04-29 15:23:20 +02001490}
1491
1492static void
1493yprp_leaflist(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001494{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001495 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001496 struct lysp_node_leaflist *llist = (struct lysp_node_leaflist *)node;
1497
Radek Krejci693262f2019-04-29 15:23:20 +02001498 yprp_node_common1(ctx, node, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001499
Radek Krejci693262f2019-04-29 15:23:20 +02001500 yprp_type(ctx, &llist->type);
1501 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, llist->units, llist->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001502 LY_ARRAY_FOR(llist->musts, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001503 yprp_restr(ctx, &llist->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001504 }
1505 LY_ARRAY_FOR(llist->dflts, u) {
Michal Vasko7f45cf22020-10-01 12:49:44 +02001506 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, llist->dflts[u].str, llist->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001507 }
1508
Radek Krejci693262f2019-04-29 15:23:20 +02001509 ypr_config(ctx, node->flags, node->exts, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001510
1511 if (llist->flags & LYS_SET_MIN) {
Radek Krejci693262f2019-04-29 15:23:20 +02001512 ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN, 0, llist->exts, llist->min, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001513 }
1514 if (llist->flags & LYS_SET_MAX) {
1515 if (llist->max) {
Radek Krejci693262f2019-04-29 15:23:20 +02001516 ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX, 0, llist->exts, llist->max, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001517 } else {
Radek Krejci693262f2019-04-29 15:23:20 +02001518 ypr_substmt(ctx, LYEXT_SUBSTMT_MAX, 0, "unbounded", llist->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001519 }
1520 }
1521
1522 if (llist->flags & LYS_ORDBY_MASK) {
Radek Krejci693262f2019-04-29 15:23:20 +02001523 ypr_substmt(ctx, LYEXT_SUBSTMT_ORDEREDBY, 0, (llist->flags & LYS_ORDBY_USER) ? "user" : "system", llist->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001524 }
1525
Radek Krejci693262f2019-04-29 15:23:20 +02001526 ypr_status(ctx, node->flags, node->exts, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001527 ypr_description(ctx, node->dsc, node->exts, NULL);
1528 ypr_reference(ctx, node->ref, node->exts, NULL);
1529
1530 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02001531 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001532}
1533
1534static void
Radek Krejci693262f2019-04-29 15:23:20 +02001535yprc_leaflist(struct ypr_ctx *ctx, const struct lysc_node *node)
1536{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001537 LY_ARRAY_COUNT_TYPE u;
Radek Krejci693262f2019-04-29 15:23:20 +02001538 struct lysc_node_leaflist *llist = (struct lysc_node_leaflist *)node;
1539
1540 yprc_node_common1(ctx, node, NULL);
1541
1542 yprc_type(ctx, llist->type);
1543 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, llist->units, llist->exts);
1544 LY_ARRAY_FOR(llist->musts, u) {
1545 yprc_must(ctx, &llist->musts[u], NULL);
1546 }
1547 LY_ARRAY_FOR(llist->dflts, u) {
Michal Vaskoba99a3e2020-08-18 15:50:05 +02001548 yprc_dflt_value(ctx, llist->dflts[u], llist->exts);
Radek Krejci693262f2019-04-29 15:23:20 +02001549 }
1550
1551 ypr_config(ctx, node->flags, node->exts, NULL);
1552
1553 ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN, 0, llist->exts, llist->min, NULL);
1554 if (llist->max) {
1555 ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX, 0, llist->exts, llist->max, NULL);
1556 } else {
1557 ypr_substmt(ctx, LYEXT_SUBSTMT_MAX, 0, "unbounded", llist->exts);
1558 }
1559
1560 ypr_substmt(ctx, LYEXT_SUBSTMT_ORDEREDBY, 0, (llist->flags & LYS_ORDBY_USER) ? "user" : "system", llist->exts);
1561
1562 ypr_status(ctx, node->flags, node->exts, NULL);
1563 ypr_description(ctx, node->dsc, node->exts, NULL);
1564 ypr_reference(ctx, node->ref, node->exts, NULL);
1565
1566 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02001567 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejci693262f2019-04-29 15:23:20 +02001568}
1569
1570static void
1571yprp_list(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001572{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001573 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001574 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001575 struct lysp_node *child;
1576 struct lysp_node_list *list = (struct lysp_node_list *)node;
1577
Radek Krejci693262f2019-04-29 15:23:20 +02001578 yprp_node_common1(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001579
1580 LY_ARRAY_FOR(list->musts, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001581 yprp_restr(ctx, &list->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001582 }
1583 if (list->key) {
1584 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001585 ypr_substmt(ctx, LYEXT_SUBSTMT_KEY, 0, list->key, list->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001586 }
1587 LY_ARRAY_FOR(list->uniques, u) {
1588 ypr_open(ctx->out, &flag);
Michal Vasko7f45cf22020-10-01 12:49:44 +02001589 ypr_substmt(ctx, LYEXT_SUBSTMT_UNIQUE, u, list->uniques[u].str, list->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001590 }
1591
Michal Vaskoacb8e742020-10-20 10:28:02 +02001592 ypr_config(ctx, node->flags, node->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001593
1594 if (list->flags & LYS_SET_MIN) {
Michal Vaskoacb8e742020-10-20 10:28:02 +02001595 ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN, 0, list->exts, list->min, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001596 }
1597 if (list->flags & LYS_SET_MAX) {
1598 if (list->max) {
Michal Vaskoacb8e742020-10-20 10:28:02 +02001599 ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX, 0, list->exts, list->max, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001600 } else {
Michal Vaskoacb8e742020-10-20 10:28:02 +02001601 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001602 ypr_substmt(ctx, LYEXT_SUBSTMT_MAX, 0, "unbounded", list->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001603 }
1604 }
1605
1606 if (list->flags & LYS_ORDBY_MASK) {
Michal Vaskoacb8e742020-10-20 10:28:02 +02001607 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001608 ypr_substmt(ctx, LYEXT_SUBSTMT_ORDEREDBY, 0, (list->flags & LYS_ORDBY_USER) ? "user" : "system", list->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001609 }
1610
Michal Vaskoacb8e742020-10-20 10:28:02 +02001611 ypr_status(ctx, node->flags, node->exts, &flag);
1612 ypr_description(ctx, node->dsc, node->exts, &flag);
1613 ypr_reference(ctx, node->ref, node->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001614
1615 LY_ARRAY_FOR(list->typedefs, u) {
1616 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001617 yprp_typedef(ctx, &list->typedefs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001618 }
1619
1620 LY_ARRAY_FOR(list->groupings, u) {
1621 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001622 yprp_grouping(ctx, &list->groupings[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001623 }
1624
1625 LY_LIST_FOR(list->child, child) {
1626 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001627 yprp_node(ctx, child);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001628 }
1629
1630 LY_ARRAY_FOR(list->actions, u) {
1631 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001632 yprp_action(ctx, &list->actions[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001633 }
1634
1635 LY_ARRAY_FOR(list->notifs, u) {
1636 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001637 yprp_notification(ctx, &list->notifs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001638 }
1639
1640 LEVEL--;
1641 ypr_close(ctx, flag);
1642}
1643
1644static void
Radek Krejci693262f2019-04-29 15:23:20 +02001645yprc_list(struct ypr_ctx *ctx, const struct lysc_node *node)
1646{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001647 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejci693262f2019-04-29 15:23:20 +02001648 struct lysc_node *child;
1649 struct lysc_node_list *list = (struct lysc_node_list *)node;
1650
Michal Vaskoacb8e742020-10-20 10:28:02 +02001651 yprc_node_common1(ctx, node, NULL);
Radek Krejci693262f2019-04-29 15:23:20 +02001652
1653 LY_ARRAY_FOR(list->musts, u) {
1654 yprc_must(ctx, &list->musts[u], NULL);
1655 }
Radek Krejci0fe9b512019-07-26 17:51:05 +02001656 if (!(list->flags & LYS_KEYLESS)) {
Michal Vasko5233e962020-08-14 14:26:20 +02001657 ly_print_(ctx->out, "%*skey \"", INDENT);
Radek Krejci0fe9b512019-07-26 17:51:05 +02001658 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 +02001659 ly_print_(ctx->out, "%s%s", u > 0 ? ", " : "", key->name);
Radek Krejci693262f2019-04-29 15:23:20 +02001660 }
Michal Vasko5233e962020-08-14 14:26:20 +02001661 ly_print_(ctx->out, "\";\n");
Radek Krejci693262f2019-04-29 15:23:20 +02001662 }
1663 LY_ARRAY_FOR(list->uniques, u) {
Michal Vasko5233e962020-08-14 14:26:20 +02001664 ly_print_(ctx->out, "%*sunique \"", INDENT);
Radek Krejci693262f2019-04-29 15:23:20 +02001665 LY_ARRAY_FOR(list->uniques[u], v) {
Michal Vasko5233e962020-08-14 14:26:20 +02001666 ly_print_(ctx->out, "%s%s", v > 0 ? ", " : "", list->uniques[u][v]->name);
Radek Krejci693262f2019-04-29 15:23:20 +02001667 }
1668 ypr_close(ctx, 0);
1669 }
1670
1671 ypr_config(ctx, node->flags, node->exts, NULL);
1672
1673 ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN, 0, list->exts, list->min, NULL);
1674 if (list->max) {
1675 ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX, 0, list->exts, list->max, NULL);
1676 } else {
1677 ypr_substmt(ctx, LYEXT_SUBSTMT_MAX, 0, "unbounded", list->exts);
1678 }
1679
1680 ypr_substmt(ctx, LYEXT_SUBSTMT_ORDEREDBY, 0, (list->flags & LYS_ORDBY_USER) ? "user" : "system", list->exts);
1681
1682 ypr_status(ctx, node->flags, node->exts, NULL);
1683 ypr_description(ctx, node->dsc, node->exts, NULL);
1684 ypr_reference(ctx, node->ref, node->exts, NULL);
1685
Radek Krejci52f65552020-09-01 17:03:35 +02001686 if (!(ctx->options & LYS_PRINT_NO_SUBSTMT)) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001687 LY_LIST_FOR(list->child, child) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001688 yprc_node(ctx, child);
1689 }
Radek Krejci693262f2019-04-29 15:23:20 +02001690
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001691 LY_ARRAY_FOR(list->actions, u) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001692 yprc_action(ctx, &list->actions[u]);
1693 }
Radek Krejci693262f2019-04-29 15:23:20 +02001694
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001695 LY_ARRAY_FOR(list->notifs, u) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08001696 yprc_notification(ctx, &list->notifs[u]);
1697 }
Radek Krejci693262f2019-04-29 15:23:20 +02001698 }
1699
1700 LEVEL--;
Michal Vaskoacb8e742020-10-20 10:28:02 +02001701 ypr_close(ctx, 1);
Radek Krejci693262f2019-04-29 15:23:20 +02001702}
1703
1704static void
1705yprp_refine(struct ypr_ctx *ctx, struct lysp_refine *refine)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001706{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001707 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001708 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001709
Michal Vasko5233e962020-08-14 14:26:20 +02001710 ly_print_(ctx->out, "%*srefine \"%s\"", INDENT, refine->nodeid);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001711 LEVEL++;
1712
Radek Krejci693262f2019-04-29 15:23:20 +02001713 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, refine->exts, &flag, 0);
1714 yprp_iffeatures(ctx, refine->iffeatures, refine->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001715
1716 LY_ARRAY_FOR(refine->musts, u) {
1717 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001718 yprp_restr(ctx, &refine->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001719 }
1720
1721 if (refine->presence) {
1722 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001723 ypr_substmt(ctx, LYEXT_SUBSTMT_PRESENCE, 0, refine->presence, refine->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001724 }
1725
1726 LY_ARRAY_FOR(refine->dflts, u) {
1727 ypr_open(ctx->out, &flag);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001728 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, refine->dflts[u].str, refine->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001729 }
1730
Radek Krejci693262f2019-04-29 15:23:20 +02001731 ypr_config(ctx, refine->flags, refine->exts, &flag);
1732 ypr_mandatory(ctx, refine->flags, refine->exts, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001733
1734 if (refine->flags & LYS_SET_MIN) {
1735 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001736 ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN, 0, refine->exts, refine->min, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001737 }
1738 if (refine->flags & LYS_SET_MAX) {
1739 ypr_open(ctx->out, &flag);
1740 if (refine->max) {
Radek Krejci693262f2019-04-29 15:23:20 +02001741 ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX, 0, refine->exts, refine->max, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001742 } else {
Radek Krejci693262f2019-04-29 15:23:20 +02001743 ypr_substmt(ctx, LYEXT_SUBSTMT_MAX, 0, "unbounded", refine->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001744 }
1745 }
1746
1747 ypr_description(ctx, refine->dsc, refine->exts, &flag);
1748 ypr_reference(ctx, refine->ref, refine->exts, &flag);
1749
1750 LEVEL--;
1751 ypr_close(ctx, flag);
1752}
1753
1754static void
Radek Krejci693262f2019-04-29 15:23:20 +02001755yprp_augment(struct ypr_ctx *ctx, const struct lysp_augment *aug)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001756{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001757 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001758 struct lysp_node *child;
1759
Michal Vasko5233e962020-08-14 14:26:20 +02001760 ly_print_(ctx->out, "%*saugment \"%s\" {\n", INDENT, aug->nodeid);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001761 LEVEL++;
1762
Radek Krejci693262f2019-04-29 15:23:20 +02001763 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, aug->exts, NULL, 0);
1764 yprp_when(ctx, aug->when, NULL);
1765 yprp_iffeatures(ctx, aug->iffeatures, aug->exts, NULL);
1766 ypr_status(ctx, aug->flags, aug->exts, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001767 ypr_description(ctx, aug->dsc, aug->exts, NULL);
1768 ypr_reference(ctx, aug->ref, aug->exts, NULL);
1769
1770 LY_LIST_FOR(aug->child, child) {
Radek Krejci693262f2019-04-29 15:23:20 +02001771 yprp_node(ctx, child);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001772 }
1773
1774 LY_ARRAY_FOR(aug->actions, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001775 yprp_action(ctx, &aug->actions[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001776 }
1777
1778 LY_ARRAY_FOR(aug->notifs, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02001779 yprp_notification(ctx, &aug->notifs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001780 }
1781
1782 LEVEL--;
Radek Krejcifc81ea82019-04-18 13:27:22 +02001783 ypr_close(ctx, 1);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001784}
1785
Radek Krejcid3ca0632019-04-16 16:54:54 +02001786static void
Radek Krejci693262f2019-04-29 15:23:20 +02001787yprp_uses(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001788{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001789 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001790 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001791 struct lysp_node_uses *uses = (struct lysp_node_uses *)node;
1792
Radek Krejci693262f2019-04-29 15:23:20 +02001793 yprp_node_common1(ctx, node, &flag);
1794 yprp_node_common2(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001795
1796 LY_ARRAY_FOR(uses->refines, u) {
1797 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001798 yprp_refine(ctx, &uses->refines[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001799 }
1800
1801 LY_ARRAY_FOR(uses->augments, u) {
1802 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001803 yprp_augment(ctx, &uses->augments[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001804 }
1805
1806 LEVEL--;
1807 ypr_close(ctx, flag);
1808}
1809
1810static void
Radek Krejci693262f2019-04-29 15:23:20 +02001811yprp_anydata(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001812{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001813 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001814 ly_bool flag = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001815 struct lysp_node_anydata *any = (struct lysp_node_anydata *)node;
1816
Radek Krejci693262f2019-04-29 15:23:20 +02001817 yprp_node_common1(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001818
1819 LY_ARRAY_FOR(any->musts, u) {
1820 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001821 yprp_restr(ctx, &any->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001822 }
1823
Radek Krejci693262f2019-04-29 15:23:20 +02001824 yprp_node_common2(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001825
1826 LEVEL--;
1827 ypr_close(ctx, flag);
1828}
1829
1830static void
Radek Krejci693262f2019-04-29 15:23:20 +02001831yprc_anydata(struct ypr_ctx *ctx, const struct lysc_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001832{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001833 LY_ARRAY_COUNT_TYPE u;
Radek Krejci857189e2020-09-01 13:26:36 +02001834 ly_bool flag = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02001835 struct lysc_node_anydata *any = (struct lysc_node_anydata *)node;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001836
Radek Krejci693262f2019-04-29 15:23:20 +02001837 yprc_node_common1(ctx, node, &flag);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001838
Radek Krejci693262f2019-04-29 15:23:20 +02001839 LY_ARRAY_FOR(any->musts, u) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001840 ypr_open(ctx->out, &flag);
Radek Krejci693262f2019-04-29 15:23:20 +02001841 yprc_must(ctx, &any->musts[u], NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001842 }
1843
Radek Krejci693262f2019-04-29 15:23:20 +02001844 yprc_node_common2(ctx, node, &flag);
1845
Radek Krejcid3ca0632019-04-16 16:54:54 +02001846 LEVEL--;
1847 ypr_close(ctx, flag);
1848}
1849
1850static void
Radek Krejci693262f2019-04-29 15:23:20 +02001851yprp_node(struct ypr_ctx *ctx, const struct lysp_node *node)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001852{
1853 switch (node->nodetype) {
1854 case LYS_CONTAINER:
Radek Krejci693262f2019-04-29 15:23:20 +02001855 yprp_container(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001856 break;
1857 case LYS_CHOICE:
Radek Krejci693262f2019-04-29 15:23:20 +02001858 yprp_choice(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001859 break;
1860 case LYS_LEAF:
Radek Krejci693262f2019-04-29 15:23:20 +02001861 yprp_leaf(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001862 break;
1863 case LYS_LEAFLIST:
Radek Krejci693262f2019-04-29 15:23:20 +02001864 yprp_leaflist(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001865 break;
1866 case LYS_LIST:
Radek Krejci693262f2019-04-29 15:23:20 +02001867 yprp_list(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001868 break;
1869 case LYS_USES:
Radek Krejci693262f2019-04-29 15:23:20 +02001870 yprp_uses(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001871 break;
1872 case LYS_ANYXML:
1873 case LYS_ANYDATA:
Radek Krejci693262f2019-04-29 15:23:20 +02001874 yprp_anydata(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001875 break;
1876 case LYS_CASE:
Radek Krejci693262f2019-04-29 15:23:20 +02001877 yprp_case(ctx, node);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001878 break;
1879 default:
1880 break;
1881 }
1882}
1883
1884static void
Radek Krejci693262f2019-04-29 15:23:20 +02001885yprc_node(struct ypr_ctx *ctx, const struct lysc_node *node)
1886{
1887 switch (node->nodetype) {
1888 case LYS_CONTAINER:
1889 yprc_container(ctx, node);
1890 break;
1891 case LYS_CHOICE:
1892 yprc_choice(ctx, node);
1893 break;
1894 case LYS_LEAF:
1895 yprc_leaf(ctx, node);
1896 break;
1897 case LYS_LEAFLIST:
1898 yprc_leaflist(ctx, node);
1899 break;
1900 case LYS_LIST:
1901 yprc_list(ctx, node);
1902 break;
1903 case LYS_ANYXML:
1904 case LYS_ANYDATA:
1905 yprc_anydata(ctx, node);
1906 break;
1907 default:
1908 break;
1909 }
1910}
1911
1912static void
1913yprp_deviation(struct ypr_ctx *ctx, const struct lysp_deviation *deviation)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001914{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001915 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001916 struct lysp_deviate_add *add;
1917 struct lysp_deviate_rpl *rpl;
1918 struct lysp_deviate_del *del;
fredgan2b11ddb2019-10-21 11:03:39 +08001919 struct lysp_deviate *elem;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001920
Michal Vasko5233e962020-08-14 14:26:20 +02001921 ly_print_(ctx->out, "%*sdeviation \"%s\" {\n", INDENT, deviation->nodeid);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001922 LEVEL++;
1923
Radek Krejci693262f2019-04-29 15:23:20 +02001924 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, deviation->exts, NULL, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001925 ypr_description(ctx, deviation->dsc, deviation->exts, NULL);
1926 ypr_reference(ctx, deviation->ref, deviation->exts, NULL);
1927
fredgan2b11ddb2019-10-21 11:03:39 +08001928 LY_LIST_FOR(deviation->deviates, elem) {
Michal Vasko5233e962020-08-14 14:26:20 +02001929 ly_print_(ctx->out, "%*sdeviate ", INDENT);
fredgan2b11ddb2019-10-21 11:03:39 +08001930 if (elem->mod == LYS_DEV_NOT_SUPPORTED) {
1931 if (elem->exts) {
Michal Vasko5233e962020-08-14 14:26:20 +02001932 ly_print_(ctx->out, "not-supported {\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +02001933 LEVEL++;
1934
fredgan2b11ddb2019-10-21 11:03:39 +08001935 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, elem->exts, NULL, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001936 } else {
Michal Vasko5233e962020-08-14 14:26:20 +02001937 ly_print_(ctx->out, "not-supported;\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +02001938 continue;
1939 }
fredgan2b11ddb2019-10-21 11:03:39 +08001940 } else if (elem->mod == LYS_DEV_ADD) {
Michal Vasko22df3f02020-08-24 13:29:22 +02001941 add = (struct lysp_deviate_add *)elem;
Michal Vasko5233e962020-08-14 14:26:20 +02001942 ly_print_(ctx->out, "add {\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +02001943 LEVEL++;
1944
Radek Krejci693262f2019-04-29 15:23:20 +02001945 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, add->exts, NULL, 0);
1946 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, add->units, add->exts);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001947 LY_ARRAY_FOR(add->musts, u) {
1948 yprp_restr(ctx, &add->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001949 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001950 LY_ARRAY_FOR(add->uniques, u) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001951 ypr_substmt(ctx, LYEXT_SUBSTMT_UNIQUE, u, add->uniques[u].str, add->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001952 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001953 LY_ARRAY_FOR(add->dflts, u) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001954 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, add->dflts[u].str, add->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001955 }
Radek Krejci693262f2019-04-29 15:23:20 +02001956 ypr_config(ctx, add->flags, add->exts, NULL);
1957 ypr_mandatory(ctx, add->flags, add->exts, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001958 if (add->flags & LYS_SET_MIN) {
Radek Krejci693262f2019-04-29 15:23:20 +02001959 ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN, 0, add->exts, add->min, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001960 }
1961 if (add->flags & LYS_SET_MAX) {
1962 if (add->max) {
Radek Krejci693262f2019-04-29 15:23:20 +02001963 ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX, 0, add->exts, add->max, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001964 } else {
Radek Krejci693262f2019-04-29 15:23:20 +02001965 ypr_substmt(ctx, LYEXT_SUBSTMT_MAX, 0, "unbounded", add->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001966 }
1967 }
fredgan2b11ddb2019-10-21 11:03:39 +08001968 } else if (elem->mod == LYS_DEV_REPLACE) {
Michal Vasko22df3f02020-08-24 13:29:22 +02001969 rpl = (struct lysp_deviate_rpl *)elem;
Michal Vasko5233e962020-08-14 14:26:20 +02001970 ly_print_(ctx->out, "replace {\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +02001971 LEVEL++;
1972
Radek Krejci693262f2019-04-29 15:23:20 +02001973 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, rpl->exts, NULL, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001974 if (rpl->type) {
Radek Krejci693262f2019-04-29 15:23:20 +02001975 yprp_type(ctx, rpl->type);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001976 }
Radek Krejci693262f2019-04-29 15:23:20 +02001977 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, rpl->units, rpl->exts);
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001978 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, rpl->dflt.str, rpl->exts);
Radek Krejci693262f2019-04-29 15:23:20 +02001979 ypr_config(ctx, rpl->flags, rpl->exts, NULL);
1980 ypr_mandatory(ctx, rpl->flags, rpl->exts, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001981 if (rpl->flags & LYS_SET_MIN) {
Radek Krejci693262f2019-04-29 15:23:20 +02001982 ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN, 0, rpl->exts, rpl->min, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001983 }
1984 if (rpl->flags & LYS_SET_MAX) {
1985 if (rpl->max) {
Radek Krejci693262f2019-04-29 15:23:20 +02001986 ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX, 0, rpl->exts, rpl->max, NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001987 } else {
Radek Krejci693262f2019-04-29 15:23:20 +02001988 ypr_substmt(ctx, LYEXT_SUBSTMT_MAX, 0, "unbounded", rpl->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001989 }
1990 }
fredgan2b11ddb2019-10-21 11:03:39 +08001991 } else if (elem->mod == LYS_DEV_DELETE) {
Michal Vasko22df3f02020-08-24 13:29:22 +02001992 del = (struct lysp_deviate_del *)elem;
Michal Vasko5233e962020-08-14 14:26:20 +02001993 ly_print_(ctx->out, "delete {\n");
Radek Krejcid3ca0632019-04-16 16:54:54 +02001994 LEVEL++;
1995
Radek Krejci693262f2019-04-29 15:23:20 +02001996 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, del->exts, NULL, 0);
1997 ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, del->units, del->exts);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001998 LY_ARRAY_FOR(del->musts, u) {
1999 yprp_restr(ctx, &del->musts[u], "must", NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002000 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002001 LY_ARRAY_FOR(del->uniques, u) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002002 ypr_substmt(ctx, LYEXT_SUBSTMT_UNIQUE, u, del->uniques[u].str, del->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002003 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002004 LY_ARRAY_FOR(del->dflts, u) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002005 ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, del->dflts[u].str, del->exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002006 }
2007 }
2008
2009 LEVEL--;
2010 ypr_close(ctx, 1);
2011 }
2012
2013 LEVEL--;
2014 ypr_close(ctx, 1);
2015}
2016
Michal Vasko7c8439f2020-08-05 13:25:19 +02002017static void
2018yang_print_parsed_linkage(struct ypr_ctx *ctx, const struct lysp_module *modp)
Radek Krejcid3ca0632019-04-16 16:54:54 +02002019{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002020 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid3ca0632019-04-16 16:54:54 +02002021
Radek Krejcid3ca0632019-04-16 16:54:54 +02002022 LY_ARRAY_FOR(modp->imports, u) {
Michal Vasko3e9bc2f2020-11-04 17:13:56 +01002023 if (modp->imports[u].flags & LYS_INTERNAL) {
2024 continue;
2025 }
2026
Michal Vasko5233e962020-08-14 14:26:20 +02002027 ly_print_(ctx->out, "%s%*simport %s {\n", u ? "" : "\n", INDENT, modp->imports[u].name);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002028 LEVEL++;
Radek Krejci693262f2019-04-29 15:23:20 +02002029 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, modp->imports[u].exts, NULL, 0);
2030 ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, modp->imports[u].prefix, modp->imports[u].exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002031 if (modp->imports[u].rev[0]) {
Radek Krejci693262f2019-04-29 15:23:20 +02002032 ypr_substmt(ctx, LYEXT_SUBSTMT_REVISIONDATE, 0, modp->imports[u].rev, modp->imports[u].exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002033 }
Radek Krejci693262f2019-04-29 15:23:20 +02002034 ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, modp->imports[u].dsc, modp->imports[u].exts);
2035 ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, modp->imports[u].ref, modp->imports[u].exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002036 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02002037 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002038 }
2039 LY_ARRAY_FOR(modp->includes, u) {
2040 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 +02002041 ly_print_(ctx->out, "%s%*sinclude %s {\n", u ? "" : "\n", INDENT, modp->includes[u].name);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002042 LEVEL++;
Radek Krejci693262f2019-04-29 15:23:20 +02002043 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, modp->includes[u].exts, NULL, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002044 if (modp->includes[u].rev[0]) {
Radek Krejci693262f2019-04-29 15:23:20 +02002045 ypr_substmt(ctx, LYEXT_SUBSTMT_REVISIONDATE, 0, modp->includes[u].rev, modp->includes[u].exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002046 }
Radek Krejci693262f2019-04-29 15:23:20 +02002047 ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, modp->includes[u].dsc, modp->includes[u].exts);
2048 ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, modp->includes[u].ref, modp->includes[u].exts);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002049 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02002050 ly_print_(ctx->out, "%*s}\n", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002051 } else {
Michal Vasko5233e962020-08-14 14:26:20 +02002052 ly_print_(ctx->out, "\n%*sinclude \"%s\";\n", INDENT, modp->includes[u].name);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002053 }
2054 }
Michal Vasko7c8439f2020-08-05 13:25:19 +02002055}
Radek Krejcid3ca0632019-04-16 16:54:54 +02002056
Michal Vasko7c8439f2020-08-05 13:25:19 +02002057static void
2058yang_print_parsed_body(struct ypr_ctx *ctx, const struct lysp_module *modp)
2059{
2060 LY_ARRAY_COUNT_TYPE u;
2061 struct lysp_node *data;
Radek Krejcid3ca0632019-04-16 16:54:54 +02002062
Radek Krejcid3ca0632019-04-16 16:54:54 +02002063 LY_ARRAY_FOR(modp->extensions, u) {
Michal Vasko5233e962020-08-14 14:26:20 +02002064 ly_print_(ctx->out, "\n");
Radek Krejci693262f2019-04-29 15:23:20 +02002065 yprp_extension(ctx, &modp->extensions[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002066 }
2067 if (modp->exts) {
Michal Vasko5233e962020-08-14 14:26:20 +02002068 ly_print_(ctx->out, "\n");
Michal Vasko7c8439f2020-08-05 13:25:19 +02002069 yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, modp->exts, NULL, 0);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002070 }
2071
2072 LY_ARRAY_FOR(modp->features, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02002073 yprp_feature(ctx, &modp->features[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002074 }
2075
2076 LY_ARRAY_FOR(modp->identities, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02002077 yprp_identity(ctx, &modp->identities[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002078 }
2079
2080 LY_ARRAY_FOR(modp->typedefs, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02002081 yprp_typedef(ctx, &modp->typedefs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002082 }
2083
2084 LY_ARRAY_FOR(modp->groupings, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02002085 yprp_grouping(ctx, &modp->groupings[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002086 }
2087
2088 LY_LIST_FOR(modp->data, data) {
Radek Krejci693262f2019-04-29 15:23:20 +02002089 yprp_node(ctx, data);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002090 }
2091
2092 LY_ARRAY_FOR(modp->augments, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02002093 yprp_augment(ctx, &modp->augments[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002094 }
2095
2096 LY_ARRAY_FOR(modp->rpcs, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02002097 yprp_action(ctx, &modp->rpcs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002098 }
2099
2100 LY_ARRAY_FOR(modp->notifs, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02002101 yprp_notification(ctx, &modp->notifs[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002102 }
2103
2104 LY_ARRAY_FOR(modp->deviations, u) {
Radek Krejci693262f2019-04-29 15:23:20 +02002105 yprp_deviation(ctx, &modp->deviations[u]);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002106 }
Michal Vasko7c8439f2020-08-05 13:25:19 +02002107}
2108
2109LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002110yang_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 +02002111{
2112 LY_ARRAY_COUNT_TYPE u;
Radek Krejci52f65552020-09-01 17:03:35 +02002113 struct ypr_ctx ctx_ = {.out = out, .level = 0, .module = module, .schema = YPR_PARSED, .options = options}, *ctx = &ctx_;
Michal Vasko7c8439f2020-08-05 13:25:19 +02002114
Michal Vasko5233e962020-08-14 14:26:20 +02002115 ly_print_(ctx->out, "%*smodule %s {\n", INDENT, module->name);
Michal Vasko7c8439f2020-08-05 13:25:19 +02002116 LEVEL++;
2117
2118 /* module-header-stmts */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02002119 if (modp->version) {
2120 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 +02002121 }
2122
2123 ypr_substmt(ctx, LYEXT_SUBSTMT_NAMESPACE, 0, module->ns, modp->exts);
2124 ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, module->prefix, modp->exts);
2125
2126 /* linkage-stmts (import/include) */
2127 yang_print_parsed_linkage(ctx, modp);
2128
2129 /* meta-stmts */
2130 if (module->org || module->contact || module->dsc || module->ref) {
Michal Vasko5233e962020-08-14 14:26:20 +02002131 ly_print_(out, "\n");
Michal Vasko7c8439f2020-08-05 13:25:19 +02002132 }
2133 ypr_substmt(ctx, LYEXT_SUBSTMT_ORGANIZATION, 0, module->org, modp->exts);
2134 ypr_substmt(ctx, LYEXT_SUBSTMT_CONTACT, 0, module->contact, modp->exts);
2135 ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, module->dsc, modp->exts);
2136 ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, module->ref, modp->exts);
2137
2138 /* revision-stmts */
2139 if (modp->revs) {
Michal Vasko5233e962020-08-14 14:26:20 +02002140 ly_print_(out, "\n");
Michal Vasko7c8439f2020-08-05 13:25:19 +02002141 }
2142 LY_ARRAY_FOR(modp->revs, u) {
2143 yprp_revision(ctx, &modp->revs[u]);
2144 }
2145 /* body-stmts */
2146 yang_print_parsed_body(ctx, modp);
2147
2148 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02002149 ly_print_(out, "%*s}\n", INDENT);
Michal Vasko7c8439f2020-08-05 13:25:19 +02002150 ly_print_flush(out);
2151
2152 return LY_SUCCESS;
2153}
2154
2155static void
2156yprp_belongsto(struct ypr_ctx *ctx, const struct lysp_submodule *submodp)
2157{
Michal Vaskoc3781c32020-10-06 14:04:08 +02002158 ly_print_(ctx->out, "%*sbelongs-to %s {\n", INDENT, submodp->mod->name);
Michal Vasko7c8439f2020-08-05 13:25:19 +02002159 LEVEL++;
2160 yprp_extension_instances(ctx, LYEXT_SUBSTMT_BELONGSTO, 0, submodp->exts, NULL, 0);
2161 ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, submodp->prefix, submodp->exts);
2162 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02002163 ly_print_(ctx->out, "%*s}\n", INDENT);
Michal Vasko7c8439f2020-08-05 13:25:19 +02002164}
2165
2166LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002167yang_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 +02002168{
2169 LY_ARRAY_COUNT_TYPE u;
Radek Krejci52f65552020-09-01 17:03:35 +02002170 struct ypr_ctx ctx_ = {.out = out, .level = 0, .module = module, .schema = YPR_PARSED, .options = options}, *ctx = &ctx_;
Michal Vasko7c8439f2020-08-05 13:25:19 +02002171
Michal Vasko5233e962020-08-14 14:26:20 +02002172 ly_print_(ctx->out, "%*ssubmodule %s {\n", INDENT, submodp->name);
Michal Vasko7c8439f2020-08-05 13:25:19 +02002173 LEVEL++;
2174
2175 /* submodule-header-stmts */
2176 if (submodp->version) {
2177 ypr_substmt(ctx, LYEXT_SUBSTMT_VERSION, 0, submodp->version == LYS_VERSION_1_1 ? "1.1" : "1", submodp->exts);
2178 }
2179
2180 yprp_belongsto(ctx, submodp);
2181
2182 /* linkage-stmts (import/include) */
2183 yang_print_parsed_linkage(ctx, (struct lysp_module *)submodp);
2184
2185 /* meta-stmts */
2186 if (submodp->org || submodp->contact || submodp->dsc || submodp->ref) {
Michal Vasko5233e962020-08-14 14:26:20 +02002187 ly_print_(out, "\n");
Michal Vasko7c8439f2020-08-05 13:25:19 +02002188 }
2189 ypr_substmt(ctx, LYEXT_SUBSTMT_ORGANIZATION, 0, submodp->org, submodp->exts);
2190 ypr_substmt(ctx, LYEXT_SUBSTMT_CONTACT, 0, submodp->contact, submodp->exts);
2191 ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, submodp->dsc, submodp->exts);
2192 ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, submodp->ref, submodp->exts);
2193
2194 /* revision-stmts */
2195 if (submodp->revs) {
Michal Vasko5233e962020-08-14 14:26:20 +02002196 ly_print_(out, "\n");
Michal Vasko7c8439f2020-08-05 13:25:19 +02002197 }
2198 LY_ARRAY_FOR(submodp->revs, u) {
2199 yprp_revision(ctx, &submodp->revs[u]);
2200 }
2201 /* body-stmts */
2202 yang_print_parsed_body(ctx, (struct lysp_module *)submodp);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002203
2204 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02002205 ly_print_(out, "%*s}\n", INDENT);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002206 ly_print_flush(out);
2207
2208 return LY_SUCCESS;
2209}
2210
2211LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002212yang_print_compiled_node(struct ly_out *out, const struct lysc_node *node, uint32_t options)
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08002213{
Radek Krejci52f65552020-09-01 17:03:35 +02002214 struct ypr_ctx ctx_ = {.out = out, .level = 0, .module = node->module, .options = options}, *ctx = &ctx_;
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08002215
2216 yprc_node(ctx, node);
2217
2218 ly_print_flush(out);
2219 return LY_SUCCESS;
2220}
2221
2222LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002223yang_print_compiled(struct ly_out *out, const struct lys_module *module, uint32_t options)
Radek Krejcid3ca0632019-04-16 16:54:54 +02002224{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002225 LY_ARRAY_COUNT_TYPE u;
Radek Krejci693262f2019-04-29 15:23:20 +02002226 struct lysc_node *data;
2227 struct lysc_module *modc = module->compiled;
Radek Krejci52f65552020-09-01 17:03:35 +02002228 struct ypr_ctx ctx_ = {.out = out, .level = 0, .module = module, .options = options}, *ctx = &ctx_;
Radek Krejci693262f2019-04-29 15:23:20 +02002229
Michal Vasko5233e962020-08-14 14:26:20 +02002230 ly_print_(ctx->out, "%*smodule %s {\n", INDENT, module->name);
Radek Krejci693262f2019-04-29 15:23:20 +02002231 LEVEL++;
2232
Radek Krejci693262f2019-04-29 15:23:20 +02002233 /* module-header-stmts */
Radek Krejci693262f2019-04-29 15:23:20 +02002234 ypr_substmt(ctx, LYEXT_SUBSTMT_NAMESPACE, 0, module->ns, modc->exts);
2235 ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, module->prefix, modc->exts);
2236
Michal Vasko7c8439f2020-08-05 13:25:19 +02002237 /* no linkage-stmts */
Radek Krejci693262f2019-04-29 15:23:20 +02002238
2239 /* meta-stmts */
2240 if (module->org || module->contact || module->dsc || module->ref) {
Michal Vasko5233e962020-08-14 14:26:20 +02002241 ly_print_(out, "\n");
Radek Krejci693262f2019-04-29 15:23:20 +02002242 }
2243 ypr_substmt(ctx, LYEXT_SUBSTMT_ORGANIZATION, 0, module->org, modc->exts);
2244 ypr_substmt(ctx, LYEXT_SUBSTMT_CONTACT, 0, module->contact, modc->exts);
2245 ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, module->dsc, modc->exts);
2246 ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, module->ref, modc->exts);
2247
2248 /* revision-stmts */
2249 if (module->revision) {
Michal Vasko5233e962020-08-14 14:26:20 +02002250 ly_print_(ctx->out, "\n%*srevision %s;\n", INDENT, module->revision);
Radek Krejci693262f2019-04-29 15:23:20 +02002251 }
2252
2253 /* body-stmts */
2254 if (modc->exts) {
Michal Vasko5233e962020-08-14 14:26:20 +02002255 ly_print_(out, "\n");
Radek Krejci693262f2019-04-29 15:23:20 +02002256 yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, module->compiled->exts, NULL, 0);
2257 }
2258
Radek Krejci80d281e2020-09-14 17:42:54 +02002259 LY_ARRAY_FOR(module->identities, u) {
2260 yprc_identity(ctx, &module->identities[u]);
Radek Krejci693262f2019-04-29 15:23:20 +02002261 }
2262
Radek Krejci52f65552020-09-01 17:03:35 +02002263 if (!(ctx->options & LYS_PRINT_NO_SUBSTMT)) {
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08002264 LY_LIST_FOR(modc->data, data) {
2265 yprc_node(ctx, data);
2266 }
Radek Krejci693262f2019-04-29 15:23:20 +02002267
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08002268 LY_ARRAY_FOR(modc->rpcs, u) {
2269 yprc_action(ctx, &modc->rpcs[u]);
2270 }
Radek Krejci693262f2019-04-29 15:23:20 +02002271
Radek Krejcid8c0f5e2019-11-17 12:18:34 +08002272 LY_ARRAY_FOR(modc->notifs, u) {
2273 yprc_notification(ctx, &modc->notifs[u]);
2274 }
Radek Krejci693262f2019-04-29 15:23:20 +02002275 }
2276
2277 LEVEL--;
Michal Vasko5233e962020-08-14 14:26:20 +02002278 ly_print_(out, "%*s}\n", INDENT);
Radek Krejci693262f2019-04-29 15:23:20 +02002279 ly_print_flush(out);
Radek Krejcid3ca0632019-04-16 16:54:54 +02002280
2281 return LY_SUCCESS;
2282}