Changeset 3232 in MondoRescue for branches/3.2/mindi-busybox/libbb/lineedit.c

Timestamp:

Jan 1, 2014, 12:47:38 AM (10 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.21.1

File:

• branches/3.2/mindi-busybox/libbb/lineedit.c (modified) (32 diffs)

branches/3.2/mindi-busybox/libbb/lineedit.c

@@ -42 +42 @@
 #include "libbb.h"
 #include "unicode.h"
+#ifndef _POSIX_VDISABLE
+# define _POSIX_VDISABLE '\0'
+#endif
+
 
 #ifdef TEST
@@ -185 +189 @@
     IF_USERNAME_OR_HOMEDIR(home_pwd_buf = (char*)null_str;) \
 } while (0)
+
 static void deinit_S(void)
 {
@@ -203 +208 @@
 
 #if ENABLE_UNICODE_SUPPORT
-static size_t load_string(const char *src, int maxsize)
-{
-    ssize_t len = mbstowcs(command_ps, src, maxsize - 1);
-    if (len < 0)
-        len = 0;
-    command_ps[len] = BB_NUL;
-    return len;
+static size_t load_string(const char *src)
+{
+    if (unicode_status == UNICODE_ON) {
+        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 (src[i] && i < S.maxsize - 1) {
+            command_ps[i] = src[i];
+            i++;
+        }
+        command_ps[i] = BB_NUL;
+        return i;
+    }
 }
 static unsigned save_string(char *dst, unsigned maxsize)
 {
+    if (unicode_status == UNICODE_ON) {
 # if !ENABLE_UNICODE_PRESERVE_BROKEN
-    ssize_t len = wcstombs(dst, command_ps, maxsize - 1);
-    if (len < 0)
-        len = 0;
-    dst[len] = '\0';
-    return len;
+        ssize_t len = wcstombs(dst, command_ps, maxsize - 1);
+        if (len < 0)
+            len = 0;
+        dst[len] = '\0';
+        return len;
 # else
-    unsigned dstpos = 0;
-    unsigned srcpos = 0;
-
-    maxsize--;
-    while (dstpos < maxsize) {
-        wchar_t wc;
-        int n = srcpos;
-
-        /* Convert up to 1st invalid byte (or up to end) */
-        while ((wc = command_ps[srcpos]) != BB_NUL
-            && !unicode_is_raw_byte(wc)
-        ) {
+        unsigned dstpos = 0;
+        unsigned srcpos = 0;
+
+        maxsize--;
+        while (dstpos < maxsize) {
+            wchar_t wc;
+            int n = srcpos;
+
+            /* Convert up to 1st invalid byte (or up to end) */
+            while ((wc = command_ps[srcpos]) != BB_NUL
+                && !unicode_is_raw_byte(wc)
+            ) {
+                srcpos++;
+            }
+            command_ps[srcpos] = BB_NUL;
+            n = wcstombs(dst + dstpos, command_ps + n, maxsize - dstpos);
+            if (n < 0) /* should not happen */
+                break;
+            dstpos += n;
+            if (wc == BB_NUL) /* usually is */
+                break;
+
+            /* We do have invalid byte here! */
+            command_ps[srcpos] = wc; /* restore it */
             srcpos++;
-        }
-        command_ps[srcpos] = BB_NUL;
-        n = wcstombs(dst + dstpos, command_ps + n, maxsize - dstpos);
-        if (n < 0) /* should not happen */
-            break;
-        dstpos += n;
-        if (wc == BB_NUL) /* usually is */
-            break;
-
-        /* We do have invalid byte here! */
-        command_ps[srcpos] = wc; /* restore it */
-        srcpos++;
-        if (dstpos == maxsize)
-            break;
-        dst[dstpos++] = (char) wc;
-    }
-    dst[dstpos] = '\0';
-    return dstpos;
+            if (dstpos == maxsize)
+                break;
+            dst[dstpos++] = (char) wc;
+        }
+        dst[dstpos] = '\0';
+        return dstpos;
 # endif
+    } else {
+        unsigned i = 0;
+        while ((dst[i] = command_ps[i]) != 0)
+            i++;
+        return i;
+    }
 }
 /* I thought just fputwc(c, stdout) would work. But no... */
 static void BB_PUTCHAR(wchar_t c)
 {
-    char buf[MB_CUR_MAX + 1];
-    mbstate_t mbst = { 0 };
-    ssize_t len;
-
-    len = wcrtomb(buf, c, &mbst);
-    if (len > 0) {
-        buf[len] = '\0';
-        fputs(buf, stdout);
+    if (unicode_status == UNICODE_ON) {
+        char buf[MB_CUR_MAX + 1];
+        mbstate_t mbst = { 0 };
+        ssize_t len = wcrtomb(buf, c, &mbst);
+        if (len > 0) {
+            buf[len] = '\0';
+            fputs(buf, stdout);
+        }
+    } else {
+        /* In this case, c is always one byte */
+        putchar(c);
     }
 }
@@ -298 +323 @@
 }
 #else /* !UNICODE */
-static size_t load_string(const char *src, int maxsize)
-{
-    safe_strncpy(command_ps, src, maxsize);
+static size_t load_string(const char *src)
+{
+    safe_strncpy(command_ps, src, S.maxsize);
     return strlen(command_ps);
 }
@@ -1203 +1228 @@
             /* 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,
@@ -1227 +1252 @@
     line_input_t *n = xzalloc(sizeof(*n));
     n->flags = flags;
+    n->max_history = MAX_HISTORY;
     return n;
 }
@@ -1232 +1258 @@
 
 #if MAX_HISTORY > 0
+
+unsigned 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)
@@ -1313 +1352 @@
         /* 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') {
@@ -1323 +1363 @@
             st_parm->cnt_history_in_file++;
             idx++;
-            if (idx == MAX_HISTORY)
+            if (idx == st_parm->max_history)
                 idx = 0;
         }
@@ -1332 +1372 @@
             while (temp_h[idx] == NULL) {
                 idx++;
-                if (idx == MAX_HISTORY)
+                if (idx == st_parm->max_history)
                     idx = 0;
             }
@@ -1338 +1378 @@
 
         /* 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);
@@ -1351 +1391 @@
         }
         st_parm->cnt_history = i;
-    }
-}
-
-/* state->flags is already checked to be nonzero */
+        if (ENABLE_FEATURE_EDITING_SAVE_ON_EXIT)
+            st_parm->cnt_history_in_file = i;
+    }
+}
+
+#  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);
@@ -1374 +1461 @@
     /* 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;
@@ -1382 +1469 @@
         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;
@@ -1402 +1490 @@
     }
 }
+#  endif
 # else
 #  define load_history(a) ((void)0)
@@ -1420 +1509 @@
         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 <= 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 <= 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++;)
@@ -1645 +1737 @@
      * 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
      */
@@ -1803 +1895 @@
     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 */
+//FIXME: cmdedit_setwidth() -> redraw() -> printf() -> KABOOM! (we are in signal handler!)
+    cmdedit_setwidth(width, /*redraw_flg:*/ nsig);
+
     errno = sv_errno;
 }
 
-static int lineedit_read_key(char *read_key_buffer)
+static int lineedit_read_key(char *read_key_buffer, int timeout)
 {
     int64_t ic;
-    int timeout = -1;
 #if ENABLE_UNICODE_SUPPORT
     char unicode_buf[MB_CUR_MAX + 1];
@@ -1912 +2004 @@
 #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(void)
+{
+    char match_buf[128]; /* for user input */
+    char read_key_buffer[KEYCODE_BUFFER_SIZE];
+    const char *matched_history_line;
+    const char *saved_prompt;
+    int32_t ic;
+
+    matched_history_line = NULL;
+    read_key_buffer[0] = 0;
+    match_buf[0] = '\0';
+
+    /* Save and replace the prompt */
+    saved_prompt = cmdedit_prompt;
+    goto set_prompt;
+
+    while (1) {
+        int h;
+        unsigned match_buf_len = strlen(match_buf);
+
+        fflush_all();
+//FIXME: correct timeout?
+        ic = lineedit_read_key(read_key_buffer, -1);
+
+        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*)cmdedit_prompt);
+ set_prompt:
+                    cmdedit_prompt = xasprintf("(reverse-i-search)'%s': ", match_buf);
+                    cmdedit_prmt_len = strlen(cmdedit_prompt);
+                    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*)cmdedit_prompt);
+    cmdedit_prompt = saved_prompt;
+    cmdedit_prmt_len = strlen(cmdedit_prompt);
+    redraw(cmdedit_y, command_len - cursor);
+
+    return ic;
+}
+#endif
+
 /* maxsize must be >= 2.
  * Returns:
@@ -1918 +2144 @@
  * >0 length of input string, including terminating '\n'
  */
-int FAST_FUNC read_line_input(const char *prompt, char *command, int maxsize, line_input_t *st)
+int FAST_FUNC read_line_input(line_input_t *st, const char *prompt, char *command, int maxsize, int timeout)
 {
     int len;
@@ -1955 +2181 @@
     S.maxsize = maxsize;
 
-    /* With null flags, no other fields are ever used */
+    /* With zero flags, no other fields are ever used */
     state = st ? st : (line_input_t*) &const_int_0;
 #if MAX_HISTORY > 0
 # if ENABLE_FEATURE_EDITING_SAVEHISTORY
-    if ((state->flags & SAVE_HISTORY) && state->hist_file)
+    if (state->hist_file)
         if (state->cnt_history == 0)
             load_history(state);
@@ -1979 +2205 @@
 
     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 */
+    /* ~ICANON: unbuffered input (most c_cc[] are disabled, VMIN/VTIME are enabled) */
+    /* ~ECHO, ~ECHONL: turn off echoing, including newline echoing */
+    /* ~ISIG: turn off INTR (ctrl-C), QUIT, SUSP */
+    new_settings.c_lflag &= ~(ICANON | ECHO | ECHONL | ISIG);
+    /* reads would block only if < 1 char is available */
     new_settings.c_cc[VMIN] = 1;
+    /* no timeout (reads block forever) */
     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;
+    /* Should be not needed if ISIG is off: */
+    /* Turn off CTRL-C */
+    /* new_settings.c_cc[VINTR] = _POSIX_VDISABLE; */
     tcsetattr_stdin_TCSANOW(&new_settings);
 
-    /* Now initialize things */
-    previous_SIGWINCH_handler = signal(SIGWINCH, win_changed);
-    win_changed(0); /* do initial resizing */
 #if ENABLE_USERNAME_OR_HOMEDIR
     {
@@ -2008 +2231 @@
 
 #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);
@@ -2016 +2239 @@
     parse_and_put_prompt(prompt);
     ask_terminal();
+
+    /* Install window resize handler (NB: after *all* init is complete) */
+//FIXME: save entire sigaction!
+    previous_SIGWINCH_handler = signal(SIGWINCH, win_changed);
+    win_changed(0); /* get initial window size */
 
     read_key_buffer[0] = 0;
@@ -2027 +2255 @@
          * in one place.
          */
-        enum {
-            VI_CMDMODE_BIT = 0x40000000,
-            /* 0x80000000 bit flags KEYCODE_xxx */
-        };
         int32_t ic, ic_raw;
 
         fflush_all();
-        ic = ic_raw = lineedit_read_key(read_key_buffer);
-
+        ic = ic_raw = lineedit_read_key(read_key_buffer, timeout);
+
+#if ENABLE_FEATURE_REVERSE_SEARCH
+ again:
+#endif
 #if ENABLE_FEATURE_EDITING_VI
         newdelflag = 1;
@@ -2139 +2366 @@
                 input_backspace();
             break;
+#if ENABLE_FEATURE_REVERSE_SEARCH
+        case CTRL('R'):
+            ic = ic_raw = reverse_i_search();
+            goto again;
+#endif
 
 #if ENABLE_FEATURE_EDITING_VI
@@ -2195 +2427 @@
             int nc, sc;
 
-            ic = lineedit_read_key(read_key_buffer);
+            ic = lineedit_read_key(read_key_buffer, timeout);
             if (errno) /* error */
                 goto return_error_indicator;
@@ -2259 +2491 @@
         case 'r'|VI_CMDMODE_BIT:
 //FIXME: unicode case?
-            ic = lineedit_read_key(read_key_buffer);
+            ic = lineedit_read_key(read_key_buffer, timeout);
             if (errno) /* error */
                 goto return_error_indicator;
@@ -2276 +2508 @@
                 input_backward(1);
             }
+            /* Handle a few ESC-<key> combinations the same way
+             * standard readline bindings (IOW: bash) do.
+             * Often, Alt-<key> generates ESC-<key>.
+             */
+            ic = lineedit_read_key(read_key_buffer, timeout);
+            switch (ic) {
+                //case KEYCODE_LEFT: - bash doesn't do this
+                case 'b':
+                    ctrl_left();
+                    break;
+                //case KEYCODE_RIGHT: - bash doesn't do this
+                case 'f':
+                    ctrl_right();
+                    break;
+                //case KEYCODE_DELETE: - bash doesn't do this
+                case 'd':  /* 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 '\b':   /* Alt-Backspace(?) */
+                case '\x7f': /* Alt-Backspace(?) */
+                //case 'w': - bash doesn't do this
+                {
+                    /* Delete word backward */
+                    int sc = cursor;
+                    ctrl_left();
+                    while (sc-- > cursor)
+                        input_delete(1);
+                    break;
+                }
+            }
             break;
 #endif /* FEATURE_COMMAND_EDITING_VI */
@@ -2292 +2562 @@
             /* 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);
@@ -2304 +2574 @@
             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;
@@ -2458 +2730 @@
     fputs(prompt, stdout);
     fflush_all();
-    fgets(command, maxsize, stdin);
+    if (!fgets(command, maxsize, stdin))
+        return -1;
     return strlen(command);
 }