plugins types UPDATE simplify type plugin getter

Author: roman

src/context.h

@@ -212,7 +212,7 @@ struct ly_ctx;
 #define LY_CTX_STATIC_PLUGINS_ONLY 0x2000 /**< By default, external plugins from directories the path to which is obtained
                                         from the `LIBYANG_TYPES_PLUGINS_DIR` and `LIBYANG_EXTENSIONS_PLUGINS_DIR` environmental variables
                                         are loaded. This option prevents loading of all external plugins and only
-                                        the static (built-in) plugins are loaded.
+                                        the static (built-in) plugins are loaded. */
 
 /* 0x80000000 reserved for internal use */
 

src/plugins.c

@@ -132,16 +132,41 @@ static struct ly_set plugins_handlers = {0};
 static struct ly_set plugins_types = {0};
 static struct ly_set plugins_extensions = {0};
 
-LIBYANG_API_DEF struct lyplg_type *
-lysc_get_type_plugin(uintptr_t plugin_id)
+/**
+ * @brief Get the plugin of the given @p type.
+ *
+ * @param[in] plugin_id Either an index of the built-in plugin (offset by +1) or a pointer to the 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_id 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_id, enum LYPLG type, const struct ly_set *plugins)
 {
-    if (plugin_id < plugins_types.count) {
-        return &((struct lyplg_type_record *)plugins_types.objs[plugin_id])->plugin;
+    /* plugin_id is offset by +1, so 0 is invalid (NULL ptr equivalent) */
+    if (!plugin_id) {
+        return NULL;
+    }
+
+    if (plugin_id <= plugins->count) {
+        /* plugin is built-in, fetch it from the global list */
+        if (type == LYPLG_EXTENSION) {
+            return &((struct lyplg_ext_record *)plugins->objs[plugin_id - 1])->plugin;
+        } else {
+            return &((struct lyplg_type_record *)plugins->objs[plugin_id - 1])->plugin;
+        }
     } else {
-        return (struct lyplg_type *)plugin_id;
+        /* plugin is external, return the pointer */
+        return (void *)plugin_id;
     }
 }
 
+LIBYANG_API_DEF struct lyplg_type *
+lysc_get_type_plugin(uintptr_t plugin_id)
+{
+    return lysc_get_plugin(plugin_id, LYPLG_TYPE, &plugins_types);
+}
+
 /**
  * @brief Iterate over list of loaded plugins of the given @p type.
  *
@@ -200,11 +225,11 @@ lyplg_record_find(const struct ly_ctx *ctx, enum LYPLG type, const char *module,
     return NULL;
 }
 
-LY_ERR
-_lyplg_type_plugin_find(const struct ly_ctx *ctx, const char *module, const char *revision, const char *name, uintptr_t *out)
+uintptr_t
+lyplg_type_plugin_find(const struct ly_ctx *ctx, const char *module, const char *revision, const char *name)
 {
     struct lyplg_type_record *record = NULL;
-    uint32_t record_idx;
+    uint32_t record_idx = 0;
 
     if (ctx) {
         /* try to find context specific plugin */
@@ -217,18 +242,17 @@ _lyplg_type_plugin_find(const struct ly_ctx *ctx, const char *module, const char
     }
 
     if (!record) {
-        return LY_ENOTFOUND;
+        /* not found */
+        return 0;
     }
 
     if (!strncmp(record->plugin.id, "ly2 - ", 6)) {
-        /* internal plugin, return an index */
-        *out = record_idx;
+        /* internal 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 */
-        *out = (uintptr_t)&record->plugin;
+        return (uintptr_t)&record->plugin;
     }
-
-    return LY_SUCCESS;
 }
 
 struct lyplg_type *

src/plugins_internal.h

@@ -61,8 +61,6 @@ LY_ERR lyplg_init(ly_bool builtin_type_plugins_only, ly_bool static_plugins_only
  */
 void lyplg_clean(void);
 
-LY_ERR _lyplg_type_plugin_find(const struct ly_ctx *ctx, const char *module, const char *revision, const char *name, uintptr_t *out);
-
 /**
  * @brief Find a type plugin.
  *
@@ -72,9 +70,10 @@ LY_ERR _lyplg_type_plugin_find(const struct ly_ctx *ctx, const char *module, con
  * @param[in] revision Revision of the module for which the plugin is implemented. NULL is not a wildcard, it matches
  * only the plugins with NULL revision specified.
  * @param[in] name Name of the type which the plugin implements.
- * @return Found type plugin, NULL if none found.
+ * @return ID of the found type plugin, 0 if none found. The type plugin can be obtained
+ * by passing the returned ID to ::lysc_get_type_plugin().
  */
-struct lyplg_type *lyplg_type_plugin_find(const struct ly_ctx *ctx, const char *module, const char *revision, const char *name);
+uintptr_t lyplg_type_plugin_find(const struct ly_ctx *ctx, const char *module, const char *revision, const char *name);
 
 /**
  * @brief Find an extension plugin.

src/plugins_types.c

@@ -900,11 +900,13 @@ lyplg_type_print_val(const struct lysc_node *node, const char *canon, LY_VALUE_F
     struct ly_err_item *err = NULL;
     const char *v;
     ly_bool dyn;
+    struct lyplg_type *type_plugin;
 
     type = ((struct lysc_node_leaf *)node)->type;
+    type_plugin = lysc_get_type_plugin(type->plugin);
 
     /* store the value */
-    r = lysc_get_type_plugin(type->plugin)->store(node->module->ctx, type, canon, strlen(canon), LYPLG_TYPE_STORE_ONLY, LY_VALUE_CANON,
+    r = type_plugin->store(node->module->ctx, type, canon, strlen(canon), LYPLG_TYPE_STORE_ONLY, LY_VALUE_CANON,
             NULL, LYD_HINT_DATA, node, &storage, NULL, &err);
     if (r && (r != LY_EINCOMPLETE)) {
         if (err) {
@@ -915,7 +917,7 @@ lyplg_type_print_val(const struct lysc_node *node, const char *canon, LY_VALUE_F
     }
 
     /* print it in the specific format */
-    v = lysc_get_type_plugin(type->plugin)->print(node->module->ctx, &storage, format, prefix_data, &dyn, NULL);
+    v = type_plugin->print(node->module->ctx, &storage, format, prefix_data, &dyn, NULL);
 
     /* store it in the dictionary, storage will be freed */
     if (dyn) {
@@ -924,7 +926,7 @@ lyplg_type_print_val(const struct lysc_node *node, const char *canon, LY_VALUE_F
         lydict_dup(node->module->ctx, v, value);
     }
 
-    lysc_get_type_plugin(type->plugin)->free(node->module->ctx, &storage);
+    type_plugin->free(node->module->ctx, &storage);
     return LY_SUCCESS;
 }
 
@@ -1050,6 +1052,7 @@ lyplg_type_resolve_leafref(const struct lysc_type_leafref *lref, const struct ly
     const char *val_str, *xp_err_msg;
     uint32_t i;
     int r;
+    struct lyplg_type *type;
 
     LY_CHECK_ARG_RET(NULL, lref, node, value, errmsg, LY_EINVAL);
 
@@ -1096,6 +1099,8 @@ lyplg_type_resolve_leafref(const struct lysc_type_leafref *lref, const struct ly
         goto cleanup;
     }
 
+    type = lysc_get_type_plugin(lref->plugin);
+
     /* check the result */
     if (target_path) {
         /* no or exact match(es) */
@@ -1110,7 +1115,7 @@ lyplg_type_resolve_leafref(const struct lysc_type_leafref *lref, const struct ly
                 continue;
             }
 
-            if (!lysc_get_type_plugin(lref->plugin)->compare(LYD_CTX(node), &((struct lyd_node_term *)set.val.nodes[i].node)->value, value)) {
+            if (!type->compare(LYD_CTX(node), &((struct lyd_node_term *)set.val.nodes[i].node)->value, value)) {
                 break;
             }
         }
@@ -1135,7 +1140,7 @@ lyplg_type_resolve_leafref(const struct lysc_type_leafref *lref, const struct ly
                 continue;
             }
 
-            if (!lysc_get_type_plugin(lref->plugin)->compare(LYD_CTX(node), &((struct lyd_node_term *)set.val.nodes[i].node)->value, value)) {
+            if (!type->compare(LYD_CTX(node), &((struct lyd_node_term *)set.val.nodes[i].node)->value, value)) {
                 rc = ly_set_add(*targets, set.val.nodes[i].node, 0, NULL);
                 LY_CHECK_GOTO(rc, cleanup);
             }

src/plugins_types/union.c

@@ -178,6 +178,7 @@ union_store_type(const struct ly_ctx *ctx, struct lysc_type_union *type_u, uint3
     LY_VALUE_FORMAT format;
     void *prefix_data;
     uint32_t opts = 0, ti;
+    struct lyplg_type *type_plugin;
 
     *err = NULL;
 
@@ -196,7 +197,7 @@ union_store_type(const struct ly_ctx *ctx, struct lysc_type_union *type_u, uint3
 
             assert(subvalue->value.realtype);
             value = lysc_get_type_plugin(subvalue->value.realtype->plugin)->print(ctx, &subvalue->value,
-                        LY_VALUE_JSON, NULL, &dynamic, &value_len);
+                    LY_VALUE_JSON, NULL, &dynamic, &value_len);
 
             /* to avoid leaks, free subvalue->value, but we need the value, which may be stored there */
             if (!dynamic) {
@@ -225,7 +226,9 @@ union_store_type(const struct ly_ctx *ctx, struct lysc_type_union *type_u, uint3
         opts |= LYPLG_TYPE_STORE_DYNAMIC;
     }
 
-    rc = lysc_get_type_plugin(type->plugin)->store(ctx, type, value, value_len, opts, format, prefix_data,
+    type_plugin = lysc_get_type_plugin(type->plugin);
+
+    rc = type_plugin->store(ctx, type, value, value_len, opts, format, prefix_data,
             subvalue->hints, subvalue->ctx_node, &subvalue->value, unres, err);
     if ((rc != LY_SUCCESS) && (rc != LY_EINCOMPLETE)) {
         /* clear any leftover/freed garbage */
@@ -235,10 +238,10 @@ union_store_type(const struct ly_ctx *ctx, struct lysc_type_union *type_u, uint3
 
     if (validate && (rc == LY_EINCOMPLETE)) {
         /* we need the value validated */
-        rc = lysc_get_type_plugin(type->plugin)->validate(ctx, type, ctx_node, tree, &subvalue->value, err);
+        rc = type_plugin->validate(ctx, type, ctx_node, tree, &subvalue->value, err);
         if (rc) {
             /* validate failed, we need to free the stored value */
-            lysc_get_type_plugin(type->plugin)->free(ctx, &subvalue->value);
+            type_plugin->free(ctx, &subvalue->value);
         }
     }
 
@@ -271,6 +274,7 @@ union_find_type(const struct ly_ctx *ctx, struct lysc_type_union *type_u, struct
     uint32_t *prev_lo, temp_lo = 0;
     char *msg = NULL;
     int msg_len = 0;
+    struct lyplg_type *type;
 
     *err = NULL;
 
@@ -308,9 +312,11 @@ union_find_type(const struct ly_ctx *ctx, struct lysc_type_union *type_u, struct
                 continue;
             }
 
-            msg = ly_realloc(msg, msg_len + 4 + strlen(lysc_get_type_plugin(type_u->types[u]->plugin)->id) + 2 + strlen(errs[u]->msg) + 2);
+            type = lysc_get_type_plugin(type_u->types[u]->plugin);
+
+            msg = ly_realloc(msg, msg_len + 4 + strlen(type->id) + 2 + strlen(errs[u]->msg) + 2);
             LY_CHECK_ERR_GOTO(!msg, ret = LY_EMEM, cleanup);
-            msg_len += sprintf(msg + msg_len, "    %s: %s\n", lysc_get_type_plugin(type_u->types[u]->plugin)->id, errs[u]->msg);
+            msg_len += sprintf(msg + msg_len, "    %s: %s\n", type->id, errs[u]->msg);
         }
 
         ret = ly_err_new(err, LY_EVALID, LYVE_DATA, NULL, NULL, "%s", msg);
@@ -445,14 +451,16 @@ lyplg_type_validate_union(const struct ly_ctx *ctx, const struct lysc_type *type
     struct lyd_value orig = {0};
     uint32_t type_idx;
     ly_bool validated = 0;
+    struct lyplg_type *subvalue_type;
 
     *err = NULL;
 
     /* because of types that do not store their own type as realtype (leafref), we are not able to call their
      * validate callback (there is no way to get the type) but even if possible, the value may be invalid
      * for the type, so we may have to perform union value storing again from scratch, but keep a value backup */
-    LY_CHECK_RET(lysc_get_type_plugin(subvalue->value.realtype->plugin)->duplicate(ctx, &subvalue->value, &orig));
-    lysc_get_type_plugin(subvalue->value.realtype->plugin)->free(ctx, &subvalue->value);
+    subvalue_type = lysc_get_type_plugin(subvalue->value.realtype->plugin);
+    LY_CHECK_RET(subvalue_type->duplicate(ctx, &subvalue->value, &orig));
+    subvalue_type->free(ctx, &subvalue->value);
 
     if (subvalue->format == LY_VALUE_LYB) {
         /* use the specific type to store and validate the value */
@@ -492,7 +500,8 @@ lyplg_type_compare_union(const struct ly_ctx *ctx, const struct lyd_value *val1,
     if (val1->subvalue->value.realtype != val2->subvalue->value.realtype) {
         return LY_ENOT;
     }
-    return lysc_get_type_plugin(val1->subvalue->value.realtype->plugin)->compare(ctx, &val1->subvalue->value, &val2->subvalue->value);
+    return lysc_get_type_plugin(val1->subvalue->value.realtype->plugin)->compare(ctx,
+            &val1->subvalue->value, &val2->subvalue->value);
 }
 
 LIBYANG_API_DEF int
@@ -503,7 +512,8 @@ lyplg_type_sort_union(const struct ly_ctx *ctx, const struct lyd_value *val1, co
     struct lysc_type **types;
 
     if (val1->subvalue->value.realtype == val2->subvalue->value.realtype) {
-        return lysc_get_type_plugin(val1->subvalue->value.realtype->plugin)->sort(ctx, &val1->subvalue->value, &val2->subvalue->value);
+        return lysc_get_type_plugin(val1->subvalue->value.realtype->plugin)->sort(ctx,
+                &val1->subvalue->value, &val2->subvalue->value);
     }
 
     /* compare according to the order of types */
@@ -561,8 +571,8 @@ lyb_union_print(const struct ly_ctx *ctx, struct lysc_type_union *type_u, struct
     LY_CHECK_RET((r != LY_SUCCESS) && (r != LY_EINCOMPLETE), NULL);
 
     /* Print subvalue in LYB format. */
-    pval = (void *)lysc_get_type_plugin(subvalue->value.realtype->plugin)->print(NULL, &subvalue->value, LY_VALUE_LYB, prefix_data, &dynamic,
-            &pval_len);
+    pval = (void *)lysc_get_type_plugin(subvalue->value.realtype->plugin)->print(NULL, &subvalue->value, LY_VALUE_LYB,
+            prefix_data, &dynamic, &pval_len);
     LY_CHECK_RET(!pval, NULL);
 
     /* Create LYB data. */
@@ -590,6 +600,7 @@ lyplg_type_print_union(const struct ly_ctx *ctx, const struct lyd_value *value,
     struct lyd_value_union *subvalue = value->subvalue;
     struct lysc_type_union *type_u = (struct lysc_type_union *)value->realtype;
     size_t lyb_data_len = 0;
+    struct lyplg_type *type;
 
     if ((format == LY_VALUE_LYB) && (subvalue->format == LY_VALUE_LYB)) {
         /* The return value is already ready. */
@@ -609,7 +620,8 @@ lyplg_type_print_union(const struct ly_ctx *ctx, const struct lyd_value *value,
     }
 
     assert(format != LY_VALUE_LYB);
-    ret = (void *)lysc_get_type_plugin(subvalue->value.realtype->plugin)->print(ctx, &subvalue->value, format, prefix_data, dynamic, value_len);
+    type = lysc_get_type_plugin(subvalue->value.realtype->plugin);
+    ret = (void *)type->print(ctx, &subvalue->value, format, prefix_data, dynamic, value_len);
     if (!value->_canonical && (format == LY_VALUE_CANON)) {
         /* the canonical value is supposed to be stored now */
         lydict_insert(ctx, subvalue->value._canonical, 0, (const char **)&value->_canonical);

src/printer_lyb.c

@@ -678,14 +678,16 @@ lyb_print_term_value(struct lyd_node_term *term, struct ly_out *out, struct lyly
     size_t value_len = 0;
     int32_t lyb_data_len;
     lyplg_type_print_clb print;
+    struct lyplg_type *type;
 
-    assert(term->value.realtype && lysc_get_type_plugin(term->value.realtype->plugin)->print && term->schema);
+    assert(term->value.realtype && (type = lysc_get_type_plugin(term->value.realtype->plugin)) &&
+            type->print && term->schema);
 
     /* Get length of LYB data to print. */
-    lyb_data_len = lysc_get_type_plugin(term->value.realtype->plugin)->lyb_data_len;
+    lyb_data_len = type->lyb_data_len;
 
     /* Get value and also print its length only if size is not fixed. */
-    print = lysc_get_type_plugin(term->value.realtype->plugin)->print;
+    print = type->print;
     if (lyb_data_len < 0) {
         /* Variable-length data. */
 

src/printer_xml.c

@@ -217,7 +217,8 @@ xml_print_meta(struct xmlpr_ctx *pctx, const struct lyd_node *node)
         ly_set_add(&ns_list, NULL, 0, NULL);
 
         /* print the value */
-        value = lysc_get_type_plugin(meta->value.realtype->plugin)->print(LYD_CTX(node), &meta->value, LY_VALUE_XML, &ns_list, &dynamic, NULL);
+        value = lysc_get_type_plugin(meta->value.realtype->plugin)->print(LYD_CTX(node),
+                &meta->value, LY_VALUE_XML, &ns_list, &dynamic, NULL);
 
         /* print namespaces connected with the value's prefixes */
         for (i = 1; i < ns_list.count; ++i) {
@@ -339,8 +340,8 @@ xml_print_term(struct xmlpr_ctx *pctx, const struct lyd_node_term *node)
     }
 
     /* print the value */
-    value = lysc_get_type_plugin(((struct lysc_node_leaf *)node->schema)->type->plugin)->print(LYD_CTX(node), &node->value, LY_VALUE_XML,
-            &ns_list, &dynamic, NULL);
+    value = lysc_get_type_plugin(((struct lysc_node_leaf *)node->schema)->type->plugin)->print(LYD_CTX(node),
+            &node->value, LY_VALUE_XML, &ns_list, &dynamic, NULL);
     LY_CHECK_ERR_GOTO(!value, rc = LY_EINVAL, cleanup);
 
     /* print node opening */

src/schema_compile.c

@@ -896,9 +896,11 @@ lys_compile_unres_dflt(struct lysc_ctx *ctx, struct lysc_node *node, struct lysc
     struct lyd_value storage = {0};
     struct ly_err_item *err = NULL;
     LY_VALUE_FORMAT format;
+    struct lyplg_type *type_plugin;
 
     options = (ctx->ctx->opts & LY_CTX_REF_IMPLEMENTED) ? LYPLG_TYPE_STORE_IMPLEMENT : 0;
-    rc = lysc_get_type_plugin(type->plugin)->store(ctx->ctx, type, dflt, strlen(dflt), options, LY_VALUE_SCHEMA, (void *)dflt_pmod,
+    type_plugin = lysc_get_type_plugin(type->plugin);
+    rc = type_plugin->store(ctx->ctx, type, dflt, strlen(dflt), options, LY_VALUE_SCHEMA, (void *)dflt_pmod,
             LYD_HINT_SCHEMA, node, &storage, unres, &err);
     if (rc == LY_ERECOMPILE) {
         /* fine, but we need to recompile */
@@ -925,7 +927,7 @@ lys_compile_unres_dflt(struct lysc_ctx *ctx, struct lysc_node *node, struct lysc
     }
 
 cleanup:
-    lysc_get_type_plugin(type->plugin)->free(ctx->ctx, &storage);
+    type_plugin->free(ctx->ctx, &storage);
     return rc;
 }