plugins REFACTOR various small changes

Author: Roytak

src/plugins.c

@@ -198,9 +198,9 @@ plugins_iter(const struct ly_ctx *ctx, enum LYPLG type, uint32_t *index)
 }
 
 /**
- * @brief Find the give @p type plugin record.
+ * @brief Find the given @p type plugin record.
  *
- * @param[in] ctx Context for which the plugin record is searched for, NULL for built-in plugins.
+ * @param[in] ctx Context for which the plugin record is searched for, NULL for static plugins.
  * @param[in] type Type of the plugin record to find.
  * @param[in] module Module name of the plugin record.
  * @param[in] revision Revision of the @p module.
@@ -244,13 +244,13 @@ lyplg_record_find(const struct ly_ctx *ctx, enum LYPLG type, const char *module,
 /**
  * @brief Find the plugin of the given @p type.
  *
- * @param[in] ctx Context for which the plugin record is searched for, NULL for built-in plugins.
+ * @param[in] ctx Context for which the plugin record is searched for, NULL for static plugins.
  * @param[in] type Type of the plugin record to find.
  * @param[in] module Module name of the plugin.
  * @param[in] revision Revision of the @p module.
  * @param[in] name Name of the plugin.
- * @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.
+ * @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)

src/plugins_exts.h

@@ -405,8 +405,7 @@ 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_ref;                   /**< reference to extension's manipulation callbacks plugin,
-                                                 use ::lysc_get_ext_plugin() to get the plugin */
+    uintptr_t plugin_ref;                   /**< reference to extension 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_internal.h

@@ -66,7 +66,7 @@ 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)
+ * @param[in] PLUGIN_REF Reference to a type plugin. Either an index of a static plugin (offset by +1)
  * or a pointer to an external plugin.
  * @return Type plugin.
  */
@@ -78,7 +78,7 @@ extern uint32_t ly_static_ext_plugins_count;
 /**
  * @brief Get an extension plugin.
  *
- * @param[in] PLUGIN_REF Reference to a plugin. Either an index of a static plugin (offset by +1)
+ * @param[in] PLUGIN_REF Reference to an extension plugin. Either an index of a static plugin (offset by +1)
  * or a pointer to an external plugin.
  * @return Extension plugin.
  */
@@ -115,7 +115,7 @@ void lyplg_clean(void);
  * only the plugins with NULL revision specified.
  * @param[in] name Name of the type which the plugin implements.
  * @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().
+ * by passing the returned ID to ::lysc_get_type_plugin() or ::LYSC_GET_TYPE_PLG.
  */
 uintptr_t lyplg_type_plugin_find(const struct ly_ctx *ctx, const char *module, const char *revision, const char *name);
 
@@ -128,7 +128,7 @@ uintptr_t lyplg_type_plugin_find(const struct ly_ctx *ctx, const char *module, c
  * only the plugins with NULL revision specified.
  * @param[in] name Name of the extension which the plugin implements.
  * @return ID of the found extension plugin, 0 if none found. The extension plugin can be obtained
- * by passing the returned ID to ::lysc_get_ext_plugin().
+ * by passing the returned ID to ::lysc_get_ext_plugin() or ::LYSC_GET_EXT_PLG.
  */
 uintptr_t lyplg_ext_plugin_find(const struct ly_ctx *ctx, const char *module, const char *revision, const char *name);
 

src/plugins_types.c

@@ -900,13 +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;
+    struct lyplg_type *type_plg;
 
     type = ((struct lysc_node_leaf *)node)->type;
-    type_plugin = LYSC_GET_TYPE_PLG(type->plugin_ref);
+    type_plg = 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,
+    r = type_plg->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) {
@@ -917,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 = type_plugin->print(node->module->ctx, &storage, format, prefix_data, &dyn, NULL);
+    v = type_plg->print(node->module->ctx, &storage, format, prefix_data, &dyn, NULL);
 
     /* store it in the dictionary, storage will be freed */
     if (dyn) {
@@ -926,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);
     }
 
-    type_plugin->free(node->module->ctx, &storage);
+    type_plg->free(node->module->ctx, &storage);
     return LY_SUCCESS;
 }
 
@@ -1052,7 +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;
+    struct lyplg_type *type_plg;
 
     LY_CHECK_ARG_RET(NULL, lref, node, value, errmsg, LY_EINVAL);
 
@@ -1099,7 +1099,7 @@ lyplg_type_resolve_leafref(const struct lysc_type_leafref *lref, const struct ly
         goto cleanup;
     }
 
-    type = LYSC_GET_TYPE_PLG(lref->plugin_ref);
+    type_plg = LYSC_GET_TYPE_PLG(lref->plugin_ref);
 
     /* check the result */
     if (target_path) {
@@ -1115,7 +1115,7 @@ lyplg_type_resolve_leafref(const struct lysc_type_leafref *lref, const struct ly
                 continue;
             }
 
-            if (!type->compare(LYD_CTX(node), &((struct lyd_node_term *)set.val.nodes[i].node)->value, value)) {
+            if (!type_plg->compare(LYD_CTX(node), &((struct lyd_node_term *)set.val.nodes[i].node)->value, value)) {
                 break;
             }
         }
@@ -1140,7 +1140,7 @@ lyplg_type_resolve_leafref(const struct lysc_type_leafref *lref, const struct ly
                 continue;
             }
 
-            if (!type->compare(LYD_CTX(node), &((struct lyd_node_term *)set.val.nodes[i].node)->value, value)) {
+            if (!type_plg->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,15 +178,16 @@ 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;
+    struct lyplg_type *type_plg;
 
     *err = NULL;
 
     if (subvalue->format == LY_VALUE_LYB) {
         lyb_parse_union(subvalue->original, subvalue->orig_len, &ti, &value, &value_len);
         if (ti != type_idx) {
             /* value of another type, first store the value properly and then use its JSON value for parsing */
-            rc = LYSC_GET_TYPE_PLG(type_u->types[ti]->plugin_ref)->store(ctx, type_u->types[ti], value, value_len,
+            type_plg = LYSC_GET_TYPE_PLG(type_u->types[ti]->plugin_ref);
+            rc = type_plg->store(ctx, type_u->types[ti], value, value_len,
                     LYPLG_TYPE_STORE_ONLY, subvalue->format, subvalue->prefix_data, subvalue->hints,
                     subvalue->ctx_node, &subvalue->value, unres, err);
             if ((rc != LY_SUCCESS) && (rc != LY_EINCOMPLETE)) {
@@ -204,7 +205,7 @@ union_store_type(const struct ly_ctx *ctx, struct lysc_type_union *type_u, uint3
                 value = strndup(value, value_len);
                 dynamic = 1;
             }
-            LYSC_GET_TYPE_PLG(type_u->types[ti]->plugin_ref)->free(ctx, &subvalue->value);
+            type_plg->free(ctx, &subvalue->value);
 
             format = LY_VALUE_JSON;
             prefix_data = NULL;
@@ -226,9 +227,9 @@ union_store_type(const struct ly_ctx *ctx, struct lysc_type_union *type_u, uint3
         opts |= LYPLG_TYPE_STORE_DYNAMIC;
     }
 
-    type_plugin = LYSC_GET_TYPE_PLG(type->plugin_ref);
+    type_plg = LYSC_GET_TYPE_PLG(type->plugin_ref);
 
-    rc = type_plugin->store(ctx, type, value, value_len, opts, format, prefix_data,
+    rc = type_plg->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 */
@@ -238,10 +239,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 = type_plugin->validate(ctx, type, ctx_node, tree, &subvalue->value, err);
+        rc = type_plg->validate(ctx, type, ctx_node, tree, &subvalue->value, err);
         if (rc) {
             /* validate failed, we need to free the stored value */
-            type_plugin->free(ctx, &subvalue->value);
+            type_plg->free(ctx, &subvalue->value);
         }
     }
 
@@ -274,7 +275,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;
+    struct lyplg_type *type_plg;
 
     *err = NULL;
 
@@ -312,11 +313,11 @@ union_find_type(const struct ly_ctx *ctx, struct lysc_type_union *type_u, struct
                 continue;
             }
 
-            type = LYSC_GET_TYPE_PLG(type_u->types[u]->plugin_ref);
+            type_plg = LYSC_GET_TYPE_PLG(type_u->types[u]->plugin_ref);
 
-            msg = ly_realloc(msg, msg_len + 4 + strlen(type->id) + 2 + strlen(errs[u]->msg) + 2);
+            msg = ly_realloc(msg, msg_len + 4 + strlen(type_plg->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", type->id, errs[u]->msg);
+            msg_len += sprintf(msg + msg_len, "    %s: %s\n", type_plg->id, errs[u]->msg);
         }
 
         ret = ly_err_new(err, LY_EVALID, LYVE_DATA, NULL, NULL, "%s", msg);
@@ -451,16 +452,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;
+    struct lyplg_type *subvalue_type_plg;
 
     *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 */
-    subvalue_type = LYSC_GET_TYPE_PLG(subvalue->value.realtype->plugin_ref);
-    LY_CHECK_RET(subvalue_type->duplicate(ctx, &subvalue->value, &orig));
-    subvalue_type->free(ctx, &subvalue->value);
+    subvalue_type_plg = LYSC_GET_TYPE_PLG(subvalue->value.realtype->plugin_ref);
+    LY_CHECK_RET(subvalue_type_plg->duplicate(ctx, &subvalue->value, &orig));
+    subvalue_type_plg->free(ctx, &subvalue->value);
 
     if (subvalue->format == LY_VALUE_LYB) {
         /* use the specific type to store and validate the value */
@@ -600,7 +601,6 @@ 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. */
@@ -620,8 +620,8 @@ lyplg_type_print_union(const struct ly_ctx *ctx, const struct lyd_value *value,
     }
 
     assert(format != LY_VALUE_LYB);
-    type = LYSC_GET_TYPE_PLG(subvalue->value.realtype->plugin_ref);
-    ret = (void *)type->print(ctx, &subvalue->value, format, prefix_data, dynamic, value_len);
+    ret = (void *)LYSC_GET_TYPE_PLG(subvalue->value.realtype->plugin_ref)->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_context.c

@@ -113,7 +113,7 @@ static void
 ctxs_exts(const struct lysc_ext_instance *exts, struct ly_ht *ht, int *size)
 {
     LY_ARRAY_COUNT_TYPE u;
-    struct lyplg_ext *ext;
+    struct lyplg_ext *ext_plg;
 
     /* sized array */
     *size += CTXS_SIZED_ARRAY(exts);
@@ -125,9 +125,9 @@ ctxs_exts(const struct lysc_ext_instance *exts, struct ly_ht *ht, int *size)
         *size += CTXS_SIZED_ARRAY(exts[u].substmts);
 
         /* compiled, substmts storage */
-        ext = LYSC_GET_EXT_PLG(exts[u].def->plugin_ref);
-        if (ext && ext->compiled_size) {
-            *size += ext->compiled_size(&exts[u], ht);
+        ext_plg = LYSC_GET_EXT_PLG(exts[u].def->plugin_ref);
+        if (ext_plg && ext_plg->compiled_size) {
+            *size += ext_plg->compiled_size(&exts[u], ht);
         }
     }
 }
@@ -789,6 +789,7 @@ ctxp_ext(const struct lysc_ext_instance *orig_ext, struct lysc_ext_instance *ext
         struct ly_set *ptr_set, void **mem)
 {
     LY_ARRAY_COUNT_TYPE u;
+    struct lyplg_ext *ext_plg;
 
     if (orig_ext->exts) {
         /* may be referenced in the parent */
@@ -822,8 +823,8 @@ ctxp_ext(const struct lysc_ext_instance *orig_ext, struct lysc_ext_instance *ext
     }
 
     /* compiled, substmts storage, use the plugin */
-    if (ext->def->plugin_ref && LYSC_GET_EXT_PLG(ext->def->plugin_ref)->compiled_print) {
-        LYSC_GET_EXT_PLG(ext->def->plugin_ref)->compiled_print(orig_ext, ext, addr_ht, ptr_set, mem);
+    if (ext->def->plugin_ref && (ext_plg = LYSC_GET_EXT_PLG(ext->def->plugin_ref))->compiled_print) {
+        ext_plg->compiled_print(orig_ext, ext, addr_ht, ptr_set, mem);
     } else {
         ext->compiled = NULL;
     }

src/schema_compile.c

@@ -114,6 +114,7 @@ LY_ERR
 lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *extp, struct lysc_ext_instance *ext, void *parent)
 {
     LY_ERR ret = LY_SUCCESS;
+    struct lyplg_ext *ext_plg;
 
     DUP_STRING_GOTO(ctx->ctx, extp->argument, ext->argument, ret, cleanup);
     ext->module = ctx->cur_mod;
@@ -132,11 +133,11 @@ lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *extp, struct lys
     COMPILE_EXTS_GOTO(ctx, extp->exts, ext->exts, ext, ret, cleanup);
 
     /* compile this extension */
-    if (ext->def->plugin_ref && LYSC_GET_EXT_PLG(ext->def->plugin_ref)->compile) {
+    if (ext->def->plugin_ref && (ext_plg = LYSC_GET_EXT_PLG(ext->def->plugin_ref))->compile) {
         if (ext->argument) {
             lysc_update_path(ctx, ext->module, ext->argument);
         }
-        ret = LYSC_GET_EXT_PLG(ext->def->plugin_ref)->compile(ctx, extp, ext);
+        ret = ext_plg->compile(ctx, extp, ext);
         if (ret == LY_ENOT) {
             lysc_ext_instance_free(ctx->ctx, ext);
         }
@@ -896,11 +897,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;
+    struct lyplg_type *type_plg;
 
     options = (ctx->ctx->opts & LY_CTX_REF_IMPLEMENTED) ? LYPLG_TYPE_STORE_IMPLEMENT : 0;
-    type_plugin = LYSC_GET_TYPE_PLG(type->plugin_ref);
-    rc = type_plugin->store(ctx->ctx, type, dflt, strlen(dflt), options, LY_VALUE_SCHEMA, (void *)dflt_pmod,
+    type_plg = LYSC_GET_TYPE_PLG(type->plugin_ref);
+    rc = type_plg->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 */
@@ -927,7 +928,7 @@ lys_compile_unres_dflt(struct lysc_ctx *ctx, struct lysc_node *node, struct lysc
     }
 
 cleanup:
-    type_plugin->free(ctx->ctx, &storage);
+    type_plg->free(ctx->ctx, &storage);
     return rc;
 }
 

src/schema_compile_amend.c

@@ -473,6 +473,7 @@ lysp_ext_dup(const struct ly_ctx *ctx, const struct lysp_module *pmod, void *par
     LY_ERR ret = LY_SUCCESS;
     struct ly_set pmods = {0};
     struct lysp_ctx pctx = {.parsed_mods = &pmods};
+    struct lyplg_ext *ext_plg;
 
     DUP_STRING_GOTO(ctx, orig_ext->name, ext->name, ret, cleanup);
     DUP_STRING_GOTO(ctx, orig_ext->argument, ext->argument, ret, cleanup);
@@ -486,10 +487,10 @@ lysp_ext_dup(const struct ly_ctx *ctx, const struct lysp_module *pmod, void *par
     ext->flags = orig_ext->flags;
 
     LY_CHECK_GOTO(ret = lysp_ext_children_dup(ctx, orig_ext->child, &ext->child), cleanup);
-    if (ext->plugin_ref && LYSC_GET_EXT_PLG(ext->plugin_ref)->parse) {
+    if (ext->plugin_ref && (ext_plg = LYSC_GET_EXT_PLG(ext->plugin_ref))->parse) {
         /* parse again */
         LY_CHECK_GOTO(ret = ly_set_add(&pmods, pmod, 1, NULL), cleanup);
-        LY_CHECK_GOTO(ret = LYSC_GET_EXT_PLG(ext->plugin_ref)->parse(&pctx, ext), cleanup);
+        LY_CHECK_GOTO(ret = ext_plg->parse(&pctx, ext), cleanup);
     }
 
 cleanup: