path UPDATE context not required for freeing

Author: michalvasko

src/path.c

@@ -1091,15 +1091,15 @@ ly_path_compile_deref(const struct ly_ctx *ctx, const struct lysc_node *ctx_node
     }
     lref = (const struct lysc_type_leafref *)deref_leaf_node->type;
     LY_CHECK_GOTO(ret = ly_path_append(ctx, path2, path), cleanup);
-    ly_path_free(ctx, path2);
+    ly_path_free(path2);
     path2 = NULL;
 
     /* compile dereferenced leafref expression and append it to the path */
     LY_CHECK_GOTO(ret = ly_path_compile_leafref(ctx, node2, top_ext, lref->path, oper, target, format, prefix_data,
             &path2), cleanup);
     node2 = path2[LY_ARRAY_COUNT(path2) - 1].node;
     LY_CHECK_GOTO(ret = ly_path_append(ctx, path2, path), cleanup);
-    ly_path_free(ctx, path2);
+    ly_path_free(path2);
     path2 = NULL;
 
     /* properly parsed path must always continue with ')' and '/' */
@@ -1123,9 +1123,9 @@ ly_path_compile_deref(const struct ly_ctx *ctx, const struct lysc_node *ctx_node
     LY_CHECK_GOTO(ret = ly_path_append(ctx, path2, path), cleanup);
 
 cleanup:
-    ly_path_free(ctx, path2);
+    ly_path_free(path2);
     if (ret) {
-        ly_path_free(ctx, *path);
+        ly_path_free(*path);
         *path = NULL;
     }
     return ret;
@@ -1281,7 +1281,7 @@ _ly_path_compile(const struct ly_ctx *ctx, const struct lys_module *cur_mod, con
 
 cleanup:
     if (ret) {
-        ly_path_free(ctx, *path);
+        ly_path_free(*path);
         *path = NULL;
     }
     LOG_LOCBACK(cur_node ? 1 : 0, 0);
@@ -1486,7 +1486,7 @@ ly_path_predicates_free(const struct ly_ctx *ctx, struct ly_path_predicate *pred
 }
 
 void
-ly_path_free(const struct ly_ctx *ctx, struct ly_path *path)
+ly_path_free(struct ly_path *path)
 {
     LY_ARRAY_COUNT_TYPE u;
 
@@ -1495,7 +1495,7 @@ ly_path_free(const struct ly_ctx *ctx, struct ly_path *path)
     }
 
     LY_ARRAY_FOR(path, u) {
-        ly_path_predicates_free(ctx, path[u].predicates);
+        ly_path_predicates_free(path[u].node->module->ctx, path[u].predicates);
     }
     LY_ARRAY_FREE(path);
 }

src/path.h

@@ -257,9 +257,8 @@ void ly_path_predicates_free(const struct ly_ctx *ctx, struct ly_path_predicate
 /**
  * @brief Free ly_path structure.
  *
- * @param[in] ctx libyang context.
  * @param[in] path The structure ([sized array](@ref sizedarrays)) to free.
  */
-void ly_path_free(const struct ly_ctx *ctx, struct ly_path *path);
+void ly_path_free(struct ly_path *path);
 
 #endif /* LY_PATH_H_ */

src/plugins_types.c

@@ -895,17 +895,17 @@ lyplg_type_lypath_new(const struct ly_ctx *ctx, const char *value, size_t value_
             ly_err_clean((struct ly_ctx *)ctx, e);
         }
 
-        ly_path_free(ctx, *path);
+        ly_path_free(*path);
         *path = NULL;
     }
 
     return ret;
 }
 
 LIBYANG_API_DEF void
-lyplg_type_lypath_free(const struct ly_ctx *ctx, struct ly_path *path)
+lyplg_type_lypath_free(const struct ly_ctx *UNUSED(ctx), struct ly_path *path)
 {
-    ly_path_free(ctx, path);
+    ly_path_free(path);
 }
 
 LIBYANG_API_DEF LY_ERR
@@ -1014,7 +1014,7 @@ lyplg_type_resolve_leafref_get_target_path(const struct lyxp_expr *path, const s
     LY_CHECK_GOTO(lyxp_expr_parse(ctx_node->module->ctx, str_path, 0, 1, target_path), cleanup);
 
 cleanup:
-    ly_path_free(ctx_node->module->ctx, p);
+    ly_path_free(p);
     free(str_path);
     return rc;
 }

src/plugins_types/instanceid.c

@@ -307,7 +307,7 @@ lyplg_type_free_instanceid(const struct ly_ctx *ctx, struct lyd_value *value)
 {
     lydict_remove(ctx, value->_canonical);
     value->_canonical = NULL;
-    ly_path_free(ctx, value->target);
+    ly_path_free(value->target);
 }
 
 /**

src/schema_compile.c

@@ -866,7 +866,7 @@ lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, st
 
     /* get the target node */
     target = p[LY_ARRAY_COUNT(p) - 1].node;
-    ly_path_free(node->module->ctx, p);
+    ly_path_free(p);
 
     if (!(target->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
         LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target node is %s instead of leaf or leaf-list.",
@@ -1456,7 +1456,7 @@ lys_compile_unres_depset(struct ly_ctx *ctx, struct lys_glob_unres *unres)
             ret = ly_path_compile_leafref(cctx.ctx, l->node, cctx.ext, lref->path,
                     (l->node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
                     LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &path);
-            ly_path_free(l->node->module->ctx, path);
+            ly_path_free(path);
 
             assert(ret != LY_ERECOMPILE);
             if (ret) {

src/tree_data.c

@@ -3595,7 +3595,7 @@ lyd_find_path(const struct lyd_node *ctx_node, const char *path, ly_bool output,
 
 cleanup:
     lyxp_expr_free(LYD_CTX(ctx_node), expr);
-    ly_path_free(LYD_CTX(ctx_node), lypath);
+    ly_path_free(lypath);
     return ret;
 }
 

src/tree_data_new.c

@@ -1823,7 +1823,7 @@ lyd_new_path_(struct lyd_node *parent, const struct ly_ctx *ctx, const struct ly
             LY_ARRAY_INCREMENT(p);
         }
     }
-    ly_path_free(ctx, p);
+    ly_path_free(p);
     if (!ret) {
         /* set out params only on success */
         if (new_parent) {

src/tree_schema.c

@@ -644,7 +644,7 @@ lys_find_path_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node,
     ret = lys_find_lypath_atoms(p, set);
 
 cleanup:
-    ly_path_free(ctx, p);
+    ly_path_free(p);
     lyxp_expr_free(ctx, expr);
     return ret;
 }
@@ -679,7 +679,7 @@ lys_find_path(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const
     snode = p[LY_ARRAY_COUNT(p) - 1].node;
 
 cleanup:
-    ly_path_free(ctx, p);
+    ly_path_free(p);
     lyxp_expr_free(ctx, expr);
     return snode;
 }

src/tree_schema_common.c

@@ -1829,7 +1829,7 @@ lysc_node_lref_target(const struct lysc_node *node)
 
     /* get the target node */
     target = p[LY_ARRAY_COUNT(p) - 1].node;
-    ly_path_free(node->module->ctx, p);
+    ly_path_free(p);
 
     return target;
 }

src/xpath.c

@@ -4042,7 +4042,7 @@ xpath_deref(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_set
             if (!r) {
                 /* get the target node */
                 target = p[LY_ARRAY_COUNT(p) - 1].node;
-                ly_path_free(set->ctx, p);
+                ly_path_free(p);
 
                 LY_CHECK_RET(lyxp_set_scnode_insert_node(set, target, LYXP_NODE_ELEM, LYXP_AXIS_SELF, NULL));
             } /* else the target was found before but is disabled so it was removed */
@@ -8272,7 +8272,9 @@ eval_name_test_with_predicate(const struct lyxp_expr *exp, uint32_t *tok_idx, en
         options &= ~LYXP_SKIP_EXPR;
     }
     lydict_remove(set->ctx, ncname_dict);
-    ly_path_predicates_free(set->ctx, predicates);
+    if (predicates) {
+        ly_path_predicates_free(scnode->module->ctx, predicates);
+    }
     return rc;
 }