/**

 * @file printer/yang.c

 * @author Radek Krejci <rkrejci@cesnet.cz>

 * @brief YANG printer for libyang data model structure

 *

 * Copyright (c) 2015 CESNET, z.s.p.o.

 *

 * This source code is licensed under BSD 3-Clause License (the "License").

 * You may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     https://opensource.org/licenses/BSD-3-Clause

 */

#define _GNU_SOURCE

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdint.h>

#include <assert.h>

#include "common.h"

#include "context.h"

#include "printer.h"

#include "tree_schema.h"

#define INDENT ""

#define LEVEL (level*2)

static void yang_print_snode(struct lyout *out, int level, const struct lys_node *node, int mask);

static void yang_print_extension_instances(struct lyout *out, int level, const struct lys_module *module,

                                           LYEXT_SUBSTMT substmt, uint8_t substmt_index,

                                           struct lys_ext_instance **ext, unsigned int count);

static void

yang_encode(struct lyout *out, const char *text, int len)

{

    int i, start_len;

    const char *start;

    char special = 0;

    if (!len) {

        return;

    }

    if (len < 0) {

        len = strlen(text);

    }

    start = text;

    start_len = 0;

    for (i = 0; i < len; ++i) {

        switch (text[i]) {

        case '\n':

        case '\t':

        case '\"':

        case '\\':

            special = text[i];

            break;

        default:

            ++start_len;

            break;

        }

        if (special) {

            ly_write(out, start, start_len);

            switch (special) {

            case '\n':

                ly_write(out, "\\n", 2);

                break;

            case '\t':

                ly_write(out, "\\t", 2);

                break;

            case '\"':

                ly_write(out, "\\\"", 2);

                break;

            case '\\':

                ly_write(out, "\\\\", 2);

                break;

            }

            start += start_len + 1;

            start_len = 0;

            special = 0;

        }

    }

    ly_write(out, start, start_len);

}

static void

yang_print_open(struct lyout *out, int *flag)

{

    if (flag && !*flag) {

        *flag = 1;

        ly_print(out, " {\n");

    }

}

static void

yang_print_close(struct lyout *out, int level, int flag)

{

    if (flag) {

        ly_print(out, "%*s}\n", LEVEL, INDENT);

    } else {

        ly_print(out, ";\n");

    }

}

static void

yang_print_text(struct lyout *out, int level, const char *name, const char *text, int singleline, int closed)

{

    const char *s, *t;

    if (singleline) {

        ly_print(out, "%*s%s \"", LEVEL, INDENT, name);

    } else {

        ly_print(out, "%*s%s\n", LEVEL, INDENT, name);

        level++;

        ly_print(out, "%*s\"", LEVEL, INDENT);

    }

    t = text;

    while ((s = strchr(t, '\n'))) {

        yang_encode(out, t, s - t);

        ly_print(out, "\n");

        t = s + 1;

        if (*t != '\n') {

            ly_print(out, "%*s ", LEVEL, INDENT);

        }

    }

    yang_encode(out, t, strlen(t));

    if (closed) {

        ly_print(out, "\";\n");

    } else {

        ly_print(out, "\"");

    }

    level--;

}

static void

yang_print_substmt(struct lyout *out, int level, LYEXT_SUBSTMT substmt, uint8_t substmt_index, const char *text,

                   const struct lys_module *module, struct lys_ext_instance **ext, unsigned int ext_size)

{

    int i = -1;

    if (!text) {

        /* nothing to print */

        return;

    }

    do {

        i = lys_ext_iter(ext, ext_size, i + 1, substmt);

    } while (i != -1 && ext[i]->insubstmt_index != substmt_index);

    if (ext_substmt_info[substmt].flags & SUBST_FLAG_ID) {

        ly_print(out, "%*s%s %s%s", LEVEL, INDENT, ext_substmt_info[substmt].name, text, i == -1 ? ";\n" : "");

    } else {

        yang_print_text(out, level, ext_substmt_info[substmt].name, text,

                        (ext_substmt_info[substmt].flags & SUBST_FLAG_YIN) ? 0 : 1, i == -1 ? 1 : 0);

    }

    if (i != -1) {

        ly_print(out, " {\n");

        do {

            yang_print_extension_instances(out, level + 1, module, substmt, substmt_index, &ext[i], 1);

            do {

                i = lys_ext_iter(ext, ext_size, i + 1, substmt);

            } while (i != -1 && ext[i]->insubstmt_index != substmt_index);

        } while (i != -1);

        ly_print(out, "%*s}\n", LEVEL, INDENT);

    }

}

static void

yang_print_iffeature(struct lyout *out, int level, const struct lys_module *module, struct lys_iffeature *iffeature)

{

    ly_print(out, "%*sif-feature \"", LEVEL, INDENT);

    ly_print_iffeature(out, module, iffeature, 0);

    /* extensions */

    if (iffeature->ext_size) {

        ly_print(out, "\" {\n");

        yang_print_extension_instances(out, level + 1, module, LYEXT_SUBSTMT_SELF, 0, iffeature->ext, iffeature->ext_size);

        ly_print(out, "%*s}\n", LEVEL, INDENT);

    } else {

        ly_print(out, "\";\n");

    }

}

/*

 * Covers:

 * extension (instances), if-features, config, mandatory, status, description, reference

 */

#define SNODE_COMMON_EXT    0x01

#define SNODE_COMMON_IFF    0x02

#define SNODE_COMMON_CONFIG 0x04

#define SNODE_COMMON_MAND   0x08

#define SNODE_COMMON_STATUS 0x10

#define SNODE_COMMON_DSC    0x20

#define SNODE_COMMON_REF    0x40

static void

yang_print_snode_common(struct lyout *out, int level, const struct lys_node *node, const struct lys_module *module,

                        int *flag, int mask)

{

    int i;

    const char *status = NULL;

    /* extensions */

    if ((mask & SNODE_COMMON_EXT) && node->ext_size) {

        yang_print_open(out, flag);

        yang_print_extension_instances(out, level, module, LYEXT_SUBSTMT_SELF, 0, node->ext, node->ext_size);

    }

    /* if-features */

    if (mask & SNODE_COMMON_IFF) {

        for (i = 0; i < node->iffeature_size; ++i) {

            yang_print_open(out, flag);

            yang_print_iffeature(out, level, module, &node->iffeature[i]);

        }

    }

    /* config */

    if (mask & SNODE_COMMON_CONFIG) {

        /* get info if there is an extension for the config statement */

        i = lys_ext_iter(node->ext, node->ext_size, 0, LYEXT_SUBSTMT_CONFIG);

        if (lys_parent(node)) {

            if ((node->flags & LYS_CONFIG_SET) || i != -1) {

                /* print config when it differs from the parent or if it has an extension instance ... */

                if (node->flags & LYS_CONFIG_W) {

                    yang_print_open(out, flag);

                    yang_print_substmt(out, level, LYEXT_SUBSTMT_CONFIG, 0, "true",

                                       module, node->ext, node->ext_size);

                } else if (node->flags & LYS_CONFIG_R) {

                    yang_print_open(out, flag);

                    yang_print_substmt(out, level, LYEXT_SUBSTMT_CONFIG, 0, "false",

                                       module, node->ext, node->ext_size);

                }

            }

        } else if (node->flags & LYS_CONFIG_R) {

            /* ... or it's a top-level state node */

            yang_print_open(out, flag);

            yang_print_substmt(out, level, LYEXT_SUBSTMT_CONFIG, 0, "false",

                               module, node->ext, node->ext_size);

        } else if (i != -1) {

            /* the config has an extension, so we have to print it */

            yang_print_open(out, flag);

            yang_print_substmt(out, level, LYEXT_SUBSTMT_CONFIG, 0, "true",

                               module, node->ext, node->ext_size);

        }

    }

    /* mandatory */

    if ((mask & SNODE_COMMON_MAND) && (node->nodetype & (LYS_LEAF | LYS_CHOICE | LYS_ANYDATA))) {

        if (node->flags & LYS_MAND_TRUE) {

            yang_print_open(out, flag);

            yang_print_substmt(out, level, LYEXT_SUBSTMT_MANDATORY, 0, "true",

                               module, node->ext, node->ext_size);

        } else if (node->flags & LYS_MAND_FALSE) {

            yang_print_open(out, flag);

            yang_print_substmt(out, level, LYEXT_SUBSTMT_MANDATORY, 0, "false",

                               module, node->ext, node->ext_size);

        }

    }

    /* status */

    if (mask & SNODE_COMMON_STATUS) {

        if (node->flags & LYS_STATUS_CURR) {

            yang_print_open(out, flag);

            status = "current";

        } else if (node->flags & LYS_STATUS_DEPRC) {

            yang_print_open(out, flag);

            status = "deprecated";

        } else if (node->flags & LYS_STATUS_OBSLT) {

            yang_print_open(out, flag);

            status = "obsolete";

        }

        yang_print_substmt(out, level, LYEXT_SUBSTMT_STATUS, 0, status, module, node->ext, node->ext_size);

    }

    /* description */

    if ((mask & SNODE_COMMON_DSC) && node->dsc) {

        yang_print_open(out, flag);

        yang_print_substmt(out, level, LYEXT_SUBSTMT_DESCRIPTION, 0, node->dsc,

                           module, node->ext, node->ext_size);

    }

    /* reference */

    if ((mask & SNODE_COMMON_REF) && node->ref) {

        yang_print_open(out, flag);

        yang_print_substmt(out, level, LYEXT_SUBSTMT_REFERENCE, 0, node->ref,

                           module, node->ext, node->ext_size);

    }

}

static void

yang_print_feature(struct lyout *out, int level, const struct lys_feature *feat)

{

    int flag = 0;

    ly_print(out, "%*sfeature %s", LEVEL, INDENT, feat->name);

    yang_print_snode_common(out, level + 1, (struct lys_node *)feat, feat->module, &flag, SNODE_COMMON_EXT |

                            SNODE_COMMON_IFF | SNODE_COMMON_STATUS | SNODE_COMMON_DSC | SNODE_COMMON_REF);

    yang_print_close(out, level, flag);

}

static void

yang_print_extension(struct lyout *out, int level, const struct lys_ext *ext)

{

    int flag = 0, flag2 = 0, i;

    ly_print(out, "%*sextension %s", LEVEL, INDENT, ext->name);

    level++;

    yang_print_snode_common(out, level, (struct lys_node *)ext, ext->module, &flag,

                            SNODE_COMMON_EXT);

    if (ext->argument) {

        yang_print_open(out, &flag;;

        ly_print(out, "%*sargument %s", LEVEL, INDENT, ext->argument);

        i = -1;

        while ((i = lys_ext_iter(ext->ext, ext->ext_size, i + 1, LYEXT_SUBSTMT_ARGUMENT)) != -1) {

            yang_print_open(out, &flag2);

            yang_print_extension_instances(out, level + 1, ext->module, LYEXT_SUBSTMT_ARGUMENT, 0, &ext->ext[i], 1);

        }

        if ((ext->flags & LYS_YINELEM) || lys_ext_iter(ext->ext, ext->ext_size, 0, LYEXT_SUBSTMT_YINELEM) != -1) {

            yang_print_open(out, &flag2);

            yang_print_substmt(out, level + 1, LYEXT_SUBSTMT_YINELEM, 0,

                               (ext->flags & LYS_YINELEM) ? "true" : "false", ext->module, ext->ext, ext->ext_size);

        }

        yang_print_close(out, level, flag2);

    }

    yang_print_snode_common(out, level, (struct lys_node *)ext, ext->module, &flag,

                            SNODE_COMMON_STATUS | SNODE_COMMON_DSC | SNODE_COMMON_REF);

    level--;

    yang_print_close(out, level, flag);

}

static void

yang_print_restr(struct lyout *out, int level, const struct lys_module *module, const struct lys_restr *restr,

                 const char *name, const char *value)

{

    int flag = 0;

    ly_print(out, "%*s%s \"", LEVEL, INDENT, name);

    yang_encode(out, value, -1);

    ly_print(out, "\"");

    level++;

    if (restr->ext_size) {

        yang_print_open(out, &flag;;

        yang_print_extension_instances(out, level, module, LYEXT_SUBSTMT_SELF, 0, restr->ext, restr->ext_size);

    }

    if (restr->expr[0] == 0x15) {

        /* special byte value in pattern's expression: 0x15 - invert-match, 0x06 - match */

        yang_print_open(out, &flag;;

        yang_print_substmt(out, level, LYEXT_SUBSTMT_MODIFIER, 0, "invert-match",

                           module, restr->ext, restr->ext_size);

    }

    if (restr->emsg != NULL) {

        yang_print_open(out, &flag;;

        yang_print_substmt(out, level, LYEXT_SUBSTMT_ERRMSG, 0, restr->emsg,

                           module, restr->ext, restr->ext_size);

    }

    if (restr->eapptag != NULL) {

        yang_print_open(out, &flag;;

        yang_print_substmt(out, level, LYEXT_SUBSTMT_ERRTAG, 0, restr->eapptag,

                           module, restr->ext, restr->ext_size);

    }

    if (restr->dsc != NULL) {

        yang_print_open(out, &flag;;

        yang_print_substmt(out, level, LYEXT_SUBSTMT_DESCRIPTION, 0, restr->dsc,

                           module, restr->ext, restr->ext_size);

    }

    if (restr->ref != NULL) {

        yang_print_open(out, &flag;;

        yang_print_substmt(out, level, LYEXT_SUBSTMT_REFERENCE, 0, restr->ref,

                           module, restr->ext, restr->ext_size);

    }

    level--;

    yang_print_close(out, level, flag);

}

static void

yang_print_when(struct lyout *out, int level, const struct lys_module *module, const struct lys_when *when)

{

    int flag = 0;

    const char *str;

    str = transform_json2schema(module, when->cond);

    if (!str) {

        ly_print(out, "(!error!)");

        return;

    }

    ly_print(out, "%*swhen \"", LEVEL, INDENT);

    yang_encode(out, str, -1);

    ly_print(out, "\"");

    lydict_remove(module->ctx, str);

    level++;

    if (when->ext_size) {

        /* extension is stored in lys_when incompatible with lys_node, so we cannot use yang_print_snode_common() */

        yang_print_open(out, &flag;;

        yang_print_extension_instances(out, level, module, LYEXT_SUBSTMT_SELF, 0, when->ext, when->ext_size);

    }

    if (when->dsc != NULL) {

        yang_print_open(out, &flag;;

        yang_print_substmt(out, level, LYEXT_SUBSTMT_DESCRIPTION, 0, when->dsc,

                           module, when->ext, when->ext_size);

    }

    if (when->ref != NULL) {

        yang_print_open(out, &flag;;

        yang_print_substmt(out, level, LYEXT_SUBSTMT_REFERENCE, 0, when->ref,

                           module, when->ext, when->ext_size);

    }

    level--;

    yang_print_close(out, level, flag);

}

static void

yang_print_unsigned(struct lyout *out, int level, LYEXT_SUBSTMT substmt, uint8_t substmt_index,

                    const struct lys_module *module, struct lys_ext_instance **ext, unsigned int ext_size,

                    unsigned int attr_value)

{

    char *str;

    if (asprintf(&str, "%u", attr_value) == -1) {

        LOGMEM(module->ctx);

        return;

    }

    yang_print_substmt(out, level, substmt, substmt_index, str, module, ext, ext_size);

    free(str);

}

static void

yang_print_signed(struct lyout *out, int level, LYEXT_SUBSTMT substmt, uint8_t substmt_index,

                  const struct lys_module *module, struct lys_ext_instance **ext, unsigned int ext_size,

                  signed int attr_value)

{

    char *str;

    if (asprintf(&str, "%d", attr_value) == -1) {

        LOGMEM(module->ctx);

        return;

    }

    yang_print_substmt(out, level, substmt, substmt_index, str, module, ext, ext_size);

    free(str);

}

static void

yang_print_type(struct lyout *out, int level, const struct lys_module *module, const struct lys_type *type)

{

    unsigned int i;

    int flag = 0, flag2;

    const char *str;

    char *s;

    struct lys_module *mod;

    if (!lys_type_is_local(type)) {

        ly_print(out, "%*stype %s:%s", LEVEL, INDENT,

                 transform_module_name2import_prefix(module, lys_main_module(type->der->module)->name), type->der->name);

    } else {

        ly_print(out, "%*stype %s", LEVEL, INDENT, type->der->name);

    }

    level++;

    /* extensions */

    if (type->ext_size) {

        yang_print_open(out, &flag;;

        yang_print_extension_instances(out, level, module, LYEXT_SUBSTMT_SELF, 0, type->ext, type->ext_size);

    }

    switch (type->base) {

    case LY_TYPE_BINARY:

        if (type->info.binary.length) {

            yang_print_open(out, &flag;;

            yang_print_restr(out, level, module, type->info.binary.length, "length", type->info.binary.length->expr);

        }

        break;

    case LY_TYPE_BITS:

        for (i = 0; i < type->info.bits.count; ++i) {

            yang_print_open(out, &flag;;

            ly_print(out, "%*sbit %s", LEVEL, INDENT, type->info.bits.bit[i].name);

            flag2 = 0;

            level++;

            yang_print_snode_common(out, level, (struct lys_node *)&type->info.bits.bit[i], module, &flag2,

                                    SNODE_COMMON_EXT | SNODE_COMMON_IFF);

            if (!(type->info.bits.bit[i].flags & LYS_AUTOASSIGNED)) {

                yang_print_open(out, &flag2);

                yang_print_unsigned(out, level, LYEXT_SUBSTMT_POSITION, 0, module,

                                    type->info.bits.bit[i].ext, type->info.bits.bit[i].ext_size,

                                    type->info.bits.bit[i].pos);

            }

            yang_print_snode_common(out, level, (struct lys_node *)&type->info.bits.bit[i], module, &flag2,

                                    SNODE_COMMON_STATUS | SNODE_COMMON_DSC | SNODE_COMMON_REF);

            level--;

            yang_print_close(out, level, flag2);

        }

        break;

    case LY_TYPE_DEC64:

        if (!type->der->type.der) {

            yang_print_open(out, &flag;;

            yang_print_unsigned(out, level, LYEXT_SUBSTMT_DIGITS, 0, module,

                                type->ext, type->ext_size, type->info.dec64.dig);

        }

        if (type->info.dec64.range != NULL) {

            yang_print_open(out, &flag;;

            yang_print_restr(out, level, module, type->info.dec64.range, "range", type->info.dec64.range->expr);

        }

        break;

    case LY_TYPE_ENUM:

        for (i = 0; i < type->info.enums.count; i++) {

            yang_print_open(out, &flag;;

            ly_print(out, "%*senum \"%s\"", LEVEL, INDENT, type->info.enums.enm[i].name);

            flag2 = 0;

            level++;

            yang_print_snode_common(out, level, (struct lys_node *)&type->info.enums.enm[i], module, &flag2,

                                    SNODE_COMMON_EXT | SNODE_COMMON_IFF);

            if (!(type->info.enums.enm[i].flags & LYS_AUTOASSIGNED)) {

                yang_print_open(out, &flag2);

                yang_print_signed(out, level, LYEXT_SUBSTMT_VALUE, 0, module,

                                  type->info.enums.enm[i].ext, type->info.enums.enm[i].ext_size,

                                  type->info.enums.enm[i].value);

            }

            yang_print_snode_common(out, level, (struct lys_node *)&type->info.enums.enm[i], module, &flag2,

                                    SNODE_COMMON_STATUS | SNODE_COMMON_DSC | SNODE_COMMON_REF);

            level--;

            yang_print_close(out, level, flag2);

        }

        break;

    case LY_TYPE_IDENT:

        if (type->info.ident.count) {

            yang_print_open(out, &flag;;

            for (i = 0; i < type->info.ident.count; ++i) {

                mod = lys_main_module(type->info.ident.ref[i]->module);

                if (lys_main_module(module) == mod) {

                    yang_print_substmt(out, level, LYEXT_SUBSTMT_BASE, 0, type->info.ident.ref[i]->name,

                                       module, type->info.ident.ref[i]->ext, type->info.ident.ref[i]->ext_size);

                } else {

                    if (asprintf(&s, "%s:%s", transform_module_name2import_prefix(module, mod->name),

                                 type->info.ident.ref[i]->name) == -1) {

                        LOGMEM(module->ctx);

                        return;

                    }

                    yang_print_substmt(out, level, LYEXT_SUBSTMT_BASE, 0, s,

                                       module, type->info.ident.ref[i]->ext, type->info.ident.ref[i]->ext_size);

                    free(s);

                }

            }

        }

        break;

    case LY_TYPE_INST:

        if (type->info.inst.req == 1) {

            yang_print_open(out, &flag;;

            yang_print_substmt(out, level, LYEXT_SUBSTMT_REQINSTANCE, 0, "true", module, type->ext, type->ext_size);

        } else if (type->info.inst.req == -1) {

            yang_print_open(out, &flag;;

            yang_print_substmt(out, level, LYEXT_SUBSTMT_REQINSTANCE, 0, "false", module, type->ext, type->ext_size);

        }

        break;

    case LY_TYPE_INT8:

    case LY_TYPE_INT16:

    case LY_TYPE_INT32:

    case LY_TYPE_INT64:

    case LY_TYPE_UINT8:

    case LY_TYPE_UINT16:

    case LY_TYPE_UINT32:

    case LY_TYPE_UINT64:

        if (type->info.num.range) {

            yang_print_open(out, &flag;;

            yang_print_restr(out, level, module, type->info.num.range, "range", type->info.num.range->expr);

        }

        break;

    case LY_TYPE_LEAFREF:

        if (ly_strequal(type->der->name, "leafref", 0)) {

            yang_print_open(out, &flag;;

            str = transform_json2schema(module, type->info.lref.path);

            yang_print_substmt(out, level, LYEXT_SUBSTMT_PATH, 0, str, module, type->ext, type->ext_size);

            lydict_remove(module->ctx, str);

        }

        if (type->info.lref.req == 1) {

            yang_print_open(out, &flag;;

            yang_print_substmt(out, level, LYEXT_SUBSTMT_REQINSTANCE, 0, "true", module, type->ext, type->ext_size);

        } else if (type->info.lref.req == -1) {

            yang_print_open(out, &flag;;

            yang_print_substmt(out, level, LYEXT_SUBSTMT_REQINSTANCE, 0, "false", module, type->ext, type->ext_size);

        }

        break;

    case LY_TYPE_STRING:

        if (type->info.str.length) {

            yang_print_open(out, &flag;;

            yang_print_restr(out, level, module, type->info.str.length, "length", type->info.str.length->expr);

        }

        for (i = 0; i < type->info.str.pat_count; i++) {

            yang_print_open(out, &flag;;

            yang_print_restr(out, level, module, &type->info.str.patterns[i],

                             "pattern", &type->info.str.patterns[i].expr[1]);

        }

        break;

    case LY_TYPE_UNION:

        for (i = 0; i < type->info.uni.count; ++i) {

            yang_print_open(out, &flag;;

            yang_print_type(out, level, module, &type->info.uni.types[i]);

        }

        break;

    default:

        /* other types do not have substatements */

        break;

    }

    level--;

    yang_print_close(out, level, flag);

}

static void

yang_print_must(struct lyout *out, int level, const struct lys_module *module, const struct lys_restr *must)

{

    const char *str;

    str = transform_json2schema(module, must->expr);

    if (!str) {

        ly_print(out, "(!error!)");

        return;

    }

    yang_print_restr(out, level, module, must, "must", str);

    lydict_remove(module->ctx, str);

}

static void

yang_print_unique(struct lyout *out, int level, const struct lys_module *module, const struct lys_unique *uniq)

{

    int i;

    const char *str;

    ly_print(out, "%*sunique \"", LEVEL, INDENT);

    for (i = 0; i < uniq->expr_size; i++) {

        str = transform_json2schema(module, uniq->expr[i]);

        ly_print(out, "%s%s", str, i + 1 < uniq->expr_size ? " " : "");

        lydict_remove(module->ctx, str);

    }

    ly_print(out, "\"");

}

static void

yang_print_refine(struct lyout *out, int level, const struct lys_module *module, const struct lys_refine *refine)

{

    int i, flag = 0;

    const char *str;

    str = transform_json2schema(module, refine->target_name);

    ly_print(out, "%*srefine \"%s\"", LEVEL, INDENT, str);

    lydict_remove(module->ctx, str);

    level++;

    yang_print_snode_common(out, level, (struct lys_node *)refine, module, &flag, SNODE_COMMON_EXT | SNODE_COMMON_IFF);

    for (i = 0; i < refine->must_size; ++i) {

        yang_print_open(out, &flag;;

        yang_print_must(out, level, module, &refine->must[i]);

    }

    if (refine->target_type == LYS_CONTAINER) {

        yang_print_open(out, &flag;;

        yang_print_substmt(out, level, LYEXT_SUBSTMT_PRESENCE, 0, refine->mod.presence,

                           module, refine->ext, refine->ext_size);

    }

    for (i = 0; i < refine->dflt_size; ++i) {

        yang_print_open(out, &flag;;

        yang_print_substmt(out, level, LYEXT_SUBSTMT_DEFAULT, i, refine->dflt[i], module, refine->ext, refine->ext_size);

    }

    if (refine->flags & LYS_CONFIG_W) {

        yang_print_open(out, &flag;;

        yang_print_substmt(out, level, LYEXT_SUBSTMT_CONFIG, 0, "true", module, refine->ext, refine->ext_size);

    } else if (refine->flags & LYS_CONFIG_R) {

        yang_print_open(out, &flag;;

        yang_print_substmt(out, level, LYEXT_SUBSTMT_CONFIG, 0, "false", module, refine->ext, refine->ext_size);

    }

    if (refine->flags & LYS_MAND_TRUE) {

        yang_print_open(out, &flag;;

        yang_print_substmt(out, level, LYEXT_SUBSTMT_MANDATORY, 0, "true", module, refine->ext, refine->ext_size);

    } else if (refine->flags & LYS_MAND_FALSE) {

        yang_print_open(out, &flag;;

        yang_print_substmt(out, level, LYEXT_SUBSTMT_MANDATORY, 0, "false", module, refine->ext, refine->ext_size);

    }

    if (refine->target_type & (LYS_LIST | LYS_LEAFLIST)) {

        if (refine->flags & LYS_RFN_MINSET) {

            yang_print_open(out, &flag;;

            yang_print_unsigned(out, level, LYEXT_SUBSTMT_MIN, 0, module, refine->ext, refine->ext_size,

                                refine->mod.list.min);

        }

        if (refine->flags & LYS_RFN_MAXSET) {

            yang_print_open(out, &flag;;

            if (refine->mod.list.max) {

                yang_print_unsigned(out, level, LYEXT_SUBSTMT_MAX, 0, module, refine->ext, refine->ext_size,

                                    refine->mod.list.max);

            } else {

                yang_print_substmt(out, level, LYEXT_SUBSTMT_MAX, 0, "unbounded", module, refine->ext, refine->ext_size);

            }

        }

    }

    yang_print_snode_common(out, level, (struct lys_node *)refine, module, &flag, SNODE_COMMON_DSC | SNODE_COMMON_REF);

    level--;

    yang_print_close(out, level, flag);

}

static void

yang_print_deviation(struct lyout *out, int level, const struct lys_module *module,

                     const struct lys_deviation *deviation)

{

    int i, j, p;

    const char *str;

    str = transform_json2schema(module, deviation->target_name);

    ly_print(out, "%*sdeviation \"%s\" {\n", LEVEL, INDENT, str);

    lydict_remove(module->ctx, str);

    level++;

    if (deviation->ext_size) {

        yang_print_extension_instances(out, level, module, LYEXT_SUBSTMT_SELF, 0, deviation->ext, deviation->ext_size);

    }

    yang_print_substmt(out, level, LYEXT_SUBSTMT_DESCRIPTION, 0, deviation->dsc,

                       module, deviation->ext, deviation->ext_size);

    yang_print_substmt(out, level, LYEXT_SUBSTMT_REFERENCE, 0, deviation->ref,

                       module, deviation->ext, deviation->ext_size);

    for (i = 0; i < deviation->deviate_size; ++i) {

        ly_print(out, "%*sdeviate ", LEVEL, INDENT);

        if (deviation->deviate[i].mod == LY_DEVIATE_NO) {

            if (deviation->deviate[i].ext_size) {

                ly_print(out, "not-supported {\n");

            } else {

                ly_print(out, "not-supported;\n");

                continue;

            }

        } else if (deviation->deviate[i].mod == LY_DEVIATE_ADD) {

            ly_print(out, "add {\n");

        } else if (deviation->deviate[i].mod == LY_DEVIATE_RPL) {

            ly_print(out, "replace {\n");

        } else if (deviation->deviate[i].mod == LY_DEVIATE_DEL) {

            ly_print(out, "delete {\n");

        }

        level++;

        /* extensions */

        if (deviation->deviate[i].ext_size) {

            yang_print_extension_instances(out, level, module, LYEXT_SUBSTMT_SELF, 0,

                                           deviation->deviate[i].ext, deviation->deviate[i].ext_size);

        }

        /* type */

        if (deviation->deviate[i].type) {

            yang_print_type(out, level, module, deviation->deviate[i].type);

        }

        /* units */

        yang_print_substmt(out, level, LYEXT_SUBSTMT_UNITS, 0, deviation->deviate[i].units, module,

                           deviation->deviate[i].ext, deviation->deviate[i].ext_size);

        /* must */

        for (j = 0; j < deviation->deviate[i].must_size; ++j) {

            yang_print_must(out, level, module, &deviation->deviate[i].must[j]);

        }

        /* unique */

        for (j = 0; j < deviation->deviate[i].unique_size; ++j) {

            yang_print_unique(out, level, module, &deviation->deviate[i].unique[j]);

            /* unique's extensions */

            p = -1;

            do {

                p = lys_ext_iter(deviation->deviate[i].ext, deviation->deviate[i].ext_size,

                                      p + 1, LYEXT_SUBSTMT_UNIQUE);

            } while (p != -1 && deviation->deviate[i].ext[p]->insubstmt_index != j);

            if (p != -1) {

                ly_print(out, " {\n");

                do {

                    yang_print_extension_instances(out, level + 1, module, LYEXT_SUBSTMT_UNIQUE, j,

                                                   &deviation->deviate[i].ext[p], 1);

                    do {

                        p = lys_ext_iter(deviation->deviate[i].ext, deviation->deviate[i].ext_size,

                                              p + 1, LYEXT_SUBSTMT_UNIQUE);

                    } while (p != -1 && deviation->deviate[i].ext[p]->insubstmt_index != j);

                } while (p != -1);

                ly_print(out, "%*s}\n", LEVEL, INDENT);

            } else {

                ly_print(out, ";\n");

            }

        }

        /* default */

        for (j = 0; j < deviation->deviate[i].dflt_size; ++j) {

            yang_print_substmt(out, level, LYEXT_SUBSTMT_DEFAULT, j, deviation->deviate[i].dflt[j], module,

                               deviation->deviate[i].ext, deviation->deviate[i].ext_size);

        }

        /* config */

        if (deviation->deviate[i].flags & LYS_CONFIG_W) {

            yang_print_substmt(out, level, LYEXT_SUBSTMT_CONFIG, 0, "true", module,

                               deviation->deviate->ext, deviation->deviate[i].ext_size);

        } else if (deviation->deviate[i].flags & LYS_CONFIG_R) {

            yang_print_substmt(out, level, LYEXT_SUBSTMT_CONFIG, 0, "false", module,

                               deviation->deviate->ext, deviation->deviate[i].ext_size);

        }

        /* mandatory */

        if (deviation->deviate[i].flags & LYS_MAND_TRUE) {

            yang_print_substmt(out, level, LYEXT_SUBSTMT_MANDATORY, 0, "true", module,

                               deviation->deviate[i].ext, deviation->deviate[i].ext_size);

        } else if (deviation->deviate[i].flags & LYS_MAND_FALSE) {

            yang_print_substmt(out, level, LYEXT_SUBSTMT_MANDATORY, 0, "false", module,

                               deviation->deviate[i].ext, deviation->deviate[i].ext_size);

        }

        /* min-elements */

        if (deviation->deviate[i].min_set) {

            yang_print_unsigned(out, level, LYEXT_SUBSTMT_MIN, 0, module,

                                deviation->deviate[i].ext, deviation->deviate[i].ext_size,

                                deviation->deviate[i].min);

        }

        /* max-elements */

        if (deviation->deviate[i].max_set) {

            if (deviation->deviate[i].max) {

                yang_print_unsigned(out, level, LYEXT_SUBSTMT_MAX, 0, module,

                                    deviation->deviate[i].ext, deviation->deviate[i].ext_size,

                                    deviation->deviate[i].max);

            } else {

                yang_print_substmt(out, level, LYEXT_SUBSTMT_MAX, 0, "unbounded", module,

                                   deviation->deviate[i].ext, deviation->deviate[i].ext_size);

            }

        }

        level--;

        ly_print(out, "%*s}\n", LEVEL, INDENT);

    }

    level--;

    ly_print(out, "%*s}\n", LEVEL, INDENT);

}

static void

yang_print_augment(struct lyout *out, int level, const struct lys_node_augment *augment)

{

    struct lys_node *sub;

    const char *str;

    str = transform_json2schema(augment->module, augment->target_name);

    ly_print(out, "%*saugment \"%s\" {\n", LEVEL, INDENT, str);

    lydict_remove(augment->module->ctx, str);

    level++;

    yang_print_snode_common(out, level, (struct lys_node *)augment, augment->module, NULL, SNODE_COMMON_EXT);

    if (augment->when) {

        yang_print_when(out, level, augment->module, augment->when);

    }

    yang_print_snode_common(out, level, (struct lys_node *)augment, augment->module, NULL,

                            SNODE_COMMON_IFF | SNODE_COMMON_STATUS | SNODE_COMMON_DSC | SNODE_COMMON_REF);

    LY_TREE_FOR(augment->child, sub) {

        /* only our augment */

        if (sub->parent != (struct lys_node *)augment) {

            continue;

        }

        yang_print_snode(out, level, sub,

                         LYS_CHOICE | LYS_CONTAINER | LYS_LEAF | LYS_LEAFLIST | LYS_LIST |

                         LYS_USES | LYS_ANYDATA | LYS_CASE | LYS_ACTION | LYS_NOTIF);

    }

    level--;

    ly_print(out, "%*s}\n", LEVEL, INDENT);

}