portugalfuturista/rizin
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename some rz_list funcs to rz_list_XXX_val (part 1) (#5671)

Browse source 
* Rename rz_list_find_ptr() to rz_list_find_val()
* Rename rz_list_delete_data() to rz_list_delete_val()
This commit is contained in:
Khairul Azhar Kasmiran 2025-12-25 22:01:49 +08:00 committed by GitHub
parent 10042e41f7
commit c1fc1419e4
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
23 changed files with 63 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
librz/arch/function.c
View file

@ -111,7 +111,7 @@ RZ_API void rz_analysis_function_free(void *_fcn) {
void **it;
rz_pvector_foreach (fcn->bbs, it) {
block = (RzAnalysisBlock *)*it;
rz_list_delete_data(block->fcns, fcn);
rz_list_delete_val(block->fcns, fcn);
rz_analysis_block_unref(block);
}
rz_pvector_free(fcn->bbs);
@ -191,7 +191,7 @@ RZ_API RzAnalysisFunction *rz_analysis_create_function(RzAnalysis *analysis, con
}
RZ_API bool rz_analysis_function_delete(RzAnalysisFunction *fcn) {
return rz_list_delete_data(fcn->analysis->fcns, fcn);
return rz_list_delete_val(fcn->analysis->fcns, fcn);
}
/**
@ -348,7 +348,7 @@ RZ_API void rz_analysis_function_add_block(RzAnalysisFunction *fcn, RzAnalysisBl
}
RZ_API void rz_analysis_function_remove_block(RzAnalysisFunction *fcn, RzAnalysisBlock *bb) {
rz_list_delete_data(bb->fcns, fcn);
rz_list_delete_val(bb->fcns, fcn);
if (fcn->meta._min != UT64_MAX && (fcn->meta._min == bb->addr || fcn->meta._max == bb->addr + bb->size)) {
// If a block is removed at the beginning or end, updating min/max is not trivial anymore, just invalidate

2
librz/arch/isa/hexagon/hexagon_arch.c
View file

@ -1061,7 +1061,7 @@ RZ_API void hex_extend_op(HexState *state, RZ_INOUT HexOp *op, const bool set_ne
if (ce) {
op->op.imm = imm_is_scaled(op->attr) ? (op->op.imm >> op->shift) : op->op.imm;
op->op.imm = ((op->op.imm & 0x3F) | ce->const_ext);
rz_list_delete_data(state->const_ext_l, ce);
rz_list_delete_val(state->const_ext_l, ce);
return;
}
}

2
librz/arch/parse.c
View file

@ -74,7 +74,7 @@ RZ_API bool rz_parse_plugin_del(RzParse *p, RZ_NONNULL RzParsePlugin *plugin) {
}
p->cur = NULL;
}
return rz_list_delete_data(p->parsers, plugin);
return rz_list_delete_val(p->parsers, plugin);
}
RZ_API bool rz_parse_use(RzParse *p, const char *name) {

2
librz/arch/similarity.c
View file

@ -331,7 +331,7 @@ static RZ_OWN RzAnalysisMatchResult *analysis_match_result_new(RZ_NONNULL RzAnal
// there is no need to sort unmatch_b because it is already sorted.
rz_list_foreach (result->matches, iter, pair) {
rz_list_delete_data(unmatch_b, (void *)pair->pair_b);
rz_list_delete_val(unmatch_b, (void *)pair->pair_b);
}
rz_th_pool_free(pool);

2
librz/bin/bfile.c
View file

@ -252,7 +252,7 @@ RZ_API ut64 rz_bin_file_delete_all(RzBin *bin) {
RZ_API bool rz_bin_file_delete(RzBin *bin, RzBinFile *bf) {
rz_return_val_if_fail(bin && bf, false);
RzListIter *it = rz_list_find_ptr(bin->binfiles, bf);
RzListIter *it = rz_list_find_val(bin->binfiles, bf);
rz_return_val_if_fail(it, false); // calling del on a bf not in the bin is a programming error
if (bin->cur == bf) {
bin->cur = NULL;

2
librz/config/config.c
View file

@ -391,7 +391,7 @@ RZ_API bool rz_config_rm(RzConfig *cfg, RZ_NONNULL const char *name) {
RzConfigNode *node = rz_config_node_get(cfg, name);
if (node) {
ht_sp_delete(cfg->ht, node->name);
rz_list_delete_data(cfg->nodes, node);
rz_list_delete_val(cfg->nodes, node);
return true;
}
return false;

6
librz/core/agraph.c
View file

@ -2311,9 +2311,9 @@ static void delete_dup_edges(RzAGraph *g) {
continue;
}
rz_list_delete(n->out_nodes, in_it2);
rz_list_delete_data(n->all_neighbours, b);
rz_list_delete_data(b->in_nodes, n);
rz_list_delete_data(b->all_neighbours, n);
rz_list_delete_val(n->all_neighbours, b);
rz_list_delete_val(b->in_nodes, n);
rz_list_delete_val(b->all_neighbours, n);
g->graph->n_edges--;
}
}

4
librz/core/cfile.c
View file

@ -1229,7 +1229,7 @@ RZ_API RZ_BORROW RzCoreFile *rz_core_file_open(RZ_NONNULL RzCore *r, RZ_NONNULL
r->file = fh;
rz_io_use_fd(r->io, fd->fd);
if (!rz_list_find_ptr(r->files, fh)) {
if (!rz_list_find_val(r->files, fh)) {
rz_list_append(r->files, fh);
}
if (rz_config_get_b(r->config, "cfg.debug")) {
@ -1331,7 +1331,7 @@ RZ_IPI void rz_core_file_bin_file_deleted(RzCore *core, RzBinFile *bf) {
RZ_API void rz_core_file_close(RzCoreFile *fh) {
rz_return_if_fail(fh && fh->core);
RzCore *r = fh->core;
RzListIter *fh_it = rz_list_find_ptr(r->files, fh);
RzListIter *fh_it = rz_list_find_val(r->files, fh);
rz_return_if_fail(fh_it);
RzIODesc *desc = rz_io_desc_get(r->io, fh->fd);
if (desc) {

2
librz/core/tui/tabs.c
View file

@ -236,7 +236,7 @@ RZ_IPI void rz_core_visual_closetab(RzCore *core) {
}
RzCoreVisualTab *tab = rz_list_get_n(visual->tabs, visual->tab);
if (tab) {
rz_list_delete_data(visual->tabs, tab);
rz_list_delete_val(visual->tabs, tab);
const int tabsCount = rz_list_length(visual->tabs);
if (tabsCount > 0) {
if (visual->tab > 0) {

4
librz/debug/bp.c
View file

@ -155,7 +155,7 @@ static void unlinkBreakpoint(RzBreakpoint *bp, RzBreakpointItem *b) {
bp->bps_idx[i] = NULL;
}
}
rz_list_delete_data(bp->bps, b);
rz_list_delete_val(bp->bps, b);
}
/**
@ -331,7 +331,7 @@ RZ_API int rz_bp_get_index_at(RzBreakpoint *bp, ut64 addr) {
RZ_API int rz_bp_del_index(RzBreakpoint *bp, int idx) {
if (idx >= 0 && idx < bp->bps_idx_count) {
rz_list_delete_data(bp->bps, bp->bps_idx[idx]);
rz_list_delete_val(bp->bps, bp->bps_idx[idx]);
bp->bps_idx[idx] = 0;
return true;
}

4
librz/debug/p/native/windows/windows_debug.c
View file

@ -776,7 +776,7 @@ static void *find_library(void *BaseOfDll) {
}
static void remove_library(PLIB_ITEM library) {
rz_list_delete_data(lib_list, library);
rz_list_delete_val(lib_list, library);
}
static void add_library(DWORD pid, LPVOID lpBaseOfDll, HANDLE hFile, char *dllname) {
@ -1178,7 +1178,7 @@ int w32_continue(RzDebug *dbg, int pid, int tid, int sig) {
}
if (th && th->bFinished) {
rz_list_delete_data(dbg->threads, th);
rz_list_delete_val(dbg->threads, th);
}
return tid;

2
librz/demangler/demangler.c
View file

@ -184,7 +184,7 @@ RZ_API bool rz_demangler_plugin_add(RZ_NONNULL RzDemangler *dem, RZ_NONNULL RzDe
RZ_API bool rz_demangler_plugin_del(RZ_NONNULL RzDemangler *dem, RZ_NONNULL RzDemanglerPlugin *plugin) {
rz_return_val_if_fail(dem && dem->plugins && plugin && plugin->language, false);
return rz_list_delete_data(dem->plugins, plugin);
return rz_list_delete_val(dem->plugins, plugin);
}
/**

2
librz/flag/flag.c
View file

@ -93,7 +93,7 @@ static void remove_offsetmap(RzFlag *f, RzFlagItem *item) {
rz_return_if_fail(f && item);
RzFlagsAtOffset *flags = rz_flag_get_nearest_list(f, item->offset, 0);
if (flags) {
rz_list_delete_data(flags->flags, item);
rz_list_delete_val(flags->flags, item);
if (rz_list_empty(flags->flags)) {
rz_skiplist_delete(f->by_off, flags);
}

4
librz/include/rz_list.h
View file

@ -89,7 +89,7 @@ RZ_API RZ_OWN RzList *rz_list_uniq(RZ_NONNULL const RzList *list, RZ_NONNULL RzL
RZ_API void rz_list_sorted_uniq(RZ_NONNULL RzList *list, RZ_NONNULL RzListComparator cmp, void *user);
RZ_API void rz_list_init(RZ_NONNULL RzList *list);
RZ_API void rz_list_delete(RZ_NONNULL RzList *list, RZ_NONNULL RzListIter *iter);
RZ_API bool rz_list_delete_data(RZ_NONNULL RzList *list, void *ptr);
RZ_API bool rz_list_delete_val(RZ_NONNULL RzList *list, void *ptr);
RZ_API void rz_list_purge(RZ_NONNULL RzList *list);
RZ_API void rz_list_free(RZ_NULLABLE RzList *list);
RZ_API RZ_OWN RzListIter *rz_list_item_new(RZ_NULLABLE void *data);
@ -108,7 +108,7 @@ RZ_API RZ_OWN char *rz_list_to_str(RZ_NONNULL RzList *list, char ch);
/* hashlike api */
RZ_API RZ_BORROW RzListIter *rz_list_contains(RZ_NONNULL const RzList *list, RZ_NONNULL const void *ptr);
RZ_API RZ_BORROW RzListIter *rz_list_find_ptr(RZ_NONNULL const RzList *list, RZ_NONNULL const void *ptr);
RZ_API RZ_BORROW RzListIter *rz_list_find_val(RZ_NONNULL const RzList *list, RZ_NONNULL const void *ptr);
RZ_API RZ_BORROW RzListIter *rz_list_find(RZ_NONNULL const RzList *list, const void *p, RZ_NONNULL RzListComparator cmp, void *user);
#ifdef __cplusplus

2
librz/lang/lang.c
View file

@ -141,7 +141,7 @@ RZ_API bool rz_lang_plugin_del(RzLang *lang, RZ_NONNULL RzLangPlugin *plugin) {
if (!plugin_fini(lang, plugin)) {
return false;
}
return rz_list_delete_data(lang->langs, plugin);
return rz_list_delete_val(lang->langs, plugin);
}
RZ_API RzLangPlugin *rz_lang_get_by_extension(RzLang *lang, const char *ext) {

2
librz/mark/mark.c
View file

@ -81,7 +81,7 @@ static void remove_offsetmap(RzMark *b, RzMarkItem *item) {
rz_return_if_fail(b && item);
RzMarksAtOffset *marks = rz_mark_get_nearest_list(b, item->from, 0);
if (marks) {
rz_list_delete_data(marks->marks, item);
rz_list_delete_val(marks->marks, item);
if (rz_list_empty(marks->marks)) {
rz_skiplist_delete(b->by_off, marks);
}

2
librz/reg/reg.c
View file

@ -240,7 +240,7 @@ RZ_API void rz_reg_free_internal(RzReg *reg, bool init) {
rz_list_free(reg->regset[i].regs);
reg->regset[i].regs = NULL;
// Ensure arena is freed and its registered in the pool
if (!rz_list_delete_data(reg->regset[i].pool, reg->regset[i].arena)) {
if (!rz_list_delete_val(reg->regset[i].pool, reg->regset[i].arena)) {
rz_reg_arena_free(reg->regset[i].arena);
}
reg->regset[i].arena = NULL;

24
librz/util/graph.c
View file

@ -186,18 +186,18 @@ RZ_API void rz_graph_del_node(RzGraph *t, RZ_OWN RzGraphNode *n) {
return;
}
rz_list_foreach (n->in_nodes, it, gn) {
rz_list_delete_data(gn->out_nodes, n);
rz_list_delete_data(gn->all_neighbours, n);
rz_list_delete_val(gn->out_nodes, n);
rz_list_delete_val(gn->all_neighbours, n);
t->n_edges--;
}
rz_list_foreach (n->out_nodes, it, gn) {
rz_list_delete_data(gn->in_nodes, n);
rz_list_delete_data(gn->all_neighbours, n);
rz_list_delete_val(gn->in_nodes, n);
rz_list_delete_val(gn->all_neighbours, n);
t->n_edges--;
}
rz_list_delete_data(t->nodes, n);
rz_list_delete_val(t->nodes, n);
t->n_nodes--;
}
@ -224,9 +224,9 @@ RZ_API RzGraphNode *rz_graph_node_split_forward(RzGraph *g, RzGraphNode *split_m
RzListIter *iter;
RzGraphNode *n;
rz_list_foreach (front->out_nodes, iter, n) {
rz_list_delete_data(n->in_nodes, split_me); // optimize me
rz_list_delete_data(n->all_neighbours, split_me); // boy this all_neighbours is so retarding perf here
rz_list_delete_data(split_me->all_neighbours, n);
rz_list_delete_val(n->in_nodes, split_me); // optimize me
rz_list_delete_val(n->all_neighbours, split_me); // boy this all_neighbours is so retarding perf here
rz_list_delete_val(split_me->all_neighbours, n);
rz_list_append(n->all_neighbours, front);
rz_list_append(n->in_nodes, front);
rz_list_append(front->all_neighbours, n);
@ -238,10 +238,10 @@ RZ_API void rz_graph_del_edge(RzGraph *t, RzGraphNode *from, RzGraphNode *to) {
if (!from || !to || !rz_graph_adjacent(t, from, to)) {
return;
}
rz_list_delete_data(from->out_nodes, to);
rz_list_delete_data(from->all_neighbours, to);
rz_list_delete_data(to->in_nodes, from);
rz_list_delete_data(to->all_neighbours, from);
rz_list_delete_val(from->out_nodes, to);
rz_list_delete_val(from->all_neighbours, to);
rz_list_delete_val(to->in_nodes, from);
rz_list_delete_val(to->all_neighbours, from);
t->n_edges--;
}

22
librz/util/list.c
View file

@ -169,12 +169,12 @@ RZ_API void rz_list_free(RZ_NULLABLE RzList *list) {
}
/**
* \brief Deletes an entry in the list by searching for a pointer
* \brief Deletes a node in the list by searching for a pointer value.
*
**/
RZ_API bool rz_list_delete_data(RZ_NONNULL RzList *list, void *ptr) {
RZ_API bool rz_list_delete_val(RZ_NONNULL RzList *list, void *val) {
rz_return_val_if_fail(list, false);
RzListIter *iter = rz_list_find_ptr(list, ptr);
RzListIter *iter = rz_list_find_val(list, val);
if (!iter) {
return false;
}
@ -183,7 +183,7 @@ RZ_API bool rz_list_delete_data(RZ_NONNULL RzList *list, void *ptr) {
}
/**
* \brief Removes an entry in the list by using the RzListIter pointer
* \brief Deletes a node in the list by using an RzListIter pointer.
*
**/
RZ_API void rz_list_delete(RZ_NONNULL RzList *list, RZ_NONNULL RzListIter *iter) {
@ -615,23 +615,23 @@ RZ_API RZ_BORROW void *rz_list_get_n(RZ_NONNULL const RzList *list, ut32 n) {
}
/**
* \brief Returns the RzListIter of the given pointer, if found
* \brief Returns the RzListIter of the given pointer value, if found.
*
**/
RZ_API RZ_BORROW RzListIter *rz_list_contains(RZ_NONNULL const RzList *list, RZ_NONNULL const void *ptr) {
return rz_list_find_ptr(list, ptr);
RZ_API RZ_BORROW RzListIter *rz_list_contains(RZ_NONNULL const RzList *list, RZ_NONNULL const void *val) {
return rz_list_find_val(list, val);
}
/**
* \brief Returns the RzListIter of the given pointer, if found
* \brief Returns the RzListIter of the given pointer value, if found.
*
**/
RZ_API RZ_BORROW RzListIter *rz_list_find_ptr(RZ_NONNULL const RzList *list, RZ_NONNULL const void *ptr) {
RZ_API RZ_BORROW RzListIter *rz_list_find_val(RZ_NONNULL const RzList *list, RZ_NONNULL const void *val) {
rz_return_val_if_fail(list, NULL);
void *p;
RzListIter *iter;
rz_list_foreach (list, iter, p) {
if (ptr == p) {
if (val == p) {
return iter;
}
}
@ -642,7 +642,7 @@ RZ_API RZ_BORROW RzListIter *rz_list_find_ptr(RZ_NONNULL const RzList *list, RZ_
* \brief Returns RzListIter element which matches via the RzListComparator
*
* Find the first RzListIter that is equal to the given data
* For searching by pointer comparison, rz_list_find_ptr() provides a simpler interface.
* For searching by pointer comparison, rz_list_find_val() provides a simpler interface.
*
* \return the first RzListIter that is equall to p w.r.t. cmp.
*/

2
librz/util/log.c
View file

@ -179,7 +179,7 @@ RZ_API void rz_log_del_callback(RZ_NULLABLE RzLogCallback cbfunc) {
log_init();
rz_th_lock_enter(logcfg.lock);
if (logcfg.callbacks) {
rz_list_delete_data(logcfg.callbacks, cbfunc);
rz_list_delete_val(logcfg.callbacks, cbfunc);
}
rz_th_lock_leave(logcfg.lock);
}

2
test/integration/test_bin.c
View file

@ -177,7 +177,7 @@ static void event_file_del_cb(RzEvent *ev, int type, void *user, void *data) {
return;
}
RzEventBinFileDel *bev = data;
RzListIter *it = rz_list_find_ptr(tracker->expect, bev->bf);
RzListIter *it = rz_list_find_val(tracker->expect, bev->bf);
if (!it) {
tracker->failed_unexpected = true;
return;

4
test/unit/test_io.c
View file

@ -429,7 +429,7 @@ static void event_desc_close_cb(RzEvent *ev, int type, void *user, void *data) {
return;
}
RzEventIODescClose *iev = data;
RzListIter *it = rz_list_find_ptr(tracker->expect, iev->desc);
RzListIter *it = rz_list_find_val(tracker->expect, iev->desc);
if (!it) {
tracker->failed_unexpected = true;
return;
@ -498,7 +498,7 @@ static void event_map_del_cb(RzEvent *ev, int type, void *user, void *data) {
return;
}
RzEventIOMapDel *iev = data;
RzListIter *it = rz_list_find_ptr(tracker->expect, iev->map);
RzListIter *it = rz_list_find_val(tracker->expect, iev->map);
if (!it) {
tracker->failed_unexpected = true;
return;

22
test/unit/test_list.c
View file

@ -162,7 +162,7 @@ bool test_rz_list_length(void) {
}
mu_assert_eq(list->length, 3, "First length check");
rz_list_delete_data(list, (void *)&test1);
rz_list_delete_val(list, (void *)&test1);
mu_assert_eq(list->length, 2, "Second length check");
rz_list_append(list, (void *)&test1);
@ -486,24 +486,24 @@ bool test_rz_list_clone(void) {
mu_end;
}
bool test_rz_list_find_ptr(void) {
bool test_rz_list_find_val(void) {
RzList *l = rz_list_new();
rz_list_push(l, (void *)42);
rz_list_push(l, (void *)1337);
rz_list_push(l, (void *)42);
RzListIter *it = rz_list_find_ptr(l, (void *)42);
mu_assert_notnull(it, "find_ptr");
mu_assert_ptreq(it, rz_list_head(l), "find_ptr");
RzListIter *it = rz_list_find_val(l, (void *)42);
mu_assert_notnull(it, "find_val");
mu_assert_ptreq(it, rz_list_head(l), "find_val");
RzListIter *expect = rz_list_iter_get_next(it);
mu_assert_notnull(it, "expect next");
it = rz_list_find_ptr(l, (void *)1337);
mu_assert_notnull(it, "find_ptr");
mu_assert_ptreq(it, expect, "find_ptr");
it = rz_list_find_val(l, (void *)1337);
mu_assert_notnull(it, "find_val");
mu_assert_ptreq(it, expect, "find_val");
it = rz_list_find_ptr(l, (void *)123);
mu_assert_null(it, "find_ptr");
it = rz_list_find_val(l, (void *)123);
mu_assert_null(it, "find_val");
rz_list_free(l);
mu_end;
@ -538,7 +538,7 @@ int all_tests() {
mu_run_test(test_rz_list_set_get);
mu_run_test(test_rz_list_reverse);
mu_run_test(test_rz_list_clone);
mu_run_test(test_rz_list_find_ptr);
mu_run_test(test_rz_list_find_val);
mu_run_test(test_rz_list_from_iter);
mu_run_test(test_rz_list_sorted_uniq);
return tests_passed != tests_run;