*
* This code is 'as is' with no warranty.
*/
-
/*
* Usage and known bugs:
* Terminal key codes are not extensive, more needs to be added.
* Ctrl-E also works as End.
*
* The following readline-like commands are not implemented:
- * ESC-b -- Move back one word
- * ESC-f -- Move forward one word
- * ESC-d -- Delete forward one word
* CTL-t -- Transpose two characters
*
* lineedit does not know that the terminal escape sequences do not
* and the \] escape to signal the end of such a sequence. Example:
*
* PS1='\[\033[01;32m\]\u@\h\[\033[01;34m\] \w \$\[\033[00m\] '
+ *
+ * Unicode in PS1 is not fully supported: prompt length calulation is wrong,
+ * resulting in line wrap problems with long (multi-line) input.
*/
-#include "libbb.h"
+#include "busybox.h"
+#include "NUM_APPLETS.h"
#include "unicode.h"
+#ifndef _POSIX_VDISABLE
+# define _POSIX_VDISABLE '\0'
+#endif
+
#ifdef TEST
# define ENABLE_FEATURE_EDITING 0
#if ENABLE_UNICODE_SUPPORT
# define BB_NUL ((wchar_t)0)
# define CHAR_T wchar_t
-static bool BB_isspace(CHAR_T c) { return ((unsigned)c < 256 && isspace(c)); }
+static bool BB_isspace(CHAR_T c)
+{
+ return ((unsigned)c < 256 && isspace(c));
+}
# if ENABLE_FEATURE_EDITING_VI
-static bool BB_isalnum(CHAR_T c) { return ((unsigned)c < 256 && isalnum(c)); }
+static bool BB_isalnum_or_underscore(CHAR_T c)
+{
+ return ((unsigned)c < 256 && isalnum(c)) || c == '_';
+}
# endif
-static bool BB_ispunct(CHAR_T c) { return ((unsigned)c < 256 && ispunct(c)); }
+static bool BB_ispunct(CHAR_T c)
+{
+ return ((unsigned)c < 256 && ispunct(c));
+}
# undef isspace
# undef isalnum
# undef ispunct
# define BB_NUL '\0'
# define CHAR_T char
# define BB_isspace(c) isspace(c)
-# define BB_isalnum(c) isalnum(c)
+# if ENABLE_FEATURE_EDITING_VI
+static bool BB_isalnum_or_underscore(CHAR_T c)
+{
+ return isalnum(c) || c == '_';
+}
+# endif
# define BB_ispunct(c) ispunct(c)
#endif
#if ENABLE_UNICODE_PRESERVE_BROKEN
struct lineedit_statics {
line_input_t *state;
- volatile unsigned cmdedit_termw; /* = 80; */ /* actual terminal width */
- sighandler_t previous_SIGWINCH_handler;
+ unsigned cmdedit_termw; /* = 80; */ /* actual terminal width */
unsigned cmdedit_x; /* real x (col) terminal position */
unsigned cmdedit_y; /* pseudoreal y (row) terminal position */
- unsigned cmdedit_prmt_len; /* length of prompt (without colors etc) */
+ unsigned cmdedit_prmt_len; /* on-screen length of last/sole prompt line */
unsigned cursor;
int command_len; /* must be signed */
CHAR_T *command_ps;
const char *cmdedit_prompt;
-#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
- int num_ok_lines; /* = 1; */
-#endif
+ const char *prompt_last_line; /* last/sole prompt line */
#if ENABLE_USERNAME_OR_HOMEDIR
char *user_buf;
unsigned num_matches;
#endif
+#if ENABLE_FEATURE_EDITING_WINCH
+ unsigned SIGWINCH_saved;
+ volatile unsigned SIGWINCH_count;
+ volatile smallint ok_to_redraw;
+#endif
+
#if ENABLE_FEATURE_EDITING_VI
# define DELBUFSIZ 128
- CHAR_T *delptr;
smallint newdelflag; /* whether delbuf should be reused yet */
+ CHAR_T *delptr;
CHAR_T delbuf[DELBUFSIZ]; /* a place to store deleted characters */
#endif
#if ENABLE_FEATURE_EDITING_ASK_TERMINAL
smallint sent_ESC_br6n;
#endif
+
+#if ENABLE_FEATURE_EDITING_WINCH
+ /* Largish struct, keeping it last results in smaller code */
+ struct sigaction SIGWINCH_handler;
+#endif
};
/* See lineedit_ptr_hack.c */
#define S (*lineedit_ptr_to_statics)
#define state (S.state )
#define cmdedit_termw (S.cmdedit_termw )
-#define previous_SIGWINCH_handler (S.previous_SIGWINCH_handler)
#define cmdedit_x (S.cmdedit_x )
#define cmdedit_y (S.cmdedit_y )
#define cmdedit_prmt_len (S.cmdedit_prmt_len)
#define command_len (S.command_len )
#define command_ps (S.command_ps )
#define cmdedit_prompt (S.cmdedit_prompt )
-#define num_ok_lines (S.num_ok_lines )
+#define prompt_last_line (S.prompt_last_line)
#define user_buf (S.user_buf )
#define home_pwd_buf (S.home_pwd_buf )
#define matches (S.matches )
#define delbuf (S.delbuf )
#define INIT_S() do { \
- (*(struct lineedit_statics**)&lineedit_ptr_to_statics) = xzalloc(sizeof(S)); \
+ (*(struct lineedit_statics**)not_const_pp(&lineedit_ptr_to_statics)) = xzalloc(sizeof(S)); \
barrier(); \
cmdedit_termw = 80; \
- IF_FEATURE_EDITING_FANCY_PROMPT(num_ok_lines = 1;) \
IF_USERNAME_OR_HOMEDIR(home_pwd_buf = (char*)null_str;) \
+ IF_FEATURE_EDITING_VI(delptr = delbuf;) \
} while (0)
+
static void deinit_S(void)
{
#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
#if ENABLE_UNICODE_SUPPORT
-static size_t load_string(const char *src, int maxsize)
+static size_t load_string(const char *src)
{
if (unicode_status == UNICODE_ON) {
- ssize_t len = mbstowcs(command_ps, src, maxsize - 1);
+ ssize_t len = mbstowcs(command_ps, src, S.maxsize - 1);
if (len < 0)
len = 0;
command_ps[len] = BB_NUL;
return len;
} else {
unsigned i = 0;
- while ((command_ps[i] = src[i]) != 0)
+ while (src[i] && i < S.maxsize - 1) {
+ command_ps[i] = src[i];
i++;
+ }
+ command_ps[i] = BB_NUL;
return i;
}
}
return wc;
}
#else /* !UNICODE */
-static size_t load_string(const char *src, int maxsize)
+static size_t load_string(const char *src)
{
- safe_strncpy(command_ps, src, maxsize);
+ safe_strncpy(command_ps, src, S.maxsize);
return strlen(command_ps);
}
# if ENABLE_FEATURE_TAB_COMPLETION
static void goto_new_line(void)
{
put_till_end_and_adv_cursor();
- if (cmdedit_x != 0)
+ /* "cursor == 0" is only if prompt is "" and user input is empty */
+ if (cursor == 0 || cmdedit_x != 0)
bb_putchar('\n');
}
bb_putchar('\007');
}
-static void put_prompt(void)
+/* Full or last/sole prompt line, reset edit cursor, calculate terminal cursor.
+ * cmdedit_y is always calculated for the last/sole prompt line.
+ */
+static void put_prompt_custom(bool is_full)
{
- unsigned w;
-
- fputs(cmdedit_prompt, stdout);
- fflush_all();
+ fputs((is_full ? cmdedit_prompt : prompt_last_line), stdout);
cursor = 0;
- w = cmdedit_termw; /* read volatile var once */
- cmdedit_y = cmdedit_prmt_len / w; /* new quasireal y */
- cmdedit_x = cmdedit_prmt_len % w;
+ cmdedit_y = cmdedit_prmt_len / cmdedit_termw; /* new quasireal y */
+ cmdedit_x = cmdedit_prmt_len % cmdedit_termw;
}
+#define put_prompt_last_line() put_prompt_custom(0)
+#define put_prompt() put_prompt_custom(1)
+
/* Move back one character */
/* (optimized for slow terminals) */
static void input_backward(unsigned num)
printf("\r" ESC"[%uA", cmdedit_y);
cmdedit_y = 0;
sv_cursor = cursor;
- put_prompt(); /* sets cursor to 0 */
+ put_prompt_last_line(); /* sets cursor to 0 */
while (cursor < sv_cursor)
put_cur_glyph_and_inc_cursor();
} else {
int lines_up;
- unsigned width;
/* num = chars to go back from the beginning of current line: */
num -= cmdedit_x;
- width = cmdedit_termw; /* read volatile var once */
/* num=1...w: one line up, w+1...2w: two, etc: */
- lines_up = 1 + (num - 1) / width;
- cmdedit_x = (width * cmdedit_y - num) % width;
+ lines_up = 1 + (num - 1) / cmdedit_termw;
+ cmdedit_x = (cmdedit_termw * cmdedit_y - num) % cmdedit_termw;
cmdedit_y -= lines_up;
/* go to 1st column; go up */
printf("\r" ESC"[%uA", lines_up);
}
}
-/* draw prompt, editor line, and clear tail */
-static void redraw(int y, int back_cursor)
+/* See redraw and draw_full below */
+static void draw_custom(int y, int back_cursor, bool is_full)
{
if (y > 0) /* up y lines */
printf(ESC"[%uA", y);
bb_putchar('\r');
- put_prompt();
+ put_prompt_custom(is_full);
put_till_end_and_adv_cursor();
printf(SEQ_CLEAR_TILL_END_OF_SCREEN);
input_backward(back_cursor);
}
+/* Move y lines up, draw last/sole prompt line, editor line[s], and clear tail.
+ * goal: redraw the prompt+input+cursor in-place, overwriting the previous */
+#define redraw(y, back_cursor) draw_custom((y), (back_cursor), 0)
+
+/* Like above, but without moving up, and while using all the prompt lines.
+ * goal: draw a full prompt+input+cursor unrelated to a previous position.
+ * note: cmdedit_y always ends up relating to the last/sole prompt line */
+#define draw_full(back_cursor) draw_custom(0, (back_cursor), 1)
+
/* Delete the char in front of the cursor, optionally saving it
* for later putback */
#if !ENABLE_FEATURE_EDITING_VI
static void add_match(char *matched)
{
+ unsigned char *p = (unsigned char*)matched;
+ while (*p) {
+ /* ESC attack fix: drop any string with control chars */
+ if (*p < ' '
+ || (!ENABLE_UNICODE_SUPPORT && *p >= 0x7f)
+ || (ENABLE_UNICODE_SUPPORT && *p == 0x7f)
+ ) {
+ free(matched);
+ return;
+ }
+ p++;
+ }
matches = xrealloc_vector(matches, 4, num_matches);
matches[num_matches] = matched;
num_matches++;
*/
static NOINLINE unsigned complete_username(const char *ud)
{
- /* Using _r function to avoid pulling in static buffers */
- char line_buff[256];
- struct passwd pwd;
- struct passwd *result;
+ struct passwd *pw;
unsigned userlen;
ud++; /* skip ~ */
userlen = strlen(ud);
setpwent();
- while (!getpwent_r(&pwd, line_buff, sizeof(line_buff), &result)) {
+ while ((pw = getpwent()) != NULL) {
/* Null usernames should result in all users as possible completions. */
- if (/*!userlen || */ strncmp(ud, pwd.pw_name, userlen) == 0) {
- add_match(xasprintf("~%s/", pwd.pw_name));
+ if (/* !ud[0] || */ is_prefixed_with(pw->pw_name, ud)) {
+ add_match(xasprintf("~%s/", pw->pw_name));
}
}
- endpwent();
+ endpwent(); /* don't keep password file open */
return 1 + userlen;
}
}
pf_len = strlen(pfind);
+ if (type == FIND_EXE_ONLY && !dirbuf) {
+# if ENABLE_FEATURE_SH_STANDALONE && NUM_APPLETS != 1
+ const char *p = applet_names;
+ while (*p) {
+ if (strncmp(pfind, p, pf_len) == 0)
+ add_match(xstrdup(p));
+ while (*p++ != '\0')
+ continue;
+ }
+# endif
+# if EDITING_HAS_get_exe_name
+ if (state->get_exe_name) {
+ i = 0;
+ for (;;) {
+ const char *b = state->get_exe_name(i++);
+ if (!b)
+ break;
+ if (strncmp(pfind, b, pf_len) == 0)
+ add_match(xstrdup(b));
+ }
+ }
+# endif
+ }
+
for (i = 0; i < npaths; i++) {
DIR *dir;
struct dirent *next;
if (!pfind[0] && DOT_OR_DOTDOT(name_found))
continue;
/* match? */
- if (strncmp(name_found, pfind, pf_len) != 0)
+ if (!is_prefixed_with(name_found, pfind))
continue; /* no */
found = concat_path_file(paths[i], name_found);
);
}
if (ENABLE_UNICODE_SUPPORT)
- puts(printable_string(NULL, matches[n]));
+ puts(printable_string(matches[n]));
else
puts(matches[n]);
}
int sav_cursor = cursor;
goto_new_line();
showfiles();
- redraw(0, command_len - sav_cursor);
+ draw_full(command_len - sav_cursor);
}
return;
}
strcpy(match_buf, &command[cursor_mb]);
/* where do we want to have cursor after all? */
strcpy(&command[cursor_mb], chosen_match + match_pfx_len);
- len = load_string(command, S.maxsize);
+ len = load_string(command);
/* add match and tail */
sprintf(&command[cursor_mb], "%s%s", chosen_match + match_pfx_len, match_buf);
- command_len = load_string(command, S.maxsize);
+ command_len = load_string(command);
/* write out the matched command */
/* paranoia: load_string can return 0 on conv error,
* prevent passing pos = (0 - 12) to redraw */
{
line_input_t *n = xzalloc(sizeof(*n));
n->flags = flags;
+ n->timeout = -1;
+#if MAX_HISTORY > 0
+ n->max_history = MAX_HISTORY;
+#endif
return n;
}
#if MAX_HISTORY > 0
+unsigned FAST_FUNC size_from_HISTFILESIZE(const char *hp)
+{
+ int size = MAX_HISTORY;
+ if (hp) {
+ size = atoi(hp);
+ if (size <= 0)
+ return 1;
+ if (size > MAX_HISTORY)
+ return MAX_HISTORY;
+ }
+ return size;
+}
+
static void save_command_ps_at_cur_history(void)
{
if (command_ps[0] != BB_NUL) {
return 0;
}
+/* Lists command history. Used by shell 'history' builtins */
+void FAST_FUNC show_history(const line_input_t *st)
+{
+ int i;
+
+ if (!st)
+ return;
+ for (i = 0; i < st->cnt_history; i++)
+ printf("%4d %s\n", i, st->history[i]);
+}
+
+void FAST_FUNC free_line_input_t(line_input_t *n)
+{
+# if ENABLE_FEATURE_EDITING_SAVEHISTORY
+ int i = n->cnt_history;
+ while (i > 0)
+ free(n->history[--i]);
+#endif
+ free(n);
+}
+
# if ENABLE_FEATURE_EDITING_SAVEHISTORY
/* We try to ensure that concurrent additions to the history
* do not overwrite each other.
* than configured MAX_HISTORY lines.
*/
-static void free_line_input_t(line_input_t *n)
-{
- int i = n->cnt_history;
- while (i > 0)
- free(n->history[--i]);
- free(n);
-}
-
/* state->flags is already checked to be nonzero */
static void load_history(line_input_t *st_parm)
{
/* fill temp_h[], retaining only last MAX_HISTORY lines */
memset(temp_h, 0, sizeof(temp_h));
- st_parm->cnt_history_in_file = idx = 0;
+ idx = 0;
+ st_parm->cnt_history_in_file = 0;
while ((line = xmalloc_fgetline(fp)) != NULL) {
if (line[0] == '\0') {
free(line);
temp_h[idx] = line;
st_parm->cnt_history_in_file++;
idx++;
- if (idx == MAX_HISTORY)
+ if (idx == st_parm->max_history)
idx = 0;
}
fclose(fp);
if (st_parm->cnt_history_in_file) {
while (temp_h[idx] == NULL) {
idx++;
- if (idx == MAX_HISTORY)
+ if (idx == st_parm->max_history)
idx = 0;
}
}
/* copy temp_h[] to st_parm->history[] */
- for (i = 0; i < MAX_HISTORY;) {
+ for (i = 0; i < st_parm->max_history;) {
line = temp_h[idx];
if (!line)
break;
idx++;
- if (idx == MAX_HISTORY)
+ if (idx == st_parm->max_history)
idx = 0;
line_len = strlen(line);
if (line_len >= MAX_LINELEN)
st_parm->history[i++] = line;
}
st_parm->cnt_history = i;
+ if (ENABLE_FEATURE_EDITING_SAVE_ON_EXIT)
+ st_parm->cnt_history_in_file = i;
}
}
-/* state->flags is already checked to be nonzero */
+# if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
+void save_history(line_input_t *st)
+{
+ FILE *fp;
+
+ if (!st->hist_file)
+ return;
+ if (st->cnt_history <= st->cnt_history_in_file)
+ return;
+
+ fp = fopen(st->hist_file, "a");
+ if (fp) {
+ int i, fd;
+ char *new_name;
+ line_input_t *st_temp;
+
+ for (i = st->cnt_history_in_file; i < st->cnt_history; i++)
+ fprintf(fp, "%s\n", st->history[i]);
+ fclose(fp);
+
+ /* we may have concurrently written entries from others.
+ * load them */
+ st_temp = new_line_input_t(st->flags);
+ st_temp->hist_file = st->hist_file;
+ st_temp->max_history = st->max_history;
+ load_history(st_temp);
+
+ /* write out temp file and replace hist_file atomically */
+ new_name = xasprintf("%s.%u.new", st->hist_file, (int) getpid());
+ fd = open(new_name, O_WRONLY | O_CREAT | O_TRUNC, 0600);
+ if (fd >= 0) {
+ fp = xfdopen_for_write(fd);
+ for (i = 0; i < st_temp->cnt_history; i++)
+ fprintf(fp, "%s\n", st_temp->history[i]);
+ fclose(fp);
+ if (rename(new_name, st->hist_file) == 0)
+ st->cnt_history_in_file = st_temp->cnt_history;
+ }
+ free(new_name);
+ free_line_input_t(st_temp);
+ }
+}
+# else
static void save_history(char *str)
{
int fd;
int len, len2;
+ if (!state->hist_file)
+ return;
+
fd = open(state->hist_file, O_WRONLY | O_CREAT | O_APPEND, 0600);
if (fd < 0)
return;
/* did we write so much that history file needs trimming? */
state->cnt_history_in_file++;
- if (state->cnt_history_in_file > MAX_HISTORY * 4) {
+ if (state->cnt_history_in_file > state->max_history * 4) {
char *new_name;
line_input_t *st_temp;
* load them */
st_temp = new_line_input_t(state->flags);
st_temp->hist_file = state->hist_file;
+ st_temp->max_history = state->max_history;
load_history(st_temp);
/* write out temp file and replace hist_file atomically */
new_name = xasprintf("%s.%u.new", state->hist_file, (int) getpid());
- fd = open(state->hist_file, O_WRONLY | O_CREAT | O_TRUNC, 0600);
+ fd = open(new_name, O_WRONLY | O_CREAT | O_TRUNC, 0600);
if (fd >= 0) {
FILE *fp;
int i;
free_line_input_t(st_temp);
}
}
+# endif
# else
# define load_history(a) ((void)0)
# define save_history(a) ((void)0)
if (i && strcmp(state->history[i-1], str) == 0)
return;
- free(state->history[MAX_HISTORY]); /* redundant, paranoia */
- state->history[MAX_HISTORY] = NULL; /* redundant, paranoia */
+ free(state->history[state->max_history]); /* redundant, paranoia */
+ state->history[state->max_history] = NULL; /* redundant, paranoia */
/* If history[] is full, remove the oldest command */
- /* we need to keep history[MAX_HISTORY] empty, hence >=, not > */
- if (i >= MAX_HISTORY) {
+ /* we need to keep history[state->max_history] empty, hence >=, not > */
+ if (i >= state->max_history) {
free(state->history[0]);
- for (i = 0; i < MAX_HISTORY-1; i++)
+ for (i = 0; i < state->max_history-1; i++)
state->history[i] = state->history[i+1];
- /* i == MAX_HISTORY-1 */
+ /* i == state->max_history-1 */
+# if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
+ if (state->cnt_history_in_file)
+ state->cnt_history_in_file--;
+# endif
}
- /* i <= MAX_HISTORY-1 */
+ /* i <= state->max_history-1 */
state->history[i++] = xstrdup(str);
- /* i <= MAX_HISTORY */
+ /* i <= state->max_history */
state->cur_history = i;
state->cnt_history = i;
-# if MAX_HISTORY > 0 && ENABLE_FEATURE_EDITING_SAVEHISTORY
- if ((state->flags & SAVE_HISTORY) && state->hist_file)
- save_history(str);
+# if ENABLE_FEATURE_EDITING_SAVEHISTORY && !ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
+ save_history(str);
# endif
- IF_FEATURE_EDITING_FANCY_PROMPT(num_ok_lines++;)
}
#else /* MAX_HISTORY == 0 */
{
CHAR_T *command = command_ps;
- if (BB_isalnum(command[cursor]) || command[cursor] == '_') {
+ if (BB_isalnum_or_underscore(command[cursor])) {
while (cursor < command_len
- && (BB_isalnum(command[cursor+1]) || command[cursor+1] == '_')
+ && (BB_isalnum_or_underscore(command[cursor+1]))
) {
input_forward();
}
input_forward();
if (cursor >= command_len-1)
return;
- if (BB_isalnum(command[cursor]) || command[cursor] == '_') {
+ if (BB_isalnum_or_underscore(command[cursor])) {
while (cursor < command_len-1
- && (BB_isalnum(command[cursor+1]) || command[cursor+1] == '_')
+ && (BB_isalnum_or_underscore(command[cursor+1]))
) {
input_forward();
}
input_backward(1);
if (cursor <= 0)
return;
- if (BB_isalnum(command[cursor]) || command[cursor] == '_') {
+ if (BB_isalnum_or_underscore(command[cursor])) {
while (cursor > 0
- && (BB_isalnum(command[cursor-1]) || command[cursor-1] == '_')
+ && (BB_isalnum_or_underscore(command[cursor-1]))
) {
input_backward(1);
}
* write(1, "~/srcdevel/bbox/fix/busybox.t4 # ", 33) = 33
* poll([{fd=0, events=POLLIN}], 1, 0) = 0 (Timeout) <-- no input exists
* write(1, "\33[6n", 4) = 4 <-- send the ESC sequence, quick!
- * poll([{fd=0, events=POLLIN}], 1, 4294967295) = 1 ([{fd=0, revents=POLLIN}])
+ * poll([{fd=0, events=POLLIN}], 1, -1) = 1 ([{fd=0, revents=POLLIN}])
* read(0, "\n", 1) = 1 <-- oh crap, user's input got in first
*/
struct pollfd pfd;
#define ask_terminal() ((void)0)
#endif
+/* Note about multi-line PS1 (e.g. "\n\w \u@\h\n> ") and prompt redrawing:
+ *
+ * If the prompt has any newlines, after we print it once we use only its last
+ * line to redraw in-place, which makes it simpler to calculate how many lines
+ * we should move the cursor up to align the redraw (cmdedit_y). The earlier
+ * prompt lines just stay on screen and we redraw below them.
+ *
+ * Use cases for all prompt lines beyond the initial draw:
+ * - After clear-screen (^L) or after displaying tab-completion choices, we
+ * print the full prompt, as it isn't redrawn in-place.
+ * - During terminal resize we could try to redraw all lines, but we don't,
+ * because it requires delicate alignment, it's good enough with only the
+ * last line, and doing it wrong is arguably worse than not doing it at all.
+ *
+ * Terminology wise, if it doesn't mention "full", then it means the last/sole
+ * prompt line. We use the prompt (last/sole line) while redrawing in-place,
+ * and the full where we need a fresh one unrelated to an earlier position.
+ *
+ * If PS1 is not multiline, the last/sole line and the full are the same string.
+ */
+
+/* Called just once at read_line_input() init time */
#if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
static void parse_and_put_prompt(const char *prmt_ptr)
{
- cmdedit_prompt = prmt_ptr;
- cmdedit_prmt_len = strlen(prmt_ptr);
+ const char *p;
+ cmdedit_prompt = prompt_last_line = prmt_ptr;
+ p = strrchr(prmt_ptr, '\n');
+ if (p)
+ prompt_last_line = p + 1;
+ cmdedit_prmt_len = unicode_strwidth(prompt_last_line);
put_prompt();
}
#else
static void parse_and_put_prompt(const char *prmt_ptr)
{
- int prmt_len = 0;
- size_t cur_prmt_len = 0;
- char flg_not_length = '[';
+ int prmt_size = 0;
char *prmt_mem_ptr = xzalloc(1);
- char *cwd_buf = xrealloc_getcwd_or_warn(NULL);
+# if ENABLE_USERNAME_OR_HOMEDIR
+ char *cwd_buf = NULL;
+# endif
+ char flg_not_length = '[';
char cbuf[2];
- char c;
- char *pbuf;
-
- cmdedit_prmt_len = 0;
- if (!cwd_buf) {
- cwd_buf = (char *)bb_msg_unknown;
- }
+ /*cmdedit_prmt_len = 0; - already is */
cbuf[1] = '\0'; /* never changes */
while (*prmt_ptr) {
+ char timebuf[sizeof("HH:MM:SS")];
char *free_me = NULL;
+ char *pbuf;
+ char c;
pbuf = cbuf;
c = *prmt_ptr++;
if (c == '\\') {
- const char *cp = prmt_ptr;
+ const char *cp;
int l;
-
- c = bb_process_escape_sequence(&prmt_ptr);
+/*
+ * Supported via bb_process_escape_sequence:
+ * \a ASCII bell character (07)
+ * \e ASCII escape character (033)
+ * \n newline
+ * \r carriage return
+ * \\ backslash
+ * \nnn char with octal code nnn
+ * Supported:
+ * \$ if the effective UID is 0, a #, otherwise a $
+ * \w current working directory, with $HOME abbreviated with a tilde
+ * Note: we do not support $PROMPT_DIRTRIM=n feature
+ * \W basename of the current working directory, with $HOME abbreviated with a tilde
+ * \h hostname up to the first '.'
+ * \H hostname
+ * \u username
+ * \[ begin a sequence of non-printing characters
+ * \] end a sequence of non-printing characters
+ * \T current time in 12-hour HH:MM:SS format
+ * \@ current time in 12-hour am/pm format
+ * \A current time in 24-hour HH:MM format
+ * \t current time in 24-hour HH:MM:SS format
+ * (all of the above work as \A)
+ * Not supported:
+ * \! history number of this command
+ * \# command number of this command
+ * \j number of jobs currently managed by the shell
+ * \l basename of the shell's terminal device name
+ * \s name of the shell, the basename of $0 (the portion following the final slash)
+ * \V release of bash, version + patch level (e.g., 2.00.0)
+ * \d date in "Weekday Month Date" format (e.g., "Tue May 26")
+ * \D{format}
+ * format is passed to strftime(3).
+ * An empty format results in a locale-specific time representation.
+ * The braces are required.
+ * Mishandled by bb_process_escape_sequence:
+ * \v version of bash (e.g., 2.00)
+ */
+ cp = prmt_ptr;
+ c = *cp;
+ if (c != 't') /* don't treat \t as tab */
+ c = bb_process_escape_sequence(&prmt_ptr);
if (prmt_ptr == cp) {
if (*cp == '\0')
break;
pbuf = user_buf ? user_buf : (char*)"";
break;
# endif
+ case 'H':
case 'h':
pbuf = free_me = safe_gethostname();
- *strchrnul(pbuf, '.') = '\0';
+ if (c == 'h')
+ strchrnul(pbuf, '.')[0] = '\0';
break;
case '$':
c = (geteuid() == 0 ? '#' : '$');
break;
+ case 'T': /* 12-hour HH:MM:SS format */
+ case '@': /* 12-hour am/pm format */
+ case 'A': /* 24-hour HH:MM format */
+ case 't': /* 24-hour HH:MM:SS format */
+ /* We show all of them as 24-hour HH:MM */
+ strftime_HHMMSS(timebuf, sizeof(timebuf), NULL)[-3] = '\0';
+ pbuf = timebuf;
+ break;
# if ENABLE_USERNAME_OR_HOMEDIR
- case 'w':
- /* /home/user[/something] -> ~[/something] */
- pbuf = cwd_buf;
- l = strlen(home_pwd_buf);
- if (l != 0
- && strncmp(home_pwd_buf, cwd_buf, l) == 0
- && (cwd_buf[l]=='/' || cwd_buf[l]=='\0')
- && strlen(cwd_buf + l) < PATH_MAX
- ) {
- pbuf = free_me = xasprintf("~%s", cwd_buf + l);
+ case 'w': /* current dir */
+ case 'W': /* basename of cur dir */
+ if (!cwd_buf) {
+ cwd_buf = xrealloc_getcwd_or_warn(NULL);
+ if (!cwd_buf)
+ cwd_buf = (char *)bb_msg_unknown;
+ else if (home_pwd_buf[0]) {
+ char *after_home_user;
+
+ /* /home/user[/something] -> ~[/something] */
+ after_home_user = is_prefixed_with(cwd_buf, home_pwd_buf);
+ if (after_home_user
+ && (*after_home_user == '/' || *after_home_user == '\0')
+ ) {
+ cwd_buf[0] = '~';
+ overlapping_strcpy(cwd_buf + 1, after_home_user);
+ }
+ }
}
- break;
-# endif
- case 'W':
pbuf = cwd_buf;
+ if (c == 'w')
+ break;
cp = strrchr(pbuf, '/');
- if (cp != NULL && cp != pbuf)
- pbuf += (cp-pbuf) + 1;
- break;
- case '!':
- pbuf = free_me = xasprintf("%d", num_ok_lines);
- break;
- case 'e': case 'E': /* \e \E = \033 */
- c = '\033';
+ if (cp)
+ pbuf = (char*)cp + 1;
break;
+# endif
+// bb_process_escape_sequence does this now:
+// case 'e': case 'E': /* \e \E = \033 */
+// c = '\033';
+// break;
case 'x': case 'X': {
char buf2[4];
for (l = 0; l < 3;) {
}
case '[': case ']':
if (c == flg_not_length) {
- flg_not_length = (flg_not_length == '[' ? ']' : '[');
+ /* Toggle '['/']' hex 5b/5d */
+ flg_not_length ^= 6;
continue;
}
break;
} /* if */
} /* if */
cbuf[0] = c;
- cur_prmt_len = strlen(pbuf);
- prmt_len += cur_prmt_len;
- if (flg_not_length != ']')
- cmdedit_prmt_len += cur_prmt_len;
- prmt_mem_ptr = strcat(xrealloc(prmt_mem_ptr, prmt_len+1), pbuf);
+ {
+ int n = strlen(pbuf);
+ prmt_size += n;
+ if (c == '\n')
+ cmdedit_prmt_len = 0;
+ else if (flg_not_length != ']') {
+#if 0 /*ENABLE_UNICODE_SUPPORT*/
+/* Won't work, pbuf is one BYTE string here instead of an one Unicode char string. */
+/* FIXME */
+ cmdedit_prmt_len += unicode_strwidth(pbuf);
+#else
+ cmdedit_prmt_len += n;
+#endif
+ }
+ }
+ prmt_mem_ptr = strcat(xrealloc(prmt_mem_ptr, prmt_size+1), pbuf);
free(free_me);
} /* while */
+# if ENABLE_USERNAME_OR_HOMEDIR
if (cwd_buf != (char *)bb_msg_unknown)
free(cwd_buf);
- cmdedit_prompt = prmt_mem_ptr;
+# endif
+ /* see comment (above this function) about multiline prompt redrawing */
+ cmdedit_prompt = prompt_last_line = prmt_mem_ptr;
+ prmt_ptr = strrchr(cmdedit_prompt, '\n');
+ if (prmt_ptr)
+ prompt_last_line = prmt_ptr + 1;
put_prompt();
}
#endif
-static void cmdedit_setwidth(unsigned w, int redraw_flg)
+#if ENABLE_FEATURE_EDITING_WINCH
+static void cmdedit_setwidth(void)
{
- cmdedit_termw = w;
- if (redraw_flg) {
- /* new y for current cursor */
- int new_y = (cursor + cmdedit_prmt_len) / w;
- /* redraw */
- redraw((new_y >= cmdedit_y ? new_y : cmdedit_y), command_len - cursor);
- fflush_all();
- }
+ int new_y;
+
+ cmdedit_termw = get_terminal_width(STDIN_FILENO);
+ /* new y for current cursor */
+ new_y = (cursor + cmdedit_prmt_len) / cmdedit_termw;
+ /* redraw */
+ redraw((new_y >= cmdedit_y ? new_y : cmdedit_y), command_len - cursor);
}
-static void win_changed(int nsig)
+static void win_changed(int nsig UNUSED_PARAM)
{
- int sv_errno = errno;
- unsigned width;
- get_terminal_width_height(0, &width, NULL);
- cmdedit_setwidth(width, nsig /* - just a yes/no flag */);
- if (nsig == SIGWINCH)
- signal(SIGWINCH, win_changed); /* rearm ourself */
- errno = sv_errno;
+ if (S.ok_to_redraw) {
+ /* We are in read_key(), safe to redraw immediately */
+ int sv_errno = errno;
+ cmdedit_setwidth();
+ fflush_all();
+ errno = sv_errno;
+ } else {
+ /* Signal main loop that redraw is necessary */
+ S.SIGWINCH_count++;
+ }
}
+#endif
static int lineedit_read_key(char *read_key_buffer, int timeout)
{
int unicode_idx = 0;
#endif
+ fflush_all();
while (1) {
/* Wait for input. TIMEOUT = -1 makes read_key wait even
* on nonblocking stdin, TIMEOUT = 50 makes sure we won't
*
* Note: read_key sets errno to 0 on success.
*/
+ IF_FEATURE_EDITING_WINCH(S.ok_to_redraw = 1;)
ic = read_key(STDIN_FILENO, read_key_buffer, timeout);
+ IF_FEATURE_EDITING_WINCH(S.ok_to_redraw = 0;)
if (errno) {
#if ENABLE_UNICODE_SUPPORT
if (errno == EAGAIN && unicode_idx != 0)
S.sent_ESC_br6n = 0;
if (cursor == 0) { /* otherwise it may be bogus */
int col = ((ic >> 32) & 0x7fff) - 1;
- if (col > cmdedit_prmt_len) {
+ /*
+ * Is col > cmdedit_prmt_len?
+ * If yes (terminal says cursor is farther to the right
+ * of where we think it should be),
+ * the prompt wasn't printed starting at col 1,
+ * there was additional text before it.
+ */
+ if ((int)(col - cmdedit_prmt_len) > 0) {
+ /* Fix our understanding of current x position */
cmdedit_x += (col - cmdedit_prmt_len);
while (cmdedit_x >= cmdedit_termw) {
cmdedit_x -= cmdedit_termw;
#undef CTRL
#define CTRL(a) ((a) & ~0x40)
+enum {
+ VI_CMDMODE_BIT = 0x40000000,
+ /* 0x80000000 bit flags KEYCODE_xxx */
+};
+
+#if ENABLE_FEATURE_REVERSE_SEARCH
+/* Mimic readline Ctrl-R reverse history search.
+ * When invoked, it shows the following prompt:
+ * (reverse-i-search)'': user_input [cursor pos unchanged by Ctrl-R]
+ * and typing results in search being performed:
+ * (reverse-i-search)'tmp': cd /tmp [cursor under t in /tmp]
+ * Search is performed by looking at progressively older lines in history.
+ * Ctrl-R again searches for the next match in history.
+ * Backspace deletes last matched char.
+ * Control keys exit search and return to normal editing (at current history line).
+ */
+static int32_t reverse_i_search(int timeout)
+{
+ char match_buf[128]; /* for user input */
+ char read_key_buffer[KEYCODE_BUFFER_SIZE];
+ const char *matched_history_line;
+ const char *saved_prompt;
+ unsigned saved_prmt_len;
+ int32_t ic;
+
+ matched_history_line = NULL;
+ read_key_buffer[0] = 0;
+ match_buf[0] = '\0';
+
+ /* Save and replace the prompt */
+ saved_prompt = prompt_last_line;
+ saved_prmt_len = cmdedit_prmt_len;
+ goto set_prompt;
+
+ while (1) {
+ int h;
+ unsigned match_buf_len = strlen(match_buf);
+
+//FIXME: correct timeout? (i.e. count it down?)
+ ic = lineedit_read_key(read_key_buffer, timeout);
+
+ switch (ic) {
+ case CTRL('R'): /* searching for the next match */
+ break;
+
+ case '\b':
+ case '\x7f':
+ /* Backspace */
+ if (unicode_status == UNICODE_ON) {
+ while (match_buf_len != 0) {
+ uint8_t c = match_buf[--match_buf_len];
+ if ((c & 0xc0) != 0x80) /* start of UTF-8 char? */
+ break; /* yes */
+ }
+ } else {
+ if (match_buf_len != 0)
+ match_buf_len--;
+ }
+ match_buf[match_buf_len] = '\0';
+ break;
+
+ default:
+ if (ic < ' '
+ || (!ENABLE_UNICODE_SUPPORT && ic >= 256)
+ || (ENABLE_UNICODE_SUPPORT && ic >= VI_CMDMODE_BIT)
+ ) {
+ goto ret;
+ }
+
+ /* Append this char */
+#if ENABLE_UNICODE_SUPPORT
+ if (unicode_status == UNICODE_ON) {
+ mbstate_t mbstate = { 0 };
+ char buf[MB_CUR_MAX + 1];
+ int len = wcrtomb(buf, ic, &mbstate);
+ if (len > 0) {
+ buf[len] = '\0';
+ if (match_buf_len + len < sizeof(match_buf))
+ strcpy(match_buf + match_buf_len, buf);
+ }
+ } else
+#endif
+ if (match_buf_len < sizeof(match_buf) - 1) {
+ match_buf[match_buf_len] = ic;
+ match_buf[match_buf_len + 1] = '\0';
+ }
+ break;
+ } /* switch (ic) */
+
+ /* Search in history for match_buf */
+ h = state->cur_history;
+ if (ic == CTRL('R'))
+ h--;
+ while (h >= 0) {
+ if (state->history[h]) {
+ char *match = strstr(state->history[h], match_buf);
+ if (match) {
+ state->cur_history = h;
+ matched_history_line = state->history[h];
+ command_len = load_string(matched_history_line);
+ cursor = match - matched_history_line;
+//FIXME: cursor position for Unicode case
+
+ free((char*)prompt_last_line);
+ set_prompt:
+ prompt_last_line = xasprintf("(reverse-i-search)'%s': ", match_buf);
+ cmdedit_prmt_len = unicode_strwidth(prompt_last_line);
+ goto do_redraw;
+ }
+ }
+ h--;
+ }
+
+ /* Not found */
+ match_buf[match_buf_len] = '\0';
+ beep();
+ continue;
+
+ do_redraw:
+ redraw(cmdedit_y, command_len - cursor);
+ } /* while (1) */
+
+ ret:
+ if (matched_history_line)
+ command_len = load_string(matched_history_line);
+
+ free((char*)prompt_last_line);
+ prompt_last_line = saved_prompt;
+ cmdedit_prmt_len = saved_prmt_len;
+ redraw(cmdedit_y, command_len - cursor);
+
+ return ic;
+}
+#endif
+
+#if ENABLE_FEATURE_EDITING_WINCH
+static void sigaction2(int sig, struct sigaction *act)
+{
+ // Grr... gcc 8.1.1:
+ // "passing argument 3 to restrict-qualified parameter aliases with argument 2"
+ // dance around that...
+ struct sigaction *oact FIX_ALIASING;
+ oact = act;
+ sigaction(sig, act, oact);
+}
+#endif
+
/* maxsize must be >= 2.
* Returns:
* -1 on read errors or EOF, or on bare Ctrl-D,
* 0 on ctrl-C (the line entered is still returned in 'command'),
+ * (in both cases the cursor remains on the input line, '\n' is not printed)
* >0 length of input string, including terminating '\n'
*/
-int FAST_FUNC read_line_input(line_input_t *st, const char *prompt, char *command, int maxsize, int timeout)
+int FAST_FUNC read_line_input(line_input_t *st, const char *prompt, char *command, int maxsize)
{
- int len;
+ int len, n;
+ int timeout;
#if ENABLE_FEATURE_TAB_COMPLETION
smallint lastWasTab = 0;
#endif
INIT_S();
- if (tcgetattr(STDIN_FILENO, &initial_settings) < 0
- || !(initial_settings.c_lflag & ECHO)
- ) {
- /* Happens when e.g. stty -echo was run before */
+ n = get_termios_and_make_raw(STDIN_FILENO, &new_settings, &initial_settings, 0
+ | TERMIOS_CLEAR_ISIG /* turn off INTR (ctrl-C), QUIT, SUSP */
+ );
+ if (n != 0 || (initial_settings.c_lflag & (ECHO|ICANON)) == ICANON) {
+ /* Happens when e.g. stty -echo was run before.
+ * But if ICANON is not set, we don't come here.
+ * (example: interactive python ^Z-backgrounded,
+ * tty is still in "raw mode").
+ */
parse_and_put_prompt(prompt);
- /* fflush_all(); - done by parse_and_put_prompt */
+ fflush_all();
if (fgets(command, maxsize, stdin) == NULL)
len = -1; /* EOF or error */
else
maxsize = MAX_LINELEN;
S.maxsize = maxsize;
- /* With null flags, no other fields are ever used */
- state = st ? st : (line_input_t*) &const_int_0;
+ timeout = -1;
+ /* Make state->flags == 0 if st is NULL.
+ * With zeroed flags, no other fields are ever referenced.
+ */
+ state = (line_input_t*) &const_int_0;
+ if (st) {
+ state = st;
+ timeout = st->timeout;
+ }
#if MAX_HISTORY > 0
+ if (state->flags & DO_HISTORY) {
# if ENABLE_FEATURE_EDITING_SAVEHISTORY
- if ((state->flags & SAVE_HISTORY) && state->hist_file)
- if (state->cnt_history == 0)
- load_history(state);
+ if (state->hist_file)
+ if (state->cnt_history == 0)
+ load_history(state);
# endif
- if (state->flags & DO_HISTORY)
state->cur_history = state->cnt_history;
+ }
#endif
/* prepare before init handlers */
#endif
#define command command_must_not_be_used
- new_settings = initial_settings;
- new_settings.c_lflag &= ~ICANON; /* unbuffered input */
- /* Turn off echoing and CTRL-C, so we can trap it */
- new_settings.c_lflag &= ~(ECHO | ECHONL | ISIG);
- /* Hmm, in linux c_cc[] is not parsed if ICANON is off */
- new_settings.c_cc[VMIN] = 1;
- new_settings.c_cc[VTIME] = 0;
- /* Turn off CTRL-C, so we can trap it */
-#ifndef _POSIX_VDISABLE
-# define _POSIX_VDISABLE '\0'
-#endif
- new_settings.c_cc[VINTR] = _POSIX_VDISABLE;
tcsetattr_stdin_TCSANOW(&new_settings);
- previous_SIGWINCH_handler = signal(SIGWINCH, win_changed);
- win_changed(0); /* do initial resizing */
#if ENABLE_USERNAME_OR_HOMEDIR
{
struct passwd *entry;
#endif
#if 0
- for (i = 0; i <= MAX_HISTORY; i++)
+ for (i = 0; i <= state->max_history; i++)
bb_error_msg("history[%d]:'%s'", i, state->history[i]);
bb_error_msg("cur_history:%d cnt_history:%d", state->cur_history, state->cnt_history);
#endif
+ /* Get width (before printing prompt) */
+ cmdedit_termw = get_terminal_width(STDIN_FILENO);
/* Print out the command prompt, optionally ask where cursor is */
parse_and_put_prompt(prompt);
ask_terminal();
+#if ENABLE_FEATURE_EDITING_WINCH
+ /* Install window resize handler (NB: after *all* init is complete) */
+ S.SIGWINCH_handler.sa_handler = win_changed;
+ S.SIGWINCH_handler.sa_flags = SA_RESTART;
+ sigaction2(SIGWINCH, &S.SIGWINCH_handler);
+#endif
read_key_buffer[0] = 0;
while (1) {
/*
* clutters the big switch a bit, but keeps all the code
* in one place.
*/
- enum {
- VI_CMDMODE_BIT = 0x40000000,
- /* 0x80000000 bit flags KEYCODE_xxx */
- };
int32_t ic, ic_raw;
+#if ENABLE_FEATURE_EDITING_WINCH
+ unsigned count;
- fflush_all();
+ count = S.SIGWINCH_count;
+ if (S.SIGWINCH_saved != count) {
+ S.SIGWINCH_saved = count;
+ cmdedit_setwidth();
+ }
+#endif
ic = ic_raw = lineedit_read_key(read_key_buffer, timeout);
+#if ENABLE_FEATURE_REVERSE_SEARCH
+ again:
+#endif
#if ENABLE_FEATURE_EDITING_VI
newdelflag = 1;
if (vi_cmdmode) {
case CTRL('L'):
vi_case(CTRL('L')|VI_CMDMODE_BIT:)
/* Control-l -- clear screen */
- printf(ESC"[H"); /* cursor to top,left */
- redraw(0, command_len - cursor);
+ /* cursor to top,left; clear to the end of screen */
+ printf(ESC"[H" ESC"[J");
+ draw_full(command_len - cursor);
break;
#if MAX_HISTORY > 0
case CTRL('N'):
while (cursor > 0 && !BB_isspace(command_ps[cursor-1]))
input_backspace();
break;
+ case KEYCODE_ALT_D: {
+ /* Delete word forward */
+ int nc, sc = cursor;
+ ctrl_right();
+ nc = cursor - sc;
+ input_backward(nc);
+ while (--nc >= 0)
+ input_delete(1);
+ break;
+ }
+ case KEYCODE_ALT_BACKSPACE: {
+ /* Delete word backward */
+ int sc = cursor;
+ ctrl_left();
+ while (sc-- > cursor)
+ input_delete(1);
+ break;
+ }
+#if ENABLE_FEATURE_REVERSE_SEARCH
+ case CTRL('R'):
+ ic = ic_raw = reverse_i_search(timeout);
+ goto again;
+#endif
#if ENABLE_FEATURE_EDITING_VI
case 'i'|VI_CMDMODE_BIT:
/* Rewrite the line with the selected history item */
/* change command */
command_len = load_string(state->history[state->cur_history] ?
- state->history[state->cur_history] : "", maxsize);
+ state->history[state->cur_history] : "");
/* redraw and go to eol (bol, in vi) */
redraw(cmdedit_y, (state->flags & VI_MODE) ? 9999 : 0);
break;
input_backward(1);
break;
case KEYCODE_CTRL_LEFT:
+ case KEYCODE_ALT_LEFT: /* bash doesn't do it */
ctrl_left();
break;
case KEYCODE_CTRL_RIGHT:
+ case KEYCODE_ALT_RIGHT: /* bash doesn't do it */
ctrl_right();
break;
case KEYCODE_HOME:
&& ic_raw == initial_settings.c_cc[VINTR]
) {
/* Ctrl-C (usually) - stop gathering input */
- goto_new_line();
command_len = 0;
break_out = -1; /* "do not append '\n'" */
break;
free(command_ps);
#endif
- if (command_len > 0)
+ if (command_len > 0) {
remember_in_history(command);
+ }
if (break_out > 0) {
command[command_len++] = '\n';
/* restore initial_settings */
tcsetattr_stdin_TCSANOW(&initial_settings);
+#if ENABLE_FEATURE_EDITING_WINCH
/* restore SIGWINCH handler */
- signal(SIGWINCH, previous_SIGWINCH_handler);
+ sigaction_set(SIGWINCH, &S.SIGWINCH_handler);
+#endif
fflush_all();
len = command_len;
{
fputs(prompt, stdout);
fflush_all();
- fgets(command, maxsize, stdin);
+ if (!fgets(command, maxsize, stdin))
+ return -1;
return strlen(command);
}
#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
"\\[\\033[32;1m\\]\\u@\\[\\x1b[33;1m\\]\\h:"
"\\[\\033[34;1m\\]\\w\\[\\033[35;1m\\] "
- "\\!\\[\\e[36;1m\\]\\$ \\[\\E[0m\\]";
+ "\\!\\[\\e[36;1m\\]\\$ \\[\\E[m\\]";
#else
"% ";
#endif