generic function for extension, yang-data flags is empty

Author: lePici

src/printer_tree.c

@@ -184,8 +184,7 @@ struct pt_indent {
 #define PT_FLAGS_TYPE_USES_OF_GROUPING "-u"
 #define PT_FLAGS_TYPE_RPC "-x"
 #define PT_FLAGS_TYPE_NOTIF "-n"
-#define PT_FLAGS_TYPE_YANG_DATA "--"
-#define PT_FLAGS_TYPE_STRUCTURE ""
+#define PT_FLAGS_TYPE_EXT ""
 #define PT_FLAGS_TYPE_MOUNT_POINT "mp"
 #define PT_NODE_NAME_PREFIX_CHOICE "("
 #define PT_NODE_NAME_PREFIX_CASE ":("
@@ -438,9 +437,7 @@ typedef enum {
  * @brief Type of extension to print.
  */
 typedef enum {
-    PT_EXT_STRUCTURE = 0,       /**< Yang Data Structure, RFC 8791 */
-    PT_EXT_AUG_STRUCTURE,       /**< Yang Data Structure Augmentation, RFC 8791 */
-    PT_EXT_YANG_DATA,           /**< yang-data, RFC 8340 */
+    PT_EXT_GENERIC,
     PT_EXT_SCHEMA_MOUNT,        /**< schema-mount subtree '\<node_name\>/', RFC 8340 */
     PT_EXT_SCHEMA_MOUNT_REF     /**< schema-mount parent reference subtree '\<node_name\>@' , RFC 8340 */
 } pt_extension_type;
@@ -2339,11 +2336,8 @@ pt_pnode_resolve_flags(struct pt_tree_ctx *tc, pt_parent_type ca_ancestor,
         return PT_FLAGS_TYPE_MOUNT_POINT;
     } else if (pn->nodetype & LYS_USES) {
         return PT_FLAGS_TYPE_USES_OF_GROUPING;
-    } else if (tc->plugin_ctx.schema && (tc->plugin_ctx.schema->ext == PT_EXT_YANG_DATA)) {
-        return PT_FLAGS_TYPE_YANG_DATA;
-    } else if (tc->plugin_ctx.schema &&
-            ((tc->plugin_ctx.schema->ext == PT_EXT_STRUCTURE) || (tc->plugin_ctx.schema->ext == PT_EXT_AUG_STRUCTURE))) {
-        return PT_FLAGS_TYPE_STRUCTURE;
+    } else if (tc->plugin_ctx.schema && (tc->plugin_ctx.schema->ext == PT_EXT_GENERIC)) {
+        return PT_FLAGS_TYPE_EXT;
     } else if ((pn->nodetype & LYS_INPUT) || (ca_ancestor == PT_ANCESTOR_RPC_INPUT)) {
         return PT_FLAGS_TYPE_RPC_INPUT_PARAMS;
     } else if ((pn->nodetype & LYS_OUTPUT) || (ca_ancestor == PT_ANCESTOR_RPC_OUTPUT)) {
@@ -2536,11 +2530,8 @@ pt_cnode_resolve_flags(struct pt_tree_ctx *tc)
 
     if (pt_ext_is_present(tc, "mount-point")) {
         return PT_FLAGS_TYPE_MOUNT_POINT;
-    } else if (tc->plugin_ctx.schema && (tc->plugin_ctx.schema->ext == PT_EXT_YANG_DATA)) {
-        return PT_FLAGS_TYPE_YANG_DATA;
-    } else if (tc->plugin_ctx.schema &&
-            ((tc->plugin_ctx.schema->ext == PT_EXT_STRUCTURE) || (tc->plugin_ctx.schema->ext == PT_EXT_AUG_STRUCTURE))) {
-        return PT_FLAGS_TYPE_STRUCTURE;
+    } else if (tc->plugin_ctx.schema && (tc->plugin_ctx.schema->ext == PT_EXT_GENERIC)) {
+        return PT_FLAGS_TYPE_EXT;
     } else if ((cn->nodetype & LYS_INPUT) || (cn->flags & LYS_IS_INPUT)) {
         return PT_FLAGS_TYPE_RPC_INPUT_PARAMS;
     } else if ((cn->nodetype & LYS_OUTPUT) || (cn->flags & LYS_IS_OUTPUT)) {
@@ -3175,7 +3166,7 @@ pt_ext_iter(const struct pt_tree_ctx *tc, const char *ext_name,
                 assert(name);
             }
         }
-    } while (ext && strcmp(name, ext_name));
+    } while (ext && ext_name && strcmp(name, ext_name));
 
     return ext;
 }
@@ -3847,218 +3838,168 @@ pt_print_groupings(struct pt_tree_ctx *tc)
 }
 
 /**
- * @brief Read extension and get storage pointer.
+ * @brief Read extension and get schema pointer.
  * @param[in] ext Extension to read.
  * @param[in] compiled Set to 1 if @p ext is from lysc tree.
- * @param[in] stmt_op Set to NULL to find data statement or set to one specific statement.
- * @return storage_p pointer from lysc_ext_instance or lysp_ext_instance extension.
+ * @return pointer to lysp or lysc node.
  */
-static void **
-pt_ext_read_storage(void *ext, ly_bool compiled, const enum ly_stmt *stmt_op)
+static void *
+pt_ext_read_storage(void *ext, ly_bool compiled)
 {
     LY_ARRAY_COUNT_TYPE i;
     enum ly_stmt stmt;
     void *substmts;
+    void **storage_p;
+    void *node = NULL, *child;
 
     substmts = compiled ? (void *)((struct lysc_ext_instance *)ext)->substmts :
             (void *)((struct lysp_ext_instance *)ext)->substmts;
 
     LY_ARRAY_FOR(substmts, i) {
-        stmt = compiled ? ((struct lysc_ext_instance *)ext)->substmts[i].stmt :
-                ((struct lysp_ext_instance *)ext)->substmts[i].stmt;
+        if (compiled) {
+            stmt = ((struct lysc_ext_instance *)ext)->substmts[i].stmt;
+            storage_p = ((struct lysc_ext_instance *)ext)->substmts[i].storage_p;
+        } else {
+            stmt = ((struct lysp_ext_instance *)ext)->substmts[i].stmt;
+            storage_p = ((struct lysp_ext_instance *)ext)->substmts[i].storage_p;
+        }
+
+        if (!storage_p) {
+            continue;
+        }
 
         /* find some data node */
-        if (!stmt_op) {
-            switch (stmt) {
-            case LY_STMT_NOTIFICATION:
-            case LY_STMT_INPUT:
-            case LY_STMT_OUTPUT:
-            case LY_STMT_ACTION:
-            case LY_STMT_RPC:
-            case LY_STMT_ANYDATA:
-            case LY_STMT_ANYXML:
-            case LY_STMT_CASE:
-            case LY_STMT_CHOICE:
-            case LY_STMT_CONTAINER:
-            case LY_STMT_LEAF:
-            case LY_STMT_LEAF_LIST:
-            case LY_STMT_LIST:
-                break;
-            default:
+        switch (stmt) {
+        case LY_STMT_NOTIFICATION:
+        case LY_STMT_INPUT:
+        case LY_STMT_OUTPUT:
+        case LY_STMT_ACTION:
+        case LY_STMT_RPC:
+        case LY_STMT_ANYDATA:
+        case LY_STMT_ANYXML:
+        case LY_STMT_CASE:
+        case LY_STMT_CHOICE:
+        case LY_STMT_CONTAINER:
+        case LY_STMT_LEAF:
+        case LY_STMT_LEAF_LIST:
+        case LY_STMT_LIST:
+            node = !node && *storage_p ? *storage_p : node;
+            break;
+        case LY_STMT_AUGMENT:
+            if (compiled) {
                 continue;
+            } else if (!*storage_p) {
+                continue;
+            } else {
+                /* for augment-structure */
+                child = (*((struct lysp_node_augment **)storage_p))->child;
+                node = child ? child : node;
             }
-            /* find one specific stmt */
-        } else if (*stmt_op != stmt) {
-            continue;
+            break;
+        default:
+            break;
         }
-        return compiled ? ((struct lysc_ext_instance *)ext)->substmts[i].storage_p :
-               ((struct lysp_ext_instance *)ext)->substmts[i].storage_p;
     }
 
-    return NULL;
+    return node;
 }
 
 /**
- * @brief Read extension and get storage pointer.
+ * @brief Read extension and get pointer to schema.
  * @param[in] ext Extension to read.
- * @param[in] compiled Set to 1 if @p ext is from lysc tree.
- * @param[in] stmt_op Set to NULL to find data statement or set to one specific statement.
- * @param[in] find_parsed Use lysc extension instance to find lysp extension instance
- * with the same name and use it.
+ * @param[in,out] compiled For input set to 1 if @p ext is compiled instance.
+ * For output is set to 1 if returned pointer is from compiled instance.
  * @param[out] ks Section name to fill.
- * @return storage_p pointer from lysc_ext_instance or lysp_ext_instance extension.
+ * @return pointer to lysp or lysc node.
  */
-static void **
-pt_ext_read(void *ext, ly_bool compiled, const enum ly_stmt *stmt_op,
-        ly_bool find_parsed, struct pt_keyword_stmt *ks)
+static void *
+pt_ext_read(void *ext, ly_bool *compiled, struct pt_keyword_stmt *ks)
 {
     LY_ARRAY_COUNT_TYPE i;
+    const char *name;
     struct lysc_ext_instance *ext_comp;
     struct lysp_ext_instance *ext_pars;
-    void **storage;
+    void *schema;
 
-    if (compiled) {
+    if (*compiled) {
         ext_comp = ext;
         ks->argument = ext_comp->argument;
-        if (!find_parsed) {
-            /* search in lysc_ext_instance */
-            storage = pt_ext_read_storage(ext_comp, 1, stmt_op);
-        } else {
-            if (!ext_comp->module->parsed) {
-                return NULL;
-            }
-            /* find lysp_ext_instance by lysc_ext_instance */
-            ext_pars = ext_comp->module->parsed->exts;
-            LY_ARRAY_FOR(ext_pars, i) {
-                if (!strcmp(ext_pars[i].argument, ext_comp->argument)) {
-                    break;
-                }
+        ks->section_name = ext_comp->def->name;
+        /* search in lysc_ext_instance */
+        schema = pt_ext_read_storage(ext_comp, 1);
+        *compiled = 1;
+        if (schema) {
+            return schema;
+        }
+        /* search in lysp_ext_instance */
+        *compiled = 0;
+        if (!ext_comp->module->parsed) {
+            return NULL;
+        }
+        /* find lysp_ext_instance by lysc_ext_instance */
+        ext_pars = ext_comp->module->parsed->exts;
+        LY_ARRAY_FOR(ext_pars, i) {
+            name = strchr(ext_pars->name, ':') + 1;
+            if (!strcmp(name, ext_comp->def->name) && !strcmp(ext_pars[i].argument, ext_comp->argument)) {
+                break;
             }
-            assert(ext_pars);
-            storage = pt_ext_read_storage(ext_pars, 0, stmt_op);
         }
+        assert(ext_pars);
+        schema = pt_ext_read_storage(ext_pars, 0);
     } else {
         ext_pars = ext;
         ks->argument = ext_pars->argument;
-        storage = pt_ext_read_storage(ext_pars, 0, stmt_op);
+        name = strchr(ext_pars->name, ':') + 1;
+        ks->section_name = name;
+        schema = pt_ext_read_storage(ext_pars, 0);
+        *compiled = 0;
     }
 
-    return storage;
+    return schema;
 }
 
 /**
- * @brief Print extension instance.
+ * @brief Print top-level extension instances.
  * @param[in] tc Tree context.
- * @param[in] ext_name Extension name to print.
- * @param[in] ext_type Extension type of @p ext_name.
- */
-static void
-pt_print_ext_instance(struct pt_tree_ctx *tc, const char *ext_name, pt_extension_type ext_type)
-{
-    ly_bool once = 1;
-    LY_ARRAY_COUNT_TYPE i = 0;
-    struct pt_keyword_stmt ks = PT_EMPTY_KEYWORD_STMT;
-    struct pt_node node;
-    void **storage;
-    void *ext;
-
-    tc->plugin_ctx.schema->compiled = tc->lysc_tree;
-    tc->plugin_ctx.schema->ext = ext_type;
-    ks.section_name = ext_name;
-
-    while ((ext = pt_ext_iter(tc, ext_name, 1, &i))) {
-        storage = pt_ext_read(ext, tc->lysc_tree, NULL, 0, &ks);
-        if (!storage) {
-            continue;
-        }
-        if (tc->lysc_tree) {
-            tc->cn = *storage;
-            tc->plugin_ctx.schema->ctree = tc->cn;
-            ks.has_node = tc->cn ? 1 : 0;
-        } else {
-            tc->pn = *storage;
-            tc->plugin_ctx.schema->ptree = tc->pn;
-            ks.has_node = tc->pn ? 1 : 0;
-        }
-        pt_print_keyword_stmt(&ks, &once, tc->out);
-        if (!ks.has_node) {
-            /* no subtree to print */
-            continue;
-        }
-        /* print subtree */
-        node = pt_modi_first_sibling(PT_EMPTY_PARENT_CACHE, tc);
-        pt_print_siblings(&node, PT_INIT_WRAPPER_BODY, PT_EMPTY_PARENT_CACHE, tc);
-    }
-}
-
-/**
- * @brief Print yang-data section.
- * @param[in,out] tc Tree context.
  */
 static void
-pt_print_yang_data(struct pt_tree_ctx tc)
+pt_print_extensions(struct pt_tree_ctx tc)
 {
-    struct pt_ext_tree_schema schema = {0};
-
-    tc.section = PT_SECT_PLUG_DATA;
-    tc.plugin_ctx.schema = &schema;
-
-    pt_print_ext_instance(&tc, "yang-data", PT_EXT_YANG_DATA);
-}
-
-/**
- * @brief Print structure section.
- * @param[in,out] tc Tree context.
- */
-static void
-pt_print_structure(struct pt_tree_ctx tc)
-{
-    struct pt_ext_tree_schema schema = {0};
-
-    tc.section = PT_SECT_PLUG_DATA;
-    tc.plugin_ctx.schema = &schema;
-
-    pt_print_ext_instance(&tc, "structure", PT_EXT_STRUCTURE);
-}
-
-/**
- * @brief Print augment structure section.
- * @param[in,out] tc Tree context.
- */
-static void
-pt_print_augment_structure(struct pt_tree_ctx tc)
-{
-    struct pt_ext_tree_schema schema = {0};
     ly_bool once = 1;
     LY_ARRAY_COUNT_TYPE i = 0;
     struct pt_keyword_stmt ks = PT_EMPTY_KEYWORD_STMT;
     struct pt_node node;
+    void *schema;
     void *ext;
-    enum ly_stmt stmt = LY_STMT_AUGMENT;
-    void **storage;
+    struct pt_ext_tree_schema ext_schema;
     ly_bool origin_lysc_tree = tc.lysc_tree;
 
     tc.section = PT_SECT_PLUG_DATA;
-    tc.plugin_ctx.schema = &schema;
-    tc.plugin_ctx.schema->ext = PT_EXT_AUG_STRUCTURE;
-    ks.section_name = "augment-structure";
+    tc.plugin_ctx.schema = &ext_schema;
+    tc.plugin_ctx.schema->ext = PT_EXT_GENERIC;
 
-    while ((ext = pt_ext_iter(&tc, ks.section_name, 1, &i))) {
+    while ((ext = pt_ext_iter(&tc, NULL, 1, &i))) {
         tc.lysc_tree = origin_lysc_tree;
 
-        storage = pt_ext_read(ext, tc.lysc_tree, &stmt, 1, &ks);
-        if (!storage) {
+        schema = pt_ext_read(ext, &tc.lysc_tree, &ks);
+        if (!strcmp(ks.section_name, "mount-point") ||
+                !strcmp(ks.section_name, "annotation")) {
+            /* extension ignored */
             continue;
         }
-
-        tc.lysc_tree = 0;
-
-        tc.plugin_ctx.schema->compiled = 0;
-        tc.pn = (*((struct lysp_node_augment **)storage))->child;
-        tc.plugin_ctx.schema->ptree = tc.pn;
-        ks.has_node = tc.pn ? 1 : 0;
+        if (tc.lysc_tree) {
+            tc.cn = schema;
+            tc.plugin_ctx.schema->ctree = tc.cn;
+            tc.plugin_ctx.schema->compiled = 1;
+            ks.has_node = tc.cn ? 1 : 0;
+        } else {
+            tc.pn = schema;
+            tc.plugin_ctx.schema->ptree = tc.pn;
+            tc.plugin_ctx.schema->compiled = 0;
+            ks.has_node = tc.pn ? 1 : 0;
+        }
         pt_print_keyword_stmt(&ks, &once, tc.out);
-        if (!tc.pn) {
+        if (!ks.has_node) {
             /* no subtree to print */
             continue;
         }
@@ -4068,8 +4009,6 @@ pt_print_augment_structure(struct pt_tree_ctx tc)
 
         tc.lysc_tree = origin_lysc_tree;
     }
-
-    return;
 }
 
 /**
@@ -4085,9 +4024,7 @@ pt_print_sections(struct pt_tree_ctx *tc)
     pt_print_rpcs(tc);
     pt_print_notifications(tc);
     pt_print_groupings(tc);
-    pt_print_yang_data(*tc);
-    pt_print_structure(*tc);
-    pt_print_augment_structure(*tc);
+    pt_print_extensions(*tc);
     ly_print_(tc->out, "\n");
 }