plugins UPDATE replace plg get fn call with macro

Also replace plugin by plugin_ref

Author: Roytak

src/log.c

@@ -30,6 +30,7 @@
 #include "in_internal.h"
 #include "ly_common.h"
 #include "plugins_exts.h"
+#include "plugins_internal.h"
 #include "set.h"
 #include "tree_data.h"
 #include "tree_data_internal.h"
@@ -885,7 +886,7 @@ lyplg_ext_parse_log(const struct lysp_ctx *pctx, const struct lysp_ext_instance
     ly_vlog_build_path_line(PARSER_CTX(pctx), &data_path, &schema_path, &line);
 
     va_start(ap, format);
-    ly_ext_log(PARSER_CTX(pctx), lysc_get_ext_plugin(ext->plugin)->id, level, err, data_path, schema_path, line, format, ap);
+    ly_ext_log(PARSER_CTX(pctx), LYSC_GET_EXT_PLG(ext->plugin_ref)->id, level, err, data_path, schema_path, line, format, ap);
     va_end(ap);
 }
 
@@ -902,7 +903,7 @@ lyplg_ext_compile_log(const struct lysc_ctx *cctx, const struct lysc_ext_instanc
     }
 
     va_start(ap, format);
-    ly_ext_log(ext->module->ctx, lysc_get_ext_plugin(ext->def->plugin)->id, level, err, NULL, schema_path, 0, format, ap);
+    ly_ext_log(ext->module->ctx, LYSC_GET_EXT_PLG(ext->def->plugin_ref)->id, level, err, NULL, schema_path, 0, format, ap);
     va_end(ap);
 }
 
@@ -919,7 +920,7 @@ lyplg_ext_compile_log_path(const char *path, const struct lysc_ext_instance *ext
     }
 
     va_start(ap, format);
-    ly_ext_log(ext->module->ctx, lysc_get_ext_plugin(ext->def->plugin)->id, level, err, NULL, schema_path, 0, format, ap);
+    ly_ext_log(ext->module->ctx, LYSC_GET_EXT_PLG(ext->def->plugin_ref)->id, level, err, NULL, schema_path, 0, format, ap);
     va_end(ap);
 }
 
@@ -940,7 +941,7 @@ _lyplg_ext_compile_log_err(const struct ly_err_item *eitem, const struct lysc_ex
     }
 
     va_start(ap, ext);
-    ly_ext_log(ext->module->ctx, lysc_get_ext_plugin(ext->def->plugin)->id, eitem->level, eitem->err,
+    ly_ext_log(ext->module->ctx, LYSC_GET_EXT_PLG(ext->def->plugin_ref)->id, eitem->level, eitem->err,
             data_path, schema_path, eitem->line, "%s", ap);
     va_end(ap);
 }

src/parser_lyb.c

@@ -32,6 +32,7 @@
 #include "parser_internal.h"
 #include "plugins_exts.h"
 #include "plugins_exts/metadata.h"
+#include "plugins_internal.h"
 #include "set.h"
 #include "tree.h"
 #include "tree_data.h"
@@ -267,9 +268,9 @@ lyb_read_term_value(const struct lysc_node_leaf *term, uint8_t **term_value, uin
     if (term->type->basetype == LY_TYPE_LEAFREF) {
         /* Leafref itself is ignored, the target is loaded directly. */
         type_lf = (struct lysc_type_leafref *)term->type;
-        lyb_data_len = lysc_get_type_plugin(type_lf->realtype->plugin)->lyb_data_len;
+        lyb_data_len = LYSC_GET_TYPE_PLG(type_lf->realtype->plugin_ref)->lyb_data_len;
     } else {
-        lyb_data_len = lysc_get_type_plugin(term->type->plugin)->lyb_data_len;
+        lyb_data_len = LYSC_GET_TYPE_PLG(term->type->plugin_ref)->lyb_data_len;
     }
 
     if (lyb_data_len < 0) {

src/plugins.c

@@ -108,7 +108,7 @@ static pthread_mutex_t plugins_guard = PTHREAD_MUTEX_INITIALIZER;
  * unloaded with the destroy of the last context. Therefore, to reload the list of plugins, all the contexts must be
  * destroyed and with the creation of a first new context after that, the plugins will be reloaded.
  */
-static uint32_t context_refcount = 0;
+static uint32_t context_refcount;
 
 /**
  * @brief Record describing an implemented extension.
@@ -127,51 +127,45 @@ struct lyplg_record {
 };
 
 #ifndef STATIC
-static struct ly_set plugins_handlers = {0};
+static struct ly_set plugins_handlers;
 #endif
-static struct ly_set plugins_types = {0};
-static struct ly_set plugins_extensions = {0};
+struct ly_set ly_plugins_types;
+struct ly_set ly_plugins_extensions;
 
-/**
- * @brief Get the plugin of the given @p type.
- *
- * @param[in] plugin_ref Reference to a plugin. Either an index of a built-in plugin (offset by +1)
- * or a pointer to an external plugin.
- * @param[in] type Type of the plugin to get.
- * @param[in] plugins Array of the built-in plugins used in case @p plugin_ref is an index of a built-in plugin.
- * @return Plugin of the given @p type or NULL if not found.
- */
-static void *
-lysc_get_plugin(uintptr_t plugin_ref, enum LYPLG type, const struct ly_set *plugins)
+/* global counters for the number of static plugins */
+uint32_t ly_static_type_plugins_count;
+uint32_t ly_static_ext_plugins_count;
+
+LIBYANG_API_DEF struct lyplg_type *
+lysc_get_type_plugin(uintptr_t plugin_ref)
 {
-    /* plugin_ref is offset by +1, so 0 is invalid (NULL ptr equivalent) */
     if (!plugin_ref) {
         return NULL;
     }
 
-    if (plugin_ref <= plugins->count) {
-        /* plugin is built-in, fetch it from the global list */
-        if (type == LYPLG_EXTENSION) {
-            return &((struct lyplg_ext_record *)plugins->objs[plugin_ref - 1])->plugin;
-        } else {
-            return &((struct lyplg_type_record *)plugins->objs[plugin_ref - 1])->plugin;
-        }
+    if (plugin_ref <= ly_plugins_types.count) {
+        /* plugin is static, fetch it from the global list */
+        return &((struct lyplg_type_record *)ly_plugins_types.objs[plugin_ref - 1])->plugin;
     } else {
-        /* plugin is external, return the pointer */
-        return (void *)plugin_ref;
+        /* plugin is dynamic, return the pointer */
+        return (struct lyplg_type *)plugin_ref;
     }
 }
 
-LIBYANG_API_DEF struct lyplg_type *
-lysc_get_type_plugin(uintptr_t plugin_ref)
-{
-    return lysc_get_plugin(plugin_ref, LYPLG_TYPE, &plugins_types);
-}
-
 LIBYANG_API_DEF struct lyplg_ext *
 lysc_get_ext_plugin(uintptr_t plugin_ref)
 {
-    return lysc_get_plugin(plugin_ref, LYPLG_EXTENSION, &plugins_extensions);
+    if (!plugin_ref) {
+        return NULL;
+    }
+
+    if (plugin_ref <= ly_plugins_extensions.count) {
+        /* plugin is static, fetch it from the global list */
+        return &((struct lyplg_ext_record *)ly_plugins_extensions.objs[plugin_ref - 1])->plugin;
+    } else {
+        /* plugin is dynamic, return the pointer */
+        return (struct lyplg_ext *)plugin_ref;
+    }
 }
 
 /**
@@ -190,9 +184,9 @@ plugins_iter(const struct ly_ctx *ctx, enum LYPLG type, uint32_t *index)
     assert(index);
 
     if (type == LYPLG_EXTENSION) {
-        plugins = ctx ? &ctx->plugins_extensions : &plugins_extensions;
+        plugins = ctx ? &ctx->plugins_extensions : &ly_plugins_extensions;
     } else {
-        plugins = ctx ? &ctx->plugins_types : &plugins_types;
+        plugins = ctx ? &ctx->plugins_types : &ly_plugins_types;
     }
 
     if (*index == plugins->count) {
@@ -255,35 +249,37 @@ lyplg_record_find(const struct ly_ctx *ctx, enum LYPLG type, const char *module,
  * @param[in] module Module name of the plugin.
  * @param[in] revision Revision of the @p module.
  * @param[in] name Name of the plugin.
- * @return Accessor to the callbacks plugin structure, use ::lysc_get_type_plugin()
- * or ::lysc_get_ext_plugin() on the returned value to get the actual plugin. 0 if not found.
+ * @return Reference to the callbacks plugin structure. Use ::LYSC_GET_TYPE_PLG()
+ * or ::LYSC_GET_EXT_PLG() on the returned value to get the actual plugin. 0 if not found.
  */
 static uintptr_t
 lyplg_plugin_find(const struct ly_ctx *ctx, enum LYPLG type, const char *module, const char *revision, const char *name)
 {
     struct lyplg_type_record *record = NULL;
-    uint32_t record_idx = 0;
+    uint32_t record_idx = 0, static_plugin_count;
 
     if (ctx) {
         /* try to find context specific plugin */
         record = lyplg_record_find(ctx, type, module, revision, name, &record_idx);
+        if (record) {
+            /* plugin found in the context, hence it is dynamic so return the ptr to it */
+            return (uintptr_t)&record->plugin;
+        }
     }
 
-    if (!record) {
-        /* try to find shared plugin */
-        record = lyplg_record_find(NULL, type, module, revision, name, &record_idx);
-    }
-
+    /* try to find shared plugin */
+    record = lyplg_record_find(NULL, type, module, revision, name, &record_idx);
     if (!record) {
         /* not found */
         return 0;
     }
 
-    if (!strncmp(record->plugin.id, "ly2 - ", 6)) {
-        /* internal plugin, return an index with an offset of +1 in order to keep 0 as an invalid index (a NULL ptr) */
+    static_plugin_count = (type == LYPLG_TYPE) ? ly_static_type_plugins_count : ly_static_ext_plugins_count;
+    if (record_idx < static_plugin_count) {
+        /* static plugin, return an index with an offset of +1 in order to keep 0 as an invalid index (a NULL ptr) */
         return record_idx + 1;
     } else {
-        /* external plugin, return the pointer */
+        /* dynamic plugin, return the pointer to it */
         return (uintptr_t)&record->plugin;
     }
 }
@@ -324,15 +320,15 @@ plugins_insert(struct ly_ctx *ctx, enum LYPLG type, const void *recs)
     if (type == LYPLG_EXTENSION) {
         const struct lyplg_ext_record *rec = (const struct lyplg_ext_record *)recs;
 
-        plugins = ctx ? &ctx->plugins_extensions : &plugins_extensions;
+        plugins = ctx ? &ctx->plugins_extensions : &ly_plugins_extensions;
 
         for (uint32_t i = 0; rec[i].name; i++) {
             LY_CHECK_RET(ly_set_add(plugins, (void *)&rec[i], 0, NULL));
         }
     } else { /* LYPLG_TYPE */
         const struct lyplg_type_record *rec = (const struct lyplg_type_record *)recs;
 
-        plugins = ctx ? &ctx->plugins_types : &plugins_types;
+        plugins = ctx ? &ctx->plugins_types : &ly_plugins_types;
 
         for (uint32_t i = 0; rec[i].name; i++) {
             LY_CHECK_RET(ly_set_add(plugins, (void *)&rec[i], 0, NULL));
@@ -358,9 +354,10 @@ lyplg_clean_(void)
         return;
     }
 
-    ly_set_erase(&plugins_types, NULL);
-    ly_set_erase(&plugins_extensions, NULL);
+    ly_set_erase(&ly_plugins_types, NULL);
+    ly_set_erase(&ly_plugins_extensions, NULL);
     ly_set_erase(&plugins_handlers, lyplg_close_cb);
+    ly_static_type_plugins_count = ly_static_ext_plugins_count = 0;
 }
 
 #endif
@@ -475,8 +472,8 @@ plugins_load_module(const char *pathname)
     }
 
     /* remember the current plugins lists for recovery */
-    types_count = plugins_types.count;
-    extensions_count = plugins_extensions.count;
+    types_count = ly_plugins_types.count;
+    extensions_count = ly_plugins_extensions.count;
 
     /* type plugin */
     ret = plugins_load(dlhandler, pathname, LYPLG_TYPE);
@@ -496,11 +493,11 @@ plugins_load_module(const char *pathname)
     dlclose(dlhandler);
 
     /* revert changes in the lists */
-    while (plugins_types.count > types_count) {
-        ly_set_rm_index(&plugins_types, plugins_types.count - 1, NULL);
+    while (ly_plugins_types.count > types_count) {
+        ly_set_rm_index(&ly_plugins_types, ly_plugins_types.count - 1, NULL);
     }
-    while (plugins_extensions.count > extensions_count) {
-        ly_set_rm_index(&plugins_extensions, plugins_extensions.count - 1, NULL);
+    while (ly_plugins_extensions.count > extensions_count) {
+        ly_set_rm_index(&ly_plugins_extensions, ly_plugins_extensions.count - 1, NULL);
     }
 
     return ret;
@@ -619,6 +616,11 @@ lyplg_init(ly_bool builtin_type_plugins_only, ly_bool static_plugins_only)
     LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_EXTENSION, plugins_schema_mount), error);
     LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_EXTENSION, plugins_structure), error);
 
+    /* the global plugin sets contain only static plugins at this point, so assign to the counters here.
+     * the counters are used to determine whether a plugin is static or not */
+    ly_static_type_plugins_count = ly_plugins_types.count;
+    ly_static_ext_plugins_count = ly_plugins_extensions.count;
+
 #ifndef STATIC
     if (!static_plugins_only) {
         /* external types */

src/plugins_exts.h

@@ -405,7 +405,8 @@ struct lysp_ext_instance {
     const char *argument;                   /**< optional value of the extension's argument */
     LY_VALUE_FORMAT format;                 /**< prefix format of the extension name/argument (::LY_VALUE_XML is YIN format) */
     void *prefix_data;                      /**< format-specific data for prefix resolution (see ly_resolve_prefix()) */
-    uintptr_t plugin;                       /**< extension plugin, use ::lysc_get_ext_plugin() */
+    uintptr_t plugin_ref;                   /**< reference to extension's manipulation callbacks plugin,
+                                                 use ::lysc_get_ext_plugin() to get the plugin */
 
     void *parent;                           /**< pointer to the parent statement holding the extension instance(s), use
                                                  ::lysp_ext_instance#parent_stmt to access the value/structure */

src/plugins_exts/nacm.c

@@ -20,6 +20,7 @@
 #include "compat.h"
 #include "libyang.h"
 #include "plugins_exts.h"
+#include "plugins_internal.h"
 
 struct nacm_dfs_arg {
     struct lysc_ext_instance *ext;
@@ -101,11 +102,11 @@ nacm_parse(struct lysp_ctx *pctx, struct lysp_ext_instance *ext)
         return LY_ENOT;
     }
 
-    ext_plugin = lysc_get_ext_plugin(ext->plugin);
+    ext_plugin = LYSC_GET_EXT_PLG(ext->plugin_ref);
 
     /* check for duplication */
     LY_ARRAY_FOR(parent->exts, u) {
-        parent_ext_plugin = lysc_get_ext_plugin(parent->exts[u].plugin);
+        parent_ext_plugin = LYSC_GET_EXT_PLG(parent->exts[u].plugin_ref);
         if ((&parent->exts[u] != ext) && parent_ext_plugin && !strcmp(parent_ext_plugin->id, ext_plugin->id)) {
             /* duplication of a NACM extension on a single node
              * We check for all NACM plugins since we want to catch even the situation that there is default-deny-all

src/plugins_internal.h

@@ -43,6 +43,50 @@
 #define LY_TYPE_INT32_STR "32bit integer"           /**< text representation of ::LY_TYPE_INT32 */
 #define LY_TYPE_INT64_STR "64bit integer"           /**< text representation of ::LY_TYPE_INT64 */
 
+/**
+ * @brief Shared (= not context specific) type plugins set.
+ */
+extern struct ly_set ly_plugins_types;
+
+/**
+ * @brief Shared (= not context specific) extension plugins set.
+ */
+extern struct ly_set ly_plugins_extensions;
+
+/**
+ * @brief Count of static type plugins.
+ */
+extern uint32_t ly_static_type_plugins_count;
+
+/**
+ * @brief Count of static extension plugins.
+ */
+extern uint32_t ly_static_ext_plugins_count;
+
+/**
+ * @brief Get a type plugin.
+ *
+ * @param[in] PLUGIN_REF Reference to a plugin. Either an index of a static plugin (offset by +1)
+ * or a pointer to an external plugin.
+ * @return Type plugin.
+ */
+#define LYSC_GET_TYPE_PLG(PLUGIN_REF) \
+    (((uintptr_t)(PLUGIN_REF) <= (uintptr_t)ly_static_type_plugins_count) ? \
+    (struct lyplg_type *)&((struct lyplg_type_record *)ly_plugins_types.objs[(PLUGIN_REF) - 1])->plugin : \
+    (struct lyplg_type *)(PLUGIN_REF))
+
+/**
+ * @brief Get an extension plugin.
+ *
+ * @param[in] PLUGIN_REF Reference to a plugin. Either an index of a static plugin (offset by +1)
+ * or a pointer to an external plugin.
+ * @return Extension plugin.
+ */
+#define LYSC_GET_EXT_PLG(PLUGIN_REF) \
+    (((uintptr_t)(PLUGIN_REF) <= (uintptr_t)ly_static_ext_plugins_count) ? \
+    (struct lyplg_ext *)&((struct lyplg_ext_record *)ly_plugins_extensions.objs[(PLUGIN_REF) - 1])->plugin : \
+    (struct lyplg_ext *)(PLUGIN_REF))
+
 /**
  * @brief Initiate libyang plugins.
  *

src/plugins_types.c

@@ -903,7 +903,7 @@ lyplg_type_print_val(const struct lysc_node *node, const char *canon, LY_VALUE_F
     struct lyplg_type *type_plugin;
 
     type = ((struct lysc_node_leaf *)node)->type;
-    type_plugin = lysc_get_type_plugin(type->plugin);
+    type_plugin = LYSC_GET_TYPE_PLG(type->plugin_ref);
 
     /* store the value */
     r = type_plugin->store(node->module->ctx, type, canon, strlen(canon), LYPLG_TYPE_STORE_ONLY, LY_VALUE_CANON,
@@ -1099,7 +1099,7 @@ lyplg_type_resolve_leafref(const struct lysc_type_leafref *lref, const struct ly
         goto cleanup;
     }
 
-    type = lysc_get_type_plugin(lref->plugin);
+    type = LYSC_GET_TYPE_PLG(lref->plugin_ref);
 
     /* check the result */
     if (target_path) {