rz_range.h File Reference

#include <rz_types.h>
#include <rz_list.h>

Go to the source code of this file.

Classes
struct	rz_range_item_t
struct	rz_range_t

Typedefs
typedef struct rz_range_item_t	RRangeItem
typedef struct rz_range_t	RRange

Functions
RZ_API RRange *	rz_range_new (void)
RZ_API RRange *	rz_range_new_from_string (const char *string)
RZ_API RRange *	rz_range_free (RRange *r)
RZ_API RRangeItem *	rz_range_item_get (RRange *r, ut64 addr)
RZ_API ut64	rz_range_size (RRange *r)
RZ_API int	rz_range_add_from_string (RRange *rgs, const char *string)
RZ_API RRangeItem *	rz_range_add (RRange *rgs, ut64 from, ut64 to, int rw)
RZ_API int	rz_range_sub (RRange *rgs, ut64 from, ut64 to)
RZ_API int	rz_range_contains (RRange *rgs, ut64 addr)
RZ_API int	rz_range_sort (RRange *rgs)
RZ_API void	rz_range_percent (RRange *rgs)
RZ_API int	rz_range_list (RRange *rgs, int rad)
RZ_API int	rz_range_get_n (RRange *rgs, int n, ut64 *from, ut64 *to)
RZ_API RRange *	rz_range_inverse (RRange *rgs, ut64 from, ut64 to, int flags)
RZ_API int	rz_range_overlap (ut64 a0, ut64 a1, ut64 b0, ut64 b1, int *d)

Typedef Documentation

RRange

typedef struct rz_range_t RRange

RRangeItem

typedef struct rz_range_item_t RRangeItem

Function Documentation

rz_range_add()

RZ_API RRangeItem* rz_range_add	(	RRange *	rgs,
		ut64	from,
		ut64	to,
		int	rw
	)

Definition at line 143 of file range.c.

                                                                       {
    RzListIter *iter;
    RRangeItem *r, *ret = NULL;
    int add = 1;
 
    rz_num_minmax_swap(&fr, &to);
    rz_list_foreach (rgs->ranges, iter, r) {
        if (r->fr == fr && r->to == to) {
            add = 0;
        } else if (r->fr <= fr && r->fr <= to && r->to >= fr && r->to <= to) {
            r->to = to;
            ret = r;
            add = 0;
        } else if (r->fr >= fr && r->fr <= to && r->to >= fr && r->to >= to) {
            r->fr = fr;
            ret = r;
            add = 0;
        } else if (r->fr <= fr && r->fr <= to && r->to >= fr && r->to >= to) {
            /* ignore */
            add = 0;
        } else if (r->fr >= fr && r->fr <= to && r->to >= fr && r->to <= to) {
            r->fr = fr;
            r->to = to;
            ret = r;
            add = 0;
        }
    }
 
    if (rw && add) {
        ret = RZ_NEW(RRangeItem);
        ret->fr = fr;
        ret->to = to;
        ret->datalen = 0;
        ret->data = NULL;
        rz_list_append(rgs->ranges, ret);
        rgs->changed = 1;
    }
 
    return ret;
}

References add(), rz_range_t::changed, rz_range_item_t::data, rz_range_item_t::datalen, rz_range_item_t::fr, NULL, r, rz_range_t::ranges, rz_list_append(), RZ_NEW, rz_num_minmax_swap(), rz_range_item_t::to, and to.

Referenced by rz_range_add_from_string(), rz_range_inverse(), and rz_range_sub().

rz_range_add_from_string()

RZ_API int rz_range_add_from_string	(	RRange *	rgs,
		const char *	string
	)

Definition at line 88 of file range.c.

                                                                     {
    ut64 addr, addr2;
    int i, len = strlen(string) + 1;
    char *str, *ostr = malloc(len);
    if (!ostr) {
        return 0;
    }
    char *p = str = ostr;
    char *p2 = NULL;
 
    memcpy(str, string, len);
    for (i = 0; i < len; i++) {
        switch (str[i]) {
        case '-':
            str[i] = '\0';
            p2 = p;
            p = str + i + 1;
            break;
        case ',':
            str[i] = '\0';
            if (p2) {
                addr = rz_num_get(NULL, p);
                addr2 = rz_num_get(NULL, p2);
                rz_range_add(rgs, addr, addr2, 1);
                p2 = NULL;
            } else {
                addr = rz_num_get(NULL, p);
                rz_range_add(rgs, addr, addr + 1, 1);
            }
            p = str + i + 1;
            str[i] = ',';
            break;
        }
    }
    if (p2) {
        addr = rz_num_get(NULL, p);
        addr2 = rz_num_get(NULL, p2);
        rz_range_add(rgs, addr, addr2, 1);
    } else if (p) {
        addr = rz_num_get(NULL, p);
        rz_range_add(rgs, addr, addr + 1, 1);
    }
    free(ostr);
    return rgs ? rgs->changed : 0;
}

References addr, rz_range_t::changed, free(), i, len, malloc(), memcpy(), NULL, p, rz_num_get(), rz_range_add(), cmd_descs_generate::str, and ut64().

Referenced by rz_range_new_from_string().

rz_range_contains()

RZ_API int rz_range_contains	(	RRange *	rgs,
		ut64	addr
	)

Definition at line 237 of file range.c.

                                                     {
    RRangeItem *r;
    RzListIter *iter;
    rz_list_foreach (rgs->ranges, iter, r) {
        if (addr >= r->fr && addr <= r->to) {
            return true;
        }
    }
    return false;
}

References addr, r, rz_range_t::ranges, and to.

Referenced by rz_range_percent().

rz_range_free()

RZ_API RRange* rz_range_free

(

RRange *

r

)

Definition at line 26 of file range.c.

                                        {
    rz_list_purge(r->ranges);
    free(r);
    return NULL;
}

References free(), NULL, r, and rz_list_purge().

Referenced by rz_range_new().

rz_range_get_n()

RZ_API int rz_range_get_n	(	RRange *	rgs,
		int	n,
		ut64 *	from,
		ut64 *	to
	)

Definition at line 331 of file range.c.

                                                                  {
    int count = 0;
    RRangeItem *r;
    RzListIter *iter;
    rz_range_sort(rgs);
    rz_list_foreach (rgs->ranges, iter, r) {
        if (count == n) {
            *fr = r->fr;
            *to = r->to;
            return 1;
        }
        count++;
    }
    return 0;
}

References count, n, r, rz_range_t::ranges, rz_range_sort(), and to.

rz_range_inverse()

RZ_API RRange* rz_range_inverse	(	RRange *	rgs,
		ut64	from,
		ut64	to,
		int	flags
	)

Definition at line 353 of file range.c.

                                                                          {
    RzListIter *iter;
    RRangeItem *r = NULL;
    RRange *newrgs = rz_range_new();
 
    rz_range_sort(rgs);
 
    rz_list_foreach (rgs->ranges, iter, r) {
        if (r->fr > fr && r->fr < to) {
            rz_range_add(newrgs, fr, r->fr, 1);
            fr = r->to;
        }
    }
    if (fr < to) {
        rz_range_add(newrgs, fr, to, 1);
    }
    return newrgs;
}

References NULL, r, rz_range_t::ranges, rz_range_add(), rz_range_new(), rz_range_sort(), and to.

rz_range_item_get()

RZ_API RRangeItem* rz_range_item_get	(	RRange *	r,
		ut64	addr
	)

Definition at line 59 of file range.c.

                                                             {
    RRangeItem *r;
    RzListIter *iter;
    rz_list_foreach (rgs->ranges, iter, r) {
        if (addr >= r->fr && addr < r->to) {
            return r;
        }
    }
    return NULL;
}

References addr, NULL, r, rz_range_t::ranges, and to.

Referenced by rz_range_get_data(), and rz_range_set_data().

rz_range_list()

RZ_API int rz_range_list	(	RRange *	rgs,
		int	rad
	)

Definition at line 314 of file range.c.

                                               {
    ut64 total = 0;
    RRangeItem *r;
    RzListIter *iter;
    rz_range_sort(rgs);
    rz_list_foreach (rgs->ranges, iter, r) {
        if (rad) {
            printf("ar+ 0x%08" PFMT64x " 0x%08" PFMT64x "\n", r->fr, r->to);
        } else {
            printf("0x%08" PFMT64x " 0x%08" PFMT64x " ; %" PFMT64d "\n", r->fr, r->to, r->to - r->fr);
        }
        total += (r->to - r->fr);
    }
    eprintf("Total bytes: %" PFMT64d "\n", total);
    return 0;
}

References eprintf, PFMT64d, PFMT64x, printf(), r, rz_range_t::ranges, rz_range_sort(), and ut64().

rz_range_new()

RZ_API RRange* rz_range_new

(

void

)

Definition at line 12 of file range.c.

                                  {
    RRange *r = RZ_NEW0(RRange);
    if (r) {
        r->count = r->changed = 0;
        r->ranges = rz_list_new();
        if (!r->ranges) {
            rz_range_free(r);
            return NULL;
        }
        r->ranges->free = free;
    }
    return r;
}

References free(), NULL, r, rz_list_new(), RZ_NEW0, and rz_range_free().

Referenced by rz_range_inverse(), and rz_range_new_from_string().

rz_range_new_from_string()

RZ_API RRange* rz_range_new_from_string

(

const char *

string

)

Definition at line 82 of file range.c.

                                                            {
    RRange *rgs = rz_range_new();
    rz_range_add_from_string(rgs, string);
    return rgs;
}

References rz_range_add_from_string(), and rz_range_new().

rz_range_overlap()

RZ_API int rz_range_overlap	(	ut64	a0,
		ut64	a1,
		ut64	b0,
		ut64	b1,
		int *	d
	)

Definition at line 378 of file range.c.

                                                                        {
    // TODO: ensure ranges minmax .. innecesary at runtime?
    // rz_num_minmax_swap (&a0, &a1);
    // rz_num_minmax_swap (&b0, &b1);
    return *d = (b0 - a0), !(a1 < b0 || a0 > b1);
#if 0
    // does not overlap
    // a  |__|           |__|
    // b      |__|   |__|
    if (a1<b0 || a0>b1)
        return 0;
 
    // a     |____|   |_____|  |____|     |_____|
    // b  |____|        |_|       |____| |_______|
    //      b needs    a needs   a needs   b needs
    // delta required
    return (b0-a0);
#endif
}

References a0, b1, and d.

rz_range_percent()

RZ_API void rz_range_percent

(

RRange *

rgs

)

Definition at line 267 of file range.c.

                                          {
    RzListIter *iter;
    RRangeItem *r;
    int w, i;
    ut64 seek, step;
    ut64 dif, fr = -1, to = -1;
 
    rz_list_foreach (rgs->ranges, iter, r) {
        if (fr == -1) {
            /* init */
            fr = r->fr;
            to = r->to;
        } else {
            if (fr > r->fr) {
                fr = r->fr;
            }
            if (to < r->to) {
                to = r->to;
            }
        }
    }
    w = 65; // columns
    if (fr != -1) {
        dif = to - fr;
        if (dif < w) {
            step = 1; // XXX
        } else {
            step = dif / w;
        }
    } else {
        step = fr = to = 0;
    }
    seek = 0;
    // XXX do not use printf here!
    printf("0x%08" PFMT64x " [", fr);
    for (i = 0; i < w; i++) {
        if (rz_range_contains(rgs, seek)) {
            printf("#");
        } else {
            printf(".");
        }
        seek += step;
    }
    printf("] 0x%08" PFMT64x "\n", to);
}

References i, PFMT64x, printf(), r, rz_range_t::ranges, rz_range_contains(), seek(), step(), to, ut64(), and w.

rz_range_size()

RZ_API ut64 rz_range_size

(

RRange *

r

)

Definition at line 72 of file range.c.

                                       {
    ut64 sum = 0;
    RzListIter *iter;
    RRangeItem *r;
    rz_list_foreach (rgs->ranges, iter, r) {
        sum += r->to - r->fr;
    }
    return sum;
}

References r, rz_range_t::ranges, and ut64().

rz_range_sort()

RZ_API int rz_range_sort

(

RRange *

rgs

)

Definition at line 254 of file range.c.

                                      {
    bool ch = rgs->ranges->sorted;
    if (!rgs->changed) {
        return false;
    }
    rgs->changed = false;
    rz_list_sort(rgs->ranges, (RzListComparator)cmp_ranges);
    if (ch != rgs->ranges->sorted) {
        rgs->changed = true;
    }
    return rgs->changed;
}

References rz_range_t::changed, cmp_ranges(), rz_range_t::ranges, rz_list_sort(), and rz_list_t::sorted.

Referenced by rz_range_get_n(), rz_range_inverse(), and rz_range_list().

rz_range_sub()

RZ_API int rz_range_sub	(	RRange *	rgs,
		ut64	from,
		ut64	to
	)

Definition at line 193 of file range.c.

                                                       {
    RRangeItem *r;
    RzListIter *iter;
 
    rz_num_minmax_swap(&fr, &to);
 
__reloop:
    rz_list_foreach (rgs->ranges, iter, r) {
        /* update to */
        if (r->fr < fr && r->fr < to && r->to > fr && r->to < to) {
            r->to = fr;
        } else if (r->fr > fr && r->fr < to && r->to > fr && r->to > to) {
            /* update fr */
            r->fr = to;
        }
        /* delete */
        if (r->fr > fr && r->fr < to && r->to > fr && r->to < to) {
            /* delete */
            rz_list_delete(rgs->ranges, iter);
            rgs->changed = 1;
            goto __reloop;
        }
        /* split */
        if (r->fr < fr && r->fr < to && r->to > fr && r->to > to) {
            r->to = fr;
            rz_range_add(rgs, to, r->to, 1);
            // ranges_add(rang, to, r->to, 1);
            goto __reloop;
        }
    }
    return 0;
}

References rz_range_t::changed, r, rz_range_t::ranges, rz_list_delete(), rz_num_minmax_swap(), rz_range_add(), and to.