table.c File Reference

#include <rz_util/rz_table.h>
#include "rz_cons.h"

Go to the source code of this file.

Macros
#define	add_column_to_rowf(row, fmt, ap)

Functions
static int	sortString (const void *a, const void *b)
static int	sortNumber (const void *a, const void *b)
RZ_API RzTableColumnType *	rz_table_type (const char *name)
static void	__table_adjust (RzTable *t)
RZ_API void	rz_table_row_fini (RZ_NONNULL void *_row)
	clear function for RzVector rows in RzTable More...
static void	rz_table_row_fini_wrapper (RZ_NONNULL void *_row, void *user)
RZ_API void	rz_table_column_fini (RZ_NONNULL void *_col)
	clear function for RzVector cols in RzTable More...
static void	rz_table_column_fini_wrapper (RZ_NONNULL void *_col, void *user)
RZ_API RzTableColumn *	rz_table_column_clone (RzTableColumn *col)
RZ_API RzTable *	rz_table_new (void)
RZ_API void	rz_table_free (RzTable *t)
static bool	column_exists (RzTable *t, const char *name)
RZ_API void	rz_table_add_column (RzTable *t, RzTableColumnType *type, const char *name, int maxWidth)
RZ_API RzTableRow *	rz_table_row_new (RzPVector *items)
static bool	__addRow (RzTable *t, RzPVector *items, const char *arg, int col)
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 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 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_add_row_columnsf (RzTable *t, const char *fmt,...)
RZ_API void	rz_table_add_rowf (RzTable *t, const char *fmt,...)
RZ_API void	rz_table_add_row (RZ_NONNULL RzTable *t, const char *name,...)
static int	__strbuf_append_col_aligned_fancy (RzTable *t, RzStrBuf *sb, RzTableColumn *col, char *str)
static void	__computeTotal (RzTable *t)
RZ_API RZ_OWN char *	rz_table_tofancystring (RZ_NONNULL RzTable *t)
	Convert the content of RzTable to string. More...
static int	__strbuf_append_col_aligned (RzStrBuf *sb, RzTableColumn *col, const char *str, bool nopad)
RZ_API char *	rz_table_tostring (RzTable *t)
RZ_API char *	rz_table_tosimplestring (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)
static int	cmp (const void *_a, const void *_b)
RZ_API void	rz_table_sort (RzTable *t, int nth, bool dec)
static int	cmplen (const void *_a, const void *_b)
RZ_API void	rz_table_sortlen (RzTable *t, int nth, bool dec)
static int	rz_rows_cmp (RzPVector *lhs, RzPVector *rhs, RzVector *cols, int nth)
RZ_API void	rz_table_uniq (RzTable *t)
RZ_API void	rz_table_group (RzTable *t, int nth, RzTableSelector fcn)
RZ_API int	rz_table_column_nth (RzTable *t, const char *name)
static int	__resolveOperation (const char *op)
RZ_API void	rz_table_columns (RzTable *t, RzList *col_names)
	Select specific columns in RzTable. More...
RZ_API void	rz_table_filter_columns (RzTable *t, RzList *list)
static bool	set_table_format (RzTable *t, const char *q)
RZ_API bool	rz_table_query (RzTable *t, const char *q)
RZ_API bool	rz_table_align (RzTable *t, int nth, int align)
RZ_API void	rz_table_hide_header (RzTable *t)
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...

Variables
static int	Gnth = 0
static RzListComparator	Gcmp = NULL
static RzTableColumnType	rz_table_type_string = { "string", sortString }
static RzTableColumnType	rz_table_type_number = { "number", sortNumber }
static RzTableColumnType	rz_table_type_bool = { "bool", sortNumber }

Macro Definition Documentation

add_column_to_rowf

#define add_column_to_rowf	(		row,
			fmt,
			ap
	)

Definition at line 241 of file table.c.

Function Documentation

__addRow()

static bool __addRow ( RzTable *  t, RzPVector *  items, const char *  arg, int  col  )

static

Definition at line 158 of file table.c.

                                                                             {
    int itemLength = rz_str_len_utf8_ansi(arg) + 1;
    RzTableColumn *c = rz_vector_index_ptr(t->cols, col);
    if (c) {
        char *str = strdup(arg);
        c->width = RZ_MAX(c->width, itemLength);
        rz_pvector_push(items, str);
        return true;
    }
    return false;
}

References c, RzTable::cols, RZ_MAX, rz_pvector_push(), rz_str_len_utf8_ansi(), rz_vector_index_ptr(), cmd_descs_generate::str, and strdup().

Referenced by rz_table_add_row().

__computeTotal()

static void __computeTotal ( RzTable *  t )

static

Definition at line 378 of file table.c.

                                       {
    RzTableRow *row;
    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 (!rz_str_cmp(col->type->name, "number", rz_str_ansi_len("number")) && rz_str_isnumber(item)) {
                if (col->total < 0) {
                    col->total = 0;
                }
                col->total += sdb_atoi(item);
            }
            c++;
        }
    }
}

References c, RzTable::cols, RzTableRow::items, RzTableColumnType::name, RzTable::rows, rz_pvector_foreach, rz_str_ansi_len(), rz_str_cmp(), rz_str_isnumber(), rz_vector_foreach, rz_vector_index_ptr(), sdb_atoi(), RzTableColumn::total, and RzTableColumn::type.

Referenced by rz_table_tofancystring(), and rz_table_tosimplestring().

__resolveOperation()

static int __resolveOperation ( const char *  op )

static

Definition at line 886 of file table.c.

                                              {
    if (!strcmp(op, "gt")) {
        return '>';
    }
    if (!strcmp(op, "ge")) {
        return ')';
    }
    if (!strcmp(op, "lt")) {
        return '<';
    }
    if (!strcmp(op, "le")) {
        return '(';
    }
    if (!strcmp(op, "eq")) {
        return '=';
    }
    if (!strcmp(op, "ne")) {
        return '!';
    }
    return -1;
}

Referenced by rz_table_query().

__strbuf_append_col_aligned()

static int __strbuf_append_col_aligned ( RzStrBuf *  sb, RzTableColumn *  col, const char *  str, bool  nopad  )

static

Definition at line 470 of file table.c.

                                                                                                      {
    int ll = rz_strbuf_length(sb);
    if (nopad) {
        rz_strbuf_appendf(sb, "%s", str);
    } else {
        char *pad = "";
        int padlen = 0;
        int len1 = rz_str_len_utf8(str);
        int len2 = rz_str_len_utf8_ansi(str);
        if (len1 > len2) {
            if (len2 < col->width) {
                padlen = col->width - len2;
            }
        }
        switch (col->align) {
        case RZ_TABLE_ALIGN_LEFT:
            pad = rz_str_repeat(" ", padlen);
            rz_strbuf_appendf(sb, "%-*s%s", col->width, str, pad);
            free(pad);
            break;
        case RZ_TABLE_ALIGN_RIGHT:
            pad = rz_str_repeat(" ", padlen);
            rz_strbuf_appendf(sb, "%s%*s ", pad, col->width, str);
            free(pad);
            break;
        case RZ_TABLE_ALIGN_CENTER: {
            int pad = (col->width - len2) / 2;
            int left = col->width - (pad * 2 + len2);
            rz_strbuf_appendf(sb, "%-*s", pad, " ");
            rz_strbuf_appendf(sb, "%-*s ", pad + left, str);
            break;
        }
        default:
            rz_warn_if_reached();
            break;
        }
    }
    return rz_strbuf_length(sb) - ll;
}

References RzTableColumn::align, free(), pad(), rz_str_len_utf8(), rz_str_len_utf8_ansi(), rz_str_repeat(), rz_strbuf_appendf(), rz_strbuf_length(), RZ_TABLE_ALIGN_CENTER, RZ_TABLE_ALIGN_LEFT, RZ_TABLE_ALIGN_RIGHT, rz_warn_if_reached, sb, cmd_descs_generate::str, RzTableColumn::width, and width.

Referenced by rz_table_tosimplestring().

__strbuf_append_col_aligned_fancy()

static int __strbuf_append_col_aligned_fancy ( RzTable *  t, RzStrBuf *  sb, RzTableColumn *  col, char *  str  )

static

Definition at line 355 of file table.c.

                                                                                                      {
    RzCons *cons = (RzCons *)t->cons;
    const char *v_line = (cons && (cons->use_utf8 || cons->use_utf8_curvy)) ? RUNE_LINE_VERT : "|";
    int ll = rz_strbuf_length(sb);
    switch (col->align) {
    case RZ_TABLE_ALIGN_LEFT:
        rz_strbuf_appendf(sb, "%s %-*s ", v_line, col->width, str);
        break;
    case RZ_TABLE_ALIGN_RIGHT:
        rz_strbuf_appendf(sb, "%s %*s ", v_line, col->width, str);
        break;
    case RZ_TABLE_ALIGN_CENTER: {
        int len = rz_str_len_utf8(str);
        int pad = (col->width - len) / 2;
        int left = col->width - (pad * 2 + len);
        rz_strbuf_appendf(sb, "%s %-*s ", v_line, pad, " ");
        rz_strbuf_appendf(sb, "%-*s ", pad + left, str);
        break;
    }
    }
    return rz_strbuf_length(sb) - ll;
}

References RzTableColumn::align, RzTable::cons, len, pad(), RUNE_LINE_VERT, rz_str_len_utf8(), rz_strbuf_appendf(), rz_strbuf_length(), RZ_TABLE_ALIGN_CENTER, RZ_TABLE_ALIGN_LEFT, RZ_TABLE_ALIGN_RIGHT, sb, cmd_descs_generate::str, rz_cons_t::use_utf8, rz_cons_t::use_utf8_curvy, and RzTableColumn::width.

Referenced by rz_table_tofancystring().

__table_adjust()

static void __table_adjust ( RzTable *  t )

static

Definition at line 40 of file table.c.

                                       {
    RzTableColumn *col;
    RzTableRow *row;
    rz_vector_foreach(t->cols, col) {
        int itemLength = rz_str_len_utf8_ansi(col->name) + 1;
        col->width = itemLength;
    }
    rz_vector_foreach(t->rows, row) {
        void **pitem;
        char *item;
        int ncol = 0;
        rz_pvector_foreach (row->items, pitem) {
            item = *pitem;
            int itemLength = rz_str_len_utf8_ansi(item) + 1;
            RzTableColumn *c = rz_vector_index_ptr(t->cols, ncol);
            if (c) {
                c->width = RZ_MAX(c->width, itemLength);
            }
            ncol++;
        }
    }
}

References c, RzTable::cols, RzTableRow::items, RzTableColumn::name, RzTable::rows, RZ_MAX, rz_pvector_foreach, rz_str_len_utf8_ansi(), rz_vector_foreach, rz_vector_index_ptr(), and RzTableColumn::width.

Referenced by rz_table_query(), rz_table_tofancystring(), and rz_table_tosimplestring().

cmp()

static int cmp ( const void *  _a, const void *  _b  )

static

Definition at line 775 of file table.c.

                                               {
    RzTableRow *a = (RzTableRow *)_a;
    RzTableRow *b = (RzTableRow *)_b;
    const char *wa = rz_pvector_at(a->items, Gnth);
    const char *wb = rz_pvector_at(b->items, Gnth);
    int res = Gcmp(wa, wb);
    return res;
}

References a, b, Gcmp, Gnth, and rz_pvector_at().

Referenced by rz_table_sort().

cmplen()

static int cmplen ( const void *  _a, const void *  _b  )

static

Definition at line 797 of file table.c.

                                                  {
    RzTableRow *a = (RzTableRow *)_a;
    RzTableRow *b = (RzTableRow *)_b;
    const char *wa = rz_pvector_at(a->items, Gnth);
    const char *wb = rz_pvector_at(b->items, Gnth);
    int res = strlen(wa) - strlen(wb);
    return res;
}

References a, b, Gnth, and rz_pvector_at().

Referenced by rz_table_sortlen().

column_exists()

static bool column_exists ( RzTable *  t, const char *  name  )

static

Definition at line 123 of file table.c.

                                                        {
    RzTableColumn *c;
 
    rz_vector_foreach(t->cols, c) {
        if (!strcmp(c->name, name)) {
            return true;
        }
    }
    return false;
}

References c, RzTable::cols, and rz_vector_foreach.

Referenced by rz_table_add_column().

rz_rows_cmp()

static int rz_rows_cmp ( RzPVector *  lhs, RzPVector *  rhs, RzVector *  cols, int  nth  )

static

Definition at line 815 of file table.c.

                                                                                {
    void *item_lhs, *item_rhs;
    RzTableColumn *item_col;
    st32 tmp, i;
 
    for (i = 0; i < rz_pvector_len(lhs) && i < rz_pvector_len(rhs) && i < rz_vector_len(cols); i++) {
        item_lhs = rz_pvector_at(lhs, i);
        item_rhs = rz_pvector_at(rhs, i);
        item_col = rz_vector_index_ptr(cols, i);
 
        if (nth == -1 || i == nth) {
            tmp = item_col->type->cmp(item_lhs, item_rhs);
            if (tmp) {
                return tmp;
            }
        }
    }
 
    if (rz_pvector_len(lhs) > rz_pvector_len(rhs)) {
        return 1;
    } else if (rz_pvector_len(lhs) < rz_pvector_len(rhs)) {
        return -1;
    }
 
    return 0;
}

References RzTableColumnType::cmp, i, rz_pvector_at(), rz_pvector_len(), rz_vector_index_ptr(), rz_vector_len(), st32, autogen_x86imm::tmp, and RzTableColumn::type.

Referenced by rz_table_group().

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_fini_wrapper()

static void rz_table_column_fini_wrapper ( RZ_NONNULL void *  _col, void *  user  )

static

Definition at line 89 of file table.c.

                                                                            {
    rz_table_column_fini(_col);
}

References rz_table_column_fini().

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

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_filter_columns()

RZ_API void rz_table_filter_columns	(	RzTable *	t,
		RzList *	list
	)

Definition at line 1015 of file table.c.

                                                              {
    const char *col;
    RzListIter *iter;
    RzVector *cols = t->cols;
    t->cols = rz_vector_new(sizeof(RzTableColumn), rz_table_column_fini_wrapper, NULL);
    rz_list_foreach (list, iter, col) {
        int ncol = rz_table_column_nth(t, col);
        if (ncol != -1) {
            RzTableColumn *c = rz_vector_index_ptr(cols, ncol);
            if (c) {
                rz_table_add_column(t, c->type, col, 0);
            }
        }
    }
    rz_vector_free(cols);
}

References c, RzTable::cols, list(), NULL, rz_table_add_column(), rz_table_column_fini_wrapper(), rz_table_column_nth(), rz_vector_free(), rz_vector_index_ptr(), and rz_vector_new().

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_fini_wrapper()

static void rz_table_row_fini_wrapper ( RZ_NONNULL void *  _row, void *  user  )

static

Definition at line 74 of file table.c.

                                                                         {
    rz_table_row_fini(_row);
}

References rz_table_row_fini().

Referenced by rz_table_new().

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	dec
	)

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_sortlen()

RZ_API void rz_table_sortlen	(	RzTable *	t,
		int	nth,
		bool	dec
	)

Definition at line 806 of file table.c.

                                                            {
    RzTableColumn *col = rz_vector_index_ptr(t->cols, nth);
    if (col) {
        Gnth = nth;
        rz_vector_sort(t->rows, cmplen, dec);
        Gnth = 0;
    }
}

References cmplen(), RzTable::cols, Gnth, RzTable::rows, rz_vector_index_ptr(), and rz_vector_sort().

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().

set_table_format()

static bool set_table_format ( RzTable *  t, const char *  q  )

static

Definition at line 1032 of file table.c.

                                                        {
    if (!strcmp(q, "quiet")) {
        t->showHeader = false;
        t->showFancy = false;
    } else if (!strcmp(q, "fancy")) {
        t->showFancy = true;
    } else if (!strcmp(q, "simple")) {
        t->showFancy = false;
    } else if (!strcmp(q, "csv")) {
        t->showCSV = true;
    } else if (!strcmp(q, "json")) {
        t->showJSON = true;
    } else {
        return false;
    }
    return true;
}

References RzTable::showCSV, RzTable::showFancy, RzTable::showHeader, and RzTable::showJSON.

Referenced by rz_table_query().

sortNumber()

static int sortNumber ( const void *  a, const void *  b  )

static

Definition at line 15 of file table.c.

                                                    {
    return rz_num_get(NULL, a) - rz_num_get(NULL, b);
}

References a, b, NULL, and rz_num_get().

sortString()

static int sortString ( const void *  a, const void *  b  )

static

Definition at line 11 of file table.c.

                                                    {
    return strcmp(a, b);
}

References a, and b.

Variable Documentation

Gcmp

RzListComparator Gcmp = NULL

static

Definition at line 9 of file table.c.

Referenced by cmp(), and rz_table_sort().

Gnth

int Gnth = 0

static

Definition at line 8 of file table.c.

Referenced by cmp(), cmplen(), rz_table_sort(), and rz_table_sortlen().

rz_table_type_bool

RzTableColumnType rz_table_type_bool = { "bool", sortNumber }

static

Definition at line 22 of file table.c.

Referenced by rz_table_type().

rz_table_type_number

RzTableColumnType rz_table_type_number = { "number", sortNumber }

static

Definition at line 21 of file table.c.

Referenced by rz_table_tojson(), and rz_table_type().

rz_table_type_string

RzTableColumnType rz_table_type_string = { "string", sortString }

static

Definition at line 20 of file table.c.

Referenced by rz_table_type().