Changeset 3621 in MondoRescue for branches/3.3/mindi-busybox/editors/vi.c

Timestamp:

Dec 20, 2016, 4:07:32 PM (7 years ago)

Author:

Bruno Cornec

Message:

New 3?3 banch for incorporation of latest busybox 1.25. Changing minor version to handle potential incompatibilities.

Location:

branches/3.3

Files:

• . (copied) (copied from branches/3.2 )
• mindi-busybox/editors/vi.c (modified) (105 diffs)

branches/3.3/mindi-busybox/editors/vi.c

@@ -18 +18 @@
  *  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"
  */
@@ -137 +136 @@
 //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))
@@ -223 +252 @@
 // vda: removed "aAiIs" as they switch us into insert mode
 // and remembering input for replay after them makes no sense
-static const char modifying_cmds[] = "cCdDJoOpPrRxX<>~";
+static const char modifying_cmds[] ALIGN1 = "cCdDJoOpPrRxX<>~";
 #endif
 
@@ -278 +307 @@
                              // [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
@@ -348 +377 @@
 
     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)
@@ -359 +423 @@
 #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             )
@@ -409 +473 @@
 #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);) \
@@ -417 +491 @@
 
 
-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
@@ -428 +501 @@
 static char *end_screen(void);  // get pointer to last char on screen
 static int count_lines(char *, char *); // count line from start to stop
-static char *find_line(int);    // find begining of line #li
+static char *find_line(int);    // find beginning of line #li
 static char *move_to_col(char *, int);  // move "p" to column l
 static void dot_left(void); // move dot left- dont leave line
@@ -438 +511 @@
 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[]!
@@ -449 +524 @@
 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
@@ -461 +542 @@
 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
 // file_insert might reallocate text[]!
 static int file_insert(const char *, char *, int);
@@ -479 +556 @@
 static void status_line(const char *, ...);     // print to status buf
 static void status_line_bold(const char *, ...);
+static void status_line_bold_errno(const char *fn);
 static void not_implemented(const char *); // display "Not implemented" message
 static int format_edit_status(void);    // format file status on status line
@@ -485 +563 @@
 static void refresh(int);   // update the terminal from screen[]
 
-static void Indicate_Error(void);       // use flash or beep to indicate error
-#define indicate_error(c) Indicate_Error()
+static void indicate_error(void);       // use flash or beep to indicate error
 static void Hit_Return(void);
 
@@ -495 +572 @@
 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
+#endif
 static void colon(char *);  // execute the "colon" mode cmds
-#endif
 #if ENABLE_FEATURE_VI_USE_SIGNALS
 static void winch_sig(int); // catch window size changes
@@ -514 +591 @@
 // 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
@@ -521 +601 @@
 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();
@@ -527 +621 @@
 #endif
 
-
 static void write1(const char *out)
 {
@@ -539 +632 @@
 
     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
@@ -618 +719 @@
 {
     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);
 
@@ -629 +737 @@
         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);
-    }
-    file_modified = 0;
-    last_file_modified = -1;
-#if ENABLE_FEATURE_VI_YANKMARK
-    /* init the marks. */
-    memset(mark, 0, sizeof(mark));
-#endif
+    rc = file_insert(fn, text, 1);
+    if (rc < 0) {
+        // file doesnt exist. Start empty buf with dummy line
+        char_insert(text, '\n', NO_UNDO);
+    }
     return rc;
 }
@@ -756 +856 @@
             } 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 +1009 @@
 #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
@@ -937 +1095 @@
         buf++;          // move past the ':'
 
-    li = ch = i = 0;
+    li = i = 0;
     b = e = -1;
     q = text;           // assume 1,$ for the range
@@ -1015 +1173 @@
             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 +1195 @@
         }
 
-        if (init_text_buffer(fn) < 0)
-            goto ret;
+        size = init_text_buffer(fn);
 
 #if ENABLE_FEATURE_VI_YANKMARK
@@ -1050 +1209 @@
         // how many lines in text[]?
         li = count_lines(text, end - 1);
-        status_line("\"%s\"%s"
+        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) {
@@ -1122 +1283 @@
         }
         // 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 +1307 @@
         editing = 0;
     } else if (strncmp(cmd, "read", i) == 0) {  // read file into text[]
+        int size;
+
         fn = args;
         if (!fn[0]) {
@@ -1155 +1318 @@
         }
         // read after current line- unless user said ":0r foo"
-        if (b != 0)
+        if (b != 0) {
             q = next_line(q);
+            // read after last line
+            if (q == end-1)
+                ++q;
+        }
         { // dance around potentially-reallocated text[]
             uintptr_t ofs = q - text;
-            ch = file_insert(fn, q, 0);
+            size = file_insert(fn, q, 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);
-        status_line("\"%s\""
+        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 {
@@ -1235 +1403 @@
         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
@@ -1269 +1440 @@
                 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;
@@ -1293 +1468 @@
             || (cmd[0] == 'x' && !cmd[1])
     ) {
+        int size;
+        //int forced = FALSE;
+
         // is there a file name to write to?
         if (args[0]) {
@@ -1299 +1477 @@
 #if ENABLE_FEATURE_VI_READONLY
         if (readonly_mode && !useforce) {
-            status_line_bold("\"%s\" File is read only", fn);
+            status_line_bold("'%s' is read only", fn);
             goto ret;
         }
@@ -1305 +1483 @@
         // 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("\"%s\" %s", fn, strerror(errno));
+                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;
+            status_line("'%s' %dL, %dC", fn, li, l);
+            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 +1536 @@
     status_line(":s expression missing delimiters");
 #endif
-}
-
 #endif /* FEATURE_VI_COLON */
+}
 
 static void Hit_Return(void)
@@ -1508 +1684 @@
 static char *prev_line(char *p) // return pointer first char prev line
 {
-    p = begin_line(p);  // goto begining of cur line
+    p = begin_line(p);  // goto beginning of cur line
     if (p > text && p[-1] == '\n')
         p--;            // step to prev line
-    p = begin_line(p);  // goto begining of prev line
+    p = begin_line(p);  // goto beginning of prev line
     return p;
 }
@@ -1559 +1735 @@
 }
 
-static char *find_line(int li)  // find begining of line #li
+static char *find_line(int li)  // find beginning of line #li
 {
     char *q;
@@ -1572 +1748 @@
 static void dot_left(void)
 {
+    undo_queue_commit();
     if (dot > text && dot[-1] != '\n')
         dot--;
@@ -1578 +1755 @@
 static void dot_right(void)
 {
+    undo_queue_commit();
     if (dot < end - 1 && *dot != '\n')
         dot++;
@@ -1584 +1762 @@
 static void dot_begin(void)
 {
+    undo_queue_commit();
     dot = begin_line(dot);  // return pointer to first char cur line
 }
@@ -1589 +1768 @@
 static void dot_end(void)
 {
+    undo_queue_commit();
     dot = end_line(dot);    // return pointer to last char cur line
 }
@@ -1614 +1794 @@
 static void dot_next(void)
 {
+    undo_queue_commit();
     dot = next_line(dot);
 }
@@ -1619 +1800 @@
 static void dot_prev(void)
 {
+    undo_queue_commit();
     dot = prev_line(dot);
 }
@@ -1626 +1808 @@
     char *q;
 
+    undo_queue_commit();
     for (; cnt > 0; cnt--) {
         if (dir < 0) {
@@ -1653 +1836 @@
 }
 
-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) {
         p = end - 1;
-        indicate_error('1');
+        indicate_error();
     }
     if (p < text) {
         p = text;
-        indicate_error('2');
+        indicate_error();
     }
     return p;
@@ -1707 +1885 @@
 static char *char_search(char *p, const char *pat, int dir, int range)
 {
+    struct re_pattern_buffer preg;
+    const char *err;
     char *q;
-    struct re_pattern_buffer preg;
     int i;
     int size;
 
     re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
-    preg.translate = 0;
-    preg.fastmap = 0;
-    preg.buffer = 0;
-    preg.allocated = 0;
+    if (ignorecase)
+        re_syntax_options = RE_SYNTAX_POSIX_EXTENDED | RE_ICASE;
+
+    memset(&preg, 0, sizeof(preg));
+    err = re_compile_pattern(pat, strlen(pat), &preg);
+    if (err != NULL) {
+        status_line_bold("bad search pattern '%s': %s", pat, err);
+        return p;
+    }
 
     // assume a LIMITED forward search
-    q = next_line(p);
-    q = end_line(q);
     q = end - 1;
-    if (dir == BACK) {
-        q = prev_line(p);
+    if (dir == BACK)
         q = text;
-    }
-    // count the number of chars to search over, forward or backward
-    size = q - p;
-    if (size < 0)
-        size = p - q;
     // RANGE could be negative if we are searching backwards
     range = q - p;
-
-    q = (char *)re_compile_pattern(pat, strlen(pat), (struct re_pattern_buffer *)&preg);
-    if (q != 0) {
-        // The pattern was not compiled
-        status_line_bold("bad search pattern: \"%s\": %s", pat, q);
-        i = 0;          // return p if pattern not compiled
-        goto cs1;
-    }
-
     q = p;
+    size = range;
     if (range < 0) {
+        size = -size;
         q = p - size;
         if (q < text)
@@ -1748 +1917 @@
     }
     // search for the compiled pattern, preg, in p[]
-    // range < 0-  search backward
-    // range > 0-  search forward
+    // range < 0: search backward
+    // range > 0: search forward
     // 0 < start < size
-    // re_search() < 0  not found or error
-    // re_search() > 0  index of found pattern
-    //            struct pattern    char     int    int    int     struct reg
-    // re_search (*pattern_buffer,  *string, size,  start, range,  *regs)
-    i = re_search(&preg, q, size, 0, range, 0);
-    if (i == -1) {
-        p = 0;
-        i = 0;          // return NULL if pattern not found
-    }
- cs1:
-    if (dir == FORWARD) {
+    // re_search() < 0: not found or error
+    // re_search() >= 0: index of found pattern
+    //           struct pattern   char     int   int    int    struct reg
+    // re_search(*pattern_buffer, *string, size, start, range, *regs)
+    i = re_search(&preg, q, size, /*start:*/ 0, range, /*struct re_registers*:*/ NULL);
+    regfree(&preg);
+    if (i < 0)
+        return NULL;
+    if (dir == FORWARD)
         p = p + i;
-    } else {
+    else
         p = p - i;
-    }
     return p;
 }
@@ -1790 +1956 @@
     len = strlen(pat);
     if (dir == FORWARD) {
-        stop = end - 1; // assume range is p - end-1
+        stop = end - 1; // assume range is p..end-1
         if (range == LIMITED)
             stop = next_line(p);    // range is to next line
@@ -1799 +1965 @@
         }
     } else if (dir == BACK) {
-        stop = text;    // assume range is text - p
+        stop = text;    // assume range is text..p
         if (range == LIMITED)
             stop = prev_line(p);    // range is to prev line
@@ -1816 +1982 @@
 #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?
@@ -1823 +1989 @@
         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
@@ -1834 +2017 @@
         }
     } else if (c == erase_char || c == 8 || c == 127) { // Is this a BS
-        //     123456789
-        if ((p[-1] != '\n') && (dot>text)) {
+        if (p > 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
         // insert a char into text[]
-        char *sp;       // "save p"
-#endif
-
         if (c == 13)
             c = '\n';   // translate \r to \n
-#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) {
-            showmatching(sp);
+        if (showmatch && strchr(")]}", c) != NULL) {
+            showmatching(p - 1);
         }
         if (autoindent && c == '\n') {  // auto indent the new line
@@ -1865 +2061 @@
                 p += bias;
                 q += bias;
+#if ENABLE_FEATURE_VI_UNDO
+                undo_push(p, len, UNDO_INS);
+#endif
                 memcpy(p, q, len);
                 p += len;
@@ -1882 +2081 @@
     p += bias;
     *p = c;
-    //file_modified++; - done by text_hole_make()
     return bias;
 }
@@ -2011 +2209 @@
 
 // find matching char of pair  ()  []  {}
+// will crash if c is not one of these
 static char *find_pair(char *p, const char c)
 {
-    char match, *q;
+    const char *braces = "()[]{}";
+    char match;
     int dir, level;
 
-    match = ')';
+    dir = strchr(braces, c) - braces;
+    dir ^= 1;
+    match = braces[dir];
+    dir = ((dir & 1) << 1) - 1; /* 1 for ([{, -1 for )\} */
+
+    // look for match, count levels of pairs  (( ))
     level = 1;
-    dir = 1;            // assume forward
-    switch (c) {
-    case '(': match = ')'; break;
-    case '[': match = ']'; break;
-    case '{': match = '}'; break;
-    case ')': match = '('; dir = -1; break;
-    case ']': match = '['; dir = -1; break;
-    case '}': match = '{'; dir = -1; break;
-    }
-    for (q = p + dir; text <= q && q < end; q += dir) {
-        // look for match, count levels of pairs  (( ))
-        if (*q == c)
+    for (;;) {
+        p += dir;
+        if (p < text || p >= end)
+            return NULL;
+        if (*p == c)
             level++;    // increase pair levels
-        if (*q == match)
+        if (*p == match) {
             level--;    // reduce pair level
-        if (level == 0)
-            break;      // found matching pair
-    }
-    if (level != 0)
-        q = NULL;       // indicate no match
-    return q;
+            if (level == 0)
+                return p; // found matching pair
+        }
+    }
 }
 
@@ -2050 +2246 @@
     q = find_pair(p, *p);   // get loc of matching char
     if (q == NULL) {
-        indicate_error('3');    // no matching char
+        indicate_error();   // no matching char
     } else {
         // "q" now points to matching pair
@@ -2062 +2258 @@
 }
 #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[]
@@ -2094 +2483 @@
     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;
@@ -2114 +2503 @@
     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
@@ -2127 +2535 @@
     if (end <= text)
         dest = end = text;  // keep pointers valid
-    file_modified++;
  thd0:
     return dest;
@@ -2135 +2542 @@
 // 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;
@@ -2164 +2571 @@
 #endif
     if (yf == YANKDEL) {
-        p = text_hole_delete(start, stop);
+        p = text_hole_delete(start, stop, undo);
     }                   // delete lines
     return p;
@@ -2230 +2637 @@
 // 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;
@@ -2236 +2643 @@
 
     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;
@@ -2387 +2804 @@
 {
     struct pollfd pfd[1];
+
+    if (hund != 0)
+        fflush_all();
 
     pfd[0].fd = STDIN_FILENO;
@@ -2484 +2904 @@
 }
 
-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)
+static int file_insert(const char *fn, char *p, int initial)
 {
     int cnt = -1;
@@ -2502 +2911 @@
     struct stat statbuf;
 
-    /* Validate file */
-    if (stat(fn, &statbuf) < 0) {
-        status_line_bold("\"%s\" %s", fn, strerror(errno));
-        goto fi0;
-    }
-    if (!S_ISREG(statbuf.st_mode)) {
-        // This is not a regular file
-        status_line_bold("\"%s\" Not a regular file", fn);
-        goto fi0;
-    }
-    if (p < text || p > end) {
-        status_line_bold("Trying to insert file outside of memory");
-        goto fi0;
-    }
-
-    // read file to buffer
+    if (p < text)
+        p = text;
+    if (p > end)
+        p = end;
+
     fd = open(fn, O_RDONLY);
     if (fd < 0) {
-        status_line_bold("\"%s\" %s", fn, strerror(errno));
-        goto fi0;
-    }
-    size = statbuf.st_size;
+        if (!initial)
+            status_line_bold_errno(fn);
+        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;
+    }
+    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("\"%s\" %s", fn, strerror(errno));
-        p = text_hole_delete(p, p + size - 1);  // un-do buffer insert
+        status_line_bold_errno(fn);
+        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[]
-        p = text_hole_delete(p + cnt, p + (size - cnt) - 1);    // un-do buffer insert
-        status_line_bold("can't read all of file \"%s\"", fn);
-    }
-    if (cnt >= size)
-        file_modified++;
+        // There was a partial read, shrink unused space
+        p = text_hole_delete(p + cnt, p + size - 1, NO_UNDO);
+        status_line_bold("can't read '%s'", fn);
+    }
+ fi:
     close(fd);
- fi0:
+
 #if ENABLE_FEATURE_VI_READONLY
-    if (update_ro_status
+    if (initial
      && ((access(fn, W_OK) < 0) ||
         /* root will always have access()
@@ -2572 +2980 @@
     if (charcnt == cnt) {
         // good write
-        //file_modified = FALSE;
+        //modified_count = FALSE;
     } else {
         charcnt = 0;
@@ -2645 +3053 @@
 }
 
-static void Indicate_Error(void)
+static void indicate_error(void)
 {
 #if ENABLE_FEATURE_VI_CRASHME
@@ -2718 +3126 @@
 }
 
+static void status_line_bold_errno(const char *fn)
+{
+    status_line_bold("'%s' %s", fn, strerror(errno));
+}
+
 // format status buffer
 static void status_line(const char *format, ...)
@@ -2789 +3202 @@
     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
@@ -2799 +3212 @@
     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;
     }
 
@@ -2830 +3244 @@
         (readonly_mode ? " [Readonly]" : ""),
 #endif
-        (file_modified ? " [Modified]" : ""),
+        (modified_count ? " [Modified]" : ""),
         cur, tot, percent);
 
@@ -2943 +3357 @@
         }
 
-        // see if there are any changes between vitual screen and out_buf
+        // see if there are any changes between virtual screen and out_buf
         changed = FALSE;    // assume no change
         cs = 0;
@@ -2980 +3394 @@
         if (ce > columns - 1) ce = columns - 1;
         if (cs > ce) { cs = 0; ce = columns - 1; }
-        // is there a change between vitual screen and out_buf
+        // is there a change between virtual screen and out_buf
         if (changed) {
             // copy changed part of buffer to virtual screen
@@ -3055 +3469 @@
             // 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;
@@ -3069 +3484 @@
         // 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;
@@ -3115 +3530 @@
         //case '_': // _-
         //case '`': // `-
-        //case 'u': // u- FIXME- there is no undo
         //case 'v': // v-
     default:            // unrecognized command
@@ -3182 +3596 @@
     case 27:            // esc
         if (cmd_mode == 0)
-            indicate_error(c);
+            indicate_error();
         cmd_mode = 0;   // stop insrting
+        undo_queue_commit();
         end_cmd_q();
         last_status_cksum = 0;  // force status update
@@ -3200 +3615 @@
             YDreg = c1;
         } else {
-            indicate_error(c);
+            indicate_error();
         }
         break;
@@ -3218 +3633 @@
             dot_skip_over_ws();
         } else {
-            indicate_error(c);
+            indicate_error();
         }
         break;
@@ -3231 +3646 @@
             mark[c1] = dot;
         } else {
-            indicate_error(c);
+            indicate_error();
         }
         break;
@@ -3258 +3673 @@
                 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;
@@ -3265 +3680 @@
             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();
@@ -3272 +3687 @@
         break;
 #endif /* FEATURE_VI_YANKMARK */
+#if ENABLE_FEATURE_VI_UNDO
+    case 'u':   // u- undo last operation
+        undo_pop();
+        break;
+#endif
     case '$':           // $- goto end of line
     case KEYCODE_END:       // Cursor Key End
@@ -3287 +3707 @@
                 p = find_pair(q, *q);
                 if (p == NULL) {
-                    indicate_error(c);
+                    indicate_error();
                 } else {
                     dot = p;
@@ -3295 +3715 @@
         }
         if (*q == '\n')
-            indicate_error(c);
+            indicate_error();
         break;
     case 'f':           // f- forward to a user specified char
@@ -3424 +3844 @@
         break;
 #endif /* FEATURE_VI_SEARCH */
-    case '0':           // 0- goto begining of line
+    case '0':           // 0- goto beginning of line
     case '1':           // 1-
     case '2':           // 2-
@@ -3442 +3862 @@
     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
@@ -3492 +3869 @@
         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);
@@ -3501 +3878 @@
                 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);
             }
         }
@@ -3545 +3922 @@
         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
@@ -3590 +3967 @@
  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
@@ -3595 +3973 @@
             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);
                 }
             }
@@ -3627 +4011 @@
     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(); // -
         }
@@ -3638 +4022 @@
  dc5:
         cmd_mode = 2;
+        undo_queue_commit();
         break;
     case KEYCODE_DELETE:
-        c = 'x';
-        // fall through
+        if (dot < end - 1)
+            dot = yank_delete(dot, dot, 1, YANKDEL, ALLOW_UNDO);
+        break;
     case 'X':           // X- delete char before dot
     case 'x':           // x- delete the current char
@@ -3652 +4038 @@
                 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);
@@ -3663 +4049 @@
         c1 = get_one_char();
         if (c1 != 'Z') {
-            indicate_error(c);
+            indicate_error();
             break;
         }
-        if (file_modified) {
+        if (modified_count) {
             if (ENABLE_FEATURE_VI_READONLY && readonly_mode) {
-                status_line_bold("\"%s\" File is read only", current_filename);
+                status_line_bold("'%s' is read only", current_filename);
                 break;
             }
@@ -3723 +4109 @@
         // 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
@@ -3734 +4121 @@
                 }
             }
-            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 {
@@ -3746 +4133 @@
             c = c1 = 27;    // error-
             ml = 0;
-            indicate_error(c);
+            indicate_error();
         }
         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)) {
@@ -3796 +4183 @@
         c1 = get_one_char();    // get the replacement char
         if (*dot != '\n') {
+#if ENABLE_FEATURE_VI_UNDO
+            undo_push(dot, 1, UNDO_DEL);
             *dot = c1;
-            file_modified++;
+            undo_push(dot, 1, UNDO_INS_CHAIN);
+#else
+            *dot = c1;
+            modified_count++;
+#endif
         }
         end_cmd_q();    // stop adding to q
@@ -3837 +4230 @@
     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);
@@ -3873 +4278 @@
     // 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;
     }