union REFACTOR minor updates

Author: michalvasko

src/plugins_types/union.c

@@ -155,42 +155,40 @@ lyb_parse_union(const void *lyb_data, size_t lyb_data_len, uint32_t *type_idx, c
  *
  * RFC7950 Section 15.5 defines the appropriate error app tag of "require-instance".
  *
- * @param[in,out] err Error record to be updated
- * @param[in] type leafref type used to extract target path
- * @param[in] value value attempting to be stored
- * @param[in] value_len Length of value that was attempted to be stored.
+ * @param[in,out] err Error record to be updated.
+ * @param[in] type Leafref type used to extract target path.
+ * @param[in] value Value attempted to be stored.
+ * @param[in] value_len Length of @p value.
  * @return LY_ERR value. Only possible errors are LY_SUCCESS and LY_EMEM.
  */
 static LY_ERR
 union_update_lref_err(struct ly_err_item *err, const struct lysc_type *type, const void *value, size_t value_len)
 {
     const struct lysc_type_leafref *lref;
     char *valstr = NULL;
-    int msg_len;
+    int r;
 
-    if ((err == NULL) || (type->basetype != LY_TYPE_LEAFREF)) {
+    if (!err || (type->basetype != LY_TYPE_LEAFREF)) {
+        /* nothing to do */
         return LY_SUCCESS;
     }
 
     lref = (const struct lysc_type_leafref *)type;
+
+    /* update error-app-tag */
     free(err->apptag);
     err->apptag = strdup("instance-required");
-    if (err->apptag == NULL) {
-        return LY_EMEM;
-    }
+    LY_CHECK_ERR_RET(!err->apptag, LOGMEM(NULL), LY_EMEM);
 
-    free(err->msg);
-    err->msg = NULL;
     valstr = strndup((const char *)value, value_len);
-    if (valstr == NULL) {
-        return LY_EMEM;
-    }
+    LY_CHECK_ERR_RET(!valstr, LOGMEM(NULL), LY_EMEM);
 
-    msg_len = asprintf(&err->msg, LY_ERRMSG_NOLREF_VAL, valstr, lyxp_get_expr(lref->path));
+    /* update error-message */
+    free(err->msg);
+    r = asprintf(&err->msg, LY_ERRMSG_NOLREF_VAL, valstr, lyxp_get_expr(lref->path));
     free(valstr);
-    if (msg_len == -1) {
-        return LY_EMEM;
-    }
+    LY_CHECK_ERR_RET(r == -1, LOGMEM(NULL), LY_EMEM);
+
     return LY_SUCCESS;
 }
 
@@ -214,7 +212,7 @@ union_store_type(const struct ly_ctx *ctx, struct lysc_type_union *type_u, uint3
         uint32_t options, ly_bool validate, const struct lyd_node *ctx_node, const struct lyd_node *tree,
         struct lys_glob_unres *unres, struct ly_err_item **err)
 {
-    LY_ERR urc, rc = LY_SUCCESS;
+    LY_ERR rc = LY_SUCCESS;
     struct lysc_type *type = type_u->types[type_idx];
     const void *value = NULL;
     size_t value_len = 0;
@@ -231,15 +229,12 @@ union_store_type(const struct ly_ctx *ctx, struct lysc_type_union *type_u, uint3
             /* value of another type, first store the value properly and then use its JSON value for parsing */
             rc = type_u->types[ti]->plugin->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)) {
+            if (rc && (rc != LY_EINCOMPLETE)) {
                 /* clear any leftover/freed garbage */
                 memset(&subvalue->value, 0, sizeof subvalue->value);
 
                 /* if this is a leafref, lets make sure we propagate the appropriate error, and not a type validation failure */
-                urc = union_update_lref_err(*err, type_u->types[ti], value, value_len);
-                if (urc != LY_SUCCESS) {
-                    rc = urc;
-                }
+                union_update_lref_err(*err, type_u->types[ti], value, value_len);
                 goto cleanup;
             }
 
@@ -272,15 +267,12 @@ union_store_type(const struct ly_ctx *ctx, struct lysc_type_union *type_u, uint3
 
     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)) {
+    if (rc && (rc != LY_EINCOMPLETE)) {
         /* clear any leftover/freed garbage */
         memset(&subvalue->value, 0, sizeof subvalue->value);
 
         /* if this is a leafref, lets make sure we propagate the appropriate error, and not a type validation failure */
-        urc = union_update_lref_err(*err, type, value, value_len);
-        if (urc != LY_SUCCESS) {
-            rc = urc;
-        }
+        union_update_lref_err(*err, type, value, value_len);
         goto cleanup;
     }
 
@@ -290,6 +282,7 @@ union_store_type(const struct ly_ctx *ctx, struct lysc_type_union *type_u, uint3
         if (rc) {
             /* validate failed, we need to free the stored value */
             type->plugin->free(ctx, &subvalue->value);
+            goto cleanup;
         }
     }