Magic-Mirror/radare2
1
0
Fork 0
mirror of https://github.com/radareorg/radare2.git synced 2024-12-15 09:21:00 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity
3fd04b1bea
radare2/libr/util/range.c

386 lines
8.4 KiB
C
Raw Blame History

/* radare - LGPL - Copyright 2008-2010 pancake<nopcode.org> */
#include <r_util.h>
// TODO: use r_list instead of list.h
// TODO: redesign this api.. why? :)
#if 0
// TODO: add tags to ranges
#endif
//void (*ranges_new_callback)(struct range_t *r) = NULL;
R_API RRange *r_range_new() {
RRange *r = R_NEW (RRange);
if (r) {
r->count = r->changed = 0;
r->ranges = r_list_new ();
r->ranges->free = free;
}
return r;
}
R_API RRange *r_range_free(RRange *r) {
r_list_purge (r->ranges);
free (r);
return NULL;
}
// TODO: optimize by just returning the pointers to the internal foo?
R_API int r_range_get_data(RRange *rgs, ut64 addr, ut8 *buf, int len) {
RRangeItem *r = r_range_item_get (rgs, addr);
if (r == NULL)
return 0;
if (r->datalen < len)
len = r->datalen;
memcpy (buf, r->data, len);
return len;
}
R_API int r_range_set_data(RRange *rgs, ut64 addr, const ut8 *buf, int len) {
RRangeItem *r = r_range_item_get (rgs, addr);
if (r == NULL)
return 0;
r->data = (ut8*)malloc (len);
r->datalen = len;
memcpy (r->data, buf, len);
return 1;
}
RRangeItem *r_range_item_get(RRange *rgs, ut64 addr) {
RRangeItem *r;
RListIter *iter;
r_list_foreach (rgs->ranges, iter, r) {
if (addr >= r->fr && addr < r->to)
return r;
}
return NULL;
}
/* returns the sum of all the ranges contained */
// XXX: can be catched while adding/removing elements
R_API ut64 r_range_size(RRange *rgs) {
ut64 sum = 0;
RListIter *iter;
RRangeItem *r;
r_list_foreach (rgs->ranges, iter, r)
sum += r->to - r->fr;
return sum;
}
R_API RRange *r_range_new_from_string(const char *string) {
RRange *rgs = r_range_new ();
r_range_add_from_string (rgs, string);
return rgs;
}
R_API int r_range_add_from_string(RRange *rgs, const char *string) {
ut64 addr, addr2;
int i, len = strlen (string)+1;
char *str, *ostr = malloc (len);
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 = r_num_get (NULL, p);
addr2 = r_num_get (NULL, p2);
r_range_add(rgs, addr, addr2, 1);
p2 = NULL;
} else {
addr = r_num_get (NULL, p);
r_range_add (rgs, addr, addr+1, 1);
}
p = str+i+1;
str[i] = ',';
break;
}
}
if (p2) {
addr = r_num_get (NULL, p);
addr2 = r_num_get (NULL, p2);
r_range_add (rgs, addr, addr2, 1);
} else
if (p) {
addr = r_num_get (NULL, p);
r_range_add (rgs, addr, addr+1, 1);
}
free (ostr);
return rgs? rgs->changed: 0;
}
#if 0
update to new one update fr update fr/to ignore
|______| |___| |_____| |____| |_______| range_t
+ |______| + |__| + |___| + |_________| + |__| fr/to
------------ ----------- ----------- ------------- -----------
= |_________| = |___||__| = |_______| = |_________| |_______| result
#endif
RRangeItem *r_range_add(RRange *rgs, ut64 fr, ut64 to, int rw) {
RListIter *iter;
RRangeItem *r, *ret = NULL;
int add = 1;
r_num_minmax_swap (&fr, &to);
r_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 = R_NEW (RRangeItem);
ret->fr = fr;
ret->to = to;
ret->datalen = 0;
ret->data = NULL;
r_list_append (rgs->ranges, ret);
rgs->changed = 1;
}
return ret;
}
#if 0
update to ignore update fr delete split
|______| |___| |_____| |____| |________| range_t
- |______| - |__| - |___| - |_________| - |__| fr/to
------------ ----------- ----------- ------------- ------------
= |__| = = |___| = |__| |__| result
#endif
R_API int r_range_sub(RRange *rgs, ut64 fr, ut64 to) {
RRangeItem *r;
RListIter *iter;
r_num_minmax_swap (&fr, &to);
__reloop:
r_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
/* update fr */
if (r->fr>fr && r->fr<to && r->to>fr && r->to>to) {
r->fr = to;
}
/* delete */
if (r->fr>fr && r->fr<to && r->to>fr && r->to < to) {
/* delete */
r_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;
r_range_add (rgs, to, r->to, 1);
//ranges_add(rang, to, r->to, 1);
goto __reloop;
}
}
return 0;
}
#if 0
/* TODO: should remove some of them right? */
R_API void r_range_merge(RRange *rgs, RRange *r) {
RListIter *iter;
RRangeItem *r;
r_list_foreach (rgs->ranges, iter, r)
r_range_add (rgs, r->fr, r->to, 0);
}
#endif
//int ranges_is_used(ut64 addr)
R_API int r_range_contains(RRange *rgs, ut64 addr) {
RRangeItem *r;
RListIter *iter;
r_list_foreach (rgs->ranges, iter, r) {
if (addr >= r->fr && addr <= r->to)
return R_TRUE;
}
return R_FALSE;
}
R_API int r_range_sort(RRange *rgs) {
RListIter *iter, *iter2;
RRangeItem *r, *r2;
if (!rgs->changed)
return R_FALSE;
rgs->changed = R_FALSE;
r_list_foreach (rgs->ranges, iter, r) {
r_list_foreach (rgs->ranges, iter2, r2) {
if ((r != r2) && (r->fr > r2->fr)) {
// TODO : IMPLEMENTED A FUCKING SWAP IN R_LIST!!!
// list_move (pos, pos2);
rgs->changed = R_TRUE;
}
}
}
return rgs->changed;
}
R_API void r_range_percent(RRange *rgs) {
RListIter *iter;
RRangeItem *r;
int w, i;
ut64 seek, step;
ut64 dif, fr = -1, to = -1;
r_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;
seek = 0;
} 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 (r_range_contains (rgs, seek))
printf ("#");
else printf (".");
seek += step;
}
printf ("] 0x%08"PFMT64x"\n", to);
}
// TODO: total can be cached in rgs!!
int r_range_list(RRange *rgs, int rad) {
ut64 total = 0;
RRangeItem *r;
RListIter *iter;
r_range_sort (rgs);
r_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;
}
int r_range_get_n(RRange *rgs, int n, ut64 *fr, ut64 *to) {
int count = 0;
RRangeItem *r;
RListIter *iter;
r_range_sort (rgs);
r_list_foreach (rgs->ranges, iter, r) {
if (count == n) {
*fr = r->fr;
*to = r->to;
return 1;
}
count++;
}
return 0;
}
#if 0
.....|______________________|...
|_____| |____| |_______|
---------------------------------
|__| |__| |_|
#endif
RRange *r_range_inverse(RRange *rgs, ut64 fr, ut64 to, int flags) {
ut64 total = 0;
RListIter *iter;
RRangeItem *r = NULL;
RRange *newrgs = r_range_new();
r_range_sort(rgs);
r_list_foreach (rgs->ranges, iter, r) {
if (r->fr > fr && r->fr < to) {
r_range_add(newrgs, fr, r->fr, 1);
//eprintf("0x%08"PFMT64x" .. 0x%08"PFMT64x"\n", fr, r->fr);
total += (r->fr - fr);
fr = r->to;
}
}
if (fr < to) {
//eprintf("0x%08"PFMT64x" .. 0x%08"PFMT64x"\n", fr, to);
r_range_add (newrgs, fr, to, 1);
total += (to-fr);
}
// eprintf("Total bytes: %"PFMT64d"\n", total);
return newrgs;
}
/*
return true if overlap
in *d
*/
// TODO: make it a macro
// TODO: move to num.c ?
R_API int r_range_overlap(ut64 a0, ut64 a1, ut64 b0, ut64 b1, int *d) {
// TODO: ensure ranges minmax .. innecesary at runtime?
//r_num_minmax_swap (&a0, &a1);
//r_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
}
Reference in New Issue View Git Blame Copy Permalink