mirror of
https://github.com/radareorg/radare2.git
synced 2024-11-23 21:29:49 +00:00
2437 lines
59 KiB
C
2437 lines
59 KiB
C
/* radare - LGPL - Copyright 2007-2024 - pancake */
|
|
/* dietline is a lightweight and portable library similar to GNU readline */
|
|
|
|
#include "r_util/r_str_util.h"
|
|
#include <r_cons.h>
|
|
#include <r_core.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#if R2__WINDOWS__
|
|
#include <windows.h>
|
|
#define printf(...) r_cons_win_printf (false, __VA_ARGS__)
|
|
#define USE_UTF8 1
|
|
static int r_line_readchar_win(ut8 *s, int slen);
|
|
#else
|
|
#include <sys/ioctl.h>
|
|
#ifndef HAVE_PTY
|
|
#include <termios.h>
|
|
#endif
|
|
#include <signal.h>
|
|
#define USE_UTF8 1
|
|
#endif
|
|
|
|
static const char word_break_characters[] = "\t\r\n ~`!@#$%^&*()-=+[]{}\\|;:\"'<>,./";
|
|
|
|
// TODO: remove global variables
|
|
static R_TH_LOCAL bool enable_yank_pop = false;
|
|
static R_TH_LOCAL int count = 0;
|
|
|
|
typedef enum {
|
|
MINOR_BREAK,
|
|
MAJOR_BREAK
|
|
} BreakMode;
|
|
|
|
static inline bool is_word_break_char(char ch, BreakMode mode) {
|
|
int i;
|
|
if (mode == MAJOR_BREAK) {
|
|
return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
|
|
}
|
|
int len =
|
|
sizeof (word_break_characters) /
|
|
sizeof (word_break_characters[0]);
|
|
for (i = 0; i < len; i++) {
|
|
if (ch == word_break_characters[i]) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static inline void swap_case(int index) {
|
|
if (IS_UPPER (I.buffer.data[index])) {
|
|
I.buffer.data[index] += 32;
|
|
} else if (IS_LOWER (I.buffer.data[index])) {
|
|
I.buffer.data[index] -= 32;
|
|
}
|
|
}
|
|
|
|
static void backward_skip_major_word_break_chars(int *cursor) {
|
|
while (*cursor >= 0 && is_word_break_char (I.buffer.data[*cursor], MAJOR_BREAK)) {
|
|
(*cursor)--;
|
|
}
|
|
}
|
|
|
|
static void skip_major_word_break_chars(int *cursor) {
|
|
while (*cursor < I.buffer.length && is_word_break_char (I.buffer.data[*cursor], MAJOR_BREAK)) {
|
|
(*cursor)++;
|
|
}
|
|
}
|
|
|
|
static void goto_word_start(int *cursor, BreakMode break_mode) {
|
|
if (!is_word_break_char (I.buffer.data[*cursor], break_mode)) {
|
|
/* move cursor backwards to the next word-break char */
|
|
while (*cursor >= 0 && !is_word_break_char (I.buffer.data[*cursor], break_mode)) {
|
|
(*cursor)--;
|
|
}
|
|
} else if (is_word_break_char (I.buffer.data[*cursor], MINOR_BREAK)) {
|
|
/* move cursor backwards to the next non-word-break char OR MAJOR break char */
|
|
while (*cursor >= 0 && is_word_break_char (I.buffer.data[*cursor], MINOR_BREAK)
|
|
&& !is_word_break_char (I.buffer.data[*cursor], MAJOR_BREAK)) {
|
|
(*cursor)--;
|
|
}
|
|
} else {
|
|
/* move cursor backwards to the next MINOR word-break char OR non-word-break char */
|
|
while (*cursor >= 0 && is_word_break_char (I.buffer.data[*cursor], MAJOR_BREAK)) {
|
|
(*cursor)--;
|
|
}
|
|
}
|
|
/* increment cursor to go to the start of current word */
|
|
if (*cursor < I.buffer.length - 1) {
|
|
(*cursor)++;
|
|
}
|
|
}
|
|
|
|
static void goto_word_end(int *cursor, BreakMode break_mode) {
|
|
if (!is_word_break_char (I.buffer.data[*cursor], break_mode)) {
|
|
/* move cursor forward to the next word-break char */
|
|
while (*cursor < I.buffer.length && !is_word_break_char (I.buffer.data[*cursor], break_mode)) {
|
|
(*cursor)++;
|
|
}
|
|
} else if (is_word_break_char (I.buffer.data[*cursor], MINOR_BREAK)) {
|
|
/* move cursor forward to the next non-word-break char or MAJOR break char */
|
|
while (*cursor < I.buffer.length && is_word_break_char (I.buffer.data[*cursor], MINOR_BREAK)
|
|
&& !is_word_break_char (I.buffer.data[*cursor], MAJOR_BREAK)) {
|
|
(*cursor)++;
|
|
}
|
|
}
|
|
/* decrement cursor to go to the end of current word */
|
|
if (*cursor > 0) {
|
|
(*cursor)--;
|
|
}
|
|
}
|
|
|
|
static void goto_next_word(int *cursor, BreakMode break_mode) {
|
|
goto_word_end (cursor, break_mode);
|
|
(*cursor)++;
|
|
if (is_word_break_char (I.buffer.data[*cursor], MAJOR_BREAK)) {
|
|
skip_major_word_break_chars (cursor);
|
|
}
|
|
}
|
|
|
|
static int vi_end_word_motion(BreakMode break_mode) {
|
|
int cursor;
|
|
if (I.buffer.index < I.buffer.length - 1) {
|
|
cursor = I.buffer.index;
|
|
if (is_word_break_char (I.buffer.data[cursor], MAJOR_BREAK)) {
|
|
skip_major_word_break_chars (&cursor);
|
|
goto_word_end (&cursor, break_mode);
|
|
} else {
|
|
cursor++;
|
|
skip_major_word_break_chars (&cursor);
|
|
goto_word_end (&cursor, break_mode);
|
|
}
|
|
return cursor;
|
|
}
|
|
return I.buffer.index;
|
|
}
|
|
|
|
static int vi_backward_word_motion(BreakMode break_mode) {
|
|
int cursor;
|
|
if (I.buffer.index > 0) {
|
|
cursor = I.buffer.index - 1;
|
|
backward_skip_major_word_break_chars (&cursor);
|
|
goto_word_start (&cursor, break_mode);
|
|
return cursor;
|
|
}
|
|
return I.buffer.index;
|
|
}
|
|
|
|
static int vi_next_word_motion(BreakMode break_mode) {
|
|
int cursor;
|
|
if (I.buffer.index < I.buffer.length) {
|
|
cursor = I.buffer.index;
|
|
if (is_word_break_char (I.buffer.data[cursor], MAJOR_BREAK)) {
|
|
skip_major_word_break_chars (&cursor);
|
|
} else {
|
|
goto_next_word (&cursor, break_mode);
|
|
}
|
|
return cursor;
|
|
}
|
|
return I.buffer.index;
|
|
}
|
|
|
|
static inline void __delete_current_char(void) {
|
|
if (I.buffer.index < I.buffer.length) {
|
|
int len = r_str_utf8_charsize (I.buffer.data + I.buffer.index);
|
|
memmove (I.buffer.data + I.buffer.index,
|
|
I.buffer.data + I.buffer.index + len,
|
|
strlen (I.buffer.data + I.buffer.index + 1) + 1);
|
|
I.buffer.length -= len;
|
|
if (I.buffer.index > 0 && I.buffer.index == I.buffer.length) {
|
|
I.buffer.index--;
|
|
}
|
|
}
|
|
}
|
|
|
|
static inline int indexof(int c, int offset) {
|
|
char *ptr;
|
|
ptr = strchr (I.buffer.data + offset, c);
|
|
if (ptr != NULL) {
|
|
return ptr - I.buffer.data;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static inline int vi_motion_seek_to_char(int c) {
|
|
int i;
|
|
if (I.buffer.index < I.buffer.length) {
|
|
i = indexof (c, I.buffer.index + 1);
|
|
if (i != -1) {
|
|
return i;
|
|
}
|
|
}
|
|
return I.buffer.index;
|
|
}
|
|
|
|
static inline int vi_motion_seek_to_char_backward(int c) {
|
|
int i;
|
|
if (I.buffer.index > 0) {
|
|
i = I.buffer.index - 1;
|
|
while (i >= 0) {
|
|
if (I.buffer.data[i] == c) {
|
|
return i;
|
|
}
|
|
i--;
|
|
}
|
|
}
|
|
return I.buffer.index;
|
|
}
|
|
|
|
static inline void shift_buffer(int start, int end) {
|
|
int len;
|
|
len = end - start + 1;
|
|
free (I.clipboard);
|
|
I.clipboard = r_str_ndup (I.buffer.data + start, len);
|
|
r_line_clipboard_push (I.clipboard);
|
|
memmove (I.buffer.data + start, I.buffer.data + end, I.buffer.length - end);
|
|
/* resize buffer to take into account the word we deleted */
|
|
I.buffer.data[I.buffer.length - len + 1] = '\0';
|
|
I.buffer.length = strlen (I.buffer.data);
|
|
}
|
|
|
|
/* https://www.gnu.org/software/bash/manual/html_node/Commands-For-Killing.html */
|
|
static void backward_kill_word(BreakMode break_mode) {
|
|
int i;
|
|
i = vi_backward_word_motion (break_mode);
|
|
if (i == I.buffer.index) {
|
|
return;
|
|
}
|
|
shift_buffer (i, I.buffer.index);
|
|
I.buffer.index = i;
|
|
}
|
|
|
|
static void kill_word(BreakMode break_mode, char motion) {
|
|
int i = 0;
|
|
if (I.buffer.index == I.buffer.length - 1) {
|
|
__delete_current_char ();
|
|
return;
|
|
}
|
|
switch (motion) {
|
|
case 'w':
|
|
i = vi_next_word_motion (break_mode);
|
|
break;
|
|
case 'e':
|
|
i = vi_end_word_motion (break_mode) + 1;
|
|
break;
|
|
}
|
|
shift_buffer (I.buffer.index, i);
|
|
if (I.buffer.index > 0 && I.buffer.index == I.buffer.length) {
|
|
I.buffer.index--;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* diw and diW commands
|
|
* how it works:
|
|
* - go to the start of the current word (spaces are considered words here)
|
|
* - delete until the last character of the word
|
|
* - handle edge cases when the last character of the current word is the last character of the line
|
|
*/
|
|
static void delete_in_word(BreakMode break_mode) {
|
|
int i;
|
|
if (I.buffer.length > 0) {
|
|
goto_word_start (&I.buffer.index, break_mode);
|
|
i = I.buffer.index;
|
|
if (!is_word_break_char (I.buffer.data[i], break_mode)) {
|
|
while (i < I.buffer.length && !is_word_break_char (I.buffer.data[i], break_mode)) {
|
|
i++;
|
|
}
|
|
if (i == I.buffer.length - 1 && !is_word_break_char (I.buffer.data[i], break_mode)) {
|
|
i--;
|
|
}
|
|
} else if (is_word_break_char (I.buffer.data[i], MAJOR_BREAK)) {
|
|
while (i < I.buffer.length && is_word_break_char (I.buffer.data[i], MAJOR_BREAK)) {
|
|
i++;
|
|
}
|
|
if (i == I.buffer.length - 1 && is_word_break_char (I.buffer.data[i], MAJOR_BREAK)) {
|
|
i--;
|
|
}
|
|
} else {
|
|
while (i < I.buffer.length && is_word_break_char (I.buffer.data[i], MINOR_BREAK)
|
|
&& !is_word_break_char (I.buffer.data[i], MAJOR_BREAK)) {
|
|
i++;
|
|
}
|
|
if (i == I.buffer.length - 1 && is_word_break_char (I.buffer.data[i], MINOR_BREAK)
|
|
&& !is_word_break_char (I.buffer.data[i], MAJOR_BREAK)) {
|
|
i--;
|
|
}
|
|
}
|
|
if (i == I.buffer.index) {
|
|
__delete_current_char ();
|
|
return;
|
|
}
|
|
shift_buffer (I.buffer.index, i);
|
|
if (I.buffer.index > 0 && I.buffer.index == I.buffer.length) {
|
|
I.buffer.index--;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* function used for di", di(, di{, ... commands
|
|
* parameters:
|
|
* - start -> starting character like '('
|
|
* - end -> closing character like ')'
|
|
* how it works:
|
|
* - start by looking for the start char backwards
|
|
* - if not found look forward
|
|
* - call indexof() to get the index of the closing char
|
|
* - shift (resize) the buffer
|
|
* note: doesn't work well with nested chars like ((test))
|
|
* would need a stack for that
|
|
*/
|
|
static inline int delete_between(int start, int end) {
|
|
int i, stop;
|
|
i = vi_motion_seek_to_char_backward (start);
|
|
if (i == I.buffer.index) {
|
|
i = vi_motion_seek_to_char (start);
|
|
}
|
|
if (i != I.buffer.index) {
|
|
stop = indexof (end, i + 1);
|
|
if (stop != -1) {
|
|
shift_buffer (i + 1, stop);
|
|
return i + 1;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static void paste(void) {
|
|
if (I.clipboard) {
|
|
char *cursor = I.buffer.data + I.buffer.index;
|
|
int dist = (I.buffer.data + I.buffer.length) - cursor;
|
|
int len = strlen (I.clipboard);
|
|
I.buffer.length += len;
|
|
memmove (cursor + len, cursor, dist);
|
|
memcpy (cursor, I.clipboard, len);
|
|
I.buffer.index += len;
|
|
enable_yank_pop = true;
|
|
}
|
|
}
|
|
|
|
static void unix_word_rubout(void) {
|
|
int i, len;
|
|
if (I.buffer.index > 0) {
|
|
for (i = I.buffer.index - 1; i > 0 && I.buffer.data[i] == ' '; i--) {
|
|
/* Move cursor backwards until we hit a non-space character or EOL */
|
|
/* This removes any trailing spaces from the input */
|
|
}
|
|
for (; i > 0 && I.buffer.data[i] != ' '; i--) {
|
|
/* Move cursor backwards until we hit a space character or EOL */
|
|
/* This deletes everything back to the previous space character */
|
|
}
|
|
if (i > 0) {
|
|
i++;
|
|
} else if (i < 0) {
|
|
i = 0;
|
|
}
|
|
if (I.buffer.index > I.buffer.length) {
|
|
I.buffer.length = I.buffer.index;
|
|
}
|
|
len = I.buffer.index - i + 1;
|
|
free (I.clipboard);
|
|
I.clipboard = r_str_ndup (I.buffer.data + i, len);
|
|
r_line_clipboard_push (I.clipboard);
|
|
memmove (I.buffer.data + i,
|
|
I.buffer.data + I.buffer.index,
|
|
I.buffer.length - I.buffer.index + 1);
|
|
I.buffer.length = strlen (I.buffer.data);
|
|
I.buffer.index = i;
|
|
}
|
|
}
|
|
|
|
static int inithist(void) {
|
|
if (I.history.data) {
|
|
int new_size = I.hist_size;
|
|
if (new_size > 0 && I.history.size != new_size) {
|
|
char **new_data = (char **) calloc (new_size, sizeof (char *));
|
|
if (new_data) {
|
|
int nb_copy_lines = R_MIN (I.history.top + 1, new_size);
|
|
memcpy (new_data, I.history.data + (I.history.top + 1 - nb_copy_lines), sizeof (char *) * nb_copy_lines);
|
|
int i;
|
|
for (i = 0; i < I.history.top + 1 - nb_copy_lines; i++) {
|
|
free (I.history.data[i]);
|
|
}
|
|
free (I.history.data);
|
|
I.history.data = new_data;
|
|
I.history.size = new_size;
|
|
I.history.top = R_MIN (I.history.top, nb_copy_lines - 1);
|
|
I.history.index = R_MIN (I.history.index, nb_copy_lines - 1);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
ZERO_FILL (I.history);
|
|
I.history.size = I.hist_size;
|
|
if (I.history.size <= 0) {
|
|
return false;
|
|
}
|
|
I.history.data = (char **) calloc (I.history.size, sizeof (char *));
|
|
if (!I.history.data) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* initialize history stuff */
|
|
R_API int r_line_dietline_init(void) {
|
|
ZERO_FILL (I.completion);
|
|
if (!inithist ()) {
|
|
return false;
|
|
}
|
|
I.echo = true;
|
|
return true;
|
|
}
|
|
|
|
#if USE_UTF8
|
|
/* read utf8 char into 's', return the length in bytes */
|
|
static int r_line_readchar_utf8(ut8 *s, int slen) {
|
|
#if R2__WINDOWS__
|
|
return r_line_readchar_win (s, slen);
|
|
#else
|
|
// TODO: add support for w32
|
|
ssize_t len, i;
|
|
if (slen < 1) {
|
|
return 0;
|
|
}
|
|
int ch = -1;
|
|
if (I.demo) {
|
|
ch = r_cons_readchar_timeout (80);
|
|
} else {
|
|
ch = r_cons_readchar ();
|
|
}
|
|
if (ch == -1) {
|
|
return I.demo? 0: -1;
|
|
}
|
|
*s = ch;
|
|
*s = r_cons_controlz (*s);
|
|
if (*s < 0x80) {
|
|
len = 1;
|
|
} else if ((s[0] & 0xe0) == 0xc0) {
|
|
len = 2;
|
|
} else if ((s[0] & 0xf0) == 0xe0) {
|
|
len = 3;
|
|
} else if ((s[0] & 0xf8) == 0xf0) {
|
|
len = 4;
|
|
} else {
|
|
return -1;
|
|
}
|
|
if (len > slen) {
|
|
return -1;
|
|
}
|
|
for (i = 1; i < len; i++) {
|
|
ch = r_cons_readchar ();
|
|
if (ch != -1) {
|
|
s[i] = ch;
|
|
}
|
|
if ((s[i] & 0xc0) != 0x80) {
|
|
return -1;
|
|
}
|
|
}
|
|
return len;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
#if R2__WINDOWS__
|
|
static int r_line_readchar_win(ut8 *s, int slen) { // this function handle the input in console mode
|
|
INPUT_RECORD irInBuf = { { 0 } };
|
|
BOOL ret;
|
|
DWORD mode, out;
|
|
char buf[5] = {
|
|
0
|
|
};
|
|
void *bed;
|
|
|
|
HANDLE h = GetStdHandle (STD_INPUT_HANDLE);
|
|
DWORD new_mode = I.vtmode == 2? ENABLE_VIRTUAL_TERMINAL_INPUT: 0;
|
|
GetConsoleMode (h, &mode);
|
|
SetConsoleMode (h, new_mode);
|
|
if (I.zerosep) {
|
|
bed = r_cons_sleep_begin ();
|
|
DWORD rsz = 0;
|
|
BOOL ret = ReadFile (h, s, 1, &rsz, NULL);
|
|
r_cons_sleep_end (bed);
|
|
SetConsoleMode (h, mode);
|
|
if (!ret || rsz != 1) {
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
do_it_again:
|
|
bed = r_cons_sleep_begin ();
|
|
if (r_cons_singleton ()->term_xterm) {
|
|
ret = ReadFile (h, buf, 1, &out, NULL);
|
|
} else {
|
|
ret = ReadConsoleInput (h, &irInBuf, 1, &out);
|
|
}
|
|
r_cons_sleep_end (bed);
|
|
if (ret < 1) {
|
|
return 0;
|
|
}
|
|
if (irInBuf.EventType == KEY_EVENT) {
|
|
if (irInBuf.Event.KeyEvent.bKeyDown) {
|
|
if (irInBuf.Event.KeyEvent.uChar.UnicodeChar) {
|
|
ut8 chbuf[4] = {
|
|
0
|
|
};
|
|
memcpy (chbuf, &(irInBuf.Event.KeyEvent.uChar), 2);
|
|
char *tmp = r_sys_conv_win_to_utf8_l ((PTCHAR) &chbuf, 1);
|
|
if (tmp) {
|
|
r_str_ncpy (buf, tmp, sizeof (buf));
|
|
free (tmp);
|
|
}
|
|
} else {
|
|
int idx = 0;
|
|
buf[idx++] = 27;
|
|
buf[idx++] = '['; // Simulate escaping
|
|
if (irInBuf.Event.KeyEvent.dwControlKeyState & 8) {
|
|
buf[idx++] = '1'; // control key
|
|
}
|
|
switch (irInBuf.Event.KeyEvent.wVirtualKeyCode) {
|
|
case VK_UP: buf[idx++] = 'A'; break;
|
|
case VK_DOWN: buf[idx++] = 'B'; break;
|
|
case VK_RIGHT: buf[idx++] = 'C'; break;
|
|
case VK_LEFT: buf[idx++] = 'D'; break;
|
|
case VK_PRIOR: buf[idx++] = '5'; break; // PAGE UP
|
|
case VK_NEXT: buf[idx++] = '6'; break; // PAGE DOWN
|
|
case VK_DELETE: buf[idx++] = '3'; break;// SUPR KEY
|
|
case VK_HOME: buf[idx++] = 'H'; break; // HOME KEY
|
|
case VK_END: buf[idx++] = 'F'; break; // END KEY
|
|
default: buf[0] = 0; break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!buf[0]) {
|
|
goto do_it_again;
|
|
}
|
|
r_str_ncpy ((char *) s, buf, slen);
|
|
SetConsoleMode (h, mode);
|
|
return strlen ((char *) s);
|
|
}
|
|
|
|
#endif
|
|
|
|
R_API int r_line_set_hist_callback(RLine *line, RLineHistoryUpCb up, RLineHistoryDownCb down) {
|
|
line->cb_history_up = up;
|
|
line->cb_history_down = down;
|
|
line->offset_hist_index = 0;
|
|
line->file_hist_index = 0;
|
|
line->sdbshell_hist_iter = r_list_head (line->sdbshell_hist);
|
|
return 1;
|
|
}
|
|
|
|
static inline bool match_hist_line(RLine *line, int i) {
|
|
const char *hist_line = line->history.data[i];
|
|
char *cur_line = line->history.match;
|
|
if (!line->histfilter) {
|
|
return true;
|
|
}
|
|
// Starts with but not equal to
|
|
return r_str_startswith (hist_line, cur_line) && strcmp (hist_line, cur_line);
|
|
}
|
|
|
|
static void setup_hist_match(RLine *line) {
|
|
if (line->history.do_setup_match) {
|
|
R_FREE (line->history.match);
|
|
if (*line->buffer.data) {
|
|
line->history.match = strdup (line->buffer.data);
|
|
}
|
|
}
|
|
line->history.do_setup_match = false;
|
|
}
|
|
|
|
R_API int r_line_hist_cmd_up(RLine *line) {
|
|
if (line->hist_up) {
|
|
return line->hist_up (line->user);
|
|
}
|
|
if (!inithist ()) {
|
|
return false;
|
|
}
|
|
if (line->history.index > 0 && line->history.data) {
|
|
setup_hist_match (line);
|
|
if (line->history.match) {
|
|
int i;
|
|
for (i = line->history.index - 1; i >= 0; i--) {
|
|
if (match_hist_line (line, i)) {
|
|
line->history.index = i;
|
|
break;
|
|
}
|
|
}
|
|
if (i < 0) {
|
|
return false;
|
|
}
|
|
} else {
|
|
line->history.index--;
|
|
}
|
|
strncpy (line->buffer.data, line->history.data[line->history.index], R_LINE_BUFSIZE - 1);
|
|
line->buffer.index = line->buffer.length = strlen (line->buffer.data);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
R_API int r_line_hist_cmd_down(RLine *line) {
|
|
if (line->hist_down) {
|
|
return line->hist_down (line->user);
|
|
}
|
|
if (!line->history.data) {
|
|
inithist ();
|
|
}
|
|
setup_hist_match (line);
|
|
if (line->history.match) {
|
|
int i;
|
|
for (i = line->history.index + 1; i < line->history.top; i++) {
|
|
if (match_hist_line (line, i)) {
|
|
break;
|
|
}
|
|
}
|
|
line->history.index = i;
|
|
} else {
|
|
line->history.index++;
|
|
}
|
|
if (line->history.index >= line->history.top) {
|
|
line->history.index = line->history.top;
|
|
if (line->history.match) {
|
|
strncpy (line->buffer.data, line->history.match, R_LINE_BUFSIZE - 1);
|
|
} else {
|
|
line->buffer.data[0] = '\0';
|
|
}
|
|
line->buffer.index = line->buffer.length = strlen (line->buffer.data);
|
|
return false;
|
|
}
|
|
if (line->history.data && line->history.data[line->history.index]) {
|
|
strncpy (line->buffer.data, line->history.data[line->history.index], R_LINE_BUFSIZE - 1);
|
|
line->buffer.index = line->buffer.length = strlen (line->buffer.data);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// TODO argument can be "owned" so we can save some unnecessary free/malloc's
|
|
// R2_600 - return bool instead of int
|
|
R_API int r_line_hist_add(const char *line) {
|
|
if (R_STR_ISEMPTY (line)) {
|
|
return false;
|
|
}
|
|
if (!I.history.data) {
|
|
inithist ();
|
|
}
|
|
/* ignore dup */
|
|
if (I.history.top > 0) {
|
|
const char *data = I.history.data[I.history.top - 1];
|
|
if (data && !strcmp (line, data)) {
|
|
I.history.index = I.history.top;
|
|
return false;
|
|
}
|
|
}
|
|
if (I.history.top == I.history.size) {
|
|
int i;
|
|
free (I.history.data[0]);
|
|
for (i = 0; i <= I.history.size - 2; i++) {
|
|
I.history.data[i] = I.history.data[i + 1];
|
|
}
|
|
I.history.top--;
|
|
}
|
|
I.history.data[I.history.top++] = strdup (line);
|
|
I.history.index = I.history.top;
|
|
return true;
|
|
}
|
|
|
|
static int r_line_hist_up(void) {
|
|
if (!I.cb_history_up) {
|
|
r_line_set_hist_callback (&I, &r_line_hist_cmd_up, &r_line_hist_cmd_down);
|
|
}
|
|
return I.cb_history_up (&I);
|
|
}
|
|
|
|
static int r_line_hist_down(void) {
|
|
if (!I.cb_history_down) {
|
|
r_line_set_hist_callback (&I, &r_line_hist_cmd_up, &r_line_hist_cmd_down);
|
|
}
|
|
return I.cb_history_down (&I);
|
|
}
|
|
|
|
R_API void r_line_hist_set_size(int size) {
|
|
I.hist_size = R_MIN (size, 65536);
|
|
}
|
|
|
|
R_API int r_line_hist_get_size(void) {
|
|
return I.history.size;
|
|
}
|
|
|
|
R_API const char *r_line_hist_get(int n) {
|
|
int i = 0;
|
|
inithist ();
|
|
n--;
|
|
if (I.history.data) {
|
|
for (i = 0; i < I.history.size && I.history.data[i]; i++) {
|
|
if (n == i) {
|
|
return I.history.data[i];
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
#if R2_USE_NEW_ABI
|
|
R_API int r_line_hist_list(bool full) {
|
|
int i = 0;
|
|
inithist ();
|
|
if (I.history.data) {
|
|
i = full? 0: I.history.load_index;
|
|
for (; i < I.history.size && I.history.data[i]; i++) {
|
|
const char *pad = r_str_pad (' ', 32 - strlen (I.history.data[i]));
|
|
r_cons_printf ("%s %s # !%d\n", I.history.data[i], pad, i);
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
#else
|
|
R_API int r_line_hist_list(void) {
|
|
int i = 0;
|
|
inithist ();
|
|
if (I.history.data) {
|
|
for (i = 0; i < I.history.size && I.history.data[i]; i++) {
|
|
const char *pad = r_str_pad (' ', 32 - strlen (I.history.data[i]));
|
|
r_cons_printf ("%s %s # !%d\n", I.history.data[i], pad, i);
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
#endif
|
|
|
|
R_API void r_line_hist_free(void) {
|
|
int i;
|
|
if (I.history.data) {
|
|
for (i = 0; i < I.history.size; i++) {
|
|
R_FREE (I.history.data[i]);
|
|
}
|
|
}
|
|
R_FREE (I.history.data);
|
|
R_FREE (I.sdbshell_hist);
|
|
I.history.index = 0;
|
|
}
|
|
|
|
/* load history from file. TODO: if file == NULL load from ~/.<prg>.history or so */
|
|
R_API bool r_line_hist_load(const char *file) {
|
|
R_RETURN_VAL_IF_FAIL (file, false);
|
|
char *buf = calloc (1, R_LINE_BUFSIZE);
|
|
FILE *fd = r_sandbox_fopen (file, "rb");
|
|
if (!fd) {
|
|
free (buf);
|
|
return false;
|
|
}
|
|
memset (buf, 0, R_LINE_BUFSIZE);
|
|
while (fgets (buf, R_LINE_BUFSIZE - 1, fd)) {
|
|
r_str_trim_tail (buf);
|
|
if (*buf) {
|
|
r_line_hist_add (buf);
|
|
}
|
|
memset (buf, 0, R_LINE_BUFSIZE);
|
|
}
|
|
#if R2_USE_NEW_ABI
|
|
I.history.load_index = I.history.index;
|
|
#endif
|
|
fclose (fd);
|
|
free (buf);
|
|
return true;
|
|
}
|
|
|
|
R_API bool r_line_hist_save(const char *file) {
|
|
R_RETURN_VAL_IF_FAIL (file && *file, false);
|
|
int i;
|
|
bool ret = false;
|
|
char *p = (char *) r_str_lastbut (file, R_SYS_DIR[0], NULL);
|
|
if (p) {
|
|
*p = 0;
|
|
if (!r_sys_mkdirp (file)) {
|
|
if (r_sandbox_check (R_SANDBOX_GRAIN_FILES)) {
|
|
R_LOG_ERROR ("Could not save history into %s", file);
|
|
}
|
|
goto end;
|
|
}
|
|
*p = R_SYS_DIR[0];
|
|
}
|
|
FILE *fd = r_sandbox_fopen (file, "w");
|
|
if (fd) {
|
|
if (I.history.data) {
|
|
for (i = 0; i < I.history.index; i++) {
|
|
fputs (I.history.data[i], fd);
|
|
fputs ("\n", fd);
|
|
}
|
|
ret = true;
|
|
}
|
|
fclose (fd);
|
|
}
|
|
end:
|
|
return ret;
|
|
}
|
|
|
|
R_API int r_line_hist_chop(const char *file, int limit) {
|
|
/* TODO */
|
|
return 0;
|
|
}
|
|
|
|
static void selection_widget_draw(void) {
|
|
RCons *cons = r_cons_singleton ();
|
|
RSelWidget *sel_widget = I.sel_widget;
|
|
int y, pos_y, pos_x = r_str_ansi_len (I.prompt);
|
|
sel_widget->h = R_MIN (sel_widget->h, R_SELWIDGET_MAXH);
|
|
for (y = 0; y < sel_widget->options_len; y++) {
|
|
sel_widget->w = R_MAX (sel_widget->w, strlen (sel_widget->options[y]));
|
|
}
|
|
if (sel_widget->direction == R_SELWIDGET_DIR_UP) {
|
|
pos_y = cons->rows;
|
|
} else {
|
|
pos_y = r_cons_get_cur_line ();
|
|
if (pos_y + sel_widget->h > cons->rows) {
|
|
printf ("%s\n", r_str_pad ('\n', sel_widget->h));
|
|
pos_y = cons->rows - sel_widget->h - 1;
|
|
}
|
|
}
|
|
sel_widget->w = R_MIN (sel_widget->w, R_SELWIDGET_MAXW);
|
|
|
|
char *background_color = cons->context->color_mode? cons->context->pal.widget_bg: Color_INVERT_RESET;
|
|
char *selected_color = cons->context->color_mode? cons->context->pal.widget_sel: Color_INVERT;
|
|
bool scrollbar = sel_widget->options_len > R_SELWIDGET_MAXH;
|
|
int scrollbar_y = 0, scrollbar_l = 0;
|
|
if (scrollbar) {
|
|
scrollbar_y = (R_SELWIDGET_MAXH * (sel_widget->selection - sel_widget->scroll)) / sel_widget->options_len;
|
|
scrollbar_l = (R_SELWIDGET_MAXH * R_SELWIDGET_MAXH) / sel_widget->options_len;
|
|
}
|
|
|
|
for (y = 0; y < sel_widget->h; y++) {
|
|
if (sel_widget->direction == R_SELWIDGET_DIR_UP) {
|
|
r_cons_gotoxy (pos_x + 1, pos_y - y - 1);
|
|
} else {
|
|
r_cons_gotoxy (pos_x + 1, pos_y + y + 1);
|
|
}
|
|
int scroll = R_MAX (0, sel_widget->selection - sel_widget->scroll);
|
|
const char *option = y < sel_widget->options_len? sel_widget->options[y + scroll]: "";
|
|
r_cons_printf ("%s", sel_widget->selection == y + scroll? selected_color: background_color);
|
|
r_cons_printf ("%-*.*s", sel_widget->w, sel_widget->w, option);
|
|
if (scrollbar && R_BETWEEN (scrollbar_y, y, scrollbar_y + scrollbar_l)) {
|
|
r_cons_write (Color_INVERT " "Color_INVERT_RESET, 10);
|
|
} else {
|
|
r_cons_write (" ", 1);
|
|
}
|
|
}
|
|
|
|
r_cons_gotoxy (pos_x + I.buffer.length, pos_y);
|
|
r_cons_write (Color_RESET_BG, 5);
|
|
r_cons_flush ();
|
|
}
|
|
|
|
static void selection_widget_up(int steps) {
|
|
RSelWidget *sel_widget = I.sel_widget;
|
|
if (sel_widget) {
|
|
if (sel_widget->direction == R_SELWIDGET_DIR_UP) {
|
|
int height = R_MIN (sel_widget->h, R_SELWIDGET_MAXH - 1);
|
|
sel_widget->selection = R_MIN (sel_widget->selection + steps, sel_widget->options_len - 1);
|
|
if (steps == 1) {
|
|
sel_widget->scroll = R_MIN (sel_widget->scroll + 1, R_SELWIDGET_MAXH - 1);
|
|
} else if (sel_widget->selection + (height - sel_widget->scroll) > sel_widget->options_len - 1) {
|
|
sel_widget->scroll = height - (sel_widget->options_len - 1 - sel_widget->selection);
|
|
}
|
|
} else {
|
|
sel_widget->selection = R_MAX (sel_widget->selection - steps, 0);
|
|
if (steps == 1) {
|
|
sel_widget->scroll = R_MAX (sel_widget->scroll - 1, 0);
|
|
} else if (sel_widget->selection - sel_widget->scroll <= 0) {
|
|
sel_widget->scroll = sel_widget->selection;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void selection_widget_down(int steps) {
|
|
RSelWidget *sel_widget = I.sel_widget;
|
|
if (sel_widget) {
|
|
if (sel_widget->direction == R_SELWIDGET_DIR_UP) {
|
|
sel_widget->selection = R_MAX (sel_widget->selection - steps, 0);
|
|
if (steps == 1) {
|
|
sel_widget->scroll = R_MAX (sel_widget->scroll - 1, 0);
|
|
} else if (sel_widget->selection - sel_widget->scroll <= 0) {
|
|
sel_widget->scroll = sel_widget->selection;
|
|
}
|
|
} else {
|
|
int height = R_MIN (sel_widget->h, R_SELWIDGET_MAXH - 1);
|
|
sel_widget->selection = R_MIN (sel_widget->selection + steps, sel_widget->options_len - 1);
|
|
if (steps == 1) {
|
|
sel_widget->scroll = R_MIN (sel_widget->scroll + 1, R_SELWIDGET_MAXH - 1);
|
|
} else if (sel_widget->selection + (height - sel_widget->scroll) > sel_widget->options_len - 1) {
|
|
sel_widget->scroll = height - (sel_widget->options_len - 1 - sel_widget->selection);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void print_rline_task(void *_core) {
|
|
r_cons_clear_line (0);
|
|
r_cons_printf ("%s%s%s", Color_RESET, I.prompt, I.buffer.data);
|
|
r_cons_flush ();
|
|
}
|
|
|
|
static void selection_widget_erase(void) {
|
|
RSelWidget *sel_widget = I.sel_widget;
|
|
if (sel_widget) {
|
|
sel_widget->options_len = 0;
|
|
sel_widget->selection = -1;
|
|
selection_widget_draw ();
|
|
R_FREE (I.sel_widget);
|
|
RCons *cons = r_cons_singleton ();
|
|
if (cons->event_resize && cons->event_data) {
|
|
cons->event_resize (cons->event_data);
|
|
RCore *core = (RCore *) (cons->user);
|
|
if (core) {
|
|
cons->cb_task_oneshot (&core->tasks, print_rline_task, core);
|
|
}
|
|
}
|
|
printf ("%s", R_CONS_CLEAR_FROM_CURSOR_TO_END);
|
|
}
|
|
}
|
|
|
|
static void selection_widget_select(void) {
|
|
RSelWidget *sel_widget = I.sel_widget;
|
|
if (sel_widget && sel_widget->selection < sel_widget->options_len) {
|
|
char *sp = strchr (I.buffer.data, ' ');
|
|
if (sp) {
|
|
int delta = sp - I.buffer.data + 1;
|
|
I.buffer.length = R_MIN (delta + strlen (sel_widget->options[sel_widget->selection]), R_LINE_BUFSIZE - 1);
|
|
memcpy (I.buffer.data + delta, sel_widget->options[sel_widget->selection], strlen (sel_widget->options[sel_widget->selection]));
|
|
I.buffer.index = I.buffer.length;
|
|
return;
|
|
}
|
|
I.buffer.length = R_MIN (strlen (sel_widget->options[sel_widget->selection]), R_LINE_BUFSIZE - 1);
|
|
memcpy (I.buffer.data, sel_widget->options[sel_widget->selection], I.buffer.length);
|
|
I.buffer.data[I.buffer.length] = '\0';
|
|
I.buffer.index = I.buffer.length;
|
|
selection_widget_erase ();
|
|
}
|
|
}
|
|
|
|
static void selection_widget_update(void) {
|
|
int argc = r_pvector_length (&I.completion.args);
|
|
const char **argv = (const char **) r_pvector_data (&I.completion.args);
|
|
if (argc == 0 || (argc == 1 && I.buffer.length >= strlen (argv[0]))) {
|
|
selection_widget_erase ();
|
|
return;
|
|
}
|
|
if (!I.sel_widget) {
|
|
RSelWidget *sel_widget = R_NEW0 (RSelWidget);
|
|
I.sel_widget = sel_widget;
|
|
}
|
|
I.sel_widget->scroll = 0;
|
|
I.sel_widget->selection = 0;
|
|
I.sel_widget->options_len = argc;
|
|
I.sel_widget->options = argv;
|
|
I.sel_widget->h = R_MAX (I.sel_widget->h, I.sel_widget->options_len);
|
|
|
|
if (I.prompt_type == R_LINE_PROMPT_DEFAULT) {
|
|
I.sel_widget->direction = R_SELWIDGET_DIR_DOWN;
|
|
} else {
|
|
I.sel_widget->direction = R_SELWIDGET_DIR_UP;
|
|
}
|
|
selection_widget_draw ();
|
|
r_cons_flush ();
|
|
return;
|
|
}
|
|
|
|
R_API void r_line_autocomplete(void) {
|
|
char *p;
|
|
const char **argv = NULL;
|
|
int argc = 0, i, j, plen, len = 0;
|
|
bool opt = false;
|
|
int cols = (int) (r_cons_get_size (NULL) * 0.82);
|
|
RCons *cons = r_cons_singleton ();
|
|
|
|
/* prepare argc and argv */
|
|
if (I.completion.run) {
|
|
I.completion.opt = false;
|
|
I.completion.run (&I.completion, &I.buffer, I.prompt_type, I.completion.run_user);
|
|
argc = r_pvector_length (&I.completion.args);
|
|
argv = (const char **) r_pvector_data (&I.completion.args);
|
|
opt = I.completion.opt;
|
|
}
|
|
if (I.sel_widget && !I.sel_widget->complete_common) {
|
|
selection_widget_update ();
|
|
return;
|
|
}
|
|
|
|
if (opt) {
|
|
p = (char *) r_sub_str_lchr (I.buffer.data, 0, I.buffer.index, '=');
|
|
} else {
|
|
p = (char *) r_sub_str_lchr (I.buffer.data, 0, I.buffer.index, ' ');
|
|
}
|
|
if (!p) {
|
|
p = (char *) r_sub_str_lchr (I.buffer.data, 0, I.buffer.index, '@'); // HACK FOR r2
|
|
}
|
|
if (p) {
|
|
p++;
|
|
plen = sizeof (I.buffer.data) - (int) (size_t) (p - I.buffer.data);
|
|
} else {
|
|
p = I.buffer.data; // XXX: removes current buffer
|
|
plen = sizeof (I.buffer.data);
|
|
}
|
|
/* autocomplete */
|
|
if (argc == 1) {
|
|
const char *end_word = r_sub_str_rchr (I.buffer.data,
|
|
I.buffer.index, strlen (I.buffer.data), ' ');
|
|
const char *t = end_word?
|
|
end_word: I.buffer.data + I.buffer.index;
|
|
int largv0 = strlen (r_str_get (argv[0]));
|
|
size_t len_t = strlen (t);
|
|
p[largv0] = '\0';
|
|
|
|
if ((p - I.buffer.data) + largv0 + 1 + len_t < plen) {
|
|
if (len_t > 0) {
|
|
int tt = largv0;
|
|
if (*t != ' ') {
|
|
p[tt++] = ' ';
|
|
}
|
|
memmove (p + tt, t, len_t);
|
|
}
|
|
memcpy (p, argv[0], largv0);
|
|
|
|
if (p[largv0 - 1] != R_SYS_DIR[0]) {
|
|
p[largv0] = ' ';
|
|
if (!len_t) {
|
|
p[largv0 + 1] = '\0';
|
|
}
|
|
}
|
|
I.buffer.length = strlen (I.buffer.data);
|
|
I.buffer.index = I.buffer.length;
|
|
}
|
|
} else if (argc > 0) {
|
|
if (*p) {
|
|
// TODO: avoid overflow
|
|
const char *t = I.buffer.data + I.buffer.index;
|
|
const char *root = argv[0];
|
|
int min_common_len = strlen (root);
|
|
size_t len_t = strlen (t);
|
|
|
|
// try to autocomplete argument
|
|
for (i = 0; i < argc; i++) {
|
|
j = 0;
|
|
if (!argv[i]) {
|
|
break;
|
|
}
|
|
while (argv[i][j] == root[j] && root[j] != '\0') j++;
|
|
if (j < min_common_len) {
|
|
min_common_len = j;
|
|
}
|
|
root = argv[i];
|
|
}
|
|
if (len_t > 0) {
|
|
int tt = min_common_len;
|
|
memmove (p + tt, t, len_t);
|
|
p[tt + len_t] = '\0';
|
|
}
|
|
memmove (p, root, min_common_len);
|
|
if (!len_t) {
|
|
p[min_common_len] = '\0';
|
|
}
|
|
I.buffer.length = strlen (I.buffer.data);
|
|
I.buffer.index = (p - I.buffer.data) + min_common_len;
|
|
}
|
|
}
|
|
|
|
if (I.prompt_type != R_LINE_PROMPT_DEFAULT || cons->show_autocomplete_widget) {
|
|
selection_widget_update ();
|
|
if (I.sel_widget) {
|
|
I.sel_widget->complete_common = false;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* show options */
|
|
if (argc > 1 && I.echo) {
|
|
const int sep = 3;
|
|
int slen, col = 10;
|
|
#ifdef R2__WINDOWS__
|
|
r_cons_win_printf (false, "%s%s\n", I.prompt, I.buffer.data);
|
|
#else
|
|
printf ("%s%s\n", I.prompt, I.buffer.data);
|
|
#endif
|
|
for (i = 0; i < argc && argv[i]; i++) {
|
|
int l = strlen (argv[i]);
|
|
if (sep + l > col) {
|
|
col = sep + l;
|
|
}
|
|
if (col > (cols >> 1)) {
|
|
col = (cols >> 1);
|
|
break;
|
|
}
|
|
}
|
|
for (len = i = 0; i < argc && argv[i]; i++) {
|
|
if (len + col > cols) {
|
|
printf ("\n");
|
|
len = 0;
|
|
}
|
|
printf ("%-*s ", col - sep, argv[i]);
|
|
slen = strlen (argv[i]);
|
|
len += (slen > col)? (slen + sep): (col + sep);
|
|
}
|
|
printf ("\n");
|
|
}
|
|
fflush (stdout);
|
|
}
|
|
|
|
R_API const char *r_line_readline(void) {
|
|
return r_line_readline_cb (NULL, NULL);
|
|
}
|
|
|
|
static inline void rotate_kill_ring(void) {
|
|
if (enable_yank_pop) {
|
|
I.buffer.index -= strlen (r_list_get_n (I.kill_ring, I.kill_ring_ptr));
|
|
I.buffer.data[I.buffer.index] = 0;
|
|
I.kill_ring_ptr -= 1;
|
|
if (I.kill_ring_ptr < 0) {
|
|
I.kill_ring_ptr = I.kill_ring->length - 1;
|
|
}
|
|
I.clipboard = r_list_get_n (I.kill_ring, I.kill_ring_ptr);
|
|
paste ();
|
|
}
|
|
}
|
|
|
|
static inline void __delete_prev_char(void) {
|
|
if (I.buffer.index < I.buffer.length) {
|
|
if (I.buffer.index > 0) {
|
|
size_t len = r_str_utf8_charsize_prev (I.buffer.data + I.buffer.index, I.buffer.index);
|
|
I.buffer.index -= len;
|
|
memmove (I.buffer.data + I.buffer.index,
|
|
I.buffer.data + I.buffer.index + len,
|
|
strlen (I.buffer.data + I.buffer.index));
|
|
I.buffer.length -= len;
|
|
}
|
|
} else {
|
|
I.buffer.length -= r_str_utf8_charsize_last (I.buffer.data);
|
|
I.buffer.index = I.buffer.length;
|
|
if (I.buffer.length < 0) {
|
|
I.buffer.length = 0;
|
|
}
|
|
}
|
|
I.buffer.data[I.buffer.length] = '\0';
|
|
if (I.buffer.index < 0) {
|
|
I.buffer.index = 0;
|
|
}
|
|
}
|
|
|
|
static inline void delete_till_end(void) {
|
|
I.buffer.data[I.buffer.index] = '\0';
|
|
I.buffer.length = I.buffer.index;
|
|
I.buffer.index = I.buffer.index > 0? I.buffer.index - 1: 0;
|
|
}
|
|
|
|
static const char *promptcolor(void) {
|
|
if (I.demo) {
|
|
return r_cons_singleton ()->context->pal.prompt;
|
|
}
|
|
return Color_RESET;
|
|
}
|
|
|
|
static void __print_prompt(void) {
|
|
RCons *cons = r_cons_singleton ();
|
|
int columns = r_cons_get_size (NULL) - 2;
|
|
int len, i, cols = R_MAX (1, columns - r_str_ansi_len (I.prompt) - 2);
|
|
if (cons->line->prompt_type == R_LINE_PROMPT_OFFSET) {
|
|
r_cons_gotoxy (0, cons->rows);
|
|
r_cons_flush ();
|
|
}
|
|
printf ("%s", promptcolor ());
|
|
r_cons_clear_line (0);
|
|
if (cons->context->color_mode > 0) {
|
|
printf ("\r%s%s%s", Color_RESET, promptcolor (), I.prompt);
|
|
} else {
|
|
printf ("\r%s", I.prompt);
|
|
}
|
|
#if 1
|
|
if (I.buffer.length > 0) {
|
|
int maxlen = R_MIN (I.buffer.length, cols);
|
|
fwrite (I.buffer.data, maxlen, 1, stdout);
|
|
if (I.buffer.length > cols) {
|
|
fwrite (" >", 2, 1, stdout);
|
|
}
|
|
}
|
|
#endif
|
|
if (I.demo) {
|
|
// 15% cpu usage, but yeah its fancy demoscene. may be good to optimize
|
|
int pos = (count > 0)? count % strlen (I.prompt): 0;
|
|
char *a = strdup (I.prompt);
|
|
char *kb = (char *) r_str_ansi_chrn (a, pos);
|
|
char *kc = (char *) r_str_ansi_chrn (kb, 3);
|
|
char *b = r_str_ndup (kb, kc - kb);
|
|
char *c = strdup (kc);
|
|
char *rb = r_str_newf (Color_WHITE "%s%s", b, promptcolor ());
|
|
*kb = 0;
|
|
printf ("\r%s%s%s%s%s", promptcolor (), a, rb, c, Color_RESET);
|
|
free (a);
|
|
free (b);
|
|
free (rb);
|
|
free (c);
|
|
count++;
|
|
if (count > strlen (I.prompt)) {
|
|
count = 0;
|
|
}
|
|
} else {
|
|
printf ("\r%s%s%s", promptcolor (), I.prompt, promptcolor ());
|
|
}
|
|
if (I.buffer.index > cols) {
|
|
printf ("< ");
|
|
i = I.buffer.index - cols;
|
|
if (i > sizeof (I.buffer.data)) {
|
|
i = sizeof (I.buffer.data) - 1;
|
|
}
|
|
} else {
|
|
i = 0;
|
|
}
|
|
len = I.buffer.index - i;
|
|
if (len > 0 && (i + len) <= I.buffer.length) {
|
|
if (i < I.buffer.length) {
|
|
size_t slen = R_MIN (len, (I.buffer.length - i));
|
|
if (slen > 0 && i < sizeof (I.buffer.data)) {
|
|
fwrite (I.buffer.data + i, 1, slen, stdout);
|
|
}
|
|
}
|
|
}
|
|
fflush (stdout);
|
|
}
|
|
|
|
static inline void vi_delete_commands(int rep) {
|
|
char c, t, e;
|
|
int i;
|
|
c = r_cons_readchar ();
|
|
while (rep--) {
|
|
switch (c) {
|
|
case 'i':
|
|
t = r_cons_readchar ();
|
|
switch (t) {
|
|
case 'w':
|
|
delete_in_word (MINOR_BREAK);
|
|
break;
|
|
case 'W':
|
|
delete_in_word (MINOR_BREAK);
|
|
break;
|
|
case 'b':
|
|
t = '(';
|
|
e = ')';
|
|
i = delete_between (t, e);
|
|
if (i != -1) {
|
|
I.buffer.index = i;
|
|
}
|
|
break;
|
|
case '"':
|
|
e = '"';
|
|
i = delete_between (t, e);
|
|
if (i != -1) {
|
|
I.buffer.index = i;
|
|
}
|
|
break;
|
|
case '\'':
|
|
e = '\'';
|
|
i = delete_between (t, e);
|
|
if (i != -1) {
|
|
I.buffer.index = i;
|
|
}
|
|
break;
|
|
case '(':
|
|
e = ')';
|
|
i = delete_between (t, e);
|
|
if (i != -1) {
|
|
I.buffer.index = i;
|
|
}
|
|
break;
|
|
case '[':
|
|
e = ']';
|
|
i = delete_between (t, e);
|
|
if (i != -1) {
|
|
I.buffer.index = i;
|
|
}
|
|
break;
|
|
case '<':
|
|
e = '>';
|
|
i = delete_between (t, e);
|
|
if (i != -1) {
|
|
I.buffer.index = i;
|
|
}
|
|
break;
|
|
case '{':
|
|
e = '}';
|
|
i = delete_between (t, e);
|
|
if (i != -1) {
|
|
I.buffer.index = i;
|
|
}
|
|
break;
|
|
}
|
|
if (I.hud) {
|
|
I.hud->vi = false;
|
|
}
|
|
break;
|
|
case 'f':
|
|
t = r_cons_readchar ();
|
|
i = vi_motion_seek_to_char (t);
|
|
if (i != I.buffer.index) {
|
|
shift_buffer (I.buffer.index, i + 1);
|
|
}
|
|
break;
|
|
case 'F':
|
|
t = r_cons_readchar ();
|
|
i = vi_motion_seek_to_char_backward (t);
|
|
if (i != I.buffer.index) {
|
|
shift_buffer (i, I.buffer.index);
|
|
I.buffer.index = i;
|
|
}
|
|
break;
|
|
case 't':
|
|
t = r_cons_readchar ();
|
|
i = vi_motion_seek_to_char (t);
|
|
if (i != I.buffer.index) {
|
|
shift_buffer (I.buffer.index, i);
|
|
}
|
|
break;
|
|
case 'T':
|
|
t = r_cons_readchar ();
|
|
i = vi_motion_seek_to_char_backward (t);
|
|
if (i != I.buffer.index) {
|
|
if (i < I.buffer.length) {
|
|
i++;
|
|
}
|
|
shift_buffer (i, I.buffer.index);
|
|
I.buffer.index = i;
|
|
}
|
|
break;
|
|
case 'E':
|
|
kill_word (MAJOR_BREAK, 'e');
|
|
break;
|
|
case 'e':
|
|
kill_word (MINOR_BREAK, 'e');
|
|
break;
|
|
case 'W':
|
|
kill_word (MAJOR_BREAK, 'w');
|
|
break;
|
|
case 'w':
|
|
kill_word (MINOR_BREAK, 'w');
|
|
break;
|
|
case 'B':
|
|
backward_kill_word (MAJOR_BREAK);
|
|
break;
|
|
case 'b':
|
|
backward_kill_word (MINOR_BREAK);
|
|
break;
|
|
case 'h':
|
|
__delete_prev_char ();
|
|
break;
|
|
case 'l':
|
|
__delete_current_char ();
|
|
break;
|
|
case '$':
|
|
delete_till_end ();
|
|
break;
|
|
case '^':
|
|
case '0':
|
|
strncpy (I.buffer.data, I.buffer.data + I.buffer.index, I.buffer.length);
|
|
I.buffer.length -= I.buffer.index;
|
|
I.buffer.index = 0;
|
|
break;
|
|
case 'c':
|
|
case 'd':
|
|
I.buffer.index = 0;
|
|
delete_till_end ();
|
|
break;
|
|
}
|
|
__print_prompt ();
|
|
} // end of while (rep--)
|
|
}
|
|
|
|
static inline void __move_cursor_right(void) {
|
|
I.buffer.index = I.buffer.index < I.buffer.length
|
|
? I.buffer.index + r_str_utf8_charsize (I.buffer.data + I.buffer.index)
|
|
: I.buffer.length;
|
|
}
|
|
|
|
static inline void __move_cursor_left(void) {
|
|
I.buffer.index = I.buffer.index
|
|
? I.buffer.index - r_str_utf8_charsize_prev (I.buffer.data + I.buffer.index, I.buffer.index)
|
|
: 0;
|
|
}
|
|
|
|
static void __update_prompt_color(void) {
|
|
RCons *cons = r_cons_singleton ();
|
|
const char *BEGIN = "", *END = Color_RESET;
|
|
if (cons->context->color_mode) {
|
|
if (I.prompt_mode) {
|
|
switch (I.vi_mode) {
|
|
case CONTROL_MODE:
|
|
BEGIN = cons->context->pal.invalid;
|
|
break;
|
|
case INSERT_MODE:
|
|
default:
|
|
BEGIN = cons->context->pal.prompt;
|
|
break;
|
|
}
|
|
} else {
|
|
BEGIN = cons->context->pal.prompt;
|
|
}
|
|
// END = cons->context->pal.reset;
|
|
}
|
|
char *prompt = r_str_escape (I.prompt); // remove the color
|
|
free (I.prompt);
|
|
I.prompt = r_str_newf ("%s%s%s", BEGIN, prompt, END);
|
|
}
|
|
|
|
static bool __vi_mode(void) {
|
|
char ch;
|
|
I.vi_mode = CONTROL_MODE;
|
|
__update_prompt_color ();
|
|
const char *gcomp_line = "";
|
|
static R_TH_LOCAL int gcomp = 0;
|
|
/* mimic vim's behaviour when entering normal mode */
|
|
__move_cursor_left ();
|
|
for (;;) {
|
|
int rep = 0;
|
|
if (I.echo) {
|
|
__print_prompt ();
|
|
}
|
|
if (I.vi_mode != CONTROL_MODE) {// exit if insert mode is selected
|
|
__update_prompt_color ();
|
|
break;
|
|
}
|
|
bool o_do_setup_match = I.history.do_setup_match;
|
|
I.history.do_setup_match = true;
|
|
ch = r_cons_readchar ();
|
|
while (IS_DIGIT (ch)) { // handle commands like 3b
|
|
if (ch == '0' && rep == 0) { // to handle the command 0
|
|
break;
|
|
}
|
|
int tmp = ch - '0';
|
|
rep = (rep * 10) + tmp;
|
|
ch = r_cons_readchar ();
|
|
}
|
|
rep = rep > 0? rep: 1;
|
|
|
|
switch (ch) {
|
|
case 3:
|
|
if (I.hud) {
|
|
I.hud->activate = false;
|
|
I.hud->current_entry_n = -1;
|
|
}
|
|
if (I.echo) {
|
|
eprintf ("^C\n");
|
|
}
|
|
I.buffer.index = I.buffer.length = 0;
|
|
*I.buffer.data = '\0';
|
|
gcomp = 0;
|
|
return false;
|
|
case 'C':
|
|
delete_till_end ();
|
|
I.buffer.index++;
|
|
if (I.hud) {
|
|
I.hud->vi = false;
|
|
}
|
|
I.vi_mode = INSERT_MODE;
|
|
break;
|
|
case 'D':
|
|
delete_till_end ();
|
|
break;
|
|
case 'r':
|
|
ch = r_cons_readchar ();
|
|
I.buffer.data[I.buffer.index] = ch;
|
|
break;
|
|
case 'x':
|
|
while (rep--) {
|
|
__delete_current_char ();
|
|
}
|
|
break;
|
|
case 'c':
|
|
if (I.hud) {
|
|
I.hud->vi = false;
|
|
}
|
|
I.vi_mode = INSERT_MODE;
|
|
/* fall through */
|
|
case 'd':
|
|
vi_delete_commands (rep);
|
|
break;
|
|
case 'I':
|
|
if (I.hud) {
|
|
I.hud->vi = false;
|
|
}
|
|
I.vi_mode = INSERT_MODE;
|
|
/* fall through */
|
|
case '^':
|
|
case '0':
|
|
if (gcomp) {
|
|
strcpy (I.buffer.data, gcomp_line);
|
|
I.buffer.length = strlen (I.buffer.data);
|
|
I.buffer.index = 0;
|
|
gcomp = false;
|
|
}
|
|
I.buffer.index = 0;
|
|
break;
|
|
case 'A':
|
|
if (gcomp) {
|
|
strcpy (I.buffer.data, gcomp_line);
|
|
I.buffer.index = strlen (I.buffer.data);
|
|
I.buffer.length = I.buffer.index;
|
|
gcomp = false;
|
|
} else {
|
|
I.buffer.index = I.buffer.length;
|
|
}
|
|
if (I.hud) {
|
|
I.hud->vi = false;
|
|
}
|
|
I.vi_mode = INSERT_MODE;
|
|
break;
|
|
case '$':
|
|
if (gcomp) {
|
|
strcpy (I.buffer.data, gcomp_line);
|
|
I.buffer.index = strlen (I.buffer.data);
|
|
I.buffer.length = I.buffer.index;
|
|
gcomp = false;
|
|
} else {
|
|
I.buffer.index = I.buffer.length - 1;
|
|
}
|
|
break;
|
|
case 'p':
|
|
while (rep--) {
|
|
paste ();
|
|
}
|
|
break;
|
|
case 'a':
|
|
I.buffer.index = I.buffer.index < I.buffer.length
|
|
? I.buffer.index + r_str_utf8_charsize (I.buffer.data + I.buffer.index)
|
|
: I.buffer.length;
|
|
/* fall through */
|
|
case 'i':
|
|
if (I.hud) {
|
|
I.hud->vi = false;
|
|
}
|
|
I.vi_mode = INSERT_MODE;
|
|
break;
|
|
case 'h':
|
|
while (rep--) {
|
|
__move_cursor_left ();
|
|
}
|
|
break;
|
|
case 'l':
|
|
while (rep--) {
|
|
__move_cursor_right ();
|
|
}
|
|
break;
|
|
case 'E':
|
|
while (rep--) {
|
|
I.buffer.index = vi_end_word_motion (MAJOR_BREAK);
|
|
}
|
|
break;
|
|
case 'e':
|
|
while (rep--) {
|
|
I.buffer.index = vi_end_word_motion (MINOR_BREAK);
|
|
}
|
|
break;
|
|
case 'B':
|
|
while (rep--) {
|
|
I.buffer.index = vi_backward_word_motion (MAJOR_BREAK);
|
|
}
|
|
break;
|
|
case 'b':
|
|
while (rep--) {
|
|
I.buffer.index = vi_backward_word_motion (MINOR_BREAK);
|
|
}
|
|
break;
|
|
case 'W':
|
|
while (rep--) {
|
|
I.buffer.index = vi_next_word_motion (MAJOR_BREAK);
|
|
if (I.buffer.index == I.buffer.length) {
|
|
I.buffer.index--;
|
|
}
|
|
}
|
|
break;
|
|
case 'w':
|
|
while (rep--) {
|
|
I.buffer.index = vi_next_word_motion (MINOR_BREAK);
|
|
if (I.buffer.index == I.buffer.length) {
|
|
I.buffer.index--;
|
|
}
|
|
}
|
|
break;
|
|
case '~':
|
|
while (rep--) {
|
|
swap_case (I.buffer.index);
|
|
__move_cursor_right ();
|
|
}
|
|
break;
|
|
case 'f':
|
|
ch = r_cons_readchar ();
|
|
while (rep--) {
|
|
I.buffer.index = vi_motion_seek_to_char (ch);
|
|
}
|
|
break;
|
|
case 'F':
|
|
ch = r_cons_readchar ();
|
|
while (rep--) {
|
|
I.buffer.index = vi_motion_seek_to_char_backward (ch);
|
|
}
|
|
break;
|
|
case 't':
|
|
ch = r_cons_readchar ();
|
|
while (rep--) {
|
|
I.buffer.index = vi_motion_seek_to_char (ch);
|
|
if (I.buffer.index > 0) {
|
|
I.buffer.index--;
|
|
}
|
|
}
|
|
break;
|
|
case 'T':
|
|
ch = r_cons_readchar ();
|
|
while (rep--) {
|
|
I.buffer.index = vi_motion_seek_to_char_backward (ch);
|
|
if (I.buffer.index < I.buffer.length - 1) {
|
|
I.buffer.index++;
|
|
}
|
|
}
|
|
break;
|
|
case 13:
|
|
/* fall through */
|
|
case '\n':
|
|
return true;
|
|
default: // escape key
|
|
ch = tolower (r_cons_arrow_to_hjkl (ch));
|
|
switch (ch) {
|
|
case 'k': // up
|
|
I.history.do_setup_match = o_do_setup_match;
|
|
r_line_hist_up ();
|
|
break;
|
|
case 'j': // down
|
|
I.history.do_setup_match = o_do_setup_match;
|
|
r_line_hist_down ();
|
|
break;
|
|
case 'l': // right
|
|
__move_cursor_right ();
|
|
break;
|
|
case 'h': // left
|
|
__move_cursor_left ();
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (I.hud) {
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void dietline_print_risprompt(const char *gcomp_line) {
|
|
RCons *cons = r_cons_singleton ();
|
|
if (cons->context->color_mode && *gcomp_line && I.buffer.length > 0) {
|
|
printf ("\r (ri-search): ");
|
|
const char *line = gcomp_line;
|
|
while (line) {
|
|
char *m = strstr (line, I.buffer.data);
|
|
if (m) {
|
|
fwrite (line, m - line, 1, stdout);
|
|
printf (Color_INVERT);
|
|
fwrite (m, I.buffer.length, 1, stdout);
|
|
printf (Color_RESET);
|
|
line = m + I.buffer.length;
|
|
} else {
|
|
printf ("%s", line);
|
|
line = NULL;
|
|
}
|
|
}
|
|
printf ("\r");
|
|
} else {
|
|
printf ("\r(ri-search (%s)): %s\r", I.buffer.data, gcomp_line);
|
|
}
|
|
}
|
|
|
|
R_API const char *r_line_readline_cb(RLineReadCallback cb, void *user) {
|
|
int rows;
|
|
const char *gcomp_line = "";
|
|
static R_TH_LOCAL int gcomp_idx = 0;
|
|
static R_TH_LOCAL bool yank_flag = 0;
|
|
static R_TH_LOCAL int gcomp = 0;
|
|
signed char buf[10];
|
|
#if USE_UTF8
|
|
int utflen;
|
|
#endif
|
|
int ch = 0, key, i = 0; /* grep completion */
|
|
char *tmp_ed_cmd, prev = 0;
|
|
int prev_buflen = -1;
|
|
RCons *cons = r_cons_singleton ();
|
|
|
|
if (!I.hud || (I.hud && !I.hud->activate)) {
|
|
I.buffer.index = I.buffer.length = 0;
|
|
I.buffer.data[0] = '\0';
|
|
if (I.hud) {
|
|
I.hud->activate = true;
|
|
}
|
|
}
|
|
int mouse_status = cons->mouse;
|
|
if (I.hud && I.hud->vi) {
|
|
__vi_mode ();
|
|
goto _end;
|
|
}
|
|
if (I.contents) {
|
|
memmove (I.buffer.data, I.contents,
|
|
R_MIN (strlen (I.contents) + 1, R_LINE_BUFSIZE - 1));
|
|
I.buffer.data[R_LINE_BUFSIZE - 1] = '\0';
|
|
I.buffer.index = I.buffer.length = strlen (I.contents);
|
|
}
|
|
if (I.disable) {
|
|
if (!fgets (I.buffer.data, R_LINE_BUFSIZE, stdin)) {
|
|
return NULL;
|
|
}
|
|
return (*I.buffer.data)? I.buffer.data: "";
|
|
}
|
|
|
|
memset (&buf, 0, sizeof buf);
|
|
r_cons_set_raw (1);
|
|
|
|
if (I.echo) {
|
|
__print_prompt ();
|
|
}
|
|
r_cons_break_push (NULL, NULL);
|
|
r_cons_enable_mouse (I.hud);
|
|
for (;;) {
|
|
yank_flag = 0;
|
|
if (r_cons_is_breaked ()) {
|
|
break;
|
|
}
|
|
#if 0
|
|
// detect truncation
|
|
if (I.buffer.length > I.length) {
|
|
I.buffer.data[0] = 0;
|
|
I.buffer.length = 0;
|
|
return NULL;
|
|
}
|
|
#endif
|
|
I.buffer.data[I.buffer.length] = '\0';
|
|
if (cb) {
|
|
int cbret = cb (user, I.buffer.data);
|
|
if (cbret == 0) {
|
|
I.buffer.data[0] = 0;
|
|
I.buffer.length = 0;
|
|
}
|
|
}
|
|
#if USE_UTF8
|
|
utflen = r_line_readchar_utf8 ((ut8 *) buf, sizeof (buf));
|
|
if (utflen < (I.demo? 0: 1)) {
|
|
r_cons_break_pop ();
|
|
return NULL;
|
|
}
|
|
buf[utflen] = 0;
|
|
if (I.demo && utflen == 0) {
|
|
// refresh
|
|
__print_prompt ();
|
|
count++;
|
|
continue;
|
|
}
|
|
#else
|
|
#if R2__WINDOWS__
|
|
{
|
|
int len = r_line_readchar_win ((ut8 *) buf, sizeof (buf));
|
|
if (len < 1) {
|
|
r_cons_break_pop ();
|
|
return NULL;
|
|
}
|
|
buf[len] = 0;
|
|
}
|
|
#else
|
|
ch = r_cons_readchar ();
|
|
if (ch == -1) {
|
|
r_cons_break_pop ();
|
|
return NULL;
|
|
}
|
|
buf[0] = ch;
|
|
#endif
|
|
#endif
|
|
bool o_do_setup_match = I.history.do_setup_match;
|
|
I.history.do_setup_match = true;
|
|
if (I.echo && cons->context->color_mode) {
|
|
r_cons_clear_line (0);
|
|
}
|
|
(void) r_cons_get_size (&rows);
|
|
switch (*buf) {
|
|
case 0: // control-space
|
|
/* ignore atm */
|
|
break;
|
|
case 1: // ^A
|
|
if (gcomp) {
|
|
strcpy (I.buffer.data, gcomp_line);
|
|
I.buffer.length = strlen (I.buffer.data);
|
|
I.buffer.index = 0;
|
|
gcomp = false;
|
|
}
|
|
I.buffer.index = 0;
|
|
break;
|
|
case 2: // ^b // emacs left
|
|
__move_cursor_left ();
|
|
break;
|
|
case 5: // ^E
|
|
if (gcomp) {
|
|
strcpy (I.buffer.data, gcomp_line);
|
|
I.buffer.index = strlen (I.buffer.data);
|
|
I.buffer.length = I.buffer.index;
|
|
gcomp = false;
|
|
} else if (prev == 24) {// ^X = 0x18
|
|
I.buffer.data[I.buffer.length] = 0; // probably unnecessary
|
|
tmp_ed_cmd = I.cb_editor (I.user, I.buffer.data);
|
|
if (tmp_ed_cmd) {
|
|
/* copied from yank (case 25) */
|
|
I.buffer.length = strlen (tmp_ed_cmd);
|
|
if (I.buffer.length < R_LINE_BUFSIZE) {
|
|
I.buffer.index = I.buffer.length;
|
|
strncpy (I.buffer.data, tmp_ed_cmd, R_LINE_BUFSIZE - 1);
|
|
I.buffer.data[R_LINE_BUFSIZE - 1] = '\0';
|
|
} else {
|
|
I.buffer.length -= strlen (tmp_ed_cmd);
|
|
}
|
|
free (tmp_ed_cmd);
|
|
}
|
|
} else {
|
|
I.buffer.index = I.buffer.length;
|
|
}
|
|
break;
|
|
case 3: // ^C
|
|
if (I.hud) {
|
|
I.hud->activate = false;
|
|
I.hud->current_entry_n = -1;
|
|
}
|
|
if (I.echo) {
|
|
eprintf ("^C\n");
|
|
}
|
|
I.buffer.index = I.buffer.length = 0;
|
|
*I.buffer.data = '\0';
|
|
gcomp = 0;
|
|
goto _end;
|
|
case 4: // ^D
|
|
if (!I.buffer.data[0]) {/* eof */
|
|
if (I.echo) {
|
|
eprintf ("^D\n");
|
|
}
|
|
r_cons_set_raw (false);
|
|
r_cons_break_pop ();
|
|
return NULL;
|
|
}
|
|
if (I.buffer.index < I.buffer.length) {
|
|
__delete_current_char ();
|
|
}
|
|
break;
|
|
case 11:// ^K
|
|
I.buffer.data[I.buffer.index] = '\0';
|
|
I.buffer.length = I.buffer.index;
|
|
break;
|
|
case 6: // ^f // emacs right
|
|
__move_cursor_right ();
|
|
break;
|
|
case 12:// ^L -- clear screen
|
|
if (I.echo) {
|
|
eprintf ("\x1b[2J\x1b[0;0H");
|
|
}
|
|
fflush (stdout);
|
|
break;
|
|
case 18:// ^R -- autocompletion
|
|
if (gcomp) {
|
|
gcomp_idx++;
|
|
}
|
|
gcomp = 1;
|
|
break;
|
|
case 19:// ^S -- backspace
|
|
if (gcomp) {
|
|
gcomp--;
|
|
} else {
|
|
__move_cursor_left ();
|
|
}
|
|
break;
|
|
case 21:// ^U - cut
|
|
free (I.clipboard);
|
|
I.clipboard = strdup (I.buffer.data);
|
|
r_line_clipboard_push (I.clipboard);
|
|
I.buffer.data[0] = '\0';
|
|
I.buffer.length = 0;
|
|
I.buffer.index = 0;
|
|
break;
|
|
#if R2__WINDOWS__
|
|
case 22:// ^V - Paste from windows clipboard
|
|
{
|
|
HANDLE hClipBoard;
|
|
PTCHAR clipText;
|
|
if (OpenClipboard (NULL)) {
|
|
#if UNICODE
|
|
hClipBoard = GetClipboardData (CF_UNICODETEXT);
|
|
#else
|
|
hClipBoard = GetClipboardData (CF_TEXT);
|
|
#endif
|
|
if (hClipBoard) {
|
|
clipText = GlobalLock (hClipBoard);
|
|
if (clipText) {
|
|
char *txt = r_sys_conv_win_to_utf8 (clipText);
|
|
if (!txt) {
|
|
R_LOG_ERROR ("Failed to allocate memory");
|
|
break;
|
|
}
|
|
int len = strlen (txt);
|
|
I.buffer.length += len;
|
|
if (I.buffer.length < R_LINE_BUFSIZE) {
|
|
I.buffer.index = I.buffer.length;
|
|
strcat (I.buffer.data, txt);
|
|
} else {
|
|
I.buffer.length -= len;
|
|
}
|
|
free (txt);
|
|
}
|
|
GlobalUnlock (hClipBoard);
|
|
}
|
|
CloseClipboard ();
|
|
}
|
|
}
|
|
break;
|
|
#endif
|
|
case 23:// ^W ^w unix-word-rubout
|
|
unix_word_rubout ();
|
|
break;
|
|
case 24:// ^X
|
|
if (I.buffer.index > 0) {
|
|
strncpy (I.buffer.data, I.buffer.data + I.buffer.index, I.buffer.length);
|
|
I.buffer.length -= I.buffer.index;
|
|
I.buffer.index = 0;
|
|
}
|
|
break;
|
|
case 25:// ^Y - paste
|
|
paste ();
|
|
yank_flag = 1;
|
|
break;
|
|
case 29: // ^^ - rotate kill ring
|
|
rotate_kill_ring ();
|
|
yank_flag = enable_yank_pop? 1: 0;
|
|
break;
|
|
case 20: // ^t Kill from point to the end of the current word,
|
|
kill_word (MINOR_BREAK, 'w');
|
|
break;
|
|
case 15:// ^o kill backward
|
|
backward_kill_word (MINOR_BREAK);
|
|
break;
|
|
case 14:// ^n
|
|
if (I.hud) {
|
|
if (I.hud->top_entry_n + 1 < I.hud->current_entry_n) {
|
|
I.hud->top_entry_n++;
|
|
}
|
|
} else if (I.sel_widget) {
|
|
selection_widget_down (1);
|
|
selection_widget_draw ();
|
|
} else if (gcomp) {
|
|
if (gcomp_idx > 0) {
|
|
gcomp_idx--;
|
|
}
|
|
} else {
|
|
I.history.do_setup_match = o_do_setup_match;
|
|
r_line_hist_down ();
|
|
}
|
|
break;
|
|
case 16:// ^p
|
|
if (I.hud) {
|
|
if (I.hud->top_entry_n >= 0) {
|
|
I.hud->top_entry_n--;
|
|
}
|
|
} else if (I.sel_widget) {
|
|
selection_widget_up (1);
|
|
selection_widget_draw ();
|
|
} else if (gcomp) {
|
|
gcomp_idx++;
|
|
} else {
|
|
I.history.do_setup_match = o_do_setup_match;
|
|
r_line_hist_up ();
|
|
}
|
|
break;
|
|
case 27:// esc-5b-41-00-00 alt/meta key
|
|
#if R2__WINDOWS__
|
|
// always skip escape
|
|
memmove (buf, buf + 1, strlen ((char *) buf));
|
|
#if 0
|
|
if (I.vtmode != 2) {
|
|
if (buf[1] == '[') {
|
|
memmove (buf, buf + 2, strlen (buf));
|
|
} else {
|
|
memmove (buf, buf + 1, strlen (buf));
|
|
}
|
|
if (!buf[0]) {
|
|
buf[0] = -1;
|
|
}
|
|
} else {
|
|
buf[0] = r_cons_readchar_timeout (50);
|
|
}
|
|
#endif
|
|
#else
|
|
buf[0] = r_cons_readchar_timeout (50);
|
|
#endif
|
|
switch (buf[0]) {
|
|
case 127: // alt+bkspace
|
|
backward_kill_word (MINOR_BREAK);
|
|
break;
|
|
case -1: // escape key, goto vi mode
|
|
if (I.enable_vi_mode) {
|
|
if (I.hud) {
|
|
I.hud->vi = true;
|
|
}
|
|
if (__vi_mode ()) {
|
|
goto _end;
|
|
}
|
|
}
|
|
;
|
|
if (I.sel_widget) {
|
|
selection_widget_erase ();
|
|
}
|
|
break;
|
|
case 1: // begin
|
|
I.buffer.index = 0;
|
|
break;
|
|
case 5: // end
|
|
I.buffer.index = I.buffer.length;
|
|
break;
|
|
case 'B':
|
|
case 'b':
|
|
for (i = I.buffer.index - 2; i >= 0; i--) {
|
|
if (is_word_break_char (I.buffer.data[i], MINOR_BREAK)
|
|
&& !is_word_break_char (I.buffer.data[i + 1], MINOR_BREAK)) {
|
|
I.buffer.index = i + 1;
|
|
break;
|
|
}
|
|
}
|
|
if (i < 0) {
|
|
I.buffer.index = 0;
|
|
}
|
|
break;
|
|
case 'D':
|
|
case 'd':
|
|
kill_word (MINOR_BREAK, 'w');
|
|
break;
|
|
case 'F':
|
|
case 'f':
|
|
// next word
|
|
for (i = I.buffer.index + 1; i < I.buffer.length; i++) {
|
|
if (!is_word_break_char (I.buffer.data[i], MINOR_BREAK)
|
|
&& is_word_break_char (I.buffer.data[i - 1], MINOR_BREAK)) {
|
|
I.buffer.index = i;
|
|
break;
|
|
}
|
|
}
|
|
if (i >= I.buffer.length) {
|
|
I.buffer.index = I.buffer.length;
|
|
}
|
|
break;
|
|
default:
|
|
#if !R2__WINDOWS__
|
|
if (I.vtmode == 2) {
|
|
buf[1] = r_cons_readchar_timeout (50);
|
|
if (buf[1] == -1) { // alt+e
|
|
r_cons_break_pop ();
|
|
__print_prompt ();
|
|
continue;
|
|
}
|
|
} else {
|
|
buf[1] = r_cons_readchar_timeout (50);
|
|
}
|
|
#endif
|
|
if (buf[0] == 'O' && strchr("ABCDFH", buf[1]) != NULL) { // O
|
|
buf[0] = '[';
|
|
}
|
|
if (buf[0] == '[') { // [
|
|
switch (buf[1]) {
|
|
case '3': // supr or mouse click
|
|
__delete_current_char ();
|
|
if (I.vtmode == 2) {
|
|
buf[1] = r_cons_readchar ();
|
|
if (buf[1] == 126) {
|
|
// handle SUPR key
|
|
r_cons_break_pop ();
|
|
__print_prompt ();
|
|
continue;
|
|
}
|
|
if (buf[1] == -1) {
|
|
r_cons_break_pop ();
|
|
return NULL;
|
|
}
|
|
}
|
|
for (;;) {
|
|
ch = r_cons_readchar ();
|
|
if (ch < 20) {
|
|
r_cons_break_pop ();
|
|
return NULL;
|
|
}
|
|
if (isupper (ch)) { // read until 'M'
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case '5': // pag up
|
|
if (I.vtmode == 2) {
|
|
buf[1] = r_cons_readchar ();
|
|
}
|
|
if (I.hud) {
|
|
I.hud->top_entry_n -= (rows - 1);
|
|
if (I.hud->top_entry_n < 0) {
|
|
I.hud->top_entry_n = 0;
|
|
}
|
|
}
|
|
if (I.sel_widget) {
|
|
selection_widget_up (R_MIN (I.sel_widget->h, R_SELWIDGET_MAXH));
|
|
selection_widget_draw ();
|
|
}
|
|
break;
|
|
case '6': // pag down
|
|
if (I.vtmode == 2) {
|
|
buf[1] = r_cons_readchar ();
|
|
}
|
|
if (I.hud) {
|
|
I.hud->top_entry_n += (rows - 1);
|
|
if (I.hud->top_entry_n >= I.hud->current_entry_n) {
|
|
I.hud->top_entry_n = I.hud->current_entry_n - 1;
|
|
}
|
|
}
|
|
if (I.sel_widget) {
|
|
selection_widget_down (R_MIN (I.sel_widget->h, R_SELWIDGET_MAXH));
|
|
selection_widget_draw ();
|
|
}
|
|
break;
|
|
case '9': // handle mouse wheel
|
|
key = r_cons_readchar ();
|
|
cons->mouse_event = 1;
|
|
if (key == '6') { // up
|
|
if (I.hud && I.hud->top_entry_n + 1 < I.hud->current_entry_n) {
|
|
I.hud->top_entry_n--;
|
|
}
|
|
} else if (key == '7') { // down
|
|
if (I.hud && I.hud->top_entry_n >= 0) {
|
|
I.hud->top_entry_n++;
|
|
}
|
|
}
|
|
while (r_cons_readchar () != 'M') {}
|
|
break;
|
|
/* arrows */
|
|
case 'A': // up arrow
|
|
if (I.hud) {
|
|
if (I.hud->top_entry_n > 0) {
|
|
I.hud->top_entry_n--;
|
|
}
|
|
} else if (I.sel_widget) {
|
|
selection_widget_up (1);
|
|
selection_widget_draw ();
|
|
} else if (gcomp) {
|
|
gcomp_idx++;
|
|
} else {
|
|
I.history.do_setup_match = o_do_setup_match;
|
|
if (r_line_hist_up () == -1) {
|
|
r_cons_break_pop ();
|
|
return NULL;
|
|
}
|
|
}
|
|
break;
|
|
case 'B': // down arrow
|
|
if (I.hud) {
|
|
if (I.hud->top_entry_n + 1 < I.hud->current_entry_n) {
|
|
I.hud->top_entry_n++;
|
|
}
|
|
} else if (I.sel_widget) {
|
|
selection_widget_down (1);
|
|
selection_widget_draw ();
|
|
} else if (gcomp) {
|
|
if (gcomp_idx > 0) {
|
|
gcomp_idx--;
|
|
}
|
|
} else {
|
|
I.history.do_setup_match = o_do_setup_match;
|
|
if (r_line_hist_down () == -1) {
|
|
r_cons_break_pop ();
|
|
return NULL;
|
|
}
|
|
}
|
|
break;
|
|
case 'C': // right arrow
|
|
__move_cursor_right ();
|
|
break;
|
|
case 'D': // left arrow
|
|
__move_cursor_left ();
|
|
break;
|
|
case 0x31: // control + arrow
|
|
if (I.vtmode == 2) {
|
|
ch = r_cons_readchar ();
|
|
if (ch == 0x7e) { // HOME in screen/tmux
|
|
// corresponding END is 0x34 below (the 0x7e is ignored there)
|
|
I.buffer.index = 0;
|
|
break;
|
|
}
|
|
r_cons_readchar (); // should be '5'
|
|
ch = r_cons_readchar ();
|
|
}
|
|
#if R2__WINDOWS__
|
|
else {
|
|
ch = buf[2];
|
|
}
|
|
#endif
|
|
int fkey = ch - '0';
|
|
switch (ch) {
|
|
case 0x41:
|
|
// first
|
|
I.buffer.index = 0;
|
|
break;
|
|
case 0x44:
|
|
// previous word
|
|
i = I.buffer.index;
|
|
do {
|
|
i--;
|
|
} while (i > 0 && I.buffer.data[i - 1] != ' ');
|
|
I.buffer.index = i;
|
|
break;
|
|
case 0x42:
|
|
// end
|
|
I.buffer.index = I.buffer.length;
|
|
break;
|
|
case 0x43:
|
|
// next word
|
|
for (i = I.buffer.index; i < I.buffer.length; i++) {
|
|
if (I.buffer.data[i] == ' ') {
|
|
I.buffer.index = i + 1;
|
|
break;
|
|
}
|
|
}
|
|
if (I.buffer.data[i] != ' ') {
|
|
I.buffer.index = I.buffer.length;
|
|
}
|
|
break;
|
|
default:
|
|
if (I.vtmode == 2) {
|
|
if (I.cb_fkey) {
|
|
I.cb_fkey (I.user, fkey);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
r_cons_set_raw (true);
|
|
break;
|
|
case 0x37: // HOME xrvt-unicode
|
|
r_cons_readchar ();
|
|
break;
|
|
case 0x48: // HOME
|
|
if (I.sel_widget) {
|
|
selection_widget_up (I.sel_widget->options_len - 1);
|
|
selection_widget_draw ();
|
|
break;
|
|
}
|
|
I.buffer.index = 0;
|
|
break;
|
|
case 0x34: // END
|
|
case 0x38: // END xrvt-unicode
|
|
r_cons_readchar ();
|
|
case 0x46: // END
|
|
if (I.sel_widget) {
|
|
selection_widget_down (I.sel_widget->options_len - 1);
|
|
selection_widget_draw ();
|
|
break;
|
|
}
|
|
I.buffer.index = I.buffer.length;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 8:
|
|
case 127:
|
|
if (I.hud && (I.buffer.index == 0)) {
|
|
I.hud->activate = false;
|
|
I.hud->current_entry_n = -1;
|
|
}
|
|
__delete_prev_char ();
|
|
break;
|
|
case 9: // TAB tab
|
|
if (I.buffer.length > 0 && I.buffer.data[I.buffer.length - 1] == '@') {
|
|
strcpy (I.buffer.data + I.buffer.length, " ");
|
|
I.buffer.length++;
|
|
I.buffer.index++;
|
|
}
|
|
if (I.sel_widget) {
|
|
selection_widget_down (1);
|
|
I.sel_widget->complete_common = true;
|
|
selection_widget_draw ();
|
|
}
|
|
if (I.hud) {
|
|
if (I.hud->top_entry_n + 1 < I.hud->current_entry_n) {
|
|
I.hud->top_entry_n++;
|
|
} else {
|
|
I.hud->top_entry_n = 0;
|
|
}
|
|
} else {
|
|
r_line_autocomplete ();
|
|
}
|
|
break;
|
|
case 10:// ^J
|
|
case 13:// enter
|
|
if (I.hud) {
|
|
I.hud->activate = false;
|
|
break;
|
|
}
|
|
if (I.sel_widget) {
|
|
selection_widget_select ();
|
|
break;
|
|
}
|
|
if (gcomp && I.buffer.length > 0) {
|
|
strncpy (I.buffer.data, gcomp_line, R_LINE_BUFSIZE - 1);
|
|
I.buffer.data[R_LINE_BUFSIZE - 1] = '\0';
|
|
I.buffer.length = strlen (gcomp_line);
|
|
}
|
|
gcomp_idx = gcomp = 0;
|
|
goto _end;
|
|
default:
|
|
if (gcomp) {
|
|
gcomp++;
|
|
}
|
|
{
|
|
#if USE_UTF8
|
|
int size = utflen;
|
|
#else
|
|
int size = 1;
|
|
#endif
|
|
if (I.buffer.length + size >= R_LINE_BUFSIZE) {
|
|
break;
|
|
}
|
|
}
|
|
if (I.buffer.index < I.buffer.length) {
|
|
#if USE_UTF8
|
|
if ((I.buffer.length + utflen) < sizeof (I.buffer.data)) {
|
|
I.buffer.length += utflen;
|
|
for (i = I.buffer.length; i > I.buffer.index; i--) {
|
|
I.buffer.data[i] = I.buffer.data[i - utflen];
|
|
}
|
|
memcpy (I.buffer.data + I.buffer.index, buf, utflen);
|
|
}
|
|
#else
|
|
for (i = ++I.buffer.length; i > I.buffer.index; i--) {
|
|
I.buffer.data[i] = I.buffer.data[i - 1];
|
|
}
|
|
I.buffer.data[I.buffer.index] = buf[0];
|
|
#endif
|
|
} else {
|
|
#if USE_UTF8
|
|
if ((I.buffer.length + utflen + 1) < sizeof (I.buffer.data)) {
|
|
memcpy (I.buffer.data + I.buffer.length, buf, utflen);
|
|
I.buffer.length += utflen;
|
|
}
|
|
I.buffer.data[I.buffer.length] = '\0';
|
|
#else
|
|
I.buffer.data[I.buffer.length] = buf[0];
|
|
I.buffer.length++;
|
|
if (I.buffer.length > (R_LINE_BUFSIZE - 1)) {
|
|
I.buffer.length--;
|
|
}
|
|
I.buffer.data[I.buffer.length] = '\0';
|
|
#endif
|
|
}
|
|
#if USE_UTF8
|
|
if ((I.buffer.index + utflen) <= I.buffer.length) {
|
|
I.buffer.index += utflen;
|
|
}
|
|
#else
|
|
if (I.buffer.index < I.buffer.length) {
|
|
I.buffer.index++;
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
if (I.sel_widget && I.buffer.length != prev_buflen) {
|
|
prev_buflen = I.buffer.length;
|
|
r_line_autocomplete ();
|
|
}
|
|
prev = buf[0];
|
|
if (I.echo) {
|
|
if (gcomp) {
|
|
gcomp_line = "";
|
|
int counter = 0;
|
|
if (I.history.data) {
|
|
for (i = I.history.size - 1; i >= 0; i--) {
|
|
if (!I.history.data[i]) {
|
|
continue;
|
|
}
|
|
if (strstr (I.history.data[i], I.buffer.data)) {
|
|
gcomp_line = I.history.data[i];
|
|
if (++counter > gcomp_idx) {
|
|
break;
|
|
}
|
|
}
|
|
if (i == 0) {
|
|
gcomp_idx--;
|
|
}
|
|
}
|
|
}
|
|
dietline_print_risprompt (gcomp_line);
|
|
} else {
|
|
__print_prompt ();
|
|
}
|
|
fflush (stdout);
|
|
}
|
|
enable_yank_pop = yank_flag? 1: 0;
|
|
if (I.hud) {
|
|
goto _end;
|
|
}
|
|
}
|
|
_end:
|
|
r_cons_break_pop ();
|
|
r_cons_set_raw (false);
|
|
r_cons_enable_mouse (mouse_status);
|
|
#if 0
|
|
if (I.buffer.length > 1024) { // R2_590 - use I.maxlength
|
|
I.buffer.data[0] = 0;
|
|
I.buffer.length = 0;
|
|
R_LOG_WARN ("Input is too large");
|
|
return I.buffer.data;
|
|
}
|
|
#endif
|
|
if (I.echo) {
|
|
printf ("\r%s%s%s%s\n", I.prompt, promptcolor (), I.buffer.data, Color_RESET);
|
|
fflush (stdout);
|
|
}
|
|
|
|
R_FREE (I.sel_widget);
|
|
|
|
// shouldnt be here
|
|
if (r_str_startswith (I.buffer.data, "!history")) {
|
|
#if R2_USE_NEW_ABI
|
|
r_line_hist_list (true);
|
|
#else
|
|
r_line_hist_list ();
|
|
#endif
|
|
return "";
|
|
}
|
|
return I.buffer.data[0] != '\0'? I.buffer.data: "";
|
|
}
|