visual.c File Reference

#include <rz_core.h>
#include <rz_cons.h>
#include <rz_windows.h>
#include "../core_private.h"
#include "visual_tabs.inc"

Go to the source code of this file.

Classes
struct	Snow

Macros
#define	NPF   5
#define	PIDX   (RZ_ABS(core->printidx % NPF))
#define	KEY_ALTQ   0xc5
#define	CMD_REGISTERS   "?== true `e cfg.debug`; ?! dr=; ?? ar="
#define	CMD_REGISTERS_REFS   "?== true `e cfg.debug`; ?! drr; ?? arr"
#define	PRINT_HEX_FORMATS   10
#define	PRINT_3_FORMATS   2
#define	PRINT_4_FORMATS   7
#define	PRINT_5_FORMATS   8
#define	USE_THREADS   1
#define	OPDELTA   32
#define	I   core->cons
#define	I   core->cons

Functions
static void	visual_refresh (RzCore *core)
RZ_API void	rz_core_visual_applyHexMode (RzCore *core, int hexMode)
RZ_API void	rz_core_visual_toggle_hints (RzCore *core)
RZ_API void	rz_core_visual_toggle_decompiler_disasm (RzCore *core, bool for_graph, bool reset)
static void	setcursor (RzCore *core, bool cur)
RZ_API void	rz_core_visual_applyDisMode (RzCore *core, int disMode)
static void	nextPrintCommand (void)
static void	prevPrintCommand (void)
static const char *	stackPrintCommand (RzCore *core)
static const char *	__core_visual_print_command (RzCore *core)
static bool	__core_visual_gogo (RzCore *core, int ch)
static void	rotateAsmBits (RzCore *core)
static const char *	rotateAsmemu (RzCore *core)
RZ_API void	rz_core_visual_showcursor (RzCore *core, int x)
static void	printFormat (RzCore *core, const int next)
static void	nextPrintFormat (RzCore *core)
static void	prevPrintFormat (RzCore *core)
RZ_API bool	rz_core_visual_hud (RzCore *core)
RZ_API void	rz_core_visual_jump (RzCore *core, ut8 ch)
RZ_API void	rz_core_visual_append_help (RzStrBuf *p, const char *title, const char **help)
static int	visual_help (RzCore *core)
static void	prompt_read (const char *p, char *buf, int buflen)
static void	reset_print_cur (RzPrint *p)
static bool	__holdMouseState (RzCore *core)
static void	backup_current_addr (RzCore *core, ut64 *addr, ut64 *bsze, ut64 *newaddr, int *cur)
static void	restore_current_addr (RzCore *core, ut64 addr, ut64 bsze, ut64 newaddr, int cur)
RZ_API void	rz_core_visual_prompt_input (RzCore *core)
RZ_API int	rz_core_visual_prompt (RzCore *core)
static void	visual_breakpoint (RzCore *core)
static int	visual_nkey (RzCore *core, int ch)
static void	setdiff (RzCore *core)
static void	findPair (RzCore *core)
static void	findNextWord (RzCore *core)
static int	isSpace (char ch)
static void	findPrevWord (RzCore *core)
static void	visual_search (RzCore *core)
RZ_API void	rz_core_visual_show_char (RzCore *core, char ch)
static void	visual_seek_animation (RzCore *core, ut64 addr)
RZ_API void	rz_core_visual_seek_animation (RzCore *core, ut64 addr)
RZ_API void	rz_core_visual_seek_animation_redo (RzCore *core)
RZ_API void	rz_core_visual_seek_animation_undo (RzCore *core)
static void	setprintmode (RzCore *core, int n)
static ut64	prevop_addr (RzCore *core, ut64 addr)
RZ_API bool	rz_core_prevop_addr (RzCore *core, ut64 start_addr, int numinstrs, ut64 *prev_addr)
RZ_API ut64	rz_core_prevop_addr_force (RzCore *core, ut64 start_addr, int numinstrs)
static bool	fill_hist_offset (RzCore *core, RzLine *line, RzCoreSeekItem *csi)
RZ_API int	rz_line_hist_offset_up (RzLine *line)
RZ_API int	rz_line_hist_offset_down (RzLine *line)
RZ_API void	rz_core_visual_offset (RzCore *core)
RZ_API int	rz_core_visual_prevopsz (RzCore *core, ut64 addr)
static void	add_comment (RzCore *core, ut64 addr, const char *prompt)
static int	follow_ref (RzCore *core, RzList *xrefs, int choice, bool xref_to)
RZ_API int	rz_core_visual_xrefs (RzCore *core, bool xref_to, bool fcnInsteadOfAddr)
char *	getcommapath (RzCore *core)
static void	visual_comma (RzCore *core)
static bool	isDisasmPrint (int mode)
static void	cursor_ocur (RzCore *core, bool use_ocur)
static void	nextOpcode (RzCore *core)
static void	prevOpcode (RzCore *core)
static void	cursor_nextrow (RzCore *core, bool use_ocur)
static void	cursor_prevrow (RzCore *core, bool use_ocur)
static void	cursor_left (RzCore *core, bool use_ocur)
static void	cursor_right (RzCore *core, bool use_ocur)
static bool	fix_cursor (RzCore *core)
static bool	insert_mode_enabled (RzCore *core)
RZ_API void	rz_core_visual_browse (RzCore *core, const char *input)
static bool	isNumber (RzCore *core, int ch)
static void	numbuf_append (int ch)
static int	numbuf_pull (void)
static bool	canWrite (RzCore *core, ut64 addr)
RZ_API int	rz_core_visual_cmd (RzCore *core, const char *arg)
static void	visual_flagzone (RzCore *core)
RZ_API void	rz_core_visual_title (RzCore *core, int color)
static int	visual_responsive (RzCore *core)
RZ_API void	rz_core_print_scrollbar (RzCore *core)
RZ_API void	rz_core_print_scrollbar_bottom (RzCore *core)
static void	visual_refresh_oneshot (RzCore *core)
RZ_API void	rz_core_visual_disasm_up (RzCore *core, int *cols)
RZ_API void	rz_core_visual_disasm_down (RzCore *core, RzAsmOp *op, int *cols)
static bool	is_mintty (RzCons *cons)
static void	flush_stdin (void)
RZ_API int	rz_core_visual (RzCore *core, const char *input)
RZ_API RzListInfo *	rz_listinfo_new (const char *name, RzInterval pitv, RzInterval vitv, int perm, const char *extra)
RZ_API void	rz_listinfo_free (RzListInfo *info)

Variables
static int	obs = 0
static int	blocksize = 0
static bool	autoblocksize = true
static int	disMode = 0
static int	hexMode = 0
static int	printMode = 0
static int	color = 1
static int	debug = 1
static int	zoom = 0
static const char *	printfmtSingle [NPF]
static const char *	printfmtColumns [NPF]
static int	currentFormat = 0
static int	current0format = 0
static const char *	printHexFormats [PRINT_HEX_FORMATS]
static int	current3format = 0
static const char *	print3Formats [PRINT_3_FORMATS]
static int	current4format = 0
static const char *	print4Formats [PRINT_4_FORMATS]
static int	current5format = 0
static const char *	print5Formats [PRINT_5_FORMATS]
static const char *	help_visual []
static const char *	help_msg_visual []
static const char *	help_msg_visual_fn []
static bool	splitView = false
static ut64	splitPtr = UT64_MAX
static bool	__ime = false
static int	__nib = -1
static char	numbuf [32] = { 0 }
static int	numbuf_i = 0

Macro Definition Documentation

CMD_REGISTERS

#define CMD_REGISTERS   "?== true `e cfg.debug`; ?! dr=; ?? ar="

Definition at line 31 of file visual.c.

CMD_REGISTERS_REFS

#define CMD_REGISTERS_REFS   "?== true `e cfg.debug`; ?! drr; ?? arr"

Definition at line 32 of file visual.c.

I [1/2]

#define I   core->cons

I [2/2]

#define I   core->cons

KEY_ALTQ

#define KEY_ALTQ   0xc5

Definition at line 29 of file visual.c.

NPF

#define NPF   5

Definition at line 9 of file visual.c.

OPDELTA

#define OPDELTA   32

Definition at line 1110 of file visual.c.

PIDX

#define PIDX   (RZ_ABS(core->printidx % NPF))

Definition at line 10 of file visual.c.

PRINT_3_FORMATS

#define PRINT_3_FORMATS   2

Definition at line 52 of file visual.c.

PRINT_4_FORMATS

#define PRINT_4_FORMATS   7

Definition at line 53 of file visual.c.

PRINT_5_FORMATS

#define PRINT_5_FORMATS   8

Definition at line 54 of file visual.c.

PRINT_HEX_FORMATS

#define PRINT_HEX_FORMATS   10

Definition at line 51 of file visual.c.

USE_THREADS

#define USE_THREADS   1

Definition at line 384 of file visual.c.

Function Documentation

__core_visual_gogo()

static bool __core_visual_gogo ( RzCore *  core, int  ch  )

static

Definition at line 261 of file visual.c.

                                                     {
    RzIOMap *map;
    switch (ch) {
    case 'g':
        if (core->io->va) {
            RzIOMap *map = rz_io_map_get(core->io, core->offset);
            RzPVector *maps = rz_io_maps(core->io);
            if (!map && !rz_pvector_empty(maps)) {
                map = rz_pvector_at(maps, rz_pvector_len(maps) - 1);
            }
            if (map) {
                rz_core_seek_and_save(core, rz_itv_begin(map->itv), true);
            }
        } else {
            rz_core_seek_and_save(core, 0, true);
        }
        return true;
    case 'G': {
        map = rz_io_map_get(core->io, core->offset);
        RzPVector *maps = rz_io_maps(core->io);
        if (!map && !rz_pvector_empty(maps)) {
            map = rz_pvector_at(maps, 0);
        }
        if (map) {
            RzPrint *p = core->print;
            int scr_rows;
            if (!p->consbind.get_size) {
                break;
            }
            (void)p->consbind.get_size(&scr_rows);
            ut64 scols = rz_config_get_i(core->config, "hex.cols");
            rz_core_seek_and_save(core, rz_itv_end(map->itv) - (scr_rows - 2) * scols, true);
        }
        return true;
    }
    }
    return false;
}

References rz_core_t::config, rz_core_t::io, map(), maps(), rz_core_t::offset, p, rz_core_t::print, rz_config_get_i(), rz_core_seek_and_save(), rz_io_map_get(), rz_io_maps(), rz_itv_begin(), rz_itv_end(), rz_pvector_at(), rz_pvector_empty(), rz_pvector_len(), ut64(), and rz_io_t::va.

Referenced by rz_core_visual_cmd(), and rz_core_visual_offset().

__core_visual_print_command()

static const char* __core_visual_print_command ( RzCore *  core )

static

Definition at line 246 of file visual.c.

                                                             {
    if (core->visual.tabs) {
        RzCoreVisualTab *tab = rz_list_get_n(core->visual.tabs, core->visual.tab);
        if (tab && tab->name[0] == ':') {
            return tab->name + 1;
        }
    }
    if (rz_config_get_i(core->config, "scr.dumpcols")) {
        free(core->stkcmd);
        core->stkcmd = rz_str_new(stackPrintCommand(core));
        return printfmtColumns[PIDX];
    }
    return printfmtSingle[PIDX];
}

References rz_core_t::config, free(), PIDX, printfmtColumns, printfmtSingle, rz_config_get_i(), rz_list_get_n(), rz_str_new(), stackPrintCommand(), rz_core_t::stkcmd, rz_core_visual_t::tab, rz_core_visual_t::tabs, and rz_core_t::visual.

Referenced by rz_core_visual_cmd(), rz_core_visual_title(), and visual_refresh().

__holdMouseState()

static bool __holdMouseState ( RzCore *  core )

static

Definition at line 678 of file visual.c.

                                           {
    bool m = rz_cons_singleton()->mouse;
    rz_cons_enable_mouse(false);
    return m;
}

References regress::m, rz_cons_t::mouse, rz_cons_enable_mouse(), and rz_cons_singleton().

Referenced by rz_core_visual_cmd(), rz_core_visual_prompt_input(), and visual_comma().

add_comment()

static void add_comment ( RzCore *  core, ut64  addr, const char *  prompt  )

static

Definition at line 1277 of file visual.c.

                                                                     {
    char buf[1024];
    rz_cons_print(prompt);
    rz_core_visual_showcursor(core, true);
    rz_cons_flush();
    rz_cons_set_raw(false);
    rz_line_set_prompt(":> ");
    rz_cons_enable_mouse(false);
    if (rz_cons_fgets(buf, sizeof(buf), 0, NULL) < 0) {
        buf[0] = '\0';
    }
    if (!strcmp(buf, "-")) {
        rz_meta_del(core->analysis, RZ_META_TYPE_COMMENT, addr, 1);
    } else if (!strcmp(buf, "!")) {
        rz_core_meta_editor(core, RZ_META_TYPE_COMMENT, addr);
    } else {
        rz_core_meta_append(core, buf, RZ_META_TYPE_COMMENT, addr);
    }
    rz_core_visual_showcursor(core, false);
    rz_cons_set_raw(true);
}

References addr, rz_core_t::analysis, NULL, prompt(), rz_cons_enable_mouse(), rz_cons_fgets(), rz_cons_flush(), rz_cons_set_raw(), rz_core_meta_append(), rz_core_meta_editor(), rz_core_visual_showcursor(), rz_line_set_prompt(), rz_meta_del(), and RZ_META_TYPE_COMMENT.

Referenced by rz_core_visual_cmd(), and rz_core_visual_xrefs().

backup_current_addr()

static void backup_current_addr ( RzCore *  core, ut64 *  addr, ut64 *  bsze, ut64 *  newaddr, int *  cur  )

static

Definition at line 684 of file visual.c.

                                                                                               {
    *addr = core->offset;
    *bsze = core->blocksize;
    *cur = core->print->cur_enabled ? core->print->cur : 0;
    if (core->print->cur_enabled) {
        if (core->print->ocur != -1) {
            int newsz = core->print->cur - core->print->ocur;
            *newaddr = core->offset + core->print->ocur;
            rz_core_block_size(core, newsz);
        } else {
            *newaddr = core->offset + core->print->cur;
        }
        rz_core_seek(core, *newaddr, true);
        core->print->cur = 0;
    }
}

References addr, rz_core_t::blocksize, rz_print_t::cur, rz_print_t::cur_enabled, rz_print_t::ocur, rz_core_t::offset, rz_core_t::print, rz_core_block_size(), and rz_core_seek().

Referenced by rz_core_visual_prompt_input().

canWrite()

static bool canWrite ( RzCore *  core, ut64  addr  )

static

Definition at line 2224 of file visual.c.

                                              {
    if (rz_config_get_b(core->config, "io.cache")) {
        return true;
    }
    RzIOMap *map = rz_io_map_get(core->io, addr);
    return (map && (map->perm & RZ_PERM_W));
}

References addr, rz_core_t::config, rz_core_t::io, map(), rz_config_get_b(), rz_io_map_get(), and RZ_PERM_W.

Referenced by rz_core_visual_cmd().

cursor_left()

static void cursor_left ( RzCore *  core, bool  use_ocur  )

static

Definition at line 1875 of file visual.c.

                                                     {
    if (PIDX == 2) {
        if (core->seltab == 1) {
            core->print->cur--;
            return;
        }
    }
    cursor_ocur(core, use_ocur);
    core->print->cur--;
}

References rz_print_t::cur, cursor_ocur(), PIDX, rz_core_t::print, and rz_core_t::seltab.

Referenced by rz_core_visual_cmd().

cursor_nextrow()

static void cursor_nextrow ( RzCore *  core, bool  use_ocur  )

static

Definition at line 1704 of file visual.c.

                                                        {
    RzPrint *p = core->print;
    ut32 roff, next_roff;
    int row, sz, delta;
    RzAsmOp op;
 
    cursor_ocur(core, use_ocur);
    if (PIDX == 1) { // DISASM
        nextOpcode(core);
        return;
    }
 
    if (PIDX == 7 || !strcmp("prc", rz_config_get(core->config, "cmd.visual"))) {
        p->cur += rz_config_get_i(core->config, "hex.cols");
        return;
    }
    if (splitView) {
        int w = rz_config_get_i(core->config, "hex.cols");
        if (w < 1) {
            w = 16;
        }
        if (core->seltab == 0) {
            splitPtr += w;
        } else {
            core->offset += w;
        }
        return;
    }
    if (PIDX == RZ_CORE_VISUAL_MODE_DB) {
        const int cols = core->dbg->regcols;
        int w = rz_config_get_i(core->config, "hex.cols");
        switch (core->seltab) {
        case 0:
            if (w < 1) {
                w = 16;
            }
            rz_config_set_i(core->config, "stack.delta",
                rz_config_get_i(core->config, "stack.delta") - w);
            return;
        case 1:
            p->cur += cols > 0 ? cols : 3;
            return;
        default:
            nextOpcode(core);
            return;
        }
    }
    if (p->row_offsets) {
        // FIXME: cache the current row
        row = rz_print_row_at_off(p, p->cur);
        roff = rz_print_rowoff(p, row);
        if (roff == -1) {
            p->cur++;
            return;
        }
        next_roff = rz_print_rowoff(p, row + 1);
        if (next_roff == UT32_MAX) {
            p->cur++;
            return;
        }
        if (next_roff > core->blocksize) {
            p->cur += 32; // XXX workaround to "fix" cursor nextrow far away scrolling issue
            return;
        }
        if (next_roff + 32 < core->blocksize) {
            sz = rz_asm_disassemble(core->rasm, &op,
                core->block + next_roff, 32);
            if (sz < 1) {
                sz = 1;
            }
        } else {
            sz = 1;
        }
        delta = p->cur - roff;
        p->cur = next_roff + RZ_MIN(delta, sz - 1);
    } else {
        p->cur += RZ_MAX(1, p->cols);
    }
}

References rz_core_t::block, rz_core_t::blocksize, rz_core_t::config, cursor_ocur(), rz_core_t::dbg, delta, nextOpcode(), rz_core_t::offset, op, p, PIDX, rz_core_t::print, rz_core_t::rasm, rz_debug_t::regcols, rz_asm_disassemble(), rz_config_get(), rz_config_get_i(), rz_config_set_i(), RZ_CORE_VISUAL_MODE_DB, RZ_MAX, RZ_MIN, rz_print_row_at_off(), rz_print_rowoff(), rz_core_t::seltab, splitPtr, splitView, UT32_MAX, and w.

Referenced by insert_mode_enabled(), and rz_core_visual_cmd().

cursor_ocur()

static void cursor_ocur ( RzCore *  core, bool  use_ocur  )

static

Definition at line 1673 of file visual.c.

                                                     {
    RzPrint *p = core->print;
    if (use_ocur && p->ocur == -1) {
        p->ocur = p->cur;
    } else if (!use_ocur) {
        p->ocur = -1;
    }
}

References p, and rz_core_t::print.

Referenced by cursor_left(), cursor_nextrow(), cursor_prevrow(), and cursor_right().

cursor_prevrow()

static void cursor_prevrow ( RzCore *  core, bool  use_ocur  )

static

Definition at line 1784 of file visual.c.

                                                        {
    RzPrint *p = core->print;
    ut32 roff, prev_roff;
    int row;
 
    cursor_ocur(core, use_ocur);
    if (PIDX == 1) { // DISASM
        prevOpcode(core);
        return;
    }
 
    if (PIDX == 7 || !strcmp("prc", rz_config_get(core->config, "cmd.visual"))) {
        int cols = rz_config_get_i(core->config, "hex.cols");
        p->cur -= RZ_MAX(cols, 0);
        return;
    }
 
    if (splitView) {
        int w = rz_config_get_i(core->config, "hex.cols");
        if (w < 1) {
            w = 16;
        }
        if (core->seltab == 0) {
            splitPtr -= w;
        } else {
            core->offset -= w;
        }
        return;
    }
    if (PIDX == RZ_CORE_VISUAL_MODE_DB) {
        switch (core->seltab) {
        case 0: {
            int w = rz_config_get_i(core->config, "hex.cols");
            if (w < 1) {
                w = 16;
            }
            rz_config_set_i(core->config, "stack.delta",
                rz_config_get_i(core->config, "stack.delta") + w);
        }
            return;
        case 1: {
            const int cols = core->dbg->regcols;
            p->cur -= cols > 0 ? cols : 4;
            return;
        }
        default:
            prevOpcode(core);
            return;
        }
    }
    if (p->row_offsets) {
        int delta, prev_sz;
 
        // FIXME: cache the current row
        row = rz_print_row_at_off(p, p->cur);
        roff = rz_print_rowoff(p, row);
        if (roff == UT32_MAX) {
            p->cur--;
            return;
        }
        prev_roff = row > 0 ? rz_print_rowoff(p, row - 1) : UT32_MAX;
        delta = p->cur - roff;
        if (prev_roff == UT32_MAX) {
            ut64 prev_addr = prevop_addr(core, core->offset + roff);
            if (prev_addr > core->offset) {
                prev_roff = 0;
                prev_sz = 1;
            } else {
                RzAsmOp op;
                prev_roff = 0;
                rz_core_seek(core, prev_addr, true);
                prev_sz = rz_asm_disassemble(core->rasm, &op,
                    core->block, 32);
            }
        } else {
            prev_sz = roff - prev_roff;
        }
        int res = RZ_MIN(delta, prev_sz - 1);
        ut64 cur = prev_roff + res;
        if (cur == p->cur) {
            if (p->cur > 0) {
                p->cur--;
            }
        } else {
            p->cur = prev_roff + delta; // res;
        }
    } else {
        p->cur -= p->cols;
    }
}

References rz_core_t::block, rz_core_t::config, cursor_ocur(), rz_core_t::dbg, delta, rz_core_t::offset, op, p, PIDX, prevop_addr(), prevOpcode(), rz_core_t::print, rz_core_t::rasm, rz_debug_t::regcols, rz_asm_disassemble(), rz_config_get(), rz_config_get_i(), rz_config_set_i(), rz_core_seek(), RZ_CORE_VISUAL_MODE_DB, RZ_MAX, RZ_MIN, rz_print_row_at_off(), rz_print_rowoff(), rz_core_t::seltab, splitPtr, splitView, UT32_MAX, ut64(), and w.

Referenced by insert_mode_enabled(), and rz_core_visual_cmd().

cursor_right()

static void cursor_right ( RzCore *  core, bool  use_ocur  )

static

Definition at line 1886 of file visual.c.

                                                      {
    if (PIDX == 2) {
        if (core->seltab == 1) {
            core->print->cur++;
            return;
        }
    }
    cursor_ocur(core, use_ocur);
    core->print->cur++;
}

References rz_print_t::cur, cursor_ocur(), PIDX, rz_core_t::print, and rz_core_t::seltab.

Referenced by rz_core_visual_cmd().

fill_hist_offset()

static bool fill_hist_offset ( RzCore *  core, RzLine *  line, RzCoreSeekItem *  csi  )

static

Definition at line 1203 of file visual.c.

                                                                              {
    ut64 off = csi->offset;
    RzFlagItem *f = rz_flag_get_at(core->flags, off, false);
    char *command = NULL;
    if (f && f->offset == off && f->offset > 0) {
        command = rz_str_newf("%s", f->name);
    } else {
        command = rz_str_newf("0x%" PFMT64x, off);
    }
    if (!command) {
        return false;
    }
 
    strncpy(line->buffer.data, command, RZ_LINE_BUFSIZE - 1);
    line->buffer.index = line->buffer.length = strlen(line->buffer.data);
    free(command);
    return true;
}

References command, f, rz_core_t::flags, free(), setup::line, NULL, off, rz_core_seek_undo_t::offset, PFMT64x, rz_flag_get_at(), RZ_LINE_BUFSIZE, rz_str_newf(), and ut64().

Referenced by rz_line_hist_offset_down(), and rz_line_hist_offset_up().

findNextWord()

static void findNextWord ( RzCore *  core )

static

Definition at line 946 of file visual.c.

                                       {
    int i, d = core->print->cur_enabled ? core->print->cur : 0;
    for (i = d + 1; i < core->blocksize; i++) {
        switch (core->block[i]) {
        case ' ':
        case '.':
        case '\t':
        case '\n':
            if (core->print->cur_enabled) {
                core->print->cur = i + 1;
                core->print->ocur = -1;
                rz_core_visual_showcursor(core, true);
            } else {
                rz_core_seek_and_save(core, core->offset + i + 1, true);
            }
            return;
        }
    }
}

References rz_core_t::block, rz_core_t::blocksize, rz_print_t::cur, rz_print_t::cur_enabled, d, i, rz_print_t::ocur, rz_core_t::offset, rz_core_t::print, rz_core_seek_and_save(), and rz_core_visual_showcursor().

Referenced by rz_core_visual_cmd().

findPair()

static void findPair ( RzCore *  core )

static

Definition at line 904 of file visual.c.

                                   {
    ut8 buf[256];
    int i, len, d = core->print->cur + 1;
    int delta = 0;
    const ut8 *p, *q = NULL;
    const char *keys = "{}[]()<>";
    ut8 ch = core->block[core->print->cur];
 
    p = (const ut8 *)strchr(keys, ch);
    if (p) {
        char p_1 = 0;
        if ((const char *)p > keys) {
            p_1 = p[-1];
        }
        delta = (size_t)(p - (const ut8 *)keys);
        ch = (delta % 2 && p != (const ut8 *)keys) ? p_1 : p[1];
    }
    len = 1;
    buf[0] = ch;
 
    if (p && (delta % 2)) {
        for (i = d - 1; i >= 0; i--) {
            if (core->block[i] == ch) {
                q = core->block + i;
                break;
            }
        }
    } else {
        q = rz_mem_mem(core->block + d, core->blocksize - d,
            (const ut8 *)buf, len);
        if (!q) {
            q = rz_mem_mem(core->block, RZ_MIN(core->blocksize, d),
                (const ut8 *)buf, len);
        }
    }
    if (q) {
        core->print->cur = (int)(size_t)(q - core->block);
        core->print->ocur = -1;
        rz_core_visual_showcursor(core, true);
    }
}

References rz_core_t::block, rz_core_t::blocksize, rz_print_t::cur, d, delta, i, int, keys, len, NULL, rz_print_t::ocur, p, rz_core_t::print, rz_core_visual_showcursor(), rz_mem_mem(), and RZ_MIN.

Referenced by rz_core_visual_cmd().

findPrevWord()

static void findPrevWord ( RzCore *  core )

static

Definition at line 978 of file visual.c.

                                       {
    int i = core->print->cur_enabled ? core->print->cur : 0;
    while (i > 1) {
        if (isSpace(core->block[i])) {
            i--;
        } else if (isSpace(core->block[i - 1])) {
            i -= 2;
        } else {
            break;
        }
    }
    for (; i >= 0; i--) {
        if (isSpace(core->block[i])) {
            if (core->print->cur_enabled) {
                core->print->cur = i + 1;
                core->print->ocur = -1;
                rz_core_visual_showcursor(core, true);
            }
            break;
        }
    }
}

References rz_core_t::block, rz_print_t::cur, rz_print_t::cur_enabled, i, isSpace(), rz_print_t::ocur, rz_core_t::print, and rz_core_visual_showcursor().

Referenced by rz_core_visual_cmd().

fix_cursor()

static bool fix_cursor ( RzCore *  core )

static

Definition at line 1897 of file visual.c.

                                     {
    RzPrint *p = core->print;
    int offscreen = (core->cons->rows - 3) * p->cols;
    bool res = false;
 
    if (!core->print->cur_enabled) {
        return false;
    }
    if (core->print->screen_bounds > 1) {
        bool off_is_visible = core->offset < core->print->screen_bounds;
        bool cur_is_visible = core->offset + p->cur < core->print->screen_bounds;
        bool is_close = core->offset + p->cur < core->print->screen_bounds + 32;
 
        if ((!cur_is_visible && !is_close) || (!cur_is_visible && p->cur == 0)) {
            // when the cursor is not visible and it's far from the
            // last visible byte, just seek there.
            rz_core_seek_delta(core, p->cur, false);
            reset_print_cur(p);
        } else if ((!cur_is_visible && is_close) || !off_is_visible) {
            RzAsmOp op;
            int sz = rz_asm_disassemble(core->rasm,
                &op, core->block, 32);
            if (sz < 1) {
                sz = 1;
            }
            rz_core_seek_delta(core, sz, false);
            p->cur = RZ_MAX(p->cur - sz, 0);
            if (p->ocur != -1) {
                p->ocur = RZ_MAX(p->ocur - sz, 0);
            }
            res |= off_is_visible;
        }
    } else if (core->print->cur >= offscreen) {
        rz_core_seek(core, core->offset + p->cols, true);
        p->cur -= p->cols;
        if (p->ocur != -1) {
            p->ocur -= p->cols;
        }
    }
 
    if (p->cur < 0) {
        int sz = p->cols;
        if (isDisasmPrint(core->printidx)) {
            sz = rz_core_visual_prevopsz(core, core->offset + p->cur);
            if (sz < 1) {
                sz = 1;
            }
        }
        rz_core_seek_delta(core, -sz, false);
        p->cur += sz;
        if (p->ocur != -1) {
            p->ocur += sz;
        }
    }
    return res;
}

References rz_core_t::block, rz_core_t::cons, rz_print_t::cur, rz_print_t::cur_enabled, if(), isDisasmPrint(), rz_core_t::offset, op, p, rz_core_t::print, rz_core_t::printidx, rz_core_t::rasm, reset_print_cur(), rz_cons_t::rows, rz_asm_disassemble(), rz_core_seek(), rz_core_seek_delta(), rz_core_visual_prevopsz(), RZ_MAX, and rz_print_t::screen_bounds.

Referenced by rz_core_visual().

flush_stdin()

static void flush_stdin ( void  )

static

Definition at line 3850 of file visual.c.

                              {
    tcflush(STDIN_FILENO, TCIFLUSH);
}

References STDIN_FILENO, and TCIFLUSH.

Referenced by rz_core_visual().

follow_ref()

static int follow_ref ( RzCore *  core, RzList *  xrefs, int  choice, bool  xref_to  )

static

Definition at line 1299 of file visual.c.

                                                                             {
    RzAnalysisXRef *xrefi = rz_list_get_n(xrefs, choice);
    if (xrefi) {
        if (core->print->cur_enabled) {
            core->print->cur = 0;
        }
        ut64 addr = xref_to ? xrefi->from : xrefi->to;
        rz_core_seek_and_save(core, addr, true);
        return 1;
    }
    return 0;
}

References addr, rz_print_t::cur, rz_print_t::cur_enabled, rz_analysis_ref_t::from, rz_core_t::print, rz_core_seek_and_save(), rz_list_get_n(), rz_analysis_ref_t::to, and ut64().

Referenced by rz_core_visual_xrefs().

getcommapath()

char* getcommapath

(

RzCore *

core

)

Definition at line 1607 of file visual.c.

                                 {
    char *cwd;
    const char *dir = rz_config_get(core->config, "dir.projects");
    const char *prj = rz_config_get(core->config, "prj.name");
    if (dir && *dir && prj && *prj) {
        char *abspath = rz_file_abspath(dir);
        /* use prjdir as base directory for comma-ent files */
        cwd = rz_str_newf("%s" RZ_SYS_DIR "%s.d", abspath, prj);
        free(abspath);
    } else {
        /* use cwd as base directory for comma-ent files */
        cwd = rz_sys_getdir();
    }
    return cwd;
}

References rz_core_t::config, test-lz4-speed::cwd, free(), rz_config_get(), rz_file_abspath(), rz_str_newf(), RZ_SYS_DIR, and rz_sys_getdir().

Referenced by rz_comment_filelink_handler(), and visual_comma().

insert_mode_enabled()

static bool insert_mode_enabled ( RzCore *  core )

static

Definition at line 1957 of file visual.c.

                                              {
    if (!__ime) {
        return false;
    }
    char ch = (ut8)rz_cons_readchar();
    if ((ut8)ch == KEY_ALTQ) {
        (void)rz_cons_readchar();
        __ime = false;
        return true;
    }
    char arrows = rz_cons_arrow_to_hjkl(ch);
    switch (ch) {
    case 127:
        core->print->cur = RZ_MAX(0, core->print->cur - 1);
        return true;
    case 9: // tab "tab" TAB
        core->print->col = core->print->col == 1 ? 2 : 1;
        break;
    }
    if (ch != 'h' && arrows == 'h') {
        core->print->cur = RZ_MAX(0, core->print->cur - 1);
        return true;
    } else if (ch != 'l' && arrows == 'l') {
        core->print->cur = core->print->cur + 1;
        return true;
    } else if (ch != 'j' && arrows == 'j') {
        cursor_nextrow(core, false);
        return true;
    } else if (ch != 'k' && arrows == 'k') {
        cursor_prevrow(core, false);
        return true;
    }
    if (core->print->col == 2) {
        /* ascii column */
        if (IS_PRINTABLE(ch)) {
            ut8 chs[2] = { ch, 0 };
            if (rz_core_write_at(core, core->offset + core->print->cur, chs, 1)) {
                core->print->cur++;
            }
        }
        return true;
    }
    ch = arrows;
    /* hex column */
    switch (ch) {
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    case 'a':
    case 'b':
    case 'c':
    case 'd':
    case 'e':
    case 'f':
        if (__nib != -1) {
            char hexpair[3] = { __nib, ch, 0 };
            rz_core_write_hexpair(core, core->offset + core->print->cur, hexpair);
            core->print->cur++;
            __nib = -1;
        } else {
            __nib = ch;
        }
        break;
    case 'r': // "r -1"
        rz_core_file_resize_delta(core, -1);
        break;
    case 'R': // "r +1"
        rz_core_file_resize_delta(core, +1);
        break;
    case 'h':
        core->print->cur = RZ_MAX(0, core->print->cur - 1);
        break;
    case 'l':
        core->print->cur = core->print->cur + 1;
        break;
    case 'j':
        cursor_nextrow(core, false);
        break;
    case 'k':
        cursor_prevrow(core, false);
        break;
    case 'Q':
    case 'q':
        __ime = false;
        break;
    case '?':
        rz_cons_less_str("\nVisual Insert Mode:\n\n"
                 " tab          - toggle between ascii and hex columns\n"
                 " q (or alt-q) - quit insert mode\n"
                 "\nHex column:\n"
                 " r            - remove byte in cursor\n"
                 " R            - insert byte in cursor\n"
                 " [0-9a-f]     - insert hexpairs in hex column\n"
                 " hjkl         - move around\n"
                 "\nAscii column:\n"
                 " arrows       - move around\n"
                 " alt-q        - quit insert mode\n",
            "?");
        break;
    }
    return true;
}

References __ime, __nib, rz_print_t::col, rz_print_t::cur, cursor_nextrow(), cursor_prevrow(), IS_PRINTABLE, KEY_ALTQ, rz_core_t::offset, rz_core_t::print, rz_cons_arrow_to_hjkl(), rz_cons_less_str(), rz_cons_readchar(), rz_core_file_resize_delta(), rz_core_write_at(), rz_core_write_hexpair(), RZ_MAX, and ut8.

Referenced by rz_core_visual().

is_mintty()

static bool is_mintty ( RzCons *  cons )

static

Definition at line 3846 of file visual.c.

                                    {
    return false;
}

Referenced by rz_core_visual().

isDisasmPrint()

static bool isDisasmPrint ( int  mode )

static

Definition at line 1669 of file visual.c.

                                    {
    return (mode == RZ_CORE_VISUAL_MODE_PD || mode == RZ_CORE_VISUAL_MODE_DB);
}

References RZ_CORE_VISUAL_MODE_DB, and RZ_CORE_VISUAL_MODE_PD.

Referenced by fix_cursor(), and rz_core_visual_cmd().

isNumber()

static bool isNumber ( RzCore *  core, int  ch  )

static

Definition at line 2190 of file visual.c.

                                           {
    if (ch > '0' && ch <= '9') {
        return true;
    }
    if (core->print->cur_enabled) {
        return ch == '0';
    }
    return false;
}

References rz_print_t::cur_enabled, and rz_core_t::print.

Referenced by rz_core_visual_cmd().

isSpace()

static int isSpace ( char  ch )

static

Definition at line 966 of file visual.c.

                            {
    switch (ch) {
    case ' ':
    case '.':
    case ',':
    case '\t':
    case '\n':
        return 1;
    }
    return 0;
}

Referenced by findNextNumber(), and findPrevWord().

nextOpcode()

static void nextOpcode ( RzCore *  core )

static

Definition at line 1682 of file visual.c.

                                     {
    RzAnalysisOp *aop = rz_core_analysis_op(core, core->offset + core->print->cur, RZ_ANALYSIS_OP_MASK_BASIC);
    RzPrint *p = core->print;
    if (aop) {
        p->cur += aop->size;
        rz_analysis_op_free(aop);
    } else {
        p->cur += 4;
    }
}

References rz_print_t::cur, rz_core_t::offset, p, rz_core_t::print, rz_analysis_op_free(), RZ_ANALYSIS_OP_MASK_BASIC, rz_core_analysis_op(), and rz_analysis_op_t::size.

Referenced by cursor_nextrow().

nextPrintCommand()

static void nextPrintCommand ( void  )

static

Definition at line 215 of file visual.c.

                                   {
    current0format++;
    current0format %= PRINT_HEX_FORMATS;
    currentFormat = current0format;
}

References current0format, currentFormat, and PRINT_HEX_FORMATS.

Referenced by rz_core_visual_cmd().

nextPrintFormat()

static void nextPrintFormat ( RzCore *  core )

inlinestatic

Definition at line 463 of file visual.c.

                                                 {
    printFormat(core, 1);
}

References printFormat().

Referenced by rz_core_visual_cmd().

numbuf_append()

static void numbuf_append ( int  ch )

static

Definition at line 2203 of file visual.c.

                                  {
    if (numbuf_i >= sizeof(numbuf) - 1) {
        numbuf_i = 0;
    }
    numbuf[numbuf_i++] = ch;
    numbuf[numbuf_i] = 0;
}

References numbuf, and numbuf_i.

Referenced by rz_core_visual_cmd().

numbuf_pull()

static int numbuf_pull ( void  )

static

Definition at line 2211 of file visual.c.

                             {
    int distance = 1;
    if (numbuf_i) {
        numbuf[numbuf_i] = 0;
        distance = atoi(numbuf);
        if (!distance) {
            distance = 1;
        }
        numbuf_i = 0;
    }
    return distance;
}

References numbuf, and numbuf_i.

Referenced by rz_core_visual_cmd().

prevop_addr()

static ut64 prevop_addr ( RzCore *  core, ut64  addr  )

static

Definition at line 1111 of file visual.c.

                                                 {
    ut8 buf[OPDELTA * 2];
    ut64 target, base;
    RzAnalysisBlock *bb;
    RzAnalysisOp op;
    int len, ret, i;
    int minop = rz_analysis_archinfo(core->analysis, RZ_ANALYSIS_ARCHINFO_MIN_OP_SIZE);
    int maxop = rz_analysis_archinfo(core->analysis, RZ_ANALYSIS_ARCHINFO_MAX_OP_SIZE);
 
    if (minop == maxop) {
        if (minop == -1) {
            return addr - 4;
        }
        return addr - minop;
    }
 
    // let's see if we can use analysis info to get the previous instruction
    // TODO: look in the current basicblock, then in the current function
    // and search in all functions only as a last chance, to try to speed
    // up the process.
    bb = rz_analysis_find_most_relevant_block_in(core->analysis, addr - minop);
    if (bb) {
        ut64 res = rz_analysis_block_get_op_addr_in(bb, addr - minop);
        if (res != UT64_MAX) {
            return res;
        }
    }
    // if we analysis info didn't help then fallback to the dumb solution.
    int midflags = rz_config_get_i(core->config, "asm.flags.middle");
    target = addr;
    base = target > OPDELTA ? target - OPDELTA : 0;
    rz_io_read_at(core->io, base, buf, sizeof(buf));
    for (i = 0; i < sizeof(buf); i++) {
        ret = rz_analysis_op(core->analysis, &op, base + i,
            buf + i, sizeof(buf) - i, RZ_ANALYSIS_OP_MASK_BASIC);
        if (ret > 0) {
            len = op.size;
            if (len < 1) {
                len = 1;
            }
            rz_analysis_op_fini(&op); // XXX
            if (midflags >= RZ_MIDFLAGS_REALIGN) {
                int skip_bytes = rz_core_flag_in_middle(core, base + i, len, &midflags);
                if (skip_bytes && base + i + skip_bytes < target) {
                    i += skip_bytes - 1;
                    continue;
                }
            }
        } else {
            len = 1;
        }
        if (target <= base + i + len) {
            return base + i;
        }
        i += len - 1;
    }
    return target > 4 ? target - 4 : 0;
}

References addr, rz_core_t::analysis, rz_core_t::config, i, rz_core_t::io, len, op, OPDELTA, rz_analysis_archinfo(), RZ_ANALYSIS_ARCHINFO_MAX_OP_SIZE, RZ_ANALYSIS_ARCHINFO_MIN_OP_SIZE, rz_analysis_block_get_op_addr_in(), rz_analysis_find_most_relevant_block_in(), rz_analysis_op(), rz_analysis_op_fini(), RZ_ANALYSIS_OP_MASK_BASIC, rz_config_get_i(), rz_core_flag_in_middle(), rz_io_read_at(), ut64(), and UT64_MAX.

Referenced by cursor_prevrow(), rz_core_prevop_addr(), rz_core_prevop_addr_force(), and rz_core_visual_prevopsz().

prevOpcode()

static void prevOpcode ( RzCore *  core )

static

Definition at line 1693 of file visual.c.

                                     {
    RzPrint *p = core->print;
    ut64 addr, oaddr = core->offset + core->print->cur;
    if (rz_core_prevop_addr(core, oaddr, 1, &addr)) {
        const int delta = oaddr - addr;
        p->cur -= delta;
    } else {
        p->cur -= 4;
    }
}

References addr, rz_print_t::cur, delta, rz_core_t::offset, p, rz_core_t::print, rz_core_prevop_addr(), and ut64().

Referenced by cursor_prevrow().

prevPrintCommand()

static void prevPrintCommand ( void  )

static

Definition at line 221 of file visual.c.

                                   {
    current0format--;
    if (current0format < 0) {
        current0format = 0;
    }
    currentFormat = current0format;
}

References current0format, and currentFormat.

Referenced by rz_core_visual_cmd().

prevPrintFormat()

static void prevPrintFormat ( RzCore *  core )

inlinestatic

Definition at line 467 of file visual.c.

                                                 {
    printFormat(core, -1);
}

References printFormat().

Referenced by rz_core_visual_cmd().

printFormat()

static void printFormat ( RzCore *  core, const int  next  )

static

Definition at line 430 of file visual.c.

                                                      {
    switch (core->printidx) {
    case RZ_CORE_VISUAL_MODE_PX: // 0 // xc
        hexMode += next;
        rz_core_visual_applyHexMode(core, hexMode);
        printfmtSingle[0] = printHexFormats[RZ_ABS(hexMode) % PRINT_HEX_FORMATS];
        break;
    case RZ_CORE_VISUAL_MODE_PD: // pd
        disMode += next;
        rz_core_visual_applyDisMode(core, disMode);
        printfmtSingle[1] = rotateAsmemu(core);
        break;
    case RZ_CORE_VISUAL_MODE_DB: // debugger
        disMode += next;
        rz_core_visual_applyDisMode(core, disMode);
        printfmtSingle[1] = rotateAsmemu(core);
        current3format += next;
        currentFormat = RZ_ABS(current3format) % PRINT_3_FORMATS;
        printfmtSingle[2] = print3Formats[currentFormat];
        break;
    case RZ_CORE_VISUAL_MODE_OV: // overview
        current4format += next;
        currentFormat = RZ_ABS(current4format) % PRINT_4_FORMATS;
        printfmtSingle[3] = print4Formats[currentFormat];
        break;
    case RZ_CORE_VISUAL_MODE_CD: // code
        current5format += next;
        currentFormat = RZ_ABS(current5format) % PRINT_5_FORMATS;
        printfmtSingle[4] = print5Formats[currentFormat];
        break;
    }
}

References current3format, current4format, current5format, currentFormat, disMode, hexMode, print3Formats, print4Formats, print5Formats, PRINT_3_FORMATS, PRINT_4_FORMATS, PRINT_5_FORMATS, PRINT_HEX_FORMATS, printfmtSingle, printHexFormats, rz_core_t::printidx, rotateAsmemu(), RZ_ABS, rz_core_visual_applyDisMode(), rz_core_visual_applyHexMode(), RZ_CORE_VISUAL_MODE_CD, RZ_CORE_VISUAL_MODE_DB, RZ_CORE_VISUAL_MODE_OV, RZ_CORE_VISUAL_MODE_PD, and RZ_CORE_VISUAL_MODE_PX.

Referenced by nextPrintFormat(), and prevPrintFormat().

prompt_read()

static void prompt_read ( const char *  p, char *  buf, int  buflen  )

static

Definition at line 662 of file visual.c.

                                                              {
    if (!buf || buflen < 1) {
        return;
    }
    *buf = 0;
    rz_line_set_prompt(p);
    rz_core_visual_showcursor(NULL, true);
    rz_cons_fgets(buf, buflen, 0, NULL);
    rz_core_visual_showcursor(NULL, false);
}

References buflen, NULL, p, rz_cons_fgets(), rz_core_visual_showcursor(), and rz_line_set_prompt().

Referenced by rz_core_visual_cmd(), and setdiff().

reset_print_cur()

static void reset_print_cur ( RzPrint *  p )

static

Definition at line 673 of file visual.c.

                                        {
    p->cur = 0;
    p->ocur = -1;
}

References p.

Referenced by fix_cursor(), restore_current_addr(), rz_core_visual_cmd(), and rz_core_visual_offset().

restore_current_addr()

static void restore_current_addr ( RzCore *  core, ut64  addr, ut64  bsze, ut64  newaddr, int  cur  )

static

Definition at line 701 of file visual.c.

                                                                                            {
    bool restore_seek = true;
    bool cursor_moved = false;
    if (core->offset != newaddr) {
        // when new address is in the screen bounds, just move
        // the cursor if enabled and restore seek
        if (core->print->cur_enabled && core->print->screen_bounds > 1) {
            if (core->offset >= addr &&
                core->offset < core->print->screen_bounds) {
                core->print->ocur = -1;
                core->print->cur = core->offset - addr;
                cursor_moved = true;
            }
        }
 
        if (!cursor_moved) {
            restore_seek = false;
            reset_print_cur(core->print);
        }
    }
 
    if (core->print->cur_enabled) {
        if (restore_seek) {
            rz_core_seek(core, addr, true);
            rz_core_block_size(core, bsze);
            if (!cursor_moved) {
                core->print->cur = cur;
            }
        }
    }
}

References addr, rz_print_t::cur, rz_print_t::cur_enabled, rz_print_t::ocur, rz_core_t::offset, rz_core_t::print, reset_print_cur(), rz_core_block_size(), rz_core_seek(), and rz_print_t::screen_bounds.

Referenced by rz_core_visual_prompt_input().

rotateAsmBits()

static void rotateAsmBits ( RzCore *  core )

static

Definition at line 386 of file visual.c.

                                        {
    RzAnalysisHint *hint = rz_analysis_hint_get(core->analysis, core->offset);
    int bits = hint ? hint->bits : rz_config_get_i(core->config, "asm.bits");
    int retries = 4;
    while (retries > 0) {
        int nb = bits == 64 ? 8 : bits == 32 ? 64
            : bits == 16                 ? 32
            : bits == 8                  ? 16
                             : bits;
        if ((core->rasm->cur->bits & nb) == nb) {
            rz_analysis_hint_set_bits(core->analysis, core->offset, nb);
            break;
        }
        bits = nb;
        retries--;
    }
    rz_analysis_hint_free(hint);
}

References rz_core_t::analysis, rz_analysis_hint_t::bits, bits(), rz_core_t::config, rz_asm_t::cur, rz_core_t::offset, rz_core_t::rasm, rz_analysis_hint_free(), rz_analysis_hint_get(), rz_analysis_hint_set_bits(), and rz_config_get_i().

Referenced by rz_core_visual_cmd().

rotateAsmemu()

static const char* rotateAsmemu ( RzCore *  core )

static

Definition at line 405 of file visual.c.

                                              {
    const bool isEmuStr = rz_config_get_b(core->config, "emu.str");
    const bool isEmu = rz_config_get_b(core->config, "asm.emu");
    if (isEmu) {
        if (isEmuStr) {
            rz_config_set(core->config, "emu.str", "false");
        } else {
            rz_config_set(core->config, "asm.emu", "false");
        }
    } else {
        rz_config_set(core->config, "emu.str", "true");
    }
    return "pd";
}

References rz_core_t::config, rz_config_get_b(), and rz_config_set().

Referenced by printFormat(), and rz_core_visual_cmd().

rz_core_prevop_addr()

RZ_API bool rz_core_prevop_addr	(	RzCore *	core,
		ut64	start_addr,
		int	numinstrs,
		ut64 *	prev_addr
	)

Definition at line 1173 of file visual.c.

                                                                                               {
    RzAnalysisBlock *bb;
    int i;
    // Check that we're in a bb, otherwise this prevop stuff won't work.
    bb = rz_analysis_find_most_relevant_block_in(core->analysis, start_addr);
    if (bb) {
        if (rz_analysis_block_get_op_addr_in(bb, start_addr) != UT64_MAX) {
            // Do some analysis looping.
            for (i = 0; i < numinstrs; i++) {
                *prev_addr = prevop_addr(core, start_addr);
                start_addr = *prev_addr;
            }
            return true;
        }
    }
    // Dang! not in a bb, return false and fallback to other methods.
    *prev_addr = UT64_MAX;
    return false;
}

References rz_core_t::analysis, i, prevop_addr(), rz_analysis_block_get_op_addr_in(), rz_analysis_find_most_relevant_block_in(), and UT64_MAX.

Referenced by __cursor_up(), prevOpcode(), rz_cmd_disassembly_n_instrs_as_text_json_handler(), rz_cmd_search(), rz_cmd_sizes_of_n_instructions_handler(), rz_core_handle_backwards_disasm(), and rz_core_seek_opcode_backward().

rz_core_prevop_addr_force()

RZ_API ut64 rz_core_prevop_addr_force	(	RzCore *	core,
		ut64	start_addr,
		int	numinstrs
	)

Definition at line 1195 of file visual.c.

                                                                                    {
    int i;
    for (i = 0; i < numinstrs; i++) {
        start_addr = prevop_addr(core, start_addr);
    }
    return start_addr;
}

References i, and prevop_addr().

Referenced by rz_cmd_disassembly_n_instrs_as_text_json_handler(), rz_cmd_search(), rz_cmd_sizes_of_n_instructions_handler(), rz_core_handle_backwards_disasm(), and rz_core_seek_opcode_backward().

rz_core_print_scrollbar()

RZ_API void rz_core_print_scrollbar

(

RzCore *

core

)

Definition at line 3541 of file visual.c.

                                                  {
    int i, h, w = rz_cons_get_size(&h);
 
    int scrollbar = rz_config_get_i(core->config, "scr.scrollbar");
    if (scrollbar == 2) {
        // already handled by the visual_flagzone()
        return;
    }
    if (scrollbar > 2) {
        rz_core_print_scrollbar_bottom(core);
        return;
    }
 
    if (w < 10 || h < 3) {
        return;
    }
    ut64 from = 0;
    ut64 to = UT64_MAX;
    if (rz_config_get_b(core->config, "cfg.debug")) {
        from = rz_num_math(core->num, "$D");
        to = rz_num_math(core->num, "$D+$DD");
    } else if (rz_config_get_b(core->config, "io.va")) {
        from = rz_num_math(core->num, "$S");
        to = rz_num_math(core->num, "$S+$SS");
    } else {
        to = rz_num_math(core->num, "$s");
    }
    char *s = rz_str_newf("[0x%08" PFMT64x "]", from);
    rz_cons_gotoxy(w - strlen(s) + 1, 2);
    rz_cons_strcat(s);
    free(s);
 
    ut64 block = (to - from) / h;
 
    RzList *words = rz_flag_zone_barlist(core->flags, from, block, h);
 
    bool hadMatch = false;
    for (i = 0; i < h; i++) {
        const char *word = rz_list_pop_head(words);
        if (word && *word) {
            rz_cons_gotoxy(w - strlen(word) - 1, i + 3);
            rz_cons_printf("%s>", word);
        }
        rz_cons_gotoxy(w, i + 3);
        if (hadMatch) {
            rz_cons_printf("|");
        } else {
            ut64 cur = from + (block * i);
            ut64 nex = from + (block * (i + 1));
            if (RZ_BETWEEN(cur, core->offset, nex)) {
                rz_cons_printf(Color_INVERT "|" Color_RESET);
                hadMatch = true;
            } else {
                rz_cons_printf("|");
            }
        }
    }
    s = rz_str_newf("[0x%08" PFMT64x "]", to);
    if (s) {
        rz_cons_gotoxy(w - strlen(s) + 1, h + 1);
        rz_cons_strcat(s);
        free(s);
    }
    rz_list_free(words);
    rz_cons_flush();
}

References Color_INVERT, Color_RESET, rz_core_t::config, rz_core_t::flags, free(), from, h, i, rz_core_t::num, rz_core_t::offset, PFMT64x, RZ_BETWEEN, rz_config_get_b(), rz_config_get_i(), rz_cons_flush(), rz_cons_get_size(), rz_cons_gotoxy(), rz_cons_printf(), rz_cons_strcat(), rz_core_print_scrollbar_bottom(), rz_flag_zone_barlist(), rz_list_free(), rz_list_pop_head(), rz_num_math(), rz_str_newf(), s, to, ut64(), UT64_MAX, and w.

Referenced by agraph_refresh(), and visual_refresh().

rz_core_print_scrollbar_bottom()

RZ_API void rz_core_print_scrollbar_bottom

(

RzCore *

core

)

Definition at line 3608 of file visual.c.

                                                         {
    int i, h, w = rz_cons_get_size(&h);
 
    if (w < 10 || h < 4) {
        return;
    }
    ut64 from = 0;
    ut64 to = UT64_MAX;
    if (rz_config_get_b(core->config, "cfg.debug")) {
        from = rz_num_math(core->num, "$D");
        to = rz_num_math(core->num, "$D+$DD");
    } else if (rz_config_get_b(core->config, "io.va")) {
        from = rz_num_math(core->num, "$S");
        to = rz_num_math(core->num, "$S+$SS");
    } else {
        to = rz_num_math(core->num, "$s");
    }
    char *s = rz_str_newf("[0x%08" PFMT64x "]", from);
    int slen = strlen(s) + 1;
    rz_cons_gotoxy(0, h + 1);
    rz_cons_strcat(s);
    free(s);
 
    int linew = (w - (slen * 2)) + 1;
    ut64 block = (to - from) / linew;
 
    RzList *words = rz_flag_zone_barlist(core->flags, from, block, h);
 
    bool hadMatch = false;
    for (i = 0; i < linew + 1; i++) {
        rz_cons_gotoxy(i + slen, h + 1);
        if (hadMatch) {
            rz_cons_strcat("-");
        } else {
            ut64 cur = from + (block * i);
            ut64 nex = from + (block * (i + 2));
            if (RZ_BETWEEN(cur, core->offset, nex)) {
                rz_cons_strcat(Color_INVERT "-" Color_RESET);
                hadMatch = true;
            } else {
                rz_cons_strcat("-");
            }
        }
    }
    for (i = 0; i < linew; i++) {
        const char *word = rz_list_pop_head(words);
        if (word && *word) {
            ut64 cur = from + (block * i);
            ut64 nex = from + (block * (i + strlen(word) + 1));
            rz_cons_gotoxy(i + slen - 1, h);
            if (RZ_BETWEEN(cur, core->offset, nex)) {
                rz_cons_printf(Color_INVERT "{%s}" Color_RESET, word);
            } else {
                rz_cons_printf("{%s}", word);
            }
        }
    }
    s = rz_str_newf("[0x%08" PFMT64x "]", to);
    if (s) {
        rz_cons_gotoxy(linew + slen + 1, h + 1);
        rz_cons_strcat(s);
        free(s);
    }
    rz_list_free(words);
    rz_cons_flush();
}

References Color_INVERT, Color_RESET, rz_core_t::config, rz_core_t::flags, free(), from, h, i, rz_core_t::num, rz_core_t::offset, PFMT64x, RZ_BETWEEN, rz_config_get_b(), rz_cons_flush(), rz_cons_get_size(), rz_cons_gotoxy(), rz_cons_printf(), rz_cons_strcat(), rz_flag_zone_barlist(), rz_list_free(), rz_list_pop_head(), rz_num_math(), rz_str_newf(), s, to, ut64(), UT64_MAX, and w.

Referenced by rz_core_print_scrollbar().

rz_core_visual()

RZ_API int rz_core_visual	(	RzCore *	core,
		const char *	input
	)

Definition at line 3856 of file visual.c.

                                                           {
    const char *teefile;
    ut64 scrseek;
    int flags, ch;
    bool skip;
    char arg[2] = {
        input[0], 0
    };
 
    splitPtr = UT64_MAX;
 
    if (rz_cons_get_size(&ch) < 1 || ch < 1) {
        eprintf("Cannot create Visual context. Use scr.fix_{columns|rows}\n");
        return 0;
    }
 
    obs = core->blocksize;
    // rz_cons_set_cup (true);
 
    core->vmode = false;
    /* honor vim */
    if (!strncmp(input, "im", 2)) {
        char *cmd = rz_str_newf("!v%s", input);
        int ret = rz_core_cmd0(core, cmd);
        free(cmd);
        return ret;
    }
    while (*input) {
        int len = *input == 'd' ? 2 : 1;
        if (!rz_core_visual_cmd(core, input)) {
            return 0;
        }
        input += len;
    }
    core->vmode = true;
 
    // disable tee in cons
    teefile = rz_cons_singleton()->teefile;
    rz_cons_singleton()->teefile = "";
 
    static char debugstr[512];
    core->print->flags |= RZ_PRINT_FLAGS_ADDRMOD;
    do {
    dodo:
        rz_core_visual_tab_update(core);
        // update the cursor when it's not visible anymore
        skip = fix_cursor(core);
        rz_cons_show_cursor(false);
        rz_cons_set_raw(1);
        const int ref = rz_config_get_b(core->config, "dbg.slow");
#if 1
        // This is why multiple debug views dont work
        if (core->printidx == RZ_CORE_VISUAL_MODE_DB) {
            const bool pxa = rz_config_get_b(core->config, "stack.anotated"); // stack.anotated
            const char *reg = rz_config_get(core->config, "stack.reg");
            const int size = rz_config_get_i(core->config, "stack.size");
            const int delta = rz_config_get_i(core->config, "stack.delta");
            const char *cmdvhex = rz_config_get(core->config, "cmd.stack");
 
            if (cmdvhex && *cmdvhex) {
                rz_strf(debugstr,
                    "?0 ; f+ tmp ; sr %s @e: cfg.seek.silent=true ; %s ; ?1 ; %s ; ?1 ; "
                    "s tmp @e: cfg.seek.silent=true ; f- tmp ; pd $r",
                    reg, cmdvhex,
                    ref ? CMD_REGISTERS_REFS : CMD_REGISTERS);
                debugstr[sizeof(debugstr) - 1] = 0;
            } else {
                const char *pxw = stackPrintCommand(core);
                const char sign = (delta < 0) ? '+' : '-';
                const int absdelta = RZ_ABS(delta);
                rz_strf(debugstr,
                    "diq ; ?0 ; f+ tmp ; sr %s @e: cfg.seek.silent=true ; %s %d @ $$%c%d;"
                    "?1 ; %s;"
                    "?1 ; s tmp @e: cfg.seek.silent=true ; f- tmp ; afal ; pd $r",
                    reg, pxa ? "pxa" : pxw, size, sign, absdelta,
                    ref ? CMD_REGISTERS_REFS : CMD_REGISTERS);
            }
            printfmtSingle[2] = debugstr;
        }
#endif
        rz_cons_enable_mouse(rz_config_get_b(core->config, "scr.wheel"));
        core->cons->event_resize = NULL; // avoid running old event with new data
        core->cons->event_data = core;
        core->cons->event_resize = (RzConsEvent)visual_refresh_oneshot;
        flags = core->print->flags;
        color = rz_config_get_i(core->config, "scr.color");
        if (color) {
            flags |= RZ_PRINT_FLAGS_COLOR;
        }
        debug = rz_config_get_b(core->config, "cfg.debug");
        flags |= RZ_PRINT_FLAGS_ADDRMOD | RZ_PRINT_FLAGS_HEADER;
        rz_print_set_flags(core->print, flags);
        scrseek = rz_num_math(core->num,
            rz_config_get(core->config, "scr.seek"));
        if (scrseek != 0LL) {
            rz_core_seek(core, scrseek, true);
        }
        if (debug) {
            rz_core_reg_update_flags(core);
        }
        core->print->vflush = !skip;
        visual_refresh(core);
        if (insert_mode_enabled(core)) {
            goto dodo;
        }
        if (!skip) {
            ch = rz_cons_readchar();
 
            if (I->vtmode == RZ_VIRT_TERM_MODE_COMPLETE && !is_mintty(core->cons)) {
                // Prevent runaway scrolling
                if (IS_PRINTABLE(ch) || ch == '\t' || ch == '\n') {
                    flush_stdin();
                } else if (ch == 0x1b) {
                    char chrs[2];
                    int chrs_read = 1;
                    chrs[0] = rz_cons_readchar();
                    if (chrs[0] == '[') {
                        chrs[1] = rz_cons_readchar();
                        chrs_read++;
                        if (chrs[1] >= 'A' && chrs[1] <= 'D') { // arrow keys
                            flush_stdin();
#ifndef __WINDOWS__
                            // Following seems to fix an issue where scrolling slows
                            // down to a crawl for some terminals after some time
                            // mashing the up and down arrow keys
                            rz_cons_set_raw(false);
                            rz_cons_set_raw(true);
#endif
                        }
                    }
                    (void)rz_cons_readpush(chrs, chrs_read);
                }
            }
            if (rz_cons_is_breaked()) {
                break;
            }
            rz_core_visual_show_char(core, ch);
            if (ch == -1 || ch == 4) {
                break; // error or eof
            }
            arg[0] = ch;
            arg[1] = 0;
        }
    } while (skip || (*arg && rz_core_visual_cmd(core, arg)));
 
    rz_cons_enable_mouse(false);
    if (color) {
        rz_cons_strcat(Color_RESET);
    }
    rz_config_set_i(core->config, "scr.color", color);
    core->print->cur_enabled = false;
    if (autoblocksize) {
        rz_core_block_size(core, obs);
    }
    rz_cons_singleton()->teefile = teefile;
    rz_cons_set_cup(false);
    rz_cons_clear00();
    core->vmode = false;
    core->cons->event_resize = NULL;
    core->cons->event_data = NULL;
    rz_cons_show_cursor(true);
    return 0;
}

References autoblocksize, rz_core_t::blocksize, cmd, CMD_REGISTERS, CMD_REGISTERS_REFS, color, Color_RESET, rz_core_t::config, rz_core_t::cons, rz_print_t::cur_enabled, debug, delta, eprintf, rz_cons_t::event_data, rz_cons_t::event_resize, fix_cursor(), rz_print_t::flags, flags, flush_stdin(), free(), I, input(), insert_mode_enabled(), is_mintty(), IS_PRINTABLE, len, NULL, rz_core_t::num, obs, rz_core_t::print, printfmtSingle, rz_core_t::printidx, reg, RZ_ABS, rz_config_get(), rz_config_get_b(), rz_config_get_i(), rz_config_set_i(), rz_cons_clear00(), rz_cons_enable_mouse(), rz_cons_get_size(), rz_cons_is_breaked(), rz_cons_readchar(), rz_cons_readpush(), rz_cons_set_cup(), rz_cons_set_raw(), rz_cons_show_cursor(), rz_cons_singleton(), rz_cons_strcat(), rz_core_block_size(), rz_core_cmd0(), rz_core_reg_update_flags(), rz_core_seek(), rz_core_visual_cmd(), RZ_CORE_VISUAL_MODE_DB, rz_core_visual_show_char(), rz_num_math(), RZ_PRINT_FLAGS_ADDRMOD, RZ_PRINT_FLAGS_COLOR, RZ_PRINT_FLAGS_HEADER, rz_print_set_flags(), rz_str_newf(), rz_strf, RZ_VIRT_TERM_MODE_COMPLETE, skip(), splitPtr, stackPrintCommand(), rz_cons_t::teefile, ut64(), UT64_MAX, rz_print_t::vflush, visual_refresh(), visual_refresh_oneshot(), and rz_core_t::vmode.

Referenced by rz_cmd_visual(), rz_core_visual_debugtraces(), and rz_core_visual_panels_root().

rz_core_visual_append_help()

RZ_API void rz_core_visual_append_help	(	RzStrBuf *	p,
		const char *	title,
		const char **	help
	)

Definition at line 532 of file visual.c.

                                                                                          {
    int i, max_length = 0, padding = 0;
    RzConsContext *cons_ctx = rz_cons_singleton()->context;
    const char *pal_args_color = cons_ctx->color_mode ? cons_ctx->pal.args : "",
           *pal_help_color = cons_ctx->color_mode ? cons_ctx->pal.help : "",
           *pal_reset = cons_ctx->color_mode ? cons_ctx->pal.reset : "";
    for (i = 0; help[i]; i += 2) {
        max_length = RZ_MAX(max_length, strlen(help[i]));
    }
    rz_strbuf_appendf(p, "|%s:\n", title);
 
    for (i = 0; help[i]; i += 2) {
        padding = max_length - (strlen(help[i]));
        rz_strbuf_appendf(p, "| %s%s%*s  %s%s%s\n",
            pal_args_color, help[i],
            padding, "",
            pal_help_color, help[i + 1], pal_reset);
    }
}

References rz_cons_printable_palette_t::args, rz_cons_context_t::color_mode, rz_cons_t::context, cmd_descs_generate::help, rz_cons_printable_palette_t::help, i, p, rz_cons_context_t::pal, rz_cons_printable_palette_t::reset, rz_cons_singleton(), RZ_MAX, and rz_strbuf_appendf().

Referenced by __update_help(), rz_core_visual_analysis(), rz_load_panels_layout(), and visual_help().

rz_core_visual_applyDisMode()

RZ_API void rz_core_visual_applyDisMode	(	RzCore *	core,
		int	disMode
	)

Definition at line 174 of file visual.c.

                                                                   {
    currentFormat = RZ_ABS(disMode) % 5;
    switch (currentFormat) {
    case 0:
        rz_config_set(core->config, "asm.pseudo", "false");
        rz_config_set(core->config, "asm.bytes", "true");
        rz_config_set(core->config, "asm.esil", "false");
        rz_config_set(core->config, "emu.str", "false");
        rz_config_set(core->config, "asm.emu", "false");
        break;
    case 1:
        rz_config_set(core->config, "asm.pseudo", "false");
        rz_config_set(core->config, "asm.bytes", "true");
        rz_config_set(core->config, "asm.esil", "false");
        rz_config_set(core->config, "asm.emu", "false");
        rz_config_set(core->config, "emu.str", "true");
        break;
    case 2:
        rz_config_set(core->config, "asm.pseudo", "true");
        rz_config_set(core->config, "asm.bytes", "true");
        rz_config_set(core->config, "asm.esil", "true");
        rz_config_set(core->config, "emu.str", "true");
        rz_config_set(core->config, "asm.emu", "true");
        break;
    case 3:
        rz_config_set(core->config, "asm.pseudo", "false");
        rz_config_set(core->config, "asm.bytes", "false");
        rz_config_set(core->config, "asm.esil", "false");
        rz_config_set(core->config, "asm.emu", "false");
        rz_config_set(core->config, "emu.str", "true");
        break;
    case 4:
        rz_config_set(core->config, "asm.pseudo", "true");
        rz_config_set(core->config, "asm.bytes", "false");
        rz_config_set(core->config, "asm.esil", "false");
        rz_config_set(core->config, "asm.emu", "false");
        rz_config_set(core->config, "emu.str", "true");
        break;
    }
}

References rz_core_t::config, currentFormat, disMode, RZ_ABS, and rz_config_set().

Referenced by __rotate_disasm_cb(), and printFormat().

rz_core_visual_applyHexMode()

RZ_API void rz_core_visual_applyHexMode	(	RzCore *	core,
		int	hexMode
	)

Definition at line 84 of file visual.c.

                                                                   {
    currentFormat = RZ_ABS(hexMode) % PRINT_HEX_FORMATS;
    switch (currentFormat) {
    case 0: /* px */
    case 3: /* prx */
    case 6: /* pxw */
    case 9: /* pxr */
        rz_config_set(core->config, "hex.compact", "false");
        rz_config_set(core->config, "hex.comments", "true");
        break;
    case 1: /* pxa */
    case 4: /* pxb */
    case 7: /* pxq */
        rz_config_set(core->config, "hex.compact", "true");
        rz_config_set(core->config, "hex.comments", "true");
        break;
    case 2: /* pxr */
    case 5: /* pxh */
    case 8: /* pxd */
        rz_config_set(core->config, "hex.compact", "false");
        rz_config_set(core->config, "hex.comments", "false");
        break;
    }
}

References rz_core_t::config, currentFormat, hexMode, PRINT_HEX_FORMATS, RZ_ABS, and rz_config_set().

Referenced by __rotate_hexdump_cb(), and printFormat().

rz_core_visual_browse()

RZ_API void rz_core_visual_browse	(	RzCore *	core,
		const char *	input
	)

Definition at line 2067 of file visual.c.

                                                                   {
    const char *browsemsg =
        "Browse stuff:\n"
        "-------------\n"
        " _  hud mode (V_)\n"
        " 1  bit editor (vd1)\n"
        " b  blocks\n"
        " a  analysis classes\n"
        " c  classes\n"
        " C  comments\n"
        " d  debug traces\n"
        " e  eval var configurations\n"
        " E  esil debugger mode\n"
        " f  flags\n"
        " F  functions\n"
        " g  graph\n"
        " h  history\n"
        " i  imports\n"
        " m  maps\n"
        " M  mountpoints\n"
        " p  pids/threads\n"
        " q  quit\n"
        " r  ROP gadgets\n"
        " s  symbols\n"
        " T  themes\n"
        " v  vars\n"
        " x  xrefs\n"
        " X  refs\n"
        " :  run command\n";
    for (;;) {
        rz_cons_clear00();
        rz_cons_printf("%s\n", browsemsg);
        rz_cons_flush();
        char ch = 0;
        if (input && *input) {
            ch = *input;
            input++;
        } else {
            ch = rz_cons_readchar();
        }
        ch = rz_cons_arrow_to_hjkl(ch);
        switch (ch) {
        case '1':
            rz_core_visual_bit_editor(core);
            break;
        case 'g': // "vbg"
            if (rz_core_visual_view_graph(core)) {
                return;
            }
            break;
        case 'r': // "vbr"
            rz_core_visual_view_rop(core);
            break;
        case 'f': // "vbf"
            rz_core_visual_trackflags(core);
            break;
        case 'F': // "vbF"
            rz_core_visual_analysis(core, NULL);
            break;
        case 'd': // "vbd"
            rz_core_visual_debugtraces(core, NULL);
            break;
        case 'v': // "vbv"
            rz_core_visual_analysis(core, "v");
            break;
        case 'e': // "vbe"
            rz_core_visual_config(core);
            break;
        case 'E': // "vbe"
            rz_core_visual_esil(core);
            break;
        case 'c': // "vbc"
            rz_core_visual_classes(core);
            break;
        case 'a': // "vba"
            rz_core_visual_analysis_classes(core);
            break;
        case 'C': // "vbC"
            rz_core_visual_comments(core);
            break;
        case 'T': // "vbT"
            rz_core_cmd0(core, "eco $(eco~...)");
            break;
        case 'p':
            rz_core_cmd0(core, "dpt=$(dpt~[1-])");
            break;
        case 'b':
            rz_core_cmd0(core, "s $(afb~...)");
            break;
        case 'i':
            // XXX ii shows index first and iiq shows no offset :(
            rz_core_cmd0(core, "s $(ii~...)");
            break;
        case 's':
            rz_core_cmd0(core, "s $(isq~...)");
            break;
        case 'm':
            rz_core_cmd0(core, "s $(dm~...)");
            break;
        case 'x':
            rz_core_visual_xrefs(core, true, true);
            break;
        case 'X':
            rz_core_visual_xrefs(core, false, true);
            break;
        case 'h': // seek history
            rz_core_cmdf(core, "sh~...");
            break;
        case '_':
            rz_core_visual_hudstuff(core);
            break;
        case ':':
            rz_core_visual_prompt_input(core);
            break;
        case 127: // backspace
        case 'q':
            return;
        }
    }
}

References input(), NULL, rz_cons_arrow_to_hjkl(), rz_cons_clear00(), rz_cons_flush(), rz_cons_printf(), rz_cons_readchar(), rz_core_cmd0(), rz_core_cmdf(), rz_core_visual_analysis(), rz_core_visual_analysis_classes(), rz_core_visual_bit_editor(), rz_core_visual_classes(), rz_core_visual_comments(), rz_core_visual_config(), rz_core_visual_debugtraces(), rz_core_visual_esil(), rz_core_visual_hudstuff(), rz_core_visual_prompt_input(), rz_core_visual_trackflags(), rz_core_visual_view_graph(), rz_core_visual_view_rop(), and rz_core_visual_xrefs().

Referenced by __panels_process(), rz_core_visual_cmd(), and rz_core_visual_graph().

rz_core_visual_cmd()

RZ_API int rz_core_visual_cmd	(	RzCore *	core,
		const char *	arg
	)

Definition at line 2232 of file visual.c.

                                                             {
    ut8 och = arg[0];
    RzAsmOp op;
    ut64 offset = core->offset;
    char buf[4096];
    const char *key_s;
    int i, cols = core->print->cols;
    int wheelspeed;
    int ch = och;
    if ((ut8)ch == KEY_ALTQ) {
        rz_cons_readchar();
        ch = 'q';
    }
    ch = rz_cons_arrow_to_hjkl(ch);
    ch = visual_nkey(core, ch);
    if (ch < 2) {
        int x, y;
        if (rz_cons_get_click(&x, &y)) {
            if (y == 1) {
                if (x < 15) {
                    ch = '_';
                } else if (x < 20) {
                    ch = 'p';
                } else if (x < 24) {
                    ch = 9;
                }
            } else if (y == 2) {
                if (x < 2) {
                    visual_closetab(core);
                } else if (x < 5) {
                    visual_newtab(core);
                } else {
                    visual_nexttab(core);
                }
                return 1;
            } else {
                ch = 0; //'c';
            }
        } else {
            return 1;
        }
    }
    if (rz_cons_singleton()->mouse_event) {
        wheelspeed = rz_config_get_i(core->config, "scr.wheel.speed");
    } else {
        wheelspeed = 1;
    }
 
    if (ch == 'l' && och == 6) {
        ch = 'J';
    } else if (ch == 'h' && och == 2) {
        ch = 'K';
    }
 
    // do we need hotkeys for data references? not only calls?
    // '0' is handled to seek at the beginning of the function
    // unless the cursor is set, then, the 0 is captured here
    if (isNumber(core, ch)) {
        // only in disasm and debug prints..
        if (isDisasmPrint(core->printidx)) {
            if (rz_config_get_b(core->config, "asm.hints") && (rz_config_get_b(core->config, "asm.hint.jmp") || rz_config_get_b(core->config, "asm.hint.lea") || rz_config_get_b(core->config, "asm.hint.emu") || rz_config_get_b(core->config, "asm.hint.call"))) {
                rz_core_visual_jump(core, ch);
            } else {
                numbuf_append(ch);
            }
        } else {
            numbuf_append(ch);
        }
    } else {
        switch (ch) {
#if __WINDOWS__
        case 0xf5:
            SetWindow(81, 25);
            break;
        case 0xcf5:
            SetWindow(81, 40);
            break;
#endif
        case 0x0d: // "enter" "\\n" "newline"
        {
            RzAnalysisOp *op;
            bool wheel = rz_config_get_b(core->config, "scr.wheel");
            if (wheel) {
                rz_cons_enable_mouse(true);
            }
            do {
                op = rz_core_analysis_op(core, core->offset + core->print->cur, RZ_ANALYSIS_OP_MASK_BASIC);
                if (op) {
                    if (op->type == RZ_ANALYSIS_OP_TYPE_JMP ||
                        op->type == RZ_ANALYSIS_OP_TYPE_CJMP ||
                        op->type == RZ_ANALYSIS_OP_TYPE_CALL ||
                        op->type == RZ_ANALYSIS_OP_TYPE_CCALL) {
                        if (core->print->cur_enabled) {
                            int delta = RZ_ABS((st64)op->jump - (st64)offset);
                            if (op->jump < core->offset || op->jump >= core->print->screen_bounds) {
                                rz_core_visual_seek_animation(core, op->jump);
                                core->print->cur = 0;
                            } else {
                                core->print->cur = delta;
                            }
                        } else {
                            rz_core_visual_seek_animation(core, op->jump);
                        }
                    }
                }
                rz_analysis_op_free(op);
            } while (--wheelspeed > 0);
        } break;
        case 'o': // tab TAB
            nextPrintFormat(core);
            break;
        case 'O': // tab TAB
        case 9: // tab TAB
            rz_core_visual_toggle_decompiler_disasm(core, false, true);
            if (splitView) {
                // this split view is kind of useless imho, we should kill it or merge it into tabs
                core->print->cur = 0;
                core->curtab = 0;
                core->seltab++;
                if (core->seltab > 1) {
                    core->seltab = 0;
                }
            } else {
                if (core->print->cur_enabled) {
                    core->curtab = 0;
                    if (core->printidx == RZ_CORE_VISUAL_MODE_DB) {
                        core->print->cur = 0;
                        core->seltab++;
                        if (core->seltab > 2) {
                            core->seltab = 0;
                        }
                    } else {
                        core->seltab = 0;
                        ut64 f = rz_config_get_i(core->config, "diff.from");
                        ut64 t = rz_config_get_i(core->config, "diff.to");
                        if (f == t && f == 0) {
                            core->print->col = core->print->col == 1 ? 2 : 1;
                        }
                    }
                } else {
                    prevPrintFormat(core);
                }
            }
            break;
        case '&':
            rotateAsmBits(core);
            break;
        case 'a': {
            {
                ut64 addr = core->offset;
                if (PIDX == 2) {
                    if (core->seltab == 0) {
                        addr = rz_debug_reg_get(core->dbg, "SP");
                    }
                }
                if (!canWrite(core, addr)) {
                    rz_cons_printf("\nFile has been opened in read-only mode. Use -w flag, oo+ or e io.cache=true\n");
                    rz_cons_any_key(NULL);
                    return true;
                }
            }
            rz_cons_printf("Enter assembler opcodes separated with ';':\n");
            rz_core_visual_showcursor(core, true);
            rz_cons_flush();
            rz_cons_set_raw(false);
            strcpy(buf, "\"wa ");
            rz_line_set_prompt(":> ");
            rz_cons_enable_mouse(false);
            if (rz_cons_fgets(buf + 4, sizeof(buf) - 4, 0, NULL) < 0) {
                buf[0] = '\0';
            }
            strcat(buf, "\"");
            bool wheel = rz_config_get_b(core->config, "scr.wheel");
            if (wheel) {
                rz_cons_enable_mouse(true);
            }
            if (*buf) {
                if (core->print->cur_enabled) {
                    int t = core->offset + core->print->cur;
                    rz_core_seek(core, t, false);
                }
                rz_core_cmd(core, buf, true);
                if (core->print->cur_enabled) {
                    int t = core->offset - core->print->cur;
                    rz_core_seek(core, t, true);
                }
            }
            rz_core_visual_showcursor(core, false);
            rz_cons_set_raw(true);
        } break;
        case '=': { // TODO: edit
            rz_core_visual_showcursor(core, true);
            const char *buf = NULL;
#define I core->cons
            const char *cmd = rz_config_get(core->config, "cmd.vprompt");
            rz_line_set_prompt("cmd.vprompt> ");
            I->line->contents = strdup(cmd);
            buf = rz_line_readline();
            I->line->contents = NULL;
            (void)rz_config_set(core->config, "cmd.vprompt", buf);
            rz_core_visual_showcursor(core, false);
        } break;
        case '|': { // TODO: edit
            rz_core_visual_showcursor(core, true);
            const char *buf = NULL;
#define I core->cons
            const char *cmd = rz_config_get(core->config, "cmd.cprompt");
            rz_line_set_prompt("cmd.cprompt> ");
            I->line->contents = strdup(cmd);
            buf = rz_line_readline();
            if (buf && !strcmp(buf, "|")) {
                RZ_FREE(I->line->contents);
                core->print->cur_enabled = true;
                core->print->cur = 0;
                (void)rz_config_set(core->config, "cmd.cprompt", "p=e $r-2");
            } else {
                RZ_FREE(I->line->contents);
                (void)rz_config_set(core->config, "cmd.cprompt", buf ? buf : "");
            }
            rz_core_visual_showcursor(core, false);
        } break;
        case '!':
            rz_core_visual_panels_root(core, core->panels_root);
            break;
        case 'g':
            rz_core_visual_showcursor(core, true);
            rz_core_visual_offset(core);
            rz_core_visual_showcursor(core, false);
            break;
        case 'G':
            __core_visual_gogo(core, 'G');
            break;
        case 'A': {
            const int oce = core->print->cur_enabled;
            const int oco = core->print->ocur;
            const int occ = core->print->cur;
            ut64 off = oce ? core->offset + core->print->cur : core->offset;
            core->print->cur_enabled = 0;
            rz_cons_enable_mouse(false);
            rz_core_visual_asm(core, off);
            core->print->cur_enabled = oce;
            core->print->cur = occ;
            core->print->ocur = oco;
            if (rz_config_get_b(core->config, "scr.wheel")) {
                rz_cons_enable_mouse(true);
            }
        } break;
        case '\\':
            if (splitPtr == UT64_MAX) {
                splitPtr = core->offset;
            }
            splitView = !splitView;
            setcursor(core, splitView);
            break;
        case 'c':
            setcursor(core, !core->print->cur_enabled);
            break;
        case '$':
            if (core->print->cur_enabled) {
                rz_core_reg_set_by_role_or_name(core, "PC", core->offset + core->print->cur);
            } else {
                rz_core_reg_set_by_role_or_name(core, "PC", core->offset);
            }
            break;
        case '@':
            if (core->print->cur_enabled) {
                char buf[128];
                prompt_read("cursor at:", buf, sizeof(buf));
                core->print->cur = (st64)rz_num_math(core->num, buf);
            }
            break;
        case 'C':
            if (++color > 3) {
                color = 0;
            }
            rz_config_set_i(core->config, "scr.color", color);
            break;
        case 'd': {
            bool mouse_state = __holdMouseState(core);
            rz_core_visual_showcursor(core, true);
            int distance = numbuf_pull();
            rz_core_visual_define(core, arg + 1, distance - 1);
            rz_core_visual_showcursor(core, false);
            rz_cons_enable_mouse(mouse_state && rz_config_get_b(core->config, "scr.wheel"));
        } break;
        case 'D':
            setdiff(core);
            break;
        case 'f': {
            bool mouse_state = __holdMouseState(core);
            int range, min, max;
            char name[256], *n;
            rz_line_set_prompt("flag name: ");
            rz_core_visual_showcursor(core, true);
            if (rz_cons_fgets(name, sizeof(name), 0, NULL) >= 0 && *name) {
                n = name;
                rz_str_trim(n);
                if (core->print->ocur != -1) {
                    min = RZ_MIN(core->print->cur, core->print->ocur);
                    max = RZ_MAX(core->print->cur, core->print->ocur);
                } else {
                    min = max = core->print->cur;
                }
                range = max - min + 1;
                if (!strcmp(n, "-")) {
                    rz_flag_unset_off(core->flags, core->offset + core->print->cur);
                } else if (*n == '.') {
                    RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset + min, 0);
                    if (fcn) {
                        if (n[1] == '-') {
                            // Unset the local label (flag)
                            rz_analysis_function_delete_label(fcn, n + 1);
                        } else {
                            rz_analysis_function_set_label(fcn, n + 1, core->offset + min);
                        }
                    } else {
                        eprintf("Cannot find function at 0x%08" PFMT64x "\n", core->offset + min);
                    }
                } else if (*n == '-') {
                    if (*n) {
                        rz_flag_unset_name(core->flags, n + 1);
                    }
                } else {
                    if (range < 1) {
                        range = 1;
                    }
                    if (*n) {
                        rz_flag_set(core->flags, n, core->offset + min, range);
                    }
                }
            }
            rz_cons_enable_mouse(mouse_state && rz_config_get_b(core->config, "scr.wheel"));
            rz_core_visual_showcursor(core, false);
        } break;
        case ',':
            visual_comma(core);
            break;
        case 't': {
            rz_cons_gotoxy(0, 0);
            if (core->visual.tabs) {
                rz_cons_printf("[tnp:=+-] ");
            } else {
                rz_cons_printf("[t] ");
            }
            rz_cons_flush();
            int ch = rz_cons_readchar();
            if (isdigit(ch)) {
                visual_nthtab(core, ch - '0' - 1);
            }
            switch (ch) {
            case 'h':
            case 'k':
            case 'p':
                visual_prevtab(core);
                break;
            case 9: // t-TAB
            case 'l':
            case 'j':
            case 'n':
                visual_nexttab(core);
                break;
            case '=':
                visual_tabname(core);
                break;
            case '-':
                visual_closetab(core);
                break;
            case ':': {
                RzCoreVisualTab *tab = visual_newtab(core);
                if (tab) {
                    tab->name[0] = ':';
                    rz_cons_fgets(tab->name + 1, sizeof(tab->name) - 1, 0, NULL);
                }
            } break;
            case '+':
            case 't':
            case 'a':
                visual_newtab(core);
                break;
            }
        } break;
        case 'T':
            visual_closetab(core);
            break;
        case 'n':
            rz_core_seek_next(core, rz_config_get(core->config, "scr.nkey"), true);
            break;
        case 'N':
            rz_core_seek_prev(core, rz_config_get(core->config, "scr.nkey"), true);
            break;
        case 'i':
        case 'I': {
            ut64 oaddr = core->offset;
            int delta = (core->print->ocur != -1) ? RZ_MIN(core->print->cur, core->print->ocur) : core->print->cur;
            ut64 addr = core->offset + delta;
            if (PIDX == 0) {
                if (strstr(printfmtSingle[0], "pxb")) {
                    rz_core_visual_define(core, "1", 1);
                    return true;
                }
                if (core->print->ocur == -1) {
                    __ime = true;
                    core->print->cur_enabled = true;
                    return true;
                }
            } else if (PIDX == 2) {
                if (core->seltab == 0) {
                    addr = rz_debug_reg_get(core->dbg, "SP") + delta;
                } else if (core->seltab == 1) {
                    // regs, writing in here not implemented
                    return true;
                }
            }
            if (!canWrite(core, addr)) {
                rz_cons_printf("\nFile has been opened in read-only mode. Use -w flag, oo+ or e io.cache=true\n");
                rz_cons_any_key(NULL);
                return true;
            }
            rz_core_visual_showcursor(core, true);
            rz_cons_flush();
            rz_cons_set_raw(0);
            if (ch == 'I') {
                strcpy(buf, "wow ");
                rz_line_set_prompt("insert hexpair block: ");
                if (rz_cons_fgets(buf + 4, sizeof(buf) - 4, 0, NULL) < 0) {
                    buf[0] = '\0';
                }
                char *p = strdup(buf);
                int cur = core->print->cur;
                if (cur >= core->blocksize) {
                    cur = core->print->cur - 1;
                }
                snprintf(buf, sizeof(buf), "%s @ $$0!%i", p,
                    core->blocksize - cur);
                rz_core_cmd(core, buf, 0);
                free(p);
                break;
            }
            if (core->print->col == 2) {
                strcpy(buf, "\"w ");
                rz_line_set_prompt("insert string: ");
                if (rz_cons_fgets(buf + 3, sizeof(buf) - 3, 0, NULL) < 0) {
                    buf[0] = '\0';
                }
                strcat(buf, "\"");
            } else {
                rz_line_set_prompt("insert hex: ");
                if (core->print->ocur != -1) {
                    int bs = RZ_ABS(core->print->cur - core->print->ocur) + 1;
                    core->blocksize = bs;
                    strcpy(buf, "wow ");
                } else {
                    strcpy(buf, "wx ");
                }
                if (rz_cons_fgets(buf + strlen(buf), sizeof(buf) - strlen(buf), 0, NULL) < 0) {
                    buf[0] = '\0';
                }
            }
            if (core->print->cur_enabled) {
                rz_core_seek(core, addr, false);
            }
            rz_core_cmd(core, buf, 1);
            if (core->print->cur_enabled) {
                rz_core_seek(core, addr, true);
            }
            rz_cons_set_raw(1);
            rz_core_visual_showcursor(core, false);
            rz_core_seek(core, oaddr, true);
        } break;
        case 'R':
            if (rz_config_get_b(core->config, "scr.randpal")) {
                rz_cons_pal_random();
            } else {
                rz_core_theme_nextpal(core, 'n');
            }
            break;
        case 'e':
            rz_core_visual_config(core);
            break;
        case '^': {
            RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, 0);
            if (fcn) {
                rz_core_seek_and_save(core, fcn->addr, false);
            } else {
                __core_visual_gogo(core, 'g');
            }
        } break;
        case 'E':
            rz_core_visual_colors(core);
            break;
        case 'x':
            rz_core_visual_xrefs(core, true, false);
            break;
        case 'X':
            rz_core_visual_xrefs(core, false, false);
            break;
        case 'r':
            // TODO: toggle shortcut hotkeys
            rz_core_visual_toggle_hints(core);
            visual_refresh(core);
            break;
        case ' ':
        case 'V': {
            RzAnalysisFunction *fun = rz_analysis_get_fcn_in(core->analysis, core->offset, RZ_ANALYSIS_FCN_TYPE_NULL);
            int ocolor = rz_config_get_i(core->config, "scr.color");
            if (!fun) {
                rz_cons_message("Not in a function. Type 'df' to define it here");
                break;
            } else if (rz_list_empty(fun->bbs)) {
                rz_cons_message("No basic blocks in this function. You may want to use 'afb+'.");
                break;
            }
            reset_print_cur(core->print);
            eprintf("\rRendering graph...");
            rz_core_visual_graph(core, NULL, NULL, true);
            rz_config_set_i(core->config, "scr.color", ocolor);
        } break;
        case 'v':
            rz_core_visual_analysis(core, NULL);
            break;
        case 'h':
        case 'l': {
            int distance = numbuf_pull();
            if (core->print->cur_enabled) {
                if (ch == 'h') {
                    for (i = 0; i < distance; i++) {
                        cursor_left(core, false);
                    }
                } else {
                    for (i = 0; i < distance; i++) {
                        cursor_right(core, false);
                    }
                }
            } else {
                if (ch == 'h') {
                    distance = -distance;
                }
                rz_core_seek_delta(core, distance, false);
            }
        } break;
        case 'L':
        case 'H': {
            int distance = numbuf_pull();
            if (core->print->cur_enabled) {
                if (ch == 'H') {
                    for (i = 0; i < distance; i++) {
                        cursor_left(core, true);
                    }
                } else {
                    for (i = 0; i < distance; i++) {
                        cursor_right(core, true);
                    }
                }
            } else {
                if (ch == 'H') {
                    distance = -distance;
                }
                rz_core_seek_delta(core, distance * 2, false);
            }
        } break;
        case 'j':
            if (core->print->cur_enabled) {
                int distance = numbuf_pull();
                for (i = 0; i < distance; i++) {
                    cursor_nextrow(core, false);
                }
            } else {
                if (rz_config_get_b(core->config, "scr.wheel.nkey")) {
                    int i, distance = numbuf_pull();
                    if (distance < 1) {
                        distance = 1;
                    }
                    for (i = 0; i < distance; i++) {
                        const char *nkey = rz_config_get(core->config, "scr.nkey");
                        rz_core_seek_next(core, nkey, true);
                    }
                } else {
                    int times = RZ_MAX(1, wheelspeed);
                    // Check if we have a data annotation.
                    ut64 amisize;
                    RzAnalysisMetaItem *ami = rz_meta_get_at(core->analysis, core->offset, RZ_META_TYPE_DATA, &amisize);
                    if (!ami) {
                        ami = rz_meta_get_at(core->analysis, core->offset, RZ_META_TYPE_STRING, &amisize);
                    }
                    if (ami) {
                        rz_core_seek_delta(core, amisize, false);
                    } else {
                        int distance = numbuf_pull();
                        if (distance > 1) {
                            times = distance;
                        }
                        while (times--) {
                            if (isDisasmPrint(core->printidx)) {
                                rz_core_visual_disasm_down(core, &op, &cols);
                            } else if (!strcmp(__core_visual_print_command(core),
                                       "prc")) {
                                cols = rz_config_get_i(core->config, "hex.cols");
                            }
                            rz_core_seek(core, core->offset + cols, true);
                        }
                    }
                }
            }
            break;
        case 'J':
            if (core->print->cur_enabled) {
                int distance = numbuf_pull();
                for (i = 0; i < distance; i++) {
                    cursor_nextrow(core, true);
                }
            } else {
                if (core->print->screen_bounds > 1 && core->print->screen_bounds >= core->offset) {
                    ut64 addr = UT64_MAX;
                    if (isDisasmPrint(core->printidx)) {
                        if (core->print->screen_bounds == core->offset) {
                            rz_asm_disassemble(core->rasm, &op, core->block, 32);
                        }
                        if (addr == core->offset || addr == UT64_MAX) {
                            addr = core->offset + 48;
                        }
                    } else {
                        int h;
                        int hexCols = rz_config_get_i(core->config, "hex.cols");
                        if (hexCols < 1) {
                            hexCols = 16;
                        }
                        (void)rz_cons_get_size(&h);
                        int delta = hexCols * (h / 4);
                        addr = core->offset + delta;
                    }
                    rz_core_seek(core, addr, true);
                } else {
                    rz_core_seek(core, core->offset + obs, true);
                }
            }
            break;
        case 'k':
            if (core->print->cur_enabled) {
                int distance = numbuf_pull();
                for (i = 0; i < distance; i++) {
                    cursor_prevrow(core, false);
                }
            } else {
                if (rz_config_get_b(core->config, "scr.wheel.nkey")) {
                    int i, distance = numbuf_pull();
                    if (distance < 1) {
                        distance = 1;
                    }
                    for (i = 0; i < distance; i++) {
                        rz_core_seek_prev(core, rz_config_get(core->config, "scr.nkey"), true);
                    }
                } else {
                    int times = wheelspeed;
                    if (times < 1) {
                        times = 1;
                    }
                    int distance = numbuf_pull();
                    if (distance > 1) {
                        times = distance;
                    }
                    while (times--) {
                        if (isDisasmPrint(core->printidx)) {
                            rz_core_visual_disasm_up(core, &cols);
                        } else if (!strcmp(__core_visual_print_command(core), "prc")) {
                            cols = rz_config_get_i(core->config, "hex.cols");
                        }
                        rz_core_seek_delta(core, -cols, false);
                    }
                }
            }
            break;
        case 'K':
            if (core->print->cur_enabled) {
                int distance = numbuf_pull();
                for (i = 0; i < distance; i++) {
                    cursor_prevrow(core, true);
                }
            } else {
                if (core->print->screen_bounds > 1 && core->print->screen_bounds > core->offset) {
                    int delta = (core->print->screen_bounds - core->offset);
                    if (core->offset >= delta) {
                        rz_core_seek(core, core->offset - delta, true);
                    } else {
                        rz_core_seek(core, 0, true);
                    }
                } else {
                    ut64 at = (core->offset > obs) ? core->offset - obs : 0;
                    if (core->offset > obs) {
                        rz_core_seek(core, at, true);
                    } else {
                        rz_core_seek(core, 0, true);
                    }
                }
            }
            break;
        case '[':
            // comments column
            if (core->print->cur_enabled &&
                (core->printidx == RZ_CORE_VISUAL_MODE_PD ||
                    (core->printidx == RZ_CORE_VISUAL_MODE_DB && core->seltab == 2))) {
                int cmtcol = rz_config_get_i(core->config, "asm.cmt.col");
                if (cmtcol > 2) {
                    rz_config_set_i(core->config, "asm.cmt.col", cmtcol - 2);
                }
            }
            // hex column
            if ((core->printidx != RZ_CORE_VISUAL_MODE_PD && core->printidx != RZ_CORE_VISUAL_MODE_DB) ||
                (core->printidx == RZ_CORE_VISUAL_MODE_DB && core->seltab != 2)) {
                int scrcols = rz_config_get_i(core->config, "hex.cols");
                if (scrcols > 1) {
                    rz_config_set_i(core->config, "hex.cols", scrcols - 1);
                }
            }
            break;
        case ']':
            // comments column
            if (core->print->cur_enabled &&
                (core->printidx == RZ_CORE_VISUAL_MODE_PD ||
                    (core->printidx == RZ_CORE_VISUAL_MODE_DB && core->seltab == 2))) {
                int cmtcol = rz_config_get_i(core->config, "asm.cmt.col");
                rz_config_set_i(core->config, "asm.cmt.col", cmtcol + 2);
            }
            // hex column
            if ((core->printidx != RZ_CORE_VISUAL_MODE_PD && core->printidx != RZ_CORE_VISUAL_MODE_DB) ||
                (core->printidx == RZ_CORE_VISUAL_MODE_DB && core->seltab != 2)) {
                int scrcols = rz_config_get_i(core->config, "hex.cols");
                rz_config_set_i(core->config, "hex.cols", scrcols + 1);
            }
            break;
        case 's':
            key_s = rz_config_get(core->config, "key.s");
            if (key_s && *key_s) {
                rz_core_cmd0(core, key_s);
            } else {
                rz_core_debug_single_step_in(core);
            }
            break;
        case 'S':
            key_s = rz_config_get(core->config, "key.S");
            if (key_s && *key_s) {
                rz_core_cmd0(core, key_s);
            } else {
                rz_core_debug_single_step_over(core);
            }
            break;
        case '"':
            rz_config_toggle(core->config, "scr.dumpcols");
            break;
        case 'p':
            rz_core_visual_toggle_decompiler_disasm(core, false, true);
            if (core->printidx == RZ_CORE_VISUAL_MODE_DB && core->print->cur_enabled) {
                nextPrintCommand();
            } else {
                setprintmode(core, 1);
            }
            break;
        case 'P':
            if (core->printidx == RZ_CORE_VISUAL_MODE_DB && core->print->cur_enabled) {
                prevPrintCommand();
            } else {
                setprintmode(core, -1);
            }
            break;
        case '%':
            if (core->print->cur_enabled) {
                findPair(core);
            } else {
                /* do nothing? */
                autoblocksize = !autoblocksize;
                if (autoblocksize) {
                    obs = core->blocksize;
                } else {
                    rz_core_block_size(core, obs);
                }
                rz_cons_clear();
            }
            break;
        case 'w':
            findNextWord(core);
            break;
        case 'W':
            findPrevWord(core);
            break;
        case 'm': {
            rz_cons_gotoxy(0, 0);
            rz_cons_printf(RZ_CONS_CLEAR_LINE "Set shortcut key for 0x%" PFMT64x "\n", core->offset);
            rz_cons_flush();
            int ch = rz_cons_readchar();
            rz_core_visual_mark(core, ch);
        } break;
        case 'M': {
            rz_cons_gotoxy(0, 0);
            if (rz_core_visual_mark_dump(core)) {
                rz_cons_printf(RZ_CONS_CLEAR_LINE "Remove a shortcut key from the list\n");
                rz_cons_flush();
                int ch = rz_cons_readchar();
                rz_core_visual_mark_del(core, ch);
            }
        } break;
        case '\'': {
            rz_cons_gotoxy(0, 0);
            if (rz_core_visual_mark_dump(core)) {
                rz_cons_flush();
                int ch = rz_cons_readchar();
                rz_core_visual_mark_seek(core, ch);
            }
        } break;
        case 'y':
            if (core->print->ocur == -1) {
                rz_core_yank(core, core->offset + core->print->cur, 1);
            } else {
                rz_core_yank(core, core->offset + ((core->print->ocur < core->print->cur) ? core->print->ocur : core->print->cur), RZ_ABS(core->print->cur - core->print->ocur) + 1);
            }
            break;
        case 'Y':
            if (!core->yank_buf) {
                rz_cons_strcat("Cannot paste, clipboard is empty.\n");
                rz_cons_flush();
                rz_cons_any_key(NULL);
                rz_cons_clear00();
            } else {
                rz_core_yank_paste(core, core->offset + core->print->cur, 0);
            }
            break;
        case '0': {
            RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, RZ_ANALYSIS_FCN_TYPE_NULL);
            if (fcn) {
                rz_core_seek_and_save(core, fcn->addr, true);
            }
        } break;
        case '-':
            if (core->print->cur_enabled) {
                if (core->printidx == RZ_CORE_VISUAL_MODE_DB) {
                    if (!core->seltab) {
                        // stack view
                        int w = rz_config_get_i(core->config, "hex.cols");
                        rz_config_set_i(core->config, "stack.size",
                            rz_config_get_i(core->config, "stack.size") - w);
                    }
                } else {
                    if (core->print->ocur == -1) {
                        sprintf(buf, "wos 01 @ $$+%i @!1", core->print->cur);
                    } else {
                        sprintf(buf, "wos 01 @ $$+%i @!%i", core->print->cur < core->print->ocur ? core->print->cur : core->print->ocur,
                            RZ_ABS(core->print->ocur - core->print->cur) + 1);
                    }
                    rz_core_cmd(core, buf, 0);
                }
            } else {
                if (!autoblocksize) {
                    rz_core_block_size(core, core->blocksize - 1);
                }
            }
            break;
        case '+':
            if (core->print->cur_enabled) {
                if (core->printidx == RZ_CORE_VISUAL_MODE_DB) {
                    if (!core->seltab) {
                        // stack view
                        int w = rz_config_get_i(core->config, "hex.cols");
                        rz_config_set_i(core->config, "stack.size",
                            rz_config_get_i(core->config, "stack.size") + w);
                    }
                } else {
                    if (core->print->ocur == -1) {
                        sprintf(buf, "woa 01 @ $$+%i @!1", core->print->cur);
                    } else {
                        sprintf(buf, "woa 01 @ $$+%i @!%i", core->print->cur < core->print->ocur ? core->print->cur : core->print->ocur,
                            RZ_ABS(core->print->ocur - core->print->cur) + 1);
                    }
                    rz_core_cmd(core, buf, 0);
                }
            } else {
                if (!autoblocksize) {
                    rz_core_block_size(core, core->blocksize + 1);
                }
            }
            break;
        case '/': {
            bool mouse_state = __holdMouseState(core);
            if (core->print->cur_enabled) {
                visual_search(core);
            } else {
                if (autoblocksize) {
                    rz_core_cmd0(core, "?i highlight;e scr.highlight=`yp`");
                } else {
                    rz_core_block_size(core, core->blocksize - cols);
                }
            }
            rz_cons_enable_mouse(mouse_state && rz_config_get_i(core->config, "scr.wheel"));
        } break;
        case ')':
            rotateAsmemu(core);
            break;
        case '#':
            if (core->printidx == 1) {
                rz_core_visual_toggle_decompiler_disasm(core, false, false);
            } else {
                // do nothing for now :?, px vs pxa?
            }
            break;
        case '*':
            if (core->print->cur_enabled) {
                rz_core_reg_set_by_role_or_name(core, "PC", core->offset + core->print->cur);
            } else if (!autoblocksize) {
                rz_core_block_size(core, core->blocksize + cols);
            }
            break;
        case '>':
            if (core->print->cur_enabled) {
                if (core->print->ocur == -1) {
                    eprintf("No range selected. Use HJKL.\n");
                    rz_cons_any_key(NULL);
                    break;
                }
                char buf[128];
                // TODO autocomplete filenames
                prompt_read("dump to file: ", buf, sizeof(buf));
                if (buf[0]) {
                    ut64 from = core->offset + core->print->ocur;
                    ut64 size = RZ_ABS(core->print->cur - core->print->ocur) + 1;
                    rz_core_dump(core, buf, from, size, false);
                }
            } else {
                rz_core_seek_and_save(core, core->offset + core->blocksize, false);
            }
            break;
        case '<': // "V<"
            if (core->print->cur_enabled) {
                char buf[128];
                // TODO autocomplete filenames
                prompt_read("load from file: ", buf, sizeof(buf));
                if (buf[0]) {
                    size_t sz;
                    char *data = rz_file_slurp(buf, &sz);
                    if (data) {
                        int cur;
                        if (core->print->ocur != -1) {
                            cur = RZ_MIN(core->print->cur, core->print->ocur);
                        } else {
                            cur = core->print->cur;
                        }
                        ut64 from = core->offset + cur;
                        ut64 size = RZ_ABS(core->print->cur - core->print->ocur) + 1;
                        ut64 s = RZ_MIN(size, (ut64)sz);
                        rz_io_write_at(core->io, from, (const ut8 *)data, s);
                    }
                }
            } else {
                rz_core_seek_and_save(core, core->offset - core->blocksize, false);
            }
            break;
        case '.': // "V."
            if (core->print->cur_enabled) {
                rz_config_set_i(core->config, "stack.delta", 0);
                rz_core_seek_and_save(core, core->offset + core->print->cur, true);
                core->print->cur = 0;
            } else {
                ut64 addr = rz_debug_reg_get(core->dbg, "PC");
                if (addr && addr != UT64_MAX) {
                    rz_core_seek_and_save(core, addr, true);
                    rz_core_analysis_set_reg(core, "PC", addr);
                } else {
                    ut64 entry = rz_num_get(core->num, "entry0");
                    if (!entry || entry == UT64_MAX) {
                        RzBinObject *o = rz_bin_cur_object(core->bin);
                        RzBinSection *s = o ? rz_bin_get_section_at(o, addr, core->io->va) : NULL;
                        if (s) {
                            entry = s->vaddr;
                        } else {
                            RzPVector *maps = rz_io_maps(core->io);
                            RzIOMap *map = rz_pvector_pop(maps);
                            if (map) {
                                entry = map->itv.addr;
                            } else {
                                entry = rz_config_get_i(core->config, "bin.baddr");
                            }
                            rz_pvector_push_front(maps, map);
                        }
                    }
                    if (entry != UT64_MAX) {
                        rz_core_seek_and_save(core, entry, true);
                    }
                }
            }
            break;
        case ':':
            rz_core_visual_prompt_input(core);
            break;
        case '_':
            rz_core_visual_hudstuff(core);
            break;
        case ';':
            rz_cons_gotoxy(0, 0);
            add_comment(core, core->offset, "Enter a comment: ('-' to remove, '!' to use cfg.editor)\n");
            break;
        case 'b':
            rz_core_visual_browse(core, arg + 1);
            break;
        case 'B': {
            ut64 addr = core->print->cur_enabled ? core->offset + core->print->cur : core->offset;
            rz_core_debug_breakpoint_toggle(core, addr);
        } break;
        case 'u':
            rz_core_visual_seek_animation_undo(core);
            break;
        case 'U':
            rz_core_visual_seek_animation_redo(core);
            break;
        case '?':
            if (visual_help(core) == '?') {
                rz_core_visual_hud(core);
            }
            break;
        case 0x1b:
        case 'q':
        case 'Q':
            setcursor(core, false);
            return false;
        }
        numbuf_i = 0;
    }
    rz_core_block_read(core);
    return true;
}

References __core_visual_gogo(), __core_visual_print_command(), __holdMouseState(), __ime, add_comment(), addr, rz_analysis_function_t::addr, rz_core_t::analysis, autoblocksize, rz_analysis_function_t::bbs, rz_core_t::bin, rz_core_t::block, rz_core_t::blocksize, canWrite(), cmd, rz_print_t::col, color, rz_print_t::cols, rz_core_t::config, rz_print_t::cur, rz_print_t::cur_enabled, cursor_left(), cursor_nextrow(), cursor_prevrow(), cursor_right(), rz_core_t::curtab, rz_core_t::dbg, delta, eprintf, f, findNextWord(), findPair(), findPrevWord(), rz_core_t::flags, free(), from, h, I, i, if(), rz_core_t::io, isdigit, isDisasmPrint(), isNumber(), KEY_ALTQ, map(), maps(), max, min, n, name, nextPrintCommand(), nextPrintFormat(), NULL, rz_core_t::num, numbuf_append(), numbuf_i, numbuf_pull(), obs, rz_print_t::ocur, off, rz_core_t::offset, op, p, rz_core_t::panels_root, PFMT64x, PIDX, prevPrintCommand(), prevPrintFormat(), rz_core_t::print, printfmtSingle, rz_core_t::printidx, prompt_read(), capstone::range, rz_core_t::rasm, reset_print_cur(), rotateAsmBits(), rotateAsmemu(), RZ_ABS, RZ_ANALYSIS_FCN_TYPE_NULL, rz_analysis_function_delete_label(), rz_analysis_function_set_label(), rz_analysis_get_fcn_in(), rz_analysis_op_free(), RZ_ANALYSIS_OP_MASK_BASIC, RZ_ANALYSIS_OP_TYPE_CALL, RZ_ANALYSIS_OP_TYPE_CCALL, RZ_ANALYSIS_OP_TYPE_CJMP, RZ_ANALYSIS_OP_TYPE_JMP, rz_asm_disassemble(), rz_bin_cur_object(), rz_bin_get_section_at(), rz_config_get(), rz_config_get_b(), rz_config_get_i(), rz_config_set(), rz_config_set_i(), rz_config_toggle(), rz_cons_any_key(), rz_cons_arrow_to_hjkl(), rz_cons_clear(), rz_cons_clear00(), RZ_CONS_CLEAR_LINE, rz_cons_enable_mouse(), rz_cons_fgets(), rz_cons_flush(), rz_cons_get_click(), rz_cons_get_size(), rz_cons_gotoxy(), rz_cons_message(), rz_cons_pal_random(), rz_cons_printf(), rz_cons_readchar(), rz_cons_set_raw(), rz_cons_singleton(), rz_cons_strcat(), rz_core_analysis_op(), rz_core_analysis_set_reg(), rz_core_block_read(), rz_core_block_size(), rz_core_cmd(), rz_core_cmd0(), rz_core_debug_breakpoint_toggle(), rz_core_debug_single_step_in(), rz_core_debug_single_step_over(), rz_core_dump(), rz_core_reg_set_by_role_or_name(), rz_core_seek(), rz_core_seek_and_save(), rz_core_seek_delta(), rz_core_seek_next(), rz_core_seek_prev(), rz_core_theme_nextpal(), rz_core_visual_analysis(), rz_core_visual_asm(), rz_core_visual_browse(), rz_core_visual_colors(), rz_core_visual_config(), rz_core_visual_define(), rz_core_visual_disasm_down(), rz_core_visual_disasm_up(), rz_core_visual_graph(), rz_core_visual_hud(), rz_core_visual_hudstuff(), rz_core_visual_jump(), rz_core_visual_mark(), rz_core_visual_mark_del(), rz_core_visual_mark_dump(), rz_core_visual_mark_seek(), RZ_CORE_VISUAL_MODE_DB, RZ_CORE_VISUAL_MODE_PD, rz_core_visual_offset(), rz_core_visual_panels_root(), rz_core_visual_prompt_input(), rz_core_visual_seek_animation(), rz_core_visual_seek_animation_redo(), rz_core_visual_seek_animation_undo(), rz_core_visual_showcursor(), rz_core_visual_toggle_decompiler_disasm(), rz_core_visual_toggle_hints(), rz_core_visual_xrefs(), rz_core_yank(), rz_core_yank_paste(), rz_debug_reg_get(), rz_file_slurp(), rz_flag_set(), rz_flag_unset_name(), rz_flag_unset_off(), RZ_FREE, rz_io_maps(), rz_io_write_at(), rz_line_readline(), rz_line_set_prompt(), RZ_MAX, rz_meta_get_at(), RZ_META_TYPE_DATA, RZ_META_TYPE_STRING, RZ_MIN, rz_num_get(), rz_num_math(), rz_pvector_pop(), rz_pvector_push_front(), rz_str_trim(), s, rz_print_t::screen_bounds, rz_core_t::seltab, setcursor(), setdiff(), setprintmode(), snprintf, splitPtr, splitView, sprintf, st64, strdup(), rz_core_visual_t::tabs, times, ut64(), UT64_MAX, rz_io_t::va, rz_core_t::visual, visual_comma(), visual_help(), visual_nkey(), visual_refresh(), visual_search(), w, x, and rz_core_t::yank_buf.

Referenced by rz_core_visual().

rz_core_visual_disasm_down()

RZ_API void rz_core_visual_disasm_down	(	RzCore *	core,
		RzAsmOp *	op,
		int *	cols
	)

Definition at line 3806 of file visual.c.

                                                                             {
    int midflags = rz_config_get_i(core->config, "asm.flags.middle");
    const bool midbb = rz_config_get_b(core->config, "asm.bb.middle");
    op->size = 1;
    rz_asm_set_pc(core->rasm, core->offset);
    *cols = rz_asm_disassemble(core->rasm,
        op, core->block, 32);
    if (midflags || midbb) {
        int skip_bytes_flag = 0, skip_bytes_bb = 0;
        if (midflags >= RZ_MIDFLAGS_REALIGN) {
            skip_bytes_flag = rz_core_flag_in_middle(core, core->offset, *cols, &midflags);
        }
        if (midbb) {
            skip_bytes_bb = rz_core_bb_starts_in_middle(core, core->offset, *cols);
        }
        if (skip_bytes_flag) {
            *cols = skip_bytes_flag;
        }
        if (skip_bytes_bb && skip_bytes_bb < *cols) {
            *cols = skip_bytes_bb;
        }
    }
    if (*cols < 1) {
        *cols = op->size > 1 ? op->size : 1;
    }
}

References rz_core_t::block, rz_core_t::config, rz_core_t::offset, rz_core_t::rasm, rz_asm_disassemble(), rz_asm_set_pc(), rz_config_get_b(), rz_config_get_i(), rz_core_bb_starts_in_middle(), and rz_core_flag_in_middle().

Referenced by __direction_disassembly_cb(), and rz_core_visual_cmd().

rz_core_visual_disasm_up()

RZ_API void rz_core_visual_disasm_up	(	RzCore *	core,
		int *	cols
	)

Definition at line 3802 of file visual.c.

                                                              {
    *cols = rz_core_visual_prevopsz(core, core->offset);
}

References rz_core_t::offset, and rz_core_visual_prevopsz().

Referenced by __direction_disassembly_cb(), and rz_core_visual_cmd().

rz_core_visual_hud()

RZ_API bool rz_core_visual_hud

(

RzCore *

core

)

Definition at line 471 of file visual.c.

                                             {
    const char *c = rz_config_get(core->config, "hud.path");
    char *system_hud_dir = rz_path_system(RZ_HUD);
    char *f = rz_file_path_join(system_hud_dir, "main");
    free(system_hud_dir);
    int use_color = core->print->flags & RZ_PRINT_FLAGS_COLOR;
    char *homehud = rz_path_home_prefix(RZ_HUD);
    char *res = NULL;
    char *p = 0;
    rz_cons_singleton()->context->color_mode = use_color;
 
    rz_core_visual_showcursor(core, true);
    if (c && *c && rz_file_exists(c)) {
        res = rz_cons_hud_file(c);
    }
    if (!res && homehud) {
        res = rz_cons_hud_file(homehud);
    }
    if (!res && rz_file_exists(f)) {
        res = rz_cons_hud_file(f);
    }
    if (!res) {
        rz_cons_message("Cannot find hud file");
        return false;
    }
 
    rz_cons_clear();
    if (res) {
        p = strchr(res, ';');
        rz_cons_println(res);
        rz_cons_flush();
        if (p) {
            rz_core_cmd0(core, p + 1);
        }
        free(res);
    }
    rz_core_visual_showcursor(core, false);
    rz_cons_flush();
    free(homehud);
    free(f);
    return true;
}

References c, rz_cons_context_t::color_mode, rz_core_t::config, rz_cons_t::context, f, rz_print_t::flags, free(), NULL, p, rz_core_t::print, rz_config_get(), rz_cons_clear(), rz_cons_flush(), rz_cons_hud_file(), rz_cons_message(), rz_cons_println(), rz_cons_singleton(), rz_core_cmd0(), rz_core_visual_showcursor(), rz_file_exists(), rz_file_path_join(), RZ_HUD, rz_path_home_prefix(), rz_path_system(), and RZ_PRINT_FLAGS_COLOR.

Referenced by __panels_process(), and rz_core_visual_cmd().

rz_core_visual_jump()

RZ_API void rz_core_visual_jump	(	RzCore *	core,
		ut8	ch
	)

Definition at line 514 of file visual.c.

                                                      {
    char chbuf[2];
    ut64 off;
    chbuf[0] = ch;
    chbuf[1] = '\0';
    off = rz_core_get_asmqjmps(core, chbuf);
    if (off != UT64_MAX) {
        int delta = RZ_ABS((st64)off - (st64)core->offset);
        if (core->print->cur_enabled && delta < 100) {
            core->print->cur = delta;
        } else {
            rz_core_visual_seek_animation(core, off);
            core->print->cur = 0;
        }
        rz_core_block_read(core);
    }
}

References rz_print_t::cur, rz_print_t::cur_enabled, delta, off, rz_core_t::offset, rz_core_t::print, RZ_ABS, rz_core_block_read(), rz_core_get_asmqjmps(), rz_core_visual_seek_animation(), st64, ut64(), and UT64_MAX.

Referenced by __panels_process(), and rz_core_visual_cmd().

rz_core_visual_offset()

RZ_API void rz_core_visual_offset

(

RzCore *

core

)

Definition at line 1247 of file visual.c.

                                                {
    char buf[256];
 
    core->cons->line->prompt_type = RZ_LINE_PROMPT_OFFSET;
    rz_line_set_hist_callback(core->cons->line,
        &rz_line_hist_offset_up,
        &rz_line_hist_offset_down);
    rz_line_set_prompt("[offset]> ");
    if (rz_cons_fgets(buf, sizeof(buf) - 1, 0, NULL) > 0) {
        if (!strcmp(buf, "g") || !strcmp(buf, "G")) {
            __core_visual_gogo(core, buf[0]);
        } else {
            if (buf[0] == '.') {
                rz_core_seek_base(core, buf + 1, true);
            } else {
                ut64 addr = rz_num_math(core->num, buf);
                rz_core_seek_and_save(core, addr, true);
            }
        }
        reset_print_cur(core->print);
    }
    rz_line_set_hist_callback(core->cons->line, &rz_line_hist_cmd_up, &rz_line_hist_cmd_down);
    core->cons->line->prompt_type = RZ_LINE_PROMPT_DEFAULT;
}

References __core_visual_gogo(), addr, rz_core_t::cons, rz_cons_t::line, NULL, rz_core_t::num, rz_core_t::print, rz_line_t::prompt_type, reset_print_cur(), rz_cons_fgets(), rz_core_seek_and_save(), rz_core_seek_base(), rz_line_hist_cmd_down(), rz_line_hist_cmd_up(), rz_line_hist_offset_down(), rz_line_hist_offset_up(), RZ_LINE_PROMPT_DEFAULT, RZ_LINE_PROMPT_OFFSET, rz_line_set_hist_callback(), rz_line_set_prompt(), rz_num_math(), and ut64().

Referenced by __panels_process(), rz_core_visual_analysis(), and rz_core_visual_cmd().

rz_core_visual_prevopsz()

RZ_API int rz_core_visual_prevopsz	(	RzCore *	core,
		ut64	addr
	)

Definition at line 1272 of file visual.c.

                                                            {
    ut64 prev_addr = prevop_addr(core, addr);
    return addr - prev_addr;
}

References addr, prevop_addr(), and ut64().

Referenced by __fix_cursor_up(), fix_cursor(), and rz_core_visual_disasm_up().

rz_core_visual_prompt()

RZ_API int rz_core_visual_prompt

(

RzCore *

core

)

Definition at line 756 of file visual.c.

                                               {
    char buf[1024];
    int ret;
    if (PIDX != 2) {
        core->seltab = 0;
    }
#if __UNIX__
    rz_line_set_prompt(Color_RESET ":> ");
#else
    rz_line_set_prompt(":> ");
#endif
    rz_core_visual_showcursor(core, true);
    rz_cons_fgets(buf, sizeof(buf), 0, NULL);
    if (!strcmp(buf, "q")) {
        ret = false;
    } else if (*buf) {
        rz_line_hist_add(buf);
        rz_core_cmd(core, buf, 0);
        rz_cons_echo(NULL);
        rz_cons_flush();
        ret = true;
        if (rz_config_get_b(core->config, "cfg.debug")) {
            rz_core_reg_update_flags(core);
        }
    } else {
        ret = false;
        // rz_cons_any_key (NULL);
        rz_cons_clear00();
        rz_core_visual_showcursor(core, false);
    }
    return ret;
}

References Color_RESET, rz_core_t::config, NULL, PIDX, rz_config_get_b(), rz_cons_clear00(), rz_cons_echo(), rz_cons_fgets(), rz_cons_flush(), rz_core_cmd(), rz_core_reg_update_flags(), rz_core_visual_showcursor(), rz_line_hist_add(), rz_line_set_prompt(), and rz_core_t::seltab.

Referenced by rz_core_visual_analysis(), rz_core_visual_debugtraces(), and rz_core_visual_prompt_input().

rz_core_visual_prompt_input()

RZ_API void rz_core_visual_prompt_input

(

RzCore *

core

)

Definition at line 733 of file visual.c.

                                                      {
    ut64 addr, bsze, newaddr = 0LL;
    int ret, h, cur;
    (void)rz_cons_get_size(&h);
    bool mouse_state = __holdMouseState(core);
    rz_cons_gotoxy(0, h);
    rz_cons_reset_colors();
    // rz_cons_printf ("\nPress <enter> to return to Visual mode.\n");
    rz_cons_show_cursor(true);
    core->vmode = false;
 
    backup_current_addr(core, &addr, &bsze, &newaddr, &cur);
    do {
        ret = rz_core_visual_prompt(core);
    } while (ret);
    restore_current_addr(core, addr, bsze, newaddr, cur);
 
    rz_cons_show_cursor(false);
    core->vmode = true;
    rz_cons_enable_mouse(mouse_state && rz_config_get_b(core->config, "scr.wheel"));
    rz_cons_show_cursor(true);
}

References __holdMouseState(), addr, backup_current_addr(), rz_core_t::config, h, restore_current_addr(), rz_config_get_b(), rz_cons_enable_mouse(), rz_cons_get_size(), rz_cons_gotoxy(), rz_cons_reset_colors(), rz_cons_show_cursor(), rz_core_visual_prompt(), ut64(), and rz_core_t::vmode.

Referenced by __handlePrompt(), __panels_process(), __rz_shell_cb(), rz_core_visual_browse(), rz_core_visual_cmd(), rz_core_visual_graph(), and rz_core_visual_xrefs().

rz_core_visual_seek_animation()

RZ_API void rz_core_visual_seek_animation	(	RzCore *	core,
		ut64	addr
	)

Definition at line 1077 of file visual.c.

                                                                   {
    rz_core_seek_and_save(core, addr, true);
    visual_seek_animation(core, addr);
}

References addr, rz_core_seek_and_save(), and visual_seek_animation().

Referenced by rz_core_visual_cmd(), and rz_core_visual_jump().

rz_core_visual_seek_animation_redo()

RZ_API void rz_core_visual_seek_animation_redo

(

RzCore *

core

)

Definition at line 1082 of file visual.c.

                                                             {
    if (rz_core_seek_redo(core)) {
        visual_seek_animation(core, core->offset);
    }
}

References rz_core_t::offset, rz_core_seek_redo(), and visual_seek_animation().

Referenced by __redo_seek(), and rz_core_visual_cmd().

rz_core_visual_seek_animation_undo()

RZ_API void rz_core_visual_seek_animation_undo

(

RzCore *

core

)

Definition at line 1088 of file visual.c.

                                                             {
    if (rz_core_seek_undo(core)) {
        visual_seek_animation(core, core->offset);
    }
}

References rz_core_t::offset, rz_core_seek_undo(), and visual_seek_animation().

Referenced by __undo_seek(), and rz_core_visual_cmd().

rz_core_visual_show_char()

RZ_API void rz_core_visual_show_char	(	RzCore *	core,
		char	ch
	)

Definition at line 1041 of file visual.c.

                                                            {
    if (rz_config_get_i(core->config, "scr.feedback") < 2) {
        return;
    }
    if (!IS_PRINTABLE(ch)) {
        return;
    }
    rz_cons_gotoxy(1, 2);
    rz_cons_printf(".---.\n");
    rz_cons_printf("| %c |\n", ch);
    rz_cons_printf("'---'\n");
    rz_cons_flush();
    rz_sys_sleep(1);
}

References rz_core_t::config, IS_PRINTABLE, rz_config_get_i(), rz_cons_flush(), rz_cons_gotoxy(), rz_cons_printf(), and rz_sys_sleep().

Referenced by rz_core_visual().

rz_core_visual_showcursor()

RZ_API void rz_core_visual_showcursor	(	RzCore *	core,
		int	x
	)

Definition at line 420 of file visual.c.

                                                           {
    if (core && core->vmode) {
        rz_cons_show_cursor(x);
        rz_cons_enable_mouse(rz_config_get_b(core->config, "scr.wheel"));
    } else {
        rz_cons_enable_mouse(false);
    }
    rz_cons_flush();
}

References rz_core_t::config, rz_config_get_b(), rz_cons_enable_mouse(), rz_cons_flush(), rz_cons_show_cursor(), rz_core_t::vmode, and x.

Referenced by __panels_process(), add_comment(), findNextWord(), findPair(), findPrevWord(), prompt_read(), rz_core_visual_analysis(), rz_core_visual_cmd(), rz_core_visual_hud(), rz_core_visual_prompt(), and visual_search().

rz_core_visual_title()

RZ_API void rz_core_visual_title	(	RzCore *	core,
		int	color
	)

Definition at line 3287 of file visual.c.

                                                          {
    bool showDelta = rz_config_get_b(core->config, "scr.slow");
    static ut64 oldpc = 0;
    const char *BEGIN = core->cons->context->pal.prompt;
    const char *filename;
    char pos[512], bar[512], pcs[32];
    if (!oldpc) {
        oldpc = rz_debug_reg_get(core->dbg, "PC");
    }
    /* automatic block size */
    int pc, hexcols = rz_config_get_i(core->config, "hex.cols");
    if (autoblocksize) {
        switch (core->printidx) {
        case RZ_CORE_VISUAL_MODE_PX: // x
            if (currentFormat == 3 || currentFormat == 9 || currentFormat == 5) { // prx
                rz_core_block_size(core, (int)(core->cons->rows * hexcols * 4));
            } else if ((RZ_ABS(hexMode) % 3) == 0) { // prx
                rz_core_block_size(core, (int)(core->cons->rows * hexcols));
            } else {
                rz_core_block_size(core, (int)(core->cons->rows * hexcols * 2));
            }
            break;
        case RZ_CORE_VISUAL_MODE_OV:
        case RZ_CORE_VISUAL_MODE_CD:
            rz_core_block_size(core, (int)(core->cons->rows * hexcols * 2));
            break;
        case RZ_CORE_VISUAL_MODE_PD: // pd
        case RZ_CORE_VISUAL_MODE_DB: // pd+dbg
        {
            int bsize = core->cons->rows * 5;
 
            if (core->print->screen_bounds > 1) {
                // estimate new blocksize with the size of the last
                // printed instructions
                int new_sz = core->print->screen_bounds - core->offset + 32;
                new_sz = RZ_MIN(new_sz, 16 * 1024);
                if (new_sz > bsize) {
                    bsize = new_sz;
                }
            }
            rz_core_block_size(core, bsize);
            break;
        }
        }
    }
    if (rz_config_get_i(core->config, "scr.scrollbar") == 2) {
        visual_flagzone(core);
    }
    if (rz_config_get_b(core->config, "cfg.debug")) {
        ut64 curpc = rz_debug_reg_get(core->dbg, "PC");
        if (curpc && curpc != UT64_MAX && curpc != oldpc) {
            // check dbg.follow here
            int follow = (int)(st64)rz_config_get_i(core->config, "dbg.follow");
            if (follow > 0) {
                if ((curpc < core->offset) || (curpc > (core->offset + follow))) {
                    rz_core_seek(core, curpc, true);
                }
            } else if (follow < 0) {
                rz_core_seek(core, curpc + follow, true);
            }
            rz_core_debug_sync_bits(core);
            oldpc = curpc;
        }
    }
    RzIOMap *map = rz_io_map_get(core->io, core->offset);
    RzIODesc *desc = map
        ? rz_io_desc_get(core->io, map->fd)
        : core->file ? rz_io_desc_get(core->io, core->file->fd)
                 : NULL;
    filename = desc ? desc->name : "";
 
    { /* get flag with delta */
        ut64 addr = core->offset + (core->print->cur_enabled ? core->print->cur : 0);
        /* TODO: we need a helper into rz_flags to do that */
        RzFlagItem *f = NULL;
        if (rz_flag_space_push(core->flags, RZ_FLAGS_FS_SYMBOLS)) {
            f = rz_flag_get_at(core->flags, addr, showDelta);
            rz_flag_space_pop(core->flags);
        }
        if (!f) {
            f = rz_flag_get_at(core->flags, addr, showDelta);
        }
        if (f) {
            if (f->offset == addr || !f->offset) {
                snprintf(pos, sizeof(pos), "@ %s", f->name);
            } else {
                snprintf(pos, sizeof(pos), "@ %s+%d # 0x%" PFMT64x,
                    f->name, (int)(addr - f->offset), addr);
            }
        } else {
            RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, addr, 0);
            if (fcn) {
                int delta = addr - fcn->addr;
                if (delta > 0) {
                    snprintf(pos, sizeof(pos), "@ %s+%d", fcn->name, delta);
                } else if (delta < 0) {
                    snprintf(pos, sizeof(pos), "@ %s%d", fcn->name, delta);
                } else {
                    snprintf(pos, sizeof(pos), "@ %s", fcn->name);
                }
            } else {
                pos[0] = 0;
            }
        }
    }
 
    if (core->print->cur < 0) {
        core->print->cur = 0;
    }
 
    if (color) {
        rz_cons_strcat(BEGIN);
    }
    const char *cmd_visual = rz_config_get(core->config, "cmd.visual");
    if (cmd_visual && *cmd_visual) {
        rz_str_ncpy(bar, cmd_visual, sizeof(bar) - 1);
        bar[10] = '.'; // chop cmdfmt
        bar[11] = '.'; // chop cmdfmt
        bar[12] = 0; // chop cmdfmt
    } else {
        const char *cmd = __core_visual_print_command(core);
        if (cmd) {
            rz_str_ncpy(bar, cmd, sizeof(bar) - 1);
            bar[10] = '.'; // chop cmdfmt
            bar[11] = '.'; // chop cmdfmt
            bar[12] = 0; // chop cmdfmt
        }
    }
    {
        ut64 sz = rz_io_size(core->io);
        ut64 pa = core->offset;
        {
            RzIOMap *map = rz_io_map_get(core->io, core->offset);
            if (map) {
                pa = map->delta;
            }
        }
        if (sz == UT64_MAX) {
            pcs[0] = 0;
        } else {
            if (!sz || pa > sz) {
                pc = 0;
            } else {
                pc = (pa * 100) / sz;
            }
            sprintf(pcs, "%d%% ", pc);
        }
    }
    {
        char *title;
        char *address = (core->print->wide_offsets && core->dbg->bits & RZ_SYS_BITS_64)
            ? rz_str_newf("0x%016" PFMT64x, core->offset)
            : rz_str_newf("0x%08" PFMT64x, core->offset);
        if (__ime) {
            title = rz_str_newf("[%s + %d> * INSERT MODE *\n",
                address, core->print->cur);
        } else {
            char pm[32] = "[XADVC]";
            int i;
            for (i = 0; i < 6; i++) {
                if (core->printidx == i) {
                    pm[i + 1] = toupper(pm[i + 1]);
                } else {
                    pm[i + 1] = tolower(pm[i + 1]);
                }
            }
            if (core->print->cur_enabled) {
                if (core->print->ocur == -1) {
                    title = rz_str_newf("[%s *0x%08" PFMT64x " %s%d ($$+0x%x)]> %s %s\n",
                        address, core->offset + core->print->cur,
                        pm, currentFormat, core->print->cur,
                        bar, pos);
                } else {
                    title = rz_str_newf("[%s 0x%08" PFMT64x " %s%d [0x%x..0x%x] %d]> %s %s\n",
                        address, core->offset + core->print->cur,
                        pm, currentFormat, core->print->ocur, core->print->cur,
                        RZ_ABS(core->print->cur - core->print->ocur) + 1,
                        bar, pos);
                }
            } else {
                title = rz_str_newf("[%s %s%d %s%d %s]> %s %s\n",
                    address, pm, currentFormat, pcs, core->blocksize, filename, bar, pos);
            }
        }
        const int tabsCount = __core_visual_tab_count(core);
        if (tabsCount > 0) {
            const char *kolor = core->cons->context->pal.prompt;
            char *tabstring = __core_visual_tab_string(core, kolor);
            if (tabstring) {
                title = rz_str_append(title, tabstring);
                free(tabstring);
            }
#if 0
            // TODO: add an option to show this tab mode instead?
            const int curTab = core->visual.tab;
            rz_cons_printf ("[");
            int i;
            for (i = 0; i < tabsCount; i++) {
                if (i == curTab) {
                    rz_cons_printf ("%d", curTab + 1);
                } else {
                    rz_cons_printf (".");
                }
            }
            rz_cons_printf ("]");
            rz_cons_printf ("[tab:%d/%d]", core->visual.tab, tabsCount);
#endif
        }
        rz_cons_print(title);
        free(title);
        free(address);
    }
    if (color) {
        rz_cons_strcat(Color_RESET);
    }
}

References __core_visual_print_command(), __ime, addr, rz_analysis_function_t::addr, rz_core_t::analysis, autoblocksize, rz_debug_t::bits, rz_core_t::blocksize, cmd, color, Color_RESET, rz_core_t::config, rz_core_t::cons, rz_cons_t::context, rz_print_t::cur, rz_print_t::cur_enabled, currentFormat, rz_core_t::dbg, delta, desc, f, rz_core_file_t::fd, rz_core_t::file, rz_core_t::flags, free(), hexMode, i, int, rz_core_t::io, map(), rz_analysis_function_t::name, NULL, rz_print_t::ocur, rz_core_t::offset, rz_cons_context_t::pal, pc, PFMT64x, pos, rz_core_t::print, rz_core_t::printidx, rz_cons_printable_palette_t::prompt, rz_cons_t::rows, RZ_ABS, rz_analysis_get_fcn_in(), rz_config_get(), rz_config_get_b(), rz_config_get_i(), rz_cons_printf(), rz_cons_strcat(), rz_core_block_size(), rz_core_debug_sync_bits(), rz_core_seek(), RZ_CORE_VISUAL_MODE_CD, RZ_CORE_VISUAL_MODE_DB, RZ_CORE_VISUAL_MODE_OV, RZ_CORE_VISUAL_MODE_PD, RZ_CORE_VISUAL_MODE_PX, rz_debug_reg_get(), rz_flag_get_at(), RZ_FLAGS_FS_SYMBOLS, rz_io_desc_get(), rz_io_map_get(), rz_io_size(), RZ_MIN, rz_str_append(), rz_str_ncpy(), rz_str_newf(), RZ_SYS_BITS_64, rz_print_t::screen_bounds, snprintf, sprintf, st64, rz_core_visual_t::tab, tolower, toupper, ut64(), UT64_MAX, rz_core_t::visual, visual_flagzone(), and rz_print_t::wide_offsets.

Referenced by visual_refresh().

rz_core_visual_toggle_decompiler_disasm()

RZ_API void rz_core_visual_toggle_decompiler_disasm	(	RzCore *	core,
		bool	for_graph,
		bool	reset
	)

Definition at line 127 of file visual.c.

                                                                                              {
    static RzConfigHold *hold = NULL; // should be a tab-specific var
    if (hold) {
        rz_config_hold_restore(hold);
        rz_config_hold_free(hold);
        hold = NULL;
        return;
    }
    if (reset) {
        return;
    }
    hold = rz_config_hold_new(core->config);
    rz_config_hold_s(hold, "asm.hint.pos", "asm.cmt.col", "asm.offset", "asm.lines",
        "asm.indent", "asm.bytes", "asm.comments", "asm.dwarf", "asm.usercomments", "asm.instr", NULL);
    if (for_graph) {
        rz_config_set(core->config, "asm.hint.pos", "-2");
        rz_config_set(core->config, "asm.lines", "false");
        rz_config_set(core->config, "asm.indent", "false");
    } else {
        rz_config_set(core->config, "asm.hint.pos", "0");
        rz_config_set(core->config, "asm.indent", "true");
        rz_config_set(core->config, "asm.lines", "true");
    }
    rz_config_set(core->config, "asm.cmt.col", "0");
    rz_config_set(core->config, "asm.offset", "false");
    rz_config_set(core->config, "asm.dwarf", "true");
    rz_config_set(core->config, "asm.bytes", "false");
    rz_config_set(core->config, "asm.comments", "false");
    rz_config_set(core->config, "asm.usercomments", "true");
    rz_config_set(core->config, "asm.instr", "false");
}

References rz_core_t::config, NULL, rz_config_hold_free(), rz_config_hold_new(), rz_config_hold_restore(), rz_config_hold_s(), and rz_config_set().

Referenced by get_body(), rz_core_visual_cmd(), and rz_core_visual_xrefs().

rz_core_visual_toggle_hints()

RZ_API void rz_core_visual_toggle_hints

(

RzCore *

core

)

Definition at line 109 of file visual.c.

                                                      {
    if (rz_config_get_b(core->config, "asm.hint.call")) {
        rz_config_toggle(core->config, "asm.hint.call");
        rz_config_set_b(core->config, "asm.hint.jmp", true);
    } else if (rz_config_get_b(core->config, "asm.hint.jmp")) {
        rz_config_toggle(core->config, "asm.hint.jmp");
        rz_config_set_b(core->config, "asm.hint.emu", true);
    } else if (rz_config_get_b(core->config, "asm.hint.emu")) {
        rz_config_toggle(core->config, "asm.hint.emu");
        rz_config_set_b(core->config, "asm.hint.lea", true);
    } else if (rz_config_get_b(core->config, "asm.hint.lea")) {
        rz_config_toggle(core->config, "asm.hint.lea");
        rz_config_set_b(core->config, "asm.hint.call", true);
    } else {
        rz_config_set_b(core->config, "asm.hint.call", true);
    }
}

References rz_core_t::config, rz_config_get_b(), rz_config_set_b(), and rz_config_toggle().

Referenced by __panels_process(), rz_core_visual_cmd(), and rz_core_visual_graph().

rz_core_visual_xrefs()

RZ_API int rz_core_visual_xrefs	(	RzCore *	core,
		bool	xref_to,
		bool	fcnInsteadOfAddr
	)

Definition at line 1312 of file visual.c.

                                                                                   {
    ut64 cur_ref_addr = UT64_MAX;
    int ret = 0;
    char ch;
    int count = 0;
    RzList *xrefs = NULL;
    RzAnalysisXRef *xrefi;
    RzListIter *iter;
    int skip = 0;
    int idx = 0;
    char cstr[32];
    ut64 addr = core->offset;
    bool xrefsMode = fcnInsteadOfAddr;
    int lastPrintMode = 3;
    if (core->print->cur_enabled) {
        addr += core->print->cur;
    }
repeat:
    rz_list_free(xrefs);
    if (xrefsMode) {
        RzAnalysisFunction *fun = rz_analysis_get_fcn_in(core->analysis, addr, RZ_ANALYSIS_FCN_TYPE_NULL);
        if (fun) {
            if (xref_to) { //  function xrefs
                xrefs = rz_analysis_xrefs_get_to(core->analysis, addr);
                // XXX xrefs = rz_analysis_function_get_xrefs_to(core->analysis, fun);
                //  this function is buggy so we must get the xrefs of the addr
            } else { // functon refs
                xrefs = rz_analysis_function_get_xrefs_from(fun);
            }
        } else {
            xrefs = NULL;
        }
    } else {
        if (xref_to) { // address xrefs
            xrefs = rz_analysis_xrefs_get_to(core->analysis, addr);
        } else { // address refs
            xrefs = rz_analysis_xrefs_get_from(core->analysis, addr);
        }
    }
 
    rz_cons_clear00();
    rz_cons_gotoxy(1, 1);
    {
        char *address = (core->dbg->bits & RZ_SYS_BITS_64)
            ? rz_str_newf("0x%016" PFMT64x, addr)
            : rz_str_newf("0x%08" PFMT64x, addr);
        rz_cons_printf("[%s%srefs]> %s # (TAB/jk/q/?) ",
            xrefsMode ? "fcn." : "addr.", xref_to ? "x" : "", address);
        free(address);
    }
    if (!xrefs || rz_list_empty(xrefs)) {
        rz_list_free(xrefs);
        xrefs = NULL;
        rz_cons_printf("\n\n(no %srefs)\n", xref_to ? "x" : "");
    } else {
        int h, w = rz_cons_get_size(&h);
        bool asm_bytes = rz_config_get_b(core->config, "asm.bytes");
        rz_config_set_b(core->config, "asm.bytes", false);
        RzCmdStateOutput state;
        if (!rz_cmd_state_output_init(&state, RZ_OUTPUT_MODE_STANDARD)) {
            return RZ_CMD_STATUS_INVALID;
        }
        rz_core_flag_describe(core, core->offset, false, &state);
        rz_cmd_state_output_fini(&state);
        int maxcount = 9;
        int rows, cols = rz_cons_get_size(&rows);
        count = 0;
        char *dis = NULL;
        rows -= 4;
        idx = 0;
        ut64 curat = UT64_MAX;
        rz_list_foreach (xrefs, iter, xrefi) {
            ut64 xaddr1 = xref_to ? xrefi->from : xrefi->to;
            ut64 xaddr2 = xref_to ? xrefi->to : xrefi->from;
            if (idx - skip > maxcount) {
                rz_cons_printf("...");
                break;
            }
            if (!iter->n && idx < skip) {
                skip = idx;
            }
            if (idx >= skip) {
                if (count > maxcount) {
                    strcpy(cstr, "?");
                } else {
                    snprintf(cstr, sizeof(cstr), "%d", count);
                }
                if (idx == skip) {
                    cur_ref_addr = xaddr1;
                }
                RzAnalysisFunction *fun = rz_analysis_get_fcn_in(core->analysis, xaddr1, RZ_ANALYSIS_FCN_TYPE_NULL);
                char *name;
                if (fun) {
                    name = strdup(fun->name);
                } else {
                    RzFlagItem *f = rz_flag_get_at(core->flags, xaddr1, true);
                    if (f) {
                        name = rz_str_newf("%s + %" PFMT64d, f->name, xaddr1 - f->offset);
                    } else {
                        name = strdup("unk");
                    }
                }
                if (w > 45) {
                    if (strlen(name) > w - 45) {
                        name[w - 45] = 0;
                    }
                } else {
                    name[0] = 0;
                }
 
                const char *cmt = rz_meta_get_string(core->analysis, RZ_META_TYPE_COMMENT, xaddr1);
                if (cmt) {
                    cmt = rz_str_trim_head_ro(cmt);
                    rz_cons_printf(" %d [%s] 0x%08" PFMT64x " 0x%08" PFMT64x " %s %sref (%s) ; %s\n",
                        idx, cstr, xaddr2, xaddr1,
                        rz_analysis_xrefs_type_tostring(xrefi->type),
                        xref_to ? "x" : "", name, cmt);
                }
                free(name);
                if (idx == skip) {
                    free(dis);
                    curat = xaddr1;
                    char *res = rz_core_cmd_strf(core, "pd 4 @ 0x%08" PFMT64x "@e:asm.flags.limit=1", xaddr2);
                    // TODO: show disasm with context. not seek addr
                    // dis = rz_core_cmd_strf (core, "pd $r-4 @ 0x%08"PFMT64x, xaddr);
                    dis = NULL;
                    res = rz_str_appendf(res, "; ---------------------------\n");
                    switch (printMode) {
                    case 0:
                        dis = rz_core_cmd_strf(core, "pd $r-4 @ 0x%08" PFMT64x, xaddr1);
                        break;
                    case 1:
                        dis = rz_core_cmd_strf(core, "pd @ 0x%08" PFMT64x "-32", xaddr1);
                        break;
                    case 2:
                        dis = rz_core_cmd_strf(core, "px @ 0x%08" PFMT64x, xaddr1);
                        break;
                    case 3:
                        dis = rz_core_cmd_strf(core, "pds @ 0x%08" PFMT64x, xaddr1);
                        break;
                    }
                    if (dis) {
                        res = rz_str_append(res, dis);
                        free(dis);
                    }
                    dis = res;
                }
                if (++count >= rows) {
                    rz_cons_printf("...");
                    break;
                }
            }
            idx++;
        }
        if (dis) {
            if (count < rows) {
                rz_cons_newline();
            }
            int i = count;
            for (; i < 9; i++) {
                rz_cons_newline();
            }
            /* prepare highlight */
            char *cmd = strdup(rz_config_get(core->config, "scr.highlight"));
            char *ats = rz_str_newf("%" PFMT64x, curat);
            if (ats && !*cmd) {
                (void)rz_config_set(core->config, "scr.highlight", ats);
            }
            /* print disasm */
            char *d = rz_str_ansi_crop(dis, 0, 0, cols, rows - 9);
            if (d) {
                rz_cons_printf("%s", d);
                free(d);
            }
            /* flush and restore highlight */
            rz_cons_flush();
            rz_config_set(core->config, "scr.highlight", cmd);
            free(ats);
            free(cmd);
            free(dis);
            dis = NULL;
        }
        rz_config_set_b(core->config, "asm.bytes", asm_bytes);
    }
    rz_cons_flush();
    rz_cons_enable_mouse(rz_config_get_b(core->config, "scr.wheel"));
    ch = rz_cons_readchar();
    ch = rz_cons_arrow_to_hjkl(ch);
    if (ch == ':') {
        rz_core_visual_prompt_input(core);
        goto repeat;
    } else if (ch == '?') {
        rz_cons_clear00();
        rz_cons_printf("Usage: Visual Xrefs\n"
                   " jk  - select next or previous item (use arrows)\n"
                   " JK  - step 10 rows\n"
                   " pP  - rotate between various print modes\n"
                   " :   - run rizin command\n"
                   " /   - highlight given word\n"
                   " ?   - show this help message\n"
                   " <>  - '<' for xrefs and '>' for refs\n"
                   " TAB - toggle between address and function references\n"
                   " xX  - switch to refs or xrefs\n"
                   " q   - quit this view\n"
                   " \\n  - seek to this xref");
        rz_cons_flush();
        rz_cons_any_key(NULL);
        goto repeat;
    } else if (ch == 9) { // TAB
        xrefsMode = !xrefsMode;
        rz_core_visual_toggle_decompiler_disasm(core, false, true);
        goto repeat;
    } else if (ch == 'p') {
        rz_core_visual_toggle_decompiler_disasm(core, false, true);
        printMode++;
        if (printMode > lastPrintMode) {
            printMode = 0;
        }
        goto repeat;
    } else if (ch == 'P') {
        rz_core_visual_toggle_decompiler_disasm(core, false, true);
        printMode--;
        if (printMode < 0) {
            printMode = lastPrintMode;
        }
        goto repeat;
    } else if (ch == '/') {
        rz_core_cmd0(core, "?i highlight;e scr.highlight=`yp`");
        goto repeat;
    } else if (ch == 'x' || ch == '<') {
        xref_to = true;
        xrefsMode = !xrefsMode;
        goto repeat;
    } else if (ch == 'X' || ch == '>') {
        xref_to = false;
        xrefsMode = !xrefsMode;
        goto repeat;
    } else if (ch == 'J') {
        skip += 10;
        goto repeat;
    } else if (ch == 'g') {
        skip = 0;
        goto repeat;
    } else if (ch == 'G') {
        skip = 9999;
        goto repeat;
    } else if (ch == ';') {
        add_comment(core, cur_ref_addr, "\nEnter comment for reference:\n");
        goto repeat;
    } else if (ch == '.') {
        skip = 0;
        goto repeat;
    } else if (ch == 'j') {
        skip++;
        goto repeat;
    } else if (ch == 'K') {
        skip = (skip < 10) ? 0 : skip - 10;
        goto repeat;
    } else if (ch == 'k') {
        skip--;
        if (skip < 0) {
            skip = 0;
        }
        goto repeat;
    } else if (ch == ' ' || ch == '\n' || ch == '\r' || ch == 'l') {
        ret = follow_ref(core, xrefs, skip, xref_to);
    } else if (IS_DIGIT(ch)) {
        ret = follow_ref(core, xrefs, ch - 0x30, xref_to);
    } else if (ch != 'q' && ch != 'Q' && ch != 'h') {
        goto repeat;
    }
    rz_list_free(xrefs);
 
    return ret;
}

References add_comment(), addr, rz_core_t::analysis, rz_debug_t::bits, cmd, rz_core_t::config, count, rz_print_t::cur, rz_print_t::cur_enabled, d, rz_core_t::dbg, dis(), f, rz_core_t::flags, follow_ref(), free(), rz_analysis_ref_t::from, h, i, setup::idx, IS_DIGIT, lastPrintMode, name, rz_analysis_function_t::name, NULL, rz_core_t::offset, PFMT64d, PFMT64x, rz_core_t::print, printMode, repeat(), RZ_ANALYSIS_FCN_TYPE_NULL, rz_analysis_function_get_xrefs_from(), rz_analysis_get_fcn_in(), rz_analysis_xrefs_get_from(), rz_analysis_xrefs_get_to(), rz_analysis_xrefs_type_tostring(), rz_cmd_state_output_fini(), rz_cmd_state_output_init(), RZ_CMD_STATUS_INVALID, rz_config_get(), rz_config_get_b(), rz_config_set(), rz_config_set_b(), rz_cons_any_key(), rz_cons_arrow_to_hjkl(), rz_cons_clear00(), rz_cons_enable_mouse(), rz_cons_flush(), rz_cons_get_size(), rz_cons_gotoxy(), rz_cons_newline(), rz_cons_printf(), rz_cons_readchar(), rz_core_cmd0(), rz_core_cmd_strf(), rz_core_flag_describe(), rz_core_visual_prompt_input(), rz_core_visual_toggle_decompiler_disasm(), rz_flag_get_at(), rz_list_free(), rz_meta_get_string(), RZ_META_TYPE_COMMENT, RZ_OUTPUT_MODE_STANDARD, rz_str_ansi_crop(), rz_str_append(), rz_str_appendf(), rz_str_newf(), rz_str_trim_head_ro(), RZ_SYS_BITS_64, skip(), snprintf, strdup(), rz_analysis_ref_t::to, rz_analysis_ref_t::type, ut64(), UT64_MAX, and w.

Referenced by __handle_refs(), __panels_process(), rz_core_visual_analysis(), rz_core_visual_browse(), rz_core_visual_cmd(), and rz_core_visual_graph().

rz_line_hist_offset_down()

RZ_API int rz_line_hist_offset_down

(

RzLine *

line

)

Definition at line 1235 of file visual.c.

                                                  {
    RzCore *core = (RzCore *)line->user;
    RzCoreSeekItem *csi = rz_core_seek_peek(core, line->offset_hist_index + 1);
    if (!csi) {
        return false;
    }
    line->offset_hist_index++;
    bool res = fill_hist_offset(core, line, csi);
    rz_core_seek_item_free(csi);
    return res;
}

References fill_hist_offset(), setup::line, rz_core_seek_item_free(), and rz_core_seek_peek().

Referenced by __break_points_cb(), rz_core_visual_offset(), and visual_offset().

rz_line_hist_offset_up()

RZ_API int rz_line_hist_offset_up

(

RzLine *

line

)

Definition at line 1222 of file visual.c.

                                                {
    RzCore *core = (RzCore *)line->user;
    RzCoreSeekItem *csi = rz_core_seek_peek(core, line->offset_hist_index - 1);
    if (!csi) {
        return false;
    }
 
    line->offset_hist_index--;
    bool res = fill_hist_offset(core, line, csi);
    rz_core_seek_item_free(csi);
    return res;
}

References fill_hist_offset(), setup::line, rz_core_seek_item_free(), and rz_core_seek_peek().

Referenced by __break_points_cb(), rz_core_visual_offset(), and visual_offset().

rz_listinfo_free()

RZ_API void rz_listinfo_free

(

RzListInfo *

info

)

Definition at line 4032 of file visual.c.

                                               {
    if (!info) {
        return;
    }
    free(info->name);
    free(info->extra);
    free(info);
}

References free(), and info().

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

rz_listinfo_new()

RZ_API RzListInfo* rz_listinfo_new	(	const char *	name,
		RzInterval	pitv,
		RzInterval	vitv,
		int	perm,
		const char *	extra
	)

Definition at line 4020 of file visual.c.

                                                                                                                    {
    RzListInfo *info = RZ_NEW(RzListInfo);
    if (info) {
        info->name = name ? strdup(name) : NULL;
        info->pitv = pitv;
        info->vitv = vitv;
        info->perm = perm;
        info->extra = extra ? strdup(extra) : NULL;
    }
    return info;
}

References info(), NULL, RZ_NEW, and strdup().

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

setcursor()

static void setcursor ( RzCore *  core, bool  cur  )

static

Definition at line 159 of file visual.c.

                                              {
    int flags = core->print->flags;
    if (core->print->cur_enabled) {
        flags |= RZ_PRINT_FLAGS_CURSOR;
    } else {
        flags &= ~(RZ_PRINT_FLAGS_CURSOR);
    }
    core->print->cur_enabled = cur;
    if (core->print->cur == -1) {
        core->print->cur = 0;
    }
    rz_print_set_flags(core->print, flags);
    core->print->col = core->print->cur_enabled ? 1 : 0;
}

References rz_print_t::col, rz_print_t::cur, rz_print_t::cur_enabled, rz_print_t::flags, flags, rz_core_t::print, RZ_PRINT_FLAGS_CURSOR, and rz_print_set_flags().

Referenced by rz_core_visual_cmd(), and visual_help().

setdiff()

static void setdiff ( RzCore *  core )

static

Definition at line 896 of file visual.c.

                                  {
    char from[64], to[64];
    prompt_read("diff from: ", from, sizeof(from));
    rz_config_set(core->config, "diff.from", from);
    prompt_read("diff to: ", to, sizeof(to));
    rz_config_set(core->config, "diff.to", to);
}

References rz_core_t::config, from, prompt_read(), rz_config_set(), and to.

Referenced by rz_core_visual_cmd().

setprintmode()

static void setprintmode ( RzCore *  core, int  n  )

static

Definition at line 1094 of file visual.c.

                                              {
    rz_config_set_i(core->config, "scr.visual.mode", core->printidx + n);
    RzAsmOp op;
 
    switch (core->printidx) {
    case RZ_CORE_VISUAL_MODE_PD:
    case RZ_CORE_VISUAL_MODE_DB:
        rz_asm_op_init(&op);
        rz_asm_disassemble(core->rasm, &op, core->block, RZ_MIN(32, core->blocksize));
        rz_asm_op_fini(&op);
        break;
    default:
        break;
    }
}

References rz_core_t::block, rz_core_t::blocksize, rz_core_t::config, n, op, rz_core_t::printidx, rz_core_t::rasm, rz_asm_disassemble(), rz_asm_op_fini(), rz_asm_op_init(), rz_config_set_i(), RZ_CORE_VISUAL_MODE_DB, RZ_CORE_VISUAL_MODE_PD, and RZ_MIN.

Referenced by rz_core_visual_cmd().

stackPrintCommand()

static const char* stackPrintCommand ( RzCore *  core )

static

Definition at line 229 of file visual.c.

                                                   {
    if (current0format == 0) {
        if (rz_config_get_b(core->config, "dbg.slow")) {
            return "pxr";
        }
        if (rz_config_get_b(core->config, "stack.bytes")) {
            return "px";
        }
        switch (core->rasm->bits) {
        case 64: return "pxq"; break;
        case 32: return "pxw"; break;
        }
        return "px";
    }
    return printHexFormats[current0format % PRINT_HEX_FORMATS];
}

References rz_asm_t::bits, rz_core_t::config, current0format, PRINT_HEX_FORMATS, printHexFormats, rz_core_t::rasm, and rz_config_get_b().

Referenced by __core_visual_print_command(), rz_core_visual(), and visual_refresh().

visual_breakpoint()

static void visual_breakpoint ( RzCore *  core )

static

Definition at line 789 of file visual.c.

                                            {
    rz_core_debug_breakpoint_toggle(core, core->offset);
}

References rz_core_t::offset, and rz_core_debug_breakpoint_toggle().

Referenced by visual_nkey().

visual_comma()

static void visual_comma ( RzCore *  core )

static

Definition at line 1623 of file visual.c.

                                       {
    bool mouse_state = __holdMouseState(core);
    ut64 addr = core->offset + (core->print->cur_enabled ? core->print->cur : 0);
    char *comment, *cwd, *cmtfile;
    const char *prev_cmt = rz_meta_get_string(core->analysis, RZ_META_TYPE_COMMENT, addr);
    comment = prev_cmt ? strdup(prev_cmt) : NULL;
    cmtfile = rz_str_between(comment, ",(", ")");
    cwd = getcommapath(core);
    if (!cmtfile) {
        char *fn;
        fn = rz_cons_input("<comment-file> ");
        if (fn && *fn) {
            cmtfile = strdup(fn);
            if (!comment || !*comment) {
                comment = rz_str_newf(",(%s)", fn);
                rz_meta_set_string(core->analysis, RZ_META_TYPE_COMMENT, addr, comment);
            } else {
                // append filename in current comment
                char *nc = rz_str_newf("%s ,(%s)", comment, fn);
                rz_meta_set_string(core->analysis, RZ_META_TYPE_COMMENT, addr, nc);
                free(nc);
            }
        }
        free(fn);
    }
    if (cmtfile) {
        char *cwf = rz_str_newf("%s" RZ_SYS_DIR "%s", cwd, cmtfile);
        char *odata = rz_file_slurp(cwf, NULL);
        if (!odata) {
            eprintf("Could not open '%s'.\n", cwf);
            free(cwf);
            goto beach;
        }
        char *data = rz_core_editor(core, NULL, odata);
        rz_file_dump(cwf, (const ut8 *)data, -1, 0);
        free(data);
        free(odata);
        free(cwf);
    } else {
        eprintf("No commafile found.\n");
    }
beach:
    free(comment);
    rz_cons_enable_mouse(mouse_state && rz_config_get_b(core->config, "scr.wheel"));
}

References __holdMouseState(), addr, rz_core_t::analysis, rz_core_t::config, rz_print_t::cur, rz_print_t::cur_enabled, test-lz4-speed::cwd, eprintf, fn, free(), getcommapath(), NULL, rz_core_t::offset, rz_core_t::print, rz_config_get_b(), rz_cons_enable_mouse(), rz_cons_input(), rz_core_editor(), rz_file_dump(), rz_file_slurp(), rz_meta_get_string(), rz_meta_set_string(), RZ_META_TYPE_COMMENT, rz_str_between(), rz_str_newf(), RZ_SYS_DIR, strdup(), and ut64().

Referenced by rz_core_visual_cmd().

visual_flagzone()

static void visual_flagzone ( RzCore *  core )

static

Definition at line 3258 of file visual.c.

                                          {
    const char *a, *b;
    int a_len = 0;
    int w = rz_cons_get_size(NULL);
    rz_flag_zone_around(core->flags, core->offset, &a, &b);
    if (a) {
        rz_cons_printf("[<< %s]", a);
        a_len = strlen(a) + 4;
    }
    int padsize = (w / 2) - a_len;
    int title_size = 12;
    if (a || b) {
        char *title = rz_str_newf("[ 0x%08" PFMT64x " ]", core->offset);
        title_size = strlen(title);
        padsize -= strlen(title) / 2;
        const char *halfpad = rz_str_pad(' ', padsize);
        rz_cons_printf("%s%s", halfpad, title);
        free(title);
    }
    if (b) {
        padsize = (w / 2) - title_size - strlen(b) - 4;
        const char *halfpad = padsize > 1 ? rz_str_pad(' ', padsize) : "";
        rz_cons_printf("%s[%s >>]", halfpad, b);
    }
    if (a || b) {
        rz_cons_newline();
    }
}

References a, b, rz_core_t::flags, free(), NULL, rz_core_t::offset, PFMT64x, rz_cons_get_size(), rz_cons_newline(), rz_cons_printf(), rz_flag_zone_around(), rz_str_newf(), rz_str_pad(), and w.

Referenced by rz_core_visual_title().

visual_help()

static int visual_help ( RzCore *  core )

static

Definition at line 552 of file visual.c.

                                     {
    int ret = 0;
    RzStrBuf *p, *q;
repeat:
    p = rz_strbuf_new(NULL);
    q = rz_strbuf_new(NULL);
    if (!p) {
        return 0;
    }
    rz_cons_clear00();
    rz_core_visual_append_help(q, "Visual Help", help_visual);
    rz_cons_printf("%s", rz_strbuf_get(q));
    rz_cons_flush();
    switch (rz_cons_readchar()) {
    case 'q':
        rz_strbuf_free(p);
        rz_strbuf_free(q);
        return ret;
    case '!':
        rz_core_visual_panels_root(core, core->panels_root);
        break;
    case '?':
        rz_core_visual_append_help(p, "Visual mode help", help_msg_visual);
        rz_core_visual_append_help(p, "Function Keys: (See 'e key.'), defaults to", help_msg_visual_fn);
        ret = rz_cons_less_str(rz_strbuf_get(p), "?");
        break;
    case 'v':
        rz_strbuf_appendf(p, "Visual Views:\n\n");
        rz_strbuf_appendf(p,
            " \\     toggle horizonal split mode\n"
            " tt     create a new tab (same as t+)\n"
            " t=     give a name to the current tab\n"
            " t-     close current tab\n"
            " th     select previous tab (same as tj)\n"
            " tl     select next tab (same as tk)\n"
            " t[1-9] select nth tab\n"
            " C   -> rotate scr.color=0,1,2,3\n"
            " R   -> rotate color theme with ecr command which honors scr.randpal\n");
        ret = rz_cons_less_str(rz_strbuf_get(p), "?");
        break;
    case 'p':
        rz_strbuf_appendf(p, "Visual Print Modes:\n\n");
        rz_strbuf_appendf(p,
            " pP  -> change to the next/previous print mode (hex, dis, ..)\n"
            " TAB -> rotate between all the configurations for the current print mode\n");
        ret = rz_cons_less_str(rz_strbuf_get(p), "?");
        break;
    case 'e':
        rz_strbuf_appendf(p, "Visual Evals:\n\n");
        rz_strbuf_appendf(p,
            " E      toggle asm.hint.lea\n"
            " &      rotate asm.bits=16,32,64\n");
        ret = rz_cons_less_str(rz_strbuf_get(p), "?");
        break;
    case 'c':
        setcursor(core, !core->print->cur_enabled);
        rz_strbuf_free(p);
        rz_strbuf_free(q);
        return ret;
    case 'i':
        rz_strbuf_appendf(p, "Visual Insertion Help:\n\n");
        rz_strbuf_appendf(p,
            " i   -> insert bits, bytes or text depending on view\n"
            " a   -> assemble instruction and write the bytes in the current offset\n"
            " A   -> visual assembler\n"
            " +   -> increment value of byte\n"
            " -   -> decrement value of byte\n");
        ret = rz_cons_less_str(rz_strbuf_get(p), "?");
        break;
    case 'd':
        rz_strbuf_appendf(p, "Visual Debugger Help:\n\n");
        rz_strbuf_appendf(p,
            " $   -> set the program counter (PC register)\n"
            " s   -> step in\n"
            " S   -> step over\n"
            " B   -> toggle breakpoint\n"
            " :dc -> continue\n");
        ret = rz_cons_less_str(rz_strbuf_get(p), "?");
        break;
    case 'm':
        rz_strbuf_appendf(p, "Visual Moving Around:\n\n");
        rz_strbuf_appendf(p,
            " g        type flag/offset/register name to seek\n"
            " hl       seek to the next/previous byte\n"
            " jk       seek to the next row (core.offset += hex.cols)\n"
            " JK       seek one page down\n"
            " ^        seek to the beginning of the current map\n"
            " $        seek to the end of the current map\n"
            " c        toggle cursor mode (use hjkl to move and HJKL to select a range)\n"
            " mK/'K    mark/go to Key (any key)\n");
        ret = rz_cons_less_str(rz_strbuf_get(p), "?");
        break;
    case 'a':
        rz_strbuf_appendf(p, "Visual Analysis:\n\n");
        rz_strbuf_appendf(p,
            " df -> define function\n"
            " du -> undefine function\n"
            " dc -> define as code\n"
            " dw -> define as dword (32bit)\n"
            " dw -> define as qword (64bit)\n"
            " dd -> define current block or selected bytes as data\n"
            " V  -> view graph (same as press the 'space' key)\n");
        ret = rz_cons_less_str(rz_strbuf_get(p), "?");
        break;
    }
    rz_strbuf_free(p);
    rz_strbuf_free(q);
    goto repeat;
}

References rz_print_t::cur_enabled, help_msg_visual, help_msg_visual_fn, help_visual, NULL, p, rz_core_t::panels_root, rz_core_t::print, repeat(), rz_cons_clear00(), rz_cons_flush(), rz_cons_less_str(), rz_cons_printf(), rz_cons_readchar(), rz_core_visual_append_help(), rz_core_visual_panels_root(), rz_strbuf_appendf(), rz_strbuf_free(), rz_strbuf_get(), rz_strbuf_new(), and setcursor().

Referenced by rz_core_visual_cmd(), and visual_nkey().

visual_nkey()

static int visual_nkey ( RzCore *  core, int  ch  )

static

Definition at line 793 of file visual.c.

                                             {
    const char *cmd;
    ut64 oseek = UT64_MAX;
    if (core->print->ocur == -1) {
        oseek = core->offset;
        rz_core_seek(core, core->offset + core->print->cur, false);
    }
 
    switch (ch) {
    case RZ_CONS_KEY_F1:
        cmd = rz_config_get(core->config, "key.f1");
        if (cmd && *cmd) {
            ch = rz_core_cmd0(core, cmd);
        } else {
            visual_help(core);
        }
        break;
    case RZ_CONS_KEY_F2:
        cmd = rz_config_get(core->config, "key.f2");
        if (cmd && *cmd) {
            ch = rz_core_cmd0(core, cmd);
        } else {
            visual_breakpoint(core);
        }
        break;
    case RZ_CONS_KEY_F3:
        cmd = rz_config_get(core->config, "key.f3");
        if (cmd && *cmd) {
            ch = rz_core_cmd0(core, cmd);
        }
        break;
    case RZ_CONS_KEY_F4:
        cmd = rz_config_get(core->config, "key.f4");
        if (cmd && *cmd) {
            ch = rz_core_cmd0(core, cmd);
        } else {
            if (core->print->cur_enabled) {
                rz_core_debug_continue_until(core, core->offset, core->offset + core->print->cur);
                core->print->cur_enabled = 0;
            }
        }
        break;
    case RZ_CONS_KEY_F5:
        cmd = rz_config_get(core->config, "key.f5");
        if (cmd && *cmd) {
            ch = rz_core_cmd0(core, cmd);
        }
        break;
    case RZ_CONS_KEY_F6:
        cmd = rz_config_get(core->config, "key.f6");
        if (cmd && *cmd) {
            ch = rz_core_cmd0(core, cmd);
        }
        break;
    case RZ_CONS_KEY_F7:
        cmd = rz_config_get(core->config, "key.f7");
        if (cmd && *cmd) {
            ch = rz_core_cmd0(core, cmd);
        } else {
            rz_core_debug_single_step_in(core);
        }
        break;
    case RZ_CONS_KEY_F8:
        cmd = rz_config_get(core->config, "key.f8");
        if (cmd && *cmd) {
            ch = rz_core_cmd0(core, cmd);
        } else {
            rz_core_debug_single_step_over(core);
        }
        break;
    case RZ_CONS_KEY_F9:
        cmd = rz_config_get(core->config, "key.f9");
        if (cmd && *cmd) {
            ch = rz_core_cmd0(core, cmd);
        } else {
            rz_core_debug_continue(core);
        }
        break;
    case RZ_CONS_KEY_F10:
        cmd = rz_config_get(core->config, "key.f10");
        if (cmd && *cmd) {
            ch = rz_core_cmd0(core, cmd);
        }
        break;
    case RZ_CONS_KEY_F11:
        cmd = rz_config_get(core->config, "key.f11");
        if (cmd && *cmd) {
            ch = rz_core_cmd0(core, cmd);
        }
        break;
    case RZ_CONS_KEY_F12:
        cmd = rz_config_get(core->config, "key.f12");
        if (cmd && *cmd) {
            ch = rz_core_cmd0(core, cmd);
        }
        break;
    }
    if (oseek != UT64_MAX) {
        rz_core_seek(core, oseek, false);
    }
    return ch;
}

References cmd, rz_core_t::config, rz_print_t::cur, rz_print_t::cur_enabled, rz_print_t::ocur, rz_core_t::offset, rz_core_t::print, rz_config_get(), RZ_CONS_KEY_F1, RZ_CONS_KEY_F10, RZ_CONS_KEY_F11, RZ_CONS_KEY_F12, RZ_CONS_KEY_F2, RZ_CONS_KEY_F3, RZ_CONS_KEY_F4, RZ_CONS_KEY_F5, RZ_CONS_KEY_F6, RZ_CONS_KEY_F7, RZ_CONS_KEY_F8, RZ_CONS_KEY_F9, rz_core_cmd0(), rz_core_debug_continue(), rz_core_debug_continue_until(), rz_core_debug_single_step_in(), rz_core_debug_single_step_over(), rz_core_seek(), ut64(), UT64_MAX, visual_breakpoint(), and visual_help().

Referenced by rz_core_visual_cmd().

visual_refresh()

static void visual_refresh ( RzCore *  core )

static

Definition at line 3675 of file visual.c.

                                         {
    static ut64 oseek = UT64_MAX;
    const char *vi, *vcmd, *cmd_str;
    if (!core) {
        return;
    }
    rz_print_set_cursor(core->print, core->print->cur_enabled, core->print->ocur, core->print->cur);
    core->cons->blankline = true;
 
    int w = visual_responsive(core);
 
    if (!autoblocksize) {
        rz_cons_clear();
    }
    rz_cons_goto_origin_reset();
    rz_cons_flush();
 
    int hex_cols = rz_config_get_i(core->config, "hex.cols");
    int split_w = 12 + 4 + hex_cols + (hex_cols * 3);
    bool ce = core->print->cur_enabled;
 
    vi = rz_config_get(core->config, "cmd.cprompt");
    bool vsplit = (vi && *vi);
 
    if (vsplit) {
        // XXX: slow
        core->cons->blankline = false;
        if (split_w > w) {
            // do not show column contents
        } else {
            rz_cons_clear();
            rz_cons_printf("[cmd.cprompt=%s]\n", vi);
            if (oseek != UT64_MAX) {
                rz_core_seek(core, oseek, true);
            }
            rz_core_cmd0(core, vi);
            rz_cons_column(split_w + 1);
            if (!strncmp(vi, "p=", 2) && core->print->cur_enabled) {
                oseek = core->offset;
                core->print->cur_enabled = false;
                rz_core_seek(core, core->num->value, true);
            } else {
                oseek = UT64_MAX;
            }
        }
        rz_cons_gotoxy(0, 0);
    }
    vi = rz_config_get(core->config, "cmd.vprompt");
    if (vi && *vi) {
        rz_core_cmd0(core, vi);
    }
    rz_core_visual_title(core, color);
    vcmd = rz_config_get(core->config, "cmd.visual");
    if (vcmd && *vcmd) {
        // disable screen bounds when it's a user-defined command
        // because it can cause some issues
        core->print->screen_bounds = 0;
        cmd_str = vcmd;
    } else {
        if (splitView) {
            static char debugstr[512];
            const char *pxw = NULL;
            int h = rz_num_get(core->num, "$r");
            int size = (h * 16) / 2;
            switch (core->printidx) {
            case 1:
                size = (h - 2) / 2;
                pxw = "pd";
                break;
            default:
                pxw = stackPrintCommand(core);
                break;
            }
            snprintf(debugstr, sizeof(debugstr),
                "?0;%s %d @ %" PFMT64d ";cl;"
                "?1;%s %d @ %" PFMT64d ";",
                pxw, size, splitPtr,
                pxw, size, core->offset);
            core->print->screen_bounds = 1LL;
            cmd_str = debugstr;
        } else {
            core->print->screen_bounds = 1LL;
            cmd_str = (zoom ? "pz" : __core_visual_print_command(core));
        }
    }
    if (cmd_str && *cmd_str) {
        if (vsplit) {
            char *cmd_result = rz_core_cmd_str(core, cmd_str);
            cmd_result = rz_str_ansi_crop(cmd_result, 0, 0, split_w, -1);
            rz_cons_strcat(cmd_result);
        } else {
            rz_core_cmd0(core, cmd_str);
        }
    }
    core->print->cur_enabled = ce;
#if 0
    if (core->print->screen_bounds != 1LL) {
        rz_cons_printf ("[0x%08"PFMT64x "..0x%08"PFMT64x "]\n",
            core->offset, core->print->screen_bounds);
    }
#endif
    blocksize = core->num->value ? core->num->value : core->blocksize;
 
    /* this is why there's flickering */
    if (core->print->vflush) {
        rz_cons_visual_flush();
    } else {
        rz_cons_reset();
    }
    if (core->scr_gadgets) {
        rz_core_gadget_print(core);
        rz_cons_flush();
    }
    core->cons->blankline = false;
    core->cons->blankline = true;
    core->curtab = 0; // which command are we focusing
    // core->seltab = 0; // user selected tab
 
    if (rz_config_get_i(core->config, "scr.scrollbar")) {
        rz_core_print_scrollbar(core);
    }
}

References __core_visual_print_command(), autoblocksize, rz_cons_t::blankline, blocksize, rz_core_t::blocksize, color, rz_core_t::config, rz_core_t::cons, rz_print_t::cur, rz_print_t::cur_enabled, rz_core_t::curtab, h, NULL, rz_core_t::num, rz_print_t::ocur, rz_core_t::offset, PFMT64d, PFMT64x, rz_core_t::print, rz_core_t::printidx, rz_config_get(), rz_config_get_i(), rz_cons_clear(), rz_cons_column(), rz_cons_flush(), rz_cons_goto_origin_reset(), rz_cons_gotoxy(), rz_cons_printf(), rz_cons_reset(), rz_cons_strcat(), rz_cons_visual_flush(), rz_core_cmd0(), rz_core_cmd_str(), rz_core_gadget_print(), rz_core_print_scrollbar(), rz_core_seek(), rz_core_visual_title(), rz_num_get(), rz_print_set_cursor(), rz_str_ansi_crop(), rz_core_t::scr_gadgets, rz_print_t::screen_bounds, snprintf, splitPtr, splitView, stackPrintCommand(), ut64(), UT64_MAX, rz_num_t::value, rz_print_t::vflush, visual_responsive(), w, and zoom.

Referenced by rz_core_visual(), rz_core_visual_cmd(), and visual_refresh_oneshot().

visual_refresh_oneshot()

static void visual_refresh_oneshot ( RzCore *  core )

static

Definition at line 3798 of file visual.c.

                                                 {
    rz_core_task_enqueue_oneshot(&core->tasks, (RzCoreTaskOneShot)visual_refresh, core);
}

References rz_core_task_enqueue_oneshot(), rz_core_t::tasks, and visual_refresh().

Referenced by rz_core_visual().

visual_responsive()

static int visual_responsive ( RzCore *  core )

static

Definition at line 3504 of file visual.c.

                                           {
    int h, w = rz_cons_get_size(&h);
    if (rz_config_get_b(core->config, "scr.responsive")) {
        if (w < 110) {
            rz_config_set_b(core->config, "asm.cmt.right", false);
        } else {
            rz_config_set_b(core->config, "asm.cmt.right", true);
        }
        if (w < 68) {
            rz_config_set_i(core->config, "hex.cols", (int)(w / 5.2));
        } else {
            rz_config_set_i(core->config, "hex.cols", 16);
        }
        if (w < 25) {
            rz_config_set_b(core->config, "asm.offset", false);
        } else {
            rz_config_set_b(core->config, "asm.offset", true);
        }
        if (w > 80) {
            rz_config_set_i(core->config, "asm.lines.width", 14);
            rz_config_set_i(core->config, "asm.lines.width", w - (int)(w / 1.2));
            rz_config_set_i(core->config, "asm.cmt.col", w - (int)(w / 2.5));
        } else {
            rz_config_set_i(core->config, "asm.lines.width", 7);
        }
        if (w < 70) {
            rz_config_set_i(core->config, "asm.lines.width", 1);
            rz_config_set_b(core->config, "asm.bytes", false);
        } else {
            rz_config_set_b(core->config, "asm.bytes", true);
        }
    }
    return w;
}

References rz_core_t::config, h, rz_config_get_b(), rz_config_set_b(), rz_config_set_i(), rz_cons_get_size(), and w.

Referenced by visual_refresh().

visual_search()

static void visual_search ( RzCore *  core )

static

Definition at line 1002 of file visual.c.

                                        {
    const ut8 *p;
    int len, d = core->print->cur;
    char str[128], buf[sizeof(str) * 2 + 1];
 
    rz_line_set_prompt("search byte/string in block: ");
    rz_cons_fgets(str, sizeof(str), 0, NULL);
    len = rz_hex_str2bin(str, (ut8 *)buf);
    if (*str == '"') {
        rz_str_ncpy(buf, str + 1, sizeof(buf));
        len = strlen(buf);
        char *e = buf + len - 1;
        if (e > buf && *e == '"') {
            *e = 0;
            len--;
        }
    } else if (len < 1) {
        rz_str_ncpy(buf, str, sizeof(buf));
        len = strlen(buf);
    }
    p = rz_mem_mem(core->block + d, core->blocksize - d,
        (const ut8 *)buf, len);
    if (p) {
        core->print->cur = (int)(size_t)(p - core->block);
        if (len > 1) {
            core->print->ocur = core->print->cur + len - 1;
        } else {
            core->print->ocur = -1;
        }
        rz_core_visual_showcursor(core, true);
        eprintf("Found in offset 0x%08" PFMT64x " + %d\n", core->offset, core->print->cur);
        rz_cons_any_key(NULL);
    } else {
        eprintf("Cannot find bytes.\n");
        rz_cons_any_key(NULL);
        rz_cons_clear00();
    }
}

References rz_core_t::block, rz_core_t::blocksize, rz_print_t::cur, d, e, eprintf, int, len, NULL, rz_print_t::ocur, rz_core_t::offset, p, PFMT64x, rz_core_t::print, rz_cons_any_key(), rz_cons_clear00(), rz_cons_fgets(), rz_core_visual_showcursor(), rz_hex_str2bin(), rz_line_set_prompt(), rz_mem_mem(), rz_str_ncpy(), and cmd_descs_generate::str.

Referenced by rz_core_visual_cmd().

visual_seek_animation()

static void visual_seek_animation ( RzCore *  core, ut64  addr  )

static

Definition at line 1056 of file visual.c.

                                                           {
    if (rz_config_get_i(core->config, "scr.feedback") < 1) {
        return;
    }
    if (core->offset == addr) {
        return;
    }
    rz_cons_gotoxy(1, 2);
    if (addr > core->offset) {
        rz_cons_printf(".----.\n");
        rz_cons_printf("| \\/ |\n");
        rz_cons_printf("'----'\n");
    } else {
        rz_cons_printf(".----.\n");
        rz_cons_printf("| /\\ |\n");
        rz_cons_printf("'----'\n");
    }
    rz_cons_flush();
    rz_sys_usleep(90000);
}

References addr, rz_core_t::config, rz_core_t::offset, rz_config_get_i(), rz_cons_flush(), rz_cons_gotoxy(), rz_cons_printf(), and rz_sys_usleep().

Referenced by rz_core_visual_seek_animation(), rz_core_visual_seek_animation_redo(), and rz_core_visual_seek_animation_undo().

Variable Documentation

__ime

bool __ime = false

static

Definition at line 1954 of file visual.c.

Referenced by insert_mode_enabled(), rz_core_visual_cmd(), and rz_core_visual_title().

__nib

int __nib = -1

static

Definition at line 1955 of file visual.c.

Referenced by insert_mode_enabled().

autoblocksize

bool autoblocksize = true

static

Definition at line 16 of file visual.c.

Referenced by rz_core_visual(), rz_core_visual_cmd(), rz_core_visual_title(), and visual_refresh().

blocksize

int blocksize = 0

static

Definition at line 15 of file visual.c.

Referenced by analBars(), cmd_print_bars(), cmd_print_pv(), myregwrite(), rz_cmd_print(), rz_core_analysis_op(), rz_core_analysis_search(), slurp(), and visual_refresh().

color

int color = 1

static

Definition at line 20 of file visual.c.

Referenced by __cons_pal_update_event(), __init_menu_color_settings_layout(), __lookup_rgb(), __panel_print(), __panels_process(), __panels_refresh(), __preline_flag(), __unrgb(), cmd_agraph_node(), cmd_p_minus_e(), cmd_prc(), cmd_print_pxA(), core_analysis_bytes_esil(), core_analysis_bytes_standard(), core_analysis_graph_construct_nodes(), core_cmp_bits(), core_print_2bpp_row(), dfs_node(), diff_hexdump_partial(), diff_unified_append_data(), diff_unified_append_ranges(), diffrow(), ds_highlight_word(), ds_print_offset(), ds_show_flags(), get_node_color(), normal_RzANode_print(), print_arg_str(), print_format_values(), printCol(), references_handler(), rizin_compare_words(), rotateColor(), rz_agraph_add_node_with_color(), rz_analysis_function_blocks_color_handler(), rz_cmd_disassembly_all_possible_opcodes_handler(), rz_cmd_disassembly_all_possible_opcodes_treeview_handler(), rz_cmd_eval_color_list_handler(), rz_cons_canvas_box(), rz_cons_fgets(), rz_cons_invert(), rz_cons_newline(), rz_cons_pal_free(), rz_cons_pal_list(), rz_core_agraph_add_node(), rz_core_annotated_code_print(), rz_core_diff_show(), rz_core_disasm_instruction(), rz_core_print_func_args(), rz_core_visual(), rz_core_visual_analysis_refresh(), rz_core_visual_cmd(), rz_core_visual_colors(), rz_core_visual_title(), rz_diff_unified_text(), rz_flag_item_set_color(), rz_graph_dfs(), rz_graph_dfs_node(), rz_graph_dfs_node_reverse(), rz_print_colorize_asm_str(), rz_print_hexdiff_str(), rz_print_hexdump_str(), rz_regs_columns_handler(), rz_str_highlight(), show_regs_handler(), var_functions_show(), and visual_refresh().

current0format

int current0format = 0

static

Definition at line 57 of file visual.c.

Referenced by nextPrintCommand(), prevPrintCommand(), and stackPrintCommand().

current3format

int current3format = 0

static

Definition at line 70 of file visual.c.

Referenced by printFormat().

current4format

int current4format = 0

static

Definition at line 75 of file visual.c.

Referenced by printFormat().

current5format

int current5format = 0

static

Definition at line 79 of file visual.c.

Referenced by printFormat().

currentFormat

int currentFormat = 0

static

Definition at line 56 of file visual.c.

Referenced by nextPrintCommand(), prevPrintCommand(), printFormat(), rz_core_visual_applyDisMode(), rz_core_visual_applyHexMode(), and rz_core_visual_title().

debug

int debug = 1

static

Definition at line 21 of file visual.c.

Referenced by decode_buffer(), rz_bin_pe_get_entrypoint(), rz_core_loadlibs_init(), rz_core_visual(), rz_main_rizin(), and rz_protobuf_decode().

disMode

int disMode = 0

static

Definition at line 17 of file visual.c.

Referenced by printFormat(), and rz_core_visual_applyDisMode().

help_msg_visual

const char* help_msg_visual[]

static

Definition at line 314 of file visual.c.

Referenced by visual_help().

help_msg_visual_fn

const char* help_msg_visual_fn[]

static

Initial value:

= {
    "F2", "toggle breakpoint",
    "F4", "run to cursor",
    "F7", "single step",
    "F8", "step over",
    "F9", "continue",
    NULL
}

Definition at line 371 of file visual.c.

Referenced by visual_help().

help_visual

const char* help_visual[]

static

Initial value:

= {
    "?", "full help",
    "!", "enter panels",
    "a", "code analysis",
    "c", "toggle cursor",
    "d", "debugger / emulator",
    "e", "toggle configurations",
    "i", "insert / write",
    "m", "moving around (seeking)",
    "p", "print commands and modes",
    "v", "view management",
    NULL
}

Definition at line 300 of file visual.c.

Referenced by visual_help().

hexMode

int hexMode = 0

static

Definition at line 18 of file visual.c.

Referenced by printFormat(), rz_core_visual_applyHexMode(), and rz_core_visual_title().

numbuf

char numbuf[32] = { 0 }

static

Definition at line 2200 of file visual.c.

Referenced by numbuf_append(), and numbuf_pull().

numbuf_i

int numbuf_i = 0

static

Definition at line 2201 of file visual.c.

Referenced by numbuf_append(), numbuf_pull(), and rz_core_visual_cmd().

obs

int obs = 0

static

Definition at line 14 of file visual.c.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), rz_analyze_n_ins_esil_handler(), rz_analyze_n_ins_handler(), rz_analyze_n_ins_size_handler(), rz_core_cmd_foreach3(), rz_core_visual(), and rz_core_visual_cmd().

print3Formats

const char* print3Formats[PRINT_3_FORMATS]

static

Initial value:

= { 
    "pxw 64@r:SP;" CMD_REGISTERS ";pd $r", 
    "pCD"
}

Definition at line 71 of file visual.c.

Referenced by printFormat().

print4Formats

const char* print4Formats[PRINT_4_FORMATS]

static

Initial value:

= {
    "prc", "prc=a", "pxAv", "pxx", "p=e $r-2", "pk 64"
}

Definition at line 76 of file visual.c.

Referenced by printFormat().

print5Formats

const char* print5Formats[PRINT_5_FORMATS]

static

Initial value:

= {
    "pca", "pcA", "p8", "pcc", "pss", "pcp", "pcd", "pcj"
}

Definition at line 80 of file visual.c.

Referenced by printFormat().

printfmtColumns

const char* printfmtColumns[NPF]

static

Initial value:

= {
    "pCx", 
    "pCd $r-1", 
    "pCD", 
    "pCA", 
    "pCc", 
}

Definition at line 42 of file visual.c.

Referenced by __core_visual_print_command().

printfmtSingle

const char* printfmtSingle[NPF]

static

Initial value:

= {
    "xc", 
    "pd $r", 
    ("pxw 64@r:SP;" CMD_REGISTERS ";pd $r"), 
    "prc", 
    "pss", 
}

Definition at line 34 of file visual.c.

Referenced by __core_visual_print_command(), printFormat(), rz_core_visual(), and rz_core_visual_cmd().

printHexFormats

const char* printHexFormats[PRINT_HEX_FORMATS]

static

Initial value:

= {
    "px",
    "pxa",
    "pxr",
    "prx",
    "pxb",
    "pxh",
    "pxw",
    "pxq",
    "pxd",
    "pxr",
}

Definition at line 58 of file visual.c.

Referenced by printFormat(), and stackPrintCommand().

printMode

int printMode = 0

static

Definition at line 19 of file visual.c.

Referenced by rz_core_visual_xrefs().

splitPtr

ut64 splitPtr = UT64_MAX

static

Definition at line 381 of file visual.c.

Referenced by cursor_nextrow(), cursor_prevrow(), rz_core_visual(), rz_core_visual_cmd(), and visual_refresh().

splitView

bool splitView = false

static

Definition at line 380 of file visual.c.

Referenced by cursor_nextrow(), cursor_prevrow(), rz_core_visual_cmd(), and visual_refresh().

zoom

int zoom = 0

static

Definition at line 22 of file visual.c.

Referenced by normal_RzANode_print(), update_node_dimension(), and visual_refresh().