static void listxrefs(HtUP *m, ut64 addr, RList *list) {
if (addr == UT64_MAX) {
ht_up_foreach (m, mylistrefs_cb, list);
} else {
bool found;
HtUP *d = ht_up_find (m, addr, &found);
if (!found) {
return;
}
ht_up_foreach (d, appendRef, list);
}
r_list_sort (list, (RListComparator)ref_cmp);
}
bool test_r_list_sort(void) {
RList* list = r_list_new ();
char* test1 = "AAAA";
char* test2 = "BBBB";
char* test3 = "CCCC";
// Put in not sorted order.
r_list_append (list, (void*)test1);
r_list_append (list, (void*)test3);
r_list_append (list, (void*)test2);
// Sort.
r_list_sort (list, (RListComparator)strcmp);
// Check that the list is actually sorted.
mu_assert_streq ((char*)list->head->data, "AAAA", "first value in sorted list");
mu_assert_streq ((char*)list->head->n->data, "BBBB", "second value in sorted list");
mu_assert_streq ((char*)list->head->n->n->data, "CCCC", "third value in sorted list");
r_list_free (list);
mu_end;
}
bool test_r_list_sort5(void) {
RList* list = r_list_new ();
int i = 0;
char *upper[] = {"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
char *lower[] = {"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"};
for (i = 0; i < 26; i++) {
r_list_append (list, (void *)lower[i]);
}
for (i = 0; i < 26; i++) {
r_list_append (list, (void *)upper[i]);
}
//add more than 43 elements to trigger merge sort
r_list_sort (list, (RListComparator)strcmp);
mu_assert_streq ((char *)list->head->data, upper[0], "First element");
mu_assert_streq ((char *)list->tail->data, lower[25], "Last element");
r_list_free (list);
mu_end;
}
char* test_r_list_sort(void) {
int bad = 0;
RList* list = r_list_new ();
char* test1 = "AAAA";
char* test2 = "BBBB";
char* test3 = "CCCC";
// Put in not sorted order.
r_list_append (list, (void*)test1);
r_list_append (list, (void*)test3);
r_list_append (list, (void*)test2);
// Sort.
r_list_sort (list, (RListComparator)strcmp);
// Check that the list is actually sorted.
bad |= strcmp ("AAAA", list->head->data);
bad |= strcmp ("BBBB", list->head->n->data);
bad |= strcmp ("CCCC", list->head->n->n->data);
mu_assert("error, list not sorted properly", bad == 0);
return NULL;
}
R_API int r_cons_grepbuf(char *buf, int len) {
RCons *cons = r_cons_singleton ();
char *tline, *tbuf, *p, *out, *in = buf;
int ret, total_lines = 0, buffer_len = 0, l = 0, tl = 0;
bool show = false;
if (cons->filter) {
cons->buffer_len = 0;
R_FREE (cons->buffer);
return 0;
}
if ((!len || !buf || buf[0] == '\0') &&
(cons->grep.json || cons->grep.less)) {
cons->grep.json = 0;
cons->grep.less = 0;
return 0;
}
if (cons->grep.json) {
if (cons->grep.json_path) {
char *u = sdb_json_get_str (cons->buffer, cons->grep.json_path);
if (u) {
cons->buffer = u;
cons->buffer_len = strlen (u);
cons->buffer_sz = cons->buffer_len + 1;
cons->grep.json = 0;
r_cons_newline ();
}
R_FREE (cons->grep.json_path);
} else {
const char *palette[] = {
cons->pal.graph_false, // f
cons->pal.graph_true, // t
cons->pal.num, // k
cons->pal.comment, // v
Color_RESET,
NULL
};
char *out = r_print_json_indent (buf, I (color), " ", palette);
if (!out) {
return 0;
}
free (cons->buffer);
cons->buffer = out;
cons->buffer_len = strlen (out);
cons->buffer_sz = cons->buffer_len + 1;
cons->grep.json = 0;
if (cons->grep.less) {
cons->grep.less = 0;
r_cons_less_str (cons->buffer, NULL);
}
}
return 3;
}
if (cons->grep.less) {
int less = cons->grep.less;
cons->grep.less = 0;
if (less == 2) {
char *res = r_cons_hud_string (buf);
r_cons_println (res);
free (res);
} else {
r_cons_less_str (buf, NULL);
buf[0] = 0;
cons->buffer_len = 0;
if (cons->buffer) {
cons->buffer[0] = 0;
}
R_FREE (cons->buffer);
}
return 0;
}
if (!cons->buffer) {
cons->buffer_len = len + 20;
cons->buffer = malloc (cons->buffer_len);
cons->buffer[0] = 0;
}
out = tbuf = calloc (1, len);
if (!out) {
return 0;
}
tline = malloc (len);
if (!tline) {
free (out);
return 0;
}
cons->lines = 0;
// used to count lines and change negative grep.line values
while ((int) (size_t) (in - buf) < len) {
p = strchr (in, '\n');
if (!p) {
break;
}
l = p - in;
if (l > 0) {
in += l + 1;
} else {
in++;
}
total_lines++;
}
if (!cons->grep.range_line && cons->grep.line < 0) {
cons->grep.line = total_lines + cons->grep.line;
}
if (cons->grep.range_line == 1) {
if (cons->grep.f_line < 0) {
cons->grep.f_line = total_lines + cons->grep.f_line;
}
if (cons->grep.l_line < 0) {
cons->grep.l_line = total_lines + cons->grep.l_line;
}
}
in = buf;
while ((int) (size_t) (in - buf) < len) {
p = strchr (in, '\n');
if (!p) {
free (tbuf);
free (tline);
return 0;
}
l = p - in;
if (l > 0) {
memcpy (tline, in, l);
if (cons->grep_color) {
tl = l;
} else {
tl = r_str_ansi_filter (tline, NULL, NULL, l);
}
if (tl < 0) {
ret = -1;
} else {
ret = r_cons_grep_line (tline, tl);
if (!cons->grep.range_line) {
if (cons->grep.line == cons->lines) {
show = true;
}
} else if (cons->grep.range_line == 1) {
if (cons->grep.f_line == cons->lines) {
show = true;
}
if (cons->grep.l_line == cons->lines) {
show = false;
}
} else {
show = true;
}
}
if (ret > 0) {
if (show) {
memcpy (out, tline, ret);
memcpy (out + ret, "\n", 1);
out += ret + 1;
buffer_len += ret + 1;
}
if (!cons->grep.range_line) {
show = false;
}
cons->lines++;
} else if (ret < 0) {
free (tbuf);
free (tline);
return 0;
}
in += l + 1;
} else {
in++;
}
}
memcpy (buf, tbuf, len);
cons->buffer_len = buffer_len;
free (tbuf);
free (tline);
if (cons->grep.counter) {
int cnt = cons->grep.charCounter? strlen (cons->buffer): cons->lines;
if (cons->buffer_len < 10) {
cons->buffer_len = 10; // HACK
}
snprintf (cons->buffer, cons->buffer_len, "%d\n", cnt);
cons->buffer_len = strlen (cons->buffer);
cons->num->value = cons->lines;
}
if (cons->grep.sort != -1) {
#define INSERT_LINES(list)\
do {\
r_list_foreach (list, iter, str) {\
int len = strlen (str);\
memcpy (ptr, str, len);\
memcpy (ptr + len, "\n", 2);\
ptr += len + 1;\
nl++;\
}\
}\
while (false)
RListIter *iter;
int nl = 0;
char *ptr = cons->buffer;
char *str;
sorted_column = cons->grep.sort;
r_list_sort (sorted_lines, cmp);
if (cons->grep.sort_invert) {
r_list_reverse (sorted_lines);
}
INSERT_LINES (unsorted_lines);
INSERT_LINES (sorted_lines);
cons->lines = nl;
r_list_free (sorted_lines);
sorted_lines = NULL;
r_list_free (unsorted_lines);
unsorted_lines = NULL;
}
return cons->lines;
}
static void print_debug_maps_ascii_art(RDebug *dbg, RList *maps, ut64 addr, int colors) {
ut64 mul; // The amount of address space a single console column will represent in bar graph
ut64 min = -1, max = 0;
int width = r_cons_get_size (NULL) - 90;
RListIter *iter;
RDebugMap *map;
if (width < 1) {
width = 30;
}
r_list_sort (maps, cmp);
mul = findMinMax (maps, &min, &max, 0, width);
ut64 last = min;
if (min != -1 && mul != 0) {
const char *color_prefix = ""; // Color escape code prefixed to string (address coloring)
const char *color_suffix = ""; // Color escape code appended to end of string
const char *fmtstr;
char size_buf[56]; // Holds the human formatted size string [124K]
int skip = 0; // Number of maps to skip when re-calculating the minmax
r_list_foreach (maps, iter, map) {
r_num_units (size_buf, map->size); // Convert map size to human readable string
if (colors) {
color_suffix = Color_RESET;
if (map->perm & 2) { // Writable maps are red
color_prefix = Color_RED;
} else if (map->perm & 1) { // Executable maps are green
color_prefix = Color_GREEN;
} else {
color_prefix = "";
color_suffix = "";
}
} else {
color_prefix = "";
color_suffix = "";
}
if ((map->addr - last) > UT32_MAX) { // TODO: Comment what this is for
mul = findMinMax (maps, &min, &max, skip, width); // Recalculate minmax
}
skip++;
fmtstr = dbg->bits & R_SYS_BITS_64 ? // Prefix formatting string (before bar)
"map %4.8s %c %s0x%016"PFMT64x"%s |" :
"map %4.8s %c %s0x%08"PFMT64x"%s |";
dbg->cb_printf (fmtstr, size_buf,
(addr >= map->addr && \
addr < map->addr_end) ? '*' : '-',
color_prefix, map->addr, color_suffix); // * indicates map is within our current seeked offset
int col;
for (col = 0; col < width; col++) { // Iterate over the available width/columns for bar graph
ut64 pos = min + (col * mul); // Current address space to check
ut64 npos = min + ((col + 1) * mul); // Next address space to check
if (map->addr < npos && map->addr_end > pos) {
dbg->cb_printf ("#"); // TODO: Comment what a # represents
} else {
dbg->cb_printf ("-");
}
}
fmtstr = dbg->bits & R_SYS_BITS_64 ? // Suffix formatting string (after bar)
"| %s0x%016"PFMT64x"%s %s %s\n" :
"| %s0x%08"PFMT64x"%s %s %s\n";
dbg->cb_printf (fmtstr, color_prefix, map->addr_end, color_suffix,
r_str_rwx_i (map->perm), map->name);
last = map->addr;
}
}
