diff options
| -rw-r--r-- | linenoise/linenoise.c | 117 | ||||
| -rw-r--r-- | txr.1 | 47 |
2 files changed, 88 insertions, 76 deletions
diff --git a/linenoise/linenoise.c b/linenoise/linenoise.c index 70ccc490..d0e3db1d 100644 --- a/linenoise/linenoise.c +++ b/linenoise/linenoise.c @@ -55,6 +55,8 @@ #include <unistd.h> #include <signal.h> #include <time.h> +#include <limits.h> +#include <assert.h> #include "config.h" #if HAVE_POLL #include <poll.h> @@ -65,7 +67,7 @@ #define LINENOISE_MAX_LINE 1024 #define LINENOISE_MAX_DISP (LINENOISE_MAX_LINE * 8) #define LINENOISE_PAREN_DELAY 400000 -#define LINENOISE_MAX_UNDO 32 +#define LINENOISE_MAX_UNDO 200 /* The lino_state structure represents the state during line editing. * We pass this state to functions implementing specific editing @@ -293,20 +295,24 @@ static int generate_beep(lino_t *ls) { return write(ls->ofd, "\x7", 1) > 0; } -static void free_undo(lino_t *l) +static void delete_undo(struct lino_undo **pundo) { - struct lino_undo *top = l->undo_stack; + struct lino_undo *u = *pundo; - if (top != 0) { - l->undo_stack = top->next; - free(top->data); - top->data = 0; - free(top); - free_undo(l); - l->undo_stack = 0; + if (u) { + *pundo = u->next; + free(u->data); + u->data = 0; + free(u); } } +static void free_undo_stack(lino_t *l) +{ + while (l->undo_stack != 0) + delete_undo(&l->undo_stack); +} + static void record_undo(lino_t *l) { struct lino_undo *rec = (struct lino_undo *) chk_malloc(sizeof *rec), *iter; @@ -322,7 +328,7 @@ static void record_undo(lino_t *l) rec->next = l->undo_stack; rec->triv = 0; rec->dpos = l->dpos; - rec->hist_index = l->history_index; + rec->hist_index = INT_MAX; rec->data = data; l->undo_stack = rec; @@ -333,11 +339,8 @@ static void record_undo(lino_t *l) /* empty */; if (iter != 0) { - struct lino_undo *save = l->undo_stack; - l->undo_stack = iter->next; - iter->next = 0; - free_undo(l); - l->undo_stack = save; + while (iter->next) + delete_undo(&iter->next); } } @@ -345,61 +348,60 @@ static void record_triv_undo(lino_t *l) { struct lino_undo *top = l->undo_stack; - if (top != 0 && top->triv && top->dpos < l->dpos) + if (top != 0 && top->triv && + (top->hist_index == INT_MAX || top->hist_index == l->history_index) && + top->dpos < l->dpos) return; record_undo(l); l->undo_stack->triv = 1; } -static void undo_pop(lino_t *l) -{ - struct lino_undo *top = l->undo_stack; - if (top == 0) - return; - l->undo_stack = top->next; - free(top->data); - top->data = 0; - free(top); -} - static void restore_undo(lino_t *l) { - struct lino_undo *top = l->undo_stack; - - if (top == 0) - return; - - if (top->hist_index >= l->history_len - 1) { - undo_pop(l); - restore_undo(l); - return; - } + struct lino_undo **ptop = &l->undo_stack; - strcpy(l->data, top->data); - l->dlen = strlen(top->data); - l->dpos = top->dpos; - l->history_index = top->hist_index; + while (*ptop) { + struct lino_undo *top = *ptop; + int hidx = top->hist_index; - { - int history_pos = l->history_len - 1 - l->history_index; + if (hidx == INT_MAX || hidx == l->history_index) { + strcpy(l->data, top->data); + l->dlen = strlen(top->data); + l->dpos = top->dpos; + l->need_refresh = 1; - if (history_pos >= 0 && history_pos < l->history_len) { - free(l->history[history_pos]); - l->history[history_pos] = chk_strdup_utf8(l->data); + if (hidx == l->history_index) { + int history_pos = l->history_len - 1 - l->history_index; + free(l->history[history_pos]); + l->history[history_pos] = chk_strdup_utf8(l->data); + } + delete_undo(ptop); + break; + } else if (hidx >= l->history_len - 1) { + delete_undo(ptop); + } else { + ptop = &top->next; } } +} - l->need_refresh = 1; - - undo_pop(l); +static void undo_subst_hist_idx(lino_t *l, int from_hist, int to_hist) +{ + struct lino_undo *iter; + for (iter = l->undo_stack; iter != 0; iter = iter->next) { + if (iter->hist_index == from_hist) + iter->hist_index = to_hist; + } } -static void renumber_undo_hist(lino_t *l, int delta) +static void undo_renumber_hist_idx(lino_t *l, int delta) { struct lino_undo *iter; - for (iter = l->undo_stack; iter != 0; iter = iter->next) + for (iter = l->undo_stack; iter != 0; iter = iter->next) { + assert (iter->hist_index != INT_MAX); iter->hist_index += delta; + } } /* ============================== Completion ================================ */ @@ -1206,8 +1208,9 @@ static void edit_move_end(lino_t *l) { #define LINENOISE_HISTORY_NEXT 0 #define LINENOISE_HISTORY_PREV 1 static void edit_history_next(lino_t *l, int dir) { - record_undo(l); clear_sel(l); + undo_subst_hist_idx(l, INT_MAX, l->history_index); + if (l->history_len > 1) { /* Update the current history entry before to * overwrite it with the next one. */ @@ -1573,7 +1576,6 @@ static int edit(lino_t *l, const char *prompt) edit_move_end(l); if (l->need_refresh) refresh_line(l); - record_undo(l); ret = l->len; goto out; case CTL('C'): @@ -1770,7 +1772,8 @@ out: l->history_len--; free(l->history[l->history_len]); l->history[l->history_len] = 0; - renumber_undo_hist(l, -1); + undo_subst_hist_idx(l, INT_MAX, 0); + undo_renumber_hist_idx(l, -1); } return ret; } @@ -1911,7 +1914,7 @@ static void lino_cleanup(lino_t *ls) { disable_raw_mode(ls); free_hist(ls); - free_undo(ls); + free_undo_stack(ls); free(ls->clip); ls->clip = 0; } @@ -2001,7 +2004,7 @@ int lino_hist_add(lino_t *ls, const char *line) { } ls->history[ls->history_len] = linecopy; ls->history_len++; - renumber_undo_hist(ls, 1); + undo_renumber_hist_idx(ls, 1); return 1; } @@ -33821,31 +33821,40 @@ when written out to the file. Conversely, when the edited file is read back, its newlines are converted to carriage returns, so that multi-line content is handled properly. (See the following section, Multi-Line Mode). -.NP* Undo +.NP* Undo Editing -The listener provides an undo feature. The Ctrl-O editing command will -restore the edit buffer contents and cursor position to the state in which -it was before a previous edit, or previous history navigation. +The listener provides an undo feature. The Ctrl-O command ("old", "oops") +restores the edit buffer contents and cursor position to a previous state. -Undo history is retained between lines. That is, after a line is submitted -with Enter, it is still possible to undo previous edits. Moreover, if a line -is canceled with Ctrl-C, such that it is not recorded in the recall history, it -is still available from the undo history. +There is a single undo history which records up the 200 most recent edit +states. However, the states are associated with history lines, so that it +appears that that undo history has its own, independent undo history. +Undoing the edits in one line has no effect on the undo history of another +line. + +Undo also records edits for lines that has been canceled with Ctrl-C, and are +not entered into the history, making it possible to recall canceled lines. + +The undo history is lost when \*(TX terminates. -Undo is limited to 32 states. Furthermore, the undo history is lost -when \*(TX terminates. +Undo doesn't save and restore previous contents of the clipboard buffer. -Undo doesn't restore previous contents of the clipboard buffer. +There is no redo. When undo removes an edit to restore to a prior edit state, +the removed edit is permanently discarded. -Undo will restore edits made to history lines. It does so unconditionally, -which means that it can introduce edits in the following situation. -When a history line is edited and then sumbitted without navigating to -a different history line, the edit isn't permanent. However, when the -edits are retraced via undo, the restored states -.I are -stored in the history. +Note that if undo is invoked on a historic line, each undo step updates that +history entry instantly to the restored state. This is in contrast +to the way new edits work. New edits are not committed to history until +navigation takes place to a different history line. -There is no redo; undoing is permanent. +Also note that when new edits are performed on a historic line and it is +submitted with Enter without navigating to another line, the undo information +for those edits is retained, and belongs to the newly submitted line. The +historic line hasn't actually been modified, and so it has no new undo +information. However, if a historic line is edited, and then navigation takes +place to a different historic line, then the undo information is committed to +that line, because the modifications to the line have been placed back +in the history entry. .SS* Visual Selection Mode |