cmd_cmp.c File Reference

#include <rz_cmp.h>
#include "../core_private.h"

Go to the source code of this file.

Functions
static int	rizin_compare_words (RzCore *core, ut64 of, ut64 od, int len, int ws)
static bool	rizin_compare_unified (RzCore *core, RzCompareData *cmp)
static bool	core_cmp_bits (RzCore *core, RzCompareData *cmp)
RZ_IPI RzCmdStatus	rz_cmd_cmp_string_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_cmd_cmp_bits_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_cmd_cmp_addr_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_cmd_cmp_bytes_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_cmd_cmp_hex_block_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_cmd_cmp_hex_diff_lines_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_cmd_cmp_disasm_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_cmd_cmp_file_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_cmd_cmp_unified_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_cmd_cmp_unified1_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_cmd_cmp_unified2_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_cmd_cmp_unified4_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_cmd_cmp_unified8_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_cmd_cmp_unified_disasm_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_cmd_cmp_add_memory_watcher_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_cmd_cmp_list_compare_watchers_handler (RzCore *core, int argc, const char **argv, RzOutputMode mode)
RZ_IPI RzCmdStatus	rz_cmd_cmp_reset_watcher_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_cmd_cmp_update_watcher_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_cmd_cmp_remove_watcher_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_cmd_cmp_hexpair_string_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_cmd_cmp_hex_block_hexdiff_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)

Function Documentation

core_cmp_bits()

static bool core_cmp_bits ( RzCore *  core, RzCompareData *  cmp  )

static

Definition at line 72 of file cmd_cmp.c.

                                                            {
    const bool scr_color = rz_config_get_i(core->config, "scr.color");
    int i;
    RzConsPrintablePalette *pal = &rz_cons_singleton()->context->pal;
    const char *color = scr_color ? pal->offset : "";
    const char *color_end = scr_color ? Color_RESET : "";
    if (rz_config_get_i(core->config, "hex.header")) {
        char *n = rz_str_newf("0x%08" PFMT64x, cmp->addr1);
        const char *extra = rz_str_pad(' ', strlen(n) - 10);
        free(n);
        rz_cons_printf("%s- offset -%s  7 6 5 4 3 2 1 0%s\n", color, extra, color_end);
    }
    color = scr_color ? pal->graph_false : "";
    color_end = scr_color ? Color_RESET : "";
 
    rz_cons_printf("%s0x%08" PFMT64x "%s  ", color, cmp->addr1, color_end);
    for (i = 7; i >= 0; i--) {
        bool b0 = (cmp->data1[0] & 1 << i) ? 1 : 0;
        bool b1 = (cmp->data2[0] & 1 << i) ? 1 : 0;
        color = scr_color ? (b0 == b1) ? "" : b0 ? pal->graph_true
                             : pal->graph_false
                  : "";
        color_end = scr_color ? Color_RESET : "";
        rz_cons_printf("%s%d%s ", color, b0, color_end);
    }
    color = scr_color ? pal->graph_true : "";
    color_end = scr_color ? Color_RESET : "";
    rz_cons_printf("\n%s0x%08" PFMT64x "%s  ", color, cmp->addr2, color_end);
    for (i = 7; i >= 0; i--) {
        bool b0 = (cmp->data1[0] & 1 << i) ? 1 : 0;
        bool b1 = (cmp->data2[0] & 1 << i) ? 1 : 0;
        color = scr_color ? (b0 == b1) ? "" : b1 ? pal->graph_true
                             : pal->graph_false
                  : "";
        color_end = scr_color ? Color_RESET : "";
        rz_cons_printf("%s%d%s ", color, b1, color_end);
    }
    rz_cons_newline();
 
    return true;
}

References b1, cmp(), color, Color_RESET, rz_core_t::config, rz_cons_t::context, free(), rz_cons_printable_palette_t::graph_false, rz_cons_printable_palette_t::graph_true, i, n, rz_cons_printable_palette_t::offset, rz_cons_context_t::pal, PFMT64x, rz_config_get_i(), rz_cons_newline(), rz_cons_printf(), rz_cons_singleton(), rz_str_newf(), and rz_str_pad().

Referenced by rz_cmd_cmp_bits_handler().

rizin_compare_unified()

static bool rizin_compare_unified ( RzCore *  core, RzCompareData *  cmp  )

static

Definition at line 48 of file cmd_cmp.c.

                                                                    {
    int i, min = 1, inc = 16;
    int headers = B_IS_SET(core->print->flags, RZ_PRINT_FLAGS_HEADER);
    if (headers) {
        B_UNSET(core->print->flags, RZ_PRINT_FLAGS_HEADER);
    }
    for (i = 0; i < cmp->len; i += inc) {
        min = RZ_MIN(16, (cmp->len - i));
        if (!memcmp(cmp->data1 + i, cmp->data2 + i, min)) {
            rz_cons_printf("  ");
            rz_core_print_hexdiff(core, cmp->addr1 + i, cmp->data1 + i, cmp->addr1 + i, cmp->data1 + i, min, 0);
        } else {
            rz_cons_printf("- ");
            rz_core_print_hexdiff(core, cmp->addr1 + i, cmp->data1 + i, cmp->addr2 + i, cmp->data2 + i, min, 0);
            rz_cons_printf("+ ");
            rz_core_print_hexdiff(core, cmp->addr2 + i, cmp->data2 + i, cmp->addr1 + i, cmp->data1 + i, min, 0);
        }
    }
    if (headers) {
        B_SET(core->print->flags, RZ_PRINT_FLAGS_HEADER);
    }
    return true;
}

References B_IS_SET, B_SET, B_UNSET, cmp(), rz_print_t::flags, i, min, rz_core_t::print, rz_cons_printf(), rz_core_print_hexdiff(), RZ_MIN, and RZ_PRINT_FLAGS_HEADER.

Referenced by rz_cmd_cmp_unified_handler().

rizin_compare_words()

static int rizin_compare_words ( RzCore *  core, ut64  of, ut64  od, int  len, int  ws  )

static

Definition at line 7 of file cmd_cmp.c.

                                                                                {
    int i;
    bool useColor = rz_config_get_i(core->config, "scr.color") != 0;
    utAny v0, v1;
    RzConsPrintablePalette *pal = &rz_cons_singleton()->context->pal;
    for (i = 0; i < len; i += ws) {
        memset(&v0, 0, sizeof(v0));
        memset(&v1, 0, sizeof(v1));
        rz_io_nread_at(core->io, of + i, (ut8 *)&v0, ws);
        rz_io_nread_at(core->io, od + i, (ut8 *)&v1, ws);
        char ch = (v0.v64 == v1.v64) ? '=' : '!';
        const char *color = useColor ? ch == '=' ? "" : pal->graph_false : "";
        const char *colorEnd = useColor ? Color_RESET : "";
 
        if (useColor) {
            rz_cons_printf("%s0x%08" PFMT64x "  " Color_RESET, pal->offset, of + i);
        } else {
            rz_cons_printf("0x%08" PFMT64x "  ", of + i);
        }
        switch (ws) {
        case 1:
            rz_cons_printf("%s0x%02x %c 0x%02x%s\n", color,
                (ut32)(v0.v8 & 0xff), ch, (ut32)(v1.v8 & 0xff), colorEnd);
            break;
        case 2:
            rz_cons_printf("%s0x%04hx %c 0x%04hx%s\n", color,
                v0.v16, ch, v1.v16, colorEnd);
            break;
        case 4:
            rz_cons_printf("%s0x%08" PFMT32x " %c 0x%08" PFMT32x "%s\n", color,
                v0.v32, ch, v1.v32, colorEnd);
            break;
        case 8:
            rz_cons_printf("%s0x%016" PFMT64x " %c 0x%016" PFMT64x "%s\n",
                color, v0.v64, ch, v1.v64, colorEnd);
            break;
        }
    }
    return 0;
}

References color, Color_RESET, rz_core_t::config, rz_cons_t::context, rz_cons_printable_palette_t::graph_false, i, rz_core_t::io, len, memset(), rz_cons_printable_palette_t::offset, rz_cons_context_t::pal, PFMT32x, PFMT64x, rz_config_get_i(), rz_cons_printf(), rz_cons_singleton(), rz_io_nread_at(), v0, and v1.

Referenced by rz_cmd_cmp_unified1_handler(), rz_cmd_cmp_unified2_handler(), rz_cmd_cmp_unified4_handler(), and rz_cmd_cmp_unified8_handler().

rz_cmd_cmp_add_memory_watcher_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_add_memory_watcher_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 289 of file cmd_cmp.c.

                                                                                                    {
    return rz_core_cmpwatch_add(core, core->offset, atoi(argv[1]), argv[2]) ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, and rz_core_cmpwatch_add().

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_addr_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_addr_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 144 of file cmd_cmp.c.

                                                                                                               {
    RzCompareData *cmp = rz_core_cmp_mem_mem(core, core->offset, rz_num_math(core->num, argv[1]), rz_num_math(core->num, argv[2]));
    if (!cmp) {
        return RZ_CMD_STATUS_ERROR;
    }
    int val = rz_core_cmp_print(core, cmp, state);
    rz_core_cmp_free(cmp);
    return val != -1 ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, cmp(), rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_cmp_free(), rz_core_cmp_mem_mem(), rz_core_cmp_print(), rz_num_math(), and val.

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_bits_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_bits_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 133 of file cmd_cmp.c.

                                                                                      {
    RzCompareData *cmp = rz_core_cmp_mem_mem(core, core->offset, rz_num_math(core->num, argv[1]), 1);
    if (!cmp) {
        return RZ_CMD_STATUS_ERROR;
    }
    bool val = core_cmp_bits(core, cmp);
    rz_core_cmp_free(cmp);
    return val ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, cmp(), core_cmp_bits(), rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_cmp_free(), rz_core_cmp_mem_mem(), rz_num_math(), and val.

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_bytes_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_bytes_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 155 of file cmd_cmp.c.

                                                                                                                {
    RzCmdStatus ret = RZ_CMD_STATUS_ERROR;
    ut64 sz = rz_num_math(core->num, argv[2]);
    if (sz > 8) {
        RZ_LOG_ERROR("Cannot compare more than 8 bytes. Use the c command instead.\n");
        return ret;
    }
 
    ut64 num = rz_num_math(core->num, argv[1]);
    ut64 mask = -1;
    mask >>= 8 - sz;
    ut64 valid_num = num & mask;
    RzCompareData *cmp = rz_core_cmp_mem_data(core, core->offset, (ut8 *)&valid_num, sz);
    if (!cmp) {
        goto end;
    }
    int val = rz_core_cmp_print(core, cmp, state);
    ret = val != -1 ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
 
end:
    rz_core_cmp_free(cmp);
    return ret;
}

References argv, cmp(), test_evm::end, mask, rz_core_t::num, num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_cmp_free(), rz_core_cmp_mem_data(), rz_core_cmp_print(), RZ_LOG_ERROR, rz_num_math(), ut64(), and val.

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_disasm_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_disasm_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 211 of file cmd_cmp.c.

                                                                                        {
    RzList *cmp = rz_core_cmp_disasm(core, core->offset, rz_num_math(core->num, argv[1]), core->blocksize);
    bool ret = rz_core_cmp_disasm_print(core, cmp, false);
    rz_list_free(cmp);
    return ret ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, rz_core_t::blocksize, cmp(), rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_cmp_disasm(), rz_core_cmp_disasm_print(), rz_list_free(), and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_file_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_file_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 219 of file cmd_cmp.c.

                                                                                                               {
    FILE *fd = rz_sys_fopen(argv[1], "rb");
    if (!fd) {
        RZ_LOG_ERROR("Cannot open file: %s\n", argv[1]);
        return RZ_CMD_STATUS_ERROR;
    }
    RzCmdStatus stat = RZ_CMD_STATUS_ERROR;
    ut8 *buf = (ut8 *)malloc(core->blocksize);
    if (!buf) {
        goto return_goto;
    }
    if (fread(buf, 1, core->blocksize, fd) < 1) {
        RZ_LOG_ERROR("Cannot read file: %s\n", argv[1]);
        goto return_goto;
    }
    RzCompareData *cmp = rz_core_cmp_mem_data(core, core->offset, buf, core->blocksize);
    if (!cmp) {
        goto return_goto;
    }
    int val = rz_core_cmp_print(core, cmp, state);
    rz_core_cmp_free(cmp);
    stat = val != -1 ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
 
return_goto:
    free(buf);
    fclose(fd);
    return stat;
}

References argv, rz_core_t::blocksize, cmp(), fd, benchmark::FILE, free(), malloc(), rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_cmp_free(), rz_core_cmp_mem_data(), rz_core_cmp_print(), RZ_LOG_ERROR, rz_sys_fopen(), stat, and val.

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_hex_block_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_hex_block_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 180 of file cmd_cmp.c.

                                                                                           {
    ut64 addr = rz_num_math(core->num, argv[1]);
    bool col = core->cons->columns > 123;
    ut8 *b = malloc(core->blocksize);
    if (b) {
        memset(b, 0xff, core->blocksize);
        rz_io_nread_at(core->io, addr, b, core->blocksize);
        rz_core_print_hexdiff(core, core->offset, core->block, addr, b, core->blocksize, col);
    }
    free(b);
    return RZ_CMD_STATUS_OK;
}

References addr, argv, b, rz_core_t::block, rz_core_t::blocksize, rz_cons_t::columns, rz_core_t::cons, free(), rz_core_t::io, malloc(), memset(), rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_OK, rz_core_print_hexdiff(), rz_io_nread_at(), rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_hex_block_hexdiff_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_hex_block_hexdiff_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 351 of file cmd_cmp.c.

                                                                                                                            {
    unsigned char *buf = malloc(core->blocksize);
    bool ret = false;
    if (!buf) {
        goto return_goto;
    }
    if (rz_io_nread_at(core->io, rz_num_math(core->num, argv[1]), buf, core->blocksize) == -1) {
        RZ_LOG_ERROR("Cannot read hexdump at %s\n", argv[1]);
        goto return_goto;
    }
 
    RzCompareData *cmp = rz_core_cmp_mem_data(core, core->offset, buf, core->blocksize);
    if (!cmp) {
        free(cmp);
        goto return_goto;
    }
    int val = rz_core_cmp_print(core, cmp, state);
    rz_core_cmp_free(cmp);
    ret = val != -1;
 
return_goto:
    free(buf);
    return ret ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, rz_core_t::blocksize, cmp(), free(), rz_core_t::io, malloc(), rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_cmp_free(), rz_core_cmp_mem_data(), rz_core_cmp_print(), rz_io_nread_at(), RZ_LOG_ERROR, rz_num_math(), and val.

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_hex_diff_lines_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_hex_diff_lines_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 194 of file cmd_cmp.c.

                                                                                                {
    ut32 oflags = core->print->flags;
    core->print->flags |= RZ_PRINT_FLAGS_DIFFOUT;
    ut64 addr = rz_num_math(core->num, argv[1]);
    bool col = core->cons->columns > 123;
    ut8 *b = malloc(core->blocksize);
    if (b) {
        memset(b, 0xff, core->blocksize);
        rz_io_nread_at(core->io, addr, b, core->blocksize);
        rz_core_print_hexdiff(core, core->offset, core->block, addr, b, core->blocksize, col);
    }
    free(b);
    core->print->flags = oflags;
    return RZ_CMD_STATUS_OK;
}

References addr, argv, b, rz_core_t::block, rz_core_t::blocksize, rz_cons_t::columns, rz_core_t::cons, rz_print_t::flags, free(), rz_core_t::io, malloc(), memset(), rz_core_t::num, rz_core_t::offset, rz_core_t::print, RZ_CMD_STATUS_OK, rz_core_print_hexdiff(), rz_io_nread_at(), rz_num_math(), RZ_PRINT_FLAGS_DIFFOUT, and ut64().

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_hexpair_string_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_hexpair_string_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 315 of file cmd_cmp.c.

                                                                                                                         {
    char *input = strdup(argv[1]);
    rz_str_remove_char(input, ' ');
    unsigned char *buf;
    int ret = false;
    if (!(buf = (ut8 *)malloc(strlen(input) + 1))) {
        goto return_goto;
    }
    ret = rz_hex_bin2str(core->block, strlen(input) / 2, (char *)buf);
    for (int i = 0; i < ret * 2; i++) {
        if (input[i] == '.') {
            input[i] = buf[i];
        }
    }
    ret = rz_hex_str2bin(input, buf);
    if (ret < 1) {
        RZ_LOG_ERROR("Cannot parse hexpair\n");
        ret = false;
        goto return_goto;
    }
    RzCompareData *cmp = rz_core_cmp_mem_data(core, core->offset, buf, strlen(input) / 2);
    if (!cmp) {
        goto return_goto;
    }
    core->num->value = cmp->same ? 0 : 1;
    int val = rz_core_cmp_print(core, cmp, state);
    rz_core_cmp_free(cmp);
    ret = val != -1;
 
return_goto:
    free(input);
    free(buf);
    return ret ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, rz_core_t::block, cmp(), free(), i, input(), malloc(), rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_cmp_free(), rz_core_cmp_mem_data(), rz_core_cmp_print(), rz_hex_bin2str(), rz_hex_str2bin(), RZ_LOG_ERROR, rz_str_remove_char(), strdup(), val, and rz_num_t::value.

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_list_compare_watchers_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_list_compare_watchers_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzOutputMode	mode
	)

Definition at line 294 of file cmd_cmp.c.

                                                                                                                          {
    rz_core_cmpwatch_show(core, UT64_MAX, mode);
    return RZ_CMD_STATUS_OK;
}

References RZ_CMD_STATUS_OK, rz_core_cmpwatch_show(), and UT64_MAX.

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_remove_watcher_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_remove_watcher_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 310 of file cmd_cmp.c.

                                                                                                {
    return rz_core_cmpwatch_del(core, core->offset) ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, and rz_core_cmpwatch_del().

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_reset_watcher_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_reset_watcher_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 300 of file cmd_cmp.c.

                                                                                               {
    return rz_core_cmpwatch_revert(core, core->offset) ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, and rz_core_cmpwatch_revert().

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_string_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_string_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 115 of file cmd_cmp.c.

                                                                                                                 {
    RzCmdStatus ret = RZ_CMD_STATUS_ERROR;
    char *unescaped = strdup(argv[1]);
    int len = rz_str_unescape(unescaped);
    RzCompareData *cmp = rz_core_cmp_mem_data(core, core->offset, (ut8 *)unescaped, len);
    if (!cmp) {
        goto end;
    }
    int val = rz_core_cmp_print(core, cmp, state);
    ret = val != -1 ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
 
end:
    rz_core_cmp_free(cmp);
    free(unescaped);
    return ret;
}

References argv, cmp(), test_evm::end, free(), len, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_cmp_free(), rz_core_cmp_mem_data(), rz_core_cmp_print(), rz_str_unescape(), strdup(), and val.

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_unified1_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_unified1_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 257 of file cmd_cmp.c.

                                                                                          {
    rizin_compare_words(core, core->offset, rz_num_math(core->num, argv[1]), core->blocksize, 1);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::blocksize, rz_core_t::num, rz_core_t::offset, rizin_compare_words(), RZ_CMD_STATUS_OK, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_unified2_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_unified2_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 263 of file cmd_cmp.c.

                                                                                          {
    rizin_compare_words(core, core->offset, rz_num_math(core->num, argv[1]), core->blocksize, 2);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::blocksize, rz_core_t::num, rz_core_t::offset, rizin_compare_words(), RZ_CMD_STATUS_OK, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_unified4_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_unified4_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 269 of file cmd_cmp.c.

                                                                                          {
    rizin_compare_words(core, core->offset, rz_num_math(core->num, argv[1]), core->blocksize, 4);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::blocksize, rz_core_t::num, rz_core_t::offset, rizin_compare_words(), RZ_CMD_STATUS_OK, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_unified8_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_unified8_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 275 of file cmd_cmp.c.

                                                                                          {
    rizin_compare_words(core, core->offset, rz_num_math(core->num, argv[1]), core->blocksize, 8);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::blocksize, rz_core_t::num, rz_core_t::offset, rizin_compare_words(), RZ_CMD_STATUS_OK, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_unified_disasm_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_unified_disasm_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 281 of file cmd_cmp.c.

                                                                                                {
    RzList *cmp = rz_core_cmp_disasm(core, core->offset, rz_num_math(core->num, argv[1]), core->blocksize);
    bool ret = rz_core_cmp_disasm_print(core, cmp, true);
    rz_list_free(cmp);
    return ret ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, rz_core_t::blocksize, cmp(), rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_cmp_disasm(), rz_core_cmp_disasm_print(), rz_list_free(), and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_unified_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_unified_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 249 of file cmd_cmp.c.

                                                                                         {
    RzCompareData *cmp = rz_core_cmp_mem_mem(core, core->offset, rz_num_math(core->num, argv[1]), core->blocksize);
    bool ret = rizin_compare_unified(core, cmp);
    rz_core_cmp_free(cmp);
    return ret ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, rz_core_t::blocksize, cmp(), rz_core_t::num, rz_core_t::offset, rizin_compare_unified(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_cmp_free(), rz_core_cmp_mem_mem(), and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_cmd_cmp_update_watcher_handler()

RZ_IPI RzCmdStatus rz_cmd_cmp_update_watcher_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 305 of file cmd_cmp.c.

                                                                                                {
    return rz_core_cmpwatch_update(core, core->offset) ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, and rz_core_cmpwatch_update().

Referenced by rzshell_cmddescs_init().