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; } }