schema compile BUGFIX compile extensions of submodules

Fixes #2481

Author: michalvasko

src/schema_compile.c

@@ -1824,58 +1824,112 @@ lys_compile(struct lys_module *mod, struct lys_depset_unres *unres)
     return ret;
 }
 
-LY_ERR
-lys_compile_extensions(struct lys_module *mod)
+/**
+ * @brief Compile all extension definitions in a parsed module into the main module.
+ *
+ * @param[in] mod Module to use.
+ * @param[in] pmod Parsed (sub)module to use.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_extensions_pmod(struct lys_module *mod, struct lysp_module *pmod)
 {
     LY_ERR rc = LY_SUCCESS;
     struct lysc_ctx ctx = {0};
     LY_ARRAY_COUNT_TYPE u;
     struct lysp_ext *ep;
     struct lysc_ext *ec;
 
-    if (!mod->parsed->extensions) {
-        return LY_SUCCESS;
-    }
-
-    LYSC_CTX_INIT_PMOD(ctx, mod->parsed, NULL);
+    LYSC_CTX_INIT_PMOD(ctx, pmod, NULL);
 
-    /* allocate the array */
-    LY_ARRAY_CREATE_RET(mod->ctx, mod->extensions, LY_ARRAY_COUNT(mod->parsed->extensions), LY_EMEM);
+    LY_ARRAY_FOR(pmod->extensions, u) {
+        ep = &pmod->extensions[u];
 
-    /* compile all extension definitions */
-    LY_ARRAY_FOR(mod->parsed->extensions, u) {
-        ep = &mod->parsed->extensions[u];
-        ec = &mod->extensions[u];
+        /* allocate a new extension */
+        LY_ARRAY_NEW_GOTO(mod->ctx, mod->extensions, ec, rc, cleanup);
 
         /* compile the extension definition */
         DUP_STRING_GOTO(ctx.ctx, ep->name, ec->name, rc, cleanup);
         DUP_STRING_GOTO(ctx.ctx, ep->argname, ec->argname, rc, cleanup);
         ec->module = mod;
         ec->plugin_ref = ep->plugin_ref;
-
-        LY_ARRAY_INCREMENT(mod->extensions);
     }
 
-    /* compile all nested extension instances, which can reference the compiled definitions */
-    LY_ARRAY_FOR(mod->parsed->extensions, u) {
-        ep = &mod->parsed->extensions[u];
-        ec = &mod->extensions[u];
+cleanup:
+    return rc;
+}
+
+/**
+ * @brief Compile all ext instances of extension definitions in a parsed module.
+ *
+ * @param[in] mod Module to use.
+ * @param[in] mod_ext_idx Index in ext of @p mod to start at.
+ * @param[in] pmod Parsed (sub)module to use.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lys_compile_extensions_ext_pmod(struct lys_module *mod, LY_ARRAY_COUNT_TYPE mod_ext_idx, struct lysp_module *pmod)
+{
+    LY_ERR rc = LY_SUCCESS;
+    struct lysc_ctx ctx = {0};
+    LY_ARRAY_COUNT_TYPE u;
+    struct lysp_ext *ep;
+    struct lysc_ext *ec;
+
+    LYSC_CTX_INIT_PMOD(ctx, pmod, NULL);
+
+    LY_ARRAY_FOR(pmod->extensions, u) {
+        ep = &pmod->extensions[u];
+        ec = &mod->extensions[mod_ext_idx];
 
         lysc_update_path(&ctx, NULL, "{extension}");
         lysc_update_path(&ctx, NULL, ep->name);
 
         /* compile nested extensions */
-        COMPILE_EXTS_GOTO(&ctx, ep->exts, ec->exts, ec, rc, cleanup);
-
+        COMPILE_EXTS_GOTO(&ctx, ep->exts, ec->exts, ec, rc, next_line);
+next_line:
         lysc_update_path(&ctx, NULL, NULL);
         lysc_update_path(&ctx, NULL, NULL);
+
+        LY_CHECK_GOTO(rc, cleanup);
+
+        ++mod_ext_idx;
     }
 
 cleanup:
-    if (rc) {
-        lysc_update_path(&ctx, NULL, NULL);
-        lysc_update_path(&ctx, NULL, NULL);
+    return rc;
+}
+
+LY_ERR
+lys_compile_extensions(struct lys_module *mod)
+{
+    LY_ERR rc = LY_SUCCESS;
+    LY_ARRAY_COUNT_TYPE u, v;
+    struct lysp_include *inc;
+
+    /* compile all module and submodule extension definitions */
+    LY_CHECK_GOTO(rc = lys_compile_extensions_pmod(mod, mod->parsed), cleanup);
+    LY_ARRAY_FOR(mod->parsed->includes, u) {
+        LY_CHECK_GOTO(rc = lys_compile_extensions_pmod(mod, (struct lysp_module *)mod->parsed->includes[u].submodule),
+                cleanup);
     }
+
+    /* compile all nested extension instances, which can reference the compiled definitions,
+     * there is one extensions array in main mod for the parsed module and all submodules so we need a special index */
+    v = 0;
+    LY_CHECK_GOTO(rc = lys_compile_extensions_ext_pmod(mod, v, mod->parsed), cleanup);
+
+    v += LY_ARRAY_COUNT(mod->parsed->extensions);
+    LY_ARRAY_FOR(mod->parsed->includes, u) {
+        inc = &mod->parsed->includes[u];
+        LY_CHECK_GOTO(rc = lys_compile_extensions_ext_pmod(mod, v, (struct lysp_module *)inc->submodule), cleanup);
+
+        v += LY_ARRAY_COUNT(inc->submodule->extensions);
+    }
+
+    assert(v == LY_ARRAY_COUNT(mod->extensions));
+
+cleanup:
     return rc;
 }
 

src/tree_schema.c

@@ -1519,6 +1519,34 @@ lysp_resolve_ext_instance_log_path(const struct lysp_ctx *pctx, const struct lys
     return LY_SUCCESS;
 }
 
+/**
+ * @brief Find ext instance plugins for all the parsed extensions.
+ *
+ * @param[in] mod Module to use.
+ */
+static void
+lysp_resolve_ext_instance_plugins(struct lys_module *mod)
+{
+    LY_ARRAY_COUNT_TYPE u, v;
+    const struct lysp_include *inc;
+
+    /* module */
+    LY_ARRAY_FOR(mod->parsed->extensions, u) {
+        mod->parsed->extensions[u].plugin_ref = lyplg_ext_plugin_find(mod->ctx, mod->name,
+                mod->revision, mod->parsed->extensions[u].name);
+    }
+
+    /* submodules */
+    LY_ARRAY_FOR(mod->parsed->includes, v) {
+        inc = &mod->parsed->includes[v];
+
+        LY_ARRAY_FOR(inc->submodule->extensions, u) {
+            inc->submodule->extensions[u].plugin_ref = lyplg_ext_plugin_find(mod->ctx, mod->name,
+                    mod->revision, inc->submodule->extensions[u].name);
+        }
+    }
+}
+
 /**
  * @brief Resolve (find) all extension instance records and finish their parsing.
  *
@@ -2218,7 +2246,6 @@ lys_parse_in(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, const st
     struct lysp_yang_ctx *yangctx = NULL;
     struct lysp_yin_ctx *yinctx = NULL;
     struct lysp_ctx *pctx = NULL;
-    LY_ARRAY_COUNT_TYPE u;
     ly_bool mod_created = 0, mod_exists = 0;
 
     assert(ctx && in && new_mods);
@@ -2355,10 +2382,7 @@ lys_parse_in(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, const st
     LY_CHECK_GOTO(rc = lysp_resolve_import_include(pctx, mod->parsed, new_mods), cleanup);
 
     /* resolve extension plugins and parse extension instances */
-    LY_ARRAY_FOR(mod->parsed->extensions, u) {
-        mod->parsed->extensions[u].plugin_ref = lyplg_ext_plugin_find(mod->ctx, mod->name,
-                mod->revision, mod->parsed->extensions[u].name);
-    }
+    lysp_resolve_ext_instance_plugins(mod);
     LY_CHECK_GOTO(rc = lysp_resolve_ext_instance_records(pctx), cleanup);
 
     /* check name collisions */