rz_table.h File Reference

#include <rz_util.h>

Go to the source code of this file.

Classes
struct	RzTableColumnType
struct	RzTableColumn
struct	RzListInfo
struct	RzTableRow
struct	RzTable

Typedefs
typedef void(*	RzTableSelector) (RzTableRow *acc, RzTableRow *new_row, int nth)

Enumerations
enum	{ RZ_TABLE_ALIGN_LEFT , RZ_TABLE_ALIGN_RIGHT , RZ_TABLE_ALIGN_CENTER }

Functions
RZ_API void	rz_table_row_fini (RZ_NONNULL void *_row)
	clear function for RzVector rows in RzTable More...
RZ_API void	rz_table_column_fini (RZ_NONNULL void *_col)
	clear function for RzVector cols in RzTable More...
RZ_API RzTableColumn *	rz_table_column_clone (RzTableColumn *col)
RZ_API RzTableColumnType *	rz_table_type (const char *name)
RZ_API RzTable *	rz_table_new (void)
RZ_API void	rz_table_free (RzTable *t)
RZ_API int	rz_table_column_nth (RzTable *t, const char *name)
RZ_API void	rz_table_add_column (RzTable *t, RzTableColumnType *type, const char *name, int maxWidth)
RZ_API void	rz_table_set_columnsf (RzTable *t, const char *fmt,...)
	Specify the types and names of the referenced table. More...
RZ_API void	rz_table_set_vcolumnsf (RzTable *t, const char *fmt, va_list ap)
	Specify the types and names of the referenced table. More...
RZ_API RzTableRow *	rz_table_row_new (RzPVector *items)
RZ_API void	rz_table_add_row (RZ_NONNULL RzTable *t, const char *name,...)
RZ_API void	rz_table_add_rowf (RzTable *t, const char *fmt,...)
RZ_API void	rz_table_add_row_columnsf (RzTable *t, const char *fmt,...)
RZ_API void	rz_table_add_row_vec (RZ_NONNULL RzTable *t, RZ_NONNULL RzPVector *items)
	Add a new row to RzTable. More...
RZ_API RZ_OWN char *	rz_table_tofancystring (RZ_NONNULL RzTable *t)
	Convert the content of RzTable to string. More...
RZ_API char *	rz_table_tosimplestring (RzTable *t)
RZ_API char *	rz_table_tostring (RzTable *t)
RZ_API char *	rz_table_tocsv (RzTable *t)
RZ_API RZ_OWN char *	rz_table_tojson (RzTable *t)
	Convert RzTable to json format. More...
RZ_API void	rz_table_filter (RzTable *t, int nth, int op, const char *un)
RZ_API void	rz_table_sort (RzTable *t, int nth, bool inc)
RZ_API void	rz_table_uniq (RzTable *t)
RZ_API void	rz_table_group (RzTable *t, int nth, RzTableSelector fcn)
RZ_API bool	rz_table_query (RzTable *t, const char *q)
RZ_API void	rz_table_hide_header (RzTable *t)
RZ_API bool	rz_table_align (RzTable *t, int nth, int align)
RZ_API void	rz_table_visual_list (RzTable *table, RzList *list, ut64 seek, ut64 len, int width, bool va)
RZ_API RZ_OWN RzTable *	rz_table_transpose (RZ_NONNULL RzTable *t)
	Generates the transpose of RzTable. More...
RZ_API void	rz_table_columns (RzTable *t, RzList *cols)
	Select specific columns in RzTable. More...

Typedef Documentation

RzTableSelector

typedef void(* RzTableSelector) (RzTableRow *acc, RzTableRow *new_row, int nth)

Definition at line 56 of file rz_table.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
RZ_TABLE_ALIGN_LEFT
RZ_TABLE_ALIGN_RIGHT
RZ_TABLE_ALIGN_CENTER

Definition at line 33 of file rz_table.h.

     {
    RZ_TABLE_ALIGN_LEFT,
    RZ_TABLE_ALIGN_RIGHT,
    RZ_TABLE_ALIGN_CENTER
};

Function Documentation

rz_table_add_column()

RZ_API void rz_table_add_column	(	RzTable *	t,
		RzTableColumnType *	type,
		const char *	name,
		int	maxWidth
	)

Definition at line 134 of file table.c.

                                                                                                     {
    if (column_exists(t, name)) {
        return;
    }
 
    RzTableColumn *c = RZ_NEW0(RzTableColumn);
    if (c) {
        c->name = strdup(name);
        c->maxWidth = maxWidth;
        c->type = type;
        int itemLength = rz_str_len_utf8_ansi(name) + 1;
        c->width = itemLength;
        c->total = -1;
        rz_vector_push(t->cols, c);
    }
    RZ_FREE(c);
}

References c, RzTable::cols, column_exists(), RZ_FREE, RZ_NEW0, rz_str_len_utf8_ansi(), rz_vector_push(), strdup(), and type.

Referenced by __new_heapblock_tbl(), cmd_pxr(), create_window_table(), function_list_print_to_table(), print_stats(), rz_analysis_function_all_opcode_stat_handler(), rz_heap_list_w32(), rz_table_filter_columns(), rz_table_set_vcolumnsf(), and rz_table_transpose().

rz_table_add_row()

RZ_API void rz_table_add_row	(	RZ_NONNULL RzTable *	t,
		const char *	name,
			...
	)

Definition at line 329 of file table.c.

                                                                           {
    rz_return_if_fail(t);
    va_list ap;
    va_start(ap, name);
    int col = 0;
    RzPVector *items = rz_pvector_new(free);
    __addRow(t, items, name, col++);
    for (;;) {
        const char *arg = va_arg(ap, const char *);
        if (!arg) {
            break;
        }
        __addRow(t, items, arg, col);
        // TODO: assert if number of columns doesnt match t->cols
        col++;
    }
    va_end(ap);
    RzTableRow *row = rz_table_row_new(items);
    rz_vector_push(t->rows, row);
    RZ_FREE(row);
    // throw warning if not enough columns defined in header
    t->totalCols = RZ_MAX(t->totalCols, rz_pvector_len(items));
}

References __addRow(), free(), RZ_FREE, RZ_MAX, rz_pvector_len(), rz_pvector_new(), rz_return_if_fail, rz_table_row_new(), and rz_vector_push().

Referenced by add_window_to_table(), and rz_table_transpose().

rz_table_add_row_columnsf()

RZ_API void rz_table_add_row_columnsf	(	RzTable *	t,
		const char *	fmt,
			...
	)

Add some columns values to the last created row, if any, or create a new row otherwise.

Definition at line 289 of file table.c.

                                                                        {
    rz_return_if_fail(t && fmt);
 
    va_list ap;
    va_start(ap, fmt);
    RzTableRow *row = rz_vector_tail(t->rows);
    RzPVector *vec;
    bool add_row;
    if (row) {
        vec = row->items;
        add_row = false;
    } else {
        vec = rz_pvector_new(free);
        add_row = true;
    }
    for (const char *f = fmt; *f; f++) {
        add_column_to_rowf(vec, *f, ap);
    }
    va_end(ap);
    if (add_row) {
        rz_table_add_row_vec(t, vec);
    }
}

References add_column_to_rowf, f, free(), RzTableRow::items, RzTable::rows, rz_pvector_new(), rz_return_if_fail, rz_table_add_row_vec(), and rz_vector_tail().

Referenced by bin_resources_print_table(), rz_core_bin_sections_mapping_print(), and sections_print_table().

rz_table_add_row_vec()

RZ_API void rz_table_add_row_vec	(	RZ_NONNULL RzTable *	t,
		RZ_NONNULL RzPVector *	items
	)

Add a new row to RzTable.

Parameters

t	pointer to RzTable
items	pointer to RzPVector which contains row elements

Definition at line 176 of file table.c.

                                                                                     {
    rz_return_if_fail(t && items);
    RzTableRow *row = rz_table_row_new(items);
    rz_vector_push(t->rows, row);
    RZ_FREE(row);
    // throw warning if not enough columns defined in header
    t->totalCols = RZ_MAX(t->totalCols, rz_pvector_len(items));
}

References RZ_FREE, RZ_MAX, rz_pvector_len(), rz_return_if_fail, rz_table_row_new(), and rz_vector_push().

Referenced by analysis_class_print(), print_stats(), rz_analysis_function_all_opcode_stat_handler(), rz_table_add_row_columnsf(), and rz_table_add_rowf().

rz_table_add_rowf()

RZ_API void rz_table_add_rowf	(	RzTable *	t,
		const char *	fmt,
			...
	)

Add a new row with the specified columns values.

Definition at line 316 of file table.c.

                                                                {
    rz_return_if_fail(t && fmt);
 
    va_list ap;
    va_start(ap, fmt);
    RzPVector *vec = rz_pvector_new(free);
    for (const char *f = fmt; *f; f++) {
        add_column_to_rowf(vec, *f, ap);
    }
    va_end(ap);
    rz_table_add_row_vec(t, vec);
}

References add_column_to_rowf, f, free(), rz_pvector_new(), rz_return_if_fail, and rz_table_add_row_vec().

Referenced by __tableItemCallback(), bb_info_print(), bin_memory_print_rec(), bin_resources_print_table(), cmd_print_blocks(), cmd_pxr(), core_bin_file_print(), desc_list_table_cb(), disassembly_as_table(), entries_initfini_print(), function_list_print_to_table(), open_maps_show(), print_arch(), print_demangler_info(), references_handler(), rz_analysis_basic_block_list_handler(), rz_cmd_debug_list_bp_handler(), rz_core_analysis_sigdb_print(), rz_core_bin_basefind_print(), rz_core_bin_class_fields_print(), rz_core_bin_class_methods_print(), rz_core_bin_classes_print(), rz_core_bin_fields_print(), rz_core_bin_imports_print(), rz_core_bin_info_print(), rz_core_bin_libs_print(), rz_core_bin_main_print(), rz_core_bin_plugin_print(), rz_core_bin_relocs_print(), rz_core_bin_sections_mapping_print(), rz_core_binxtr_plugin_print(), rz_core_file_info_print(), rz_core_io_plugin_print(), rz_heap_debug_block_win(), rz_heap_list_w32(), rz_table_filter(), rz_table_visual_list(), rzil_print_register_bitv(), rzil_print_register_bool(), sections_print_table(), show_regs_handler(), strings_print(), symbols_print(), table_add_row_bool(), and w32_list_heaps_blocks().

rz_table_align()

RZ_API bool rz_table_align	(	RzTable *	t,
		int	nth,
		int	align
	)

Definition at line 1192 of file table.c.

                                                           {
    RzTableColumn *col = rz_vector_index_ptr(t->cols, nth);
    if (col) {
        col->align = align;
        return true;
    }
    return false;
}

References RzTableColumn::align, RzTable::cols, and rz_vector_index_ptr().

Referenced by analysis_class_print().

rz_table_column_clone()

RZ_API RzTableColumn* rz_table_column_clone

(

RzTableColumn *

col

)

Definition at line 93 of file table.c.

                                                                {
    RzTableColumn *c = RZ_NEW0(RzTableColumn);
    if (!c) {
        return NULL;
    }
    memcpy(c, col, sizeof(*c));
    c->name = strdup(c->name);
    return c;
}

References c, memcpy(), NULL, RZ_NEW0, and strdup().

Referenced by rz_table_columns().

rz_table_column_fini()

RZ_API void rz_table_column_fini

(

RZ_NONNULL void *

_col

)

clear function for RzVector cols in RzTable

Parameters

_col	pointer to the elements of cols in RzTable

Definition at line 83 of file table.c.

                                                        {
    rz_return_if_fail(_col);
    RzTableColumn *col = _col;
    free(col->name);
}

References free(), RzTableColumn::name, and rz_return_if_fail.

Referenced by rz_table_column_fini_wrapper(), and rz_table_columns().

rz_table_column_nth()

RZ_API int rz_table_column_nth	(	RzTable *	t,
		const char *	name
	)

Definition at line 873 of file table.c.

                                                             {
    RzTableColumn *col;
    ut32 n = 0;
 
    rz_vector_foreach(t->cols, col) {
        if (!strcmp(name, col->name)) {
            return n;
        }
        n++;
    }
    return -1;
}

References RzTable::cols, n, RzTableColumn::name, and rz_vector_foreach.

Referenced by rz_table_columns(), rz_table_filter_columns(), and rz_table_query().

rz_table_columns()

RZ_API void rz_table_columns	(	RzTable *	t,
		RzList *	col_names
	)

Select specific columns in RzTable.

Parameters

t	pointer to RzTable
col_names	pointer to RzList containing column names

Definition at line 914 of file table.c.

                                                            {
    // 1 bool per OLD column to indicate whether it should be freed (masked out)
    bool *free_cols = malloc(sizeof(bool) * rz_vector_len(t->cols));
    if (!free_cols) {
        return;
    }
    size_t i;
    for (i = 0; i < rz_vector_len(t->cols); i++) {
        free_cols[i] = true;
    }
 
    // 1 value per NEW column to indicate from which OLD column to take the info from and whether to dup it
    struct col_source {
        int oldcol;
        bool dup;
    } *col_sources = calloc(rz_list_length(col_names), sizeof(struct col_source));
    if (!col_sources) {
        free(free_cols);
        return;
    }
 
    // First create the plan which new columns to take from which old, which ones to dup or free.
    RzListIter *it;
    const char *col_name;
    size_t new_count = 0;
    rz_list_foreach (col_names, it, col_name) {
        int fc = rz_table_column_nth(t, col_name);
        if (fc < 0) {
            continue;
        }
        col_sources[new_count].oldcol = fc;
        col_sources[new_count].dup = !free_cols[fc]; // if we already used the same old column for another new column before, we must dup it for all following!
        free_cols[fc] = false;
        new_count++;
    }
 
    RzTableRow *row;
    rz_vector_foreach(t->rows, row) {
        RzPVector *old_items = row->items;
        RzPVector *new_items = rz_pvector_new(free);
 
        for (i = 0; i < new_count; i++) {
            char *item = *rz_pvector_index_ptr(old_items, col_sources[i].oldcol);
            if (!item) {
                continue;
            }
            if (col_sources[i].dup) {
                item = strdup(item);
            }
            rz_pvector_push(new_items, item);
        }
        row->items = new_items;
 
        // Free dropped items
        void **item;
        i = 0;
        rz_pvector_foreach (old_items, item) {
            if (free_cols[i]) {
                free(*item);
            }
            i++;
        }
        // Set old_items->free = NULL to avoid useful items are freed
        old_items->v.free = NULL;
        rz_pvector_free(old_items);
    }
 
    RzVector *old_cols = t->cols;
    RzVector *new_cols = rz_vector_new(sizeof(RzTableColumn), rz_table_column_fini_wrapper, NULL);
    for (i = 0; i < new_count; i++) {
        RzTableColumn *col = rz_vector_index_ptr(old_cols, col_sources[i].oldcol);
        if (!col) {
            continue;
        }
        if (col_sources[i].dup) {
            col = rz_table_column_clone(col);
            rz_vector_push(new_cols, col);
            RZ_FREE(col);
        } else {
            rz_vector_push(new_cols, col);
        }
    }
    t->cols = new_cols;
 
    // Free dropped columns
    RzTableColumn *col;
    i = 0;
    rz_vector_foreach(old_cols, col) {
        if (free_cols[i]) {
            rz_table_column_fini(col);
        }
        i++;
    }
    // Set old_cols->free = NULL to avoid useful columns are freed
    old_cols->free = NULL;
    rz_vector_free(old_cols);
 
    free(col_sources);
    free(free_cols);
}

References calloc(), RzTable::cols, dup, rz_vector_t::free, free(), i, RzTableRow::items, malloc(), NULL, RzTable::rows, RZ_FREE, rz_list_length(), rz_pvector_foreach, rz_pvector_free(), rz_pvector_index_ptr(), rz_pvector_new(), rz_pvector_push(), rz_table_column_clone(), rz_table_column_fini(), rz_table_column_fini_wrapper(), rz_table_column_nth(), rz_vector_foreach, rz_vector_free(), rz_vector_index_ptr(), rz_vector_len(), rz_vector_new(), rz_vector_push(), strdup(), and rz_pvector_t::v.

Referenced by rz_table_query().

rz_table_filter()

RZ_API void rz_table_filter	(	RzTable *	t,
		int	nth,
		int	op,
		const char *	un
	)

Definition at line 661 of file table.c.

                                                                         {
    rz_return_if_fail(t && un);
    RzTableRow *row;
    ut64 uv = rz_num_math(NULL, un);
    ut64 sum = 0;
    size_t page = 0, page_items = 0;
    size_t lrow = 0;
    if (op == 't') {
        size_t ll = rz_vector_len(t->rows);
        if (ll > uv) {
            uv = ll - uv;
        }
    }
    if (op == 'p') {
        sscanf(un, "%zd/%zd", &page, &page_items);
        if (page < 1) {
            page = 1;
        }
        lrow = page_items * (page - 1);
        uv = page_items * (page);
    }
    size_t nrow = 0;
    ut32 i;
    for (i = 0; i < rz_vector_len(t->rows); i++) {
        row = rz_vector_index_ptr(t->rows, i);
        const char *nn = nth < 0 ? NULL : rz_pvector_at(row->items, nth);
        ut64 nv = rz_num_math(NULL, nn);
        bool match = true;
        RzTableRow *del_row = RZ_NEW(RzTableRow);
        if (!del_row) {
            RZ_LOG_ERROR("Failed to allocate memory.\n");
            return;
        }
        switch (op) {
        case 'p':
            nrow++;
            if (nrow < lrow) {
                match = false;
            }
            if (nrow > uv) {
                match = false;
            }
            break;
        case 't':
            nrow++;
            if (nrow < uv) {
                match = false;
            }
            break;
        case 'h':
            nrow++;
            if (nrow > uv) {
                match = false;
            }
            break;
        case '+':
            // "sum"
            sum += nv;
            match = false;
            break;
        case '>':
            match = (nv > uv);
            break;
        case ')':
            // ">="
            match = (nv >= uv);
            break;
        case '<':
            match = (nv < uv);
            break;
        case '(':
            // "<="
            match = (nv <= uv);
            break;
        case '=':
            if (nv == 0 && nn != NULL) {
                match = !strcmp(nn, un);
            } else {
                match = (nv == uv);
            }
            break;
        case '!':
            if (nv == 0) {
                match = strcmp(nn, un);
            } else {
                match = (nv != uv);
            }
            break;
        case '~':
            match = strstr(nn, un) != NULL;
            break;
        case 's':
            match = strlen(nn) == atoi(un);
            break;
        case 'l':
            match = strlen(nn) > atoi(un);
            break;
        case 'L':
            match = strlen(nn) < atoi(un);
            break;
        case '\0':
            break;
        }
        if (!match) {
            rz_vector_remove_at(t->rows, i--, del_row);
            rz_table_row_fini(del_row);
        }
        RZ_FREE(del_row);
    }
    if (op == '+') {
        rz_table_add_rowf(t, "u", sum);
    }
}

References i, RzTableRow::items, NULL, RzTable::rows, RZ_FREE, RZ_LOG_ERROR, RZ_NEW, rz_num_math(), rz_pvector_at(), rz_return_if_fail, rz_table_add_rowf(), rz_table_row_fini(), rz_vector_index_ptr(), rz_vector_len(), rz_vector_remove_at(), and ut64().

Referenced by rz_table_query().

rz_table_free()

RZ_API void rz_table_free

(

RzTable *

t

)

Definition at line 114 of file table.c.

                                      {
    if (!t) {
        return;
    }
    rz_vector_free(t->cols);
    rz_vector_free(t->rows);
    free(t);
}

References RzTable::cols, free(), RzTable::rows, and rz_vector_free().

Referenced by analysis_class_print(), cmd_print_blocks(), print_windows(), references_handler(), rz_analysis_function_list_ascii_handler(), rz_cmd_info_section_bars_handler(), rz_cmd_state_output_fini(), rz_core_analysis_bbs_asciiart(), rz_core_analysis_il_vm_status(), rz_core_bin_sections_print(), rz_debug_traces_ascii(), rz_heap_debug_block_win(), rz_heap_list_w32(), rz_open_binary_list_ascii_handler(), rz_open_maps_list_ascii_handler(), rz_w32_identify_window(), and w32_list_heaps_blocks().

rz_table_group()

RZ_API void rz_table_group	(	RzTable *	t,
		int	nth,
		RzTableSelector	fcn
	)

Definition at line 846 of file table.c.

                                                                     {
    RzTableRow *row, *uniq_row, *del_row = RZ_NEW(RzTableRow);
    RzVector *rows = t->rows;
    ut32 i, j;
 
    if (!del_row) {
        RZ_LOG_ERROR("Failed to allocate memory.\n");
        return;
    }
    for (i = 0; i < rz_vector_len(rows); i++) {
        row = rz_vector_index_ptr(rows, i);
        for (j = 0; j < i; j++) {
            uniq_row = rz_vector_index_ptr(rows, j);
            if (!rz_rows_cmp(uniq_row->items, row->items, t->cols, nth)) {
                if (fcn) {
                    fcn(uniq_row, row, nth);
                }
                rz_vector_remove_at(rows, i--, del_row);
                // free the deleted row
                rz_table_row_fini(del_row);
                break;
            }
        }
    }
    RZ_FREE(del_row);
}

References RzTable::cols, i, RzTableRow::items, RzTable::rows, RZ_FREE, RZ_LOG_ERROR, RZ_NEW, rz_rows_cmp(), rz_table_row_fini(), rz_vector_index_ptr(), rz_vector_len(), and rz_vector_remove_at().

Referenced by rz_table_query(), and rz_table_uniq().

rz_table_hide_header()

RZ_API void rz_table_hide_header

(

RzTable *

t

)

Definition at line 1201 of file table.c.

                                             {
    t->showHeader = false;
}

References RzTable::showHeader.

Referenced by rz_core_bin_info_print(), and rz_core_file_info_print().

rz_table_new()

RZ_API RzTable* rz_table_new

(

void

)

Definition at line 103 of file table.c.

                                   {
    RzTable *t = RZ_NEW0(RzTable);
    if (t) {
        t->showHeader = true;
        t->cols = rz_vector_new(sizeof(RzTableColumn), rz_table_column_fini_wrapper, NULL);
        t->rows = rz_vector_new(sizeof(RzTableRow), rz_table_row_fini_wrapper, NULL);
        t->showSum = false;
    }
    return t;
}

References RzTable::cols, NULL, RzTable::rows, RZ_NEW0, rz_table_column_fini_wrapper(), rz_table_row_fini_wrapper(), rz_vector_new(), RzTable::showHeader, and RzTable::showSum.

Referenced by __new_heapblock_tbl(), analysis_class_print(), create_window_table(), rz_cmd_state_output_init(), rz_core_analysis_il_vm_status(), rz_core_bin_sections_print(), rz_core_table(), rz_debug_traces_ascii(), rz_heap_list_w32(), and rz_table_transpose().

rz_table_query()

RZ_API bool rz_table_query	(	RzTable *	t,
		const char *	q
	)

Definition at line 1050 of file table.c.

                                                      {
    rz_return_val_if_fail(t, false);
    q = rz_str_trim_head_ro(q);
    // TODO support parenthesis and (or)||
    // split by "&&" (or comma) -> run .filter on each
    // addr/gt/200,addr/lt/400,addr/sort/dec,offset/sort/inc
    if (!q || !*q) {
        __table_adjust(t);
        return true;
    }
    if (*q == '?') {
        eprintf("RzTableQuery> comma separated. 'c' stands for column name.\n");
        eprintf(" c/sort/inc        sort rows by given colname\n");
        eprintf(" c/sortlen/inc     sort rows by strlen()\n");
        eprintf(" c/cols/c1/c2      only show selected columns\n");
        eprintf(" c                 only show column c\n");
        eprintf(" c/gt/0x800        grep rows matching col0 > 0x800\n");
        eprintf(" c/ge/0x800        grep rows matching col0 >= 0x800\n");
        eprintf(" c/lt/0x800        grep rows matching col0 < 0x800\n");
        eprintf(" c/le/0x800        grep rows matching col0 <= 0x800\n");
        eprintf(" c/eq/0x800        grep rows matching col0 == 0x800\n");
        eprintf(" c/ne/0x800        grep rows matching col0 != 0x800\n");
        eprintf(" */uniq            get the first row of each that col0 is unique\n");
        eprintf(" */head/10         same as | head -n 10\n");
        eprintf(" */tail/10         same as | tail -n 10\n");
        eprintf(" */page/1/10       show the first 10 rows (/page/2/10 will show the 2nd)\n");
        eprintf(" c/str/warn        grep rows matching col(name).str(warn)\n");
        eprintf(" c/strlen/3        grep rows matching strlen(col) == X\n");
        eprintf(" c/minlen/3        grep rows matching strlen(col) > X\n");
        eprintf(" c/maxlen/3        grep rows matching strlen(col) < X\n");
        eprintf(" c/sum             sum all the values of given column\n");
        eprintf(" :csv              .tostring() == .tocsv()\n");
        eprintf(" :json             .tostring() == .tojson()\n");
        eprintf(" :fancy            fancy table output with lines\n");
        eprintf(" :simple           simple table output without lines\n");
        eprintf(" :quiet            do not print column names header, implies :simple\n");
        return false;
    }
 
    RzListIter *iter;
    char *qq = strdup(q);
    RzList *queries = rz_str_split_list(qq, ":", 0);
    char *query;
    rz_list_foreach (queries, iter, query) {
        bool is_formatter = set_table_format(t, query);
 
        RzList *q = rz_str_split_list(query, "/", 2);
        if (rz_list_length(q) < 2 && (is_formatter || !*query)) {
            rz_list_free(q);
            continue;
        }
 
        const char *columnName = rz_list_get_n(q, 0);
        if (!columnName) {
            eprintf("Column name is NULL for (%s)\n", query);
            rz_list_free(q);
            continue;
        }
        const char *operation = rz_list_get_n(q, 1);
        const char *operand = rz_list_get_n(q, 2);
 
        int col = rz_table_column_nth(t, columnName);
        if (col == -1) {
            if (*columnName == '[') {
                col = atoi(columnName + 1);
            }
        }
        if (!operation) {
            RzList *list = rz_list_new();
            if (list) {
                rz_list_append(list, strdup(columnName));
                rz_table_columns(t, list);
                rz_list_free(list);
            }
        } else if (!strcmp(operation, "sort")) {
            rz_table_sort(t, col, operand && !strcmp(operand, "dec"));
        } else if (!strcmp(operation, "uniq")) {
            rz_table_group(t, col, NULL);
        } else if (!strcmp(operation, "sortlen")) {
            rz_table_sortlen(t, col, operand && !strcmp(operand, "dec"));
        } else if (!strcmp(operation, "join")) {
            // TODO: implement join operation with other command's tables
        } else if (!strcmp(operation, "sum")) {
            char *op = strdup(operand ? operand : "");
            RzList *list = rz_str_split_list(op, "/", 0);
            rz_list_prepend(list, strdup(columnName));
            rz_table_columns(t, list); // select/reorder columns
            rz_list_free(list);
            rz_table_filter(t, 0, '+', op);
            free(op);
        } else if (!strcmp(operation, "strlen")) {
            if (operand) {
                rz_table_filter(t, col, 's', operand);
            }
        } else if (!strcmp(operation, "minlen")) {
            if (operand) {
                rz_table_filter(t, col, 'l', operand);
            }
        } else if (!strcmp(operation, "maxlen")) {
            if (operand) {
                rz_table_filter(t, col, 'L', operand);
            }
        } else if (!strcmp(operation, "page")) {
            if (operand) {
                rz_table_filter(t, col, 'p', operand);
            }
        } else if (!strcmp(operation, "tail")) {
            if (operand) {
                rz_table_filter(t, col, 't', operand);
            }
        } else if (!strcmp(operation, "head")) {
            if (operand) {
                rz_table_filter(t, col, 'h', operand);
            }
        } else if (!strcmp(operation, "str")) {
            if (operand) {
                rz_table_filter(t, col, '~', operand);
            }
        } else if (!strcmp(operation, "cols")) {
            char *op = strdup(operand ? operand : "");
            RzList *list = rz_str_split_list(op, "/", 0);
            rz_list_prepend(list, strdup(columnName));
            rz_table_columns(t, list); // select/reorder columns
            rz_list_free(list);
            free(op);
            // TODO rz_table_filter_columns (t, q);
        } else {
            int op = __resolveOperation(operation);
            if (op == -1) {
                eprintf("Invalid operation (%s)\n", operation);
            } else {
                rz_table_filter(t, col, op, operand);
            }
        }
        rz_list_free(q);
    }
    rz_list_free(queries);
    free(qq);
    __table_adjust(t);
    return true;
}

References __resolveOperation(), __table_adjust(), eprintf, free(), list(), NULL, rz_list_append(), rz_list_free(), rz_list_get_n(), rz_list_length(), rz_list_new(), rz_list_prepend(), rz_return_val_if_fail, rz_str_split_list(), rz_str_trim_head_ro(), rz_table_column_nth(), rz_table_columns(), rz_table_filter(), rz_table_group(), rz_table_sort(), rz_table_sortlen(), set_table_format(), and strdup().

Referenced by argv_call_cb(), cmd_pxr(), and rz_core_bin_sections_print().

rz_table_row_fini()

RZ_API void rz_table_row_fini

(

RZ_NONNULL void *

_row

)

clear function for RzVector rows in RzTable

Parameters

_row	pointer to the elements of rows in RzTable

Definition at line 68 of file table.c.

                                                     {
    rz_return_if_fail(_row);
    RzTableRow *row = _row;
    rz_pvector_free(row->items);
}

References RzTableRow::items, rz_pvector_free(), and rz_return_if_fail.

Referenced by rz_table_filter(), rz_table_group(), and rz_table_row_fini_wrapper().

rz_table_row_new()

RZ_API RzTableRow* rz_table_row_new

(

RzPVector *

items

)

Definition at line 152 of file table.c.

                                                      {
    RzTableRow *row = RZ_NEW(RzTableRow);
    row->items = items;
    return row;
}

References RzTableRow::items, and RZ_NEW.

Referenced by rz_table_add_row(), and rz_table_add_row_vec().

rz_table_set_columnsf()

RZ_API void rz_table_set_columnsf	(	RzTable *	t,
		const char *	fmt,
			...
	)

Specify the types and names of the referenced table.

Parameters

t	Referenced RzTable
fmt	String containing the numer and types of the columns
...	Variable number of strings that specify the names of the columns. There should be enough string as characters in fmt .

Definition at line 234 of file table.c.

                                                                    {
    va_list ap;
    va_start(ap, fmt);
    rz_table_set_vcolumnsf(t, fmt, ap);
    va_end(ap);
}

References rz_table_set_vcolumnsf().

Referenced by analysis_class_print(), cmd_print_blocks(), disassembly_as_table(), references_handler(), rz_core_analysis_il_vm_status(), rz_core_analysis_sigdb_print(), rz_core_bin_info_print(), rz_core_io_plugin_print(), rz_table_visual_list(), and show_regs_handler().

rz_table_set_vcolumnsf()

RZ_API void rz_table_set_vcolumnsf	(	RzTable *	t,
		const char *	fmt,
		va_list	ap
	)

Specify the types and names of the referenced table.

Parameters

t	Referenced RzTable
fmt	String containing the numer and types of the columns
ap	Variable number of strings that specify the names of the columns. There should be enough string as characters in fmt .

Definition at line 193 of file table.c.

                                                                            {
    RzTableColumnType *typeString = rz_table_type("string");
    RzTableColumnType *typeNumber = rz_table_type("number");
    RzTableColumnType *typeBool = rz_table_type("bool");
    const char *name;
    const char *f = fmt;
    for (; *f; f++) {
        name = va_arg(ap, const char *);
        if (!name) {
            break;
        }
        switch (*f) {
        case 'b':
            rz_table_add_column(t, typeBool, name, 0);
            break;
        case 's':
        case 'z':
            rz_table_add_column(t, typeString, name, 0);
            break;
        case 'i':
        case 'd':
        case 'n':
        case 'x':
        case 'X':
            rz_table_add_column(t, typeNumber, name, 0);
            break;
        default:
            eprintf("Invalid format string char '%c', use 's' or 'n'\n", *f);
            break;
        }
    }
}

References eprintf, f, name, rz_table_add_column(), rz_table_type(), and typeString().

Referenced by rz_cmd_state_output_set_columnsf(), and rz_table_set_columnsf().

rz_table_sort()

RZ_API void rz_table_sort	(	RzTable *	t,
		int	nth,
		bool	inc
	)

Definition at line 784 of file table.c.

                                                         {
    RzTableColumn *col = rz_vector_index_ptr(t->cols, nth);
    if (col) {
        Gnth = nth;
        if (col->type && col->type->cmp) {
            Gcmp = col->type->cmp;
            rz_vector_sort(t->rows, cmp, dec);
        }
        Gnth = 0;
        Gcmp = NULL;
    }
}

References RzTableColumnType::cmp, cmp(), RzTable::cols, Gcmp, Gnth, NULL, RzTable::rows, rz_vector_index_ptr(), rz_vector_sort(), and RzTableColumn::type.

Referenced by rz_table_query().

rz_table_tocsv()

RZ_API char* rz_table_tocsv

(

RzTable *

t

)

Definition at line 580 of file table.c.

                                        {
    RzStrBuf *sb = rz_strbuf_new("");
    RzTableRow *row;
    RzTableColumn *col;
    if (t->showHeader) {
        const char *comma = "";
        rz_vector_foreach(t->cols, col) {
            if (strchr(col->name, ',')) {
                // TODO. escaped string?
                rz_strbuf_appendf(sb, "%s\"%s\"", comma, col->name);
            } else {
                rz_strbuf_appendf(sb, "%s%s", comma, col->name);
            }
            comma = ",";
        }
        rz_strbuf_append(sb, "\n");
    }
    rz_vector_foreach(t->rows, row) {
        void **pitem;
        char *item;
        int c = 0;
        const char *comma = "";
        rz_pvector_foreach (row->items, pitem) {
            item = *pitem;
            RzTableColumn *col = rz_vector_index_ptr(t->cols, c);
            if (col) {
                if (strchr(col->name, ',')) {
                    rz_strbuf_appendf(sb, "%s\"%s\"", comma, col->name);
                } else {
                    rz_strbuf_appendf(sb, "%s%s", comma, item);
                }
                comma = ",";
            }
            c++;
        }
        rz_strbuf_append(sb, "\n");
    }
    return rz_strbuf_drain(sb);
}

References c, RzTable::cols, comma, RzTableRow::items, RzTableColumn::name, RzTable::rows, rz_pvector_foreach, rz_strbuf_append(), rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_new(), rz_vector_foreach, rz_vector_index_ptr(), sb, and RzTable::showHeader.

Referenced by rz_table_tostring().

rz_table_tofancystring()

RZ_API RZ_OWN char* rz_table_tofancystring

(

RZ_NONNULL RzTable *

t

)

Convert the content of RzTable to string.

Parameters

t	pointer to RzTable

Returns

string containing content of RzTable

Definition at line 404 of file table.c.

                                                                  {
    rz_return_val_if_fail(t, NULL);
    if (rz_vector_len(t->cols) == 0) {
        return strdup("");
    }
    RzStrBuf *sb = rz_strbuf_new("");
    RzTableRow *row;
    RzTableColumn *col;
    RzCons *cons = (RzCons *)t->cons;
    bool useUtf8 = (cons && cons->use_utf8);
    bool useUtf8Curvy = (cons && cons->use_utf8_curvy);
    const char *v_line = useUtf8 || useUtf8Curvy ? RUNE_LINE_VERT : "|";
    const char *h_line = useUtf8 || useUtf8Curvy ? RUNE_LINE_HORIZ : "-";
    const char *l_intersect = useUtf8 || useUtf8Curvy ? RUNE_LINE_VERT : ")";
    const char *rz_intersect = useUtf8 || useUtf8Curvy ? RUNE_LINE_VERT : "(";
    const char *tl_corner = useUtf8 ? (useUtf8Curvy ? RUNE_CURVE_CORNER_TL : RUNE_CORNER_TL) : ".";
    const char *tr_corner = useUtf8 ? (useUtf8Curvy ? RUNE_CURVE_CORNER_TR : RUNE_CORNER_TR) : ".";
    const char *bl_corner = useUtf8 ? (useUtf8Curvy ? RUNE_CURVE_CORNER_BL : RUNE_CORNER_BL) : "`";
    const char *br_corner = useUtf8 ? (useUtf8Curvy ? RUNE_CURVE_CORNER_BR : RUNE_CORNER_BR) : "'";
    __table_adjust(t);
 
    rz_vector_foreach(t->cols, col) {
        __strbuf_append_col_aligned_fancy(t, sb, col, col->name);
    }
    int len = rz_str_len_utf8_ansi(rz_strbuf_get(sb)) - 1;
    int maxlen = len;
    char *h_line_str = rz_str_repeat(h_line, maxlen);
    {
        char *s = rz_str_newf("%s%s%s\n", tl_corner, h_line_str, tr_corner);
        rz_strbuf_prepend(sb, s);
        free(s);
    }
 
    rz_strbuf_appendf(sb, "%s\n%s%s%s\n", v_line, l_intersect, h_line_str, rz_intersect);
    rz_vector_foreach(t->rows, row) {
        void **pitem;
        char *item;
        int c = 0;
        rz_pvector_foreach (row->items, pitem) {
            item = *pitem;
            RzTableColumn *col = rz_vector_index_ptr(t->cols, c);
            if (col) {
                int l = __strbuf_append_col_aligned_fancy(t, sb, col, item);
                len = RZ_MAX(len, l);
            }
            c++;
        }
        rz_strbuf_appendf(sb, "%s\n", v_line);
    }
 
    if (t->showSum) {
        char tmp[64];
        __computeTotal(t);
        rz_strbuf_appendf(sb, "%s%s%s\n", l_intersect, h_line_str, rz_intersect);
        rz_vector_foreach(t->cols, col) {
            char *num = col->total == -1 ? "" : sdb_itoa(col->total, tmp, 10);
            int l = __strbuf_append_col_aligned_fancy(t, sb, col, num);
            len = RZ_MAX(len, l);
        }
        rz_strbuf_appendf(sb, "%s\n", v_line);
    }
    rz_strbuf_appendf(sb, "%s%s%s\n", bl_corner, h_line_str, br_corner);
    free(h_line_str);
    return rz_strbuf_drain(sb);
}

References __computeTotal(), __strbuf_append_col_aligned_fancy(), __table_adjust(), c, free(), RzTableRow::items, len, maxlen, RzTableColumn::name, NULL, num, RUNE_CORNER_BL, RUNE_CORNER_BR, RUNE_CORNER_TL, RUNE_CORNER_TR, RUNE_CURVE_CORNER_BL, RUNE_CURVE_CORNER_BR, RUNE_CURVE_CORNER_TL, RUNE_CURVE_CORNER_TR, RUNE_LINE_HORIZ, RUNE_LINE_VERT, RZ_MAX, rz_pvector_foreach, rz_return_val_if_fail, rz_str_len_utf8_ansi(), rz_str_newf(), rz_str_repeat(), rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_get(), rz_strbuf_new(), rz_strbuf_prepend(), rz_vector_foreach, rz_vector_index_ptr(), rz_vector_len(), s, sb, sdb_itoa(), strdup(), autogen_x86imm::tmp, RzTableColumn::total, rz_cons_t::use_utf8, rz_cons_t::use_utf8_curvy, useUtf8, and useUtf8Curvy.

Referenced by cmd_print_blocks(), rz_table_tostring(), and rz_w32_identify_window().

rz_table_tojson()

RZ_API RZ_OWN char* rz_table_tojson

(

RzTable *

t

)

Convert RzTable to json format.

Parameters

t	pointer to RzTable

Returns

json string

Definition at line 626 of file table.c.

                                                {
    rz_return_val_if_fail(t, NULL);
    PJ *pj = pj_new();
    RzTableRow *row;
    pj_a(pj);
    rz_vector_foreach(t->rows, row) {
        void **pitem;
        char *item;
        int c = 0;
        pj_o(pj);
        rz_pvector_foreach (row->items, pitem) {
            item = *pitem;
            RzTableColumn *col = rz_vector_index_ptr(t->cols, c);
            if (col) {
                if (col->type == &rz_table_type_number) {
                    ut64 n = rz_num_get(NULL, item);
                    if (n) {
                        pj_kn(pj, col->name, n);
                    } else if (*item && *item != '0') {
                        pj_ks(pj, col->name, item);
                    }
                } else {
                    if (*item) {
                        pj_ks(pj, col->name, item);
                    }
                }
            }
            c++;
        }
        pj_end(pj);
    }
    pj_end(pj);
    return pj_drain(pj);
}

References c, RzTable::cols, RzTableRow::items, n, RzTableColumn::name, NULL, pj_a(), pj_drain(), pj_end(), pj_kn(), pj_ks(), pj_new(), pj_o(), RzTable::rows, rz_num_get(), rz_pvector_foreach, rz_return_val_if_fail, rz_table_type_number, rz_vector_foreach, rz_vector_index_ptr(), RzTableColumn::type, and ut64().

Referenced by references_handler(), and rz_table_tostring().

rz_table_tosimplestring()

RZ_API char* rz_table_tosimplestring

(

RzTable *

t

)

Definition at line 527 of file table.c.

                                                 {
    RzStrBuf *sb = rz_strbuf_new("");
    RzTableRow *row;
    RzTableColumn *col;
    RzCons *cons = (RzCons *)t->cons;
    const char *h_line = (cons && (cons->use_utf8 || cons->use_utf8_curvy)) ? RUNE_LONG_LINE_HORIZ : "-";
    __table_adjust(t);
    int maxlen = 0;
    if (t->showHeader) {
        rz_vector_foreach(t->cols, col) {
            int ll = __strbuf_append_col_aligned(sb, col, col->name, false);
            maxlen = RZ_MAX(maxlen, ll);
        }
        int len = rz_str_len_utf8_ansi(rz_strbuf_get(sb));
        char *l = rz_str_repeat(h_line, RZ_MAX(maxlen, len));
        if (l) {
            rz_strbuf_appendf(sb, "\n%s\n", l);
            free(l);
        }
    }
    rz_vector_foreach(t->rows, row) {
        void **pitem;
        char *item;
        int c = 0;
        rz_pvector_foreach (row->items, pitem) {
            item = *pitem;
            bool nopad = (item == rz_pvector_tail(row->items));
            RzTableColumn *col = rz_vector_index_ptr(t->cols, c);
            if (col) {
                (void)__strbuf_append_col_aligned(sb, col, item, nopad);
            }
            c++;
        }
        rz_strbuf_append(sb, "\n");
    }
    if (t->showSum) {
        char tmp[64];
        __computeTotal(t);
        if (maxlen > 0) {
            char *l = rz_str_repeat(h_line, maxlen);
            if (l) {
                rz_strbuf_appendf(sb, "\n%s\n", l);
                free(l);
            }
        }
        rz_vector_foreach(t->cols, col) {
            bool nopad = (col == rz_vector_tail(t->cols));
            (void)__strbuf_append_col_aligned(sb, col, sdb_itoa(col->total, tmp, 10), nopad);
        }
    }
    return rz_strbuf_drain(sb);
}

References __computeTotal(), __strbuf_append_col_aligned(), __table_adjust(), c, RzTable::cols, RzTable::cons, free(), RzTableRow::items, len, maxlen, RzTableColumn::name, RzTable::rows, RUNE_LONG_LINE_HORIZ, RZ_MAX, rz_pvector_foreach, rz_pvector_tail(), rz_str_len_utf8_ansi(), rz_str_repeat(), rz_strbuf_append(), rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_get(), rz_strbuf_new(), rz_vector_foreach, rz_vector_index_ptr(), rz_vector_tail(), sb, sdb_itoa(), RzTable::showHeader, RzTable::showSum, autogen_x86imm::tmp, RzTableColumn::total, rz_cons_t::use_utf8, and rz_cons_t::use_utf8_curvy.

Referenced by rz_table_tostring().

rz_table_tostring()

RZ_API char* rz_table_tostring

(

RzTable *

t

)

Definition at line 510 of file table.c.

                                           {
    if (t->showCSV) {
        return rz_table_tocsv(t);
    }
    if (t->showJSON) {
        char *s = rz_table_tojson(t);
        char *q = rz_str_newf("%s\n", s);
        ;
        free(s);
        return q;
    }
    if (t->showFancy) {
        return rz_table_tofancystring(t);
    }
    return rz_table_tosimplestring(t);
}

References free(), rz_str_newf(), rz_table_tocsv(), rz_table_tofancystring(), rz_table_tojson(), rz_table_tosimplestring(), s, RzTable::showCSV, RzTable::showFancy, and RzTable::showJSON.

Referenced by add_footer(), analysis_class_print(), print_windows(), references_handler(), rz_analysis_function_list_ascii_handler(), rz_cmd_info_section_bars_handler(), rz_cmd_state_output_print(), rz_core_analysis_bbs_asciiart(), rz_core_analysis_il_vm_status(), rz_core_bin_sections_print(), rz_debug_traces_ascii(), rz_heap_debug_block_win(), rz_heap_list_w32(), rz_open_binary_list_ascii_handler(), rz_open_maps_list_ascii_handler(), and w32_list_heaps_blocks().

rz_table_transpose()

RZ_API RZ_OWN RzTable* rz_table_transpose

(

RZ_NONNULL RzTable *

t

)

Generates the transpose of RzTable.

/param t Referenced RzTable /return t Referenced RzTable

This function returns the transpose of the RzTable passed to the table.

Definition at line 1292 of file table.c.

                                                                 {
    rz_return_val_if_fail(t, NULL);
    RzListIter *iter;
    RzList *row_name = rz_list_new();
    RzTable *transpose = rz_table_new();
    RzTableColumn *col;
    RzTableRow *row;
    RzTableColumnType *typeString = rz_table_type("string");
    void **pitem;
    char *item;
    ut32 i;
 
    // getting table column names to add to row head
    rz_table_add_column(transpose, typeString, "Name", 0);
 
    // adding rows to transpose table rows * (number of columns in the table)
    for (i = 0; i < rz_vector_len(t->rows); i++) {
        char name[20];
        if (rz_vector_len(t->rows) == 1) {
            rz_table_add_column(transpose, typeString, "Value", 0);
        } else {
            rz_table_add_column(transpose, typeString, rz_strf(name, "Value%d", i + 1), 0);
        }
    }
 
    // column names to row heads
    rz_vector_foreach(t->cols, col) {
        rz_list_append(row_name, col->name);
    }
 
    // adding rows with name alone
    if (row_name && t->rows) {
        iter = row_name->head;
        if (iter) {
            item = iter->data;
            for (i = 0; i < t->totalCols; i++) {
                rz_table_add_row(transpose, item, NULL);
                if (iter->n) {
                    iter = iter->n;
                    item = iter->data;
                }
            }
        }
    }
 
    if (transpose->rows) {
        rz_vector_foreach(t->rows, row) {
            if (!row) {
                RZ_LOG_WARN("Invalid row while doing transpose.\n");
                continue;
            }
            i = 0;
            rz_pvector_foreach (row->items, pitem) {
                item = *pitem;
                RzTableRow *tr_row = rz_vector_index_ptr(transpose->rows, i++);
                RzPVector *tr_items = tr_row->items;
                rz_pvector_push(tr_items, strdup(item));
            }
        }
    }
 
    rz_list_free(row_name);
    return transpose;
}

References rz_list_t::head, i, RzTableRow::items, RzTableColumn::name, NULL, RzTable::rows, rz_list_append(), rz_list_free(), rz_list_new(), RZ_LOG_WARN, rz_pvector_foreach, rz_pvector_push(), rz_return_val_if_fail, rz_strf, rz_table_add_column(), rz_table_add_row(), rz_table_new(), rz_table_type(), rz_vector_foreach, rz_vector_index_ptr(), rz_vector_len(), strdup(), and typeString().

rz_table_type()

RZ_API RzTableColumnType* rz_table_type

(

const char *

name

)

Definition at line 24 of file table.c.

                                                          {
    if (!strcmp(name, "bool")) {
        return &rz_table_type_bool;
    }
    if (!strcmp(name, "boolean")) {
        return &rz_table_type_bool;
    }
    if (!strcmp(name, "string")) {
        return &rz_table_type_string;
    }
    if (!strcmp(name, "number")) {
        return &rz_table_type_number;
    }
    return NULL;
}

References NULL, rz_table_type_bool, rz_table_type_number, and rz_table_type_string.

Referenced by __new_heapblock_tbl(), cmd_pxr(), create_window_table(), function_list_print_to_table(), print_stats(), rz_analysis_function_all_opcode_stat_handler(), rz_heap_list_w32(), rz_table_set_vcolumnsf(), rz_table_transpose(), and table_add_row_bool().

rz_table_uniq()

RZ_API void rz_table_uniq

(

RzTable *

t

)

Definition at line 842 of file table.c.

                                      {
    rz_table_group(t, -1, NULL);
}

References NULL, and rz_table_group().

rz_table_visual_list()

RZ_API void rz_table_visual_list	(	RzTable *	table,
		RzList *	list,
		ut64	seek,
		ut64	len,
		int	width,
		bool	va
	)

Definition at line 1205 of file table.c.

                                                                                                        {
    ut64 mul, min = -1, max = -1;
    RzListIter *iter;
    RzListInfo *info;
    RzCons *cons = (RzCons *)table->cons;
    table->showHeader = false;
    const char *h_line = cons->use_utf8 ? RUNE_LONG_LINE_HORIZ : "-";
    const char *block = cons->use_utf8 ? UTF_BLOCK : "#";
    int j, i;
    width -= 80;
    if (width < 1) {
        width = 30;
    }
 
    rz_table_set_columnsf(table, "sxsxsss", "No.", "start", "blocks", "end", "perms", "extra", "name");
    rz_list_foreach (list, iter, info) {
        if (min == -1 || info->pitv.addr < min) {
            min = info->pitv.addr;
        }
        if (max == -1 || info->pitv.addr + info->pitv.size > max) {
            max = info->pitv.addr + info->pitv.size;
        }
    }
    mul = (max - min) / width;
    if (min != -1 && mul > 0) {
        i = 0;
        rz_list_foreach (list, iter, info) {
            RzStrBuf *buf = rz_strbuf_new("");
            for (j = 0; j < width; j++) {
                ut64 pos = min + j * mul;
                ut64 npos = min + (j + 1) * mul;
                const char *arg = (info->pitv.addr < npos && (info->pitv.addr + info->pitv.size) > pos)
                    ? block
                    : h_line;
                rz_strbuf_append(buf, arg);
            }
            char *b = rz_strbuf_drain(buf);
            char no[64];
            if (va) {
                rz_table_add_rowf(table, "sxsxsss",
                    rz_strf(no, "%d%c", i, rz_itv_contain(info->vitv, seek) ? '*' : ' '),
                    info->vitv.addr,
                    b,
                    rz_itv_end(info->vitv),
                    (info->perm != -1) ? rz_str_rwx_i(info->perm) : "",
                    (info->extra) ? info->extra : "",
                    (info->name) ? info->name : "");
            } else {
                rz_table_add_rowf(table, "sxsxsss",
                    rz_strf(no, "%d%c", i, rz_itv_contain(info->pitv, seek) ? '*' : ' '),
                    info->pitv.addr,
                    b,
                    rz_itv_end(info->pitv),
                    (info->perm != -1) ? rz_str_rwx_i(info->perm) : "",
                    (info->extra) ? info->extra : "",
                    (info->name) ? info->name : "");
            }
            free(b);
            i++;
        }
        RzStrBuf *buf = rz_strbuf_new("");
        /* current seek */
        if (i > 0 && len != 0) {
            if (seek == UT64_MAX) {
                seek = 0;
            }
            for (j = 0; j < width; j++) {
                rz_strbuf_append(buf, ((j * mul) + min >= seek && (j * mul) + min <= seek + len) ? "^" : h_line);
            }
            char *s = rz_strbuf_drain(buf);
            rz_table_add_rowf(table, "sssssss", "=>", sdb_fmt("0x%08" PFMT64x, seek),
                s, sdb_fmt("0x%08" PFMT64x, seek + len), "", "", "");
            free(s);
        } else {
            rz_strbuf_free(buf);
        }
    }
}

References b, RzTable::cons, free(), i, if(), info(), len, list(), max, min, mul(), PFMT64x, pos, RUNE_LONG_LINE_HORIZ, rz_itv_contain(), rz_itv_end(), rz_str_rwx_i(), rz_strbuf_append(), rz_strbuf_drain(), rz_strbuf_free(), rz_strbuf_new(), rz_strf, rz_table_add_rowf(), rz_table_set_columnsf(), s, sdb_fmt(), seek(), RzTable::showHeader, rz_cons_t::use_utf8, ut64(), UT64_MAX, UTF_BLOCK, and width.

Referenced by rz_analysis_function_list_ascii_handler(), rz_cmd_info_section_bars_handler(), rz_core_analysis_bbs_asciiart(), rz_debug_traces_ascii(), rz_open_binary_list_ascii_handler(), and rz_open_maps_list_ascii_handler().