cprint.c File Reference

#include <rz_core.h>

Go to the source code of this file.

Macros
#define	STRING_CHUNK   16

Functions
RZ_API RZ_OWN char *	rz_core_print_string_c_cpp (RzCore *core)
RZ_API RZ_OWN char *	rz_core_hex_of_assembly (RzCore *core, const char *assembly)
	Get the hexpair of the assembly. More...
RZ_API RZ_OWN char *	rz_core_esil_of_assembly (RzCore *core, const char *assembly)
	Get the esil of the assembly. More...
RZ_API RZ_OWN char *	rz_core_assembly_of_hex (RzCore *core, ut8 *hex, int len)
	Get the assembly of the hexstr. More...
RZ_API RZ_OWN char *	rz_core_esil_of_hex (RzCore *core, ut8 *hex, int len)
	Get the esil of the hexstr. More...
RZ_IPI void	rz_core_print_hexdump (RZ_NONNULL RzCore *core, ut64 addr, RZ_NONNULL const ut8 *buf, int len, int base, int step, size_t zoomsz)
RZ_IPI void	rz_core_print_jsondump (RZ_NONNULL RzCore *core, RZ_NONNULL const ut8 *buf, int len, int wordsize)
RZ_IPI void	rz_core_print_hexdiff (RZ_NONNULL RzCore *core, ut64 aa, RZ_NONNULL const ut8 *_a, ut64 ba, RZ_NONNULL const ut8 *_b, int len, int scndcol)
RZ_API char *	rz_core_print_hexdump_diff_str (RZ_NONNULL RzCore *core, ut64 aa, ut64 ba, ut64 len)
	Print hexdump diff between aa and ba with len. More...
RZ_IPI bool	rz_core_print_hexdump_diff (RZ_NONNULL RzCore *core, ut64 aa, ut64 ba, ut64 len)
static st8	format_type_to_base (const RzCorePrintFormatType format, const ut8 n)
static void	fix_size_from_format (const RzCorePrintFormatType format, ut8 *size)
static void	len_fixup (RzCore *core, ut64 *addr, int *len)
RZ_API char *	rz_core_print_dump_str (RZ_NONNULL RzCore *core, RzOutputMode mode, ut64 addr, ut8 n, int len, RzCorePrintFormatType format)
	Print dump at addr. More...
RZ_IPI bool	rz_core_print_dump (RZ_NONNULL RzCore *core, RzOutputMode mode, ut64 addr, ut8 n, int len, RzCorePrintFormatType format)
RZ_API char *	rz_core_print_hexdump_or_hexdiff_str (RZ_NONNULL RzCore *core, RzOutputMode mode, ut64 addr, int len, bool use_comment)
	Print hexdump at addr, but maybe print hexdiff if (diff.from or diff.to),. More...
RZ_IPI bool	rz_core_print_hexdump_or_hexdiff (RZ_NONNULL RzCore *core, RZ_NULLABLE RzOutputMode mode, ut64 addr, int len, bool use_comment)
static char *	ut64_to_hex (const ut64 x, const ut8 width)
RZ_API RZ_OWN char *	rz_core_print_hexdump_byline_str (RZ_NONNULL RzCore *core, bool hex_offset, ut64 addr, int len, ut8 size)
	Hexdump at addr. More...
RZ_IPI bool	rz_core_print_hexdump_byline (RZ_NONNULL RzCore *core, bool hexoffset, ut64 addr, int len, ut8 size)

Macro Definition Documentation

STRING_CHUNK

#define STRING_CHUNK   16

Definition at line 6 of file cprint.c.

Function Documentation

fix_size_from_format()

static void fix_size_from_format ( const RzCorePrintFormatType  format, ut8 *  size  )

inlinestatic

Definition at line 242 of file cprint.c.

                                                                                       {
    if (format != RZ_CORE_PRINT_FORMAT_TYPE_INTEGER) {
        return;
    }
    static const st8 sizes[] = {
        0, 4, 2, [4] = 4, [8] = 4
    };
    if (*size >= sizeof(sizes)) {
        return;
    }
    *size = sizes[*size];
}

References st8.

Referenced by rz_core_print_dump_str().

format_type_to_base()

static st8 format_type_to_base ( const RzCorePrintFormatType  format, const ut8  n  )

inlinestatic

Definition at line 230 of file cprint.c.

                                                                                       {
    static const st8 bases[][9] = {
        { 0, 8 },
        { 0, -1, -10, [4] = 10, [8] = -8 },
        { 0, 16, 32, [4] = 32, [8] = 64 },
    };
    if (format >= RZ_CORE_PRINT_FORMAT_TYPE_INVALID || n >= sizeof(bases[0])) {
        return 0;
    }
    return bases[format][n];
}

References n, and st8.

Referenced by rz_core_print_dump_str().

len_fixup()

static void len_fixup ( RzCore *  core, ut64 *  addr, int *  len  )

inlinestatic

Definition at line 255 of file cprint.c.

                                                                 {
    if (!len) {
        return;
    }
    bool is_positive = *len > 0;
    if (RZ_ABS(*len) > core->blocksize_max) {
        RZ_LOG_ERROR("this <len> is too big (0x%" PFMT32x
                 " < 0x%" PFMT32x ").",
            *len, core->blocksize_max);
        *len = (int)core->blocksize_max;
    }
    if (is_positive) {
        return;
    }
    *len = RZ_ABS(*len);
    if (addr) {
        *addr = *addr - *len;
    }
}

References addr, rz_core_t::blocksize_max, int, len, PFMT32x, RZ_ABS, and RZ_LOG_ERROR.

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

rz_core_assembly_of_hex()

RZ_API RZ_OWN char* rz_core_assembly_of_hex	(	RzCore *	core,
		ut8 *	hex,
		int	len
	)

Get the assembly of the hexstr.

Parameters

core	RzCore
hex	hex
len	length of hex

Returns

a string containing the assembly of the hexstr

Definition at line 109 of file cprint.c.

                                                                             {
    RzStrBuf *buf = rz_strbuf_new("");
    if (!buf) {
        RZ_LOG_ERROR("Fail to allocate memory\n");
        return NULL;
    }
    rz_asm_set_pc(core->rasm, core->offset);
    RzAsmCode *acode = rz_asm_mdisassemble(core->rasm, hex, len);
    if (!acode) {
        RZ_LOG_ERROR("Invalid hexstr\n");
        rz_strbuf_free(buf);
        return NULL;
    }
    rz_strbuf_append(buf, acode->assembly);
    rz_asm_code_free(acode);
    return rz_strbuf_drain(buf);
}

References rz_asm_code_t::assembly, hex, len, NULL, rz_core_t::offset, rz_core_t::rasm, rz_asm_code_free(), rz_asm_mdisassemble(), rz_asm_set_pc(), RZ_LOG_ERROR, rz_strbuf_append(), rz_strbuf_drain(), rz_strbuf_free(), and rz_strbuf_new().

Referenced by rz_assembly_of_hex_handler().

rz_core_esil_of_assembly()

RZ_API RZ_OWN char* rz_core_esil_of_assembly	(	RzCore *	core,
		const char *	assembly
	)

Get the esil of the assembly.

Parameters

core	RzCore
assembly	assembly

Returns

a string containing the esil of the assembly

Definition at line 68 of file cprint.c.

                                                                                 {
    RzStrBuf *buf = rz_strbuf_new("");
    if (!buf) {
        RZ_LOG_ERROR("Fail to allocate memory\n");
        return NULL;
    }
    rz_asm_set_pc(core->rasm, core->offset);
    RzAsmCode *acode = rz_asm_massemble(core->rasm, assembly);
    if (!acode) {
        RZ_LOG_ERROR("Fail to assemble by rz_asm_massemble()\n");
        rz_strbuf_free(buf);
        return NULL;
    }
    int printed = 0, bufsz = acode->len;
    RzAnalysisOp aop = { 0 };
    while (printed < bufsz) {
        aop.size = 0;
        if (rz_analysis_op(core->analysis, &aop, core->offset,
                (const ut8 *)acode->bytes + printed, bufsz - printed, RZ_ANALYSIS_OP_MASK_ESIL) <= 0 ||
            aop.size < 1) {
            RZ_LOG_ERROR("Cannot decode instruction\n");
            rz_analysis_op_fini(&aop);
            rz_strbuf_free(buf);
            rz_asm_code_free(acode);
            return NULL;
        }
        rz_strbuf_appendf(buf, "%s\n", RZ_STRBUF_SAFEGET(&aop.esil));
        printed += aop.size;
        rz_analysis_op_fini(&aop);
    }
    rz_asm_code_free(acode);
    return rz_strbuf_drain(buf);
}

References rz_core_t::analysis, rz_asm_code_t::bytes, rz_analysis_op_t::esil, rz_asm_code_t::len, NULL, rz_core_t::offset, rz_core_t::rasm, rz_analysis_op(), rz_analysis_op_fini(), RZ_ANALYSIS_OP_MASK_ESIL, rz_asm_code_free(), rz_asm_massemble(), rz_asm_set_pc(), RZ_LOG_ERROR, rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_free(), rz_strbuf_new(), RZ_STRBUF_SAFEGET, and rz_analysis_op_t::size.

Referenced by rz_esil_of_assembly_handler().

rz_core_esil_of_hex()

RZ_API RZ_OWN char* rz_core_esil_of_hex	(	RzCore *	core,
		ut8 *	hex,
		int	len
	)

Get the esil of the hexstr.

Parameters

core	RzCore
hex	hex
len	length of hex

Returns

a string containing the esil of the hexstr

Definition at line 134 of file cprint.c.

                                                                         {
    RzStrBuf *buf = rz_strbuf_new("");
    if (!buf) {
        RZ_LOG_ERROR("Fail to allocate memory\n");
        goto fail;
    }
    int printed = 0;
    RzAnalysisOp aop = { 0 };
    while (printed < len) {
        aop.size = 0;
        if (rz_analysis_op(core->analysis, &aop, core->offset,
                (const ut8 *)hex + printed, len - printed, RZ_ANALYSIS_OP_MASK_ESIL) <= 0 ||
            aop.size < 1) {
            RZ_LOG_ERROR("Cannot decode instruction\n");
            rz_analysis_op_fini(&aop);
            goto fail;
        }
        rz_strbuf_appendf(buf, "%s\n", RZ_STRBUF_SAFEGET(&aop.esil));
        printed += aop.size;
        rz_analysis_op_fini(&aop);
    }
    return rz_strbuf_drain(buf);
fail:
    rz_strbuf_free(buf);
    return NULL;
}

References rz_core_t::analysis, rz_analysis_op_t::esil, fail, hex, len, NULL, rz_core_t::offset, rz_analysis_op(), rz_analysis_op_fini(), RZ_ANALYSIS_OP_MASK_ESIL, RZ_LOG_ERROR, rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_free(), rz_strbuf_new(), RZ_STRBUF_SAFEGET, and rz_analysis_op_t::size.

Referenced by rz_esil_of_hex_handler().

rz_core_hex_of_assembly()

RZ_API RZ_OWN char* rz_core_hex_of_assembly	(	RzCore *	core,
		const char *	assembly
	)

Get the hexpair of the assembly.

Parameters

core	RzCore
assembly	assembly

Returns

a string containing the hexpair of the assembly

Definition at line 41 of file cprint.c.

                                                                                {
    RzStrBuf *buf = rz_strbuf_new("");
    if (!buf) {
        RZ_LOG_ERROR("Fail to allocate memory\n");
        return NULL;
    }
    rz_asm_set_pc(core->rasm, core->offset);
    RzAsmCode *acode = rz_asm_massemble(core->rasm, assembly);
    if (!acode) {
        RZ_LOG_ERROR("Fail to assemble by rz_asm_massemble()\n");
        rz_strbuf_free(buf);
        return NULL;
    }
    for (int i = 0; i < acode->len; i++) {
        ut8 b = acode->bytes[i]; // core->print->big_endian? (bytes - 1 - i): i ];
        rz_strbuf_appendf(buf, "%02x", b);
    }
    rz_asm_code_free(acode);
    return rz_strbuf_drain(buf);
}

References b, rz_asm_code_t::bytes, i, rz_asm_code_t::len, NULL, rz_core_t::offset, rz_core_t::rasm, rz_asm_code_free(), rz_asm_massemble(), rz_asm_set_pc(), RZ_LOG_ERROR, rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_free(), and rz_strbuf_new().

Referenced by rz_hex_of_assembly_handler().

rz_core_print_dump()

RZ_IPI bool rz_core_print_dump	(	RZ_NONNULL RzCore *	core,
		RzOutputMode	mode,
		ut64	addr,
		ut8	n,
		int	len,
		RzCorePrintFormatType	format
	)

Definition at line 322 of file cprint.c.

                                                             {
    char *string = rz_core_print_dump_str(core, mode, addr, n, len, format);
    if (!string) {
        RZ_LOG_ERROR("fail to print dump at 0x%" PFMT64x "\n", addr);
        return false;
    }
    rz_cons_print(string);
    return true;
}

References addr, len, n, PFMT64x, rz_core_print_dump_str(), and RZ_LOG_ERROR.

Referenced by rz_print_hexdump_hex_common_handler(), rz_print_hexdump_oct_handler(), and rz_print_hexdump_signed_integer_common_handler().

rz_core_print_dump_str()

RZ_API char* rz_core_print_dump_str	(	RZ_NONNULL RzCore *	core,
		RzOutputMode	mode,
		ut64	addr,
		ut8	n,
		int	len,
		RzCorePrintFormatType	format
	)

Print dump at addr.

Parameters

n	Word size by bytes (1,2,4,8)
len	Dump bytes length
format	Print format, such as RZ_CORE_PRINT_FORMAT_TYPE_HEXADECIMAL

Definition at line 281 of file cprint.c.

                                                             {
    rz_return_val_if_fail(core, false);
    if (!len) {
        return NULL;
    }
    st8 base = format_type_to_base(format, n);
    if (!base) {
        return NULL;
    }
    len_fixup(core, &addr, &len);
    ut8 *buffer = malloc(len);
    if (!buffer) {
        return NULL;
    }
 
    char *string = NULL;
    rz_io_read_at(core->io, addr, buffer, len);
    RzPrint *print = core->print;
    rz_print_init_rowoffsets(print);
    bool old_use_comments = print->use_comments;
    print->use_comments = false;
 
    switch (mode) {
    case RZ_OUTPUT_MODE_JSON:
        string = rz_print_jsondump_str(print, buffer, len, n * 8);
        break;
    case RZ_OUTPUT_MODE_STANDARD:
        fix_size_from_format(format, &n);
        string = rz_print_hexdump_str(print, addr, buffer, len, base, (int)n, 1);
        break;
    default:
        rz_warn_if_reached();
        break;
    }
 
    print->use_comments = old_use_comments;
    free(buffer);
    return string;
}

References addr, fix_size_from_format(), format_type_to_base(), free(), len, len_fixup(), malloc(), n, NULL, rz_io_read_at(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_STANDARD, rz_print_hexdump_str(), rz_print_init_rowoffsets(), rz_print_jsondump_str(), rz_return_val_if_fail, rz_warn_if_reached, st8, and rz_print_t::use_comments.

Referenced by rz_core_print_dump().

rz_core_print_hexdiff()

RZ_IPI void rz_core_print_hexdiff	(	RZ_NONNULL RzCore *	core,
		ut64	aa,
		RZ_NONNULL const ut8 *	_a,
		ut64	ba,
		RZ_NONNULL const ut8 *	_b,
		int	len,
		int	scndcol
	)

Definition at line 182 of file cprint.c.

                                                                                                                                                       {
    char *string = rz_print_hexdiff_str(core->print, aa, _a, ba, _b, len, scndcol);
    if (!string) {
        RZ_LOG_ERROR("fail to print hexdiff between 0x%" PFMT64x " and 0x%" PFMT64x "\n", aa, ba);
        return;
    }
    rz_cons_print(string);
    free(string);
}

References free(), len, PFMT64x, RZ_LOG_ERROR, and rz_print_hexdiff_str().

Referenced by rizin_compare_unified(), rz_cmd_cmp_hex_block_handler(), and rz_cmd_cmp_hex_diff_lines_handler().

rz_core_print_hexdump()

RZ_IPI void rz_core_print_hexdump	(	RZ_NONNULL RzCore *	core,
		ut64	addr,
		RZ_NONNULL const ut8 *	buf,
		int	len,
		int	base,
		int	step,
		size_t	zoomsz
	)

Definition at line 161 of file cprint.c.

                                                {
    char *string = rz_print_hexdump_str(core->print, addr, buf, len, base, step, zoomsz);
    if (!string) {
        RZ_LOG_ERROR("fail to print hexdump at 0x%" PFMT64x "\n", addr);
        return;
    }
    rz_cons_print(string);
    free(string);
}

References addr, free(), len, PFMT64x, RZ_LOG_ERROR, rz_print_hexdump_str(), and step().

Referenced by cmd_print_op(), ds_print_meta_infos(), print_heap_chunk(), rz_cmd_heap_chunks_print_handler(), rz_core_disasm_pdi_with_buf(), rz_core_yank_print_hexdump(), rz_print_hexdump_hexless_bytes_handler(), rz_print_hexdump_hexless_words_handler(), rz_print_hexdump_sparse_handler(), rz_reg_arenas_hexdump_handler(), and search_collisions().

rz_core_print_hexdump_byline()

RZ_IPI bool rz_core_print_hexdump_byline	(	RZ_NONNULL RzCore *	core,
		bool	hexoffset,
		ut64	addr,
		int	len,
		ut8	size
	)

Definition at line 466 of file cprint.c.

                                                                                                                {
    char *string = rz_core_print_hexdump_byline_str(core, hexoffset, addr, len, size);
    if (!string) {
        RZ_LOG_ERROR("fail to print hexdump by line at 0x%" PFMT64x "\n", addr);
        return false;
    }
    rz_cons_print(string);
    free(string);
    return true;
}

References addr, free(), len, PFMT64x, rz_core_print_hexdump_byline_str(), and RZ_LOG_ERROR.

Referenced by rz_print_hexdump_hexl_common_handler().

rz_core_print_hexdump_byline_str()

RZ_API RZ_OWN char* rz_core_print_hexdump_byline_str	(	RZ_NONNULL RzCore *	core,
		bool	hex_offset,
		ut64	addr,
		int	len,
		ut8	size
	)

Hexdump at addr.

Parameters

len	Dump bytes length
size	Word size by bytes (1,2,4,8)

Returns

Hexdump string

Definition at line 406 of file cprint.c.

                                  {
    rz_return_val_if_fail(core, false);
    if (!len) {
        return NULL;
    }
    len_fixup(core, &addr, &len);
    ut8 *buffer = malloc(len);
    if (!buffer) {
        return NULL;
    }
 
    rz_io_read_at(core->io, addr, buffer, len);
    const int round_len = len - (len % size);
    RzStrBuf *sb = rz_strbuf_new(NULL);
    for (int i = 0; i < round_len; i += size) {
        const char *a, *b;
        char *fn;
        RzPrint *p = core->print;
        RzFlagItem *f;
        ut64 v = rz_read_ble(buffer + i, p->big_endian, size * 8);
        if (p->colorfor) {
            a = p->colorfor(p->user, v, true);
            if (a && *a) {
                b = Color_RESET;
            } else {
                a = b = "";
            }
        } else {
            a = b = "";
        }
        f = rz_flag_get_at(core->flags, v, true);
        fn = NULL;
        if (f) {
            st64 delta = (st64)(v - f->offset);
            if (delta >= 0 && delta < 8192) {
                if (v == f->offset) {
                    fn = strdup(f->name);
                } else {
                    fn = rz_str_newf("%s+%" PFMT64d, f->name, v - f->offset);
                }
            }
        }
        char *vstr = ut64_to_hex(v, size * 2);
        if (vstr) {
            if (hex_offset) {
                rz_strbuf_append(sb, rz_print_section_str(core->print, addr + i));
                rz_strbuf_appendf(sb, "0x%08" PFMT64x " %s%s%s%s%s\n",
                    (ut64)addr + i, a, vstr, b, fn ? " " : "", fn ? fn : "");
            } else {
                rz_strbuf_appendf(sb, "%s%s%s\n", a, vstr, b);
            }
        }
        free(vstr);
        free(fn);
    }
    free(buffer);
    return rz_strbuf_drain(sb);
}

References a, addr, b, Color_RESET, delta, f, fn, free(), i, len, len_fixup(), malloc(), NULL, p, PFMT64d, PFMT64x, rz_flag_get_at(), rz_io_read_at(), rz_print_section_str(), rz_read_ble(), rz_return_val_if_fail, rz_str_newf(), rz_strbuf_append(), rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_new(), sb, st64, strdup(), ut64(), ut64_to_hex(), and v.

Referenced by rz_core_print_hexdump_byline().

rz_core_print_hexdump_diff()

RZ_IPI bool rz_core_print_hexdump_diff	(	RZ_NONNULL RzCore *	core,
		ut64	aa,
		ut64	ba,
		ut64	len
	)

Definition at line 219 of file cprint.c.

                                                                                            {
    char *string = rz_core_print_hexdump_diff_str(core, aa, ba, len);
    if (!string) {
        RZ_LOG_ERROR("fail to print hexdump diff between 0x%" PFMT64x " and 0x%" PFMT64x "\n", aa, ba);
        return false;
    }
    rz_cons_print(string);
    free(string);
    return true;
}

References free(), len, PFMT64x, rz_core_print_hexdump_diff_str(), and RZ_LOG_ERROR.

rz_core_print_hexdump_diff_str()

RZ_API char* rz_core_print_hexdump_diff_str	(	RZ_NONNULL RzCore *	core,
		ut64	aa,
		ut64	ba,
		ut64	len
	)

Print hexdump diff between aa and ba with len.

Definition at line 195 of file cprint.c.

                                                                                                 {
    rz_return_val_if_fail(core && core->cons && len > 0, false);
    ut8 *a = malloc(len);
    if (!a) {
        return NULL;
    }
    ut8 *b = malloc(len);
    if (!b) {
        free(a);
        return NULL;
    }
 
    RZ_LOG_VERBOSE("print hexdump diff 0x%" PFMT64x " 0x%" PFMT64x " with len:%" PFMT64d "\n", aa, ba, len);
 
    rz_io_read_at(core->io, aa, a, (int)len);
    rz_io_read_at(core->io, ba, b, (int)len);
    int col = core->cons->columns > 123;
    char *pstr = rz_print_hexdiff_str(core->print, aa, a,
        ba, b, (int)len, col);
    free(a);
    free(b);
    return pstr;
}

References a, b, free(), len, malloc(), NULL, PFMT64d, PFMT64x, rz_io_read_at(), RZ_LOG_VERBOSE, rz_print_hexdiff_str(), and rz_return_val_if_fail.

Referenced by rz_core_print_hexdump_diff(), and rz_core_print_hexdump_or_hexdiff_str().

rz_core_print_hexdump_or_hexdiff()

RZ_IPI bool rz_core_print_hexdump_or_hexdiff	(	RZ_NONNULL RzCore *	core,
		RZ_NULLABLE RzOutputMode	mode,
		ut64	addr,
		int	len,
		bool	use_comment
	)

Definition at line 378 of file cprint.c.

                      {
    char *string = rz_core_print_hexdump_or_hexdiff_str(core, mode, addr, len, use_comment);
    if (!string) {
        RZ_LOG_ERROR("fail to print hexdump at 0x%" PFMT64x "\n", addr);
        return false;
    }
    rz_cons_print(string);
    return true;
}

References addr, len, PFMT64x, rz_core_print_hexdump_or_hexdiff_str(), and RZ_LOG_ERROR.

rz_core_print_hexdump_or_hexdiff_str()

RZ_API char* rz_core_print_hexdump_or_hexdiff_str	(	RZ_NONNULL RzCore *	core,
		RzOutputMode	mode,
		ut64	addr,
		int	len,
		bool	use_comment
	)

Print hexdump at addr, but maybe print hexdiff if (diff.from or diff.to),.

See also

"el diff"

Parameters

len	Dump bytes length

Definition at line 337 of file cprint.c.

                      {
    rz_return_val_if_fail(core, false);
    if (!len) {
        return NULL;
    }
 
    char *string = NULL;
    RzPrint *print = core->print;
    bool old_use_comments = print->use_comments;
    print->use_comments = use_comment ? print->flags & RZ_PRINT_FLAGS_COMMENT : false;
    switch (mode) {
    case RZ_OUTPUT_MODE_STANDARD: {
        ut64 from = rz_config_get_i(core->config, "diff.from");
        ut64 to = rz_config_get_i(core->config, "diff.to");
        if (from == to && !from) {
            len_fixup(core, &addr, &len);
            ut8 *buffer = malloc(len);
            if (!buffer) {
                return NULL;
            }
            rz_io_read_at(core->io, addr, buffer, len);
            string = rz_print_hexdump_str(core->print, rz_core_pava(core, addr), buffer, len, 16, 1, 1);
            free(buffer);
        } else {
            string = rz_core_print_hexdump_diff_str(core, addr, addr + to - from, len);
        }
        core->num->value = len;
        break;
    }
    case RZ_OUTPUT_MODE_JSON:
        string = rz_print_jsondump_str(core->print, core->block, len, 8);
        break;
    default:
        rz_warn_if_reached();
        break;
    }
    print->use_comments = old_use_comments;
    return string;
}

References addr, rz_print_t::flags, free(), from, len, len_fixup(), malloc(), NULL, rz_config_get_i(), rz_core_pava(), rz_core_print_hexdump_diff_str(), rz_io_read_at(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_STANDARD, RZ_PRINT_FLAGS_COMMENT, rz_print_hexdump_str(), rz_print_jsondump_str(), rz_return_val_if_fail, rz_warn_if_reached, to, rz_print_t::use_comments, and ut64().

Referenced by rz_core_print_hexdump_or_hexdiff().

rz_core_print_jsondump()

RZ_IPI void rz_core_print_jsondump	(	RZ_NONNULL RzCore *	core,
		RZ_NONNULL const ut8 *	buf,
		int	len,
		int	wordsize
	)

Definition at line 172 of file cprint.c.

                                                                                                              {
    char *string = rz_print_jsondump_str(core->print, buf, len, wordsize);
    if (!string) {
        RZ_LOG_ERROR("fail to print json hexdump\n");
        return;
    }
    rz_cons_print(string);
    free(string);
}

References free(), len, RZ_LOG_ERROR, and rz_print_jsondump_str().

rz_core_print_string_c_cpp()

RZ_API RZ_OWN char* rz_core_print_string_c_cpp

(

RzCore *

core

)

Return a C/C++ string defination with block size as the length

Parameters

core

RzCore

Returns

a string defination or NULL if the error happens

Definition at line 13 of file cprint.c.

                                                             {
    ut64 value;
    size_t size = core->blocksize;
    RzStrBuf *sb = rz_strbuf_new(NULL);
 
    if (!sb) {
        RZ_LOG_ERROR("Fail to allocate the memory\n");
        return NULL;
    }
    rz_strbuf_appendf(sb, "#define STRING_SIZE %" PFMTSZd "\nconst char s[STRING_SIZE] = \"", size);
    for (size_t pos = 0; pos < size; pos++) {
        if (pos && !(pos % STRING_CHUNK)) {
            // newline and padding for long string
            rz_strbuf_appendf(sb, "\"\n                            \"");
        }
        value = rz_read_ble(core->block + pos, false, 8);
        rz_strbuf_appendf(sb, "\\x%02" PFMT64x, value);
    }
    rz_strbuf_append(sb, "\";");
    return rz_strbuf_drain(sb);
}

References rz_core_t::block, rz_core_t::blocksize, NULL, PFMT64x, PFMTSZd, pos, RZ_LOG_ERROR, rz_read_ble(), rz_strbuf_append(), rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_new(), sb, STRING_CHUNK, ut64(), and value.

Referenced by rz_print_string_c_cpp_handler().

ut64_to_hex()

static char* ut64_to_hex ( const ut64  x, const ut8  width  )

inlinestatic

Definition at line 389 of file cprint.c.

                                                               {
    RzStrBuf *sb = rz_strbuf_new(NULL);
    rz_strbuf_appendf(sb, "%" PFMT64x, x);
    ut8 len = rz_strbuf_length(sb);
    if (len < width) {
        rz_strbuf_prepend(sb, rz_str_pad('0', width - len));
    }
    rz_strbuf_prepend(sb, "0x");
    return rz_strbuf_drain(sb);
}

References len, NULL, PFMT64x, rz_str_pad(), rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_length(), rz_strbuf_new(), rz_strbuf_prepend(), sb, width, and x.

Referenced by rz_core_print_hexdump_byline_str().