print.c File Reference

#include <ctype.h>
#include <rz_util/rz_str.h>
#include <rz_list.h>
#include <rz_regex.h>
#include <rz_types.h>
#include <rz_util/rz_assert.h>
#include <rz_util/rz_log.h>
#include <rz_util/rz_strbuf.h>
#include <rz_vector.h>
#include <rz_util/rz_print.h>
#include <rz_analysis.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

Go to the source code of this file.

Macros
#define	DFLT_ROWS   16
#define	P(x)   (p->cons && p->cons->context->pal.x) ? p->cons->context->pal.x
#define	memcat(x, y)
#define	P(x)   (p->cons && p->cons->context->pal.x) ? p->cons->context->pal.x
#define	Pal(x, y)   (x->cons && x->cons->context->pal.y) ? x->cons->context->pal.y
#define	PREOFF(x)   (p && p->cons && p->cons->context && p->cons->context->pal.x) ? p->cons->context->pal.x
#define	BD(a, b)   getbytediff(p, fmt, (a)[i + j], (b)[i + j])
#define	CD(a, b)   getchardiff(p, fmt, (a)[i + j], (b)[i + j])
#define	INC   5

Functions
static int	nullprinter (const char *a,...)
static int	libc_printf (const char *format,...)
static int	libc_eprintf (const char *format,...)
RZ_API bool	rz_print_is_interrupted (void)
RZ_API void	rz_print_set_is_interrupted_cb (RzPrintIsInterruptedCallback cb)
RZ_API RzPrint *	rz_print_new (void)
RZ_API RzPrint *	rz_print_free (RzPrint *p)
RZ_API void	rz_print_set_flags (RzPrint *p, int _flags)
RZ_API void	rz_print_set_cursor (RzPrint *p, int enable, int ocursor, int cursor)
RZ_API bool	rz_print_have_cursor (RzPrint *p, int cur, int len)
RZ_API bool	rz_print_cursor_pointer (RzPrint *p, int cur, int len)
RZ_API void	rz_print_cursor (RzPrint *p, int cur, int len, int set)
RZ_API char *	rz_print_hexpair (RzPrint *p, const char *str, int n)
RZ_API const char *	rz_print_byte_color (RzPrint *p, int ch)
static bool	checkSparse (const ut8 *p, int len, int ch)
static bool	isAllZeros (const ut8 *buf, int len)
RZ_API void	rz_print_hexii (RzPrint *rp, ut64 addr, const ut8 *buf, int len, int step)
RZ_API void	rz_print_set_screenbounds (RzPrint *p, ut64 addr)
	Sets screen_bounds member of p to addr if the cursor is not visible on the screen. More...
static void	print_addr (RzStrBuf *sb, RzPrint *p, ut64 addr)
RZ_API void	rz_print_addr (RzPrint *p, ut64 addr)
static void	print_section (RzStrBuf *sb, RzPrint *p, ut64 at)
RZ_API char *	rz_print_section_str (RzPrint *p, ut64 at)
static void	print_cursor_l (RzStrBuf *sb, RzPrint *p, int cur, int len)
static void	print_cursor_r (RzStrBuf *sb, RzPrint *p, int cur, int len)
static void	print_byte (RzStrBuf *sb, RzPrint *p, const char *fmt, int idx, ut8 ch)
RZ_API void	rz_print_byte (RzPrint *p, const char *fmt, int idx, ut8 ch)
RZ_API RZ_OWN char *	rz_print_hexdump_str (RZ_NONNULL RzPrint *p, ut64 addr, RZ_NONNULL const ut8 *buf, int len, int base, int step, size_t zoomsz)
	Prints a hexdump of buf at addr. More...
static const char *	getbytediff (RzPrint *p, char *fmt, ut8 a, ut8 b)
static const char *	getchardiff (RzPrint *p, char *fmt, ut8 a, ut8 b)
static ut8 *	M (const ut8 *b, int len)
RZ_API RZ_OWN char *	rz_print_hexdiff_str (RZ_NONNULL RzPrint *p, ut64 aa, RZ_NONNULL const ut8 *_a, ut64 ba, RZ_NONNULL const ut8 *_b, int len, int scndcol)
	Print hexdump diff between _a and _b. More...
RZ_API void	rz_print_bytes (RzPrint *p, const ut8 *buf, int len, const char *fmt)
RZ_API void	rz_print_raw (RzPrint *p, ut64 addr, const ut8 *buf, int len)
RZ_API void	rz_print_progressbar (RzPrint *p, int pc, int _cols)
RZ_API void	rz_print_rangebar (RzPrint *p, ut64 startA, ut64 endA, ut64 min, ut64 max, int cols)
static void	printHistBlock (RzPrint *p, int k, int cols)
RZ_API void	rz_print_fill (RzPrint *p, const ut8 *arr, int size, ut64 addr, int step)
RZ_API const char *	rz_print_color_op_type (RZ_NONNULL RzPrint *p, ut32 analysis_type)
RZ_API void	rz_print_init_rowoffsets (RzPrint *p)
RZ_API void	rz_print_set_rowoff (RzPrint *p, int i, ut32 offset, bool overwrite)
RZ_API ut32	rz_print_rowoff (RzPrint *p, int i)
RZ_API int	rz_print_row_at_off (RzPrint *p, ut32 offset)
RZ_API int	rz_print_get_cursor (RzPrint *p)
RZ_API RZ_OWN char *	rz_print_jsondump_str (RZ_NONNULL RzPrint *p, RZ_NONNULL const ut8 *buf, int len, int wordsize)
	Print dump in json format. More...
RZ_API RZ_OWN RzStrBuf *	rz_print_colorize_asm_str (RZ_BORROW RzPrint *p, const RzAsmTokenString *toks)
	Colorizes a tokenized asm string. More...

Variables
static const char	hex [16] = "0123456789ABCDEF"
static RzPrintIsInterruptedCallback	is_interrupted_cb = NULL
static char	colorbuffer [64]
static RzPrint	staticp

Macro Definition Documentation

BD

#define BD	(		a,
			b
	)		getbytediff(p, fmt, (a)[i + j], (b)[i + j])

Definition at line 1148 of file print.c.

CD

#define CD	(		a,
			b
	)		getchardiff(p, fmt, (a)[i + j], (b)[i + j])

Definition at line 1149 of file print.c.

DFLT_ROWS

#define DFLT_ROWS   16

Definition at line 19 of file print.c.

INC

#define INC   5

memcat

#define memcat	(		x,
			y
	)

Value:

    { \
        memcpy(x, y, strlen(y)); \
        (x) += strlen(y); \
    }

P [1/2]

#define P

(

x

)

(p->cons && p->cons->context->pal.x) ? p->cons->context->pal.x

Definition at line 268 of file print.c.

P [2/2]

#define P

(

x

)

(p->cons && p->cons->context->pal.x) ? p->cons->context->pal.x

Definition at line 268 of file print.c.

Pal

#define Pal	(		x,
			y
	)		(x->cons && x->cons->context->pal.y) ? x->cons->context->pal.y

Definition at line 317 of file print.c.

PREOFF

#define PREOFF

(

x

)

(p && p->cons && p->cons->context && p->cons->context->pal.x) ? p->cons->context->pal.x

Function Documentation

checkSparse()

static bool checkSparse ( const ut8 *  p, int  len, int  ch  )

static

Definition at line 293 of file print.c.

                                                       {
    int i;
    ut8 q = *p;
    if (ch && ch != q) {
        return false;
    }
    for (i = 1; i < len; i++) {
        if (p[i] != q) {
            return false;
        }
    }
    return true;
}

References i, len, and p.

Referenced by rz_print_hexdump_str().

getbytediff()

static const char* getbytediff ( RzPrint *  p, char *  fmt, ut8  a, ut8  b  )

static

Definition at line 1120 of file print.c.

                                                                    {
    if (*fmt) {
        if (a == b) {
            sprintf(fmt, "%s%02x" Color_RESET, p->cons->context->pal.graph_true, a);
        } else {
            sprintf(fmt, "%s%02x" Color_RESET, p->cons->context->pal.graph_false, a);
        }
    } else {
        sprintf(fmt, "%02x", a);
    }
    return fmt;
}

References a, b, Color_RESET, p, and sprintf.

getchardiff()

static const char* getchardiff ( RzPrint *  p, char *  fmt, ut8  a, ut8  b  )

static

Definition at line 1133 of file print.c.

                                                                    {
    char ch = IS_PRINTABLE(a) ? a : '.';
    if (*fmt) {
        if (a == b) {
            sprintf(fmt, "%s%c" Color_RESET, p->cons->context->pal.graph_true, ch);
        } else {
            sprintf(fmt, "%s%c" Color_RESET, p->cons->context->pal.graph_false, ch);
        }
    } else {
        sprintf(fmt, "%c", ch);
    }
    // else { fmt[0] = ch; fmt[1]=0; }
    return fmt;
}

References a, b, Color_RESET, IS_PRINTABLE, p, and sprintf.

isAllZeros()

static bool isAllZeros ( const ut8 *  buf, int  len  )

static

Definition at line 307 of file print.c.

                                                {
    int i;
    for (i = 0; i < len; i++) {
        if (buf[i] != 0) {
            return false;
        }
    }
    return true;
}

References i, and len.

Referenced by rz_print_hexii().

libc_eprintf()

static int libc_eprintf ( const char *  format,   ...  )

static

Definition at line 35 of file print.c.

                                                 {
    va_list ap;
    va_start(ap, format);
    vfprintf(stderr, format, ap);
    va_end(ap);
    return 0;
}

Referenced by rz_print_new().

libc_printf()

static int libc_printf ( const char *  format,   ...  )

static

Definition at line 27 of file print.c.

                                                {
    va_list ap;
    va_start(ap, format);
    vprintf(format, ap);
    va_end(ap);
    return 0;
}

Referenced by rz_print_new().

M()

static ut8* M ( const ut8 *  b, int  len  )

static

Definition at line 1151 of file print.c.

                                     {
    ut8 *r = malloc(len + 16);
    if (r) {
        memset(r, 0xff, len + 16);
        memcpy(r, b, len);
    }
    return r;
}

References b, len, malloc(), memcpy(), memset(), and r.

Referenced by rz_print_hexdiff_str().

nullprinter()

static int nullprinter ( const char *  a,   ...  )

static

Definition at line 23 of file print.c.

                                           {
    return 0;
}

Referenced by rz_print_new().

print_addr()

static void print_addr ( RzStrBuf *  sb, RzPrint *  p, ut64  addr  )

inlinestatic

Definition at line 403 of file print.c.

                                                                   {
    char space[32] = {
        0
    };
    const char *white = "";
#define PREOFF(x) (p && p->cons && p->cons->context && p->cons->context->pal.x) ? p->cons->context->pal.x
    bool use_segoff = p ? (p->flags & RZ_PRINT_FLAGS_SEGOFF) : false;
    bool use_color = p ? (p->flags & RZ_PRINT_FLAGS_COLOR) : false;
    bool dec = p ? (p->flags & RZ_PRINT_FLAGS_ADDRDEC) : false;
    bool mod = p ? (p->flags & RZ_PRINT_FLAGS_ADDRMOD) : false;
    char ch = p ? ((p->addrmod && mod) ? ((addr % p->addrmod) ? ' ' : ',') : ' ') : ' ';
    if (p && p->flags & RZ_PRINT_FLAGS_COMPACT && p->col == 1) {
        ch = '|';
    }
    if (p && p->pava) {
        ut64 va = p->iob.p2v(p->iob.io, addr);
        if (va != UT64_MAX) {
            addr = va;
        }
    }
    if (use_segoff) {
        ut32 s, a;
        a = addr & 0xffff;
        s = (addr - a) >> (p ? p->seggrn : 0);
        if (dec) {
            snprintf(space, sizeof(space), "%d:%d", s & 0xffff, a & 0xffff);
            white = rz_str_pad(' ', 9 - strlen(space));
        }
        if (use_color) {
            const char *pre = PREOFF(offset)
                : Color_GREEN;
            const char *fin = Color_RESET;
            if (dec) {
                rz_strbuf_appendf(sb, "%s%s%s%s%c", pre, white, space, fin, ch);
            } else {
                rz_strbuf_appendf(sb, "%s%04x:%04x%s%c", pre, s & 0xffff, a & 0xffff, fin, ch);
            }
        } else {
            if (dec) {
                rz_strbuf_appendf(sb, "%s%s%c", white, space, ch);
            } else {
                rz_strbuf_appendf(sb, "%04x:%04x%c", s & 0xffff, a & 0xffff, ch);
            }
        }
    } else {
        if (dec) {
            snprintf(space, sizeof(space), "%" PFMT64d, addr);
            int w = RZ_MAX(10 - strlen(space), 0);
            white = rz_str_pad(' ', w);
        }
        if (use_color) {
            const char *pre = PREOFF(offset)
                : Color_GREEN;
            const char *fin = Color_RESET;
            if (p && p->flags & RZ_PRINT_FLAGS_RAINBOW) {
                // pre = rz_cons_rgb_str_off (rgbstr, addr);
                if (p->cons && p->cons->rgbstr) {
                    static char rgbstr[32];
                    pre = p->cons->rgbstr(rgbstr, sizeof(rgbstr), addr);
                }
            }
            if (dec) {
                rz_strbuf_appendf(sb, "%s%s%" PFMT64d "%s%c", pre, white, addr, fin, ch);
            } else {
                if (p && p->wide_offsets) {
                    // TODO: make %016 depend on asm.bits
                    rz_strbuf_appendf(sb, "%s0x%016" PFMT64x "%s%c", pre, addr, fin, ch);
                } else {
                    rz_strbuf_appendf(sb, "%s0x%08" PFMT64x "%s%c", pre, addr, fin, ch);
                }
            }
        } else {
            if (dec) {
                rz_strbuf_appendf(sb, "%s%" PFMT64d "%c", white, addr, ch);
            } else {
                if (p && p->wide_offsets) {
                    // TODO: make %016 depend on asm.bits
                    rz_strbuf_appendf(sb, "0x%016" PFMT64x "%c", addr, ch);
                } else {
                    rz_strbuf_appendf(sb, "0x%08" PFMT64x "%c", addr, ch);
                }
            }
        }
    }
}

References a, addr, Color_GREEN, Color_RESET, mod(), p, PFMT64d, PFMT64x, PREOFF, RZ_MAX, RZ_PRINT_FLAGS_ADDRDEC, RZ_PRINT_FLAGS_ADDRMOD, RZ_PRINT_FLAGS_COLOR, RZ_PRINT_FLAGS_COMPACT, RZ_PRINT_FLAGS_RAINBOW, RZ_PRINT_FLAGS_SEGOFF, rz_str_pad(), rz_strbuf_appendf(), s, sb, snprintf, ut64(), UT64_MAX, and w.

Referenced by rz_print_addr(), and rz_print_hexdump_str().

print_byte()

static void print_byte ( RzStrBuf *  sb, RzPrint *  p, const char *  fmt, int  idx, ut8  ch  )

inlinestatic

Definition at line 531 of file print.c.

                                                                                          {
    ut8 rch = ch;
    if (!IS_PRINTABLE(ch) && fmt[0] == '%' && fmt[1] == 'c') {
        rch = '.';
    }
    print_cursor_l(sb, p, idx, 1);
    if (p && p->flags & RZ_PRINT_FLAGS_COLOR) {
        const char *bytecolor = rz_print_byte_color(p, ch);
        if (bytecolor) {
            rz_strbuf_append(sb, bytecolor);
        }
        rz_strbuf_appendf(sb, fmt, rch);
        if (bytecolor) {
            rz_strbuf_append(sb, Color_RESET);
        }
    } else {
        rz_strbuf_appendf(sb, fmt, rch);
    }
    print_cursor_r(sb, p, idx, 1);
}

References Color_RESET, setup::idx, IS_PRINTABLE, p, print_cursor_l(), print_cursor_r(), rz_print_byte_color(), RZ_PRINT_FLAGS_COLOR, rz_strbuf_append(), rz_strbuf_appendf(), and sb.

Referenced by rz_print_byte(), and rz_print_hexdump_str().

print_cursor_l()

static void print_cursor_l ( RzStrBuf *  sb, RzPrint *  p, int  cur, int  len  )

inlinestatic

Definition at line 519 of file print.c.

                                                                              {
    if (rz_print_have_cursor(p, cur, len)) {
        rz_strbuf_append(sb, RZ_CONS_INVERT(1, 1));
    }
}

References len, p, rz_print_have_cursor(), rz_strbuf_append(), and sb.

Referenced by print_byte(), rz_print_hexdiff_str(), and rz_print_hexdump_str().

print_cursor_r()

static void print_cursor_r ( RzStrBuf *  sb, RzPrint *  p, int  cur, int  len  )

inlinestatic

Definition at line 525 of file print.c.

                                                                              {
    if (rz_print_have_cursor(p, cur, len)) {
        rz_strbuf_append(sb, RZ_CONS_INVERT(0, 1));
    }
}

References len, p, rz_print_have_cursor(), rz_strbuf_append(), and sb.

Referenced by print_byte(), rz_print_hexdiff_str(), and rz_print_hexdump_str().

print_section()

static void print_section ( RzStrBuf *  sb, RzPrint *  p, ut64  at  )

inlinestatic

Definition at line 499 of file print.c.

                                                                    {
    bool use_section = p && p->flags & RZ_PRINT_FLAGS_SECTION;
    if (!use_section) {
        return;
    }
    const char *s = p->get_section_name(p->user, at);
    if (!s) {
        s = "";
    }
    rz_strbuf_appendf(sb, "%20s ", s);
}

References p, RZ_PRINT_FLAGS_SECTION, rz_strbuf_appendf(), s, and sb.

Referenced by rz_print_hexdump_str(), and rz_print_section_str().

printHistBlock()

static void printHistBlock ( RzPrint *  p, int  k, int  cols  )

inlinestatic

Definition at line 1313 of file print.c.

                                                               {
    RzConsPrintablePalette *pal = &p->cons->context->pal;
    const char *h_line = p->cons->use_utf8 ? RUNE_LONG_LINE_HORIZ : "-";
    const char *block = p->cons->use_utf8 ? UTF_BLOCK : "#";
    const char *kol[5];
    kol[0] = pal->nop;
    kol[1] = pal->mov;
    kol[2] = pal->cjmp;
    kol[3] = pal->jmp;
    kol[4] = pal->call;
    if (cols < 1) {
        cols = 1;
    }
    const bool show_colors = (p && (p->flags & RZ_PRINT_FLAGS_COLOR));
    if (show_colors) {
        int idx = (int)((k * 4) / cols);
        if (idx < 5) {
            const char *str = kol[idx];
            if (p->histblock) {
                p->cb_printf("%s%s%s", str, block, Color_RESET);
            } else {
                p->cb_printf("%s%s%s", str, h_line, Color_RESET);
            }
        }
    } else {
        if (p->histblock) {
            p->cb_printf("%s", block);
        } else {
            p->cb_printf("%s", h_line);
        }
    }
}

References rz_cons_printable_palette_t::call, rz_cons_printable_palette_t::cjmp, Color_RESET, setup::idx, int, rz_cons_printable_palette_t::jmp, k, rz_cons_printable_palette_t::mov, rz_cons_printable_palette_t::nop, p, RUNE_LONG_LINE_HORIZ, RZ_PRINT_FLAGS_COLOR, cmd_descs_generate::str, and UTF_BLOCK.

Referenced by rz_print_fill().

rz_print_addr()

RZ_API void rz_print_addr	(	RzPrint *	p,
		ut64	addr
	)

Definition at line 489 of file print.c.

                                                 {
    rz_return_if_fail(p);
    RzStrBuf sb;
    rz_strbuf_init(&sb);
    print_addr(&sb, p, addr);
    char *s = rz_strbuf_drain_nofree(&sb);
    p->cb_printf("%s", s);
    free(s);
}

References addr, free(), p, print_addr(), rz_return_if_fail, rz_strbuf_drain_nofree(), rz_strbuf_init(), s, and sb.

Referenced by cmd_prc(), and rz_print_hexdump_emoji_handler().

rz_print_byte()

RZ_API void rz_print_byte	(	RzPrint *	p,
		const char *	fmt,
		int	idx,
		ut8	ch
	)

Definition at line 552 of file print.c.

                                                                        {
    rz_return_if_fail(p && fmt);
    RzStrBuf sb;
    rz_strbuf_init(&sb);
    print_byte(&sb, p, fmt, idx, ch);
    char *s = rz_strbuf_drain_nofree(&sb);
    p->cb_printf("%s", s);
    free(s);
}

References free(), setup::idx, p, print_byte(), rz_return_if_fail, rz_strbuf_drain_nofree(), rz_strbuf_init(), s, and sb.

Referenced by rz_print_hexdump_emoji_handler().

rz_print_byte_color()

RZ_API const char* rz_print_byte_color	(	RzPrint *	p,
		int	ch
	)

Definition at line 269 of file print.c.

                                                           {
    if (p->flags & RZ_PRINT_FLAGS_RAINBOW) {
        // EXPERIMENTAL
        int bg = (p->flags & RZ_PRINT_FLAGS_NONHEX) ? 48 : 38;
        snprintf(colorbuffer, sizeof(colorbuffer), "\033[%d;5;%dm", bg, ch);
        return colorbuffer;
    }
    const bool use_color = p->flags & RZ_PRINT_FLAGS_COLOR;
    if (!use_color) {
        return NULL;
    }
    switch (ch) {
    case 0x00: return P(b0x00)
        : Color_GREEN;
    case 0x7F: return P(b0x7f)
        : Color_YELLOW;
    case 0xFF: return P(b0xff)
        : Color_RED;
    default: return IS_PRINTABLE(ch) ? P(btext) : Color_MAGENTA : P(other)
        : Color_WHITE;
    }
    return NULL;
}

References Color_GREEN, Color_MAGENTA, Color_RED, Color_WHITE, Color_YELLOW, colorbuffer, IS_PRINTABLE, NULL, P, p, RZ_PRINT_FLAGS_COLOR, RZ_PRINT_FLAGS_NONHEX, RZ_PRINT_FLAGS_RAINBOW, and snprintf.

Referenced by annotated_hexdump(), and print_byte().

rz_print_bytes()

RZ_API void rz_print_bytes	(	RzPrint *	p,
		const ut8 *	buf,
		int	len,
		const char *	fmt
	)

Definition at line 1233 of file print.c.

                                                                                 {
    rz_return_if_fail(fmt);
    int i;
    if (p) {
        for (i = 0; i < len; i++) {
            p->cb_printf(fmt, buf[i]);
        }
        p->cb_printf("\n");
    } else {
        for (i = 0; i < len; i++) {
            printf(fmt, buf[i]);
        }
        printf("\n");
    }
}

References i, len, p, printf(), and rz_return_if_fail.

Referenced by rz_cmd_print(), and rz_print_hexdump_hexpair_bytes_handler().

rz_print_color_op_type()

RZ_API const char* rz_print_color_op_type	(	RZ_NONNULL RzPrint *	p,
		ut32	analysis_type
	)

Definition at line 1435 of file print.c.

                                                                                       {
    rz_return_val_if_fail(p, NULL);
    RzConsPrintablePalette *pal = &p->cons->context->pal;
    switch (analysis_type & RZ_ANALYSIS_OP_TYPE_MASK) {
    case RZ_ANALYSIS_OP_TYPE_NOP:
        return pal->nop;
    case RZ_ANALYSIS_OP_TYPE_ADD:
    case RZ_ANALYSIS_OP_TYPE_SUB:
    case RZ_ANALYSIS_OP_TYPE_MUL:
    case RZ_ANALYSIS_OP_TYPE_DIV:
    case RZ_ANALYSIS_OP_TYPE_MOD:
    case RZ_ANALYSIS_OP_TYPE_LENGTH:
        return pal->math;
    case RZ_ANALYSIS_OP_TYPE_AND:
    case RZ_ANALYSIS_OP_TYPE_OR:
    case RZ_ANALYSIS_OP_TYPE_XOR:
    case RZ_ANALYSIS_OP_TYPE_NOT:
    case RZ_ANALYSIS_OP_TYPE_SHL:
    case RZ_ANALYSIS_OP_TYPE_SAL:
    case RZ_ANALYSIS_OP_TYPE_SAR:
    case RZ_ANALYSIS_OP_TYPE_SHR:
    case RZ_ANALYSIS_OP_TYPE_ROL:
    case RZ_ANALYSIS_OP_TYPE_ROR:
    case RZ_ANALYSIS_OP_TYPE_CPL:
        return pal->bin;
    case RZ_ANALYSIS_OP_TYPE_IO:
        return pal->swi;
    case RZ_ANALYSIS_OP_TYPE_JMP:
    case RZ_ANALYSIS_OP_TYPE_UJMP:
        return pal->ujmp;
    case RZ_ANALYSIS_OP_TYPE_IJMP:
    case RZ_ANALYSIS_OP_TYPE_RJMP:
    case RZ_ANALYSIS_OP_TYPE_IRJMP:
    case RZ_ANALYSIS_OP_TYPE_MJMP:
        return pal->jmp;
    case RZ_ANALYSIS_OP_TYPE_CJMP:
    case RZ_ANALYSIS_OP_TYPE_UCJMP:
    case RZ_ANALYSIS_OP_TYPE_SWITCH:
        return pal->cjmp;
    case RZ_ANALYSIS_OP_TYPE_CMP:
    case RZ_ANALYSIS_OP_TYPE_ACMP:
        return pal->cmp;
    case RZ_ANALYSIS_OP_TYPE_UCALL:
        return pal->ucall;
    case RZ_ANALYSIS_OP_TYPE_ICALL:
    case RZ_ANALYSIS_OP_TYPE_RCALL:
    case RZ_ANALYSIS_OP_TYPE_IRCALL:
    case RZ_ANALYSIS_OP_TYPE_UCCALL:
    case RZ_ANALYSIS_OP_TYPE_CALL:
    case RZ_ANALYSIS_OP_TYPE_CCALL:
        return pal->call;
    case RZ_ANALYSIS_OP_TYPE_NEW:
    case RZ_ANALYSIS_OP_TYPE_SWI:
        return pal->swi;
    case RZ_ANALYSIS_OP_TYPE_ILL:
    case RZ_ANALYSIS_OP_TYPE_TRAP:
        return pal->trap;
    case RZ_ANALYSIS_OP_TYPE_CRET:
    case RZ_ANALYSIS_OP_TYPE_RET:
        return pal->ret;
    case RZ_ANALYSIS_OP_TYPE_CAST:
    case RZ_ANALYSIS_OP_TYPE_MOV:
    case RZ_ANALYSIS_OP_TYPE_LEA:
    case RZ_ANALYSIS_OP_TYPE_CMOV: // TODO: add cmov cathegory?
        return pal->mov;
    case RZ_ANALYSIS_OP_TYPE_PUSH:
    case RZ_ANALYSIS_OP_TYPE_UPUSH:
    case RZ_ANALYSIS_OP_TYPE_RPUSH:
    case RZ_ANALYSIS_OP_TYPE_LOAD:
        return pal->push;
    case RZ_ANALYSIS_OP_TYPE_POP:
    case RZ_ANALYSIS_OP_TYPE_STORE:
        return pal->pop;
    case RZ_ANALYSIS_OP_TYPE_CRYPTO:
        return pal->crypto;
    case RZ_ANALYSIS_OP_TYPE_NULL:
        return pal->other;
    case RZ_ANALYSIS_OP_TYPE_UNK:
    default:
        return pal->invalid;
    }
}

References rz_cons_printable_palette_t::bin, rz_cons_printable_palette_t::call, rz_cons_printable_palette_t::cjmp, rz_cons_printable_palette_t::cmp, rz_cons_printable_palette_t::crypto, rz_cons_printable_palette_t::invalid, rz_cons_printable_palette_t::jmp, rz_cons_printable_palette_t::math, rz_cons_printable_palette_t::mov, rz_cons_printable_palette_t::nop, NULL, rz_cons_printable_palette_t::other, p, rz_cons_printable_palette_t::pop, rz_cons_printable_palette_t::push, rz_cons_printable_palette_t::ret, RZ_ANALYSIS_OP_TYPE_ACMP, RZ_ANALYSIS_OP_TYPE_ADD, RZ_ANALYSIS_OP_TYPE_AND, RZ_ANALYSIS_OP_TYPE_CALL, RZ_ANALYSIS_OP_TYPE_CAST, RZ_ANALYSIS_OP_TYPE_CCALL, RZ_ANALYSIS_OP_TYPE_CJMP, RZ_ANALYSIS_OP_TYPE_CMOV, RZ_ANALYSIS_OP_TYPE_CMP, RZ_ANALYSIS_OP_TYPE_CPL, RZ_ANALYSIS_OP_TYPE_CRET, RZ_ANALYSIS_OP_TYPE_CRYPTO, RZ_ANALYSIS_OP_TYPE_DIV, RZ_ANALYSIS_OP_TYPE_ICALL, RZ_ANALYSIS_OP_TYPE_IJMP, RZ_ANALYSIS_OP_TYPE_ILL, RZ_ANALYSIS_OP_TYPE_IO, RZ_ANALYSIS_OP_TYPE_IRCALL, RZ_ANALYSIS_OP_TYPE_IRJMP, RZ_ANALYSIS_OP_TYPE_JMP, RZ_ANALYSIS_OP_TYPE_LEA, RZ_ANALYSIS_OP_TYPE_LENGTH, RZ_ANALYSIS_OP_TYPE_LOAD, RZ_ANALYSIS_OP_TYPE_MASK, RZ_ANALYSIS_OP_TYPE_MJMP, RZ_ANALYSIS_OP_TYPE_MOD, RZ_ANALYSIS_OP_TYPE_MOV, RZ_ANALYSIS_OP_TYPE_MUL, RZ_ANALYSIS_OP_TYPE_NEW, RZ_ANALYSIS_OP_TYPE_NOP, RZ_ANALYSIS_OP_TYPE_NOT, RZ_ANALYSIS_OP_TYPE_NULL, RZ_ANALYSIS_OP_TYPE_OR, RZ_ANALYSIS_OP_TYPE_POP, RZ_ANALYSIS_OP_TYPE_PUSH, RZ_ANALYSIS_OP_TYPE_RCALL, RZ_ANALYSIS_OP_TYPE_RET, RZ_ANALYSIS_OP_TYPE_RJMP, RZ_ANALYSIS_OP_TYPE_ROL, RZ_ANALYSIS_OP_TYPE_ROR, RZ_ANALYSIS_OP_TYPE_RPUSH, RZ_ANALYSIS_OP_TYPE_SAL, RZ_ANALYSIS_OP_TYPE_SAR, RZ_ANALYSIS_OP_TYPE_SHL, RZ_ANALYSIS_OP_TYPE_SHR, RZ_ANALYSIS_OP_TYPE_STORE, RZ_ANALYSIS_OP_TYPE_SUB, RZ_ANALYSIS_OP_TYPE_SWI, RZ_ANALYSIS_OP_TYPE_SWITCH, RZ_ANALYSIS_OP_TYPE_TRAP, RZ_ANALYSIS_OP_TYPE_UCALL, RZ_ANALYSIS_OP_TYPE_UCCALL, RZ_ANALYSIS_OP_TYPE_UCJMP, RZ_ANALYSIS_OP_TYPE_UJMP, RZ_ANALYSIS_OP_TYPE_UNK, RZ_ANALYSIS_OP_TYPE_UPUSH, RZ_ANALYSIS_OP_TYPE_XOR, rz_return_val_if_fail, rz_cons_printable_palette_t::swi, rz_cons_printable_palette_t::trap, rz_cons_printable_palette_t::ucall, and rz_cons_printable_palette_t::ujmp.

Referenced by rz_print_colorize_asm_str().

rz_print_colorize_asm_str()

RZ_API RZ_OWN RzStrBuf* rz_print_colorize_asm_str	(	RZ_BORROW RzPrint *	p,
		const RzAsmTokenString *	toks
	)

Colorizes a tokenized asm string.

Parameters

p	The RzPrint struct. Used to retrieve the color palette.
toks	The tokenized asm string.
opt	Options for colorizing. E.g. reset background color, an address to highlight etc.

Returns

The colorized asm string.

Definition at line 1613 of file print.c.

                                                                                                      {
    rz_return_val_if_fail(p && toks, NULL);
    // Color palette.
    RzConsPrintablePalette palette = p->cons->context->pal;
    // Black white asm string.
    char *bw_str = rz_strbuf_get(toks->str);
    rz_return_val_if_fail(bw_str, NULL);
    char *reset = p->colorize_opts.reset_bg ? Color_RESET_NOBG : Color_RESET;
    // mnemonic color
    const char *mnem_col = rz_print_color_op_type(p, toks->op_type);
 
    RzStrBuf *out = rz_strbuf_new("");
    rz_return_val_if_fail(out, NULL);
 
    const char *color;
    RzAsmToken *tok;
    rz_vector_foreach(toks->tokens, tok) {
        switch (tok->type) {
        default:
            rz_strbuf_free(out);
            rz_warn_if_reached();
            return NULL;
        case RZ_ASM_TOKEN_UNKNOWN:
            color = palette.other;
            break;
        case RZ_ASM_TOKEN_MNEMONIC:
            color = mnem_col;
            break;
        case RZ_ASM_TOKEN_NUMBER:
            if (tok->val.number == p->colorize_opts.hl_addr && tok->val.number != 0) {
                color = palette.func_var_type;
            } else {
                color = palette.num;
            }
            break;
        case RZ_ASM_TOKEN_OPERATOR:
        case RZ_ASM_TOKEN_SEPARATOR:
            color = palette.other;
            break;
        case RZ_ASM_TOKEN_REGISTER:
            color = palette.reg;
            break;
        case RZ_ASM_TOKEN_META:
            color = palette.meta;
            break;
        }
 
        rz_strbuf_append(out, color);
        rz_strbuf_append_n(out, bw_str + tok->start, tok->len);
        rz_strbuf_append(out, reset);
    }
    rz_strbuf_append(out, "\0");
    return out;
}

References color, Color_RESET, Color_RESET_NOBG, rz_cons_printable_palette_t::func_var_type, RzAsmToken::len, rz_cons_printable_palette_t::meta, NULL, rz_cons_printable_palette_t::num, RzAsmToken::number, RzAsmTokenString::op_type, rz_cons_printable_palette_t::other, out, p, rz_cons_printable_palette_t::reg, RZ_ASM_TOKEN_META, RZ_ASM_TOKEN_MNEMONIC, RZ_ASM_TOKEN_NUMBER, RZ_ASM_TOKEN_OPERATOR, RZ_ASM_TOKEN_REGISTER, RZ_ASM_TOKEN_SEPARATOR, RZ_ASM_TOKEN_UNKNOWN, rz_print_color_op_type(), rz_return_val_if_fail, rz_strbuf_append(), rz_strbuf_append_n(), rz_strbuf_free(), rz_strbuf_get(), rz_strbuf_new(), rz_vector_foreach, rz_warn_if_reached, RzAsmToken::start, RzAsmTokenString::str, RzAsmTokenString::tokens, RzAsmToken::type, and RzAsmToken::val.

Referenced by rz_asm_colorize_asm_str().

rz_print_cursor()

RZ_API void rz_print_cursor	(	RzPrint *	p,
		int	cur,
		int	len,
		int	set
	)

Definition at line 166 of file print.c.

                                                                   {
    if (rz_print_have_cursor(p, cur, len)) {
        p->cb_printf("%s", RZ_CONS_INVERT(set, 1));
    }
}

References len, p, and rz_print_have_cursor().

Referenced by rz_print_hexdump_bits_handler().

rz_print_cursor_pointer()

RZ_API bool rz_print_cursor_pointer	(	RzPrint *	p,
		int	cur,
		int	len
	)

Definition at line 152 of file print.c.

                                                                  {
    rz_return_val_if_fail(p, false);
    if (!p->cur_enabled) {
        return false;
    }
    int to = p->cur;
    do {
        if (cur + len - 1 == to) {
            return true;
        }
    } while (--len);
    return false;
}

References len, p, rz_return_val_if_fail, and to.

Referenced by rz_print_hexdump_str().

rz_print_fill()

RZ_API void rz_print_fill	(	RzPrint *	p,
		const ut8 *	arr,
		int	size,
		ut64	addr,
		int	step
	)

Definition at line 1346 of file print.c.

                                                                                     {
    rz_return_if_fail(p && arr);
    const bool show_colors = (p && (p->flags & RZ_PRINT_FLAGS_COLOR));
    const bool show_offset = (p && (p->flags & RZ_PRINT_FLAGS_OFFSET));
    bool useUtf8 = p->cons->use_utf8;
    const char *v_line = useUtf8 ? RUNE_LINE_VERT : "|";
    int i = 0, j;
 
#define INC 5
#if TOPLINE
    if (arr[0] > 1) {
        p->cb_printf("         ");
        if (addr != UT64_MAX && step > 0) {
            p->cb_printf("           ");
        }
        if (arr[0] > 1) {
            for (i = 0; i < arr[0]; i += INC) {
                p->cb_printf(h_line);
            }
        }
        p->cb_printf("\n");
    }
#endif
    // get the max of columns
    int cols = 0;
    for (i = 0; i < size; i++) {
        cols = arr[i] > cols ? arr[i] : cols;
    }
    cols /= 5;
    for (i = 0; i < size; i++) {
        ut8 next = (i + 1 < size) ? arr[i + 1] : 0;
        int base = 0, k = 0;
        if (addr != UT64_MAX && step > 0) {
            ut64 at = addr + (i * step);
            if (show_offset) {
                if (p->cur_enabled) {
                    if (i == p->cur) {
                        p->cb_printf(Color_INVERT "> 0x%08" PFMT64x " " Color_RESET, at);
                        if (p->num) {
                            p->num->value = at;
                        }
                    } else {
                        p->cb_printf("  0x%08" PFMT64x " ", at);
                    }
                } else {
                    p->cb_printf("0x%08" PFMT64x " ", at);
                }
            }
            p->cb_printf("%03x %04x %s", i, arr[i], v_line);
        } else {
            p->cb_printf("%s", v_line);
        }
        if (next < INC) {
            base = 1;
        }
        if (next < arr[i]) {
            if (arr[i] > INC) {
                for (j = 0; j < next + base; j += INC) {
                    printHistBlock(p, k, cols);
                    k++;
                }
            }
            for (j = next + INC; j + base < arr[i]; j += INC) {
                printHistBlock(p, k, cols);
                k++;
            }
        } else {
            printHistBlock(p, k, cols);
            k++;
        }
        if (i + 1 == size) {
            for (j = arr[i] + INC + base; j + base < next; j += INC) {
                printHistBlock(p, k, cols);
                k++;
            }
        } else if (arr[i + 1] > arr[i]) {
            for (j = arr[i] + INC + base; j + base < next; j += INC) {
                printHistBlock(p, k, cols);
                k++;
            }
        }
        if (show_colors) {
            p->cb_printf("%s", Color_RESET);
        }
        p->cb_printf("\n");
    }
}

References addr, syscall_preprocessing::arr, Color_INVERT, Color_RESET, i, INC, k, p, PFMT64x, printHistBlock(), RUNE_LINE_VERT, RZ_PRINT_FLAGS_COLOR, RZ_PRINT_FLAGS_OFFSET, rz_return_if_fail, step(), useUtf8, ut64(), and UT64_MAX.

Referenced by cmd_print_bars(), and search_similar_pattern_in().

rz_print_free()

RZ_API RzPrint* rz_print_free

(

RzPrint *

p

)

Definition at line 101 of file print.c.

                                          {
    if (!p) {
        return NULL;
    }
    RZ_FREE(p->strconv_mode);
    if (p->zoom) {
        free(p->zoom->buf);
        free(p->zoom);
        p->zoom = NULL;
    }
    RZ_FREE(p->row_offsets);
    free(p);
    return NULL;
}

References free(), NULL, p, and RZ_FREE.

Referenced by gprobe_getinformation(), run_old_command(), and rz_core_fini().

rz_print_get_cursor()

RZ_API int rz_print_get_cursor

(

RzPrint *

p

)

Definition at line 1571 of file print.c.

                                           {
    return p->cur_enabled ? p->cur : 0;
}

References p.

Referenced by get_current_seek_state().

rz_print_have_cursor()

RZ_API bool rz_print_have_cursor	(	RzPrint *	p,
		int	cur,
		int	len
	)

Definition at line 133 of file print.c.

                                                               {
    if (!p || !p->cur_enabled) {
        return false;
    }
    if (p->ocur != -1) {
        int from = p->ocur;
        int to = p->cur;
        rz_num_minmax_swap_i(&from, &to);
        do {
            if (cur + len - 1 >= from && cur + len - 1 <= to) {
                return true;
            }
        } while (--len);
    } else if (p->cur >= cur && p->cur <= cur + len - 1) {
        return true;
    }
    return false;
}

References from, len, p, rz_num_minmax_swap_i(), and to.

Referenced by print_cursor_l(), print_cursor_r(), and rz_print_cursor().

rz_print_hexdiff_str()

RZ_API RZ_OWN char* rz_print_hexdiff_str	(	RZ_NONNULL RzPrint *	p,
		ut64	aa,
		RZ_NONNULL const ut8 *	_a,
		ut64	ba,
		RZ_NONNULL const ut8 *	_b,
		int	len,
		int	scndcol
	)

Print hexdump diff between _a and _b.

Parameters

p	RzPrint instance.
aa	Address of first buffer.
_a	First buffer.
ba	Address of second buffer.
_b	Second buffer.
len	Diff length.
scndcol	True If core->cons->columns > 123 ?

Returns

Hexdump diff string.

Definition at line 1172 of file print.c.

                                                             {
    rz_return_val_if_fail(p && _a && _b && len > 0, NULL);
    ut8 *a, *b;
    char linediff, fmt[64];
    int color = p->flags & RZ_PRINT_FLAGS_COLOR;
    int diffskip = p->flags & RZ_PRINT_FLAGS_DIFFOUT;
    int i, j, min;
    RzStrBuf *sb = rz_strbuf_new(NULL);
    if (!((a = M(_a, len)))) {
        return NULL;
    }
    if (!((b = M(_b, len)))) {
        free(a);
        return NULL;
    }
    for (i = 0; i < len; i += 16) {
        min = RZ_MIN(16, len - i);
        linediff = (memcmp(a + i, b + i, min)) ? '!' : '|';
        if (diffskip && linediff == '|') {
            continue;
        }
        rz_strbuf_appendf(sb, "0x%08" PFMT64x " ", aa + i);
        for (j = 0; j < min; j++) {
            *fmt = color;
            print_cursor_l(sb, p, i + j, 1);
            rz_strbuf_appendf(sb, "%s", BD(a, b));
            print_cursor_r(sb, p, i + j, 1);
        }
        rz_strbuf_append(sb, " ");
        for (j = 0; j < min; j++) {
            *fmt = color;
            print_cursor_l(sb, p, i + j, 1);
            rz_strbuf_appendf(sb, "%s", CD(a, b));
            print_cursor_r(sb, p, i + j, 1);
        }
        if (scndcol) {
            rz_strbuf_appendf(sb, " %c 0x%08" PFMT64x " ", linediff, ba + i);
            for (j = 0; j < min; j++) {
                *fmt = color;
                print_cursor_r(sb, p, i + j, 1);
                rz_strbuf_appendf(sb, "%s", BD(b, a));
                print_cursor_r(sb, p, i + j, 1);
            }
            rz_strbuf_append(sb, " ");
            for (j = 0; j < min; j++) {
                *fmt = color;
                print_cursor_r(sb, p, i + j, 1);
                rz_strbuf_appendf(sb, "%s", CD(b, a));
                print_cursor_r(sb, p, i + j, 1);
            }
            rz_strbuf_append(sb, "\n");
        } else {
            rz_strbuf_appendf(sb, " %c\n", linediff);
        }
    }
    free(a);
    free(b);
    return rz_strbuf_drain(sb);
}

References a, b, BD, CD, color, free(), i, len, M(), min, NULL, p, PFMT64x, print_cursor_l(), print_cursor_r(), RZ_MIN, RZ_PRINT_FLAGS_COLOR, RZ_PRINT_FLAGS_DIFFOUT, rz_return_val_if_fail, rz_strbuf_append(), rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_new(), and sb.

Referenced by rz_core_print_hexdiff(), and rz_core_print_hexdump_diff_str().

rz_print_hexdump_str()

RZ_API RZ_OWN char* rz_print_hexdump_str	(	RZ_NONNULL RzPrint *	p,
		ut64	addr,
		RZ_NONNULL const ut8 *	buf,
		int	len,
		int	base,
		int	step,
		size_t	zoomsz
	)

Prints a hexdump of buf at addr.

Parameters

p	RzPrint instance
addr	Address of the buffer
buf	Buffer to print
len	Print only this many bytes
base	Byte print format ? (-10,-1,8,10,16,32,64)
step	Word size ?
zoomsz	Zoom size ?

Returns

Hexdump string

Definition at line 573 of file print.c.

                                                {
    rz_return_val_if_fail(p && buf && len > 0, NULL);
    RzStrBuf *sb = rz_strbuf_new(NULL);
    if (!sb) {
        return NULL;
    }
    bool pairs = p->pairs;
    bool use_sparse = p->flags & RZ_PRINT_FLAGS_SPARSE;
    bool use_header = p->flags & RZ_PRINT_FLAGS_HEADER;
    bool use_hdroff = p->flags & RZ_PRINT_FLAGS_HDROFF;
    bool use_segoff = p->flags & RZ_PRINT_FLAGS_SEGOFF;
    bool use_align = p->flags & RZ_PRINT_FLAGS_ALIGN;
    bool use_offset = p->flags & RZ_PRINT_FLAGS_OFFSET;
    bool hex_style = p->flags & RZ_PRINT_FLAGS_STYLE;
    bool use_hexa = !(p->flags & RZ_PRINT_FLAGS_NONHEX);
    bool use_unalloc = p->flags & RZ_PRINT_FLAGS_UNALLOC;
    bool compact = p->flags & RZ_PRINT_FLAGS_COMPACT;
    int inc = p->cols; // row width
    int col = p->col; // selected column (0=none, 1=hex, 2=ascii)
    int stride = p->stride;
 
    size_t i, j;
    int sparse_char = 0;
    const char *bytefmt = "%02x";
    const char *pre = "";
    int last_sparse = 0;
    const char *a, *b;
 
    if (step < len) {
        len = len - (len % step);
    }
    if (!use_hexa) {
        inc *= 4;
    }
    if (step < 1) {
        step = 1;
    }
    if (inc < 1) {
        inc = 1;
    }
    if (zoomsz < 1) {
        zoomsz = 1;
    }
    switch (base) {
    case -10:
        bytefmt = "0x%08x ";
        pre = " ";
        if (inc < 4) {
            inc = 4;
        }
        break;
    case -1:
        bytefmt = "0x%08x ";
        pre = "  ";
        if (inc < 4) {
            inc = 4;
        }
        break;
    case 8:
        bytefmt = "%03o";
        pre = " ";
        break;
    case 10:
        bytefmt = "%3d";
        pre = " ";
        break;
    case 16:
        if (inc < 2) {
            inc = 2;
            use_header = false;
        }
        break;
    case 32:
        bytefmt = "0x%08x ";
        pre = " ";
        if (inc < 4) {
            inc = 4;
        }
        break;
    case 64:
        bytefmt = "0x%016x ";
        pre = " ";
        if (inc < 8) {
            inc = 8;
        }
        break;
    }
    const char *space = hex_style ? "." : " ";
    // TODO: Use base to change %03o and so on
    if (step == 1 && base < 0) {
        use_header = false;
    }
    if (use_header) {
        bool c = p->flags & RZ_PRINT_FLAGS_COLOR;
        if (c) {
            const char *color_title = Pal(p, offset)
                : Color_MAGENTA;
            rz_strbuf_append(sb, color_title);
        }
        if (base < 32) {
            { // XXX: use rz_print_addr_header
                int i, delta;
                char soff[32];
                if (hex_style) {
                    rz_strbuf_append(sb, "..offset..");
                } else {
                    rz_strbuf_append(sb, "- offset -");
                    if (p->wide_offsets) {
                        rz_strbuf_append(sb, "       ");
                    }
                }
                if (use_segoff) {
                    ut32 s, a;
                    a = addr & 0xffff;
                    s = ((addr - a) >> p->seggrn) & 0xffff;
                    snprintf(soff, sizeof(soff), "%04x:%04x ", s, a);
                    delta = strlen(soff) - 10;
                } else {
                    snprintf(soff, sizeof(soff), "0x%08" PFMT64x, addr);
                    delta = strlen(soff) - 9;
                }
                if (compact) {
                    delta--;
                }
                for (i = 0; i < delta; i++) {
                    rz_strbuf_append(sb, space);
                }
            }
            ut32 K = 0;
            ut32 k = 0;
            /* column after number, before hex data */
            rz_strbuf_append(sb, (col == 1) ? "|" : space);
            if (use_hdroff) {
                k = addr & 0xf;
                K = (addr >> 4) & 0xf;
            } else {
                k = 0; // TODO: ??? SURE??? config.seek & 0xF;
            }
            if (use_hexa) {
                /* extra padding for offsets > 8 digits */
                for (i = 0; i < inc; i++) {
                    rz_strbuf_append(sb, pre);
                    if (base < 0) {
                        if (i & 1) {
                            rz_strbuf_append(sb, space);
                        }
                    }
                    if (use_hdroff) {
                        if (pairs) {
                            rz_strbuf_appendf(sb, "%c%c",
                                hex[(((i + k) >> 4) + K) % 16],
                                hex[(i + k) % 16]);
                        } else {
                            rz_strbuf_appendf(sb, " %c", hex[(i + k) % 16]);
                        }
                    } else {
                        rz_strbuf_appendf(sb, " %c", hex[(i + k) % 16]);
                    }
                    if (i & 1 || !pairs) {
                        if (!compact) {
                            rz_strbuf_append(sb, col != 1 ? space : ((i + 1) < inc) ? space
                                                        : "|");
                        }
                    }
                }
            }
            /* ascii column */
            if (compact) {
                rz_strbuf_append(sb, col > 0 ? "|" : space);
            } else {
                rz_strbuf_append(sb, col == 2 ? "|" : space);
            }
            if (!(p->flags & RZ_PRINT_FLAGS_NONASCII)) {
                for (i = 0; i < inc; i++) {
                    rz_strbuf_appendf(sb, "%c", hex[(i + k) % 16]);
                }
            }
            if (col == 2) {
                rz_strbuf_append(sb, "|");
            }
            /* print comment header*/
            if (p->use_comments && !compact) {
                if (col != 2) {
                    rz_strbuf_append(sb, " ");
                }
                if (!hex_style) {
                    rz_strbuf_append(sb, " comment");
                }
            }
            rz_strbuf_append(sb, "\n");
        }
 
        if (c) {
            rz_strbuf_append(sb, Color_RESET);
        }
    }
 
    // is this necessary?
    rz_print_set_screenbounds(p, addr);
    int rowbytes;
    int rows = 0;
    int bytes = 0;
    bool printValue = true;
    bool oPrintValue = true;
    bool isPxr = p->flags & RZ_PRINT_FLAGS_REFS;
 
    for (i = j = 0; i < len; i += (stride ? stride : inc)) {
        if (p->cons && p->cons->context && p->cons->context->breaked) {
            break;
        }
        rowbytes = inc;
        if (use_align) {
            int sz = p->offsize ? p->offsize(p->user, addr + j) : -1;
            if (sz > 0) { // flags with size 0 dont work
                rowbytes = sz;
            }
        }
 
        if (use_sparse) {
            if (checkSparse(buf + i, inc, sparse_char)) {
                if (i + inc >= len || checkSparse(buf + i + inc, inc, sparse_char)) {
                    if (i + inc + inc >= len ||
                        checkSparse(buf + i + inc + inc, inc, sparse_char)) {
                        sparse_char = buf[j];
                        last_sparse++;
                        if (last_sparse == 2) {
                            rz_strbuf_append(sb, " ...\n");
                            continue;
                        }
                        if (last_sparse > 2) {
                            continue;
                        }
                    }
                }
            } else {
                last_sparse = 0;
            }
        }
        ut64 at = addr + (j * zoomsz);
        if (use_offset && (!isPxr || inc < 4)) {
            print_section(sb, p, at);
            print_addr(sb, p, at);
        }
        int row_have_cursor = -1;
        ut64 row_have_addr = UT64_MAX;
        if (use_hexa) {
            if (!compact && !isPxr) {
                rz_strbuf_append(sb, (col == 1) ? "|" : " ");
            }
            for (j = i; j < i + inc; j++) {
                if (j != i && use_align && rowbytes == inc) {
                    int sz = p->offsize ? p->offsize(p->user, addr + j) : -1;
                    if (sz >= 0) {
                        rowbytes = bytes;
                    }
                }
                if (row_have_cursor == -1) {
                    if (rz_print_cursor_pointer(p, j, 1)) {
                        row_have_cursor = j - i;
                        row_have_addr = addr + j;
                    }
                }
                if (!compact && ((j >= len) || bytes >= rowbytes)) {
                    if (col == 1) {
                        if (j + 1 >= inc + i) {
                            rz_strbuf_append(sb, j % 2 ? "  |" : "| ");
                        } else {
                            rz_strbuf_append(sb, j % 2 ? "   " : "  ");
                        }
                    } else {
                        if (base == 32) {
                            rz_strbuf_append(sb, (j % 4) ? "   " : "  ");
                        } else if (base == 10) {
                            rz_strbuf_append(sb, j % 2 ? "     " : "  ");
                        } else {
                            rz_strbuf_append(sb, j % 2 ? "   " : "  ");
                        }
                    }
                    continue;
                }
                const char *hl = (hex_style && p->offname(p->user, addr + j)) ? Color_INVERT : NULL;
                if (hl) {
                    rz_strbuf_append(sb, hl);
                }
                if ((base == 32 || base == 64)) {
                    int left = len - i;
                    /* TODO: check step. it should be 2/4 for base(32) and 8 for
                     *       base(64) */
                    ut64 n = 0;
                    size_t sz_n = (base == 64)
                        ? sizeof(ut64)
                        : (step == 2)
                        ? sizeof(ut16)
                        : sizeof(ut32);
                    sz_n = RZ_MIN(left, sz_n);
                    if (j + sz_n > len) {
                        // oob
                        j += sz_n;
                        continue;
                    }
                    rz_mem_swaporcopy((ut8 *)&n, buf + j, sz_n, p->big_endian);
                    print_cursor_l(sb, p, j, sz_n);
                    // stub for colors
                    if (p->colorfor) {
                        if (!p->iob.addr_is_mapped(p->iob.io, addr + j)) {
                            a = p->cons->context->pal.ai_unmap;
                        } else {
                            a = p->colorfor(p->user, n, true);
                        }
                        if (a && *a) {
                            b = Color_RESET;
                        } else {
                            a = b = "";
                        }
                    } else {
                        a = b = "";
                    }
                    printValue = true;
                    bool hasNull = false;
                    if (isPxr) {
                        if (n == 0) {
                            if (oPrintValue) {
                                hasNull = true;
                            }
                            printValue = false;
                        }
                    }
                    if (printValue) {
                        if (use_offset && !hasNull && isPxr) {
                            print_section(sb, p, at);
                            print_addr(sb, p, addr + j * zoomsz);
                        }
                        if (base == 64) {
                            rz_strbuf_appendf(sb, "%s0x%016" PFMT64x "%s  ", a, (ut64)n, b);
                        } else if (step == 2) {
                            rz_strbuf_appendf(sb, "%s0x%04x%s ", a, (ut16)n, b);
                        } else {
                            rz_strbuf_appendf(sb, "%s0x%08x%s ", a, (ut32)n, b);
                        }
                    } else {
                        if (hasNull) {
                            const char *n = p->offname(p->user, addr + j);
                            print_section(sb, p, at);
                            print_addr(sb, p, addr + j * zoomsz);
                            rz_strbuf_appendf(sb, "..[ null bytes ]..   00000000 %s\n", n ? n : "");
                        }
                    }
                    print_cursor_r(sb, p, j, sz_n);
                    oPrintValue = printValue;
                    j += step - 1;
                } else if (base == -8) {
                    long long w = rz_read_ble64(buf + j, p->big_endian);
                    print_cursor_l(sb, p, j, 8);
                    rz_strbuf_appendf(sb, "%23" PFMT64d " ", w);
                    print_cursor_r(sb, p, j, 8);
                    j += 7;
                } else if (base == -1) {
                    st8 w = rz_read_ble8(buf + j);
                    print_cursor_l(sb, p, j, 1);
                    rz_strbuf_appendf(sb, "%4d ", w);
                    print_cursor_r(sb, p, j, 1);
                } else if (base == -10) {
                    if (j + 1 < len) {
                        st16 w = rz_read_ble16(buf + j, p->big_endian);
                        print_cursor_l(sb, p, j, 2);
                        rz_strbuf_appendf(sb, "%7d ", w);
                        print_cursor_r(sb, p, j, 2);
                    }
                    j += 1;
                } else if (base == 10) { // "pxd"
                    if (j + 3 < len) {
                        int w = rz_read_ble32(buf + j, p->big_endian);
                        print_cursor_l(sb, p, j, 4);
                        rz_strbuf_appendf(sb, "%13d ", w);
                        print_cursor_r(sb, p, j, 4);
                    }
                    j += 3;
                } else {
                    if (j >= len) {
                        break;
                    }
                    if (use_unalloc && !p->iob.is_valid_offset(p->iob.io, addr + j, false)) {
                        char ch = p->io_unalloc_ch;
                        char dbl_ch_str[] = { ch, ch, 0 };
                        rz_strbuf_appendf(sb, "%s", dbl_ch_str);
                    } else {
                        print_byte(sb, p, bytefmt, j, buf[j]);
                    }
                    if (pairs && !compact && (inc & 1)) {
                        bool mustspace = (rows % 2) ? !(j & 1) : (j & 1);
                        if (mustspace) {
                            rz_strbuf_append(sb, " ");
                        }
                    } else if (bytes % 2 || !pairs) {
                        if (col == 1) {
                            if (j + 1 < inc + i) {
                                if (!compact) {
                                    rz_strbuf_append(sb, " ");
                                }
                            } else {
                                rz_strbuf_append(sb, "|");
                            }
                        } else {
                            if (!compact) {
                                rz_strbuf_append(sb, " ");
                            }
                        }
                    }
                }
                if (hl) {
                    rz_strbuf_append(sb, Color_RESET);
                }
                bytes++;
            }
        }
        if (printValue) {
            if (compact) {
                if (col == 0) {
                    rz_strbuf_append(sb, " ");
                } else if (col == 1) {
                    // print (" ");
                } else {
                    rz_strbuf_append(sb, (col == 2) ? "|" : "");
                }
            } else {
                rz_strbuf_append(sb, (col == 2) ? "|" : " ");
            }
            if (!p || !(p->flags & RZ_PRINT_FLAGS_NONASCII)) {
                bytes = 0;
                size_t end = i + inc;
                for (j = i; j < end; j++) {
                    if (j != i && use_align && bytes >= rowbytes) {
                        int sz = (p->offsize) ? p->offsize(p->user, addr + j) : -1;
                        if (sz >= 0) {
                            rz_strbuf_append(sb, " ");
                            break;
                        }
                    }
                    if (j >= len || (use_align && bytes >= rowbytes)) {
                        break;
                    }
                    ut8 ch = (use_unalloc && !p->iob.is_valid_offset(p->iob.io, addr + j, false))
                        ? ' '
                        : buf[j];
                    print_byte(sb, p, "%c", j, ch);
                    bytes++;
                }
            }
            /* ascii column */
            if (col == 2) {
                rz_strbuf_append(sb, "|");
            }
            bool eol = false;
            if (!eol && p->flags & RZ_PRINT_FLAGS_REFS) {
                ut64 off = UT64_MAX;
                if (inc == 8) {
                    if (i + sizeof(ut64) - 1 < len) {
                        off = rz_read_le64(buf + i);
                    }
                } else if (inc == 4) {
                    if (i + sizeof(ut32) - 1 < len) {
                        off = rz_read_le32(buf + i);
                    }
                } else if (inc == 2 && base == 16) {
                    if (i + sizeof(ut16) - 1 < len) {
                        off = rz_read_le16(buf + i);
                        if (off == 0) {
                            off = UT64_MAX;
                        }
                    }
                }
                if (p->hasrefs && off != UT64_MAX) {
                    char *rstr = p->hasrefs(p->user, addr + i, false);
                    if (rstr && *rstr) {
                        rz_strbuf_appendf(sb, " @ %s", rstr);
                    }
                    free(rstr);
                    rstr = p->hasrefs(p->user, off, true);
                    if (rstr && *rstr) {
                        rz_strbuf_appendf(sb, " %s", rstr);
                    }
                    free(rstr);
                }
            }
            if (!eol && p->use_comments) {
                for (; j < i + inc; j++) {
                    rz_strbuf_append(sb, " ");
                }
                for (j = i; j < i + inc; j++) {
                    if (use_align && (j - i) >= rowbytes) {
                        break;
                    }
                    if (p->offname) {
                        a = p->offname(p->user, addr + j);
                        if (p->colorfor && a && *a) {
                            const char *color = p->colorfor(p->user, addr + j, true);
                            rz_strbuf_appendf(sb, "%s  ; %s%s", color ? color : "", a,
                                color ? Color_RESET : "");
                        }
                    }
                    char *comment = p->get_comments(p->user, addr + j);
                    if (comment) {
                        if (p->colorfor) {
                            a = p->colorfor(p->user, addr + j, true);
                            if (!a || !*a) {
                                a = "";
                            }
                        } else {
                            a = "";
                        }
                        rz_strbuf_appendf(sb, "%s  ; %s", a, comment);
                        free(comment);
                    }
                }
            }
            if (use_align && rowbytes < inc && bytes >= rowbytes) {
                i -= (inc - bytes);
            }
            rz_strbuf_append(sb, "\n");
        }
        rows++;
        bytes = 0;
        if (p->cfmt && *p->cfmt) {
            if (row_have_cursor != -1) {
                int i = 0;
                rz_strbuf_append(sb, " _________");
                if (!compact) {
                    rz_strbuf_append(sb, "_");
                }
                for (i = 0; i < row_have_cursor; i++) {
                    if (!pairs || (!compact && i % 2)) {
                        rz_strbuf_append(sb, "___");
                    } else {
                        rz_strbuf_append(sb, "__");
                    }
                }
                rz_strbuf_append(sb, "__|\n");
                rz_strbuf_appendf(sb, "| cmd.hexcursor = %s\n", p->cfmt);
                p->coreb.cmdf(p->coreb.core,
                    "%s @ 0x%08" PFMT64x, p->cfmt, row_have_addr);
            }
        }
    }
    return rz_strbuf_drain(sb);
}

References a, addr, b, bytes, c, checkSparse(), color, Color_INVERT, Color_MAGENTA, Color_RESET, delta, test_evm::end, free(), hex, i, k, len, n, NULL, off, p, Pal, PFMT64d, PFMT64x, print_addr(), print_byte(), print_cursor_l(), print_cursor_r(), print_section(), rz_mem_swaporcopy(), RZ_MIN, rz_print_cursor_pointer(), RZ_PRINT_FLAGS_ALIGN, RZ_PRINT_FLAGS_COLOR, RZ_PRINT_FLAGS_COMPACT, RZ_PRINT_FLAGS_HDROFF, RZ_PRINT_FLAGS_HEADER, RZ_PRINT_FLAGS_NONASCII, RZ_PRINT_FLAGS_NONHEX, RZ_PRINT_FLAGS_OFFSET, RZ_PRINT_FLAGS_REFS, RZ_PRINT_FLAGS_SEGOFF, RZ_PRINT_FLAGS_SPARSE, RZ_PRINT_FLAGS_STYLE, RZ_PRINT_FLAGS_UNALLOC, rz_print_set_screenbounds(), rz_read_ble16(), rz_read_ble32(), rz_read_ble64(), rz_read_ble8(), rz_read_le16(), rz_read_le32(), rz_read_le64(), rz_return_val_if_fail, rz_strbuf_append(), rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_new(), s, sb, snprintf, st16, st8, step(), ut64(), UT64_MAX, and w.

Referenced by cmd_pxr(), gprobe_getinformation(), hit(), run_old_command(), rz_core_print_dump_str(), rz_core_print_hexdump(), and rz_core_print_hexdump_or_hexdiff_str().

rz_print_hexii()

RZ_API void rz_print_hexii	(	RzPrint *	rp,
		ut64	addr,
		const ut8 *	buf,
		int	len,
		int	step
	)

Definition at line 318 of file print.c.

                                                                                      {
    PrintfCallback p = (PrintfCallback)rp->cb_printf;
    bool c = rp->flags & RZ_PRINT_FLAGS_COLOR;
    const char *color_0xff = c ? (Pal(rp, b0xff)
                         : Color_RED)
                   : "";
    const char *color_text = c ? (Pal(rp, btext)
                         : Color_MAGENTA)
                   : "";
    const char *color_other = c ? (Pal(rp, other)
                          : Color_WHITE)
                    : "";
    const char *color_reset = c ? Color_RESET : "";
    int i, j;
    bool show_offset = rp->show_offset;
 
    if (rp->flags & RZ_PRINT_FLAGS_HEADER) {
        p("         ");
        for (i = 0; i < step; i++) {
            p("%3X", i);
        }
        p("\n");
    }
 
    for (i = 0; i < len; i += step) {
        int inc = RZ_MIN(step, (len - i));
        if (isAllZeros(buf + i, inc)) {
            continue;
        }
        if (show_offset) {
            p("%8" PFMT64x ":", addr + i);
        }
        for (j = 0; j < inc; j++) {
            ut8 ch = buf[i + j];
            if (ch == 0x00) {
                p("   ");
            } else if (ch == 0xff) {
                p("%s ##%s", color_0xff, color_reset);
            } else if (IS_PRINTABLE(ch)) {
                p("%s .%c%s", color_text, ch, color_reset);
            } else {
                p("%s %02x%s", color_other, ch, color_reset);
            }
        }
        p("\n");
    }
    p("%8" PFMT64x " ]\n", addr + i);
}

References addr, c, Color_MAGENTA, Color_RED, Color_RESET, Color_WHITE, i, IS_PRINTABLE, isAllZeros(), len, p, Pal, PFMT64x, rp, RZ_MIN, RZ_PRINT_FLAGS_COLOR, RZ_PRINT_FLAGS_HEADER, and step().

Referenced by rz_print_hexdump_hexii_handler().

rz_print_hexpair()

RZ_API char* rz_print_hexpair	(	RzPrint *	p,
		const char *	str,
		int	n
	)

Definition at line 172 of file print.c.

                                                                  {
    const char *s, *lastcol = Color_WHITE;
    char *d, *dst = (char *)calloc((strlen(str) + 2), 32);
    int colors = p->flags & RZ_PRINT_FLAGS_COLOR;
    const char *color_0x00 = "";
    const char *color_0x7f = "";
    const char *color_0xff = "";
    const char *color_text = "";
    const char *color_other = "";
    int bs = p->bytespace;
    /* XXX That is hacky but it partially works */
    /* TODO: Use rz_print_set_cursor for win support */
    int cur = RZ_MIN(p->cur, p->ocur);
    int ocur = RZ_MAX(p->cur, p->ocur);
    int ch, i;
 
    if (colors) {
#define P(x) (p->cons && p->cons->context->pal.x) ? p->cons->context->pal.x
        color_0x00 = P(b0x00)
            : Color_GREEN;
        color_0x7f = P(b0x7f)
            : Color_YELLOW;
        color_0xff = P(b0xff)
            : Color_RED;
        color_text = P(btext)
            : Color_MAGENTA;
        color_other = P(other)
            : "";
    }
    if (p->cur_enabled && cur == -1) {
        cur = ocur;
    }
    ocur++;
    d = dst;
// XXX: overflow here
// TODO: Use rz_cons primitives here
#define memcat(x, y) \
    { \
        memcpy(x, y, strlen(y)); \
        (x) += strlen(y); \
    }
    for (s = str, i = 0; s[0]; i++) {
        int d_inc = 2;
        if (p->cur_enabled) {
            if (i == ocur - n) {
                memcat(d, Color_RESET);
            }
            if (colors) {
                memcat(d, lastcol);
            }
            if (i >= cur - n && i < ocur - n) {
                memcat(d, Color_INVERT);
            }
        }
        if (colors) {
            if (s[0] == '0' && s[1] == '0') {
                lastcol = color_0x00;
            } else if (s[0] == '7' && s[1] == 'f') {
                lastcol = color_0x7f;
            } else if (s[0] == 'f' && s[1] == 'f') {
                lastcol = color_0xff;
            } else {
                ch = rz_hex_pair2bin(s);
                if (ch == -1) {
                    break;
                }
                if (IS_PRINTABLE(ch)) {
                    lastcol = color_text;
                } else {
                    lastcol = color_other;
                }
            }
            memcat(d, lastcol);
        }
        if (s[0] == '.') {
            d_inc = 1;
        }
        memcpy(d, s, d_inc);
        d += d_inc;
        s += d_inc;
        if (bs) {
            memcat(d, " ");
        }
    }
    if (colors || p->cur_enabled) {
        if (p->resetbg) {
            memcat(d, Color_RESET);
        } else {
            memcat(d, Color_RESET_NOBG);
        }
    }
    *d = '\0';
    return dst;
}

References calloc(), Color_GREEN, Color_INVERT, Color_MAGENTA, Color_RED, Color_RESET, Color_RESET_NOBG, Color_WHITE, Color_YELLOW, colors, d, dst, i, IS_PRINTABLE, memcat, memcpy(), n, P, p, rz_hex_pair2bin(), RZ_MAX, RZ_MIN, RZ_PRINT_FLAGS_COLOR, s, and cmd_descs_generate::str.

Referenced by ds_print_show_bytes(), rz_core_visual_bit_editor(), and rz_core_visual_esil().

rz_print_init_rowoffsets()

RZ_API void rz_print_init_rowoffsets

(

RzPrint *

p

)

Definition at line 1519 of file print.c.

                                                 {
    if (p->calc_row_offsets) {
        RZ_FREE(p->row_offsets);
        p->row_offsets_sz = 0;
    }
}

References p, and RZ_FREE.

Referenced by rz_cmd_print(), and rz_core_print_dump_str().

rz_print_is_interrupted()

RZ_API bool rz_print_is_interrupted

(

void

)

Definition at line 45 of file print.c.

                                          {
    if (is_interrupted_cb) {
        return is_interrupted_cb();
    }
    return false;
}

References is_interrupted_cb.

Referenced by rz_search_pattern().

rz_print_jsondump_str()

RZ_API RZ_OWN char* rz_print_jsondump_str	(	RZ_NONNULL RzPrint *	p,
		RZ_NONNULL const ut8 *	buf,
		int	len,
		int	wordsize
	)

Print dump in json format.

Parameters

p	RzPrint instance
buf	Buffer to print to
len	Print only this many bytes
wordsize	Size of a word in bits

Returns

Dump JSON string

Definition at line 1583 of file print.c.

                                                                                                                   {
    rz_return_val_if_fail(p && buf && len > 0 && wordsize > 0, 0);
    int bytesize = wordsize / 8;
    if (bytesize < 1) {
        bytesize = 8;
    }
    PJ *j = pj_new();
    if (!j) {
        return NULL;
    }
    pj_a(j);
    for (int i = 0; i + bytesize < len; i += bytesize) {
        ut64 word = rz_read_ble(buf + i, p->big_endian, wordsize);
        pj_n(j, word);
    }
    pj_end(j);
    char *str = strdup(pj_string(j));
    pj_free(j);
    return str;
}

References i, len, NULL, p, pj_a(), pj_end(), pj_free(), pj_n(), pj_new(), pj_string(), rz_read_ble(), rz_return_val_if_fail, cmd_descs_generate::str, strdup(), and ut64().

Referenced by rz_core_print_dump_str(), rz_core_print_hexdump_or_hexdiff_str(), and rz_core_print_jsondump().

rz_print_new()

RZ_API RzPrint* rz_print_new

(

void

)

Definition at line 56 of file print.c.

                                   {
    RzPrint *p = RZ_NEW0(RzPrint);
    if (!p) {
        return NULL;
    }
    strcpy(p->datefmt, "%Y-%m-%d %H:%M:%S %z");
    rz_io_bind_init(p->iob);
    p->pairs = true;
    p->resetbg = true;
    p->cb_printf = libc_printf;
    p->cb_eprintf = libc_eprintf;
    p->oprintf = nullprinter;
    p->bits = 32;
    p->stride = 0;
    p->bytespace = 0;
    p->big_endian = false;
    p->datezone = 0;
    p->col = 0;
    p->width = 78;
    p->cols = 16;
    p->cur_enabled = false;
    p->cur = p->ocur = -1;
    p->addrmod = 4;
    p->flags =
        RZ_PRINT_FLAGS_COLOR |
        RZ_PRINT_FLAGS_OFFSET |
        RZ_PRINT_FLAGS_HEADER |
        RZ_PRINT_FLAGS_ADDRMOD;
    p->seggrn = 4;
    p->zoom = RZ_NEW0(RzPrintZoom);
    p->reg = NULL;
    p->get_register = NULL;
    p->get_register_value = NULL;
    p->calc_row_offsets = true;
    p->row_offsets_sz = 0;
    p->row_offsets = NULL;
    p->vflush = true;
    p->screen_bounds = 0;
    p->esc_bslash = false;
    p->strconv_mode = NULL;
    memset(&p->consbind, 0, sizeof(p->consbind));
    p->io_unalloc_ch = '.';
    return p;
}

References libc_eprintf(), libc_printf(), memset(), NULL, nullprinter(), p, rz_io_bind_init, RZ_NEW0, RZ_PRINT_FLAGS_ADDRMOD, RZ_PRINT_FLAGS_COLOR, RZ_PRINT_FLAGS_HEADER, and RZ_PRINT_FLAGS_OFFSET.

Referenced by gprobe_getinformation(), run_old_command(), rz_core_init(), and rz_main_rz_find().

rz_print_progressbar()

RZ_API void rz_print_progressbar	(	RzPrint *	p,
		int	pc,
		int	_cols
	)

Definition at line 1259 of file print.c.

                                                                {
    // TODO: add support for colors
    int i, cols = (_cols == -1) ? 78 : _cols;
    if (!p) {
        p = &staticp;
    }
    const char *h_line = p->cons->use_utf8 ? RUNE_LONG_LINE_HORIZ : "-";
    const char *block = p->cons->use_utf8 ? UTF_BLOCK : "#";
 
    pc = RZ_MAX(0, RZ_MIN(100, pc));
    if (p->flags & RZ_PRINT_FLAGS_HEADER) {
        p->cb_printf("%4d%% ", pc);
    }
    cols -= 15;
    p->cb_printf("[");
    for (i = cols * pc / 100; i; i--) {
        p->cb_printf("%s", block);
    }
    for (i = cols - (cols * pc / 100); i; i--) {
        p->cb_printf("%s", h_line);
    }
    p->cb_printf("]");
}

References i, p, pc, RUNE_LONG_LINE_HORIZ, RZ_MAX, RZ_MIN, RZ_PRINT_FLAGS_HEADER, staticp, and UTF_BLOCK.

Referenced by cmd_print_bars(), desc_list_visual_cb(), and rz_cmd_help().

rz_print_rangebar()

RZ_API void rz_print_rangebar	(	RzPrint *	p,
		ut64	startA,
		ut64	endA,
		ut64	min,
		ut64	max,
		int	cols
	)

Definition at line 1283 of file print.c.

                                                                                                {
    const char *h_line = p->cons->use_utf8 ? RUNE_LONG_LINE_HORIZ : "-";
    const char *block = p->cons->use_utf8 ? UTF_BLOCK : "#";
    const bool show_colors = p->flags & RZ_PRINT_FLAGS_COLOR;
    int j = 0;
    p->cb_printf("|");
    if (cols < 1) {
        cols = 1;
    }
    int mul = (max - min) / cols;
    bool isFirst = true;
    for (j = 0; j < cols; j++) {
        ut64 startB = min + (j * mul);
        ut64 endB = min + ((j + 1) * mul);
        if (startA <= endB && endA >= startB) {
            if (show_colors & isFirst) {
                p->cb_printf(Color_GREEN);
                isFirst = false;
            }
            p->cb_printf("%s", block);
        } else {
            if (!isFirst) {
                p->cb_printf(Color_RESET);
            }
            p->cb_printf("%s", h_line);
        }
    }
    p->cb_printf("|");
}

References Color_GREEN, Color_RESET, max, min, mul(), p, RUNE_LONG_LINE_HORIZ, RZ_PRINT_FLAGS_COLOR, ut64(), and UTF_BLOCK.

Referenced by flagbar_foreach().

rz_print_raw()

RZ_API void rz_print_raw	(	RzPrint *	p,
		ut64	addr,
		const ut8 *	buf,
		int	len
	)

Definition at line 1249 of file print.c.

                                                                         {
    p->write(buf, len);
}

References len, and p.

Referenced by printraw().

rz_print_row_at_off()

RZ_API int rz_print_row_at_off	(	RzPrint *	p,
		ut32	offset
	)

Definition at line 1562 of file print.c.

                                                        {
    int i = 0;
    ut32 tt;
    while ((tt = rz_print_rowoff(p, i)) != UT32_MAX && tt <= offset) {
        i++;
    }
    return tt != UT32_MAX ? i - 1 : -1;
}

References i, p, rz_print_rowoff(), and UT32_MAX.

Referenced by cursor_nextrow(), and cursor_prevrow().

rz_print_rowoff()

RZ_API ut32 rz_print_rowoff	(	RzPrint *	p,
		int	i
	)

Definition at line 1553 of file print.c.

                                               {
    if (i < 0 || i >= p->row_offsets_sz) {
        return UT32_MAX;
    }
    return p->row_offsets[i];
}

References i, p, and UT32_MAX.

Referenced by cursor_nextrow(), cursor_prevrow(), and rz_print_row_at_off().

rz_print_section_str()

RZ_API char* rz_print_section_str	(	RzPrint *	p,
		ut64	at
	)

Definition at line 511 of file print.c.

                                                       {
    rz_return_val_if_fail(p, NULL);
    RzStrBuf sb;
    rz_strbuf_init(&sb);
    print_section(&sb, p, at);
    return rz_strbuf_drain_nofree(&sb);
}

References NULL, p, print_section(), rz_return_val_if_fail, rz_strbuf_drain_nofree(), rz_strbuf_init(), and sb.

Referenced by rz_core_print_hexdump_byline_str(), and rz_print_hexdump_bits_handler().

rz_print_set_cursor()

RZ_API void rz_print_set_cursor	(	RzPrint *	p,
		int	enable,
		int	ocursor,
		int	cursor
	)

Definition at line 121 of file print.c.

                                                                                 {
    if (!p) {
        return;
    }
    p->cur_enabled = enable;
    p->ocur = ocursor;
    if (cursor < 0) {
        cursor = 0;
    }
    p->cur = cursor;
}

References p.

Referenced by visual_refresh().

rz_print_set_flags()

RZ_API void rz_print_set_flags	(	RzPrint *	p,
		int	_flags
	)

Definition at line 117 of file print.c.

                                                       {
    p->flags = _flags;
}

References p.

Referenced by cb_asmsubsec(), cb_color(), cb_decoff(), cb_scr_bgfill(), cb_scrrainbow(), rz_core_visual(), and setcursor().

rz_print_set_is_interrupted_cb()

RZ_API void rz_print_set_is_interrupted_cb

(

RzPrintIsInterruptedCallback

cb

)

Definition at line 52 of file print.c.

                                                                            {
    is_interrupted_cb = cb;
}

References cb, and is_interrupted_cb.

Referenced by rz_cons_new().

rz_print_set_rowoff()

RZ_API void rz_print_set_rowoff	(	RzPrint *	p,
		int	i,
		ut32	offset,
		bool	overwrite
	)

Definition at line 1527 of file print.c.

                                                                                {
    if (!overwrite) {
        return;
    }
    if (i < 0) {
        return;
    }
    if (!p->row_offsets || !p->row_offsets_sz) {
        p->row_offsets_sz = RZ_MAX(i + 1, DFLT_ROWS);
        p->row_offsets = RZ_NEWS(ut32, p->row_offsets_sz);
    }
    if (i >= p->row_offsets_sz) {
        size_t new_size;
        p->row_offsets_sz *= 2;
        // XXX dangerous
        while (i >= p->row_offsets_sz) {
            p->row_offsets_sz *= 2;
        }
        new_size = sizeof(ut32) * p->row_offsets_sz;
        p->row_offsets = realloc(p->row_offsets, new_size);
    }
    p->row_offsets[i] = offset;
}

References DFLT_ROWS, i, p, realloc(), RZ_MAX, and RZ_NEWS.

Referenced by rz_core_print_disasm().

rz_print_set_screenbounds()

RZ_API void rz_print_set_screenbounds	(	RzPrint *	p,
		ut64	addr
	)

Sets screen_bounds member of p to addr if the cursor is not visible on the screen.

Parameters

p	RzPrint instance
addr	Address to set screen_bounds if not visible

This function will only calculate the screen_bounds if the current value of screen_bounds is 1. It caches the number of rows visible on the first call to this function. The cache is invalidated when screen_bounds is set.

Definition at line 376 of file print.c.

                                                             {
    rz_return_if_fail(p);
 
    if (!p->screen_bounds) {
        return;
    }
    if (!p->consbind.get_size) {
        return;
    }
    if (!p->consbind.get_cursor) {
        return;
    }
 
    if (p->screen_bounds == 1) {
        int rc;
        if (!p->rows) {
            (void)p->consbind.get_size(&p->rows);
        }
        (void)p->consbind.get_cursor(&rc);
 
        if (rc > p->rows - 1) {
            p->screen_bounds = addr;
            p->rows = 0;
        }
    }
}

References addr, p, and rz_return_if_fail.

Referenced by ds_print_offset(), and rz_print_hexdump_str().

Variable Documentation

colorbuffer

char colorbuffer[64]

static

Definition at line 267 of file print.c.

Referenced by rz_print_byte_color().

hex

const char hex[16] = "0123456789ABCDEF"

static

Definition at line 21 of file print.c.

Referenced by capstone.CsInsn::__repr__(), cmd_analysis_esil(), hex2char(), hexdump(), i4004_get_ins_len(), old_transform_op(), readline_callback(), replace_asm_test(), rtr_visual(), rz_asm_op_set_hexbuf(), rz_assembly_of_hex_handler(), rz_bv_as_hex_string(), rz_core_assembly_of_hex(), rz_core_esil_of_hex(), rz_core_io_cache_print(), rz_core_seek_base(), rz_core_transform_op(), rz_core_write_block_op_at(), rz_esil_of_hex_handler(), rz_num_tail(), rz_num_tailff(), rz_print_hexdump_str(), rz_reg_arenas_write_hex_handler(), rz_test_load_asm_test_file(), rz_test_run_asm_test(), rz_write_block_handler(), rzil_print_register_bitv(), write_op_val(), z80_ed_branch_index_res(), z80_fddd_branch_index_res(), and z80_op_24_branch_index_res().

is_interrupted_cb

RzPrintIsInterruptedCallback is_interrupted_cb = NULL

static

Definition at line 43 of file print.c.

Referenced by rz_print_is_interrupted(), and rz_print_set_is_interrupted_cb().

staticp

RzPrint staticp

static

Initial value:

= {
    .cb_printf = libc_printf
}

Definition at line 1254 of file print.c.

Referenced by rz_print_progressbar().