340 lines
7.3 KiB
C
340 lines
7.3 KiB
C
// SPDX-FileCopyrightText: 2008-2020 pancake <pancake@nopcode.org>
|
|
// SPDX-License-Identifier: LGPL-3.0-only
|
|
|
|
#include <rz_util.h>
|
|
|
|
// TODO: add tags to ranges
|
|
|
|
// void (*ranges_new_callback)(struct range_t *r) = NULL;
|
|
|
|
RZ_API RRange *rz_range_new(void) {
|
|
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;
|
|
}
|
|
|
|
RZ_API RRange *rz_range_free(RRange *r) {
|
|
rz_list_purge(r->ranges);
|
|
free(r);
|
|
return NULL;
|
|
}
|
|
|
|
// TODO: optimize by just returning the pointers to the internal foo?
|
|
RZ_API int rz_range_get_data(RRange *rgs, ut64 addr, ut8 *buf, int len) {
|
|
RRangeItem *r = rz_range_item_get(rgs, addr);
|
|
if (!r) {
|
|
return 0;
|
|
}
|
|
if (r->datalen < len) {
|
|
len = r->datalen;
|
|
}
|
|
memcpy(buf, r->data, len);
|
|
return len;
|
|
}
|
|
|
|
RZ_API int rz_range_set_data(RRange *rgs, ut64 addr, const ut8 *buf, int len) {
|
|
RRangeItem *r = rz_range_item_get(rgs, addr);
|
|
if (!r) {
|
|
return 0;
|
|
}
|
|
r->data = (ut8 *)malloc(len);
|
|
if (!r->data) {
|
|
return 0;
|
|
}
|
|
r->datalen = len;
|
|
memcpy(r->data, buf, len);
|
|
return 1;
|
|
}
|
|
|
|
RZ_API RRangeItem *rz_range_item_get(RRange *rgs, ut64 addr) {
|
|
RRangeItem *r;
|
|
RzListIter *iter;
|
|
rz_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 caught while adding/removing elements
|
|
RZ_API ut64 rz_range_size(RRange *rgs) {
|
|
ut64 sum = 0;
|
|
RzListIter *iter;
|
|
RRangeItem *r;
|
|
rz_list_foreach (rgs->ranges, iter, r) {
|
|
sum += r->to - r->fr;
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
RZ_API RRange *rz_range_new_from_string(const char *string) {
|
|
RRange *rgs = rz_range_new();
|
|
rz_range_add_from_string(rgs, string);
|
|
return rgs;
|
|
}
|
|
|
|
RZ_API int rz_range_add_from_string(RRange *rgs, const char *string) {
|
|
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;
|
|
}
|
|
|
|
#if 0
|
|
update to new one update fr update fr/to ignore
|
|
|
|
|______| |___| |_____| |____| |_______| range_t
|
|
+ |______| + |__| + |___| + |_________| + |__| fr/to
|
|
------------ ----------- ----------- ------------- -----------
|
|
= |_________| = |___||__| = |_______| = |_________| |_______| result
|
|
#endif
|
|
|
|
RZ_API RRangeItem *rz_range_add(RRange *rgs, ut64 fr, ut64 to, int rw) {
|
|
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;
|
|
}
|
|
|
|
#if 0
|
|
update to ignore update fr delete split
|
|
|
|
|______| |___| |_____| |____| |________| range_t
|
|
- |______| - |__| - |___| - |_________| - |__| fr/to
|
|
------------ ----------- ----------- ------------- ------------
|
|
= |__| = = |___| = |__| |__| result
|
|
#endif
|
|
|
|
RZ_API int rz_range_sub(RRange *rgs, ut64 fr, ut64 to) {
|
|
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;
|
|
}
|
|
|
|
// int ranges_is_used(ut64 addr)
|
|
RZ_API int rz_range_contains(RRange *rgs, ut64 addr) {
|
|
RRangeItem *r;
|
|
RzListIter *iter;
|
|
rz_list_foreach (rgs->ranges, iter, r) {
|
|
if (addr >= r->fr && addr <= r->to) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static int cmp_ranges(void *a, void *b, void *user) {
|
|
RRangeItem *first = (RRangeItem *)a;
|
|
RRangeItem *second = (RRangeItem *)b;
|
|
return (first->fr > second->fr) - (first->fr < second->fr);
|
|
}
|
|
|
|
RZ_API int rz_range_sort(RRange *rgs) {
|
|
bool ch = rgs->ranges->sorted;
|
|
if (!rgs->changed) {
|
|
return false;
|
|
}
|
|
rgs->changed = false;
|
|
rz_list_sort(rgs->ranges, (RzListComparator)cmp_ranges, NULL);
|
|
if (ch != rgs->ranges->sorted) {
|
|
rgs->changed = true;
|
|
}
|
|
return rgs->changed;
|
|
}
|
|
|
|
RZ_API void rz_range_percent(RRange *rgs) {
|
|
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);
|
|
}
|
|
|
|
RZ_API int rz_range_get_n(RRange *rgs, int n, ut64 *fr, ut64 *to) {
|
|
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;
|
|
}
|
|
|
|
#if 0
|
|
.....|______________________|...
|
|
|_____| |____| |_______|
|
|
---------------------------------
|
|
|__| |__| |_|
|
|
#endif
|
|
RZ_API RRange *rz_range_inverse(RRange *rgs, ut64 fr, ut64 to, int flags) {
|
|
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;
|
|
}
|