1 files changed, 606 insertions, 189 deletions

diff --git a/editors/vi.c b/editors/vi.c
index ab49b3f7d..a6505e0bf 100644
--- a/editors/vi.c
+++ b/editors/vi.c
@@ -17,7 +17,6 @@
  *      it would be easier to change the mark when add/delete lines
  *      More intelligence in refresh()
  *      ":r !cmd"  and  "!cmd"  to filter text through an external command
- *      A true "undo" facility
  *      An "ex" line oriented mode- maybe using "cmdedit"
  */
 
@@ -136,6 +135,36 @@
 //config:         cursor position using "ESC [ 6 n" escape sequence, then read stdin.
 //config:
 //config:         This is not clean but helps a lot on serial lines and such.
+//config:config FEATURE_VI_UNDO
+//config:       bool "Support undo command 'u'"
+//config:       default y
+//config:       depends on VI
+//config:       help
+//config:         Support the 'u' command to undo insertion, deletion, and replacement
+//config:         of text.
+//config:config FEATURE_VI_UNDO_QUEUE
+//config:       bool "Enable undo operation queuing"
+//config:       default y
+//config:       depends on FEATURE_VI_UNDO
+//config:       help
+//config:         The vi undo functions can use an intermediate queue to greatly lower
+//config:         malloc() calls and overhead. When the maximum size of this queue is
+//config:         reached, the contents of the queue are committed to the undo stack.
+//config:         This increases the size of the undo code and allows some undo
+//config:         operations (especially un-typing/backspacing) to be far more useful.
+//config:config FEATURE_VI_UNDO_QUEUE_MAX
+//config:       int "Maximum undo character queue size"
+//config:       default 256
+//config:       range 32 65536
+//config:       depends on FEATURE_VI_UNDO_QUEUE
+//config:       help
+//config:         This option sets the number of bytes used at runtime for the queue.
+//config:         Smaller values will create more undo objects and reduce the amount
+//config:         of typed or backspaced characters that are grouped into one undo
+//config:         operation; larger values increase the potential size of each undo
+//config:         and will generally malloc() larger objects and less frequently.
+//config:         Unless you want more (or less) frequent "undo points" while typing,
+//config:         you should probably leave this unchanged.
 
 //applet:IF_VI(APPLET(vi, BB_DIR_BIN, BB_SUID_DROP))
 
@@ -277,8 +306,8 @@ struct globals {
         smallint editing;        // >0 while we are editing a file
                                  // [code audit says "can be 0, 1 or 2 only"]
         smallint cmd_mode;       // 0=command  1=insert 2=replace
-        int file_modified;       // buffer contents changed (counter, not flag!)
-        int last_file_modified;  // = -1;
+        int modified_count;      // buffer contents changed if !0
+        int last_modified_count; // = -1;
         int save_argc;           // how many file names on cmd line
         int cmdcnt;              // repetition count
         unsigned rows, columns;  // the terminal screen is this size
@@ -347,6 +376,42 @@ struct globals {
         char get_input_line__buf[MAX_INPUT_LEN]; /* former static */
 
         char scr_out_buf[MAX_SCR_COLS + MAX_TABSTOP * 2];
+#if ENABLE_FEATURE_VI_UNDO
+// undo_push() operations
+#define UNDO_INS         0
+#define UNDO_DEL         1
+#define UNDO_INS_CHAIN   2
+#define UNDO_DEL_CHAIN   3
+// UNDO_*_QUEUED must be equal to UNDO_xxx ORed with UNDO_QUEUED_FLAG
+#define UNDO_QUEUED_FLAG 4
+#define UNDO_INS_QUEUED  4
+#define UNDO_DEL_QUEUED  5
+#define UNDO_USE_SPOS   32
+#define UNDO_EMPTY      64
+// Pass-through flags for functions that can be undone
+#define NO_UNDO          0
+#define ALLOW_UNDO       1
+#define ALLOW_UNDO_CHAIN 2
+# if ENABLE_FEATURE_VI_UNDO_QUEUE
+#define ALLOW_UNDO_QUEUED 3
+        char undo_queue_state;
+        int undo_q;
+        char *undo_queue_spos;  // Start position of queued operation
+        char undo_queue[CONFIG_FEATURE_VI_UNDO_QUEUE_MAX];
+# else
+// If undo queuing disabled, don't invoke the missing queue logic
+#define ALLOW_UNDO_QUEUED 1
+# endif
+
+        struct undo_object {
+                struct undo_object *prev;       // Linking back avoids list traversal (LIFO)
+                int start;              // Offset where the data should be restored/deleted
+                int length;             // total data size
+                uint8_t u_type;         // 0=deleted, 1=inserted, 2=swapped
+                char undo_text[1];      // text that was deleted (if deletion)
+        } *undo_stack_tail;
+#endif /* ENABLE_FEATURE_VI_UNDO */
+
 };
 #define G (*ptr_to_globals)
 #define text           (G.text          )
@@ -358,8 +423,8 @@ struct globals {
 #define vi_setops               (G.vi_setops          )
 #define editing                 (G.editing            )
 #define cmd_mode                (G.cmd_mode           )
-#define file_modified           (G.file_modified      )
-#define last_file_modified      (G.last_file_modified )
+#define modified_count          (G.modified_count     )
+#define last_modified_count     (G.last_modified_count)
 #define save_argc               (G.save_argc          )
 #define cmdcnt                  (G.cmdcnt             )
 #define rows                    (G.rows               )
@@ -408,15 +473,24 @@ struct globals {
 #define last_modifying_cmd  (G.last_modifying_cmd )
 #define get_input_line__buf (G.get_input_line__buf)
 
+#if ENABLE_FEATURE_VI_UNDO
+#define undo_stack_tail  (G.undo_stack_tail )
+# if ENABLE_FEATURE_VI_UNDO_QUEUE
+#define undo_queue_state (G.undo_queue_state)
+#define undo_q           (G.undo_q          )
+#define undo_queue       (G.undo_queue      )
+#define undo_queue_spos  (G.undo_queue_spos )
+# endif
+#endif
+
 #define INIT_G() do { \
         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
-        last_file_modified = -1; \
+        last_modified_count = -1; \
         /* "" but has space for 2 chars: */ \
         IF_FEATURE_VI_SEARCH(last_search_pattern = xzalloc(2);) \
 } while (0)
 
 
-static int init_text_buffer(char *); // init from file or create new
 static void edit_file(char *);  // edit one file
 static void do_cmd(int);        // execute a command
 static int next_tabstop(int);
@@ -437,10 +511,12 @@ static void dot_next(void);	// move dot to next line B-o-l
 static void dot_prev(void);     // move dot to prev line B-o-l
 static void dot_scroll(int, int);       // move the screen up or down
 static void dot_skip_over_ws(void);     // move dot pat WS
-static void dot_delete(void);   // delete the char at 'dot'
 static char *bound_dot(char *); // make sure  text[0] <= P < "end"
 static char *new_screen(int, int);      // malloc virtual screen memory
-static char *char_insert(char *, char); // insert the char c at 'p'
+#if !ENABLE_FEATURE_VI_UNDO
+#define char_insert(a,b,c) char_insert(a,b)
+#endif
+static char *char_insert(char *, char, int);    // insert the char c at 'p'
 // might reallocate text[]! use p += stupid_insert(p, ...),
 // and be careful to not use pointers into potentially freed text[]!
 static uintptr_t stupid_insert(char *, char);   // stupidly insert the char c at 'p'
@@ -448,11 +524,17 @@ static int find_range(char **, char **, char);	// return pointers for an object
 static int st_test(char *, int, int, char *);   // helper for skip_thing()
 static char *skip_thing(char *, int, int, int); // skip some object
 static char *find_pair(char *, char);   // find matching pair ()  []  {}
-static char *text_hole_delete(char *, char *);  // at "p", delete a 'size' byte hole
+#if !ENABLE_FEATURE_VI_UNDO
+#define text_hole_delete(a,b,c) text_hole_delete(a,b)
+#endif
+static char *text_hole_delete(char *, char *, int);     // at "p", delete a 'size' byte hole
 // might reallocate text[]! use p += text_hole_make(p, ...),
 // and be careful to not use pointers into potentially freed text[]!
 static uintptr_t text_hole_make(char *, int);   // at "p", make a 'size' byte hole
-static char *yank_delete(char *, char *, int, int);     // yank text[] into register then delete
+#if !ENABLE_FEATURE_VI_UNDO
+#define yank_delete(a,b,c,d,e) yank_delete(a,b,c,d)
+#endif
+static char *yank_delete(char *, char *, int, int, int);        // yank text[] into register then delete
 static void show_help(void);    // display some help info
 static void rawmode(void);      // set "raw" mode on tty
 static void cookmode(void);     // return to "cooked" mode on tty
@@ -460,7 +542,6 @@ static void cookmode(void);	// return to "cooked" mode on tty
 static int mysleep(int);
 static int readit(void);        // read (maybe cursor) key from stdin
 static int get_one_char(void);  // read 1 char from stdin
-static int file_size(const char *);   // what is the byte size of "fn"
 #if !ENABLE_FEATURE_VI_READONLY
 #define file_insert(fn, p, update_ro_status) file_insert(fn, p)
 #endif
@@ -495,8 +576,8 @@ static char *char_search(char *, const char *, int, int);	// search for pattern
 #if ENABLE_FEATURE_VI_COLON
 static char *get_one_address(char *, int *);    // get colon addr, if present
 static char *get_address(char *, int *, int *); // get two colon addrs, if present
-static void colon(char *);      // execute the "colon" mode cmds
 #endif
+static void colon(char *);      // execute the "colon" mode cmds
 #if ENABLE_FEATURE_VI_USE_SIGNALS
 static void winch_sig(int);     // catch window size changes
 static void suspend_sig(int);   // catch ctrl-Z
@@ -514,20 +595,36 @@ static void showmatching(char *);	// show the matching pair ()  []  {}
 #if ENABLE_FEATURE_VI_YANKMARK || (ENABLE_FEATURE_VI_COLON && ENABLE_FEATURE_VI_SEARCH) || ENABLE_FEATURE_VI_CRASHME
 // might reallocate text[]! use p += string_insert(p, ...),
 // and be careful to not use pointers into potentially freed text[]!
-static uintptr_t string_insert(char *, const char *);   // insert the string at 'p'
+# if !ENABLE_FEATURE_VI_UNDO
+#define string_insert(a,b,c) string_insert(a,b)
+# endif
+static uintptr_t string_insert(char *, const char *, int);      // insert the string at 'p'
 #endif
 #if ENABLE_FEATURE_VI_YANKMARK
 static char *text_yank(char *, char *, int);    // save copy of "p" into a register
 static char what_reg(void);             // what is letter of current YDreg
 static void check_context(char);        // remember context for '' command
 #endif
+#if ENABLE_FEATURE_VI_UNDO
+static void flush_undo_data(void);
+static void undo_push(char *, unsigned int, unsigned char);     // Push an operation on the undo stack
+static void undo_pop(void);     // Undo the last operation
+# if ENABLE_FEATURE_VI_UNDO_QUEUE
+static void undo_queue_commit(void);    // Flush any queued objects to the undo stack
+# else
+# define undo_queue_commit() ((void)0)
+# endif
+#else
+#define flush_undo_data()   ((void)0)
+#define undo_queue_commit() ((void)0)
+#endif
+
 #if ENABLE_FEATURE_VI_CRASHME
 static void crash_dummy();
 static void crash_test();
 static int crashme = 0;
 #endif
 
-
 static void write1(const char *out)
 {
         fputs(out, stdout);
@@ -540,6 +637,14 @@ int vi_main(int argc, char **argv)
 
         INIT_G();
 
+#if ENABLE_FEATURE_VI_UNDO
+        /* undo_stack_tail = NULL; - already is */
+#if ENABLE_FEATURE_VI_UNDO_QUEUE
+        undo_queue_state = UNDO_EMPTY;
+        /* undo_q = 0; - already is  */
+#endif
+#endif
+
 #if ENABLE_FEATURE_VI_USE_SIGNALS || ENABLE_FEATURE_VI_CRASHME
         my_pid = getpid();
 #endif
@@ -618,30 +723,29 @@ int vi_main(int argc, char **argv)
 static int init_text_buffer(char *fn)
 {
         int rc;
-        int size = file_size(fn);       // file size. -1 means does not exist.
+
+        flush_undo_data();
+        modified_count = 0;
+        last_modified_count = -1;
+#if ENABLE_FEATURE_VI_YANKMARK
+        /* init the marks */
+        memset(mark, 0, sizeof(mark));
+#endif
 
         /* allocate/reallocate text buffer */
         free(text);
-        text_size = size + 10240;
+        text_size = 10240;
         screenbegin = dot = end = text = xzalloc(text_size);
 
         if (fn != current_filename) {
                 free(current_filename);
                 current_filename = xstrdup(fn);
         }
-        if (size < 0) {
-                // file dont exist. Start empty buf with dummy line
-                char_insert(text, '\n');
-                rc = 0;
-        } else {
-                rc = file_insert(fn, text, 1);
+        rc = file_insert(fn, text, 1);
+        if (rc < 0) {
+                // file doesnt exist. Start empty buf with dummy line
+                char_insert(text, '\n', NO_UNDO);
         }
-        file_modified = 0;
-        last_file_modified = -1;
-#if ENABLE_FEATURE_VI_YANKMARK
-        /* init the marks. */
-        memset(mark, 0, sizeof(mark));
-#endif
         return rc;
 }
 
@@ -756,7 +860,7 @@ static void edit_file(char *fn)
                                 crash_dummy();  // generate a random command
                         } else {
                                 crashme = 0;
-                                string_insert(text, "\n\n#####  Ran out of text to work on.  #####\n\n"); // insert the string
+                                string_insert(text, "\n\n#####  Ran out of text to work on.  #####\n\n", NO_UNDO); // insert the string
                                 dot = text;
                                 refresh(FALSE);
                         }
@@ -909,13 +1013,71 @@ static void setops(const char *args, const char *opname, int flg_no,
 }
 #endif
 
+#endif /* FEATURE_VI_COLON */
+
 // buf must be no longer than MAX_INPUT_LEN!
 static void colon(char *buf)
 {
+#if !ENABLE_FEATURE_VI_COLON
+        /* Simple ":cmd" handler with minimal set of commands */
+        char *p = buf;
+        int cnt;
+
+        if (*p == ':')
+                p++;
+        cnt = strlen(p);
+        if (cnt == 0)
+                return;
+        if (strncmp(p, "quit", cnt) == 0
+         || strncmp(p, "q!", cnt) == 0
+        ) {
+                if (modified_count && p[1] != '!') {
+                        status_line_bold("No write since last change (:%s! overrides)", p);
+                } else {
+                        editing = 0;
+                }
+                return;
+        }
+        if (strncmp(p, "write", cnt) == 0
+         || strncmp(p, "wq", cnt) == 0
+         || strncmp(p, "wn", cnt) == 0
+         || (p[0] == 'x' && !p[1])
+        ) {
+                cnt = file_write(current_filename, text, end - 1);
+                if (cnt < 0) {
+                        if (cnt == -1)
+                                status_line_bold("Write error: %s", strerror(errno));
+                } else {
+                        modified_count = 0;
+                        last_modified_count = -1;
+                        status_line("'%s' %dL, %dC",
+                                current_filename,
+                                count_lines(text, end - 1), cnt
+                        );
+                        if (p[0] == 'x' || p[1] == 'q' || p[1] == 'n'
+                         || p[0] == 'X' || p[1] == 'Q' || p[1] == 'N'
+                        ) {
+                                editing = 0;
+                        }
+                }
+                return;
+        }
+        if (strncmp(p, "file", cnt) == 0) {
+                last_status_cksum = 0;  // force status update
+                return;
+        }
+        if (sscanf(p, "%d", &cnt) > 0) {
+                dot = find_line(cnt);
+                dot_skip_over_ws();
+                return;
+        }
+        not_implemented(p);
+#else
+
         char c, *orig_buf, *buf1, *q, *r;
         char *fn, cmd[MAX_INPUT_LEN], args[MAX_INPUT_LEN];
-        int i, l, li, ch, b, e;
-        int useforce, forced = FALSE;
+        int i, l, li, b, e;
+        int useforce;
 
         // :3154        // if (-e line 3154) goto it  else stay put
         // :4,33w! foo  // write a portion of buffer to file "foo"
@@ -937,7 +1099,7 @@ static void colon(char *buf)
         if (*buf == ':')
                 buf++;                  // move past the ':'
 
-        li = ch = i = 0;
+        li = i = 0;
         b = e = -1;
         q = text;                       // assume 1,$ for the range
         r = end - 1;
@@ -1015,11 +1177,13 @@ static void colon(char *buf)
                         q = begin_line(dot);    // assume .,. for the range
                         r = end_line(dot);
                 }
-                dot = yank_delete(q, r, 1, YANKDEL);    // save, then delete lines
+                dot = yank_delete(q, r, 1, YANKDEL, ALLOW_UNDO);        // save, then delete lines
                 dot_skip_over_ws();
         } else if (strncmp(cmd, "edit", i) == 0) {      // Edit a file
+                int size;
+
                 // don't edit, if the current file has been modified
-                if (file_modified && !useforce) {
+                if (modified_count && !useforce) {
                         status_line_bold("No write since last change (:%s! overrides)", cmd);
                         goto ret;
                 }
@@ -1035,8 +1199,7 @@ static void colon(char *buf)
                         goto ret;
                 }
 
-                if (init_text_buffer(fn) < 0)
-                        goto ret;
+                size = init_text_buffer(fn);
 
 #if ENABLE_FEATURE_VI_YANKMARK
                 if (Ureg >= 0 && Ureg < 28) {
@@ -1052,12 +1215,14 @@ static void colon(char *buf)
                 li = count_lines(text, end - 1);
                 status_line("'%s'%s"
                         IF_FEATURE_VI_READONLY("%s")
-                        " %dL, %dC", current_filename,
-                        (file_size(fn) < 0 ? " [New file]" : ""),
+                        " %dL, %dC",
+                        current_filename,
+                        (size < 0 ? " [New file]" : ""),
                         IF_FEATURE_VI_READONLY(
                                 ((readonly_mode) ? " [Readonly]" : ""),
                         )
-                        li, ch);
+                        li, (int)(end - text)
+                );
         } else if (strncmp(cmd, "file", i) == 0) {      // what File is this
                 if (b != -1 || e != -1) {
                         status_line_bold("No address allowed on this command");
@@ -1122,7 +1287,7 @@ static void colon(char *buf)
                         goto ret;
                 }
                 // don't exit if the file been modified
-                if (file_modified) {
+                if (modified_count) {
                         status_line_bold("No write since last change (:%s! overrides)", cmd);
                         goto ret;
                 }
@@ -1146,6 +1311,8 @@ static void colon(char *buf)
                 }
                 editing = 0;
         } else if (strncmp(cmd, "read", i) == 0) {      // read file into text[]
+                int size;
+
                 fn = args;
                 if (!fn[0]) {
                         status_line_bold("No filename given");
@@ -1159,26 +1326,27 @@ static void colon(char *buf)
                         q = next_line(q);
                 { // dance around potentially-reallocated text[]
                         uintptr_t ofs = q - text;
-                        ch = file_insert(fn, q, 0);
+                        size = file_insert(fn, q, /*update_ro:*/ 0);
                         q = text + ofs;
                 }
-                if (ch < 0)
+                if (size < 0)
                         goto ret;       // nothing was inserted
                 // how many lines in text[]?
-                li = count_lines(q, q + ch - 1);
+                li = count_lines(q, q + size - 1);
                 status_line("'%s'"
                         IF_FEATURE_VI_READONLY("%s")
-                        " %dL, %dC", fn,
+                        " %dL, %dC",
+                        fn,
                         IF_FEATURE_VI_READONLY((readonly_mode ? " [Readonly]" : ""),)
-                        li, ch);
-                if (ch > 0) {
+                        li, size
+                );
+                if (size > 0) {
                         // if the insert is before "dot" then we need to update
                         if (q <= dot)
-                                dot += ch;
-                        /*file_modified++; - done by file_insert */
+                                dot += size;
                 }
         } else if (strncmp(cmd, "rewind", i) == 0) {    // rewind cmd line args
-                if (file_modified && !useforce) {
+                if (modified_count && !useforce) {
                         status_line_bold("No write since last change (:%s! overrides)", cmd);
                 } else {
                         // reset the filenames to edit
@@ -1235,6 +1403,9 @@ static void colon(char *buf)
                 char *F, *R, *flags;
                 size_t len_F, len_R;
                 int gflag;              // global replace flag
+#if ENABLE_FEATURE_VI_UNDO
+                int dont_chain_first_item = ALLOW_UNDO;
+#endif
 
                 // F points to the "find" pattern
                 // R points to the "replace" pattern
@@ -1269,9 +1440,13 @@ static void colon(char *buf)
                         if (found) {
                                 uintptr_t bias;
                                 // we found the "find" pattern - delete it
-                                text_hole_delete(found, found + len_F - 1);
-                                // inset the "replace" patern
-                                bias = string_insert(found, R); // insert the string
+                                // For undo support, the first item should not be chained
+                                text_hole_delete(found, found + len_F - 1, dont_chain_first_item);
+#if ENABLE_FEATURE_VI_UNDO
+                                dont_chain_first_item = ALLOW_UNDO_CHAIN;
+#endif
+                                // insert the "replace" patern
+                                bias = string_insert(found, R, ALLOW_UNDO_CHAIN);
                                 found += bias;
                                 ls += bias;
                                 /*q += bias; - recalculated anyway */
@@ -1293,6 +1468,9 @@ static void colon(char *buf)
                 || strncmp(cmd, "wn", i) == 0
                 || (cmd[0] == 'x' && !cmd[1])
         ) {
+                int size;
+                //int forced = FALSE;
+
                 // is there a file name to write to?
                 if (args[0]) {
                         fn = args;
@@ -1305,34 +1483,33 @@ static void colon(char *buf)
 #endif
                 // how many lines in text[]?
                 li = count_lines(q, r);
-                ch = r - q + 1;
-                // see if file exists- if not, its just a new file request
-                if (useforce) {
+                size = r - q + 1;
+                //if (useforce) {
                         // if "fn" is not write-able, chmod u+w
                         // sprintf(syscmd, "chmod u+w %s", fn);
                         // system(syscmd);
-                        forced = TRUE;
-                }
+                        // forced = TRUE;
+                //}
                 l = file_write(fn, q, r);
-                if (useforce && forced) {
+                //if (useforce && forced) {
                         // chmod u-w
                         // sprintf(syscmd, "chmod u-w %s", fn);
                         // system(syscmd);
-                        forced = FALSE;
-                }
+                        // forced = FALSE;
+                //}
                 if (l < 0) {
                         if (l == -1)
                                 status_line_bold_errno(fn);
                 } else {
                         status_line("'%s' %dL, %dC", fn, li, l);
-                        if (q == text && r == end - 1 && l == ch) {
-                                file_modified = 0;
-                                last_file_modified = -1;
+                        if (q == text && r == end - 1 && l == size) {
+                                modified_count = 0;
+                                last_modified_count = -1;
                         }
                         if ((cmd[0] == 'x' || cmd[1] == 'q' || cmd[1] == 'n'
                             || cmd[0] == 'X' || cmd[1] == 'Q' || cmd[1] == 'N'
                             )
-                         && l == ch
+                         && l == size
                         ) {
                                 editing = 0;
                         }
@@ -1359,9 +1536,8 @@ static void colon(char *buf)
  colon_s_fail:
         status_line(":s expression missing delimiters");
 #endif
-}
-
 #endif /* FEATURE_VI_COLON */
+}
 
 static void Hit_Return(void)
 {
@@ -1572,23 +1748,27 @@ static char *find_line(int li)	// find begining of line #li
 //----- Dot Movement Routines ----------------------------------
 static void dot_left(void)
 {
+        undo_queue_commit();
         if (dot > text && dot[-1] != '\n')
                 dot--;
 }
 
 static void dot_right(void)
 {
+        undo_queue_commit();
         if (dot < end - 1 && *dot != '\n')
                 dot++;
 }
 
 static void dot_begin(void)
 {
+        undo_queue_commit();
         dot = begin_line(dot);  // return pointer to first char cur line
 }
 
 static void dot_end(void)
 {
+        undo_queue_commit();
         dot = end_line(dot);    // return pointer to last char cur line
 }
 
@@ -1614,11 +1794,13 @@ static char *move_to_col(char *p, int l)
 
 static void dot_next(void)
 {
+        undo_queue_commit();
         dot = next_line(dot);
 }
 
 static void dot_prev(void)
 {
+        undo_queue_commit();
         dot = prev_line(dot);
 }
 
@@ -1626,6 +1808,7 @@ static void dot_scroll(int cnt, int dir)
 {
         char *q;
 
+        undo_queue_commit();
         for (; cnt > 0; cnt--) {
                 if (dir < 0) {
                         // scroll Backwards
@@ -1653,11 +1836,6 @@ static void dot_skip_over_ws(void)
                 dot++;
 }
 
-static void dot_delete(void)    // delete the char at 'dot'
-{
-        text_hole_delete(dot, dot);
-}
-
 static char *bound_dot(char *p) // make sure  text[0] <= P < "end"
 {
         if (p >= end && end > text) {
@@ -1804,17 +1982,34 @@ static char *char_search(char *p, const char *pat, int dir, int range)
 
 #endif /* FEATURE_VI_SEARCH */
 
-static char *char_insert(char *p, char c) // insert the char c at 'p'
+static char *char_insert(char *p, char c, int undo) // insert the char c at 'p'
 {
         if (c == 22) {          // Is this an ctrl-V?
                 p += stupid_insert(p, '^');     // use ^ to indicate literal next
                 refresh(FALSE); // show the ^
                 c = get_one_char();
                 *p = c;
+#if ENABLE_FEATURE_VI_UNDO
+                switch (undo) {
+                        case ALLOW_UNDO:
+                                undo_push(p, 1, UNDO_INS);
+                                break;
+                        case ALLOW_UNDO_CHAIN:
+                                undo_push(p, 1, UNDO_INS_CHAIN);
+                                break;
+# if ENABLE_FEATURE_VI_UNDO_QUEUE
+                        case ALLOW_UNDO_QUEUED:
+                                undo_push(p, 1, UNDO_INS_QUEUED);
+                                break;
+# endif
+                }
+#else
+                modified_count++;
+#endif /* ENABLE_FEATURE_VI_UNDO */
                 p++;
-                file_modified++;
         } else if (c == 27) {   // Is this an ESC?
                 cmd_mode = 0;
+                undo_queue_commit();
                 cmdcnt = 0;
                 end_cmd_q();    // stop adding to q
                 last_status_cksum = 0;  // force status update
@@ -1825,7 +2020,7 @@ static char *char_insert(char *p, char c) // insert the char c at 'p'
                 //     123456789
                 if ((p[-1] != '\n') && (dot>text)) {
                         p--;
-                        p = text_hole_delete(p, p);     // shrink buffer 1 char
+                        p = text_hole_delete(p, p, ALLOW_UNDO_QUEUED);  // shrink buffer 1 char
                 }
         } else {
 #if ENABLE_FEATURE_VI_SETOPTS
@@ -1838,6 +2033,27 @@ static char *char_insert(char *p, char c) // insert the char c at 'p'
 #if ENABLE_FEATURE_VI_SETOPTS
                 sp = p;                 // remember addr of insert
 #endif
+#if ENABLE_FEATURE_VI_UNDO
+# if ENABLE_FEATURE_VI_UNDO_QUEUE
+                if (c == '\n')
+                        undo_queue_commit();
+# endif
+                switch (undo) {
+                        case ALLOW_UNDO:
+                                undo_push(p, 1, UNDO_INS);
+                                break;
+                        case ALLOW_UNDO_CHAIN:
+                                undo_push(p, 1, UNDO_INS_CHAIN);
+                                break;
+# if ENABLE_FEATURE_VI_UNDO_QUEUE
+                        case ALLOW_UNDO_QUEUED:
+                                undo_push(p, 1, UNDO_INS_QUEUED);
+                                break;
+# endif
+                }
+#else
+                modified_count++;
+#endif /* ENABLE_FEATURE_VI_UNDO */
                 p += 1 + stupid_insert(p, c);   // insert the char
 #if ENABLE_FEATURE_VI_SETOPTS
                 if (showmatch && strchr(")]}", *sp) != NULL) {
@@ -1853,6 +2069,9 @@ static char *char_insert(char *p, char c) // insert the char c at 'p'
                                 bias = text_hole_make(p, len);
                                 p += bias;
                                 q += bias;
+#if ENABLE_FEATURE_VI_UNDO
+                                undo_push(p, len, UNDO_INS);
+#endif
                                 memcpy(p, q, len);
                                 p += len;
                         }
@@ -1870,7 +2089,6 @@ static uintptr_t stupid_insert(char *p, char c) // stupidly insert the char c at
         bias = text_hole_make(p, 1);
         p += bias;
         *p = c;
-        //file_modified++; - done by text_hole_make()
         return bias;
 }
 
@@ -2051,6 +2269,199 @@ static void showmatching(char *p)
 }
 #endif /* FEATURE_VI_SETOPTS */
 
+#if ENABLE_FEATURE_VI_UNDO
+static void flush_undo_data(void)
+{
+        struct undo_object *undo_entry;
+
+        while (undo_stack_tail) {
+                undo_entry = undo_stack_tail;
+                undo_stack_tail = undo_entry->prev;
+                free(undo_entry);
+        }
+}
+
+// Undo functions and hooks added by Jody Bruchon (jody@jodybruchon.com)
+static void undo_push(char *src, unsigned int length, uint8_t u_type)   // Add to the undo stack
+{
+        struct undo_object *undo_entry;
+
+        // "u_type" values
+        // UNDO_INS: insertion, undo will remove from buffer
+        // UNDO_DEL: deleted text, undo will restore to buffer
+        // UNDO_{INS,DEL}_CHAIN: Same as above but also calls undo_pop() when complete
+        // The CHAIN operations are for handling multiple operations that the user
+        // performs with a single action, i.e. REPLACE mode or find-and-replace commands
+        // UNDO_{INS,DEL}_QUEUED: If queuing feature is enabled, allow use of the queue
+        // for the INS/DEL operation. The raw values should be equal to the values of
+        // UNDO_{INS,DEL} ORed with UNDO_QUEUED_FLAG
+
+#if ENABLE_FEATURE_VI_UNDO_QUEUE
+        // This undo queuing functionality groups multiple character typing or backspaces
+        // into a single large undo object. This greatly reduces calls to malloc() for
+        // single-character operations while typing and has the side benefit of letting
+        // an undo operation remove chunks of text rather than a single character.
+        switch (u_type) {
+        case UNDO_EMPTY:        // Just in case this ever happens...
+                return;
+        case UNDO_DEL_QUEUED:
+                if (length != 1)
+                        return; // Only queue single characters
+                switch (undo_queue_state) {
+                case UNDO_EMPTY:
+                        undo_queue_state = UNDO_DEL;
+                case UNDO_DEL:
+                        undo_queue_spos = src;
+                        undo_q++;
+                        undo_queue[CONFIG_FEATURE_VI_UNDO_QUEUE_MAX - undo_q] = *src;
+                        // If queue is full, dump it into an object
+                        if (undo_q == CONFIG_FEATURE_VI_UNDO_QUEUE_MAX)
+                                undo_queue_commit();
+                        return;
+                case UNDO_INS:
+                        // Switch from storing inserted text to deleted text
+                        undo_queue_commit();
+                        undo_push(src, length, UNDO_DEL_QUEUED);
+                        return;
+                }
+                break;
+        case UNDO_INS_QUEUED:
+                if (length != 1)
+                        return;
+                switch (undo_queue_state) {
+                case UNDO_EMPTY:
+                        undo_queue_state = UNDO_INS;
+                        undo_queue_spos = src;
+                case UNDO_INS:
+                        undo_q++;       // Don't need to save any data for insertions
+                        if (undo_q == CONFIG_FEATURE_VI_UNDO_QUEUE_MAX)
+                                undo_queue_commit();
+                        return;
+                case UNDO_DEL:
+                        // Switch from storing deleted text to inserted text
+                        undo_queue_commit();
+                        undo_push(src, length, UNDO_INS_QUEUED);
+                        return;
+                }
+                break;
+        }
+#else
+        // If undo queuing is disabled, ignore the queuing flag entirely
+        u_type = u_type & ~UNDO_QUEUED_FLAG;
+#endif
+
+        // Allocate a new undo object
+        if (u_type == UNDO_DEL || u_type == UNDO_DEL_CHAIN) {
+                // For UNDO_DEL objects, save deleted text
+                if ((src + length) == end)
+                        length--;
+                // If this deletion empties text[], strip the newline. When the buffer becomes
+                // zero-length, a newline is added back, which requires this to compensate.
+                undo_entry = xzalloc(offsetof(struct undo_object, undo_text) + length);
+                memcpy(undo_entry->undo_text, src, length);
+        } else {
+                undo_entry = xzalloc(sizeof(*undo_entry));
+        }
+        undo_entry->length = length;
+#if ENABLE_FEATURE_VI_UNDO_QUEUE
+        if ((u_type & UNDO_USE_SPOS) != 0) {
+                undo_entry->start = undo_queue_spos - text;     // use start position from queue
+        } else {
+                undo_entry->start = src - text; // use offset from start of text buffer
+        }
+        u_type = (u_type & ~UNDO_USE_SPOS);
+#else
+        undo_entry->start = src - text;
+#endif
+        undo_entry->u_type = u_type;
+
+        // Push it on undo stack
+        undo_entry->prev = undo_stack_tail;
+        undo_stack_tail = undo_entry;
+        modified_count++;
+}
+
+static void undo_pop(void)      // Undo the last operation
+{
+        int repeat;
+        char *u_start, *u_end;
+        struct undo_object *undo_entry;
+
+        // Commit pending undo queue before popping (should be unnecessary)
+        undo_queue_commit();
+
+        undo_entry = undo_stack_tail;
+        // Check for an empty undo stack
+        if (!undo_entry) {
+                status_line("Already at oldest change");
+                return;
+        }
+
+        switch (undo_entry->u_type) {
+        case UNDO_DEL:
+        case UNDO_DEL_CHAIN:
+                // make hole and put in text that was deleted; deallocate text
+                u_start = text + undo_entry->start;
+                text_hole_make(u_start, undo_entry->length);
+                memcpy(u_start, undo_entry->undo_text, undo_entry->length);
+                status_line("Undo [%d] %s %d chars at position %d",
+                        modified_count, "restored",
+                        undo_entry->length, undo_entry->start
+                );
+                break;
+        case UNDO_INS:
+        case UNDO_INS_CHAIN:
+                // delete what was inserted
+                u_start = undo_entry->start + text;
+                u_end = u_start - 1 + undo_entry->length;
+                text_hole_delete(u_start, u_end, NO_UNDO);
+                status_line("Undo [%d] %s %d chars at position %d",
+                        modified_count, "deleted",
+                        undo_entry->length, undo_entry->start
+                );
+                break;
+        }
+        repeat = 0;
+        switch (undo_entry->u_type) {
+        // If this is the end of a chain, lower modification count and refresh display
+        case UNDO_DEL:
+        case UNDO_INS:
+                dot = (text + undo_entry->start);
+                refresh(FALSE);
+                break;
+        case UNDO_DEL_CHAIN:
+        case UNDO_INS_CHAIN:
+                repeat = 1;
+                break;
+        }
+        // Deallocate the undo object we just processed
+        undo_stack_tail = undo_entry->prev;
+        free(undo_entry);
+        modified_count--;
+        // For chained operations, continue popping all the way down the chain.
+        if (repeat) {
+                undo_pop();     // Follow the undo chain if one exists
+        }
+}
+
+#if ENABLE_FEATURE_VI_UNDO_QUEUE
+static void undo_queue_commit(void)     // Flush any queued objects to the undo stack
+{
+        // Pushes the queue object onto the undo stack
+        if (undo_q > 0) {
+                // Deleted character undo events grow from the end
+                undo_push(undo_queue + CONFIG_FEATURE_VI_UNDO_QUEUE_MAX - undo_q,
+                        undo_q,
+                        (undo_queue_state | UNDO_USE_SPOS)
+                );
+                undo_queue_state = UNDO_EMPTY;
+                undo_q = 0;
+        }
+}
+#endif
+
+#endif /* ENABLE_FEATURE_VI_UNDO */
+
 // open a hole in text[]
 // might reallocate text[]! use p += text_hole_make(p, ...),
 // and be careful to not use pointers into potentially freed text[]!
@@ -2082,12 +2493,12 @@ static uintptr_t text_hole_make(char *p, int size)	// at "p", make a 'size' byte
         }
         memmove(p + size, p, end - size - p);
         memset(p, ' ', size);   // clear new hole
-        file_modified++;
         return bias;
 }
 
 //  close a hole in text[]
-static char *text_hole_delete(char *p, char *q) // delete "p" through "q", inclusive
+//  "undo" value indicates if this operation should be undo-able
+static char *text_hole_delete(char *p, char *q, int undo) // delete "p" through "q", inclusive
 {
         char *src, *dest;
         int cnt, hole_size;
@@ -2102,10 +2513,29 @@ static char *text_hole_delete(char *p, char *q) // delete "p" through "q", inclu
         }
         hole_size = q - p + 1;
         cnt = end - src;
+#if ENABLE_FEATURE_VI_UNDO
+        switch (undo) {
+                case NO_UNDO:
+                        break;
+                case ALLOW_UNDO:
+                        undo_push(p, hole_size, UNDO_DEL);
+                        break;
+                case ALLOW_UNDO_CHAIN:
+                        undo_push(p, hole_size, UNDO_DEL_CHAIN);
+                        break;
+# if ENABLE_FEATURE_VI_UNDO_QUEUE
+                case ALLOW_UNDO_QUEUED:
+                        undo_push(p, hole_size, UNDO_DEL_QUEUED);
+                        break;
+# endif
+        }
+        modified_count--;
+#endif
         if (src < text || src > end)
                 goto thd0;
         if (dest < text || dest >= end)
                 goto thd0;
+        modified_count++;
         if (src >= end)
                 goto thd_atend; // just delete the end of the buffer
         memmove(dest, src, cnt);
@@ -2115,7 +2545,6 @@ static char *text_hole_delete(char *p, char *q) // delete "p" through "q", inclu
                 dest = end - 1; // make sure dest in below end-1
         if (end <= text)
                 dest = end = text;      // keep pointers valid
-        file_modified++;
  thd0:
         return dest;
 }
@@ -2123,7 +2552,7 @@ static char *text_hole_delete(char *p, char *q) // delete "p" through "q", inclu
 // copy text into register, then delete text.
 // if dist <= 0, do not include, or go past, a NewLine
 //
-static char *yank_delete(char *start, char *stop, int dist, int yf)
+static char *yank_delete(char *start, char *stop, int dist, int yf, int undo)
 {
         char *p;
 
@@ -2152,7 +2581,7 @@ static char *yank_delete(char *start, char *stop, int dist, int yf)
         text_yank(start, stop, YDreg);
 #endif
         if (yf == YANKDEL) {
-                p = text_hole_delete(start, stop);
+                p = text_hole_delete(start, stop, undo);
         }                                       // delete lines
         return p;
 }
@@ -2218,12 +2647,22 @@ static void end_cmd_q(void)
  || ENABLE_FEATURE_VI_CRASHME
 // might reallocate text[]! use p += string_insert(p, ...),
 // and be careful to not use pointers into potentially freed text[]!
-static uintptr_t string_insert(char *p, const char *s) // insert the string at 'p'
+static uintptr_t string_insert(char *p, const char *s, int undo) // insert the string at 'p'
 {
         uintptr_t bias;
         int i;
 
         i = strlen(s);
+#if ENABLE_FEATURE_VI_UNDO
+        switch (undo) {
+                case ALLOW_UNDO:
+                        undo_push(p, i, UNDO_INS);
+                        break;
+                case ALLOW_UNDO_CHAIN:
+                        undo_push(p, i, UNDO_INS_CHAIN);
+                        break;
+        }
+#endif
         bias = text_hole_make(p, i);
         p += bias;
         memcpy(p, s, i);
@@ -2481,17 +2920,6 @@ static char *get_input_line(const char *prompt)
 #undef buf
 }
 
-static int file_size(const char *fn) // what is the byte size of "fn"
-{
-        struct stat st_buf;
-        int cnt;
-
-        cnt = -1;
-        if (fn && stat(fn, &st_buf) == 0)       // see if file exists
-                cnt = (int) st_buf.st_size;
-        return cnt;
-}
-
 // might reallocate text[]!
 static int file_insert(const char *fn, char *p, int update_ro_status)
 {
@@ -2499,38 +2927,37 @@ static int file_insert(const char *fn, char *p, int update_ro_status)
         int fd, size;
         struct stat statbuf;
 
-        /* Validate file */
-        if (stat(fn, &statbuf) < 0) {
-                status_line_bold_errno(fn);
-                goto fi0;
-        }
-        if (!S_ISREG(statbuf.st_mode)) {
-                // This is not a regular file
-                status_line_bold("'%s' is not a regular file", fn);
-                goto fi0;
-        }
         if (p < text || p > end) {
                 status_line_bold("Trying to insert file outside of memory");
-                goto fi0;
+                return cnt;
         }
 
-        // read file to buffer
         fd = open(fn, O_RDONLY);
         if (fd < 0) {
                 status_line_bold_errno(fn);
-                goto fi0;
+                return cnt;
+        }
+
+        /* Validate file */
+        if (fstat(fd, &statbuf) < 0) {
+                status_line_bold_errno(fn);
+                goto fi;
+        }
+        if (!S_ISREG(statbuf.st_mode)) {
+                status_line_bold("'%s' is not a regular file", fn);
+                goto fi;
         }
 #if ENABLE_PLATFORM_MINGW32
         _setmode(fd, _O_TEXT);
 #endif
         size = (statbuf.st_size < INT_MAX ? (int)statbuf.st_size : INT_MAX);
         p += text_hole_make(p, size);
-        cnt = safe_read(fd, p, size);
+        cnt = full_read(fd, p, size);
         if (cnt < 0) {
                 status_line_bold_errno(fn);
-                p = text_hole_delete(p, p + size - 1);  // un-do buffer insert
+                p = text_hole_delete(p, p + size - 1, NO_UNDO); // un-do buffer insert
         } else if (cnt < size) {
-                // There was a partial read, shrink unused space text[]
+                // There was a partial read, shrink unused space
 #if ENABLE_PLATFORM_MINGW32
                 int i, newline;
 
@@ -2541,7 +2968,7 @@ static int file_insert(const char *fn, char *p, int update_ro_status)
                         }
                 }
 #endif
-                p = text_hole_delete(p + cnt, p + size - 1);    // un-do buffer insert
+                p = text_hole_delete(p + cnt, p + size - 1, NO_UNDO);
 #if ENABLE_PLATFORM_MINGW32
                 // on WIN32 a partial read might just mean CRs have been removed
                 if ( cnt+newline != size ) {
@@ -2551,10 +2978,9 @@ static int file_insert(const char *fn, char *p, int update_ro_status)
                 status_line_bold("can't read '%s'", fn);
 #endif
         }
-        if (cnt >= size)
-                file_modified++;
+ fi:
         close(fd);
- fi0:
+
 #if ENABLE_FEATURE_VI_READONLY
         if (update_ro_status
          && ((access(fn, W_OK) < 0) ||
@@ -2607,7 +3033,7 @@ static int file_write(char *fn, char *first, char *last)
 #endif
         if (charcnt == cnt) {
                 // good write
-                //file_modified = FALSE;
+                //modified_count = FALSE;
         } else {
                 charcnt = 0;
         }
@@ -2829,7 +3255,7 @@ static int format_edit_status(void)
 
         int cur, percent, ret, trunc_at;
 
-        // file_modified is now a counter rather than a flag.  this
+        // modified_count is now a counter rather than a flag.  this
         // helps reduce the amount of line counting we need to do.
         // (this will cause a mis-reporting of modified status
         // once every MAXINT editing operations.)
@@ -2839,11 +3265,12 @@ static int format_edit_status(void)
         // we're on, then we shouldn't have to do this count_lines()
         cur = count_lines(text, dot);
 
-        // reduce counting -- the total lines can't have
-        // changed if we haven't done any edits.
-        if (file_modified != last_file_modified) {
+        // count_lines() is expensive.
+        // Call it only if something was changed since last time
+        // we were here:
+        if (modified_count != last_modified_count) {
                 tot = cur + count_lines(dot, end - 1) - 1;
-                last_file_modified = file_modified;
+                last_modified_count = modified_count;
         }
 
         //    current line         percent
@@ -2870,7 +3297,7 @@ static int format_edit_status(void)
 #if ENABLE_FEATURE_VI_READONLY
                 (readonly_mode ? " [Readonly]" : ""),
 #endif
-                (file_modified ? " [Modified]" : ""),
+                (modified_count ? " [Modified]" : ""),
                 cur, tot, percent);
 
         if (ret >= 0 && ret < trunc_at)
@@ -3095,11 +3522,12 @@ static void do_cmd(int c)
                 if (*dot == '\n') {
                         // don't Replace past E-o-l
                         cmd_mode = 1;   // convert to insert
+                        undo_queue_commit();
                 } else {
                         if (1 <= c || Isprint(c)) {
                                 if (c != 27)
-                                        dot = yank_delete(dot, dot, 0, YANKDEL);        // delete char
-                                dot = char_insert(dot, c);      // insert new char
+                                        dot = yank_delete(dot, dot, 0, YANKDEL, ALLOW_UNDO);    // delete char
+                                dot = char_insert(dot, c, ALLOW_UNDO_CHAIN);    // insert new char
                         }
                         goto dc1;
                 }
@@ -3109,7 +3537,7 @@ static void do_cmd(int c)
                 if (c == KEYCODE_INSERT) goto dc5;
                 // insert the char c at "dot"
                 if (1 <= c || Isprint(c)) {
-                        dot = char_insert(dot, c);
+                        dot = char_insert(dot, c, ALLOW_UNDO_QUEUED);
                 }
                 goto dc1;
         }
@@ -3155,7 +3583,6 @@ static void do_cmd(int c)
                 //case ']':     // ]-
                 //case '_':     // _-
                 //case '`':     // `-
-                //case 'u':     // u- FIXME- there is no undo
                 //case 'v':     // v-
         default:                        // unrecognized command
                 buf[0] = c;
@@ -3224,6 +3651,7 @@ static void do_cmd(int c)
                 if (cmd_mode == 0)
                         indicate_error(c);
                 cmd_mode = 0;   // stop insrting
+                undo_queue_commit();
                 end_cmd_q();
                 last_status_cksum = 0;  // force status update
                 break;
@@ -3298,15 +3726,20 @@ static void do_cmd(int c)
                         if (c == 'p')
                                 dot_right();    // move to right, can move to NL
                 }
-                string_insert(dot, p);  // insert the string
+                string_insert(dot, p, ALLOW_UNDO);      // insert the string
                 end_cmd_q();    // stop adding to q
                 break;
+#if ENABLE_FEATURE_VI_UNDO
+        case 'u':       // u- undo last operation
+                undo_pop();
+                break;
+#endif
         case 'U':                       // U- Undo; replace current line with original version
                 if (reg[Ureg] != NULL) {
                         p = begin_line(dot);
                         q = end_line(dot);
-                        p = text_hole_delete(p, q);     // delete cur line
-                        p += string_insert(p, reg[Ureg]);       // insert orig line
+                        p = text_hole_delete(p, q, ALLOW_UNDO); // delete cur line
+                        p += string_insert(p, reg[Ureg], ALLOW_UNDO_CHAIN);     // insert orig line
                         dot = p;
                         dot_skip_over_ws();
                 }
@@ -3482,57 +3915,14 @@ static void do_cmd(int c)
                 break;
         case ':':                       // :- the colon mode commands
                 p = get_input_line(":");        // get input line- use "status line"
-#if ENABLE_FEATURE_VI_COLON
                 colon(p);               // execute the command
-#else
-                if (*p == ':')
-                        p++;                            // move past the ':'
-                cnt = strlen(p);
-                if (cnt <= 0)
-                        break;
-                if (strncmp(p, "quit", cnt) == 0
-                 || strncmp(p, "q!", cnt) == 0   // delete lines
-                ) {
-                        if (file_modified && p[1] != '!') {
-                                status_line_bold("No write since last change (:%s! overrides)", p);
-                        } else {
-                                editing = 0;
-                        }
-                } else if (strncmp(p, "write", cnt) == 0
-                        || strncmp(p, "wq", cnt) == 0
-                        || strncmp(p, "wn", cnt) == 0
-                        || (p[0] == 'x' && !p[1])
-                ) {
-                        cnt = file_write(current_filename, text, end - 1);
-                        if (cnt < 0) {
-                                if (cnt == -1)
-                                        status_line_bold("Write error: %s", strerror(errno));
-                        } else {
-                                file_modified = 0;
-                                last_file_modified = -1;
-                                status_line("'%s' %dL, %dC", current_filename, count_lines(text, end - 1), cnt);
-                                if (p[0] == 'x' || p[1] == 'q' || p[1] == 'n'
-                                 || p[0] == 'X' || p[1] == 'Q' || p[1] == 'N'
-                                ) {
-                                        editing = 0;
-                                }
-                        }
-                } else if (strncmp(p, "file", cnt) == 0) {
-                        last_status_cksum = 0;  // force status update
-                } else if (sscanf(p, "%d", &j) > 0) {
-                        dot = find_line(j);             // go to line # j
-                        dot_skip_over_ws();
-                } else {                // unrecognized cmd
-                        not_implemented(p);
-                }
-#endif /* !FEATURE_VI_COLON */
                 break;
         case '<':                       // <- Left  shift something
         case '>':                       // >- Right shift something
                 cnt = count_lines(text, dot);   // remember what line we are on
                 c1 = get_one_char();    // get the type of thing to delete
                 find_range(&p, &q, c1);
-                yank_delete(p, q, 1, YANKONLY); // save copy before change
+                yank_delete(p, q, 1, YANKONLY, NO_UNDO);        // save copy before change
                 p = begin_line(p);
                 q = end_line(q);
                 i = count_lines(p, q);  // # of lines we are shifting
@@ -3541,16 +3931,16 @@ static void do_cmd(int c)
                                 // shift left- remove tab or 8 spaces
                                 if (*p == '\t') {
                                         // shrink buffer 1 char
-                                        text_hole_delete(p, p);
+                                        text_hole_delete(p, p, NO_UNDO);
                                 } else if (*p == ' ') {
                                         // we should be calculating columns, not just SPACE
                                         for (j = 0; *p == ' ' && j < tabstop; j++) {
-                                                text_hole_delete(p, p);
+                                                text_hole_delete(p, p, NO_UNDO);
                                         }
                                 }
                         } else if (c == '>') {
                                 // shift right -- add tab or 8 spaces
-                                char_insert(p, '\t');
+                                char_insert(p, '\t', ALLOW_UNDO);
                         }
                 }
                 dot = find_line(cnt);   // what line were we on
@@ -3585,7 +3975,7 @@ static void do_cmd(int c)
                 save_dot = dot;
                 dot = dollar_line(dot); // move to before NL
                 // copy text into a register and delete
-                dot = yank_delete(save_dot, dot, 0, YANKDEL);   // delete to e-o-l
+                dot = yank_delete(save_dot, dot, 0, YANKDEL, ALLOW_UNDO);       // delete to e-o-l
                 if (c == 'C')
                         goto dc_i;      // start inserting
 #if ENABLE_FEATURE_VI_DOT_CMD
@@ -3630,15 +4020,22 @@ static void do_cmd(int c)
         case KEYCODE_INSERT:    // Cursor Key Insert
  dc_i:
                 cmd_mode = 1;   // start inserting
+                undo_queue_commit();    // commit queue when cmd_mode changes
                 break;
         case 'J':                       // J- join current and next lines together
                 do {
                         dot_end();              // move to NL
                         if (dot < end - 1) {    // make sure not last char in text[]
+#if ENABLE_FEATURE_VI_UNDO
+                                undo_push(dot, 1, UNDO_DEL);
                                 *dot++ = ' ';   // replace NL with space
-                                file_modified++;
+                                undo_push((dot - 1), 1, UNDO_INS_CHAIN);
+#else
+                                *dot++ = ' ';
+                                modified_count++;
+#endif
                                 while (isblank(*dot)) { // delete leading WS
-                                        dot_delete();
+                                        text_hole_delete(dot, dot, ALLOW_UNDO_CHAIN);
                                 }
                         }
                 } while (--cmdcnt > 0);
@@ -3667,10 +4064,10 @@ static void do_cmd(int c)
                         dot_prev();
         case 'o':                       // o- open a empty line below; Yes, I know it is in the middle of the "if (..."
                         dot_end();
-                        dot = char_insert(dot, '\n');
+                        dot = char_insert(dot, '\n', ALLOW_UNDO);
                 } else {
                         dot_begin();    // 0
-                        dot = char_insert(dot, '\n');   // i\n ESC
+                        dot = char_insert(dot, '\n', ALLOW_UNDO);       // i\n ESC
                         dot_prev();     // -
                 }
                 goto dc_i;
@@ -3678,6 +4075,7 @@ static void do_cmd(int c)
         case 'R':                       // R- continuous Replace char
  dc5:
                 cmd_mode = 2;
+                undo_queue_commit();
                 break;
         case KEYCODE_DELETE:
                 c = 'x';
@@ -3692,7 +4090,7 @@ static void do_cmd(int c)
                         if (dot[dir] != '\n') {
                                 if (c == 'X')
                                         dot--;  // delete prev char
-                                dot = yank_delete(dot, dot, 0, YANKDEL);        // delete char
+                                dot = yank_delete(dot, dot, 0, YANKDEL, ALLOW_UNDO);    // delete char
                         }
                 } while (--cmdcnt > 0);
                 end_cmd_q();    // stop adding to q
@@ -3706,7 +4104,7 @@ static void do_cmd(int c)
                         indicate_error(c);
                         break;
                 }
-                if (file_modified) {
+                if (modified_count) {
                         if (ENABLE_FEATURE_VI_READONLY && readonly_mode) {
                                 status_line_bold("'%s' is read only", current_filename);
                                 break;
@@ -3763,6 +4161,7 @@ static void do_cmd(int c)
                         c1 = get_one_char();    // get the type of thing to delete
                 // determine range, and whether it spans lines
                 ml = find_range(&p, &q, c1);
+                place_cursor(0, 0);
                 if (c1 == 27) { // ESC- user changed mind and wants out
                         c = c1 = 27;    // Escape- do nothing
                 } else if (strchr("wW", c1)) {
@@ -3774,13 +4173,13 @@ static void do_cmd(int c)
                                         q--;
                                 }
                         }
-                        dot = yank_delete(p, q, ml, yf);        // delete word
+                        dot = yank_delete(p, q, ml, yf, ALLOW_UNDO);    // delete word
                 } else if (strchr("^0bBeEft%$ lh\b\177", c1)) {
                         // partial line copy text into a register and delete
-                        dot = yank_delete(p, q, ml, yf);        // delete word
+                        dot = yank_delete(p, q, ml, yf, ALLOW_UNDO);    // delete word
                 } else if (strchr("cdykjHL+-{}\r\n", c1)) {
                         // whole line copy text into a register and delete
-                        dot = yank_delete(p, q, ml, yf);        // delete lines
+                        dot = yank_delete(p, q, ml, yf, ALLOW_UNDO);    // delete lines
                         whole = 1;
                 } else {
                         // could not recognize object
@@ -3790,7 +4189,7 @@ static void do_cmd(int c)
                 }
                 if (ml && whole) {
                         if (c == 'c') {
-                                dot = char_insert(dot, '\n');
+                                dot = char_insert(dot, '\n', ALLOW_UNDO_CHAIN);
                                 // on the last line of file don't move to prev line
                                 if (whole && dot != (end-1)) {
                                         dot_prev();
@@ -3836,8 +4235,14 @@ static void do_cmd(int c)
         case 'r':                       // r- replace the current char with user input
                 c1 = get_one_char();    // get the replacement char
                 if (*dot != '\n') {
+#if ENABLE_FEATURE_VI_UNDO
+                        undo_push(dot, 1, UNDO_DEL);
+                        *dot = c1;
+                        undo_push(dot, 1, UNDO_INS_CHAIN);
+#else
                         *dot = c1;
-                        file_modified++;
+                        modified_count++;
+#endif
                 }
                 end_cmd_q();    // stop adding to q
                 break;
@@ -3877,13 +4282,25 @@ static void do_cmd(int c)
                 break;
         case '~':                       // ~- flip the case of letters   a-z -> A-Z
                 do {
+#if ENABLE_FEATURE_VI_UNDO
+                        if (islower(*dot)) {
+                                undo_push(dot, 1, UNDO_DEL);
+                                *dot = toupper(*dot);
+                                undo_push(dot, 1, UNDO_INS_CHAIN);
+                        } else if (isupper(*dot)) {
+                                undo_push(dot, 1, UNDO_DEL);
+                                *dot = tolower(*dot);
+                                undo_push(dot, 1, UNDO_INS_CHAIN);
+                        }
+#else
                         if (islower(*dot)) {
                                 *dot = toupper(*dot);
-                                file_modified++;
+                                modified_count++;
                         } else if (isupper(*dot)) {
                                 *dot = tolower(*dot);
-                                file_modified++;
+                                modified_count++;
                         }
+#endif
                         dot_right();
                 } while (--cmdcnt > 0);
                 end_cmd_q();    // stop adding to q
@@ -3913,7 +4330,7 @@ static void do_cmd(int c)
  dc1:
         // if text[] just became empty, add back an empty line
         if (end == text) {
-                char_insert(text, '\n');        // start empty buf with dummy line
+                char_insert(text, '\n', NO_UNDO);       // start empty buf with dummy line
                 dot = text;
         }
         // it is OK for dot to exactly equal to end, otherwise check dot validity