diff options
Diffstat (limited to '')
| -rw-r--r-- | src/printer_tree.c | 4673 |
1 files changed, 4673 insertions, 0 deletions
diff --git a/src/printer_tree.c b/src/printer_tree.c new file mode 100644 index 0000000..6a7e7ce --- /dev/null +++ b/src/printer_tree.c @@ -0,0 +1,4673 @@ +/** + * @file printer_tree.c + * @author Adam Piecek <piecek@cesnet.cz> + * @brief RFC tree printer for libyang data structure + * + * Copyright (c) 2015 - 2021 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 + * + * @section TRP_DESIGN Design + * + * @code + * +---------+ +---------+ +---------+ + * output | trp | | trb | | tro | + * <---+ Print +<---+ Browse +<-->+ Obtain | + * | | | | | | + * +---------+ +----+----+ +---------+ + * ^ + * | + * +----+----+ + * | trm | + * | Manager | + * | | + * +----+----+ + * ^ + * | input + * + + * @endcode + * + * @subsection TRP_GLOSSARY Glossary + * + * @subsubsection TRP_trm trm + * Manager functions are at the peak of abstraction. They are + * able to print individual sections of the YANG tree diagram + * (eg module, notifications, rpcs ...) and they call + * Browse functions (@ref TRP_trb). + * + * @subsubsection TRP_trb trb + * Browse functions contain a general algorithm (Preorder DFS) + * for traversing the tree. It does not matter what data type + * the tree contains (@ref lysc_node or @ref lysp_node), because it + * requires a ready-made getter functions for traversing the tree + * (@ref trt_fp_all) and transformation function to its own node + * data type (@ref trt_node). These getter functions are generally + * referred to as @ref TRP_tro. Browse functions can repeatedly + * traverse nodes in the tree, for example, to calculate the alignment + * gap before the nodes \<type\> in the YANG Tree Diagram. + * The obtained @ref trt_node is passed to the @ref TRP_trp functions + * to print the Tree diagram. + * + * @subsubsection TRP_tro tro + * Functions that provide an extra wrapper for the libyang library. + * The Obtain functions are further specialized according to whether + * they operate on lysp_tree (@ref TRP_trop) or lysc_tree + * (@ref TRP_troc). If they are general algorithms, then they have the + * prefix \b tro_. The Obtain functions provide information to + * @ref TRP_trb functions for printing the Tree diagram. + * + * @subsubsection TRP_trop trop + * Functions for Obtaining information from Parsed schema tree. + * + * @subsubsection TRP_troc troc + * Functions for Obtaining information from Compiled schema tree. + * + * @subsubsection TRP_trp trp + * Print functions take care of the printing YANG diagram. They can + * also split one node into multiple lines if the node does not fit + * on one line. + * + * @subsubsection TRP_trt trt + * Data type marking in the printer_tree module. + * + * @subsubsection TRP_trg trg + * General functions. + * + * @subsection TRP_ADJUSTMENTS Adjustments + * It is assumed that the changes are likely to take place mainly for + * @ref TRP_tro, @ref TRP_trop or @ref TRP_troc functions because + * they are the only ones dependent on libyang implementation. + * In special cases, changes will also need to be made to the + * @ref TRP_trp functions if a special algorithm is needed to print + * (right now this is prepared for printing list's keys + * and if-features). + */ + +#include <assert.h> +#include <string.h> + +#include "common.h" +#include "compat.h" +#include "out_internal.h" +#include "plugins_exts.h" +#include "plugins_types.h" +#include "printer_internal.h" +#include "printer_schema.h" +#include "tree_schema_internal.h" +#include "xpath.h" + +/** + * @brief List of available actions. + */ +typedef enum { + TRD_PRINT = 0, /**< Normal behavior. It just prints. */ + TRD_CHAR_COUNT /**< Characters will be counted instead of printing. */ +} trt_ly_out_clb_arg_flag; + +/** + * @brief Structure is passed as 'writeclb' argument + * to the ::ly_out_new_clb(). + */ +struct ly_out_clb_arg { + trt_ly_out_clb_arg_flag mode; /**< flag specifying which action to take. */ + struct ly_out *out; /**< The ly_out pointer delivered to the printer tree module via the main interface. */ + size_t counter; /**< Counter of printed characters. */ + LY_ERR last_error; /**< The last error that occurred. If no error has occurred, it will be ::LY_SUCCESS. */ +}; + +/** + * @brief Initialize struct ly_out_clb_arg with default settings. + */ +#define TRP_INIT_LY_OUT_CLB_ARG(MODE, OUT, COUNTER, LAST_ERROR) \ + (struct ly_out_clb_arg) { \ + .mode = MODE, .out = OUT, \ + .counter = COUNTER, .last_error = LAST_ERROR \ + } + +/********************************************************************** + * Print getters + *********************************************************************/ + +/** + * @brief Callback functions that prints special cases. + * + * It just groups together tree context with trt_fp_print. + */ +struct trt_cf_print { + const struct trt_tree_ctx *ctx; /**< Context of libyang tree. */ + + void (*pf)(const struct trt_tree_ctx *, struct ly_out *); /**< Pointing to function which printing list's keys or features. */ +}; + +/** + * @brief Callback functions for printing special cases. + * + * Functions with the suffix 'trp' can print most of the text on + * output, just by setting the pointer to the string. But in some + * cases, it's not that simple, because its entire string is fragmented + * in memory. For example, for printing list's keys or if-features. + * However, this depends on how the libyang library is implemented. + * This implementation of the printer_tree module goes through + * a lysp tree, but if it goes through a lysc tree, these special cases + * would be different. + * Functions must print including spaces or delimiters between names. + */ +struct trt_fp_print { + void (*print_features_names)(const struct trt_tree_ctx *, struct ly_out *); /**< Print list of features without {}? wrapper. */ + void (*print_keys)(const struct trt_tree_ctx *, struct ly_out *); /**< Print list's keys without [] wrapper. */ +}; + +/** + * @brief Package which only groups getter function. + */ +struct trt_pck_print { + const struct trt_tree_ctx *tree_ctx; /**< Context of libyang tree. */ + struct trt_fp_print fps; /**< Print function. */ +}; + +/** + * @brief Initialize struct trt_pck_print by parameters. + */ +#define TRP_INIT_PCK_PRINT(TREE_CTX, FP_PRINT) \ + (struct trt_pck_print) {.tree_ctx = TREE_CTX, .fps = FP_PRINT} + +/********************************************************************** + * Indent + *********************************************************************/ + +/** + * @brief Constants which are defined in the RFC or are observable + * from the pyang tool. + */ +typedef enum { + TRD_INDENT_EMPTY = 0, /**< If the node is a case node, there is no space before the \<name\>. */ + TRD_INDENT_LONG_LINE_BREAK = 2, /**< The new line should be indented so that it starts below \<name\> with + a whitespace offset of at least two characters. */ + TRD_INDENT_LINE_BEGIN = 2, /**< Indent below the keyword (module, augment ...). */ + TRD_INDENT_BTW_SIBLINGS = 2, /**< Indent between | and | characters. */ + TRD_INDENT_BEFORE_KEYS = 1, /**< "..."___\<keys\>. */ + TRD_INDENT_BEFORE_TYPE = 4, /**< "..."___\<type\>, but if mark is set then indent == 3. */ + TRD_INDENT_BEFORE_IFFEATURES = 1 /**< "..."___\<iffeatures\>. */ +} trt_cnf_indent; + +/** + * @brief Type of indent in node. + */ +typedef enum { + TRD_INDENT_IN_NODE_NORMAL = 0, /**< Node fits on one line. */ + TRD_INDENT_IN_NODE_DIVIDED, /**< The node must be split into multiple rows. */ + TRD_INDENT_IN_NODE_FAILED /**< Cannot be crammed into one line. The condition for the maximum line length is violated. */ +} trt_indent_in_node_type; + +/** Constant to indicate the need to break a line. */ +#define TRD_LINEBREAK -1 + +/** + * @brief Records the alignment between the individual + * elements of the node. + * + * @see trp_default_indent_in_node, trp_try_normal_indent_in_node + */ +struct trt_indent_in_node { + trt_indent_in_node_type type; /**< Type of indent in node. */ + int16_t btw_name_opts; /**< Indent between node name and \<opts\>. */ + int16_t btw_opts_type; /**< Indent between \<opts\> and \<type\>. */ + int16_t btw_type_iffeatures; /**< Indent between type and features. Ignored if \<type\> missing. */ +}; + +/** + * @brief Type of wrappers to be printed. + */ +typedef enum { + TRD_WRAPPER_TOP = 0, /**< Related to the module. */ + TRD_WRAPPER_BODY /**< Related to e.g. Augmentations or Groupings */ +} trd_wrapper_type; + +/** + * @brief For resolving sibling symbol ('|') placement. + * + * Bit indicates where the sibling symbol must be printed. + * This place is in multiples of ::TRD_INDENT_BTW_SIBLINGS. + * + * @see TRP_INIT_WRAPPER_TOP, TRP_INIT_WRAPPER_BODY, + * trp_wrapper_set_mark, trp_wrapper_set_shift, + * trp_wrapper_if_last_sibling, trp_wrapper_eq, trp_print_wrapper + */ +struct trt_wrapper { + trd_wrapper_type type; /**< Location of the wrapper. */ + uint64_t bit_marks1; /**< The set bits indicate where the '|' character is to be printed. + It follows that the maximum immersion of the printable node is 64. */ + uint32_t actual_pos; /**< Actual position in bit_marks. */ +}; + +/** + * @brief Get wrapper related to the module section. + * + * @code + * module: <module-name> + * +--<node> + * | + * @endcode + */ +#define TRP_INIT_WRAPPER_TOP \ + (struct trt_wrapper) { \ + .type = TRD_WRAPPER_TOP, .actual_pos = 0, .bit_marks1 = 0 \ + } + +/** + * @brief Get wrapper related to subsection + * e.g. Augmenations or Groupings. + * + * @code + * module: <module-name> + * +--<node> + * + * augment <target-node>: + * +--<node> + * @endcode + */ +#define TRP_INIT_WRAPPER_BODY \ + (struct trt_wrapper) { \ + .type = TRD_WRAPPER_BODY, .actual_pos = 0, .bit_marks1 = 0 \ + } + +/** + * @brief Package which only groups wrapper and indent in node. + */ +struct trt_pck_indent { + struct trt_wrapper wrapper; /**< Coded " | | " sequence. */ + struct trt_indent_in_node in_node; /**< Indent in node. */ +}; + +/** + * @brief Initialize struct trt_pck_indent by parameters. + */ +#define TRP_INIT_PCK_INDENT(WRAPPER, INDENT_IN_NODE) \ + (struct trt_pck_indent){ \ + .wrapper = WRAPPER, .in_node = INDENT_IN_NODE \ + } + +/********************************************************************** + * flags + *********************************************************************/ + +#define TRD_FLAGS_TYPE_EMPTY "--" +#define TRD_FLAGS_TYPE_RW "rw" +#define TRD_FLAGS_TYPE_RO "ro" +#define TRD_FLAGS_TYPE_RPC_INPUT_PARAMS "-w" +#define TRD_FLAGS_TYPE_USES_OF_GROUPING "-u" +#define TRD_FLAGS_TYPE_RPC "-x" +#define TRD_FLAGS_TYPE_NOTIF "-n" +#define TRD_FLAGS_TYPE_MOUNT_POINT "mp" + +/********************************************************************** + * node_name and opts + *********************************************************************/ + +#define TRD_NODE_NAME_PREFIX_CHOICE "(" +#define TRD_NODE_NAME_PREFIX_CASE ":(" +#define TRD_NODE_NAME_TRIPLE_DOT "..." + +/** + * @brief Type of the node. + * + * Used mainly to complete the correct \<opts\> next to or + * around the \<name\>. + */ +typedef enum { + TRD_NODE_ELSE = 0, /**< For some node which does not require special treatment. \<name\> */ + TRD_NODE_CASE, /**< For case node. :(\<name\>) */ + TRD_NODE_CHOICE, /**< For choice node. (\<name\>) */ + TRD_NODE_TRIPLE_DOT /**< For collapsed sibling nodes and their children. Special case which doesn't belong here very well. */ +} trt_node_type; + +#define TRD_NODE_OPTIONAL "?" /**< For an optional leaf, anydata, or anyxml. \<name\>? */ +#define TRD_NODE_CONTAINER "!" /**< For a presence container. \<name\>! */ +#define TRD_NODE_LISTLEAFLIST "*" /**< For a leaf-list or list. \<name\>* */ + +/** + * @brief Type of node and his name. + * + * @see TRP_EMPTY_NODE_NAME, TRP_NODE_NAME_IS_EMPTY, + * trp_print_node_name, trp_mark_is_used, trp_print_opts_keys + */ +struct trt_node_name { + trt_node_type type; /**< Type of the node relevant for printing. */ + ly_bool keys; /**< Set to 1 if [\<keys\>] are to be printed. Valid for some types only. */ + const char *module_prefix; /**< If the node is augmented into the tree from another module, + so this is the prefix of that module. */ + const char *str; /**< Name of the node. */ + const char *add_opts; /**< Additional opts symbol from plugin. */ + const char *opts; /**< The \<opts\> symbol. */ +}; + +/** + * @brief Create struct trt_node_name as empty. + */ +#define TRP_EMPTY_NODE_NAME \ + (struct trt_node_name) { \ + .type = TRD_NODE_ELSE, .keys = 0, .module_prefix = NULL, .str = NULL, .opts = NULL, .add_opts = NULL \ + } + +/** + * @brief Check if struct trt_node_name is empty. + */ +#define TRP_NODE_NAME_IS_EMPTY(NODE_NAME) \ + !NODE_NAME.str + +/********************************************************************** + * type + *********************************************************************/ + +/** + * @brief Type of the \<type\> + */ +typedef enum { + TRD_TYPE_NAME = 0, /**< Type is just a name that does not require special treatment. */ + TRD_TYPE_TARGET, /**< Should have a form "-> TARGET", where TARGET is the leafref path. */ + TRD_TYPE_LEAFREF, /**< This type is set automatically by the 'trp' algorithm. + So set type as ::TRD_TYPE_TARGET. */ + TRD_TYPE_EMPTY /**< Type is not used at all. */ +} trt_type_type; + +/** + * @brief \<type\> in the \<node\>. + * + * @see TRP_EMPTY_TRT_TYPE, TRP_TRT_TYPE_IS_EMPTY, trp_print_type + */ +struct trt_type { + trt_type_type type; /**< Type of the \<type\>. */ + const char *str; /**< Path or name of the type. */ +}; + +/** + * @brief Create empty struct trt_type. + */ +#define TRP_EMPTY_TRT_TYPE \ + (struct trt_type) {.type = TRD_TYPE_EMPTY, .str = NULL} + +/** + * @brief Check if struct trt_type is empty. + */ +#define TRP_TRT_TYPE_IS_EMPTY(TYPE_OF_TYPE) \ + TYPE_OF_TYPE.type == TRD_TYPE_EMPTY + +/** + * @brief Initialize struct trt_type by parameters. + */ +#define TRP_INIT_TRT_TYPE(TYPE_OF_TYPE, STRING) \ + (struct trt_type) {.type = TYPE_OF_TYPE, .str = STRING} + +/** + * @brief If-feature type. + */ +typedef enum { + TRD_IFF_NON_PRESENT = 0, /**< iffeatures are not present. */ + TRD_IFF_PRESENT, /**< iffeatures are present and will be printed by + trt_fp_print.print_features_names callback */ + TRD_IFF_OVERR /**< iffeatures are override by plugin */ +} trt_iffeatures_type; + +/** + * @brief \<if-features\>. + */ +struct trt_iffeatures { + trt_iffeatures_type type; /**< Type of iffeature. */ + char *str; /**< iffeatures string ready to print. Set if TRD_IFF_OVERR is set. */ +}; + +/** + * @brief Create empty iffeatures. + */ +#define TRP_EMPTY_TRT_IFFEATURES \ + (struct trt_iffeatures) {.type = TRD_IFF_NON_PRESENT} + +/** + * @brief Check if iffeatures is empty. + * + * @param[in] IFF_TYPE value from trt_iffeatures.type. + * @return 1 if is empty. + */ +#define TRP_EMPTY_TRT_IFFEATURES_IS_EMPTY(IFF_TYPE) \ + (IFF_TYPE == TRD_IFF_NON_PRESENT) + +/********************************************************************** + * node + *********************************************************************/ + +/** + * @brief \<node\> data for printing. + * + * It contains RFC's: + * \<status\>--\<flags\> \<name\>\<opts\> \<type\> \<if-features\>. + * Item \<opts\> is moved to part struct trt_node_name. + * For printing [\<keys\>] and if-features is required special + * functions which prints them. + * + * @see TRP_EMPTY_NODE, trp_node_is_empty, trp_node_body_is_empty, + * trp_print_node_up_to_name, trp_print_divided_node_up_to_name, + * trp_print_node + */ +struct trt_node { + const char *status; /**< \<status\>. */ + const char *flags; /**< \<flags\>. */ + struct trt_node_name name; /**< \<node\> with \<opts\> mark or [\<keys\>]. */ + struct trt_type type; /**< \<type\> contains the name of the type or type for leafref. */ + struct trt_iffeatures iffeatures; /**< \<if-features\>. */ + ly_bool last_one; /**< Information about whether the node is the last. */ +}; + +/** + * @brief Create struct trt_node as empty. + */ +#define TRP_EMPTY_NODE \ + (struct trt_node) { \ + .status = NULL, \ + .flags = NULL, \ + .name = TRP_EMPTY_NODE_NAME, \ + .type = TRP_EMPTY_TRT_TYPE, \ + .iffeatures = TRP_EMPTY_TRT_IFFEATURES, \ + .last_one = 1 \ + } + +/** + * @brief Package which only groups indent and node. + */ +struct trt_pair_indent_node { + struct trt_indent_in_node indent; + struct trt_node node; +}; + +/** + * @brief Initialize struct trt_pair_indent_node by parameters. + */ +#define TRP_INIT_PAIR_INDENT_NODE(INDENT_IN_NODE, NODE) \ + (struct trt_pair_indent_node) { \ + .indent = INDENT_IN_NODE, .node = NODE \ + } + +/********************************************************************** + * statement + *********************************************************************/ + +#define TRD_KEYWORD_MODULE "module" +#define TRD_KEYWORD_SUBMODULE "submodule" +#define TRD_KEYWORD_AUGMENT "augment" +#define TRD_KEYWORD_RPC "rpcs" +#define TRD_KEYWORD_NOTIF "notifications" +#define TRD_KEYWORD_GROUPING "grouping" + +/** + * @brief Main sign of the tree nodes. + * + * @see TRP_EMPTY_KEYWORD_STMT, TRP_KEYWORD_STMT_IS_EMPTY + * trt_print_keyword_stmt_begin, trt_print_keyword_stmt_str, + * trt_print_keyword_stmt_end, trp_print_keyword_stmt + */ +struct trt_keyword_stmt { + const char *section_name; /**< String containing section name. */ + const char *argument; /**< Name or path located begind section name. */ + ly_bool has_node; /**< Flag if section has any nodes. */ +}; + +/** + * @brief Create struct trt_keyword_stmt as empty. + */ +#define TRP_EMPTY_KEYWORD_STMT \ + (struct trt_keyword_stmt) {.section_name = NULL, .argument = NULL, .has_node = 0} + +/********************************************************************** + * Modify getters + *********************************************************************/ + +struct trt_parent_cache; + +/** + * @brief Functions that change the state of the tree_ctx structure. + * + * The 'trop' or 'troc' functions are set here, which provide data + * for the 'trp' printing functions and are also called from the + * 'trb' browsing functions when walking through a tree. These callback + * functions need to be checked or reformulated if changes to the + * libyang library affect the printing tree. For all, if the value + * cannot be returned, its empty version obtained by relevant TRP_EMPTY + * macro is returned. + */ +struct trt_fp_modify_ctx { + ly_bool (*parent)(struct trt_tree_ctx *); /**< Jump to parent node. Return true if parent exists. */ + struct trt_node (*first_sibling)(struct trt_parent_cache, struct trt_tree_ctx *); /**< Jump on the first of the siblings. */ + struct trt_node (*next_sibling)(struct trt_parent_cache, struct trt_tree_ctx *); /**< Jump to next sibling of the current node. */ + struct trt_node (*next_child)(struct trt_parent_cache, struct trt_tree_ctx *); /**< Jump to the child of the current node. */ +}; + +/** + * @brief Create modify functions for compiled tree. + */ +#define TRP_TRT_FP_MODIFY_COMPILED \ + (struct trt_fp_modify_ctx) { \ + .parent = troc_modi_parent, \ + .first_sibling = troc_modi_first_sibling, \ + .next_sibling = troc_modi_next_sibling, \ + .next_child = troc_modi_next_child, \ + } + +/** + * @brief Create modify functions for parsed tree. + */ +#define TRP_TRT_FP_MODIFY_PARSED \ + (struct trt_fp_modify_ctx) { \ + .parent = trop_modi_parent, \ + .first_sibling = trop_modi_first_sibling, \ + .next_sibling = trop_modi_next_sibling, \ + .next_child = trop_modi_next_child, \ + } + +/********************************************************************** + * Read getters + *********************************************************************/ + +/** + * @brief Functions that do not change the state of the tree_structure. + * + * For details see trt_fp_modify_ctx. + */ +struct trt_fp_read { + struct trt_keyword_stmt (*module_name)(const struct trt_tree_ctx *); /**< Get name of the module. */ + struct trt_node (*node)(struct trt_parent_cache, struct trt_tree_ctx *); /**< Get current node. */ + ly_bool (*if_sibling_exists)(const struct trt_tree_ctx *); /**< Check if node's sibling exists. */ + ly_bool (*if_parent_exists)(const struct trt_tree_ctx *); /**< Check if node's parent exists. */ +}; + +/** + * @brief Create read functions for compiled tree. + */ +#define TRP_TRT_FP_READ_COMPILED \ + (struct trt_fp_read) { \ + .module_name = tro_read_module_name, \ + .node = troc_read_node, \ + .if_sibling_exists = troc_read_if_sibling_exists, \ + .if_parent_exists = tro_read_if_sibling_exists \ + } + +/** + * @brief Create read functions for parsed tree. + */ +#define TRP_TRT_FP_READ_PARSED \ + (struct trt_fp_read) { \ + .module_name = tro_read_module_name, \ + .node = trop_read_node, \ + .if_sibling_exists = trop_read_if_sibling_exists, \ + .if_parent_exists = tro_read_if_sibling_exists \ + } + +/********************************************************************** + * All getters + *********************************************************************/ + +/** + * @brief A set of all necessary functions that must be provided + * for the printer. + */ +struct trt_fp_all { + struct trt_fp_modify_ctx modify; /**< Function pointers which modify state of trt_tree_ctx. */ + struct trt_fp_read read; /**< Function pointers which only reads state of trt_tree_ctx. */ + struct trt_fp_print print; /**< Functions pointers for printing special items in node. */ +}; + +/********************************************************************** + * Printer context + *********************************************************************/ + +/** + * @brief Main structure for @ref TRP_trp part. + */ +struct trt_printer_ctx { + struct ly_out *out; /**< Handler to printing. */ + struct trt_fp_all fp; /**< @ref TRP_tro functions callbacks. */ + size_t max_line_length; /**< The maximum number of characters that can be + printed on one line, including the last. */ +}; + +/********************************************************************** + * Tro functions + *********************************************************************/ + +/** + * @brief The name of the section to which the node belongs. + */ +typedef enum { + TRD_SECT_MODULE = 0, /**< The node belongs to the "module: <module_name>:" label. */ + TRD_SECT_AUGMENT, /**< The node belongs to some "augment <target-node>:" label. */ + TRD_SECT_RPCS, /**< The node belongs to the "rpcs:" label. */ + TRD_SECT_NOTIF, /**< The node belongs to the "notifications:" label. */ + TRD_SECT_GROUPING, /**< The node belongs to some "grouping <grouping-name>:" label. */ + TRD_SECT_PLUG_DATA /**< The node belongs to some plugin section. */ +} trt_actual_section; + +/** + * @brief Types of nodes that have some effect on their children. + */ +typedef enum { + TRD_ANCESTOR_ELSE = 0, /**< Everything not listed. */ + TRD_ANCESTOR_RPC_INPUT, /**< ::LYS_INPUT */ + TRD_ANCESTOR_RPC_OUTPUT, /**< ::LYS_OUTPUT */ + TRD_ANCESTOR_NOTIF /**< ::LYS_NOTIF */ +} trt_ancestor_type; + +/** + * @brief Saved information when browsing the tree downwards. + * + * This structure helps prevent frequent retrieval of information + * from the tree. Functions @ref TRP_trb are designed to preserve + * this structures during their recursive calls. This functions do not + * interfere in any way with this data. This structure + * is used by @ref TRP_trop functions which, thanks to this + * structure, can return a node with the correct data. The word + * \b parent is in the structure name, because this data refers to + * the last parent and at the same time the states of its + * ancestors data. Only the function jumping on the child + * (next_child(...)) creates this structure, because the pointer + * to the current node moves down the tree. It's like passing + * the genetic code to children. Some data must be inherited and + * there are two approaches to this problem. Either it will always + * be determined which inheritance states belong to the current node + * (which can lead to regular travel to the root node) or + * the inheritance states will be stored during the recursive calls. + * So the problem was solved by the second option. Why does + * the structure contain this data? Because it walks through + * the lysp tree. For walks through the lysc tree is trt_parent_cache + * useless. + * + * @see TRO_EMPTY_PARENT_CACHE, tro_parent_cache_for_child + */ +struct trt_parent_cache { + trt_ancestor_type ancestor; /**< Some types of nodes have a special effect on their children. */ + uint16_t lys_status; /**< Inherited status CURR, DEPRC, OBSLT. */ + uint16_t lys_config; /**< Inherited config W or R. */ + const struct lysp_node_list *last_list; /**< The last ::LYS_LIST passed. */ +}; + +/** + * @brief Return trt_parent_cache filled with default values. + */ +#define TRP_EMPTY_PARENT_CACHE \ + (struct trt_parent_cache) { \ + .ancestor = TRD_ANCESTOR_ELSE, .lys_status = LYS_STATUS_CURR, \ + .lys_config = LYS_CONFIG_W, .last_list = NULL \ + } + +/** + * @brief Node override from plugin. + */ +struct lyplg_ext_sprinter_tree_node_override { + const char *flags; /**< Override for \<flags\>. */ + const char *add_opts; /**< Additional symbols for \<opts\>. */ +}; + +/** + * @brief Context for plugin extension. + */ +struct trt_plugin_ctx { + struct lyspr_tree_ctx *ctx; /**< Pointer to main context. */ + struct lyspr_tree_schema *schema; /**< Current schema to print. */ + ly_bool filtered; /**< Flag if current node is filtered. */ + struct lyplg_ext_sprinter_tree_node_override node_overr; /**< Current node override. */ + ly_bool last_schema; /**< Flag if schema is last. */ + ly_bool last_error; /**< Last error from plugin. */ +}; + +/** + * @brief Main structure for browsing the libyang tree + */ +struct trt_tree_ctx { + ly_bool lysc_tree; /**< The lysc nodes are used for browsing through the tree. + It is assumed that once set, it does not change. + If it is true then trt_tree_ctx.pn and + trt_tree_ctx.tpn are not used. + If it is false then trt_tree_ctx.cn is not used. */ + trt_actual_section section; /**< To which section pn points. */ + const struct lysp_module *pmod; /**< Parsed YANG schema tree. */ + const struct lysc_module *cmod; /**< Compiled YANG schema tree. */ + const struct lysp_node *pn; /**< Actual pointer to parsed node. */ + const struct lysp_node *tpn; /**< Pointer to actual top-node. */ + const struct lysc_node *cn; /**< Actual pointer to compiled node. */ + LY_ERR last_error; /**< Error value during printing. */ + + struct trt_plugin_ctx plugin_ctx; /**< Context for plugin. */ +}; + +/** + * @brief Create empty node override. + */ +#define TRP_TREE_CTX_EMPTY_NODE_OVERR \ + (struct lyplg_ext_sprinter_tree_node_override) { \ + .flags = NULL, \ + .add_opts = NULL, \ + } + +/** + * @brief Check if lysp node is available from + * the current compiled node. + * + * Use only if trt_tree_ctx.lysc_tree is set to true. + */ +#define TRP_TREE_CTX_LYSP_NODE_PRESENT(CN) \ + (CN->priv) + +/** + * @brief Get lysp_node from trt_tree_ctx.cn. + * + * Use only if :TRP_TREE_CTX_LYSP_NODE_PRESENT returns true + * for that node. + */ +#define TRP_TREE_CTX_GET_LYSP_NODE(CN) \ + ((const struct lysp_node *)CN->priv) + +/** Getter function for ::trop_node_charptr(). */ +typedef const char *(*trt_get_charptr_func)(const struct lysp_node *pn); + +/** + * @brief Simple getter functions for lysp and lysc nodes. + * + * This structure is useful if we have a general algorithm + * (tro function) that can be used for both lysc and lysp nodes. + * Thanks to this structure, we prevent code redundancy. + * We don't have to write basically the same algorithm twice + * for lysp and lysc trees. + */ +struct tro_getters { + uint16_t (*nodetype)(const void *); /**< Get nodetype. */ + const void *(*next)(const void *); /**< Get sibling. */ + const void *(*parent)(const void *); /**< Get parent. */ + const void *(*child)(const void *); /**< Get child. */ + const void *(*actions)(const void *); /**< Get actions. */ + const void *(*action_input)(const void *); /**< Get input action from action node. */ + const void *(*action_output)(const void *); /**< Get output action from action node. */ + const void *(*notifs)(const void *); /**< Get notifs. */ +}; + +/********************************************************************** + * Definition of the general Trg functions + *********************************************************************/ + +/** + * @brief Print a substring but limited to the maximum length. + * @param[in] str is pointer to source. + * @param[in] len is number of characters to be printed. + * @param[in,out] out is output handler. + * @return str parameter shifted by len. + */ +static const char * +trg_print_substr(const char *str, size_t len, struct ly_out *out) +{ + for (size_t i = 0; i < len; i++) { + ly_print_(out, "%c", str[0]); + str++; + } + return str; +} + +/** + * @brief Pointer is not NULL and does not point to an empty string. + * @param[in] str is pointer to string to be checked. + * @return 1 if str pointing to non empty string otherwise 0. + */ +static ly_bool +trg_charptr_has_data(const char *str) +{ + return (str) && (str[0] != '\0'); +} + +/** + * @brief Check if @p word in @p src is present where words are + * delimited by @p delim. + * @param[in] src is source where words are separated by @p delim. + * @param[in] word to be searched. + * @param[in] delim is delimiter between @p words in @p src. + * @return 1 if src contains @p word otherwise 0. + */ +static ly_bool +trg_word_is_present(const char *src, const char *word, char delim) +{ + const char *hit; + + if ((!src) || (src[0] == '\0') || (!word)) { + return 0; + } + + hit = strstr(src, word); + + if (hit) { + /* word was founded at the begin of src + * OR it match somewhere after delim + */ + if ((hit == src) || (hit[-1] == delim)) { + /* end of word was founded at the end of src + * OR end of word was match somewhere before delim + */ + char delim_or_end = (hit + strlen(word))[0]; + + if ((delim_or_end == '\0') || (delim_or_end == delim)) { + return 1; + } + } + /* after -> hit is just substr and it's not the whole word */ + /* jump to the next word */ + for ( ; (src[0] != '\0') && (src[0] != delim); src++) {} + /* skip delim */ + src = src[0] == '\0' ? src : src + 1; + /* continue with searching */ + return trg_word_is_present(src, word, delim); + } else { + return 0; + } +} + +/********************************************************************** + * Definition of printer functions + *********************************************************************/ + +/** + * @brief Write callback for ::ly_out_new_clb(). + * + * @param[in] user_data is type of struct ly_out_clb_arg. + * @param[in] buf contains input characters + * @param[in] count is number of characters in buf. + * @return Number of printed bytes. + * @return Negative value in case of error. + */ +static ssize_t +trp_ly_out_clb_func(void *user_data, const void *buf, size_t count) +{ + LY_ERR erc = LY_SUCCESS; + struct ly_out_clb_arg *data = (struct ly_out_clb_arg *)user_data; + + switch (data->mode) { + case TRD_PRINT: + erc = ly_write_(data->out, buf, count); + break; + case TRD_CHAR_COUNT: + data->counter = data->counter + count; + break; + default: + break; + } + + if (erc != LY_SUCCESS) { + data->last_error = erc; + return -1; + } else { + return count; + } +} + +/** + * @brief Check that indent in node can be considered as equivalent. + * @param[in] first is the first indent in node. + * @param[in] second is the second indent in node. + * @return 1 if indents are equivalent otherwise 0. + */ +static ly_bool +trp_indent_in_node_are_eq(struct trt_indent_in_node first, struct trt_indent_in_node second) +{ + const ly_bool a = first.type == second.type; + const ly_bool b = first.btw_name_opts == second.btw_name_opts; + const ly_bool c = first.btw_opts_type == second.btw_opts_type; + const ly_bool d = first.btw_type_iffeatures == second.btw_type_iffeatures; + + return a && b && c && d; +} + +/** + * @brief Setting space character because node is last sibling. + * @param[in] wr is wrapper over which the shift operation + * is to be performed. + * @return New shifted wrapper. + */ +static struct trt_wrapper +trp_wrapper_set_shift(struct trt_wrapper wr) +{ + assert(wr.actual_pos < 64); + /* +--<node> + * +--<node> + */ + wr.actual_pos++; + return wr; +} + +/** + * @brief Setting '|' symbol because node is divided or + * it is not last sibling. + * @param[in] wr is source of wrapper. + * @return New wrapper which is marked at actual position and shifted. + */ +static struct trt_wrapper +trp_wrapper_set_mark(struct trt_wrapper wr) +{ + assert(wr.actual_pos < 64); + wr.bit_marks1 |= 1U << wr.actual_pos; + return trp_wrapper_set_shift(wr); +} + +/** + * @brief Setting ' ' symbol if node is last sibling otherwise set '|'. + * @param[in] wr is actual wrapper. + * @param[in] last_one is flag. Value 1 saying if the node is the last + * and has no more siblings. + * @return New wrapper for the actual node. + */ +static struct trt_wrapper +trp_wrapper_if_last_sibling(struct trt_wrapper wr, ly_bool last_one) +{ + return last_one ? trp_wrapper_set_shift(wr) : trp_wrapper_set_mark(wr); +} + +/** + * @brief Test if the wrappers are equivalent. + * @param[in] first is the first wrapper. + * @param[in] second is the second wrapper. + * @return 1 if the wrappers are equivalent otherwise 0. + */ +static ly_bool +trp_wrapper_eq(struct trt_wrapper first, struct trt_wrapper second) +{ + const ly_bool a = first.type == second.type; + const ly_bool b = first.bit_marks1 == second.bit_marks1; + const ly_bool c = first.actual_pos == second.actual_pos; + + return a && b && c; +} + +/** + * @brief Print " | " sequence on line. + * @param[in] wr is wrapper to be printed. + * @param[in,out] out is output handler. + */ +static void +trp_print_wrapper(struct trt_wrapper wr, struct ly_out *out) +{ + uint32_t lb; + + if (wr.type == TRD_WRAPPER_TOP) { + lb = TRD_INDENT_LINE_BEGIN; + } else if (wr.type == TRD_WRAPPER_BODY) { + lb = TRD_INDENT_LINE_BEGIN * 2; + } else { + lb = TRD_INDENT_LINE_BEGIN; + } + + ly_print_(out, "%*c", lb, ' '); + + if (trp_wrapper_eq(wr, TRP_INIT_WRAPPER_TOP)) { + return; + } + + for (uint32_t i = 0; i < wr.actual_pos; i++) { + /** Test if the bit on the index is set. */ + if ((wr.bit_marks1 >> i) & 1U) { + ly_print_(out, "|"); + } else { + ly_print_(out, " "); + } + + if (i != wr.actual_pos) { + ly_print_(out, "%*c", TRD_INDENT_BTW_SIBLINGS, ' '); + } + } +} + +/** + * @brief Check if struct trt_node is empty. + * @param[in] node is item to test. + * @return 1 if node is considered empty otherwise 0. + */ +static ly_bool +trp_node_is_empty(const struct trt_node *node) +{ + const ly_bool a = TRP_EMPTY_TRT_IFFEATURES_IS_EMPTY(node->iffeatures.type); + const ly_bool b = TRP_TRT_TYPE_IS_EMPTY(node->type); + const ly_bool c = TRP_NODE_NAME_IS_EMPTY(node->name); + const ly_bool d = node->flags == NULL; + const ly_bool e = node->status == NULL; + + return a && b && c && d && e; +} + +/** + * @brief Check if [\<keys\>], \<type\> and + * \<iffeatures\> are empty/not_set. + * @param[in] node is item to test. + * @return 1 if node has no \<keys\> \<type\> or \<iffeatures\> + * otherwise 0. + */ +static ly_bool +trp_node_body_is_empty(const struct trt_node *node) +{ + const ly_bool a = TRP_EMPTY_TRT_IFFEATURES_IS_EMPTY(node->iffeatures.type); + const ly_bool b = TRP_TRT_TYPE_IS_EMPTY(node->type); + const ly_bool c = !node->name.keys; + + return a && b && c; +} + +/** + * @brief Print entire struct trt_node_name structure. + * @param[in] node_name is item to print. + * @param[in,out] out is output handler. + */ +static void +trp_print_node_name(struct trt_node_name node_name, struct ly_out *out) +{ + const char *mod_prefix; + const char *colon; + const char trd_node_name_suffix_choice[] = ")"; + const char trd_node_name_suffix_case[] = ")"; + + if (TRP_NODE_NAME_IS_EMPTY(node_name)) { + return; + } + + if (node_name.module_prefix) { + mod_prefix = node_name.module_prefix; + colon = ":"; + } else { + mod_prefix = ""; + colon = ""; + } + + switch (node_name.type) { + case TRD_NODE_ELSE: + ly_print_(out, "%s%s%s", mod_prefix, colon, node_name.str); + break; + case TRD_NODE_CASE: + ly_print_(out, "%s%s%s%s%s", TRD_NODE_NAME_PREFIX_CASE, mod_prefix, colon, node_name.str, trd_node_name_suffix_case); + break; + case TRD_NODE_CHOICE: + ly_print_(out, "%s%s%s%s%s", TRD_NODE_NAME_PREFIX_CHOICE, mod_prefix, colon, node_name.str, trd_node_name_suffix_choice); + break; + case TRD_NODE_TRIPLE_DOT: + ly_print_(out, "%s", TRD_NODE_NAME_TRIPLE_DOT); + break; + default: + break; + } + + if (node_name.add_opts) { + ly_print_(out, "%s", node_name.add_opts); + } + if (node_name.opts) { + ly_print_(out, "%s", node_name.opts); + } +} + +/** + * @brief Check if mark (?, !, *, /, @) is implicitly contained in + * struct trt_node_name. + * @param[in] node_name is structure containing the 'mark'. + * @return 1 if contain otherwise 0. + */ +static ly_bool +trp_mark_is_used(struct trt_node_name node_name) +{ + if (TRP_NODE_NAME_IS_EMPTY(node_name)) { + return 0; + } else if (node_name.keys) { + return 0; + } + + switch (node_name.type) { + case TRD_NODE_ELSE: + case TRD_NODE_CASE: + return 0; + default: + if (node_name.add_opts || node_name.opts) { + return 1; + } else { + return 0; + } + } +} + +/** + * @brief Print opts keys. + * @param[in] node_name contains type of the node with his name. + * @param[in] btw_name_opts is number of spaces between name and [keys]. + * @param[in] cf is basically a pointer to the function that prints + * the keys. + * @param[in,out] out is output handler. + */ +static void +trp_print_opts_keys(struct trt_node_name node_name, int16_t btw_name_opts, struct trt_cf_print cf, struct ly_out *out) +{ + if (!node_name.keys) { + return; + } + + /* <name><mark>___<keys>*/ + if (btw_name_opts > 0) { + ly_print_(out, "%*c", btw_name_opts, ' '); + } + ly_print_(out, "["); + cf.pf(cf.ctx, out); + ly_print_(out, "]"); +} + +/** + * @brief Print entire struct trt_type structure. + * @param[in] type is item to print. + * @param[in,out] out is output handler. + */ +static void +trp_print_type(struct trt_type type, struct ly_out *out) +{ + if (TRP_TRT_TYPE_IS_EMPTY(type)) { + return; + } + + switch (type.type) { + case TRD_TYPE_NAME: + ly_print_(out, "%s", type.str); + break; + case TRD_TYPE_TARGET: + ly_print_(out, "-> %s", type.str); + break; + case TRD_TYPE_LEAFREF: + ly_print_(out, "leafref"); + default: + break; + } +} + +/** + * @brief Print all iffeatures of node + * + * @param[in] iff is iffeatures to print. + * @param[in] cf is basically a pointer to the function that prints the list of features. + * @param[in,out] out is output handler. + */ +static void +trp_print_iffeatures(struct trt_iffeatures iff, struct trt_cf_print cf, struct ly_out *out) +{ + if (iff.type == TRD_IFF_PRESENT) { + ly_print_(out, "{"); + cf.pf(cf.ctx, out); + ly_print_(out, "}?"); + } else if (iff.type == TRD_IFF_OVERR) { + ly_print_(out, "%s", iff.str); + } +} + +/** + * @brief Print just \<status\>--\<flags\> \<name\> with opts mark. + * @param[in] node contains items to print. + * @param[in] out is output handler. + */ +static void +trp_print_node_up_to_name(const struct trt_node *node, struct ly_out *out) +{ + if (node->name.type == TRD_NODE_TRIPLE_DOT) { + trp_print_node_name(node->name, out); + return; + } + /* <status>--<flags> */ + ly_print_(out, "%s", node->status); + ly_print_(out, "--"); + /* If the node is a case node, there is no space before the <name> + * also case node has no flags. + */ + if (node->flags && (node->name.type != TRD_NODE_CASE)) { + ly_print_(out, "%s", node->flags); + ly_print_(out, " "); + } + /* <name> */ + trp_print_node_name(node->name, out); +} + +/** + * @brief Print alignment (spaces) instead of + * \<status\>--\<flags\> \<name\> for divided node. + * @param[in] node contains items to print. + * @param[in] out is output handler. + */ +static void +trp_print_divided_node_up_to_name(const struct trt_node *node, struct ly_out *out) +{ + uint32_t space = strlen(node->flags); + + if (node->name.type == TRD_NODE_CASE) { + /* :(<name> */ + space += strlen(TRD_NODE_NAME_PREFIX_CASE); + } else if (node->name.type == TRD_NODE_CHOICE) { + /* (<name> */ + space += strlen(TRD_NODE_NAME_PREFIX_CHOICE); + } else { + /* _<name> */ + space += strlen(" "); + } + + /* <name> + * __ + */ + space += TRD_INDENT_LONG_LINE_BREAK; + + ly_print_(out, "%*c", space, ' '); +} + +/** + * @brief Print struct trt_node structure. + * @param[in] node is item to print. + * @param[in] pck package of functions for + * printing [\<keys\>] and \<iffeatures\>. + * @param[in] indent is the indent in node. + * @param[in,out] out is output handler. + */ +static void +trp_print_node(const struct trt_node *node, struct trt_pck_print pck, struct trt_indent_in_node indent, struct ly_out *out) +{ + ly_bool triple_dot; + ly_bool divided; + struct trt_cf_print cf_print_keys; + struct trt_cf_print cf_print_iffeatures; + + if (trp_node_is_empty(node)) { + return; + } + + /* <status>--<flags> <name><opts> <type> <if-features> */ + triple_dot = node->name.type == TRD_NODE_TRIPLE_DOT; + divided = indent.type == TRD_INDENT_IN_NODE_DIVIDED; + + if (triple_dot) { + trp_print_node_name(node->name, out); + return; + } else if (!divided) { + trp_print_node_up_to_name(node, out); + } else { + trp_print_divided_node_up_to_name(node, out); + } + + /* <opts> */ + /* <name>___<opts>*/ + cf_print_keys.ctx = pck.tree_ctx; + cf_print_keys.pf = pck.fps.print_keys; + + trp_print_opts_keys(node->name, indent.btw_name_opts, cf_print_keys, out); + + /* <opts>__<type> */ + if (indent.btw_opts_type > 0) { + ly_print_(out, "%*c", indent.btw_opts_type, ' '); + } + + /* <type> */ + trp_print_type(node->type, out); + + /* <type>__<iffeatures> */ + if (indent.btw_type_iffeatures > 0) { + ly_print_(out, "%*c", indent.btw_type_iffeatures, ' '); + } + + /* <iffeatures> */ + cf_print_iffeatures.ctx = pck.tree_ctx; + cf_print_iffeatures.pf = pck.fps.print_features_names; + + trp_print_iffeatures(node->iffeatures, cf_print_iffeatures, out); +} + +/** + * @brief Print keyword based on trt_keyword_stmt.type. + * @param[in] ks is keyword statement to print. + * @param[in,out] out is output handler + */ +static void +trt_print_keyword_stmt_begin(struct trt_keyword_stmt ks, struct ly_out *out) +{ + if (!strcmp(ks.section_name, TRD_KEYWORD_MODULE) || + !strcmp(ks.section_name, TRD_KEYWORD_SUBMODULE)) { + ly_print_(out, "%s: ", ks.section_name); + return; + } + + ly_print_(out, "%*c", TRD_INDENT_LINE_BEGIN, ' '); + if (ks.argument) { + ly_print_(out, "%s ", ks.section_name); + } else { + ly_print_(out, "%s", ks.section_name); + } +} + +/** + * @brief Print trt_keyword_stmt.str which is string of name or path. + * @param[in] ks is keyword statement structure. + * @param[in] mll is max line length. + * @param[in,out] out is output handler. + */ +static void +trt_print_keyword_stmt_str(struct trt_keyword_stmt ks, size_t mll, struct ly_out *out) +{ + uint32_t ind_initial; + uint32_t ind_divided; + /* flag if path must be splitted to more lines */ + ly_bool linebreak_was_set; + /* flag if at least one subpath was printed */ + ly_bool subpath_printed; + /* the sum of the sizes of the substrings on the current line */ + uint32_t how_far; + /* pointer to start of the subpath */ + const char *sub_ptr; + /* size of subpath from sub_ptr */ + size_t sub_len; + + if ((!ks.argument) || (ks.argument[0] == '\0')) { + return; + } + + /* module name cannot be splitted */ + if (!strcmp(ks.section_name, TRD_KEYWORD_MODULE) || !strcmp(ks.section_name, TRD_KEYWORD_SUBMODULE)) { + ly_print_(out, "%s", ks.argument); + return; + } + + /* after -> for trd_keyword_stmt_body do */ + + /* set begin indentation */ + ind_initial = TRD_INDENT_LINE_BEGIN + strlen(ks.section_name) + 1; + ind_divided = ind_initial + TRD_INDENT_LONG_LINE_BREAK; + linebreak_was_set = 0; + subpath_printed = 0; + how_far = 0; + sub_ptr = ks.argument; + sub_len = 0; + + while (sub_ptr[0] != '\0') { + uint32_t ind; + /* skip slash */ + const char *tmp = sub_ptr[0] == '/' ? sub_ptr + 1 : sub_ptr; + + /* get position of the end of substr */ + tmp = strchr(tmp, '/'); + /* set correct size if this is a last substring */ + sub_len = !tmp ? strlen(sub_ptr) : (size_t)(tmp - sub_ptr); + /* actualize sum of the substring's sizes on the current line */ + how_far += sub_len; + /* correction due to colon character if it this is last substring */ + how_far = *(sub_ptr + sub_len) == '\0' ? how_far + 1 : how_far; + /* choose indentation which depends on + * whether the string is printed on multiple lines or not + */ + ind = linebreak_was_set ? ind_divided : ind_initial; + if (ind + how_far <= mll) { + /* printing before max line length */ + sub_ptr = trg_print_substr(sub_ptr, sub_len, out); + subpath_printed = 1; + } else { + /* printing on new line */ + if (subpath_printed == 0) { + /* first subpath is too long + * but print it at first line anyway + */ + sub_ptr = trg_print_substr(sub_ptr, sub_len, out); + subpath_printed = 1; + continue; + } + ly_print_(out, "\n"); + ly_print_(out, "%*c", ind_divided, ' '); + linebreak_was_set = 1; + sub_ptr = trg_print_substr(sub_ptr, sub_len, out); + how_far = sub_len; + subpath_printed = 1; + } + } +} + +/** + * @brief Print separator based on trt_keyword_stmt.type + * @param[in] ks is keyword statement structure. + * @param[in,out] out is output handler. + */ +static void +trt_print_keyword_stmt_end(struct trt_keyword_stmt ks, struct ly_out *out) +{ + if (!strcmp(ks.section_name, TRD_KEYWORD_MODULE) || !strcmp(ks.section_name, TRD_KEYWORD_SUBMODULE)) { + return; + } else if (ks.has_node) { + ly_print_(out, ":"); + } +} + +/** + * @brief Print entire struct trt_keyword_stmt structure. + * @param[in] ks is item to print. + * @param[in] mll is max line length. + * @param[in,out] out is output handler. + */ +static void +trp_print_keyword_stmt(struct trt_keyword_stmt ks, size_t mll, struct ly_out *out) +{ + assert(ks.section_name); + trt_print_keyword_stmt_begin(ks, out); + trt_print_keyword_stmt_str(ks, mll, out); + trt_print_keyword_stmt_end(ks, out); +} + +/********************************************************************** + * Main trp functions + *********************************************************************/ + +/** + * @brief Printing one line including wrapper and node + * which can be incomplete (divided). + * @param[in] node is \<node\> representation. + * @param[in] pck contains special printing functions callback. + * @param[in] indent contains wrapper and indent in node numbers. + * @param[in,out] out is output handler. + */ +static void +trp_print_line(const struct trt_node *node, struct trt_pck_print pck, struct trt_pck_indent indent, struct ly_out *out) +{ + trp_print_wrapper(indent.wrapper, out); + trp_print_node(node, pck, indent.in_node, out); +} + +/** + * @brief Printing one line including wrapper and + * \<status\>--\<flags\> \<name\>\<option_mark\>. + * @param[in] node is \<node\> representation. + * @param[in] wr is wrapper for printing indentation before node. + * @param[in] out is output handler. + */ +static void +trp_print_line_up_to_node_name(const struct trt_node *node, struct trt_wrapper wr, struct ly_out *out) +{ + trp_print_wrapper(wr, out); + trp_print_node_up_to_name(node, out); +} + +/** + * @brief Check if leafref target must be change to string 'leafref' + * because his target string is too long. + * @param[in] node containing leafref target. + * @param[in] wr is wrapper for printing indentation before node. + * @param[in] mll is max line length. + * @param[in] out is output handler. + * @return true if leafref must be changed to string 'leafref'. + */ +static ly_bool +trp_leafref_target_is_too_long(const struct trt_node *node, struct trt_wrapper wr, size_t mll, struct ly_out *out) +{ + size_t type_len; + struct ly_out_clb_arg *data; + + if (node->type.type != TRD_TYPE_TARGET) { + return 0; + } + + /* set ly_out to counting characters */ + data = out->method.clb.arg; + + data->counter = 0; + data->mode = TRD_CHAR_COUNT; + /* count number of printed bytes */ + trp_print_wrapper(wr, out); + ly_print_(out, "%*c", TRD_INDENT_BTW_SIBLINGS, ' '); + trp_print_divided_node_up_to_name(node, out); + data->mode = TRD_PRINT; + type_len = strlen(node->type.str); + + return data->counter + type_len > mll; +} + +/** + * @brief Get default indent in node based on node values. + * @param[in] node is \<node\> representation. + * @return Default indent in node assuming that the node + * will not be divided. + */ +static struct trt_indent_in_node +trp_default_indent_in_node(const struct trt_node *node) +{ + struct trt_indent_in_node ret; + uint32_t opts_len = 0; + + ret.type = TRD_INDENT_IN_NODE_NORMAL; + + /* btw_name_opts */ + ret.btw_name_opts = node->name.keys ? TRD_INDENT_BEFORE_KEYS : 0; + + /* btw_opts_type */ + if (!(TRP_TRT_TYPE_IS_EMPTY(node->type))) { + if (trp_mark_is_used(node->name)) { + opts_len += node->name.add_opts ? strlen(node->name.add_opts) : 0; + opts_len += node->name.opts ? strlen(node->name.opts) : 0; + ret.btw_opts_type = TRD_INDENT_BEFORE_TYPE > opts_len ? 1 : TRD_INDENT_BEFORE_TYPE - opts_len; + } else { + ret.btw_opts_type = TRD_INDENT_BEFORE_TYPE; + } + } else { + ret.btw_opts_type = 0; + } + + /* btw_type_iffeatures */ + ret.btw_type_iffeatures = node->iffeatures.type == TRD_IFF_PRESENT ? TRD_INDENT_BEFORE_IFFEATURES : 0; + + return ret; +} + +/** + * @brief Setting linebreaks in trt_indent_in_node. + * + * The order where the linebreak tag can be placed is from the end. + * + * @param[in] indent containing alignment lengths + * or already linebreak marks. + * @return indent with a newly placed linebreak tag. + * @return .type set to TRD_INDENT_IN_NODE_FAILED if it is not possible + * to place a more linebreaks. + */ +static struct trt_indent_in_node +trp_indent_in_node_place_break(struct trt_indent_in_node indent) +{ + /* somewhere must be set a line break in node */ + struct trt_indent_in_node ret = indent; + + /* gradually break the node from the end */ + if ((indent.btw_type_iffeatures != TRD_LINEBREAK) && (indent.btw_type_iffeatures != 0)) { + ret.btw_type_iffeatures = TRD_LINEBREAK; + } else if ((indent.btw_opts_type != TRD_LINEBREAK) && (indent.btw_opts_type != 0)) { + ret.btw_opts_type = TRD_LINEBREAK; + } else if ((indent.btw_name_opts != TRD_LINEBREAK) && (indent.btw_name_opts != 0)) { + /* set line break between name and opts */ + ret.btw_name_opts = TRD_LINEBREAK; + } else { + /* it is not possible to place a more line breaks, + * unfortunately the max_line_length constraint is violated + */ + ret.type = TRD_INDENT_IN_NODE_FAILED; + } + return ret; +} + +/** + * @brief Set the first half of the node based on the linebreak mark. + * + * Items in the second half of the node will be empty. + * + * @param[in,out] innod contains information in which part of the \<node\> + * the first half ends. Set first half of the node, indent is unchanged. + */ +static void +trp_first_half_node(struct trt_pair_indent_node *innod) +{ + if (innod->indent.btw_name_opts == TRD_LINEBREAK) { + innod->node.type = TRP_EMPTY_TRT_TYPE; + innod->node.iffeatures = TRP_EMPTY_TRT_IFFEATURES; + } else if (innod->indent.btw_opts_type == TRD_LINEBREAK) { + innod->node.type = TRP_EMPTY_TRT_TYPE; + innod->node.iffeatures = TRP_EMPTY_TRT_IFFEATURES; + } else if (innod->indent.btw_type_iffeatures == TRD_LINEBREAK) { + innod->node.iffeatures = TRP_EMPTY_TRT_IFFEATURES; + } +} + +/** + * @brief Set the second half of the node based on the linebreak mark. + * + * Items in the first half of the node will be empty. + * Indentations belonging to the first node will be reset to zero. + * + * @param[in,out] innod contains information in which part of the \<node\> + * the second half starts. Set second half of the node, indent is newly set. + */ +static void +trp_second_half_node(struct trt_pair_indent_node *innod) +{ + if (innod->indent.btw_name_opts < 0) { + /* Logically, the information up to token <opts> should + * be deleted, but the the trp_print_node function needs it to + * create the correct indent. + */ + innod->indent.btw_name_opts = 0; + innod->indent.btw_opts_type = TRP_TRT_TYPE_IS_EMPTY(innod->node.type) ? 0 : TRD_INDENT_BEFORE_TYPE; + innod->indent.btw_type_iffeatures = innod->node.iffeatures.type == TRD_IFF_NON_PRESENT ? 0 : TRD_INDENT_BEFORE_IFFEATURES; + } else if (innod->indent.btw_opts_type == TRD_LINEBREAK) { + innod->indent.btw_name_opts = 0; + innod->indent.btw_opts_type = 0; + innod->indent.btw_type_iffeatures = innod->node.iffeatures.type == TRD_IFF_NON_PRESENT ? 0 : TRD_INDENT_BEFORE_IFFEATURES; + } else if (innod->indent.btw_type_iffeatures == TRD_LINEBREAK) { + innod->node.type = TRP_EMPTY_TRT_TYPE; + innod->indent.btw_name_opts = 0; + innod->indent.btw_opts_type = 0; + innod->indent.btw_type_iffeatures = 0; + } +} + +/** + * @brief Get the correct alignment for the node. + * + * This function is recursively called itself. It's like a backend + * function for a function ::trp_try_normal_indent_in_node(). + * + * @param[in] pck contains speciall callback functions for printing. + * @param[in] wrapper contains information about '|' context. + * @param[in] mll is max line length. + * @param[in,out] cnt counting number of characters to print. + * @param[in,out] out is output handler. + * @param[in,out] innod pair of node and indentation numbers of that node. + */ +static void +trp_try_normal_indent_in_node_(struct trt_pck_print pck, struct trt_wrapper wrapper, size_t mll, size_t *cnt, + struct ly_out *out, struct trt_pair_indent_node *innod) +{ + trp_print_line(&innod->node, pck, TRP_INIT_PCK_INDENT(wrapper, innod->indent), out); + + if (*cnt <= mll) { + /* success */ + return; + } else { + innod->indent = trp_indent_in_node_place_break(innod->indent); + if (innod->indent.type != TRD_INDENT_IN_NODE_FAILED) { + /* erase information in node due to line break */ + trp_first_half_node(innod); + /* check if line fits, recursive call */ + *cnt = 0; + trp_try_normal_indent_in_node_(pck, wrapper, mll, cnt, out, innod); + /* make sure that the result will be with the status divided + * or eventually with status failed */ + innod->indent.type = innod->indent.type == TRD_INDENT_IN_NODE_FAILED ? TRD_INDENT_IN_NODE_FAILED : TRD_INDENT_IN_NODE_DIVIDED; + } + return; + } +} + +/** + * @brief Get the correct alignment for the node. + * + * @param[in] node is \<node\> representation. + * @param[in] pck contains speciall callback functions for printing. + * @param[in] indent contains wrapper and indent in node numbers. + * @param[in] mll is max line length. + * @param[in,out] out is output handler. + * @param[out] innod If the node does not fit in the line, some indent variable has negative value as a line break sign + * and therefore ::TRD_INDENT_IN_NODE_DIVIDED is set. + * If the node fits into the line, all indent variables values has non-negative number and therefore + * ::TRD_INDENT_IN_NODE_NORMAL is set. + * If the node does not fit into the line, all indent variables has negative or zero values, function failed + * and therefore ::TRD_INDENT_IN_NODE_FAILED is set. + */ +static void +trp_try_normal_indent_in_node(const struct trt_node *node, struct trt_pck_print pck, struct trt_pck_indent indent, + size_t mll, struct ly_out *out, struct trt_pair_indent_node *innod) +{ + struct ly_out_clb_arg *data; + + *innod = TRP_INIT_PAIR_INDENT_NODE(indent.in_node, *node); + + /* set ly_out to counting characters */ + data = out->method.clb.arg; + + data->counter = 0; + data->mode = TRD_CHAR_COUNT; + trp_try_normal_indent_in_node_(pck, indent.wrapper, mll, &data->counter, out, innod); + data->mode = TRD_PRINT; +} + +/** + * @brief Auxiliary function for ::trp_print_entire_node() + * that prints split nodes. + * @param[in] node is node representation. + * @param[in] ppck contains speciall callback functions for printing. + * @param[in] ipck contains wrapper and indent in node numbers. + * @param[in] mll is max line length. + * @param[in,out] out is output handler. + */ +static void +trp_print_divided_node(const struct trt_node *node, struct trt_pck_print ppck, struct trt_pck_indent ipck, size_t mll, struct ly_out *out) +{ + ly_bool entire_node_was_printed; + struct trt_pair_indent_node innod; + + trp_try_normal_indent_in_node(node, ppck, ipck, mll, out, &innod); + + if (innod.indent.type == TRD_INDENT_IN_NODE_FAILED) { + /* nothing can be done, continue as usual */ + innod.indent.type = TRD_INDENT_IN_NODE_DIVIDED; + } + + trp_print_line(&innod.node, ppck, TRP_INIT_PCK_INDENT(ipck.wrapper, innod.indent), out); + entire_node_was_printed = trp_indent_in_node_are_eq(ipck.in_node, innod.indent); + + if (!entire_node_was_printed) { + ly_print_(out, "\n"); + /* continue with second half node */ + innod.node = *node; + trp_second_half_node(&innod); + /* continue with printing node */ + trp_print_divided_node(&innod.node, ppck, TRP_INIT_PCK_INDENT(ipck.wrapper, innod.indent), mll, out); + } else { + return; + } +} + +/** + * @brief Printing of the wrapper and the whole node, + * which can be divided into several lines. + * @param[in] node_p is node representation. + * @param[in] ppck contains speciall callback functions for printing. + * @param[in] ipck contains wrapper and indent in node numbers. + * @param[in] mll is max line length. + * @param[in,out] out is output handler. + */ +static void +trp_print_entire_node(const struct trt_node *node_p, struct trt_pck_print ppck, struct trt_pck_indent ipck, size_t mll, + struct ly_out *out) +{ + struct trt_pair_indent_node innod; + struct trt_pck_indent tmp; + struct trt_node node; + + node = *node_p; + if (trp_leafref_target_is_too_long(&node, ipck.wrapper, mll, out)) { + node.type.type = TRD_TYPE_LEAFREF; + } + + /* check if normal indent is possible */ + trp_try_normal_indent_in_node(&node, ppck, ipck, mll, out, &innod); + + if (innod.indent.type == TRD_INDENT_IN_NODE_NORMAL) { + /* node fits to one line */ + trp_print_line(&node, ppck, ipck, out); + } else if (innod.indent.type == TRD_INDENT_IN_NODE_DIVIDED) { + /* node will be divided */ + /* print first half */ + tmp = TRP_INIT_PCK_INDENT(ipck.wrapper, innod.indent); + /* pretend that this is normal node */ + tmp.in_node.type = TRD_INDENT_IN_NODE_NORMAL; + + trp_print_line(&innod.node, ppck, tmp, out); + ly_print_(out, "\n"); + + /* continue with second half on new line */ + innod.node = node; + trp_second_half_node(&innod); + tmp = TRP_INIT_PCK_INDENT(trp_wrapper_if_last_sibling(ipck.wrapper, node.last_one), innod.indent); + + trp_print_divided_node(&innod.node, ppck, tmp, mll, out); + } else if (innod.indent.type == TRD_INDENT_IN_NODE_FAILED) { + /* node name is too long */ + trp_print_line_up_to_node_name(&node, ipck.wrapper, out); + + if (trp_node_body_is_empty(&node)) { + return; + } else { + ly_print_(out, "\n"); + + innod.node = node; + trp_second_half_node(&innod); + innod.indent.type = TRD_INDENT_IN_NODE_DIVIDED; + tmp = TRP_INIT_PCK_INDENT(trp_wrapper_if_last_sibling(ipck.wrapper, node.last_one), innod.indent); + + trp_print_divided_node(&innod.node, ppck, tmp, mll, out); + } + } +} + +/** + * @brief Check if parent-stmt is valid for printing extensinon. + * + * @param[in] lysc_tree flag if ext is from compiled tree. + * @param[in] ext Extension to check. + * @return 1 if extension is valid. + */ +static ly_bool +trp_ext_parent_is_valid(ly_bool lysc_tree, void *ext) +{ + enum ly_stmt parent_stmt; + + if (lysc_tree) { + parent_stmt = ((struct lysc_ext_instance *)ext)->parent_stmt; + } else { + parent_stmt = ((struct lysp_ext_instance *)ext)->parent_stmt; + } + if ((parent_stmt & LY_STMT_OP_MASK) || (parent_stmt & LY_STMT_DATA_NODE_MASK) || + (parent_stmt & LY_STMT_SUBMODULE) || parent_stmt & LY_STMT_MODULE) { + return 1; + } else { + return 0; + } +} + +/** + * @brief Check if printer_tree can use node extension. + * + * @param[in] lysc_tree Flag if @p node is compiled. + * @param[in] node to check. Its type is lysc_node or lysp_node. + * @return Pointer to extension instance which printer_tree can used. + */ +static void * +trp_ext_is_present(ly_bool lysc_tree, const void *node) +{ + const struct lysp_node *pn; + const struct lysc_node *cn; + LY_ARRAY_COUNT_TYPE i; + void *ret = NULL; + + if (!node) { + return NULL; + } + + if (lysc_tree) { + cn = (const struct lysc_node *)node; + LY_ARRAY_FOR(cn->exts, i) { + if (!(cn->exts && cn->exts->def->plugin && cn->exts->def->plugin->printer_ctree)) { + continue; + } + if (!trp_ext_parent_is_valid(1, &cn->exts[i])) { + continue; + } + ret = &cn->exts[i]; + break; + } + } else { + pn = (const struct lysp_node *)node; + LY_ARRAY_FOR(pn->exts, i) { + if (!(pn->exts && pn->exts->record->plugin.printer_ptree)) { + continue; + } + if (!trp_ext_parent_is_valid(0, &pn->exts[i])) { + continue; + } + ret = &pn->exts[i]; + break; + } + } + + return ret; +} + +/** + * @brief Check if printer_tree can use node extension. + * + * @param[in] tc Context with current node. + * @return 1 if some extension for printer_tree is valid. + */ +static ly_bool +trp_ext_is_present_in_node(struct trt_tree_ctx *tc) +{ + if (tc->lysc_tree && trp_ext_is_present(tc->lysc_tree, tc->cn)) { + return 1; + } else if (trp_ext_is_present(tc->lysc_tree, tc->pn)) { + return 1; + } + + return 0; +} + +/** + * @brief Release allocated memory and set pointers to NULL. + * + * @param[in,out] overr is override structure to release. + * @param[out] filtered is flag to reset. + */ +static void +trp_ext_free_node_override(struct lyplg_ext_sprinter_tree_node_override *overr, ly_bool *filtered) +{ + *filtered = 0; + overr->flags = NULL; + overr->add_opts = NULL; +} + +/** + * @brief Release private plugin data. + * + * @param[in,out] plug_ctx is plugin context. + */ +static void +trp_ext_free_plugin_ctx(struct lyspr_tree_ctx *plug_ctx) +{ + LY_ARRAY_FREE(plug_ctx->schemas); + if (plug_ctx->free_plugin_priv) { + plug_ctx->free_plugin_priv(plug_ctx->plugin_priv); + } +} + +/********************************************************************** + * trop and troc getters + *********************************************************************/ + +/** + * @brief Get nodetype. + * @param[in] node is any lysp_node. + */ +static uint16_t +trop_nodetype(const void *node) +{ + return ((const struct lysp_node *)node)->nodetype; +} + +/** + * @brief Get sibling. + * @param[in] node is any lysp_node. + */ +static const void * +trop_next(const void *node) +{ + return ((const struct lysp_node *)node)->next; +} + +/** + * @brief Get parent. + * @param[in] node is any lysp_node. + */ +static const void * +trop_parent(const void *node) +{ + return ((const struct lysp_node *)node)->parent; +} + +/** + * @brief Try to get child. + * @param[in] node is any lysp_node. + */ +static const void * +trop_child(const void *node) +{ + return lysp_node_child(node); +} + +/** + * @brief Try to get action. + * @param[in] node is any lysp_node. + */ +static const void * +trop_actions(const void *node) +{ + return lysp_node_actions(node); +} + +/** + * @brief Try to get action. + * @param[in] node must be of type lysp_node_action. + */ +static const void * +trop_action_input(const void *node) +{ + return &((const struct lysp_node_action *)node)->input; +} + +/** + * @brief Try to get action. + * @param[in] node must be of type lysp_node_action. + */ +static const void * +trop_action_output(const void *node) +{ + return &((const struct lysp_node_action *)node)->output; +} + +/** + * @brief Try to get action. + * @param[in] node is any lysp_node. + */ +static const void * +trop_notifs(const void *node) +{ + return lysp_node_notifs(node); +} + +/** + * @brief Fill struct tro_getters with @ref TRP_trop getters + * which are adapted to lysp nodes. + */ +static struct tro_getters +trop_init_getters(void) +{ + return (struct tro_getters) { + .nodetype = trop_nodetype, + .next = trop_next, + .parent = trop_parent, + .child = trop_child, + .actions = trop_actions, + .action_input = trop_action_input, + .action_output = trop_action_output, + .notifs = trop_notifs + }; +} + +/** + * @brief Get nodetype. + * @param[in] node is any lysc_node. + */ +static uint16_t +troc_nodetype(const void *node) +{ + return ((const struct lysc_node *)node)->nodetype; +} + +/** + * @brief Get sibling. + * @param[in] node is any lysc_node. + */ +static const void * +troc_next(const void *node) +{ + return ((const struct lysc_node *)node)->next; +} + +/** + * @brief Get parent. + * @param[in] node is any lysc_node. + */ +static const void * +troc_parent(const void *node) +{ + return ((const struct lysc_node *)node)->parent; +} + +/** + * @brief Try to get child. + * @param[in] node is any lysc_node. + */ +static const void * +troc_child(const void *node) +{ + return lysc_node_child(node); +} + +/** + * @brief Try to get action. + * @param[in] node is any lysc_node. + */ +static const void * +troc_actions(const void *node) +{ + return lysc_node_actions(node); +} + +/** + * @brief Try to get action. + * @param[in] node must be of type lysc_node_action. + */ +static const void * +troc_action_input(const void *node) +{ + return &((const struct lysc_node_action *)node)->input; +} + +/** + * @brief Try to get action. + * @param[in] node must be of type lysc_node_action. + */ +static const void * +troc_action_output(const void *node) +{ + return &((const struct lysc_node_action *)node)->output; +} + +/** + * @brief Try to get action. + * @param[in] node is any lysc_node. + */ +static const void * +troc_notifs(const void *node) +{ + return lysc_node_notifs(node); +} + +/** + * @brief Fill struct tro_getters with @ref TRP_troc getters + * which are adapted to lysc nodes. + */ +static struct tro_getters +troc_init_getters(void) +{ + return (struct tro_getters) { + .nodetype = troc_nodetype, + .next = troc_next, + .parent = troc_parent, + .child = troc_child, + .actions = troc_actions, + .action_input = troc_action_input, + .action_output = troc_action_output, + .notifs = troc_notifs + }; +} + +/********************************************************************** + * tro functions + *********************************************************************/ + +/** + * @brief Call override function for @p node. + * + * @param[in] lysc_tree if @p node is compiled. + * @param[in] node to create override. + * @param[in] erase_node_overr if override structure must be reseted. + * @param[in,out] plc current plugin context. + * @return pointer to override structure or NULL. Override structure in @p plc is updated too. + */ +static struct lyplg_ext_sprinter_tree_node_override * +tro_set_node_overr(ly_bool lysc_tree, const void *node, ly_bool erase_node_overr, struct trt_plugin_ctx *plc) +{ + LY_ERR rc = LY_SUCCESS; + struct lyplg_ext_sprinter_tree_node_override *no; + struct lyspr_tree_ctx *plug_ctx; + struct lysc_ext_instance *ce; + struct lysp_ext_instance *pe; + + if (erase_node_overr) { + trp_ext_free_node_override(&plc->node_overr, &plc->filtered); + } + no = &plc->node_overr; + if (!plc->ctx && lysc_tree && (ce = trp_ext_is_present(lysc_tree, node))) { + rc = ce->def->plugin->printer_ctree(ce, NULL, &no->flags, &no->add_opts); + } else if (!plc->ctx && (pe = trp_ext_is_present(lysc_tree, node))) { + rc = pe->record->plugin.printer_ptree(pe, NULL, &no->flags, &no->add_opts); + } else if (plc->ctx) { + if (plc->schema && plc->schema->compiled && plc->schema->cn_overr) { + rc = plc->schema->cn_overr(node, plc->ctx->plugin_priv, &plc->filtered, &no->flags, &no->add_opts); + } else if (plc->schema && plc->schema->pn_overr) { + rc = plc->schema->pn_overr(node, plc->ctx->plugin_priv, &plc->filtered, &no->flags, &no->add_opts); + } else { + no = NULL; + } + if (trp_ext_is_present(lysc_tree, node)) { + plug_ctx = plc->ctx; + plc->ctx = NULL; + tro_set_node_overr(lysc_tree, node, 0, plc); + plc->ctx = plug_ctx; + } + } else { + no = NULL; + } + + if (rc) { + plc->last_error = rc; + no = NULL; + } + + return no; +} + +/** + * @brief Get next sibling of the current node. + * + * This is a general algorithm that is able to + * work with lysp_node or lysc_node. + * + * @param[in] node points to lysp_node or lysc_node. + * @param[in] tc current tree context. + * @return next sibling node. + */ +static const void * +tro_next_sibling(const void *node, const struct trt_tree_ctx *tc) +{ + struct tro_getters get; + struct trt_plugin_ctx plugin_ctx; + const void *tmp, *parent, *sibl; + + assert(node); + + get = tc->lysc_tree ? troc_init_getters() : trop_init_getters(); + + if (get.nodetype(node) & (LYS_RPC | LYS_ACTION)) { + if ((tmp = get.next(node))) { + /* next action exists */ + sibl = tmp; + } else if ((parent = get.parent(node))) { + /* maybe if notif exists as sibling */ + sibl = get.notifs(parent); + } else { + sibl = NULL; + } + } else if (get.nodetype(node) & LYS_INPUT) { + if ((parent = get.parent(node))) { + /* if output action has data */ + if (get.child(get.action_output(parent))) { + /* then next sibling is output action */ + sibl = get.action_output(parent); + } else { + /* input action cannot have siblings other + * than output action. + */ + sibl = NULL; + } + } else { + /* there is no way how to get output action */ + sibl = NULL; + } + } else if (get.nodetype(node) & LYS_OUTPUT) { + /* output action cannot have siblings */ + sibl = NULL; + } else if (get.nodetype(node) & LYS_NOTIF) { + /* must have as a sibling only notif */ + sibl = get.next(node); + } else { + /* for rest of nodes */ + if ((tmp = get.next(node))) { + /* some sibling exists */ + sibl = tmp; + } else if ((parent = get.parent(node))) { + /* Action and notif are siblings too. + * They can be reached through parent. + */ + if ((tmp = get.actions(parent))) { + /* next sibling is action */ + sibl = tmp; + } else if ((tmp = get.notifs(parent))) { + /* next sibling is notif */ + sibl = tmp; + } else { + /* sibling not exists */ + sibl = NULL; + } + } else { + /* sibling not exists */ + sibl = NULL; + } + } + + plugin_ctx = tc->plugin_ctx; + if (sibl && tro_set_node_overr(tc->lysc_tree, sibl, 1, &plugin_ctx) && plugin_ctx.filtered) { + return tro_next_sibling(sibl, tc); + } + + return sibl; +} + +/** + * @brief Get child of the current node. + * + * This is a general algorithm that is able to + * work with lysp_node or lysc_node. + * + * @param[in] node points to lysp_node or lysc_node. + * @param[in] tc current tree context. + * @return child node. + */ +static const void * +tro_next_child(const void *node, const struct trt_tree_ctx *tc) +{ + struct tro_getters get; + struct trt_plugin_ctx plugin_ctx; + const void *tmp, *child; + + assert(node); + + get = tc->lysc_tree ? troc_init_getters() : trop_init_getters(); + + if (get.nodetype(node) & (LYS_ACTION | LYS_RPC)) { + if (get.child(get.action_input(node))) { + /* go to LYS_INPUT */ + child = get.action_input(node); + } else if (get.child(get.action_output(node))) { + /* go to LYS_OUTPUT */ + child = get.action_output(node); + } else { + /* input action and output action have no data */ + child = NULL; + } + } else { + if ((tmp = get.child(node))) { + child = tmp; + } else { + /* current node can't have children or has no children */ + /* but maybe has some actions or notifs */ + if ((tmp = get.actions(node))) { + child = tmp; + } else if ((tmp = get.notifs(node))) { + child = tmp; + } else { + child = NULL; + } + } + } + + plugin_ctx = tc->plugin_ctx; + if (child && tro_set_node_overr(tc->lysc_tree, child, 1, &plugin_ctx) && plugin_ctx.filtered) { + return tro_next_sibling(child, tc); + } + + return child; +} + +/** + * @brief Get new trt_parent_cache if we apply the transfer + * to the child node in the tree. + * @param[in] ca is parent cache for current node. + * @param[in] tc contains current tree node. + * @return Cache for the current node. + */ +static struct trt_parent_cache +tro_parent_cache_for_child(struct trt_parent_cache ca, const struct trt_tree_ctx *tc) +{ + struct trt_parent_cache ret = TRP_EMPTY_PARENT_CACHE; + + if (!tc->lysc_tree) { + const struct lysp_node *pn = tc->pn; + + ret.ancestor = + pn->nodetype & (LYS_INPUT) ? TRD_ANCESTOR_RPC_INPUT : + pn->nodetype & (LYS_OUTPUT) ? TRD_ANCESTOR_RPC_OUTPUT : + pn->nodetype & (LYS_NOTIF) ? TRD_ANCESTOR_NOTIF : + ca.ancestor; + + ret.lys_status = + pn->flags & (LYS_STATUS_CURR | LYS_STATUS_DEPRC | LYS_STATUS_OBSLT) ? pn->flags : + ca.lys_status; + + ret.lys_config = + ca.ancestor == TRD_ANCESTOR_RPC_INPUT ? 0 : /* because <flags> will be -w */ + ca.ancestor == TRD_ANCESTOR_RPC_OUTPUT ? LYS_CONFIG_R : + pn->flags & (LYS_CONFIG_R | LYS_CONFIG_W) ? pn->flags : + ca.lys_config; + + ret.last_list = + pn->nodetype & (LYS_LIST) ? (struct lysp_node_list *)pn : + ca.last_list; + } + + return ret; +} + +/** + * @brief Transformation of the Schema nodes flags to + * Tree diagram \<status\>. + * @param[in] flags is node's flags obtained from the tree. + */ +static char * +tro_flags2status(uint16_t flags) +{ + return flags & LYS_STATUS_OBSLT ? "o" : + flags & LYS_STATUS_DEPRC ? "x" : + "+"; +} + +/** + * @brief Transformation of the Schema nodes flags to Tree diagram + * \<flags\> but more specifically 'ro' or 'rw'. + * @param[in] flags is node's flags obtained from the tree. + */ +static char * +tro_flags2config(uint16_t flags) +{ + return flags & LYS_CONFIG_R ? TRD_FLAGS_TYPE_RO : + flags & LYS_CONFIG_W ? TRD_FLAGS_TYPE_RW : + TRD_FLAGS_TYPE_EMPTY; +} + +/** + * @brief Print current node's iffeatures. + * @param[in] tc is tree context. + * @param[in,out] out is output handler. + */ +static void +tro_print_features_names(const struct trt_tree_ctx *tc, struct ly_out *out) +{ + const struct lysp_qname *iffs; + + if (tc->lysc_tree) { + assert(TRP_TREE_CTX_LYSP_NODE_PRESENT(tc->cn)); + iffs = TRP_TREE_CTX_GET_LYSP_NODE(tc->cn)->iffeatures; + } else { + iffs = tc->pn->iffeatures; + } + LY_ARRAY_COUNT_TYPE i; + + LY_ARRAY_FOR(iffs, i) { + if (i == 0) { + ly_print_(out, "%s", iffs[i].str); + } else { + ly_print_(out, ",%s", iffs[i].str); + } + } + +} + +/** + * @brief Print current list's keys. + * + * Well, actually printing keys in the lysp_tree is trivial, + * because char* points to all keys. However, special functions have + * been reserved for this, because in principle the list of elements + * can have more implementations. + * + * @param[in] tc is tree context. + * @param[in,out] out is output handler. + */ +static void +tro_print_keys(const struct trt_tree_ctx *tc, struct ly_out *out) +{ + const struct lysp_node_list *list; + + if (tc->lysc_tree) { + assert(TRP_TREE_CTX_LYSP_NODE_PRESENT(tc->cn)); + list = (const struct lysp_node_list *)TRP_TREE_CTX_GET_LYSP_NODE(tc->cn); + } else { + list = (const struct lysp_node_list *)tc->pn; + } + assert(list->nodetype & LYS_LIST); + + if (trg_charptr_has_data(list->key)) { + ly_print_(out, "%s", list->key); + } +} + +/** + * @brief Get address of the current node. + * @param[in] tc contains current node. + * @return Address of lysc_node or lysp_node, or NULL. + */ +static const void * +tro_tree_ctx_get_node(const struct trt_tree_ctx *tc) +{ + return tc->lysc_tree ? + (const void *)tc->cn : + (const void *)tc->pn; +} + +/** + * @brief Get address of current node's child. + * @param[in,out] tc contains current node. + */ +static const void * +tro_tree_ctx_get_child(const struct trt_tree_ctx *tc) +{ + if (!tro_tree_ctx_get_node(tc)) { + return NULL; + } + + if (tc->lysc_tree) { + return lysc_node_child(tc->cn); + } else { + return lysp_node_child(tc->pn); + } +} + +/** + * @brief Get rpcs section if exists. + * @param[in,out] tc is tree context. + * @return Section representation if it exists. The @p tc is modified + * and his pointer points to the first node in rpcs section. + * @return Empty section representation otherwise. + */ +static struct trt_keyword_stmt +tro_modi_get_rpcs(struct trt_tree_ctx *tc) +{ + assert(tc); + const void *actions; + struct trt_keyword_stmt ret = {0}; + + if (tc->lysc_tree) { + actions = tc->cmod->rpcs; + if (actions) { + tc->cn = actions; + } + } else { + actions = tc->pmod->rpcs; + if (actions) { + tc->pn = actions; + tc->tpn = tc->pn; + } + } + + if (actions) { + tc->section = TRD_SECT_RPCS; + ret.section_name = TRD_KEYWORD_RPC; + ret.has_node = tro_tree_ctx_get_node(tc) ? 1 : 0; + } + + return ret; +} + +/** + * @brief Get notification section if exists + * @param[in,out] tc is tree context. + * @return Section representation if it exists. + * The @p tc is modified and his pointer points to the + * first node in notification section. + * @return Empty section representation otherwise. + */ +static struct trt_keyword_stmt +tro_modi_get_notifications(struct trt_tree_ctx *tc) +{ + assert(tc); + const void *notifs; + struct trt_keyword_stmt ret = {0}; + + if (tc->lysc_tree) { + notifs = tc->cmod->notifs; + if (notifs) { + tc->cn = notifs; + } + } else { + notifs = tc->pmod->notifs; + if (notifs) { + tc->pn = notifs; + tc->tpn = tc->pn; + } + } + + if (notifs) { + tc->section = TRD_SECT_NOTIF; + ret.section_name = TRD_KEYWORD_NOTIF; + ret.has_node = tro_tree_ctx_get_node(tc) ? 1 : 0; + } + + return ret; +} + +static struct trt_keyword_stmt +tro_get_ext_section(struct trt_tree_ctx *tc, void *ext, struct lyspr_tree_ctx *plug_ctx) +{ + struct trt_keyword_stmt ret = {0}; + struct lysc_ext_instance *ce = NULL; + struct lysp_ext_instance *pe = NULL; + + if (tc->lysc_tree) { + ce = ext; + ret.section_name = ce->def->name; + ret.argument = ce->argument; + ret.has_node = plug_ctx->schemas->ctree ? 1 : 0; + } else { + pe = ext; + ret.section_name = pe->def->name; + ret.argument = pe->argument; + ret.has_node = plug_ctx->schemas->ptree ? 1 : 0; + } + + return ret; +} + +/** + * @brief Get name of the module. + * @param[in] tc is context of the tree. + */ +static struct trt_keyword_stmt +tro_read_module_name(const struct trt_tree_ctx *tc) +{ + assert(tc); + struct trt_keyword_stmt ret; + + ret.section_name = !tc->lysc_tree && tc->pmod->is_submod ? + TRD_KEYWORD_SUBMODULE : + TRD_KEYWORD_MODULE; + + ret.argument = !tc->lysc_tree ? + LYSP_MODULE_NAME(tc->pmod) : + tc->cmod->mod->name; + + ret.has_node = tro_tree_ctx_get_node(tc) ? 1 : 0; + + return ret; +} + +static ly_bool +tro_read_if_sibling_exists(const struct trt_tree_ctx *tc) +{ + const void *parent; + + if (tc->lysc_tree) { + parent = troc_parent(tc->cn); + } else { + parent = trop_parent(tc->pn); + } + + return parent ? 1 : 0; +} + +/** + * @brief Create implicit "case" node as parent of @p node. + * @param[in] node child of implicit case node. + * @param[out] case_node created case node. + */ +static void +tro_create_implicit_case_node(const struct trt_node *node, struct trt_node *case_node) +{ + case_node->status = node->status; + case_node->flags = TRD_FLAGS_TYPE_EMPTY; + case_node->name.type = TRD_NODE_CASE; + case_node->name.keys = node->name.keys; + case_node->name.module_prefix = node->name.module_prefix; + case_node->name.str = node->name.str; + case_node->name.opts = node->name.opts; + case_node->name.add_opts = node->name.add_opts; + case_node->type = TRP_EMPTY_TRT_TYPE; + case_node->iffeatures = TRP_EMPTY_TRT_IFFEATURES; + case_node->last_one = node->last_one; +} + +/********************************************************************** + * Definition of trop reading functions + *********************************************************************/ + +/** + * @brief Check if list statement has keys. + * @param[in] pn is pointer to the list. + * @return 1 if has keys, otherwise 0. + */ +static ly_bool +trop_list_has_keys(const struct lysp_node *pn) +{ + return trg_charptr_has_data(((const struct lysp_node_list *)pn)->key); +} + +/** + * @brief Check if it contains at least one feature. + * @param[in] pn is current node. + * @return 1 if has if-features, otherwise 0. + */ +static ly_bool +trop_node_has_iffeature(const struct lysp_node *pn) +{ + LY_ARRAY_COUNT_TYPE u; + const struct lysp_qname *iffs; + + ly_bool ret = 0; + + iffs = pn->iffeatures; + LY_ARRAY_FOR(iffs, u) { + ret = 1; + break; + } + return ret; +} + +/** + * @brief Find out if leaf is also the key in last list. + * @param[in] pn is pointer to leaf. + * @param[in] ca_last_list is pointer to last visited list. + * Obtained from trt_parent_cache. + * @return 1 if leaf is also the key, otherwise 0. + */ +static ly_bool +trop_leaf_is_key(const struct lysp_node *pn, const struct lysp_node_list *ca_last_list) +{ + const struct lysp_node_leaf *leaf = (const struct lysp_node_leaf *)pn; + const struct lysp_node_list *list = ca_last_list; + + if (!list) { + return 0; + } + return trg_charptr_has_data(list->key) ? + trg_word_is_present(list->key, leaf->name, ' ') : 0; +} + +/** + * @brief Check if container's type is presence. + * @param[in] pn is pointer to container. + * @return 1 if container has presence statement, otherwise 0. + */ +static ly_bool +trop_container_has_presence(const struct lysp_node *pn) +{ + return trg_charptr_has_data(((struct lysp_node_container *)pn)->presence); +} + +/** + * @brief Get leaflist's path without lysp_node type control. + * @param[in] pn is pointer to the leaflist. + */ +static const char * +trop_leaflist_refpath(const struct lysp_node *pn) +{ + const struct lysp_node_leaflist *list = (const struct lysp_node_leaflist *)pn; + + return list->type.path ? list->type.path->expr : NULL; +} + +/** + * @brief Get leaflist's type name without lysp_node type control. + * @param[in] pn is pointer to the leaflist. + */ +static const char * +trop_leaflist_type_name(const struct lysp_node *pn) +{ + const struct lysp_node_leaflist *list = (const struct lysp_node_leaflist *)pn; + + return list->type.name; +} + +/** + * @brief Get leaf's path without lysp_node type control. + * @param[in] pn is pointer to the leaf node. + */ +static const char * +trop_leaf_refpath(const struct lysp_node *pn) +{ + const struct lysp_node_leaf *leaf = (const struct lysp_node_leaf *)pn; + + return leaf->type.path ? leaf->type.path->expr : NULL; +} + +/** + * @brief Get leaf's type name without lysp_node type control. + * @param[in] pn is pointer to the leaf's type name. + */ +static const char * +trop_leaf_type_name(const struct lysp_node *pn) +{ + const struct lysp_node_leaf *leaf = (const struct lysp_node_leaf *)pn; + + return leaf->type.name; +} + +/** + * @brief Get pointer to data using node type specification + * and getter function. + * + * @param[in] flags is node type specification. + * If it is the correct node, the getter function is called. + * @param[in] f is getter function which provides the desired + * char pointer from the structure. + * @param[in] pn pointer to node. + * @return NULL if node has wrong type or getter function return + * pointer to NULL. + * @return Pointer to desired char pointer obtained from the node. + */ +static const char * +trop_node_charptr(uint16_t flags, trt_get_charptr_func f, const struct lysp_node *pn) +{ + if (pn->nodetype & flags) { + const char *ret = f(pn); + + return trg_charptr_has_data(ret) ? ret : NULL; + } else { + return NULL; + } +} + +/** + * @brief Resolve \<status\> of the current node. + * @param[in] nodetype is node's type obtained from the tree. + * @param[in] flags is node's flags obtained from the tree. + * @param[in] ca_lys_status is inherited status obtained from trt_parent_cache. + * @return The status type. + */ +static char * +trop_resolve_status(uint16_t nodetype, uint16_t flags, uint16_t ca_lys_status) +{ + if (nodetype & (LYS_INPUT | LYS_OUTPUT)) { + /* LYS_INPUT and LYS_OUTPUT is special case */ + return tro_flags2status(ca_lys_status); + /* if ancestor's status is deprc or obslt + * and also node's status is not set + */ + } else if ((ca_lys_status & (LYS_STATUS_DEPRC | LYS_STATUS_OBSLT)) && !(flags & (LYS_STATUS_CURR | LYS_STATUS_DEPRC | LYS_STATUS_OBSLT))) { + /* get ancestor's status */ + return tro_flags2status(ca_lys_status); + } else { + /* else get node's status */ + return tro_flags2status(flags); + } +} + +/** + * @brief Resolve \<flags\> of the current node. + * @param[in] nodetype is node's type obtained from the tree. + * @param[in] flags is node's flags obtained from the tree. + * @param[in] ca_ancestor is ancestor type obtained from trt_parent_cache. + * @param[in] ca_lys_config is inherited config item obtained from trt_parent_cache. + * @param[in] no Override structure for flags. + * @return The flags type. + */ +static const char * +trop_resolve_flags(uint16_t nodetype, uint16_t flags, trt_ancestor_type ca_ancestor, uint16_t ca_lys_config, + struct lyplg_ext_sprinter_tree_node_override *no) +{ + if (no && no->flags) { + return no->flags; + } else if ((nodetype & LYS_INPUT) || (ca_ancestor == TRD_ANCESTOR_RPC_INPUT)) { + return TRD_FLAGS_TYPE_RPC_INPUT_PARAMS; + } else if ((nodetype & LYS_OUTPUT) || (ca_ancestor == TRD_ANCESTOR_RPC_OUTPUT)) { + return TRD_FLAGS_TYPE_RO; + } else if (ca_ancestor == TRD_ANCESTOR_NOTIF) { + return TRD_FLAGS_TYPE_RO; + } else if (nodetype & LYS_NOTIF) { + return TRD_FLAGS_TYPE_NOTIF; + } else if (nodetype & LYS_USES) { + return TRD_FLAGS_TYPE_USES_OF_GROUPING; + } else if (nodetype & (LYS_RPC | LYS_ACTION)) { + return TRD_FLAGS_TYPE_RPC; + } else if (!(flags & (LYS_CONFIG_R | LYS_CONFIG_W))) { + /* config is not set. Look at ancestor's config */ + return tro_flags2config(ca_lys_config); + } else { + return tro_flags2config(flags); + } +} + +/** + * @brief Resolve node type of the current node. + * @param[in] pn is pointer to the current node in the tree. + * @param[in] ca_last_list is pointer to the last visited list. Obtained from the trt_parent_cache. + * @param[out] type Resolved type of node. + * @param[out] opts Resolved opts of node. + */ +static void +trop_resolve_node_opts(const struct lysp_node *pn, const struct lysp_node_list *ca_last_list, trt_node_type *type, + const char **opts) +{ + if (pn->nodetype & (LYS_INPUT | LYS_OUTPUT)) { + *type = TRD_NODE_ELSE; + } else if (pn->nodetype & LYS_CASE) { + *type = TRD_NODE_CASE; + } else if ((pn->nodetype & LYS_CHOICE) && !(pn->flags & LYS_MAND_TRUE)) { + *type = TRD_NODE_CHOICE; + *opts = TRD_NODE_OPTIONAL; + } else if (pn->nodetype & LYS_CHOICE) { + *type = TRD_NODE_CHOICE; + } else if ((pn->nodetype & LYS_CONTAINER) && (trop_container_has_presence(pn))) { + *opts = TRD_NODE_CONTAINER; + } else if (pn->nodetype & (LYS_LIST | LYS_LEAFLIST)) { + *opts = TRD_NODE_LISTLEAFLIST; + } else if ((pn->nodetype & (LYS_ANYDATA | LYS_ANYXML)) && !(pn->flags & LYS_MAND_TRUE)) { + *opts = TRD_NODE_OPTIONAL; + } else if ((pn->nodetype & LYS_LEAF) && !(pn->flags & LYS_MAND_TRUE) && (!trop_leaf_is_key(pn, ca_last_list))) { + *opts = TRD_NODE_OPTIONAL; + } else { + *type = TRD_NODE_ELSE; + } +} + +/** + * @brief Resolve \<type\> of the current node. + * @param[in] pn is current node. + * @return Resolved type. + */ +static struct trt_type +trop_resolve_type(const struct lysp_node *pn) +{ + const char *tmp = NULL; + + if (!pn) { + return TRP_EMPTY_TRT_TYPE; + } else if ((tmp = trop_node_charptr(LYS_LEAFLIST, trop_leaflist_refpath, pn))) { + return TRP_INIT_TRT_TYPE(TRD_TYPE_TARGET, tmp); + } else if ((tmp = trop_node_charptr(LYS_LEAFLIST, trop_leaflist_type_name, pn))) { + return TRP_INIT_TRT_TYPE(TRD_TYPE_NAME, tmp); + } else if ((tmp = trop_node_charptr(LYS_LEAF, trop_leaf_refpath, pn))) { + return TRP_INIT_TRT_TYPE(TRD_TYPE_TARGET, tmp); + } else if ((tmp = trop_node_charptr(LYS_LEAF, trop_leaf_type_name, pn))) { + return TRP_INIT_TRT_TYPE(TRD_TYPE_NAME, tmp); + } else if (pn->nodetype == LYS_ANYDATA) { + return TRP_INIT_TRT_TYPE(TRD_TYPE_NAME, "anydata"); + } else if (pn->nodetype & LYS_ANYXML) { + return TRP_INIT_TRT_TYPE(TRD_TYPE_NAME, "anyxml"); + } else { + return TRP_EMPTY_TRT_TYPE; + } +} + +/** + * @brief Resolve iffeatures. + * + * @param[in] pn is current parsed node. + * @return Resolved iffeatures. + */ +static struct trt_iffeatures +trop_resolve_iffeatures(const struct lysp_node *pn) +{ + struct trt_iffeatures iff; + + if (pn && trop_node_has_iffeature(pn)) { + iff.type = TRD_IFF_PRESENT; + iff.str = NULL; + } else { + iff.type = TRD_IFF_NON_PRESENT; + iff.str = NULL; + } + + return iff; +} + +/** + * @brief Transformation of current lysp_node to struct trt_node. + * @param[in] ca contains stored important data + * when browsing the tree downwards. + * @param[in] tc is context of the tree. + */ +static struct trt_node +trop_read_node(struct trt_parent_cache ca, struct trt_tree_ctx *tc) +{ + const struct lysp_node *pn; + struct trt_node ret; + struct lyplg_ext_sprinter_tree_node_override *no; + + assert(tc && tc->pn && tc->pn->nodetype != LYS_UNKNOWN); + + no = tro_set_node_overr(tc->lysc_tree, tc->pn, 1, &tc->plugin_ctx); + + pn = tc->pn; + ret = TRP_EMPTY_NODE; + + /* <status> */ + ret.status = trop_resolve_status(pn->nodetype, pn->flags, ca.lys_status); + + /* <flags> */ + ret.flags = trop_resolve_flags(pn->nodetype, pn->flags, ca.ancestor, ca.lys_config, no); + + /* set type of the node */ + trop_resolve_node_opts(pn, ca.last_list, &ret.name.type, &ret.name.opts); + ret.name.add_opts = no && no->add_opts ? no->add_opts : NULL; + ret.name.keys = (tc->pn->nodetype & LYS_LIST) && trop_list_has_keys(tc->pn); + + /* The parsed tree is not compiled, so no node can be augmented + * from another module. This means that nodes from the parsed tree + * will never have the prefix. + */ + ret.name.module_prefix = NULL; + + /* set node's name */ + ret.name.str = pn->name; + + /* <type> */ + ret.type = trop_resolve_type(pn); + + /* <iffeature> */ + ret.iffeatures = trop_resolve_iffeatures(pn); + + ret.last_one = !tro_next_sibling(pn, tc); + + return ret; +} + +/** + * @brief Find out if the current node has siblings. + * @param[in] tc is context of the tree. + * @return 1 if sibling exists otherwise 0. + */ +static ly_bool +trop_read_if_sibling_exists(const struct trt_tree_ctx *tc) +{ + return tro_next_sibling(tc->pn, tc) != NULL; +} + +/********************************************************************** + * Modify trop getters + *********************************************************************/ + +/** + * @brief Change current node pointer to its parent + * but only if parent exists. + * @param[in,out] tc is tree context. + * Contains pointer to the current node. + * @return 1 if the node had parents and the change was successful. + * @return 0 if the node did not have parents. + * The pointer to the current node did not change. + */ +static ly_bool +trop_modi_parent(struct trt_tree_ctx *tc) +{ + assert(tc && tc->pn); + /* If no parent exists, stay in actual node. */ + if ((tc->pn != tc->tpn) && (tc->pn->parent)) { + tc->pn = tc->pn->parent; + return 1; + } else { + return 0; + } +} + +/** + * @brief Change the current node pointer to its child + * but only if exists. + * @param[in] ca contains inherited data from ancestors. + * @param[in,out] tc is context of the tree. + * Contains pointer to the current node. + * @return Non-empty \<node\> representation of the current + * node's child. The @p tc is modified. + * @return Empty \<node\> representation if child don't exists. + * The @p tc is not modified. + */ +static struct trt_node +trop_modi_next_child(struct trt_parent_cache ca, struct trt_tree_ctx *tc) +{ + const struct lysp_node *tmp; + + assert(tc && tc->pn); + + if ((tmp = tro_next_child(tc->pn, tc))) { + tc->pn = tmp; + return trop_read_node(ca, tc); + } else { + return TRP_EMPTY_NODE; + } +} + +/** + * @brief Change the pointer to the current node to its next sibling + * only if exists. + * @param[in] ca contains inherited data from ancestors. + * @param[in,out] tc is tree context. + * Contains pointer to the current node. + * @return Non-empty \<node\> representation if sibling exists. + * The @p tc is modified. + * @return Empty \<node\> representation otherwise. + * The @p tc is not modified. + */ +static struct trt_node +trop_modi_next_sibling(struct trt_parent_cache ca, struct trt_tree_ctx *tc) +{ + const struct lysp_node *pn; + + assert(tc && tc->pn); + + pn = tro_next_sibling(tc->pn, tc); + + if (pn) { + if ((tc->tpn == tc->pn) && (tc->section != TRD_SECT_PLUG_DATA)) { + tc->tpn = pn; + } + tc->pn = pn; + return trop_read_node(ca, tc); + } else { + return TRP_EMPTY_NODE; + } +} + +/** + * @brief Change the current node pointer to the first child of node's + * parent. If current node is already first sibling/child then nothing + * will change. + * @param[in] ca Settings of parent. + * @param[in,out] tc is tree context. + * @return node for printing. + */ +static struct trt_node +trop_modi_first_sibling(struct trt_parent_cache ca, struct trt_tree_ctx *tc) +{ + struct trt_node node; + + assert(tc && tc->pn); + + if (trop_modi_parent(tc)) { + node = trop_modi_next_child(ca, tc); + } else if (tc->plugin_ctx.schema) { + tc->pn = tc->plugin_ctx.schema->ptree; + tc->tpn = tc->pn; + node = trop_read_node(ca, tc); + } else { + /* current node is top-node */ + switch (tc->section) { + case TRD_SECT_MODULE: + tc->pn = tc->pmod->data; + tc->tpn = tc->pn; + break; + case TRD_SECT_AUGMENT: + tc->pn = (const struct lysp_node *)tc->pmod->augments; + tc->tpn = tc->pn; + break; + case TRD_SECT_RPCS: + tc->pn = (const struct lysp_node *)tc->pmod->rpcs; + tc->tpn = tc->pn; + break; + case TRD_SECT_NOTIF: + tc->pn = (const struct lysp_node *)tc->pmod->notifs; + tc->tpn = tc->pn; + break; + case TRD_SECT_GROUPING: + tc->pn = (const struct lysp_node *)tc->pmod->groupings; + tc->tpn = tc->pn; + break; + case TRD_SECT_PLUG_DATA: + /* Nothing to do. */ + break; + default: + assert(0); + } + node = trop_read_node(ca, tc); + } + + if (tc->plugin_ctx.filtered) { + node = trop_modi_next_sibling(ca, tc); + } + + return node; +} + +/** + * @brief Get next (or first) augment section if exists. + * @param[in,out] tc is tree context. It is modified and his current + * node is set to the lysp_node_augment. + * @return Section's representation if (next augment) section exists. + * @return Empty section structure otherwise. + */ +static struct trt_keyword_stmt +trop_modi_next_augment(struct trt_tree_ctx *tc) +{ + assert(tc); + const struct lysp_node_augment *augs; + struct trt_keyword_stmt ret = {0}; + + /* if next_augment func was called for the first time */ + if (tc->section != TRD_SECT_AUGMENT) { + tc->section = TRD_SECT_AUGMENT; + augs = tc->pmod->augments; + } else { + /* get augment sibling from top-node pointer */ + augs = (const struct lysp_node_augment *)tc->tpn->next; + } + + if (augs) { + tc->pn = &augs->node; + tc->tpn = tc->pn; + ret.section_name = TRD_KEYWORD_AUGMENT; + ret.argument = augs->nodeid; + ret.has_node = tro_tree_ctx_get_node(tc) ? 1 : 0; + } + + return ret; +} + +/** + * @brief Get next (or first) grouping section if exists + * @param[in,out] tc is tree context. It is modified and his current + * node is set to the lysp_node_grp. + * @return The next (or first) section representation if it exists. + * @return Empty section representation otherwise. + */ +static struct trt_keyword_stmt +trop_modi_next_grouping(struct trt_tree_ctx *tc) +{ + assert(tc); + const struct lysp_node_grp *grps; + struct trt_keyword_stmt ret = {0}; + + if (tc->section != TRD_SECT_GROUPING) { + tc->section = TRD_SECT_GROUPING; + grps = tc->pmod->groupings; + } else { + grps = (const struct lysp_node_grp *)tc->tpn->next; + } + + if (grps) { + tc->pn = &grps->node; + tc->tpn = tc->pn; + ret.section_name = TRD_KEYWORD_GROUPING; + ret.argument = grps->name; + ret.has_node = tro_tree_ctx_get_child(tc) ? 1 : 0; + } + + return ret; +} + +/********************************************************************** + * Definition of troc reading functions + *********************************************************************/ + +/** + * @copydoc trop_read_if_sibling_exists + */ +static ly_bool +troc_read_if_sibling_exists(const struct trt_tree_ctx *tc) +{ + return tro_next_sibling(tc->cn, tc) != NULL; +} + +/** + * @brief Resolve \<flags\> of the current node. + * + * Use this function only if trt_tree_ctx.lysc_tree is true. + * + * @param[in] nodetype is current lysc_node.nodetype. + * @param[in] flags is current lysc_node.flags. + * @param[in] no Override structure for flags. + * @return The flags type. + */ +static const char * +troc_resolve_flags(uint16_t nodetype, uint16_t flags, struct lyplg_ext_sprinter_tree_node_override *no) +{ + if (no && no->flags) { + return no->flags; + } else if ((nodetype & LYS_INPUT) || (flags & LYS_IS_INPUT)) { + return TRD_FLAGS_TYPE_RPC_INPUT_PARAMS; + } else if ((nodetype & LYS_OUTPUT) || (flags & LYS_IS_OUTPUT)) { + return TRD_FLAGS_TYPE_RO; + } else if (nodetype & LYS_IS_NOTIF) { + return TRD_FLAGS_TYPE_RO; + } else if (nodetype & LYS_NOTIF) { + return TRD_FLAGS_TYPE_NOTIF; + } else if (nodetype & LYS_USES) { + return TRD_FLAGS_TYPE_USES_OF_GROUPING; + } else if (nodetype & (LYS_RPC | LYS_ACTION)) { + return TRD_FLAGS_TYPE_RPC; + } else { + return tro_flags2config(flags); + } +} + +/** + * @brief Resolve node type of the current node. + * + * Use this function only if trt_tree_ctx.lysc_tree is true. + * + * @param[in] nodetype is current lysc_node.nodetype. + * @param[in] flags is current lysc_node.flags. + * @param[out] type Resolved type of node. + * @param[out] opts Resolved opts. + */ +static void +troc_resolve_node_opts(uint16_t nodetype, uint16_t flags, trt_node_type *type, const char **opts) +{ + if (nodetype & (LYS_INPUT | LYS_OUTPUT)) { + *type = TRD_NODE_ELSE; + } else if (nodetype & LYS_CASE) { + *type = TRD_NODE_CASE; + } else if ((nodetype & LYS_CHOICE) && !(flags & LYS_MAND_TRUE)) { + *type = TRD_NODE_CHOICE; + *opts = TRD_NODE_OPTIONAL; + } else if (nodetype & LYS_CHOICE) { + *type = TRD_NODE_CHOICE; + } else if ((nodetype & LYS_CONTAINER) && (flags & LYS_PRESENCE)) { + *opts = TRD_NODE_CONTAINER; + } else if (nodetype & (LYS_LIST | LYS_LEAFLIST)) { + *opts = TRD_NODE_LISTLEAFLIST; + } else if ((nodetype & (LYS_ANYDATA | LYS_ANYXML)) && !(flags & LYS_MAND_TRUE)) { + *opts = TRD_NODE_OPTIONAL; + } else if ((nodetype & LYS_LEAF) && !(flags & (LYS_MAND_TRUE | LYS_KEY))) { + *opts = TRD_NODE_OPTIONAL; + } else { + *type = TRD_NODE_ELSE; + } +} + +/** + * @brief Resolve prefix (\<prefix\>:\<name\>) of node that has been + * placed from another module via an augment statement. + * + * @param[in] cn is current compiled node. + * @param[in] current_compiled_module is module whose nodes are + * currently being printed. + * @return Prefix of foreign module or NULL. + */ +static const char * +troc_resolve_node_prefix(const struct lysc_node *cn, const struct lysc_module *current_compiled_module) +{ + const struct lys_module *node_module; + const char *ret = NULL; + + node_module = cn->module; + if (!node_module || !current_compiled_module) { + return NULL; + } else if (node_module->compiled != current_compiled_module) { + ret = node_module->prefix; + } + + return ret; +} + +/** + * @brief Transformation of current lysc_node to struct trt_node. + * @param[in] ca is not used. + * @param[in] tc is context of the tree. + */ +static struct trt_node +troc_read_node(struct trt_parent_cache ca, struct trt_tree_ctx *tc) +{ + (void) ca; + const struct lysc_node *cn; + struct trt_node ret; + struct lyplg_ext_sprinter_tree_node_override *no; + + assert(tc && tc->cn); + + no = tro_set_node_overr(tc->lysc_tree, tc->cn, 1, &tc->plugin_ctx); + + cn = tc->cn; + ret = TRP_EMPTY_NODE; + + /* <status> */ + ret.status = tro_flags2status(cn->flags); + + /* <flags> */ + ret.flags = troc_resolve_flags(cn->nodetype, cn->flags, no); + + /* set type of the node */ + troc_resolve_node_opts(cn->nodetype, cn->flags, &ret.name.type, &ret.name.opts); + ret.name.add_opts = no && no->add_opts ? no->add_opts : NULL; + ret.name.keys = (cn->nodetype & LYS_LIST) && !(cn->flags & LYS_KEYLESS); + + /* <prefix> */ + ret.name.module_prefix = troc_resolve_node_prefix(cn, tc->cmod); + + /* set node's name */ + ret.name.str = cn->name; + + /* <type> */ + ret.type = trop_resolve_type(TRP_TREE_CTX_GET_LYSP_NODE(cn)); + + /* <iffeature> */ + ret.iffeatures = trop_resolve_iffeatures(TRP_TREE_CTX_GET_LYSP_NODE(cn)); + + ret.last_one = !tro_next_sibling(cn, tc); + + return ret; +} + +/********************************************************************** + * Modify troc getters + *********************************************************************/ + +/** + * @copydoc ::trop_modi_parent() + */ +static ly_bool +troc_modi_parent(struct trt_tree_ctx *tc) +{ + assert(tc && tc->cn); + /* If no parent exists, stay in actual node. */ + if (tc->cn->parent) { + tc->cn = tc->cn->parent; + return 1; + } else { + return 0; + } +} + +/** + * @copydoc ::trop_modi_next_sibling() + */ +static struct trt_node +troc_modi_next_sibling(struct trt_parent_cache ca, struct trt_tree_ctx *tc) +{ + const struct lysc_node *cn; + + assert(tc && tc->cn); + + cn = tro_next_sibling(tc->cn, tc); + + /* if next sibling exists */ + if (cn) { + /* update trt_tree_ctx */ + tc->cn = cn; + return troc_read_node(ca, tc); + } else { + return TRP_EMPTY_NODE; + } +} + +/** + * @copydoc trop_modi_next_child() + */ +static struct trt_node +troc_modi_next_child(struct trt_parent_cache ca, struct trt_tree_ctx *tc) +{ + const struct lysc_node *tmp; + + assert(tc && tc->cn); + + if ((tmp = tro_next_child(tc->cn, tc))) { + tc->cn = tmp; + return troc_read_node(ca, tc); + } else { + return TRP_EMPTY_NODE; + } +} + +/** + * @copydoc ::trop_modi_first_sibling() + */ +static struct trt_node +troc_modi_first_sibling(struct trt_parent_cache ca, struct trt_tree_ctx *tc) +{ + struct trt_node node; + + assert(tc && tc->cn); + + if (troc_modi_parent(tc)) { + node = troc_modi_next_child(ca, tc); + } else if (tc->plugin_ctx.schema) { + tc->cn = tc->plugin_ctx.schema->ctree; + node = troc_read_node(ca, tc); + } else { + /* current node is top-node */ + switch (tc->section) { + case TRD_SECT_MODULE: + tc->cn = tc->cmod->data; + break; + case TRD_SECT_RPCS: + tc->cn = (const struct lysc_node *)tc->cmod->rpcs; + break; + case TRD_SECT_NOTIF: + tc->cn = (const struct lysc_node *)tc->cmod->notifs; + break; + case TRD_SECT_PLUG_DATA: + /* nothing to do */ + break; + default: + assert(0); + } + node = troc_read_node(ca, tc); + } + + if (tc->plugin_ctx.filtered) { + node = troc_modi_next_sibling(ca, tc); + } + + return node; +} + +/********************************************************************** + * Definition of tree browsing functions + *********************************************************************/ + +static uint32_t +trb_gap_to_opts(const struct trt_node *node) +{ + uint32_t len = 0; + + if (node->name.keys) { + return 0; + } + + if (node->flags) { + len += strlen(node->flags); + /* space between flags and name */ + len += 1; + } else { + /* space between -- and name */ + len += 1; + } + + switch (node->name.type) { + case TRD_NODE_CASE: + /* ':' is already counted. Plus parentheses. */ + len += 2; + break; + case TRD_NODE_CHOICE: + /* Plus parentheses. */ + len += 2; + break; + default: + break; + } + + if (node->name.module_prefix) { + len += strlen(node->name.module_prefix); + } + if (node->name.str) { + len += strlen(node->name.str); + } + if (node->name.add_opts) { + len += strlen(node->name.add_opts); + } + if (node->name.opts) { + len += strlen(node->name.opts); + } + + return len; +} + +static uint32_t +trb_gap_to_type(const struct trt_node *node) +{ + uint32_t len, opts_len; + + if (node->name.keys) { + return 0; + } + + len = trb_gap_to_opts(node); + /* Gap between opts and type. */ + opts_len = 0; + opts_len += node->name.add_opts ? strlen(node->name.add_opts) : 0; + opts_len += node->name.opts ? strlen(node->name.opts) : 0; + if (opts_len >= TRD_INDENT_BEFORE_TYPE) { + /* At least one space should be there. */ + len += 1; + } else if (node->name.add_opts || node->name.opts) { + len += TRD_INDENT_BEFORE_TYPE - opts_len; + } else { + len += TRD_INDENT_BEFORE_TYPE; + } + + return len; +} + +/** + * @brief Calculate the trt_indent_in_node.btw_opts_type indent size + * for a particular node. + * @param[in] node for which we get btw_opts_type. + * @param[in] max_gap_before_type is the maximum value of btw_opts_type + * that it can have. + * @return Indent between \<opts\> and \<type\> for node. + */ +static int16_t +trb_calc_btw_opts_type(const struct trt_node *node, int16_t max_gap_before_type) +{ + uint32_t to_opts_len; + + to_opts_len = trb_gap_to_opts(node); + if (to_opts_len == 0) { + return 1; + } else { + return max_gap_before_type - to_opts_len; + } +} + +/** + * @brief Print node. + * + * This function is wrapper for ::trp_print_entire_node(). + * But difference is that take @p max_gap_before_type which will be + * used to set the unified alignment. + * + * @param[in] node to print. + * @param[in] max_gap_before_type is number of indent before \<type\>. + * @param[in] wr is wrapper for printing indentation before node. + * @param[in] pc contains mainly functions for printing. + * @param[in] tc is tree context. + */ +static void +trb_print_entire_node(const struct trt_node *node, uint32_t max_gap_before_type, struct trt_wrapper wr, + struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + struct trt_indent_in_node ind = trp_default_indent_in_node(node); + + if ((max_gap_before_type > 0) && (node->type.type != TRD_TYPE_EMPTY)) { + /* print actual node with unified indent */ + ind.btw_opts_type = trb_calc_btw_opts_type(node, max_gap_before_type); + } + /* after -> print actual node with default indent */ + trp_print_entire_node(node, TRP_INIT_PCK_PRINT(tc, pc->fp.print), + TRP_INIT_PCK_INDENT(wr, ind), pc->max_line_length, pc->out); +} + +/** + * @brief Check if parent of the current node is the last + * of his siblings. + * + * To mantain stability use this function only if the current node is + * the first of the siblings. + * Side-effect -> current node is set to the first sibling + * if node has a parent otherwise no side-effect. + * + * @param[in] fp contains all @ref TRP_tro callback functions. + * @param[in,out] tc is tree context. + * @return 1 if parent is last sibling otherwise 0. + */ +static ly_bool +trb_node_is_last_sibling(const struct trt_fp_all *fp, struct trt_tree_ctx *tc) +{ + if (fp->read.if_parent_exists(tc)) { + return !fp->read.if_sibling_exists(tc); + } else { + return !fp->read.if_sibling_exists(tc) && tc->plugin_ctx.last_schema; + } +} + +/** + * @brief For all siblings find maximal space from '--' to \<type\>. + * + * Side-effect -> Current node is set to the first sibling. + * + * @param[in] ca contains inherited data from ancestors. + * @param[in] pc contains mainly functions for printing. + * @param[in,out] tc is tree context. + * @return max space. + */ +static uint32_t +trb_max_gap_to_type(struct trt_parent_cache ca, struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + struct trt_node node; + int32_t maxlen, len; + + maxlen = 0; + for (node = pc->fp.modify.first_sibling(ca, tc); + !trp_node_is_empty(&node); + node = pc->fp.modify.next_sibling(ca, tc)) { + len = trb_gap_to_type(&node); + maxlen = maxlen < len ? len : maxlen; + } + pc->fp.modify.first_sibling(ca, tc); + + return maxlen; +} + +/** + * @brief Find out if it is possible to unify + * the alignment before \<type\>. + * + * The goal is for all node siblings to have the same alignment + * for \<type\> as if they were in a column. All siblings who cannot + * adapt because they do not fit on the line at all are ignored. + * Side-effect -> Current node is set to the first sibling. + * + * @param[in] ca contains inherited data from ancestors. + * @param[in] pc contains mainly functions for printing. + * @param[in,out] tc is tree context. + * @return positive number indicating the maximum number of spaces + * before \<type\> if the length of the flags, node name and opts is 0. To calculate + * the trt_indent_in_node.btw_opts_type indent size for a particular + * node, use the ::trb_calc_btw_opts_type(). +*/ +static uint32_t +trb_try_unified_indent(struct trt_parent_cache ca, struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + return trb_max_gap_to_type(ca, pc, tc); +} + +/** + * @brief Check if there is no case statement + * under the choice statement. + * + * It can return true only if the Parsed schema tree + * is used for browsing. + * + * @param[in] tc is tree context. + * @return 1 if implicit case statement is present otherwise 0. + */ +static ly_bool +trb_need_implicit_node_case(struct trt_tree_ctx *tc) +{ + return !tc->lysc_tree && tc->pn->parent && + (tc->pn->parent->nodetype & LYS_CHOICE) && + (tc->pn->nodetype & (LYS_ANYDATA | LYS_CHOICE | LYS_CONTAINER | + LYS_LEAF | LYS_LEAFLIST)); +} + +static void trb_print_subtree_nodes(struct trt_node *node, uint32_t max_gap_before_type, + struct trt_wrapper wr, struct trt_parent_cache ca, struct trt_printer_ctx *pc, struct trt_tree_ctx *tc); + +/** + * @brief Print implicit case node and his subtree. + * + * @param[in] node is child of implicit case. + * @param[in] wr is wrapper for printing identation before node. + * @param[in] pc contains mainly functions for printing. + * @param[in] tc is tree context. Its settings should be the same as + * before the function call. + * @return new indentation wrapper for @p node. + */ +static struct trt_wrapper +trb_print_implicit_node(const struct trt_node *node, struct trt_wrapper wr, struct trt_printer_ctx *pc, + struct trt_tree_ctx *tc) +{ + struct trt_node case_node; + struct trt_wrapper wr_case_child; + + tro_create_implicit_case_node(node, &case_node); + ly_print_(pc->out, "\n"); + trb_print_entire_node(&case_node, 0, wr, pc, tc); + ly_print_(pc->out, "\n"); + wr_case_child = pc->fp.read.if_sibling_exists(tc) ? + trp_wrapper_set_mark(wr) : trp_wrapper_set_shift(wr); + return wr_case_child; +} + +/** + * @brief Calculate the wrapper about how deep in the tree the node is. + * @param[in] wr_in A wrapper to use as a starting point + * @param[in] node from which to count. + * @return wrapper for @p node. + */ +static struct trt_wrapper +trb_count_depth(const struct trt_wrapper *wr_in, const struct lysc_node *node) +{ + struct trt_wrapper wr = wr_in ? *wr_in : TRP_INIT_WRAPPER_TOP; + const struct lysc_node *parent; + + if (!node) { + return wr; + } + + for (parent = node->parent; parent; parent = parent->parent) { + wr = trp_wrapper_set_shift(wr); + } + + return wr; +} + +/** + * @brief Print all parent nodes of @p node and the @p node itself. + * + * Side-effect -> trt_tree_ctx.cn will be set to @p node. + * + * @param[in] node on which the function is focused. + * @param[in] wr_in for printing identation before node. + * @param[in] pc is @ref TRP_trp settings. + * @param[in,out] tc is context of tree printer. + */ +static void +trb_print_parents(const struct lysc_node *node, struct trt_wrapper *wr_in, struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + uint32_t max_gap_before_type; + struct trt_wrapper wr; + struct trt_node print_node; + + assert(pc && tc && tc->section == TRD_SECT_MODULE); + + /* stop recursion */ + if (!node) { + return; + } + trb_print_parents(node->parent, wr_in, pc, tc); + + /* setup for printing */ + tc->cn = node; + wr = trb_count_depth(wr_in, node); + + /* print node */ + ly_print_(pc->out, "\n"); + print_node = pc->fp.read.node(TRP_EMPTY_PARENT_CACHE, tc); + max_gap_before_type = trb_max_gap_to_type(TRP_EMPTY_PARENT_CACHE, pc, tc); + trb_print_entire_node(&print_node, max_gap_before_type, wr, pc, tc); +} + +/** + * @brief Set current node on its child. + * @param[in,out] tc contains current node. + */ +static void +trb_tree_ctx_set_child(struct trt_tree_ctx *tc) +{ + const void *node = tro_tree_ctx_get_child(tc); + + if (tc->lysc_tree) { + tc->cn = node; + } else { + tc->pn = node; + } +} + +/** + * @brief Move extension iterator to the next position. + * + * @param[in] lysc_tree flag if exts is from compiled tree. + * @param[in] exts is current array of extensions. + * @param[in,out] i is state of iterator. + * @return Pointer to the first/next extension. + */ +static void * +trb_ext_iter_next(ly_bool lysc_tree, void *exts, uint64_t *i) +{ + void *ext = NULL; + struct lysc_ext_instance *ce; + struct lysp_ext_instance *pe; + + if (!exts) { + return NULL; + } + + if (lysc_tree) { + ce = exts; + while (*i < LY_ARRAY_COUNT(ce)) { + if (ce->def->plugin && trp_ext_parent_is_valid(1, &ce[*i])) { + ext = &ce[*i]; + break; + } + ++(*i); + } + } else { + pe = exts; + while (*i < LY_ARRAY_COUNT(pe)) { + if (trp_ext_parent_is_valid(0, &pe[*i])) { + ext = &pe[*i]; + break; + } + ++(*i); + } + } + ++(*i); + + return ext; +} + +/** + * @brief Iterate over extensions in module. + * + * @param[in] tc contains current node. + * @param[in,out] i is state of iterator. + * @return First/next extension or NULL. + */ +static void * +trb_mod_ext_iter(const struct trt_tree_ctx *tc, uint64_t *i) +{ + if (tc->lysc_tree) { + return trb_ext_iter_next(1, tc->cmod->exts, i); + } else { + return trb_ext_iter_next(0, tc->pmod->exts, i); + } +} + +/** + * @brief Iterate over extensions in node. + * + * @param[in] tc contains current node. + * @param[in,out] i is state of iterator. + * @return First/next extension or NULL. + */ +static void * +trb_ext_iter(const struct trt_tree_ctx *tc, uint64_t *i) +{ + if (tc->lysc_tree) { + return trb_ext_iter_next(1, tc->cn->exts, i); + } else { + return trb_ext_iter_next(0, tc->pn->exts, i); + } +} + +/** + * @brief Initialize plugin context. + * + * @param[in] compiled if @p ext is lysc structure. + * @param[in] ext current processed extension. + * @param[out] plug_ctx is plugin context which will be initialized. + * @return LY_ERR value. + */ +static LY_ERR +tro_ext_printer_tree(ly_bool compiled, void *ext, const struct lyspr_tree_ctx *plug_ctx) +{ + struct lysc_ext_instance *ext_comp; + struct lysp_ext_instance *ext_pars; + const char *flags = NULL, *add_opts = NULL; + + if (compiled) { + ext_comp = ext; + return ext_comp->def->plugin->printer_ctree(ext, plug_ctx, &flags, &add_opts); + } else { + ext_pars = ext; + return ext_pars->record->plugin.printer_ptree(ext, plug_ctx, &flags, &add_opts); + } +} + +/** + * @brief Reset tree context by plugin context. + * + * @param[in] plug_ctx is plugin context. + * @param[in] i which index in schemas should be used. + * @param[in] pc are printing functions. + * @param[out] tc tree context which will be updated. + */ +static void +trm_reset_tree_ctx_by_plugin(struct lyspr_tree_ctx *plug_ctx, LY_ARRAY_COUNT_TYPE i, struct trt_printer_ctx *pc, + struct trt_tree_ctx *tc) +{ + tc->plugin_ctx.ctx = plug_ctx; + tc->pmod = NULL; + tc->cmod = NULL; + if (plug_ctx->schemas[i].compiled) { + tc->lysc_tree = 1; + tc->cn = plug_ctx->schemas[i].ctree; + tc->plugin_ctx.schema = &plug_ctx->schemas[i]; + pc->fp.modify = TRP_TRT_FP_MODIFY_COMPILED; + pc->fp.read = TRP_TRT_FP_READ_COMPILED; + } else { + tc->lysc_tree = 0; + tc->pn = plug_ctx->schemas[i].ptree; + tc->tpn = tc->pn; + tc->plugin_ctx.schema = &plug_ctx->schemas[i]; + pc->fp.modify = TRP_TRT_FP_MODIFY_PARSED; + pc->fp.read = TRP_TRT_FP_READ_PARSED; + } +} + +/** + * @brief Print schemas from plugin context. + * + * @param[in] plug_ctx is plugin context. + * @param[in] last_nodes if this schemas will be the last. + * @param[in] max_gap_before_type is gap before type. + * @param[in] wr is indentation wrapper. + * @param[in] ca containing information from parent. + * @param[in] pc functions for tree traversing. + * @param[in] tc current tree context. + */ +static void +trb_ext_print_schemas(struct lyspr_tree_ctx *plug_ctx, ly_bool last_nodes, uint32_t max_gap_before_type, + struct trt_wrapper wr, struct trt_parent_cache ca, struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + LY_ARRAY_COUNT_TYPE i; + struct trt_printer_ctx pc_dupl; + struct trt_tree_ctx tc_dupl; + struct trt_node node; + + tc_dupl = *tc; + pc_dupl = *pc; + + LY_ARRAY_FOR(plug_ctx->schemas, i) { + trm_reset_tree_ctx_by_plugin(plug_ctx, i, pc, tc); + tc->plugin_ctx.last_schema = last_nodes && ((i + 1) == LY_ARRAY_COUNT(plug_ctx->schemas)); + node = TRP_EMPTY_NODE; + trb_print_subtree_nodes(&node, max_gap_before_type, wr, ca, pc, tc); + *tc = tc_dupl; + } + + *pc = pc_dupl; +} + +/** + * @brief Count unified indentation across schemas from extension instance. + * + * @param[in] plug_ctx is plugin context. + * @param[in] ca containing parent settings. + * @param[out] max_gap_before_type is result of unified indent. + * @param[in] pc functions for tree traversing. + * @param[in] tc is tree context. + */ +static void +trb_ext_try_unified_indent(struct lyspr_tree_ctx *plug_ctx, struct trt_parent_cache ca, uint32_t *max_gap_before_type, + struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + LY_ARRAY_COUNT_TYPE i; + struct trt_printer_ctx pc_dupl; + struct trt_tree_ctx tc_dupl; + uint32_t max; + + tc_dupl = *tc; + pc_dupl = *pc; + + LY_ARRAY_FOR(plug_ctx->schemas, i) { + trm_reset_tree_ctx_by_plugin(plug_ctx, i, pc, tc); + max = trb_try_unified_indent(ca, pc, tc); + *max_gap_before_type = max > *max_gap_before_type ? max : *max_gap_before_type; + *tc = tc_dupl; + } + + *pc = pc_dupl; +} + +/** + * @brief For every extension instance print all schemas. + * + * @param[in] wr indentation wrapper for node. + * @param[in] ca parent settings. + * @param[in] pc function used for tree traversing. + * @param[in] tc tree context. + */ +static void +trb_ext_print_instances(struct trt_wrapper wr, struct trt_parent_cache ca, struct trt_printer_ctx *pc, + struct trt_tree_ctx *tc) +{ + LY_ERR rc; + LY_ARRAY_COUNT_TYPE i; + uint64_t last_instance = UINT64_MAX; + void *ext; + ly_bool child_exists; + uint32_t max, max_gap_before_type = 0; + + ca = tro_parent_cache_for_child(ca, tc); + /* if node is last sibling, then do not add '|' to wrapper */ + wr = trb_node_is_last_sibling(&pc->fp, tc) ? + trp_wrapper_set_shift(wr) : trp_wrapper_set_mark(wr); + + if (tc->lysc_tree) { + child_exists = tro_next_child(tc->cn, tc) ? 1 : 0; + } else { + child_exists = tro_next_child(tc->pn, tc) ? 1 : 0; + } + + i = 0; + while ((ext = trb_ext_iter(tc, &i))) { + struct lyspr_tree_ctx plug_ctx = {0}; + + rc = tro_ext_printer_tree(tc->lysc_tree, ext, &plug_ctx); + LY_CHECK_ERR_GOTO(rc, tc->last_error = rc, end); + trb_ext_try_unified_indent(&plug_ctx, ca, &max_gap_before_type, pc, tc); + if (plug_ctx.schemas) { + last_instance = i; + } + trp_ext_free_plugin_ctx(&plug_ctx); + } + + if (child_exists) { + pc->fp.modify.next_child(ca, tc); + max = trb_try_unified_indent(ca, pc, tc); + max_gap_before_type = max > max_gap_before_type ? max : max_gap_before_type; + pc->fp.modify.parent(tc); + } + + i = 0; + while ((ext = trb_ext_iter(tc, &i))) { + struct lyspr_tree_ctx plug_ctx = {0}; + + rc = tro_ext_printer_tree(tc->lysc_tree, ext, &plug_ctx); + LY_CHECK_ERR_GOTO(rc, tc->last_error = rc, end); + if (!child_exists && (last_instance == i)) { + trb_ext_print_schemas(&plug_ctx, 1, max_gap_before_type, wr, ca, pc, tc); + } else { + trb_ext_print_schemas(&plug_ctx, 0, max_gap_before_type, wr, ca, pc, tc); + } + trp_ext_free_plugin_ctx(&plug_ctx); + } + +end: + return; +} + +/** + * @brief Print subtree of nodes. + * + * The current node is expected to be the root of the subtree. + * Before root node is no linebreak printing. This must be addressed by + * the caller. Root node will also be printed. Behind last printed node + * is no linebreak. + * + * @param[in,out] node current processed node used as iterator. + * @param[in] max_gap_before_type is result from + * ::trb_try_unified_indent() function for root node. + * Set parameter to 0 if distance does not matter. + * @param[in] wr is wrapper saying how deep in the whole tree + * is the root of the subtree. + * @param[in] ca is parent_cache from root's parent. + * If root is top-level node, insert ::TRP_EMPTY_PARENT_CACHE. + * @param[in] pc is @ref TRP_trp settings. + * @param[in,out] tc is context of tree printer. + */ +static void +trb_print_subtree_nodes(struct trt_node *node, uint32_t max_gap_before_type, struct trt_wrapper wr, + struct trt_parent_cache ca, struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + if (!trp_node_is_empty(node)) { + /* Print root node. */ + trb_print_entire_node(node, max_gap_before_type, wr, pc, tc); + if (trp_ext_is_present_in_node(tc)) { + trb_ext_print_instances(wr, ca, pc, tc); + } + /* if node is last sibling, then do not add '|' to wrapper */ + wr = trb_node_is_last_sibling(&pc->fp, tc) ? + trp_wrapper_set_shift(wr) : trp_wrapper_set_mark(wr); + /* go to the child */ + ca = tro_parent_cache_for_child(ca, tc); + *node = pc->fp.modify.next_child(ca, tc); + if (trp_node_is_empty(node)) { + return; + } + /* TODO comment browse through instances + filtered. try unified indentation for children */ + max_gap_before_type = trb_try_unified_indent(ca, pc, tc); + } else { + /* Root node is ignored, continue with child. */ + *node = pc->fp.modify.first_sibling(ca, tc); + } + + do { + if (!tc->plugin_ctx.filtered && !trb_need_implicit_node_case(tc)) { + /* normal behavior */ + ly_print_(pc->out, "\n"); + trb_print_subtree_nodes(node, max_gap_before_type, wr, ca, pc, tc); + } else if (!tc->plugin_ctx.filtered) { + struct trt_wrapper wr_case_child; + + wr_case_child = trb_print_implicit_node(node, wr, pc, tc); + trb_print_subtree_nodes(node, max_gap_before_type, wr_case_child, ca, pc, tc); + } + /* go to the actual node's sibling */ + *node = pc->fp.modify.next_sibling(ca, tc); + } while (!trp_node_is_empty(node)); + + /* get back from child node to root node */ + pc->fp.modify.parent(tc); +} + +/** + * @brief Print all parents and their children. + * + * This function is suitable for printing top-level nodes that + * do not have ancestors. Function call ::trb_print_subtree_nodes() + * for all top-level siblings. Use this function after 'module' keyword + * or 'augment' and so. The nodes may not be exactly top-level in the + * tree, but the function considers them that way. + * + * @param[in] wr is wrapper saying how deeply the top-level nodes are + * immersed in the tree. + * @param[pc] pc contains mainly functions for printing. + * @param[in,out] tc is tree context. + */ +static void +trb_print_family_tree(struct trt_wrapper wr, struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + struct trt_parent_cache ca; + struct trt_node node; + uint32_t max_gap_before_type; + + if (!tro_tree_ctx_get_node(tc)) { + return; + } + + ca = TRP_EMPTY_PARENT_CACHE; + max_gap_before_type = trb_try_unified_indent(ca, pc, tc); + + if (!tc->lysc_tree) { + if ((tc->section == TRD_SECT_GROUPING) && (tc->tpn == tc->pn->parent)) { + ca.lys_config = 0x0; + } + } + + for (node = pc->fp.modify.first_sibling(ca, tc); + !trp_node_is_empty(&node); + node = pc->fp.modify.next_sibling(ca, tc)) { + ly_print_(pc->out, "\n"); + trb_print_subtree_nodes(&node, max_gap_before_type, wr, ca, pc, tc); + } +} + +/********************************************************************** + * Definition of trm main functions + *********************************************************************/ + +/** + * @brief Settings if lysp_node are used for browsing through the tree. + * + * @param[in] module YANG schema tree structure representing + * YANG module. + * @param[in] out is output handler. + * @param[in] max_line_length is the maximum line length limit + * that should not be exceeded. + * @param[in,out] pc will be adapted to lysp_tree. + * @param[in,out] tc will be adapted to lysp_tree. + */ +static void +trm_lysp_tree_ctx(const struct lys_module *module, struct ly_out *out, size_t max_line_length, + struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + *tc = (struct trt_tree_ctx) { + .lysc_tree = 0, + .section = TRD_SECT_MODULE, + .pmod = module->parsed, + .cmod = NULL, + .pn = module->parsed ? module->parsed->data : NULL, + .tpn = module->parsed ? module->parsed->data : NULL, + .cn = NULL, + .last_error = 0, + .plugin_ctx.ctx = NULL, + .plugin_ctx.schema = NULL, + .plugin_ctx.filtered = 0, + .plugin_ctx.node_overr = TRP_TREE_CTX_EMPTY_NODE_OVERR, + .plugin_ctx.last_schema = 1, + .plugin_ctx.last_error = 0 + }; + + pc->out = out; + + pc->fp.modify = TRP_TRT_FP_MODIFY_PARSED; + pc->fp.read = TRP_TRT_FP_READ_PARSED; + + pc->fp.print = (struct trt_fp_print) { + .print_features_names = tro_print_features_names, + .print_keys = tro_print_keys + }; + + pc->max_line_length = max_line_length; +} + +/** + * @brief Settings if lysc_node are used for browsing through the tree. + * + * Pointers to current nodes will be set to module data. + * + * @param[in] module YANG schema tree structure representing + * YANG module. + * @param[in] out is output handler. + * @param[in] max_line_length is the maximum line length limit + * that should not be exceeded. + * @param[in,out] pc will be adapted to lysc_tree. + * @param[in,out] tc will be adapted to lysc_tree. + */ +static void +trm_lysc_tree_ctx(const struct lys_module *module, struct ly_out *out, size_t max_line_length, + struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + *tc = (struct trt_tree_ctx) { + .lysc_tree = 1, + .section = TRD_SECT_MODULE, + .pmod = module->parsed, + .cmod = module->compiled, + .tpn = NULL, + .pn = NULL, + .cn = module->compiled->data, + .last_error = 0, + .plugin_ctx.ctx = NULL, + .plugin_ctx.schema = NULL, + .plugin_ctx.filtered = 0, + .plugin_ctx.node_overr = TRP_TREE_CTX_EMPTY_NODE_OVERR, + .plugin_ctx.last_schema = 1, + .plugin_ctx.last_error = 0 + }; + + pc->out = out; + + pc->fp.modify = TRP_TRT_FP_MODIFY_COMPILED; + pc->fp.read = TRP_TRT_FP_READ_COMPILED; + + pc->fp.print = (struct trt_fp_print) { + .print_features_names = tro_print_features_names, + .print_keys = tro_print_keys + }; + + pc->max_line_length = max_line_length; +} + +/** + * @brief Reset settings to browsing through the lysc tree. + * @param[in,out] pc resets to @ref TRP_troc functions. + * @param[in,out] tc resets to lysc browsing. + */ +static void +trm_reset_to_lysc_tree_ctx(struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + LY_ERR erc; + + erc = tc->last_error; + trp_ext_free_node_override(&tc->plugin_ctx.node_overr, &tc->plugin_ctx.filtered); + trm_lysc_tree_ctx(tc->pmod->mod, pc->out, pc->max_line_length, pc, tc); + tc->last_error = erc; +} + +/** + * @brief Reset settings to browsing through the lysp tree. + * @param[in,out] pc resets to @ref TRP_trop functions. + * @param[in,out] tc resets to lysp browsing. + */ +static void +trm_reset_to_lysp_tree_ctx(struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + LY_ERR erc; + + erc = tc->last_error; + trp_ext_free_node_override(&tc->plugin_ctx.node_overr, &tc->plugin_ctx.filtered); + trm_lysp_tree_ctx(tc->pmod->mod, pc->out, pc->max_line_length, pc, tc); + tc->last_error = erc; +} + +/** + * @brief If augment's target node is located on the current module. + * @param[in] pn is examined augment. + * @param[in] pmod is current module. + * @return 1 if nodeid refers to the local node, otherwise 0. + */ +static ly_bool +trm_nodeid_target_is_local(const struct lysp_node_augment *pn, const struct lysp_module *pmod) +{ + const char *id, *prefix, *name; + size_t prefix_len, name_len; + const struct lys_module *mod; + ly_bool ret = 0; + + if (pn == NULL) { + return ret; + } + + id = pn->nodeid; + if (!id) { + return ret; + } + /* only absolute-schema-nodeid is taken into account */ + assert(id[0] == '/'); + ++id; + + ly_parse_nodeid(&id, &prefix, &prefix_len, &name, &name_len); + if (prefix) { + mod = ly_resolve_prefix(pmod->mod->ctx, prefix, prefix_len, LY_VALUE_SCHEMA, pmod); + ret = mod ? (mod->parsed == pmod) : 0; + } else { + ret = 1; + } + + return ret; +} + +/** + * @brief Printing section module, rpcs, notifications or yang-data. + * + * First node must be the first child of 'module', + * 'rpcs', 'notifications' or 'yang-data'. + * + * @param[in] ks is section representation. + * @param[in] pc contains mainly functions for printing. + * @param[in,out] tc is the tree context. + */ +static void +trm_print_section_as_family_tree(struct trt_keyword_stmt ks, struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + assert(ks.section_name); + + trp_print_keyword_stmt(ks, pc->max_line_length, pc->out); + if (!strcmp(ks.section_name, TRD_KEYWORD_MODULE) || !strcmp(ks.section_name, TRD_KEYWORD_SUBMODULE)) { + trb_print_family_tree(TRP_INIT_WRAPPER_TOP, pc, tc); + } else { + trb_print_family_tree(TRP_INIT_WRAPPER_BODY, pc, tc); + } +} + +/** + * @brief Printing section augment or grouping. + * + * First node is 'augment' or 'grouping' itself. + * + * @param[in] ks is section representation. + * @param[in] pc contains mainly functions for printing. + * @param[in,out] tc is the tree context. + */ +static void +trm_print_section_as_subtree(struct trt_keyword_stmt ks, struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + assert(ks.section_name); + trp_print_keyword_stmt(ks, pc->max_line_length, pc->out); + trb_tree_ctx_set_child(tc); + trb_print_family_tree(TRP_INIT_WRAPPER_BODY, pc, tc); +} + +/** + * @brief Print 'module' keyword, its name and all nodes. + * @param[in] pc contains mainly functions for printing. + * @param[in,out] tc is the tree context. + */ +static void +trm_print_module_section(struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + trm_print_section_as_family_tree(pc->fp.read.module_name(tc), pc, tc); +} + +/** + * @brief For all augment sections: print 'augment' keyword, + * its target node and all nodes. + * @param[in] pc contains mainly functions for printing. + * @param[in,out] tc is the tree context. + */ +static void +trm_print_augmentations(struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + ly_bool once; + ly_bool origin_was_lysc_tree = 0; + struct trt_keyword_stmt ks; + + if (tc->lysc_tree) { + origin_was_lysc_tree = 1; + trm_reset_to_lysp_tree_ctx(pc, tc); + } + + once = 1; + for (ks = trop_modi_next_augment(tc); ks.section_name; ks = trop_modi_next_augment(tc)) { + + if (origin_was_lysc_tree) { + /* if lysc tree is used, then only augments targeting + * another module are printed + */ + if (trm_nodeid_target_is_local((const struct lysp_node_augment *)tc->tpn, tc->pmod)) { + continue; + } + } + + if (once) { + ly_print_(pc->out, "\n"); + ly_print_(pc->out, "\n"); + once = 0; + } else { + ly_print_(pc->out, "\n"); + } + + trm_print_section_as_subtree(ks, pc, tc); + } + + if (origin_was_lysc_tree) { + trm_reset_to_lysc_tree_ctx(pc, tc); + } +} + +/** + * @brief For rpcs section: print 'rpcs' keyword and all its nodes. + * @param[in] pc contains mainly functions for printing. + * @param[in,out] tc is the tree context. + */ +static void +trm_print_rpcs(struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + struct trt_keyword_stmt rpc; + + rpc = tro_modi_get_rpcs(tc); + + if (rpc.section_name) { + ly_print_(pc->out, "\n"); + ly_print_(pc->out, "\n"); + trm_print_section_as_family_tree(rpc, pc, tc); + } +} + +/** + * @brief For notifications section: print 'notifications' keyword + * and all its nodes. + * @param[in] pc contains mainly functions for printing. + * @param[in,out] tc is the tree context. + */ +static void +trm_print_notifications(struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + struct trt_keyword_stmt notifs; + + notifs = tro_modi_get_notifications(tc); + + if (notifs.section_name) { + ly_print_(pc->out, "\n"); + ly_print_(pc->out, "\n"); + trm_print_section_as_family_tree(notifs, pc, tc); + } +} + +/** + * @brief For all grouping sections: print 'grouping' keyword, its name + * and all nodes. + * @param[in] pc contains mainly functions for printing. + * @param[in,out] tc is the tree context. + */ +static void +trm_print_groupings(struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + ly_bool once; + struct trt_keyword_stmt ks; + + if (tc->lysc_tree) { + return; + } + + once = 1; + for (ks = trop_modi_next_grouping(tc); ks.section_name; ks = trop_modi_next_grouping(tc)) { + if (once) { + ly_print_(pc->out, "\n"); + ly_print_(pc->out, "\n"); + once = 0; + } else { + ly_print_(pc->out, "\n"); + } + trm_print_section_as_subtree(ks, pc, tc); + } +} + +/** + * @brief Print all sections defined in plugins. + * + * @param[in] pc contains mainly functions for printing. + * @param[in,out] tc is the tree context. + */ +static void +trm_print_plugin_ext(struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + LY_ERR rc; + ly_bool once; + LY_ARRAY_COUNT_TYPE i = 0, j; + struct trt_keyword_stmt ks, prev_ks = {0}; + struct trt_printer_ctx pc_dupl; + struct trt_tree_ctx tc_dupl; + struct trt_node node; + uint32_t max_gap_before_type; + void *ext; + + tc->section = TRD_SECT_PLUG_DATA; + + tc_dupl = *tc; + pc_dupl = *pc; + + once = 1; + + while ((ext = trb_mod_ext_iter(tc, &i))) { + struct lyspr_tree_ctx plug_ctx = {0}; + + rc = tro_ext_printer_tree(tc->lysc_tree, ext, &plug_ctx); + LY_CHECK_ERR_GOTO(rc, tc->last_error = rc, end); + if (!plug_ctx.schemas) { + continue; + } + + ks = tro_get_ext_section(tc, ext, &plug_ctx); + if (once || (prev_ks.section_name && strcmp(prev_ks.section_name, ks.section_name))) { + ly_print_(pc->out, "\n"); + ly_print_(pc->out, "\n"); + once = 0; + } else { + ly_print_(pc->out, "\n"); + } + trp_print_keyword_stmt(ks, pc->max_line_length, pc->out); + + max_gap_before_type = 0; + trb_ext_try_unified_indent(&plug_ctx, TRP_EMPTY_PARENT_CACHE, &max_gap_before_type, pc, tc); + LY_ARRAY_FOR(plug_ctx.schemas, j) { + trm_reset_tree_ctx_by_plugin(&plug_ctx, j, pc, tc); + node = TRP_EMPTY_NODE; + trb_print_subtree_nodes(&node, max_gap_before_type, TRP_INIT_WRAPPER_BODY, TRP_EMPTY_PARENT_CACHE, pc, tc); + } + + *tc = tc_dupl; + trp_ext_free_plugin_ctx(&plug_ctx); + prev_ks = ks; + } + +end: + *pc = pc_dupl; + return; +} + +/** + * @brief Print sections module, augment, rpcs, notifications, + * grouping, yang-data. + * @param[in] pc contains mainly functions for printing. + * @param[in,out] tc is the tree context. + */ +static void +trm_print_sections(struct trt_printer_ctx *pc, struct trt_tree_ctx *tc) +{ + trm_print_module_section(pc, tc); + trm_print_augmentations(pc, tc); + trm_print_rpcs(pc, tc); + trm_print_notifications(pc, tc); + trm_print_groupings(pc, tc); + trm_print_plugin_ext(pc, tc); + ly_print_(pc->out, "\n"); +} + +static LY_ERR +tree_print_check_error(struct ly_out_clb_arg *out, struct trt_tree_ctx *tc) +{ + if (out->last_error) { + return out->last_error; + } else if (tc->last_error) { + return tc->last_error; + } else { + return LY_SUCCESS; + } +} + +/********************************************************************** + * Definition of module interface + *********************************************************************/ + +LY_ERR +tree_print_module(struct ly_out *out, const struct lys_module *module, uint32_t UNUSED(options), size_t line_length) +{ + struct trt_printer_ctx pc; + struct trt_tree_ctx tc; + struct ly_out *new_out; + LY_ERR erc; + struct ly_out_clb_arg clb_arg = TRP_INIT_LY_OUT_CLB_ARG(TRD_PRINT, out, 0, LY_SUCCESS); + + LY_CHECK_ARG_RET3(module->ctx, out, module, module->parsed, LY_EINVAL); + + if ((erc = ly_out_new_clb(&trp_ly_out_clb_func, &clb_arg, &new_out))) { + return erc; + } + + line_length = line_length == 0 ? SIZE_MAX : line_length; + if ((module->ctx->flags & LY_CTX_SET_PRIV_PARSED) && module->compiled) { + trm_lysc_tree_ctx(module, new_out, line_length, &pc, &tc); + } else { + trm_lysp_tree_ctx(module, new_out, line_length, &pc, &tc); + } + + trm_print_sections(&pc, &tc); + erc = tree_print_check_error(&clb_arg, &tc); + + ly_out_free(new_out, NULL, 1); + + return erc; +} + +LY_ERR +tree_print_compiled_node(struct ly_out *out, const struct lysc_node *node, uint32_t options, size_t line_length) +{ + struct trt_printer_ctx pc; + struct trt_tree_ctx tc; + struct ly_out *new_out; + struct trt_wrapper wr; + LY_ERR erc; + struct ly_out_clb_arg clb_arg = TRP_INIT_LY_OUT_CLB_ARG(TRD_PRINT, out, 0, LY_SUCCESS); + + assert(out && node); + + if (!(node->module->ctx->flags & LY_CTX_SET_PRIV_PARSED)) { + return LY_EINVAL; + } + + if ((erc = ly_out_new_clb(&trp_ly_out_clb_func, &clb_arg, &new_out))) { + return erc; + } + + line_length = line_length == 0 ? SIZE_MAX : line_length; + trm_lysc_tree_ctx(node->module, new_out, line_length, &pc, &tc); + + trp_print_keyword_stmt(pc.fp.read.module_name(&tc), pc.max_line_length, pc.out); + trb_print_parents(node, NULL, &pc, &tc); + + if (!(options & LYS_PRINT_NO_SUBSTMT)) { + tc.cn = lysc_node_child(node); + wr = trb_count_depth(NULL, tc.cn); + trb_print_family_tree(wr, &pc, &tc); + } + ly_print_(out, "\n"); + + erc = tree_print_check_error(&clb_arg, &tc); + ly_out_free(new_out, NULL, 1); + + return erc; +} + +LY_ERR +tree_print_parsed_submodule(struct ly_out *out, const struct lysp_submodule *submodp, uint32_t UNUSED(options), + size_t line_length) +{ + struct trt_printer_ctx pc; + struct trt_tree_ctx tc; + struct ly_out *new_out; + LY_ERR erc; + struct ly_out_clb_arg clb_arg = TRP_INIT_LY_OUT_CLB_ARG(TRD_PRINT, out, 0, LY_SUCCESS); + + assert(submodp); + LY_CHECK_ARG_RET(submodp->mod->ctx, out, LY_EINVAL); + + if ((erc = ly_out_new_clb(&trp_ly_out_clb_func, &clb_arg, &new_out))) { + return erc; + } + + line_length = line_length == 0 ? SIZE_MAX : line_length; + trm_lysp_tree_ctx(submodp->mod, new_out, line_length, &pc, &tc); + tc.pmod = (struct lysp_module *)submodp; + tc.tpn = submodp->data; + tc.pn = tc.tpn; + + trm_print_sections(&pc, &tc); + erc = tree_print_check_error(&clb_arg, &tc); + + ly_out_free(new_out, NULL, 1); + + return erc; +} |