input.c File Reference

#include <rz_cons.h>
#include <string.h>

Go to the source code of this file.

Macros
#define	I   rz_cons_singleton()
#define	RETURN(x)

Functions
RZ_API int	rz_cons_controlz (int ch)
static int	__parseMouseEvent (void)
RZ_API int	rz_cons_arrow_to_hjkl (int ch)
RZ_API int	rz_cons_fgets (char *buf, int len, int argc, const char **argv)
RZ_API int	rz_cons_any_key (const char *msg)
void	resizeWin (void)
RZ_API int	rz_cons_readchar_timeout (ut32 usec)
RZ_API bool	rz_cons_readpush (const char *str, int len)
RZ_API void	rz_cons_readflush (void)
RZ_API void	rz_cons_switchbuf (bool active)
RZ_API bool	rz_cons_readbuffer_readchar (char *ch)
RZ_API int	rz_cons_readchar (void)
RZ_API bool	rz_cons_yesno (int def, const char *fmt,...)
RZ_API char *	rz_cons_input (const char *msg)

Variables
volatile sig_atomic_t	sigwinchFlag

Macro Definition Documentation

I

#define I   rz_cons_singleton()

Definition at line 12 of file input.c.

RETURN

#define RETURN

(

x

)

Value:

    { \
        ret = x; \
        goto beach; \
    }

Function Documentation

__parseMouseEvent()

static int __parseMouseEvent ( void  )

static

Definition at line 30 of file input.c.

                                   {
    char xpos[32];
    char ypos[32];
    (void)rz_cons_readchar(); // skip first char
    int ch2 = rz_cons_readchar();
 
    // [32M - mousedown
    // [35M - mouseup
    if (ch2 == ';') {
        int i;
        // read until next ;
        for (i = 0; i < sizeof(xpos) - 1; i++) {
            char ch = rz_cons_readchar();
            if (ch == ';' || ch == 'M') {
                break;
            }
            xpos[i] = ch;
        }
        xpos[i] = 0;
        for (i = 0; i < sizeof(ypos) - 1; i++) {
            char ch = rz_cons_readchar();
            if (ch == ';' || ch == 'M') {
                break;
            }
            ypos[i] = ch;
        }
        ypos[i] = 0;
        rz_cons_set_click(atoi(xpos), atoi(ypos));
        (void)rz_cons_readchar();
        // ignored
        int ch = rz_cons_readchar();
        if (ch == 27) {
            ch = rz_cons_readchar(); // '['
        }
        if (ch == '[') {
            do {
                ch = rz_cons_readchar(); // '3'
            } while (ch != 'M');
        }
    }
    return 0;
}

References i, rz_cons_readchar(), and rz_cons_set_click().

Referenced by rz_cons_arrow_to_hjkl().

resizeWin()

void resizeWin

(

void

)

Definition at line 471 of file cons.c.

                     {
    if (I.event_resize) {
        I.event_resize(I.event_data);
    }
}

References I.

Referenced by rz_cons_readchar().

rz_cons_any_key()

RZ_API int rz_cons_any_key

(

const char *

msg

)

Definition at line 393 of file input.c.

                                            {
    if (msg && *msg) {
        rz_cons_printf("\n-- %s --\n", msg);
    } else {
        rz_cons_print("\n--press any key--\n");
    }
    rz_cons_flush();
    return rz_cons_readchar();
    // rz_cons_strcat ("\x1b[2J\x1b[0;0H");
}

References msg, rz_cons_flush(), rz_cons_printf(), and rz_cons_readchar().

Referenced by rtr_visual(), rz_cmd_help(), rz_cons_message(), rz_core_visual_analysis(), rz_core_visual_analysis_classes(), rz_core_visual_asm(), rz_core_visual_bit_editor(), rz_core_visual_classes(), rz_core_visual_cmd(), rz_core_visual_comments(), rz_core_visual_config(), rz_core_visual_debugtraces(), rz_core_visual_debugtraces_help(), rz_core_visual_define(), rz_core_visual_esil(), rz_core_visual_graph(), rz_core_visual_trackflags(), rz_core_visual_view_graph(), rz_core_visual_view_rop(), rz_core_visual_xrefs(), and visual_search().

rz_cons_arrow_to_hjkl()

RZ_API int rz_cons_arrow_to_hjkl

(

int

ch

)

Definition at line 78 of file input.c.

                                         {
#if __WINDOWS__
    if (I->vtmode != RZ_VIRT_TERM_MODE_COMPLETE) {
        if (is_arrow) {
            switch (ch) {
            case VK_DOWN: // key down
                ch = bCtrl ? 'J' : 'j';
                break;
            case VK_RIGHT: // key right
                ch = bCtrl ? 'L' : 'l';
                break;
            case VK_UP: // key up
                ch = bCtrl ? 'K' : 'k';
                break;
            case VK_LEFT: // key left
                ch = bCtrl ? 'H' : 'h';
                break;
            case VK_PRIOR: // key home
                ch = 'K';
                break;
            case VK_NEXT: // key end
                ch = 'J';
                break;
            }
        }
        return I->mouse_event && (ut8)ch == UT8_MAX ? 0 : ch;
    }
#endif
    I->mouse_event = 0;
    /* emacs */
    switch ((ut8)ch) {
    case 0xc3:
        rz_cons_readchar();
        ch = 'K';
        break; // emacs repag (alt + v)
    case 0x16: ch = 'J'; break; // emacs avpag (ctrl + v)
    case 0x10: ch = 'k'; break; // emacs up (ctrl + p)
    case 0x0e: ch = 'j'; break; // emacs down (ctrl + n)
    case 0x06: ch = 'l'; break; // emacs right (ctrl + f)
    case 0x02: ch = 'h'; break; // emacs left (ctrl + b)
    }
    if (ch != 0x1b) {
        return ch;
    }
    ch = rz_cons_readchar();
    if (!ch) {
        return 0;
    }
    switch (ch) {
    case 0x1b:
        ch = 'q'; // XXX: must be 0x1b (RZ_CONS_KEY_ESC)
        break;
    case 0x4f: // function keys from f1 to f4
        ch = rz_cons_readchar();
#if defined(__HAIKU__)
        /* Haiku't don use the '[' char for function keys */
        if (ch > 'O') { /* only in f1..f12 function keys */
            ch = 0xf1 + (ch & 0xf);
            break;
        }
    case '[': // 0x5b function keys (2)
        /* Haiku need ESC + [ for PageUp and PageDown  */
        if (ch < 'A' || ch == '[') {
            ch = rz_cons_readchar();
        }
#else
        ch = 0xf1 + (ch & 0xf);
        break;
    case '[': // function keys (2)
        ch = rz_cons_readchar();
#endif
        switch (ch) {
        case '<': {
            char pos[8] = { 0 };
            int p = 0;
            int x = 0;
            int y = 0;
            int sc = 0;
 
            char vel[8] = { 0 };
            int vn = 0;
            do {
                ch = rz_cons_readchar();
                // just for debugging
                // eprintf ( "%c", ch);
                if (sc > 0) {
                    if (ch >= '0' && ch <= '9') {
                        pos[p++] = ch;
                    }
                }
                if (sc < 1) {
                    vel[vn++] = ch;
                }
                if (ch == ';') {
                    if (sc == 1) {
                        pos[p++] = 0;
                        x = atoi(pos);
                    }
                    sc++;
                    p = 0;
                }
            } while (ch != 'M' && ch != 'm');
            int nvel = atoi(vel);
            switch (nvel) {
            case 2: // right click
                if (ch == 'M') {
                    return INT8_MAX;
                }
                return -INT8_MAX;
            case 64: // wheel up
                return 'k';
            case 65: // wheel down
                return 'j';
            }
            pos[p++] = 0;
            y = atoi(pos);
            rz_cons_set_click(x, y);
        }
            return 0;
        case '[':
            ch = rz_cons_readchar();
            switch (ch) {
            case '2': ch = RZ_CONS_KEY_F11; break;
            case 'A': ch = RZ_CONS_KEY_F1; break;
            case 'B': ch = RZ_CONS_KEY_F2; break;
            case 'C': ch = RZ_CONS_KEY_F3; break;
            case 'D': ch = RZ_CONS_KEY_F4; break;
            }
            break;
        case '9':
            // handle mouse wheel
            //      __parseWheelEvent();
            ch = rz_cons_readchar();
            // 6 is up
            // 7 is down
            I->mouse_event = 1;
            if (ch == '6') {
                ch = 'k';
            } else if (ch == '7') {
                ch = 'j';
            } else {
                // unhandled case
                ch = 0;
            }
            int ch2;
            do {
                ch2 = rz_cons_readchar();
            } while (ch2 != 'M');
            break;
        case '3':
            // handle mouse down /up events (35 vs 32)
            __parseMouseEvent();
            return 0;
            break;
        case '2':
            ch = rz_cons_readchar();
            switch (ch) {
            case 0x7e:
                ch = RZ_CONS_KEY_F12;
                break;
            default:
                rz_cons_readchar();
                switch (ch) {
                case '0': ch = RZ_CONS_KEY_F9; break;
                case '1': ch = RZ_CONS_KEY_F10; break;
                case '3': ch = RZ_CONS_KEY_F11; break;
                }
                break;
            }
            break;
        case '1':
            ch = rz_cons_readchar();
            switch (ch) {
            case '1': ch = RZ_CONS_KEY_F1; break;
            case '2': ch = RZ_CONS_KEY_F2; break;
            case '3': ch = RZ_CONS_KEY_F3; break;
            case '4': ch = RZ_CONS_KEY_F4; break;
            case '5': ch = RZ_CONS_KEY_F5; break;
            // case '6': ch = RZ_CONS_KEY_F5; break;
            case '7': ch = RZ_CONS_KEY_F6; break;
            case '8': ch = RZ_CONS_KEY_F7; break;
            case '9': ch = RZ_CONS_KEY_F8; break;
#if 0
            case '5':
                rz_cons_readchar ();
                ch = 0xf5;
                break;
            case '6':
                rz_cons_readchar ();
                ch = 0xf7;
                break;
            case '7':
                rz_cons_readchar ();
                ch = 0xf6;
                break;
            case '8':
                rz_cons_readchar ();
                ch = 0xf7;
                break;
            case '9':
                rz_cons_readchar ();
                ch = 0xf8;
                break;
#endif
            // Support st/st-256color term and others
            // for shift+arrows
            case ';': // arrow+mod
                ch = rz_cons_readchar();
                switch (ch) {
                case '2': // arrow+shift
                    ch = rz_cons_readchar();
                    switch (ch) {
                    case 'A': ch = 'K'; break;
                    case 'B': ch = 'J'; break;
                    case 'C': ch = 'L'; break;
                    case 'D': ch = 'H'; break;
                    }
                    break;
                    // add other modifiers
                }
                break;
            case ':': // arrow+shift
                rz_cons_readchar();
                ch = rz_cons_readchar();
                switch (ch) {
                case 'A': ch = 'K'; break;
                case 'B': ch = 'J'; break;
                case 'C': ch = 'L'; break;
                case 'D': ch = 'H'; break;
                }
                break;
            } // F9-F12 not yet supported!!
            break;
        case '5':
            ch = 'K';
            rz_cons_readchar();
            break; // repag
        case '6':
            ch = 'J';
            rz_cons_readchar();
            break; // avpag
        /* arrow keys */
        case 'A': ch = 'k'; break; // up
        case 'B': ch = 'j'; break; // down
        case 'C': ch = 'l'; break; // right
        case 'D':
            ch = 'h';
            break; // left
        // Support rxvt-unicode term for shift+arrows
        case 'a': ch = 'K'; break; // shift+up
        case 'b': ch = 'J'; break; // shift+down
        case 'c': ch = 'L'; break; // shift+right
        case 'd': ch = 'H'; break; // shift+left
        case 'M': ch = __parseMouseEvent(); break;
        }
        break;
    }
    return ch;
}

References __parseMouseEvent(), I, INT8_MAX, p, pos, 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_cons_readchar(), rz_cons_set_click(), RZ_VIRT_TERM_MODE_COMPLETE, sc, ut8, UT8_MAX, and x.

Referenced by __create_almighty(), __move_panel_to_dir(), __panels_process(), __vi_mode(), insert_mode_enabled(), rz_cons_less_str(), rz_core_visual_analysis(), rz_core_visual_analysis_classes(), rz_core_visual_bit_editor(), rz_core_visual_browse(), rz_core_visual_classes(), rz_core_visual_cmd(), rz_core_visual_colors(), rz_core_visual_comments(), rz_core_visual_config(), rz_core_visual_debugtraces(), rz_core_visual_define(), rz_core_visual_esil(), rz_core_visual_graph(), rz_core_visual_trackflags(), rz_core_visual_view_graph(), rz_core_visual_view_rop(), rz_core_visual_xrefs(), and rz_diff_hex_visual().

rz_cons_controlz()

RZ_API int rz_cons_controlz

(

int

ch

)

Definition at line 14 of file input.c.

                                    {
#if __UNIX__
    if (ch == 0x1a) {
        rz_cons_show_cursor(true);
        rz_cons_enable_mouse(false);
        rz_sys_stop();
        return 0;
    }
#endif
    return ch;
}

References rz_cons_enable_mouse(), rz_cons_show_cursor(), and rz_sys_stop().

Referenced by rz_cons_readchar(), and rz_line_readchar_utf8().

rz_cons_fgets()

RZ_API int rz_cons_fgets	(	char *	buf,
		int	len,
		int	argc,
		const char **	argv
	)

Definition at line 339 of file input.c.

                                                                          {
#define RETURN(x) \
    { \
        ret = x; \
        goto beach; \
    }
    RzCons *cons = rz_cons_singleton();
    int ret = 0, color = cons->context->pal.input && *cons->context->pal.input;
    if (cons->echo) {
        rz_cons_set_raw(false);
        rz_cons_show_cursor(true);
    }
#if 0
    int mouse = rz_cons_enable_mouse (false);
    rz_cons_enable_mouse (false);
    rz_cons_flush ();
#endif
    errno = 0;
    if (cons->user_fgets) {
        RETURN(cons->user_fgets(buf, len, cons->user_fgets_user));
    }
    printf("%s", cons->line->prompt);
    fflush(stdout);
    *buf = '\0';
    if (color) {
        const char *p = cons->context->pal.input;
        if (RZ_STR_ISNOTEMPTY(p)) {
            fwrite(p, strlen(p), 1, stdout);
            fflush(stdout);
        }
    }
    if (!fgets(buf, len, cons->fdin)) {
        if (color) {
            printf(Color_RESET);
            fflush(stdout);
        }
        RETURN(-1);
    }
    if (feof(cons->fdin)) {
        if (color) {
            printf(Color_RESET);
        }
        RETURN(-2);
    }
    rz_str_trim_tail(buf);
    if (color) {
        printf(Color_RESET);
    }
    ret = strlen(buf);
beach:
    // rz_cons_enable_mouse (mouse);
    return ret;
}

References color, Color_RESET, rz_cons_t::context, rz_cons_t::echo, rz_cons_t::fdin, rz_cons_printable_palette_t::input, len, rz_cons_t::line, p, rz_cons_context_t::pal, printf(), rz_line_t::prompt, RETURN, rz_cons_enable_mouse(), rz_cons_flush(), rz_cons_set_raw(), rz_cons_show_cursor(), rz_cons_singleton(), RZ_STR_ISNOTEMPTY, rz_str_trim_tail(), rz_cons_t::user_fgets, and rz_cons_t::user_fgets_user.

Referenced by __handleComment(), __panel_prompt(), __prompt(), add_comment(), config_visual_hit(), handleHints(), prompt(), prompt_read(), rtr_visual(), rz_cmd_help(), rz_cmd_kuery(), rz_cons_input(), rz_core_prompt(), rz_core_visual_analysis(), rz_core_visual_analysis_classes(), rz_core_visual_bit_editor(), rz_core_visual_classes(), rz_core_visual_cmd(), rz_core_visual_colors(), rz_core_visual_config_hud(), rz_core_visual_define(), rz_core_visual_esil(), rz_core_visual_graph(), rz_core_visual_offset(), rz_core_visual_prompt(), rz_core_visual_trackflags(), rz_core_visual_view_graph(), rz_core_visual_view_rop(), visual_offset(), visual_prompt(), and visual_search().

rz_cons_input()

RZ_API char* rz_cons_input

(

const char *

msg

)

Definition at line 696 of file input.c.

                                            {
    char *oprompt = rz_line_get_prompt();
    if (!oprompt) {
        return NULL;
    }
    char buf[1024];
    if (msg) {
        rz_line_set_prompt(msg);
    } else {
        rz_line_set_prompt("");
    }
    buf[0] = 0;
    rz_cons_fgets(buf, sizeof(buf), 0, NULL);
    rz_line_set_prompt(oprompt);
    free(oprompt);
    return strdup(buf);
}

References free(), msg, NULL, rz_cons_fgets(), rz_line_get_prompt(), rz_line_set_prompt(), and strdup().

Referenced by __show_status_input(), agraph_follow_innodes(), rz_core_visual_define(), and visual_comma().

rz_cons_readbuffer_readchar()

RZ_API bool rz_cons_readbuffer_readchar

(

char *

ch

)

Definition at line 609 of file input.c.

                                                  {
    if (I->input->readbuffer_length <= 0) {
        return false;
    }
    *ch = *I->input->readbuffer;
    I->input->readbuffer_length--;
    memmove(I->input->readbuffer, I->input->readbuffer + 1, I->input->readbuffer_length);
    return true;
}

References I.

Referenced by rz_cons_readchar(), and rz_cons_readchar_timeout().

rz_cons_readchar()

RZ_API int rz_cons_readchar

(

void

)

Definition at line 619 of file input.c.

                                  {
    char buf[2], ch;
    buf[0] = -1;
    if (rz_cons_readbuffer_readchar(&ch)) {
        return ch;
    }
    rz_cons_set_raw(1);
#if __WINDOWS__
    return __cons_readchar_w32(0);
#else
    void *bed = rz_cons_sleep_begin();
 
    // Blocks until either stdin has something to read or a signal happens.
    // This serves to check if the terminal window was resized. It avoids the race
    // condition that could happen if we did not use pselect or select in case SIGWINCH
    // was handled immediately before the blocking call (select or read). The race is
    // prevented from happening by having SIGWINCH blocked process-wide except for in
    // pselect (that is what pselect is for).
    fd_set readfds;
    sigset_t sigmask;
    FD_ZERO(&readfds);
    FD_SET(STDIN_FILENO, &readfds);
    rz_signal_sigmask(0, NULL, &sigmask);
    sigdelset(&sigmask, SIGWINCH);
    while (pselect(STDIN_FILENO + 1, &readfds, NULL, NULL, NULL, &sigmask) == -1) {
        if (errno == EBADF) {
            eprintf("rz_cons_readchar (): EBADF\n");
            return -1;
        }
        if (sigwinchFlag) {
            sigwinchFlag = 0;
            resizeWin();
        }
    }
 
    ssize_t ret = read(STDIN_FILENO, buf, 1);
    rz_cons_sleep_end(bed);
    if (ret != 1) {
        return -1;
    }
    if (I->input->bufactive) {
        rz_cons_set_raw(0);
    }
    return rz_cons_controlz(buf[0]);
#endif
}

References EBADF, eprintf, FD_SET, FD_ZERO, I, NULL, read(), readfds, resizeWin(), rz_cons_controlz(), rz_cons_readbuffer_readchar(), rz_cons_set_raw(), rz_cons_sleep_begin(), rz_cons_sleep_end(), SIGWINCH, sigwinchFlag, and STDIN_FILENO.

Referenced by __create_almighty(), __handle_tab(), __handle_visual_mark(), __panels_process(), __parseMouseEvent(), __show_status(), __vi_mode(), agraph_follow_innodes(), goto_asmqjmps(), insert_mode_enabled(), rtr_visual(), rz_cons_any_key(), rz_cons_arrow_to_hjkl(), rz_cons_less_str(), rz_cons_readchar_timeout(), rz_core_visual(), rz_core_visual_analysis(), rz_core_visual_analysis_classes(), rz_core_visual_bit_editor(), rz_core_visual_browse(), rz_core_visual_classes(), rz_core_visual_cmd(), rz_core_visual_colors(), rz_core_visual_comments(), rz_core_visual_config(), rz_core_visual_debugtraces(), rz_core_visual_define(), rz_core_visual_esil(), rz_core_visual_graph(), rz_core_visual_trackflags(), rz_core_visual_view_graph(), rz_core_visual_view_rop(), rz_core_visual_xrefs(), rz_diff_hex_visual(), rz_line_readchar_utf8(), rz_line_readline_cb(), and visual_help().

rz_cons_readchar_timeout()

RZ_API int rz_cons_readchar_timeout

(

ut32

usec

)

Definition at line 560 of file input.c.

                                               {
    char ch;
    if (rz_cons_readbuffer_readchar(&ch)) {
        return ch;
    }
#if __UNIX__
    struct timeval tv;
    fd_set fdset, errset;
    FD_ZERO(&fdset);
    FD_ZERO(&errset);
    FD_SET(0, &fdset);
    tv.tv_sec = 0; // usec / 1000;
    tv.tv_usec = 1000 * usec;
    rz_cons_set_raw(1);
    if (select(1, &fdset, NULL, &errset, &tv) == 1) {
        return rz_cons_readchar();
    }
    rz_cons_set_raw(0);
    // timeout
    return -1;
#else
    return __cons_readchar_w32(usec);
#endif
}

References FD_SET, FD_ZERO, NULL, rz_cons_readbuffer_readchar(), rz_cons_readchar(), rz_cons_set_raw(), select, and tv.

Referenced by rz_line_readline_cb().

rz_cons_readflush()

RZ_API void rz_cons_readflush

(

void

)

Definition at line 596 of file input.c.

                                    {
    RZ_FREE(I->input->readbuffer);
    I->input->readbuffer_length = 0;
}

References I, and RZ_FREE.

rz_cons_readpush()

RZ_API bool rz_cons_readpush	(	const char *	str,
		int	len
	)

Definition at line 585 of file input.c.

                                                       {
    char *res = (len + I->input->readbuffer_length > 0) ? realloc(I->input->readbuffer, len + I->input->readbuffer_length) : NULL;
    if (res) {
        I->input->readbuffer = res;
        memmove(I->input->readbuffer + I->input->readbuffer_length, str, len);
        I->input->readbuffer_length += len;
        return true;
    }
    return false;
}

References I, len, NULL, realloc(), and cmd_descs_generate::str.

Referenced by rz_core_visual(), and rz_push_escaped_handler().

rz_cons_switchbuf()

RZ_API void rz_cons_switchbuf

(

bool

active

)

Definition at line 601 of file input.c.

                                           {
    I->input->bufactive = active;
}

References I.

Referenced by __handle_console(), __handle_menu(), __handle_tab_key(), __handle_window_mode(), __handle_zoom_mode(), and __panels_process().

rz_cons_yesno()

RZ_API bool rz_cons_yesno	(	int	def,
		const char *	fmt,
			...
	)

Definition at line 666 of file input.c.

                                                         {
    va_list ap;
    ut8 key = (ut8)def;
    va_start(ap, fmt);
 
    if (!rz_cons_is_interactive()) {
        va_end(ap);
        return def == 'y';
    }
    vfprintf(stderr, fmt, ap);
    va_end(ap);
    fflush(stderr);
    rz_cons_set_raw(true);
    char buf[] = " ?\n";
    if (read(0, buf + 1, 1) == 1) {
        key = (ut8)buf[1];
        if (write(2, buf, 3) == 3) {
            if (key == 'Y') {
                key = 'y';
            }
            rz_cons_set_raw(false);
            if (key == '\n' || key == '\r') {
                key = def;
            }
            return key == 'y';
        }
    }
    return false;
}

References def(), key, read(), rz_cons_is_interactive(), rz_cons_set_raw(), ut8, and write.

Referenced by __show_status_yesno(), agraph_refresh(), check_function_modified(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), rz_cmd_help(), rz_cons_flush(), rz_core_cmd_subst(), rz_core_visual_asm(), rz_core_visual_graph(), rz_main_rizin(), rz_w32_identify_window(), and w32_list_heaps_blocks().

Variable Documentation

sigwinchFlag

volatile sig_atomic_t sigwinchFlag

extern

Referenced by rz_cons_readchar().