flag.c File Reference

#include <rz_flag.h>
#include <rz_util.h>
#include <rz_cons.h>
#include <stdio.h>

Go to the source code of this file.

Classes
struct	unset_off_foreach_t
struct	unset_foreach_t
struct	flag_relocate_t

Macros
#define	IS_FI_NOTIN_SPACE(f, i)   (rz_flag_space_cur(f) && (i)->space != rz_flag_space_cur(f))
#define	IS_FI_IN_SPACE(fi, sp)   (!(sp) || (fi)->space == (sp))
#define	STRDUP_OR_NULL(s)   (!RZ_STR_ISEMPTY(s) ? strdup(s) : NULL)
#define	FOREACH_BODY(condition)

Functions
	RZ_LIB_VERSION (rz_flag)
static const char *	str_callback (RzNum *user, ut64 off, int *ok)
static void	flag_skiplist_free (void *data)
static int	flag_skiplist_cmp (const void *va, const void *vb)
static ut64	num_callback (RzNum *user, const char *name, int *ok)
static void	free_item_realname (RzFlagItem *item)
static void	free_item_name (RzFlagItem *item)
static RzFlagsAtOffset *	rz_flag_get_nearest_list (RzFlag *f, ut64 off, int dir)
static void	remove_offsetmap (RzFlag *f, RzFlagItem *item)
static RzFlagsAtOffset *	flags_at_offset (RzFlag *f, ut64 off)
static char *	filter_item_name (const char *name)
static void	set_name (RzFlagItem *item, char *name)
static bool	update_flag_item_offset (RzFlag *f, RzFlagItem *item, ut64 newoff, bool is_new, bool force)
static bool	update_flag_item_name (RzFlag *f, RzFlagItem *item, const char *newname, bool force)
static void	ht_free_flag (HtPPKv *kv)
static bool	count_flags (RzFlagItem *fi, void *user)
static bool	unset_flags_space (RzFlagItem *fi, void *user)
static void	count_flags_in_space (RzEvent *ev, int type, void *user, void *data)
static void	unset_flagspace (RzEvent *ev, int type, void *user, void *data)
static void	new_spaces (RzFlag *f)
RZ_API RzFlag *	rz_flag_new (void)
RZ_API RzFlagItem *	rz_flag_item_clone (RzFlagItem *item)
RZ_API void	rz_flag_item_free (RzFlagItem *item)
RZ_API RzFlag *	rz_flag_free (RzFlag *f)
static RzFlagItem *	evalFlag (RzFlag *f, RzFlagItem *item)
RZ_API bool	rz_flag_exist_at (RzFlag *f, const char *flag_prefix, ut16 fp_size, ut64 off)
RZ_API RzFlagItem *	rz_flag_get (RzFlag *f, const char *name)
RZ_API RzFlagItem *	rz_flag_get_i (RzFlag *f, ut64 off)
RZ_API RzFlagItem *	rz_flag_get_by_spaces (RzFlag *f, ut64 off,...)
static bool	isFunctionFlag (const char *n)
RZ_API RzFlagItem *	rz_flag_get_at (RzFlag *f, ut64 off, bool closest)
static bool	append_to_list (RzFlagItem *fi, void *user)
RZ_API RzList *	rz_flag_all_list (RzFlag *f, bool by_space)
RZ_API const RzList *	rz_flag_get_list (RzFlag *f, ut64 off)
RZ_API char *	rz_flag_get_liststr (RzFlag *f, ut64 off)
RZ_API RzFlagItem *	rz_flag_set_next (RzFlag *f, const char *name, ut64 off, ut32 size)
RZ_API RzFlagItem *	rz_flag_set (RzFlag *f, const char *name, ut64 off, ut32 size)
RZ_API void	rz_flag_item_set_alias (RzFlagItem *item, const char *alias)
RZ_API void	rz_flag_item_set_comment (RzFlagItem *item, const char *comment)
RZ_API void	rz_flag_item_set_realname (RzFlagItem *item, const char *realname)
RZ_API const char *	rz_flag_item_set_color (RzFlagItem *item, const char *color)
RZ_API int	rz_flag_rename (RzFlag *f, RzFlagItem *item, const char *name)
RZ_API bool	rz_flag_unset (RzFlag *f, RzFlagItem *item)
RZ_API bool	rz_flag_unset_off (RzFlag *f, ut64 off)
static bool	unset_off_foreach (void *user, const void *k, const void *v)
RZ_API bool	rz_flag_unset_all_off (RzFlag *f, ut64 off)
static bool	unset_foreach (RzFlagItem *fi, void *user)
RZ_API int	rz_flag_unset_glob (RzFlag *f, const char *glob)
RZ_API bool	rz_flag_unset_name (RzFlag *f, const char *name)
RZ_API void	rz_flag_unset_all (RzFlag *f)
RZ_API void	rz_flag_unset_all_in_space (RzFlag *f, const char *space_name)
	Unset all flag items in the space with the given name. More...
static bool	flag_relocate_foreach (RzFlagItem *fi, void *user)
RZ_API int	rz_flag_relocate (RzFlag *f, ut64 off, ut64 off_mask, ut64 to)
RZ_API bool	rz_flag_move (RzFlag *f, ut64 at, ut64 to)
RZ_API void	rz_flag_bind (RzFlag *f, RzFlagBind *fb)
static bool	flag_count_foreach (RzFlagItem *fi, void *user)
RZ_API int	rz_flag_count (RzFlag *f, const char *glob)
RZ_API void	rz_flag_foreach (RzFlag *f, RzFlagItemCb cb, void *user)
RZ_API void	rz_flag_foreach_prefix (RzFlag *f, const char *pfx, int pfx_len, RzFlagItemCb cb, void *user)
RZ_API void	rz_flag_foreach_range (RZ_NONNULL RzFlag *f, ut64 from, ut64 to, RzFlagItemCb cb, void *user)
RZ_API void	rz_flag_foreach_glob (RzFlag *f, const char *glob, RzFlagItemCb cb, void *user)
RZ_API void	rz_flag_foreach_space_glob (RzFlag *f, const char *glob, const RzSpace *space, RzFlagItemCb cb, void *user)
RZ_API void	rz_flag_foreach_space (RzFlag *f, const RzSpace *space, RzFlagItemCb cb, void *user)

Macro Definition Documentation

FOREACH_BODY

#define FOREACH_BODY

(

condition

)

Value:

    RzSkipListNode *it, *tmp; \
    RzFlagsAtOffset *flags_at; \
    RzListIter *it2, *tmp2; \
    RzFlagItem *fi; \
    rz_skiplist_foreach_safe(f->by_off, it, tmp, flags_at) { \
        if (flags_at) { \
            rz_list_foreach_safe (flags_at->flags, it2, tmp2, fi) { \
                if (condition) { \
                    if (!cb(fi, user)) { \
                        return; \
                    } \
                } \
            } \
        } \
    }

Definition at line 783 of file flag.c.

IS_FI_IN_SPACE

#define IS_FI_IN_SPACE	(		fi,
			sp
	)		(!(sp) || (fi)->space == (sp))

Definition at line 13 of file flag.c.

IS_FI_NOTIN_SPACE

#define IS_FI_NOTIN_SPACE	(		f,
			i
	)		(rz_flag_space_cur(f) && (i)->space != rz_flag_space_cur(f))

Definition at line 12 of file flag.c.

STRDUP_OR_NULL

#define STRDUP_OR_NULL

(

s

)

(!RZ_STR_ISEMPTY(s) ? strdup(s) : NULL)

Definition at line 14 of file flag.c.

Function Documentation

append_to_list()

static bool append_to_list ( RzFlagItem *  fi, void *  user  )

static

Definition at line 457 of file flag.c.

                                                       {
    RzList *ret = (RzList *)user;
    rz_list_append(ret, fi);
    return true;
}

References rz_list_append().

Referenced by rz_flag_all_list().

count_flags()

static bool count_flags ( RzFlagItem *  fi, void *  user  )

static

Definition at line 189 of file flag.c.

                                                    {
    int *count = (int *)user;
    (*count)++;
    return true;
}

References count.

Referenced by count_flags_in_space().

count_flags_in_space()

static void count_flags_in_space ( RzEvent *  ev, int  type, void *  user, void *  data  )

static

Definition at line 200 of file flag.c.

                                                                                {
    RzSpaces *sp = (RzSpaces *)ev->user;
    RzFlag *f = container_of(sp, RzFlag, spaces);
    RzSpaceEvent *spe = (RzSpaceEvent *)data;
    rz_flag_foreach_space(f, spe->data.count.space, count_flags, &spe->res);
}

References container_of, rz_space_event_t::count, count_flags(), rz_space_event_t::data, f, rz_space_event_t::res, rz_flag_foreach_space(), sp, spaces(), and rz_event_t::user.

Referenced by new_spaces().

evalFlag()

static RzFlagItem* evalFlag ( RzFlag *  f, RzFlagItem *  item  )

static

Definition at line 283 of file flag.c.

                                                         {
    rz_return_val_if_fail(f && item, NULL);
    if (item->alias) {
        item->offset = rz_num_math(f->num, item->alias);
    }
    return item;
}

References rz_flag_item_t::alias, f, NULL, rz_flag_item_t::offset, rz_num_math(), and rz_return_val_if_fail.

Referenced by rz_flag_get(), rz_flag_get_at(), rz_flag_get_by_spaces(), and rz_flag_get_i().

filter_item_name()

static char* filter_item_name ( const char *  name )

static

Definition at line 125 of file flag.c.

                                                {
    char *res = strdup(name);
    if (!res) {
        return NULL;
    }
 
    rz_str_trim(res);
    rz_name_filter(res, 0, true);
    return res;
}

References NULL, rz_name_filter(), rz_str_trim(), and strdup().

Referenced by rz_flag_set(), and update_flag_item_name().

flag_count_foreach()

static bool flag_count_foreach ( RzFlagItem *  fi, void *  user  )

static

Definition at line 770 of file flag.c.

                                                           {
    int *count = (int *)user;
    (*count)++;
    return true;
}

References count.

Referenced by rz_flag_count().

flag_relocate_foreach()

static bool flag_relocate_foreach ( RzFlagItem *  fi, void *  user  )

static

Definition at line 713 of file flag.c.

                                                              {
    struct flag_relocate_t *u = (struct flag_relocate_t *)user;
    ut64 fn = fi->offset & u->neg_mask;
    ut64 on = u->off & u->neg_mask;
    if (fn == on) {
        ut64 fm = fi->offset & u->off_mask;
        ut64 om = u->to & u->off_mask;
        update_flag_item_offset(u->f, fi, (u->to & u->neg_mask) + fm + om, false, false);
        u->n++;
    }
    return true;
}

References flag_relocate_t::f, fn, flag_relocate_t::n, flag_relocate_t::neg_mask, flag_relocate_t::off, flag_relocate_t::off_mask, rz_flag_item_t::offset, flag_relocate_t::to, update_flag_item_offset(), and ut64().

Referenced by rz_flag_relocate().

flag_skiplist_cmp()

static int flag_skiplist_cmp ( const void *  va, const void *  vb  )

static

Definition at line 40 of file flag.c.

                                                             {
    const RzFlagsAtOffset *a = (RzFlagsAtOffset *)va, *b = (RzFlagsAtOffset *)vb;
    if (a->off == b->off) {
        return 0;
    }
    return a->off < b->off ? -1 : 1;
}

References a, b, and patch_major_os_version::vb.

Referenced by rz_flag_new().

flag_skiplist_free()

static void flag_skiplist_free ( void *  data )

static

Definition at line 34 of file flag.c.

                                           {
    RzFlagsAtOffset *item = (RzFlagsAtOffset *)data;
    rz_list_free(item->flags);
    free(data);
}

References rz_flags_at_offset_t::flags, free(), and rz_list_free().

Referenced by rz_flag_new().

flags_at_offset()

static RzFlagsAtOffset* flags_at_offset ( RzFlag *  f, ut64  off  )

static

Definition at line 102 of file flag.c.

                                                             {
    RzFlagsAtOffset *res = rz_flag_get_nearest_list(f, off, 0);
    if (res) {
        return res;
    }
 
    // there is no existing flagsAtOffset, we create one now
    res = RZ_NEW(RzFlagsAtOffset);
    if (!res) {
        return NULL;
    }
 
    res->flags = rz_list_new();
    if (!res->flags) {
        free(res);
        return NULL;
    }
 
    res->off = off;
    rz_skiplist_insert(f->by_off, res);
    return res;
}

References f, rz_flags_at_offset_t::flags, free(), NULL, off, rz_flags_at_offset_t::off, rz_flag_get_nearest_list(), rz_list_new(), RZ_NEW, and rz_skiplist_insert().

Referenced by update_flag_item_offset().

free_item_name()

static void free_item_name ( RzFlagItem *  item )

static

Definition at line 73 of file flag.c.

                                             {
    if (item->name != item->realname) {
        free(item->name);
    }
}

References free(), rz_flag_item_t::name, and rz_flag_item_t::realname.

Referenced by rz_flag_item_free(), and set_name().

free_item_realname()

static void free_item_realname ( RzFlagItem *  item )

static

Definition at line 67 of file flag.c.

                                                 {
    if (item->name != item->realname) {
        free(item->realname);
    }
}

References free(), rz_flag_item_t::name, and rz_flag_item_t::realname.

Referenced by rz_flag_item_set_realname(), and set_name().

ht_free_flag()

static void ht_free_flag ( HtPPKv *  kv )

static

Definition at line 184 of file flag.c.

                                     {
    free(kv->key);
    rz_flag_item_free(kv->value);
}

References free(), and rz_flag_item_free().

Referenced by rz_flag_new(), and rz_flag_unset_all().

isFunctionFlag()

static bool isFunctionFlag ( const char *  n )

static

Definition at line 398 of file flag.c.

                                          {
    return (!strncmp(n, "sym.func.", 9) || !strncmp(n, "method.", 7) || !strncmp(n, "sym.", 4) || !strncmp(n, "func.", 5) || !strncmp(n, "fcn.0", 5));
}

References n.

Referenced by rz_flag_get_at().

new_spaces()

static void new_spaces ( RzFlag *  f )

static

Definition at line 214 of file flag.c.

                                  {
    rz_spaces_init(&f->spaces, "fs");
    rz_event_hook(f->spaces.event, RZ_SPACE_EVENT_COUNT, count_flags_in_space, NULL);
    rz_event_hook(f->spaces.event, RZ_SPACE_EVENT_UNSET, unset_flagspace, NULL);
}

References count_flags_in_space(), f, NULL, rz_event_hook(), RZ_SPACE_EVENT_COUNT, RZ_SPACE_EVENT_UNSET, rz_spaces_init(), and unset_flagspace().

Referenced by rz_flag_new(), and rz_flag_unset_all().

num_callback()

static ut64 num_callback ( RzNum *  user, const char *  name, int *  ok  )

static

Definition at line 48 of file flag.c.

                                                                 {
    RzFlag *f = (RzFlag *)user;
    if (ok) {
        *ok = 0;
    }
    RzFlagItem *item = ht_pp_find(f->ht_name, name, NULL);
    if (item) {
        // NOTE: to avoid warning infinite loop here we avoid recursivity
        if (item->alias) {
            return 0LL;
        }
        if (ok) {
            *ok = 1;
        }
        return item->offset;
    }
    return 0LL;
}

References rz_flag_item_t::alias, f, NULL, rz_flag_item_t::offset, and ok.

Referenced by rz_flag_new().

remove_offsetmap()

static void remove_offsetmap ( RzFlag *  f, RzFlagItem *  item  )

static

Definition at line 91 of file flag.c.

                                                          {
    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);
        if (rz_list_empty(flags->flags)) {
            rz_skiplist_delete(f->by_off, flags);
        }
    }
}

References f, flags, rz_flag_item_t::offset, rz_flag_get_nearest_list(), rz_list_delete_data(), rz_return_if_fail, and rz_skiplist_delete().

Referenced by rz_flag_unset(), and update_flag_item_offset().

rz_flag_all_list()

RZ_API RzList* rz_flag_all_list	(	RzFlag *	f,
		bool	by_space
	)

Definition at line 463 of file flag.c.

                                                            {
    RzList *ret = rz_list_new();
    if (!ret) {
        return NULL;
    }
 
    RzSpace *cur = by_space ? rz_flag_space_cur(f) : NULL;
    rz_flag_foreach_space(f, cur, append_to_list, ret);
    return ret;
}

References append_to_list(), f, NULL, rz_flag_foreach_space(), and rz_list_new().

Referenced by autocmplt_cmd_arg_flag(), rz_core_visual_trackflags(), rz_flag_describe_closest_handler(), and rz_flag_unset_all_in_space().

rz_flag_bind()

RZ_API void rz_flag_bind	(	RzFlag *	f,
		RzFlagBind *	fb
	)

Definition at line 752 of file flag.c.

                                                    {
    rz_return_if_fail(f && fb);
    fb->f = f;
    fb->exist_at = rz_flag_exist_at;
    fb->get = rz_flag_get;
    fb->get_at = rz_flag_get_at;
    fb->get_at_by_spaces = rz_flag_get_by_spaces;
    fb->get_list = rz_flag_get_list;
    fb->set = rz_flag_set;
    fb->unset = rz_flag_unset;
    fb->unset_name = rz_flag_unset_name;
    fb->unset_off = rz_flag_unset_off;
    fb->set_fs = rz_flag_space_set;
    fb->push_fs = rz_flag_space_push;
    fb->pop_fs = rz_flag_space_pop;
    fb->rename = rz_flag_rename;
}

References rz_flag_bind_t::exist_at, rz_flag_bind_t::f, f, rz_flag_bind_t::get, rz_flag_bind_t::get_at, rz_flag_bind_t::get_at_by_spaces, rz_flag_bind_t::get_list, rz_flag_bind_t::pop_fs, rz_flag_bind_t::push_fs, rz_flag_bind_t::rename, rz_flag_exist_at(), rz_flag_get(), rz_flag_get_at(), rz_flag_get_by_spaces(), rz_flag_get_list(), rz_flag_rename(), rz_flag_set(), rz_flag_unset(), rz_flag_unset_name(), rz_flag_unset_off(), rz_return_if_fail, rz_flag_bind_t::set, rz_flag_bind_t::set_fs, rz_flag_bind_t::unset, rz_flag_bind_t::unset_name, and rz_flag_bind_t::unset_off.

Referenced by rz_core_init().

rz_flag_count()

RZ_API int rz_flag_count	(	RzFlag *	f,
		const char *	glob
	)

Definition at line 776 of file flag.c.

                                                      {
    int count = 0;
    rz_return_val_if_fail(f, -1);
    rz_flag_foreach_glob(f, glob, flag_count_foreach, &count);
    return count;
}

References count, f, flag_count_foreach(), rz_flag_foreach_glob(), and rz_return_val_if_fail.

Referenced by rz_core_analysis_sigdb_apply(), rz_flirt_scan_handler(), and rz_print_analysis_details_handler().

rz_flag_exist_at()

RZ_API bool rz_flag_exist_at	(	RzFlag *	f,
		const char *	flag_prefix,
		ut16	fp_size,
		ut64	off
	)

Definition at line 293 of file flag.c.

                                                                                         {
    rz_return_val_if_fail(f && flag_prefix, false);
    RzListIter *iter = NULL;
    RzFlagItem *item = NULL;
    const RzList *list = rz_flag_get_list(f, off);
    if (list) {
        rz_list_foreach (list, iter, item) {
            if (item->name && !strncmp(item->name, flag_prefix, fp_size)) {
                return true;
            }
        }
    }
    return false;
}

References f, list(), rz_flag_item_t::name, NULL, off, rz_flag_get_list(), and rz_return_val_if_fail.

Referenced by propagate_types_among_used_variables(), and rz_flag_bind().

rz_flag_foreach()

RZ_API void rz_flag_foreach	(	RzFlag *	f,
		RzFlagItemCb	cb,
		void *	user
	)

Definition at line 800 of file flag.c.

                                                                    {
    FOREACH_BODY(true);
}

References FOREACH_BODY.

Referenced by __rebase_everything(), rz_core_seek_next(), rz_core_seek_prev(), rz_core_visual_hudstuff(), rz_flag_relocate(), rz_flag_tags_get(), and rz_serialize_flag_save().

rz_flag_foreach_glob()

RZ_API void rz_flag_foreach_glob	(	RzFlag *	f,
		const char *	glob,
		RzFlagItemCb	cb,
		void *	user
	)

Definition at line 818 of file flag.c.

                                                                                           {
    FOREACH_BODY(!glob || rz_str_glob(fi->name, glob));
}

References FOREACH_BODY, and rz_str_glob().

Referenced by flag_ordinals(), flag_to_flag(), rz_analyze_symbols_entries_flags_handler(), rz_analyze_symbols_entries_handler(), rz_core_cmd_foreach3(), rz_flag_base_handler(), rz_flag_count(), and rz_flag_unset_glob().

rz_flag_foreach_prefix()

RZ_API void rz_flag_foreach_prefix	(	RzFlag *	f,
		const char *	pfx,
		int	pfx_len,
		RzFlagItemCb	cb,
		void *	user
	)

Definition at line 804 of file flag.c.

                                                                                                         {
    pfx_len = pfx_len < 0 ? strlen(pfx) : pfx_len;
    FOREACH_BODY(!strncmp(fi->name, pfx, pfx_len));
}

References FOREACH_BODY.

Referenced by autocmplt_cmd_arg_rznum(), autocomplete_flags(), rz_core_autocomplete(), rz_core_seek_next(), and rz_core_seek_prev().

rz_flag_foreach_range()

RZ_API void rz_flag_foreach_range	(	RZ_NONNULL RzFlag *	f,
		ut64	from,
		ut64	to,
		RzFlagItemCb	cb,
		void *	user
	)

Parameters

from	inclusive
to	inclusive

Definition at line 813 of file flag.c.

                                                                                                         {
    rz_return_if_fail(f);
    FOREACH_BODY(fi->offset >= from && fi->offset <= to);
}

References f, FOREACH_BODY, from, rz_return_if_fail, and to.

Referenced by rz_core_analysis_get_stats().

rz_flag_foreach_space()

RZ_API void rz_flag_foreach_space	(	RzFlag *	f,
		const RzSpace *	space,
		RzFlagItemCb	cb,
		void *	user
	)

Definition at line 826 of file flag.c.

                                                                                                {
    FOREACH_BODY(IS_FI_IN_SPACE(fi, space));
}

References FOREACH_BODY, and IS_FI_IN_SPACE.

Referenced by count_flags_in_space(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), flag_print(), rz_core_cmd_foreach(), rz_core_flag_real_name_print(), rz_flag_all_list(), rz_flag_graph_handler(), and unset_flagspace().

rz_flag_foreach_space_glob()

RZ_API void rz_flag_foreach_space_glob	(	RzFlag *	f,
		const char *	glob,
		const RzSpace *	space,
		RzFlagItemCb	cb,
		void *	user
	)

Definition at line 822 of file flag.c.

                                                                                                                       {
    FOREACH_BODY(IS_FI_IN_SPACE(fi, space) && (!glob || rz_str_glob(fi->name, glob)));
}

References FOREACH_BODY, IS_FI_IN_SPACE, and rz_str_glob().

Referenced by flagbars().

rz_flag_free()

RZ_API RzFlag* rz_flag_free

(

RzFlag *

f

)

Definition at line 271 of file flag.c.

                                       {
    rz_return_val_if_fail(f, NULL);
    rz_skiplist_free(f->by_off);
    ht_pp_free(f->ht_name);
    sdb_free(f->tags);
    rz_spaces_fini(&f->spaces);
    rz_num_free(f->num);
    rz_list_free(f->zones);
    free(f);
    return NULL;
}

References f, free(), NULL, rz_list_free(), rz_num_free(), rz_return_val_if_fail, rz_skiplist_free(), rz_spaces_fini(), and sdb_free().

Referenced by rz_core_fini(), and rz_flag_new().

rz_flag_get()

RZ_API RzFlagItem* rz_flag_get	(	RzFlag *	f,
		const char *	name
	)

Definition at line 310 of file flag.c.

                                                            {
    rz_return_val_if_fail(f, NULL);
    RzFlagItem *r = ht_pp_find(f->ht_name, name, NULL);
    return r ? evalFlag(f, r) : NULL;
}

References evalFlag(), f, NULL, r, and rz_return_val_if_fail.

Referenced by __printRecursive(), convert_offset_from_input(), core_flg_class_get(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), ds_show_functions(), num_callback(), parseOperand(), reloc_set_flag(), rz_analysis_var_global_get_flag_item(), rz_block_flag_handler(), rz_core_analysis_all(), rz_core_analysis_autoname_all_fcns(), rz_core_analysis_esil_init_mem_p(), rz_core_analysis_function_autoname(), rz_core_analysis_function_rename(), rz_core_bin_apply_symbols(), rz_core_bin_export_info(), rz_core_bin_load(), rz_core_cmd_subst_i(), rz_flag_alias_handler(), rz_flag_bind(), rz_flag_color_handler(), rz_flag_comment_handler(), rz_flag_exists_handler(), rz_flag_realname_handler(), rz_flag_rename_handler(), rz_flag_set(), rz_flag_set_next(), and rz_main_rizin().

rz_flag_get_at()

RZ_API RzFlagItem* rz_flag_get_at	(	RzFlag *	f,
		ut64	off,
		bool	closest
	)

Definition at line 404 of file flag.c.

                                                                     {
    rz_return_val_if_fail(f, NULL);
 
    RzFlagItem *nice = NULL;
    RzListIter *iter;
    const RzFlagsAtOffset *flags_at = rz_flag_get_nearest_list(f, off, -1);
    if (!flags_at) {
        return NULL;
    }
    if (flags_at->off == off) {
        RzFlagItem *item;
        rz_list_foreach (flags_at->flags, iter, item) {
            if (IS_FI_NOTIN_SPACE(f, item)) {
                continue;
            }
            if (nice) {
                if (isFunctionFlag(nice->name)) {
                    nice = item;
                }
            } else {
                nice = item;
            }
        }
        if (nice) {
            return evalFlag(f, nice);
        }
    }
 
    if (!closest) {
        return NULL;
    }
    while (!nice && flags_at) {
        RzFlagItem *item;
        rz_list_foreach (flags_at->flags, iter, item) {
            if (IS_FI_NOTIN_SPACE(f, item)) {
                continue;
            }
            if (item->offset == off) {
                eprintf("XXX Should never happend\n");
                return evalFlag(f, item);
            }
            nice = item;
            break;
        }
        if (!nice && flags_at->off) {
            flags_at = rz_flag_get_nearest_list(f, flags_at->off - 1, -1);
        } else {
            flags_at = NULL;
        }
    }
    return nice ? evalFlag(f, nice) : NULL;
}

References eprintf, evalFlag(), f, rz_flags_at_offset_t::flags, IS_FI_NOTIN_SPACE, isFunctionFlag(), nice, NULL, off, rz_flags_at_offset_t::off, rz_flag_item_t::offset, rz_flag_get_nearest_list(), and rz_return_val_if_fail.

Referenced by __refs(), __xrefs(), _CbInRangeAav(), add_single_addr_xrefs(), backtrace_vars(), cmd_print_bars(), core_flag_get_at_as_ref_type(), ds_pre_emulation(), ds_print_esil_analysis(), ds_print_lines_left(), ds_print_offset(), ds_show_xrefs(), fill_hist_offset(), get_backtrace_info(), getNameDelta(), prompt_add_offset(), rz_analysis_xrefs_from_list_handler(), rz_core_flag_describe(), rz_core_print_hexdump_byline_str(), rz_core_visual_title(), rz_core_visual_xrefs(), rz_flag_add_handler(), rz_flag_bind(), rz_seek_history_list_handler(), and trace_traverse_pre().

rz_flag_get_by_spaces()

RZ_API RzFlagItem* rz_flag_get_by_spaces	(	RzFlag *	f,
		ut64	off,
			...
	)

Definition at line 326 of file flag.c.

                                                                   {
    rz_return_val_if_fail(f, NULL);
 
    const RzList *list = rz_flag_get_list(f, off);
    RzFlagItem *ret = NULL;
    const char *spacename;
    RzSpace **spaces;
    RzListIter *iter;
    RzFlagItem *flg;
    va_list ap, aq;
    size_t n_spaces = 0, i;
 
    va_start(ap, off);
    // some quick checks for common cases
    if (rz_list_empty(list)) {
        goto beach;
    }
    if (rz_list_length(list) == 1) {
        ret = rz_list_get_top(list);
        goto beach;
    }
 
    // count spaces in the vaarg
    va_copy(aq, ap);
    spacename = va_arg(aq, const char *);
    while (spacename) {
        n_spaces++;
        spacename = va_arg(aq, const char *);
    }
    va_end(aq);
 
    // get RzSpaces from the names
    i = 0;
    spaces = RZ_NEWS(RzSpace *, n_spaces);
    spacename = va_arg(ap, const char *);
    while (spacename) {
        RzSpace *space = rz_flag_space_get(f, spacename);
        if (space) {
            spaces[i++] = space;
        }
        spacename = va_arg(ap, const char *);
    }
    n_spaces = i;
 
    ut64 min_space_i = n_spaces + 1;
    rz_list_foreach (list, iter, flg) {
        // get the "priority" of the flag flagspace and
        // check if better than what we found so far
        for (i = 0; i < n_spaces; i++) {
            if (flg->space == spaces[i]) {
                break;
            }
            if (i >= min_space_i) {
                break;
            }
        }
 
        if (i < min_space_i) {
            min_space_i = i;
            ret = flg;
        }
        if (!min_space_i) {
            // this is the best flag we can find, let's stop immediately
            break;
        }
    }
    free(spaces);
beach:
    va_end(ap);
    return ret ? evalFlag(f, ret) : NULL;
}

References evalFlag(), f, free(), i, list(), NULL, off, rz_flag_get_list(), rz_list_get_top(), rz_list_length(), RZ_NEWS, rz_return_val_if_fail, rz_flag_item_t::space, spaces(), and ut64().

Referenced by core_flag_get_at_as_ref_type(), ds_print_demangled(), ds_print_fcn_name(), ds_show_xrefs(), propagate_types_among_used_variables(), rz_analysis_extract_rarg(), rz_core_analysis_function_strings_print(), rz_core_flag_get_by_spaces(), rz_flag_bind(), set_jump_realname(), and type_match().

rz_flag_get_i()

RZ_API RzFlagItem* rz_flag_get_i	(	RzFlag *	f,
		ut64	off
	)

Definition at line 317 of file flag.c.

                                                      {
    rz_return_val_if_fail(f, NULL);
    const RzList *list = rz_flag_get_list(f, off);
    return list ? evalFlag(f, rz_list_get_top(list)) : NULL;
}

References evalFlag(), f, list(), NULL, off, rz_flag_get_list(), rz_list_get_top(), and rz_return_val_if_fail.

Referenced by _analysis_calls(), add_single_addr_xrefs(), annotated_hexdump(), autoname_imp_trampoline(), cmd_prc(), disassembly_as_table(), ds_build_op_str(), ds_control_flow_comments(), ds_print_calls_hints(), ds_print_esil_analysis(), ds_print_offset(), ds_print_ptr(), ds_show_comments_right(), filter(), function_print_calls(), function_rename(), getName(), handleMidFlags(), meta_get_flag(), myregwrite(), num_callback(), rz_core_analysis_address(), rz_core_analysis_callgraph(), rz_core_analysis_coderefs(), rz_core_analysis_datarefs(), rz_core_analysis_function_autoname(), rz_core_analysis_hasrefs(), rz_core_analysis_name(), rz_core_analysis_rename(), rz_core_disasm_pdi_with_buf(), rz_core_print_bb_gml(), rz_core_print_func_args(), rz_core_print_offname(), rz_core_print_offsize(), rz_core_visual_define(), rz_flag_comment_handler(), rz_flag_hexdump_handler(), rz_flag_length_handler(), rz_flag_move(), rz_flag_realname_handler(), rz_flag_space_move_handler(), rz_flag_unset_off(), and str_callback().

rz_flag_get_list()

RZ_API const RzList* rz_flag_get_list	(	RzFlag *	f,
		ut64	off
	)

Definition at line 475 of file flag.c.

                                                             {
    const RzFlagsAtOffset *item = rz_flag_get_nearest_list(f, off, 0);
    return item ? item->flags : NULL;
}

References f, rz_flags_at_offset_t::flags, NULL, off, and rz_flag_get_nearest_list().

Referenced by __flagsGet(), ds_print_data_type(), ds_show_flags(), ds_show_refs(), is_skippable_addr(), rz_core_analysis_hasrefs_to_depth(), rz_core_print_disasm_json(), rz_flag_bind(), rz_flag_describe_at_handler(), rz_flag_exist_at(), rz_flag_get_by_spaces(), rz_flag_get_i(), rz_flag_get_liststr(), step_until_flag(), and str_callback().

rz_flag_get_liststr()

RZ_API char* rz_flag_get_liststr	(	RzFlag *	f,
		ut64	off
	)

Definition at line 480 of file flag.c.

                                                      {
    RzFlagItem *fi;
    RzListIter *iter;
    const RzList *list = rz_flag_get_list(f, off);
    char *p = NULL;
    rz_list_foreach (list, iter, fi) {
        p = rz_str_appendf(p, "%s%s",
            fi->realname, iter->n ? "," : "");
    }
    return p;
}

References f, list(), NULL, off, p, rz_flag_item_t::realname, rz_flag_get_list(), and rz_str_appendf().

Referenced by ds_print_show_bytes(), and rz_core_analysis_hasrefs_to_depth().

rz_flag_get_nearest_list()

static RzFlagsAtOffset* rz_flag_get_nearest_list ( RzFlag *  f, ut64  off, int  dir  )

static

Definition at line 83 of file flag.c.

                                                                               {
    RzFlagsAtOffset key = { .off = off };
    RzFlagsAtOffset *flags = (dir >= 0)
        ? rz_skiplist_get_geq(f->by_off, &key)
        : rz_skiplist_get_leq(f->by_off, &key);
    return (dir == 0 && flags && flags->off != off) ? NULL : flags;
}

References f, flags, key, NULL, off, rz_skiplist_get_geq(), and rz_skiplist_get_leq().

Referenced by flags_at_offset(), remove_offsetmap(), rz_flag_get_at(), and rz_flag_get_list().

rz_flag_item_clone()

RZ_API RzFlagItem* rz_flag_item_clone

(

RzFlagItem *

item

)

Definition at line 240 of file flag.c.

                                                        {
    rz_return_val_if_fail(item, NULL);
 
    RzFlagItem *n = RZ_NEW0(RzFlagItem);
    if (!n) {
        return NULL;
    }
    n->color = STRDUP_OR_NULL(item->color);
    n->comment = STRDUP_OR_NULL(item->comment);
    n->alias = STRDUP_OR_NULL(item->alias);
    n->name = STRDUP_OR_NULL(item->name);
    n->realname = STRDUP_OR_NULL(item->realname);
    n->offset = item->offset;
    n->size = item->size;
    n->space = item->space;
    return n;
}

References rz_flag_item_t::alias, rz_flag_item_t::color, rz_flag_item_t::comment, n, rz_flag_item_t::name, NULL, rz_flag_item_t::offset, rz_flag_item_t::realname, RZ_NEW0, rz_return_val_if_fail, rz_flag_item_t::size, rz_flag_item_t::space, and STRDUP_OR_NULL.

Referenced by duplicate_flag().

rz_flag_item_free()

RZ_API void rz_flag_item_free

(

RzFlagItem *

item

)

Definition at line 258 of file flag.c.

                                                {
    if (!item) {
        return;
    }
    free(item->color);
    free(item->comment);
    free(item->alias);
    /* release only one of the two pointers if they are the same */
    free_item_name(item);
    free(item->realname);
    free(item);
}

References rz_flag_item_t::alias, rz_flag_item_t::color, rz_flag_item_t::comment, free(), free_item_name(), and rz_flag_item_t::realname.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), ht_free_flag(), rz_core_cmd_foreach(), and rz_flag_set().

rz_flag_item_set_alias()

RZ_API void rz_flag_item_set_alias	(	RzFlagItem *	item,
		const char *	alias
	)

Definition at line 557 of file flag.c.

                                                                        {
    rz_return_if_fail(item);
    free(item->alias);
    item->alias = RZ_STR_ISEMPTY(alias) ? NULL : strdup(alias);
}

References rz_flag_item_t::alias, free(), NULL, rz_return_if_fail, RZ_STR_ISEMPTY, and strdup().

Referenced by rz_flag_alias_handler().

rz_flag_item_set_color()

RZ_API const char* rz_flag_item_set_color	(	RzFlagItem *	item,
		const char *	color
	)

Definition at line 578 of file flag.c.

                                                                               {
    rz_return_val_if_fail(item, NULL);
    free(item->color);
    item->color = (color && *color) ? strdup(color) : NULL;
    return item->color;
}

References color, rz_flag_item_t::color, free(), NULL, rz_return_val_if_fail, and strdup().

Referenced by rz_core_visual_define(), and rz_flag_color_handler().

rz_flag_item_set_comment()

RZ_API void rz_flag_item_set_comment	(	RzFlagItem *	item,
		const char *	comment
	)

Definition at line 564 of file flag.c.

                                                                            {
    rz_return_if_fail(item);
    free(item->comment);
    item->comment = RZ_STR_ISEMPTY(comment) ? NULL : strdup(comment);
}

References rz_flag_item_t::comment, free(), NULL, rz_return_if_fail, RZ_STR_ISEMPTY, and strdup().

Referenced by flag_set_comment(), and rz_core_bin_apply_symbols().

rz_flag_item_set_realname()

RZ_API void rz_flag_item_set_realname	(	RzFlagItem *	item,
		const char *	realname
	)

Definition at line 571 of file flag.c.

                                                                              {
    rz_return_if_fail(item);
    free_item_realname(item);
    item->realname = RZ_STR_ISEMPTY(realname) ? NULL : strdup(realname);
}

References free_item_realname(), NULL, rz_flag_item_t::realname, rz_return_if_fail, RZ_STR_ISEMPTY, and strdup().

Referenced by pdb_set_symbols(), reloc_set_flag(), rz_core_bin_apply_symbols(), and rz_flag_realname_handler().

rz_flag_move()

RZ_API bool rz_flag_move	(	RzFlag *	f,
		ut64	at,
		ut64	to
	)

Definition at line 741 of file flag.c.

                                                      {
    rz_return_val_if_fail(f, false);
    RzFlagItem *item = rz_flag_get_i(f, at);
    if (item) {
        rz_flag_set(f, item->name, to, item->size);
        return true;
    }
    return false;
}

References f, rz_flag_item_t::name, rz_flag_get_i(), rz_flag_set(), rz_return_val_if_fail, rz_flag_item_t::size, and to.

Referenced by rebase_helper(), and rz_flag_move_handler().

rz_flag_new()

RZ_API RzFlag* rz_flag_new

(

void

)

Definition at line 220 of file flag.c.

                                 {
    RzFlag *f = RZ_NEW0(RzFlag);
    if (!f) {
        return NULL;
    }
    f->num = rz_num_new(&num_callback, &str_callback, f);
    if (!f->num) {
        rz_flag_free(f);
        return NULL;
    }
    f->base = 0;
    f->zones = NULL;
    f->tags = sdb_new0();
    f->ht_name = ht_pp_new(NULL, ht_free_flag, NULL);
    f->by_off = rz_skiplist_new(flag_skiplist_free, flag_skiplist_cmp);
    rz_list_free(f->zones);
    new_spaces(f);
    return f;
}

References f, flag_skiplist_cmp(), flag_skiplist_free(), ht_free_flag(), new_spaces(), NULL, num_callback(), rz_flag_free(), rz_list_free(), RZ_NEW0, rz_num_new(), rz_skiplist_new(), sdb_new0(), and str_callback().

Referenced by rz_core_init().

rz_flag_relocate()

RZ_API int rz_flag_relocate	(	RzFlag *	f,
		ut64	off,
		ut64	off_mask,
		ut64	to
	)

Definition at line 726 of file flag.c.

                                                                         {
    rz_return_val_if_fail(f, -1);
    struct flag_relocate_t u = {
        .f = f,
        .off = off,
        .off_mask = off_mask,
        .neg_mask = ~(off_mask),
        .to = to,
        .n = 0
    };
 
    rz_flag_foreach(f, flag_relocate_foreach, &u);
    return u.n;
}

References flag_relocate_t::f, f, flag_relocate_foreach(), n, flag_relocate_t::n, off, flag_relocate_t::off_mask, rz_flag_foreach(), rz_return_val_if_fail, and to.

Referenced by rz_flag_relocate_handler().

rz_flag_rename()

RZ_API int rz_flag_rename	(	RzFlag *	f,
		RzFlagItem *	item,
		const char *	name
	)

Definition at line 587 of file flag.c.

                                                                         {
    rz_return_val_if_fail(f && item && name && *name, false);
    return update_flag_item_name(f, item, name, false);
}

References f, rz_return_val_if_fail, and update_flag_item_name().

Referenced by function_rename(), rename_flag_ordinal(), rz_analysis_var_global_rename(), rz_core_analysis_autoname_all_fcns(), rz_core_analysis_function_rename(), rz_core_analysis_rename(), rz_core_visual_define(), rz_flag_bind(), and rz_flag_rename_handler().

rz_flag_set()

RZ_API RzFlagItem* rz_flag_set	(	RzFlag *	f,
		const char *	name,
		ut64	off,
		ut32	size
	)

Definition at line 521 of file flag.c.

                                                                                 {
    rz_return_val_if_fail(f && name && *name, NULL);
 
    bool is_new = false;
    char *itemname = filter_item_name(name);
    if (!itemname) {
        return NULL;
    }
 
    RzFlagItem *item = rz_flag_get(f, itemname);
    free(itemname);
    if (item && item->offset == off) {
        item->size = size;
        return item;
    }
 
    if (!item) {
        item = RZ_NEW0(RzFlagItem);
        if (!item) {
            goto err;
        }
        is_new = true;
    }
 
    item->space = rz_flag_space_cur(f);
    item->size = size;
 
    update_flag_item_offset(f, item, off + f->base, is_new, true);
    update_flag_item_name(f, item, name, true);
    return item;
err:
    rz_flag_item_free(item);
    return NULL;
}

References err, f, filter_item_name(), free(), NULL, off, rz_flag_item_t::offset, rz_flag_get(), rz_flag_item_free(), RZ_NEW0, rz_return_val_if_fail, rz_flag_item_t::size, rz_flag_item_t::space, update_flag_item_name(), and update_flag_item_offset().

Referenced by __core_analysis_fcn(), __handle_mouse_on_panel(), __rebase_flags(), _cb_hit(), _CbInRangeAav(), add_arch_platform_flag_comment_cb(), add_mmio_extended_flag_cb(), add_mmio_flag_cb(), add_new_func_symbol(), add_string_ref(), core_flg_class_set(), core_flg_fcn_set(), core_recover_golang_functions_go_1_16(), core_recover_golang_functions_go_1_18(), core_recover_golang_functions_go_1_2(), do_analysis_search(), do_asm_search(), do_syscall_search(), foreach_reg_set_or_clear(), function_rename(), pdb_set_symbols(), recover_string_at(), regs_to_flags(), rz_analysis_var_global_add(), rz_cmd_alias(), rz_core_analysis_flag_every_function(), rz_core_analysis_function_rename(), rz_core_analysis_rename(), rz_core_bin_apply_classes(), rz_core_bin_apply_entry(), rz_core_bin_apply_main(), rz_core_bin_apply_resources(), rz_core_bin_apply_sections(), rz_core_bin_apply_strings(), rz_core_bin_apply_symbols(), rz_core_bin_export_info(), rz_core_magic_at(), rz_core_visual_cmd(), rz_core_visual_define(), rz_flag_add_handler(), rz_flag_alias_handler(), rz_flag_append_handler(), rz_flag_bind(), rz_flag_move(), rz_flag_set_next(), set_new_xref(), and w32_list_heaps_blocks().

rz_flag_set_next()

RZ_API RzFlagItem* rz_flag_set_next	(	RzFlag *	f,
		const char *	name,
		ut64	off,
		ut32	size
	)

Definition at line 494 of file flag.c.

                                                                                      {
    rz_return_val_if_fail(f && name, NULL);
    if (!rz_flag_get(f, name)) {
        return rz_flag_set(f, name, off, size);
    }
    int i, newNameSize = strlen(name);
    char *newName = malloc(newNameSize + 16);
    if (!newName) {
        return NULL;
    }
    strcpy(newName, name);
    for (i = 0;; i++) {
        snprintf(newName + newNameSize, 15, ".%d", i);
        if (!rz_flag_get(f, newName)) {
            RzFlagItem *fi = rz_flag_set(f, newName, off, size);
            if (fi) {
                free(newName);
                return fi;
            }
        }
    }
    return NULL;
}

References f, free(), i, malloc(), NULL, off, rz_flag_get(), rz_flag_set(), rz_return_val_if_fail, and snprintf.

Referenced by apply_maps_as_flags(), reloc_set_flag(), rz_analysis_dwarf_integrate_functions(), and rz_core_analysis_esil().

rz_flag_unset()

RZ_API bool rz_flag_unset	(	RzFlag *	f,
		RzFlagItem *	item
	)

Definition at line 597 of file flag.c.

                                                       {
    rz_return_val_if_fail(f && item, false);
    remove_offsetmap(f, item);
    ht_pp_delete(f->ht_name, item->name);
    return true;
}

References f, rz_flag_item_t::name, remove_offsetmap(), and rz_return_val_if_fail.

Referenced by rz_analysis_var_global_free(), rz_core_bin_apply_symbols(), rz_flag_bind(), rz_flag_unset_all_in_space(), rz_flag_unset_name(), rz_flag_unset_off(), unset_foreach(), and unset_off_foreach().

rz_flag_unset_all()

RZ_API void rz_flag_unset_all

(

RzFlag *

f

)

Definition at line 677 of file flag.c.

                                         {
    rz_return_if_fail(f);
    ht_pp_free(f->ht_name);
    f->ht_name = ht_pp_new(NULL, ht_free_flag, NULL);
    rz_skiplist_purge(f->by_off);
    rz_spaces_fini(&f->spaces);
    new_spaces(f);
}

References f, ht_free_flag(), new_spaces(), NULL, rz_return_if_fail, rz_skiplist_purge(), and rz_spaces_fini().

Referenced by rz_flag_remove_all_handler(), rz_open_close_all_handler(), and rz_serialize_flag_load().

rz_flag_unset_all_in_space()

RZ_API void rz_flag_unset_all_in_space	(	RzFlag *	f,
		const char *	space_name
	)

Unset all flag items in the space with the given name.

Parameters

f	an RzFlag
space_name	name of the space

Definition at line 692 of file flag.c.

                                                                          {
    rz_flag_space_push(f, space_name);
    RzList *flags = rz_flag_all_list(f, true);
    RzFlagItem *flag;
    RzListIter *iter;
    rz_list_foreach (flags, iter, flag) {
        rz_flag_unset(f, flag);
    }
    rz_flag_space_pop(f);
    rz_list_free(flags);
}

References f, flags, rz_flag_all_list(), rz_flag_unset(), and rz_list_free().

Referenced by rz_analysis_all_esil_functions_handler(), rz_analysis_all_esil_handler(), rz_core_debug_map_update_flags(), rz_platform_index_add_flags_comments(), and rz_platform_profile_add_flag_every_io().

rz_flag_unset_all_off()

RZ_API bool rz_flag_unset_all_off	(	RzFlag *	f,
		ut64	off
	)

Definition at line 635 of file flag.c.

                                                       {
    rz_return_val_if_fail(f, false);
    struct unset_off_foreach_t u = { f, off };
    ht_pp_foreach(f->ht_name, unset_off_foreach, &u);
    return true;
}

References f, off, rz_return_val_if_fail, and unset_off_foreach().

Referenced by recover_string_at(), and rz_flag_remove_handler().

rz_flag_unset_glob()

RZ_API int rz_flag_unset_glob	(	RzFlag *	f,
		const char *	glob
	)

Definition at line 660 of file flag.c.

                                                           {
    rz_return_val_if_fail(f, -1);
 
    struct unset_foreach_t u = { .f = f, .n = 0 };
    rz_flag_foreach_glob(f, glob, unset_foreach, &u);
    return u.n;
}

References unset_foreach_t::f, f, unset_foreach_t::n, rz_flag_foreach_glob(), rz_return_val_if_fail, and unset_foreach().

Referenced by rz_flag_remove_handler().

rz_flag_unset_name()

RZ_API bool rz_flag_unset_name	(	RzFlag *	f,
		const char *	name
	)

Definition at line 670 of file flag.c.

                                                            {
    rz_return_val_if_fail(f, false);
    RzFlagItem *item = ht_pp_find(f->ht_name, name, NULL);
    return item && rz_flag_unset(f, item);
}

References f, NULL, rz_flag_unset(), and rz_return_val_if_fail.

Referenced by foreach_reg_set_or_clear(), function_rename(), rz_core_analysis_esil_init_mem_del(), rz_core_analysis_undefine(), rz_core_visual_cmd(), rz_core_visual_trackflags(), and rz_flag_bind().

rz_flag_unset_off()

RZ_API bool rz_flag_unset_off	(	RzFlag *	f,
		ut64	off
	)

Definition at line 608 of file flag.c.

                                                   {
    rz_return_val_if_fail(f, false);
    RzFlagItem *item = rz_flag_get_i(f, off);
    if (item && rz_flag_unset(f, item)) {
        return true;
    }
    return false;
}

References f, off, rz_flag_get_i(), rz_flag_unset(), and rz_return_val_if_fail.

Referenced by rz_analysis_dwarf_integrate_functions(), rz_core_visual_cmd(), and rz_flag_bind().

RZ_LIB_VERSION()

RZ_LIB_VERSION

(

rz_flag

)

set_name()

static void set_name ( RzFlagItem *  item, char *  name  )

static

Definition at line 136 of file flag.c.

                                                   {
    free_item_name(item);
    item->name = name;
    free_item_realname(item);
    item->realname = item->name;
}

References free_item_name(), free_item_realname(), name, rz_flag_item_t::name, and rz_flag_item_t::realname.

Referenced by update_flag_item_name().

str_callback()

static const char* str_callback ( RzNum *  user, ut64  off, int *  ok  )

static

Definition at line 16 of file flag.c.

                                                                {
    RzFlag *f = (RzFlag *)user;
    if (ok) {
        *ok = 0;
    }
    if (f) {
        const RzList *list = rz_flag_get_list(f, off);
        RzFlagItem *item = rz_list_get_top(list);
        if (item) {
            if (ok) {
                *ok = true;
            }
            return item->name;
        }
    }
    return NULL;
}

References f, list(), rz_flag_item_t::name, NULL, off, ok, rz_flag_get_list(), and rz_list_get_top().

Referenced by rz_flag_new().

unset_flags_space()

static bool unset_flags_space ( RzFlagItem *  fi, void *  user  )

static

Definition at line 195 of file flag.c.

                                                          {
    fi->space = NULL;
    return true;
}

References NULL, and rz_flag_item_t::space.

Referenced by unset_flagspace().

unset_flagspace()

static void unset_flagspace ( RzEvent *  ev, int  type, void *  user, void *  data  )

static

Definition at line 207 of file flag.c.

                                                                           {
    RzSpaces *sp = (RzSpaces *)ev->user;
    RzFlag *f = container_of(sp, RzFlag, spaces);
    const RzSpaceEvent *spe = (const RzSpaceEvent *)data;
    rz_flag_foreach_space(f, spe->data.unset.space, unset_flags_space, NULL);
}

References container_of, rz_space_event_t::data, f, NULL, rz_flag_foreach_space(), sp, spaces(), rz_space_event_t::unset, unset_flags_space(), and rz_event_t::user.

Referenced by new_spaces().

unset_foreach()

static bool unset_foreach ( RzFlagItem *  fi, void *  user  )

static

Definition at line 647 of file flag.c.

                                                      {
    struct unset_foreach_t *u = (struct unset_foreach_t *)user;
    if (IS_FI_NOTIN_SPACE(u->f, fi)) {
        return true;
    }
    rz_flag_unset(u->f, fi);
    u->n++;
    return true;
}

References unset_foreach_t::f, IS_FI_NOTIN_SPACE, unset_foreach_t::n, and rz_flag_unset().

Referenced by rz_flag_unset_glob().

unset_off_foreach()

static bool unset_off_foreach ( void *  user, const void *  k, const void *  v  )

static

Definition at line 622 of file flag.c.

                                                                        {
    struct unset_off_foreach_t *u = (struct unset_off_foreach_t *)user;
    RzFlagItem *fi = (RzFlagItem *)v;
    if (u->offset == fi->offset) {
        rz_flag_unset(u->f, fi);
    }
    return true;
}

References unset_off_foreach_t::f, unset_off_foreach_t::offset, rz_flag_item_t::offset, rz_flag_unset(), and v.

Referenced by rz_flag_unset_all_off().

update_flag_item_name()

static bool update_flag_item_name ( RzFlag *  f, RzFlagItem *  item, const char *  newname, bool  force  )

static

Definition at line 162 of file flag.c.

                                                                                                {
    if (!f || !item || !newname) {
        return false;
    }
    if (!force && (item->name == newname || (item->name && !strcmp(item->name, newname)))) {
        return false;
    }
    char *fname = filter_item_name(newname);
    if (!fname) {
        return false;
    }
    bool res = (item->name)
        ? ht_pp_update_key(f->ht_name, item->name, fname)
        : ht_pp_insert(f->ht_name, fname, item);
    if (res) {
        set_name(item, fname);
        return true;
    }
    free(fname);
    return false;
}

References f, filter_item_name(), create_tags_rz::fname, free(), rz_flag_item_t::name, and set_name().

Referenced by rz_flag_rename(), and rz_flag_set().

update_flag_item_offset()

static bool update_flag_item_offset ( RzFlag *  f, RzFlagItem *  item, ut64  newoff, bool  is_new, bool  force  )

static

Definition at line 143 of file flag.c.

                                                                                                       {
    if (item->offset != newoff || force) {
        if (!is_new) {
            remove_offsetmap(f, item);
        }
        item->offset = newoff;
 
        RzFlagsAtOffset *flagsAtOffset = flags_at_offset(f, newoff);
        if (!flagsAtOffset) {
            return false;
        }
 
        rz_list_append(flagsAtOffset->flags, item);
        return true;
    }
 
    return false;
}

References f, rz_flags_at_offset_t::flags, flags_at_offset(), rz_flag_item_t::offset, remove_offsetmap(), and rz_list_append().

Referenced by flag_relocate_foreach(), and rz_flag_set().