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

Timestamp:

Dec 20, 2016, 4:07:32 PM (8 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/Config.src (modified) (1 diff)
• mindi-busybox/editors/Kbuild.src (modified) (1 diff)
• mindi-busybox/editors/awk.c (modified) (31 diffs)
• mindi-busybox/editors/cmp.c (modified) (1 diff)
• mindi-busybox/editors/diff.c (modified) (7 diffs)
• mindi-busybox/editors/ed.c (modified) (5 diffs)
• mindi-busybox/editors/patch.c (modified) (7 diffs)
• mindi-busybox/editors/patch_bbox.c (modified) (1 diff)
• mindi-busybox/editors/sed.c (modified) (45 diffs)
• mindi-busybox/editors/vi.c (modified) (105 diffs)

branches/3.3/mindi-busybox/editors/Config.src

@@ -7 +7 @@
 
 INSERT
-
-config AWK
-    bool "awk"
-    default y
-    help
-      Awk is used as a pattern scanning and processing language. This is
-      the BusyBox implementation of that programming language.
-
-config FEATURE_AWK_LIBM
-    bool "Enable math functions (requires libm)"
-    default y
-    depends on AWK
-    help
-      Enable math functions of the Awk programming language.
-      NOTE: This will require libm to be present for linking.
-
-config CMP
-    bool "cmp"
-    default y
-    help
-      cmp is used to compare two files and returns the result
-      to standard output.
-
-config DIFF
-    bool "diff"
-    default y
-    help
-      diff compares two files or directories and outputs the
-      differences between them in a form that can be given to
-      the patch command.
-
-config FEATURE_DIFF_LONG_OPTIONS
-    bool "Enable long options"
-    default y
-    depends on DIFF && LONG_OPTS
-    help
-      Enable use of long options.
-
-config FEATURE_DIFF_DIR
-    bool "Enable directory support"
-    default y
-    depends on DIFF
-    help
-      This option enables support for directory and subdirectory
-      comparison.
-
-config ED
-    bool "ed"
-    default y
-    help
-      The original 1970's Unix text editor, from the days of teletypes.
-      Small, simple, evil. Part of SUSv3. If you're not already using
-      this, you don't need it.
-
-config SED
-    bool "sed"
-    default y
-    help
-      sed is used to perform text transformations on a file
-      or input from a pipeline.
 
 config FEATURE_ALLOW_EXEC

branches/3.3/mindi-busybox/editors/Kbuild.src

@@ -8 +8 @@
 
 INSERT
-lib-$(CONFIG_AWK)       += awk.o
-lib-$(CONFIG_CMP)       += cmp.o
-lib-$(CONFIG_DIFF)      += diff.o
-lib-$(CONFIG_ED)        += ed.o
-lib-$(CONFIG_SED)       += sed.o

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

@@ -8 +8 @@
  */
 
+//config:config AWK
+//config:   bool "awk"
+//config:   default y
+//config:   help
+//config:     Awk is used as a pattern scanning and processing language. This is
+//config:     the BusyBox implementation of that programming language.
+//config:
+//config:config FEATURE_AWK_LIBM
+//config:   bool "Enable math functions (requires libm)"
+//config:   default y
+//config:   depends on AWK
+//config:   help
+//config:     Enable math functions of the Awk programming language.
+//config:     NOTE: This will require libm to be present for linking.
+//config:
+//config:config FEATURE_AWK_GNU_EXTENSIONS
+//config:   bool "Enable a few GNU extensions"
+//config:   default y
+//config:   depends on AWK
+//config:   help
+//config:     Enable a few features from gawk:
+//config:     * command line option -e AWK_PROGRAM
+//config:     * simultaneous use of -f and -e on the command line.
+//config:       This enables the use of awk library files.
+//config:       Ex: awk -f mylib.awk -e '{print myfunction($1);}' ...
+
+//applet:IF_AWK(APPLET_NOEXEC(awk, awk, BB_DIR_USR_BIN, BB_SUID_DROP, awk))
+
+//kbuild:lib-$(CONFIG_AWK) += awk.o
+
 //usage:#define awk_trivial_usage
 //usage:       "[OPTIONS] [AWK_PROGRAM] [FILE]..."
@@ -14 +44 @@
 //usage:     "\n    -F SEP      Use SEP as field separator"
 //usage:     "\n    -f FILE     Read program from FILE"
+//usage:    IF_FEATURE_AWK_GNU_EXTENSIONS(
+//usage:     "\n    -e AWK_PROGRAM"
+//usage:    )
 
 #include "libbb.h"
@@ -39 +72 @@
 
 
+#define OPTSTR_AWK \
+    "F:v:f:" \
+    IF_FEATURE_AWK_GNU_EXTENSIONS("e:") \
+    "W:"
+#define OPTCOMPLSTR_AWK \
+    "v::f::" \
+    IF_FEATURE_AWK_GNU_EXTENSIONS("e::")
+enum {
+    OPTBIT_F,   /* define field separator */
+    OPTBIT_v,   /* define variable */
+    OPTBIT_f,   /* pull in awk program from file */
+    IF_FEATURE_AWK_GNU_EXTENSIONS(OPTBIT_e,) /* -e AWK_PROGRAM */
+    OPTBIT_W,   /* -W ignored */
+    OPT_F = 1 << OPTBIT_F,
+    OPT_v = 1 << OPTBIT_v,
+    OPT_f = 1 << OPTBIT_f,
+    OPT_e = IF_FEATURE_AWK_GNU_EXTENSIONS((1 << OPTBIT_e)) + 0,
+    OPT_W = 1 << OPTBIT_W
+};
 
 #define MAXVARFMT       240
@@ -156 +208 @@
 /* simple token classes */
 /* Order and hex values are very important!!!  See next_token() */
-#define TC_SEQSTART 1           /* ( */
+#define TC_SEQSTART (1 << 0)        /* ( */
 #define TC_SEQTERM  (1 << 1)        /* ) */
 #define TC_REGEXP   (1 << 2)        /* /.../ */
@@ -176 +228 @@
 #define TC_ELSE     (1 << 18)
 #define TC_BUILTIN  (1 << 19)
-#define TC_GETLINE  (1 << 20)
-#define TC_FUNCDECL (1 << 21)       /* `function' `func' */
-#define TC_BEGIN    (1 << 22)
-#define TC_END      (1 << 23)
-#define TC_EOF      (1 << 24)
-#define TC_VARIABLE (1 << 25)
-#define TC_ARRAY    (1 << 26)
-#define TC_FUNCTION (1 << 27)
-#define TC_STRING   (1 << 28)
-#define TC_NUMBER   (1 << 29)
+/* This costs ~50 bytes of code.
+ * A separate class to support deprecated "length" form. If we don't need that
+ * (i.e. if we demand that only "length()" with () is valid), then TC_LENGTH
+ * can be merged with TC_BUILTIN:
+ */
+#define TC_LENGTH   (1 << 20)
+#define TC_GETLINE  (1 << 21)
+#define TC_FUNCDECL (1 << 22)       /* `function' `func' */
+#define TC_BEGIN    (1 << 23)
+#define TC_END      (1 << 24)
+#define TC_EOF      (1 << 25)
+#define TC_VARIABLE (1 << 26)
+#define TC_ARRAY    (1 << 27)
+#define TC_FUNCTION (1 << 28)
+#define TC_STRING   (1 << 29)
+#define TC_NUMBER   (1 << 30)
 
 #define TC_UOPPRE  (TC_UOPPRE1 | TC_UOPPRE2)
@@ -191 +249 @@
 /* combined token classes */
 #define TC_BINOP   (TC_BINOPX | TC_COMMA | TC_PIPE | TC_IN)
-#define TC_UNARYOP (TC_UOPPRE | TC_UOPPOST)
+//#define   TC_UNARYOP (TC_UOPPRE | TC_UOPPOST)
 #define TC_OPERAND (TC_VARIABLE | TC_ARRAY | TC_FUNCTION \
-                   | TC_BUILTIN | TC_GETLINE | TC_SEQSTART | TC_STRING | TC_NUMBER)
+                   | TC_BUILTIN | TC_LENGTH | TC_GETLINE \
+                   | TC_SEQSTART | TC_STRING | TC_NUMBER)
 
 #define TC_STATEMNT (TC_STATX | TC_WHILE)
@@ -199 +258 @@
 
 /* word tokens, cannot mean something else if not expected */
-#define TC_WORD    (TC_IN | TC_STATEMNT | TC_ELSE | TC_BUILTIN \
-                   | TC_GETLINE | TC_FUNCDECL | TC_BEGIN | TC_END)
+#define TC_WORD    (TC_IN | TC_STATEMNT | TC_ELSE \
+                   | TC_BUILTIN | TC_LENGTH | TC_GETLINE \
+                   | TC_FUNCDECL | TC_BEGIN | TC_END)
 
 /* discard newlines after these */
@@ -295 +355 @@
 #define NTCC    '\377'
 
-#define OC_B  OC_BUILTIN
-
 static const char tokenlist[] ALIGN1 =
-    "\1("         NTC
-    "\1)"         NTC
-    "\1/"         NTC                                   /* REGEXP */
-    "\2>>"        "\1>"         "\1|"       NTC         /* OUTRDR */
-    "\2++"        "\2--"        NTC                     /* UOPPOST */
-    "\2++"        "\2--"        "\1$"       NTC         /* UOPPRE1 */
-    "\2=="        "\1="         "\2+="      "\2-="      /* BINOPX */
+    "\1("         NTC                                   /* TC_SEQSTART */
+    "\1)"         NTC                                   /* TC_SEQTERM */
+    "\1/"         NTC                                   /* TC_REGEXP */
+    "\2>>"        "\1>"         "\1|"       NTC         /* TC_OUTRDR */
+    "\2++"        "\2--"        NTC                     /* TC_UOPPOST */
+    "\2++"        "\2--"        "\1$"       NTC         /* TC_UOPPRE1 */
+    "\2=="        "\1="         "\2+="      "\2-="      /* TC_BINOPX */
     "\2*="        "\2/="        "\2%="      "\2^="
     "\1+"         "\1-"         "\3**="     "\2**"
@@ -311 +369 @@
     "\1<"         "\2!~"        "\1~"       "\2&&"
     "\2||"        "\1?"         "\1:"       NTC
-    "\2in"        NTC
-    "\1,"         NTC
-    "\1|"         NTC
-    "\1+"         "\1-"         "\1!"       NTC         /* UOPPRE2 */
-    "\1]"         NTC
-    "\1{"         NTC
-    "\1}"         NTC
-    "\1;"         NTC
-    "\1\n"        NTC
-    "\2if"        "\2do"        "\3for"     "\5break"   /* STATX */
+    "\2in"        NTC                                   /* TC_IN */
+    "\1,"         NTC                                   /* TC_COMMA */
+    "\1|"         NTC                                   /* TC_PIPE */
+    "\1+"         "\1-"         "\1!"       NTC         /* TC_UOPPRE2 */
+    "\1]"         NTC                                   /* TC_ARRTERM */
+    "\1{"         NTC                                   /* TC_GRPSTART */
+    "\1}"         NTC                                   /* TC_GRPTERM */
+    "\1;"         NTC                                   /* TC_SEMICOL */
+    "\1\n"        NTC                                   /* TC_NEWLINE */
+    "\2if"        "\2do"        "\3for"     "\5break"   /* TC_STATX */
     "\10continue" "\6delete"    "\5print"
     "\6printf"    "\4next"      "\10nextfile"
     "\6return"    "\4exit"      NTC
-    "\5while"     NTC
-    "\4else"      NTC
-
-    "\3and"       "\5compl"     "\6lshift"  "\2or"
+    "\5while"     NTC                                   /* TC_WHILE */
+    "\4else"      NTC                                   /* TC_ELSE */
+    "\3and"       "\5compl"     "\6lshift"  "\2or"      /* TC_BUILTIN */
     "\6rshift"    "\3xor"
-    "\5close"     "\6system"    "\6fflush"  "\5atan2"   /* BUILTIN */
+    "\5close"     "\6system"    "\6fflush"  "\5atan2"
     "\3cos"       "\3exp"       "\3int"     "\3log"
     "\4rand"      "\3sin"       "\4sqrt"    "\5srand"
-    "\6gensub"    "\4gsub"      "\5index"   "\6length"
+    "\6gensub"    "\4gsub"      "\5index"   /* "\6length" was here */
     "\5match"     "\5split"     "\7sprintf" "\3sub"
     "\6substr"    "\7systime"   "\10strftime" "\6mktime"
     "\7tolower"   "\7toupper"   NTC
-    "\7getline"   NTC
-    "\4func"      "\10function" NTC
-    "\5BEGIN"     NTC
-    "\3END"
+    "\6length"    NTC                                   /* TC_LENGTH */
+    "\7getline"   NTC                                   /* TC_GETLINE */
+    "\4func"      "\10function" NTC                     /* TC_FUNCDECL */
+    "\5BEGIN"     NTC                                   /* TC_BEGIN */
+    "\3END"                                             /* TC_END */
     /* compiler adds trailing "\0" */
     ;
+
+#define OC_B  OC_BUILTIN
 
 static const uint32_t tokeninfo[] = {
@@ -357 +417 @@
     OC_COMPARE|VV|P(39)|2,   OC_MATCH|Sx|P(45)|'!',   OC_MATCH|Sx|P(45)|'~',   OC_LAND|Vx|P(55),
     OC_LOR|Vx|P(59),         OC_TERNARY|Vx|P(64)|'?', OC_COLON|xx|P(67)|':',
-    OC_IN|SV|P(49), /* in */
+    OC_IN|SV|P(49), /* TC_IN */
     OC_COMMA|SS|P(80),
     OC_PGETLINE|SV|P(37),
@@ -372 +432 @@
     ST_WHILE,
     0, /* else */
-
     OC_B|B_an|P(0x83), OC_B|B_co|P(0x41), OC_B|B_ls|P(0x83), OC_B|B_or|P(0x83),
     OC_B|B_rs|P(0x83), OC_B|B_xo|P(0x83),
@@ -378 +437 @@
     OC_FBLTIN|Nx|F_co, OC_FBLTIN|Nx|F_ex, OC_FBLTIN|Nx|F_in, OC_FBLTIN|Nx|F_lg,
     OC_FBLTIN|F_rn,    OC_FBLTIN|Nx|F_si, OC_FBLTIN|Nx|F_sq, OC_FBLTIN|Nx|F_sr,
-    OC_B|B_ge|P(0xd6), OC_B|B_gs|P(0xb6), OC_B|B_ix|P(0x9b), OC_FBLTIN|Sx|F_le,
+    OC_B|B_ge|P(0xd6), OC_B|B_gs|P(0xb6), OC_B|B_ix|P(0x9b), /* OC_FBLTIN|Sx|F_le, was here */
     OC_B|B_ma|P(0x89), OC_B|B_sp|P(0x8b), OC_SPRINTF,        OC_B|B_su|P(0xb6),
     OC_B|B_ss|P(0x8f), OC_FBLTIN|F_ti,    OC_B|B_ti|P(0x0b), OC_B|B_mt|P(0x0b),
     OC_B|B_lo|P(0x49), OC_B|B_up|P(0x49),
+    OC_FBLTIN|Sx|F_le, /* TC_LENGTH */
     OC_GETLINE|SV|P(0),
     0,                 0,
     0,
-    0 /* END */
+    0 /* TC_END */
 };
 
@@ -1009 +1069 @@
     if (t_rollback) {
         t_rollback = FALSE;
-
     } else if (concat_inserted) {
         concat_inserted = FALSE;
         t_tclass = save_tclass;
         t_info = save_info;
-
     } else {
         p = g_pos;
@@ -1030 +1088 @@
             tc = TC_EOF;
             debug_printf_parse("%s: token found: TC_EOF\n", __func__);
-
         } else if (*p == '\"') {
             /* it's a string */
@@ -1046 +1103 @@
             tc = TC_STRING;
             debug_printf_parse("%s: token found:'%s' TC_STRING\n", __func__, t_string);
-
         } else if ((expected & TC_REGEXP) && *p == '/') {
             /* it's regexp */
@@ -1079 +1135 @@
             tc = TC_NUMBER;
             debug_printf_parse("%s: token found:%f TC_NUMBER\n", __func__, t_double);
-
         } else {
             /* search for something known */
@@ -1156 +1211 @@
 
     /* Are we ready for this? */
-    if (!(ltclass & expected))
+    if (!(ltclass & expected)) {
         syntax_error((ltclass & (TC_NEWLINE | TC_EOF)) ?
                 EMSG_UNEXP_EOS : EMSG_UNEXP_TOKEN);
+    }
 
     return ltclass;
@@ -1325 +1381 @@
                     cn->l.n = condition();
                     break;
+
+                case TC_LENGTH:
+                    debug_printf_parse("%s: TC_LENGTH\n", __func__);
+                    next_token(TC_SEQSTART | TC_OPTERM | TC_GRPTERM);
+                    rollback_token();
+                    if (t_tclass & TC_SEQSTART) {
+                        /* It was a "(" token. Handle just like TC_BUILTIN */
+                        cn->l.n = condition();
+                    }
+                    break;
                 }
             }
@@ -1489 +1555 @@
             n = chain_node(OC_EXEC);
             n->a.n = break_ptr;
+            chain_expr(t_info);
             break;
 
@@ -1495 +1562 @@
             n = chain_node(OC_EXEC);
             n->a.n = continue_ptr;
+            chain_expr(t_info);
             break;
 
@@ -1527 +1595 @@
             seq = &beginseq;
             chain_group();
-
         } else if (tclass & TC_END) {
             debug_printf_parse("%s: TC_END\n", __func__);
             seq = &endseq;
             chain_group();
-
         } else if (tclass & TC_FUNCDECL) {
             debug_printf_parse("%s: TC_FUNCDECL\n", __func__);
@@ -1550 +1616 @@
             chain_group();
             clear_array(ahash);
-
         } else if (tclass & TC_OPSEQ) {
             debug_printf_parse("%s: TC_OPSEQ\n", __func__);
@@ -1565 +1630 @@
             }
             cn->r.n = mainseq.last;
-
         } else /* if (tclass & TC_GRPSTART) */ {
             debug_printf_parse("%s: TC_GRPSTART(?)\n", __func__);
@@ -1826 +1890 @@
 
         mk_splitter(getvar_s(v), &fsplitter);
-
     } else if (v == intvar[RS]) {
         mk_splitter(getvar_s(v), &rsplitter);
-
     } else if (v == intvar[IGNORECASE]) {
         icase = istrue(v);
-
     } else {                /* $n */
         n = getvar_i(intvar[NF]);
@@ -2016 +2077 @@
     const char *s = format;
 
-    if (int_as_int && n == (int)n) {
-        r = snprintf(b, size, "%d", (int)n);
+    if (int_as_int && n == (long long)n) {
+        r = snprintf(b, size, "%lld", (long long)n);
     } else {
         do { c = *s; } while (c && *++s);
@@ -2662 +2723 @@
             const char *sv_progname;
 
-            if (!op->r.f->body.first)
+            /* The body might be empty, still has to eval the args */
+            if (!op->r.n->info && !op->r.f->body.first)
                 syntax_error(EMSG_UNDEF_FUNC);
 
@@ -2733 +2795 @@
             switch (opn) {
             case F_in:
-                R_d = (int)L_d;
+                R_d = (long long)L_d;
                 break;
 
@@ -2784 +2846 @@
 
             case F_le:
-                if (!op1)
+                debug_printf_eval("length: L.s:'%s'\n", L.s);
+                if (!op1) {
                     L.s = getvar_s(intvar[F0]);
+                    debug_printf_eval("length: L.s='%s'\n", L.s);
+                }
+                else if (L.v->type & VF_ARRAY) {
+                    R_d = L.v->x.array->nel;
+                    debug_printf_eval("length: array_len:%d\n", L.v->x.array->nel);
+                    break;
+                }
                 R_d = strlen(L.s);
                 break;
@@ -2931 +3001 @@
                 if (R_d == 0)
                     syntax_error(EMSG_DIV_BY_ZERO);
-                L_d -= (int)(L_d / R_d) * R_d;
+                L_d -= (long long)(L_d / R_d) * R_d;
                 break;
             }
@@ -3079 +3149 @@
     llist_t *list_v = NULL;
     llist_t *list_f = NULL;
+#if ENABLE_FEATURE_AWK_GNU_EXTENSIONS
+    llist_t *list_e = NULL;
+#endif
     int i, j;
     var *v;
@@ -3137 +3210 @@
         }
     }
-    opt_complementary = "v::f::"; /* -v and -f can occur multiple times */
-    opt = getopt32(argv, "F:v:f:W:", &opt_F, &list_v, &list_f, NULL);
+    opt_complementary = OPTCOMPLSTR_AWK;
+    opt = getopt32(argv, OPTSTR_AWK, &opt_F, &list_v, &list_f, IF_FEATURE_AWK_GNU_EXTENSIONS(&list_e,) NULL);
     argv += optind;
     argc -= optind;
-    if (opt & 0x1) { /* -F */
+    if (opt & OPT_W)
+        bb_error_msg("warning: option -W is ignored");
+    if (opt & OPT_F) {
         unescape_string_in_place(opt_F);
         setvar_s(intvar[FS], opt_F);
     }
-    while (list_v) { /* -v */
+    while (list_v) {
         if (!is_assignment(llist_pop(&list_v)))
             bb_show_usage();
     }
-    if (list_f) { /* -f */
-        do {
-            char *s = NULL;
-            FILE *from_file;
-
-            g_progname = llist_pop(&list_f);
-            from_file = xfopen_stdin(g_progname);
-            /* one byte is reserved for some trick in next_token */
-            for (i = j = 1; j > 0; i += j) {
-                s = xrealloc(s, i + 4096);
-                j = fread(s + i, 1, 4094, from_file);
-            }
-            s[i] = '\0';
-            fclose(from_file);
-            parse_program(s + 1);
-            free(s);
-        } while (list_f);
-        argc++;
-    } else { // no -f: take program from 1st parameter
-        if (!argc)
+    while (list_f) {
+        char *s = NULL;
+        FILE *from_file;
+
+        g_progname = llist_pop(&list_f);
+        from_file = xfopen_stdin(g_progname);
+        /* one byte is reserved for some trick in next_token */
+        for (i = j = 1; j > 0; i += j) {
+            s = xrealloc(s, i + 4096);
+            j = fread(s + i, 1, 4094, from_file);
+        }
+        s[i] = '\0';
+        fclose(from_file);
+        parse_program(s + 1);
+        free(s);
+    }
+    g_progname = "cmd. line";
+#if ENABLE_FEATURE_AWK_GNU_EXTENSIONS
+    while (list_e) {
+        parse_program(llist_pop(&list_e));
+    }
+#endif
+    if (!(opt & (OPT_f | OPT_e))) {
+        if (!*argv)
             bb_show_usage();
-        g_progname = "cmd. line";
         parse_program(*argv++);
-    }
-    if (opt & 0x8) // -W
-        bb_error_msg("warning: option -W is ignored");
+        argc--;
+    }
 
     /* fill in ARGV array */
-    setvar_i(intvar[ARGC], argc);
+    setvar_i(intvar[ARGC], argc + 1);
     setari_u(intvar[ARGV], 0, "awk");
     i = 0;

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

@@ -10 +10 @@
 /* BB_AUDIT SUSv3 (virtually) compliant -- uses nicer GNU format for -l. */
 /* http://www.opengroup.org/onlinepubs/007904975/utilities/cmp.html */
+
+//config:config CMP
+//config:   bool "cmp"
+//config:   default y
+//config:   help
+//config:     cmp is used to compare two files and returns the result
+//config:     to standard output.
+
+//kbuild:lib-$(CONFIG_CMP) += cmp.o
+
+//applet:IF_CMP(APPLET(cmp, BB_DIR_USR_BIN, BB_SUID_DROP))
 
 //usage:#define cmp_trivial_usage

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

@@ -77 +77 @@
  */
 
+//config:config DIFF
+//config:   bool "diff"
+//config:   default y
+//config:   help
+//config:     diff compares two files or directories and outputs the
+//config:     differences between them in a form that can be given to
+//config:     the patch command.
+//config:
+//config:config FEATURE_DIFF_LONG_OPTIONS
+//config:   bool "Enable long options"
+//config:   default y
+//config:   depends on DIFF && LONG_OPTS
+//config:   help
+//config:     Enable use of long options.
+//config:
+//config:config FEATURE_DIFF_DIR
+//config:   bool "Enable directory support"
+//config:   default y
+//config:   depends on DIFF
+//config:   help
+//config:     This option enables support for directory and subdirectory
+//config:     comparison.
+
+//kbuild:lib-$(CONFIG_DIFF) += diff.o
+
+//applet:IF_DIFF(APPLET(diff, BB_DIR_USR_BIN, BB_SUID_DROP))
+
 //usage:#define diff_trivial_usage
 //usage:       "[-abBdiNqrTstw] [-L LABEL] [-S FILE] [-U LINES] FILE1 FILE2"
@@ -99 +126 @@
 
 #include "libbb.h"
+#include "common_bufsiz.h"
 
 #if 0
@@ -337 +365 @@
 
 struct line {
-    /* 'serial' is not used in the begining, so we reuse it
+    /* 'serial' is not used in the beginning, so we reuse it
      * to store line offsets, thus reducing memory pressure
      */
@@ -407 +435 @@
             int c = fgetc(ft->ft_fp);
             if (c == EOF) {
-                printf("\n\\ No newline at end of file\n");
+                puts("\n\\ No newline at end of file");
                 return;
             }
@@ -632 +660 @@
 
                 for (j = 0; j < 2; j++)
-                    for (k = v[j].a; k < v[j].b; k++)
-                        nonempty |= (ix[j][k+1] - ix[j][k] != 1);
+                    for (k = v[j].a; k <= v[j].b; k++)
+                        nonempty |= (ix[j][k] - ix[j][k - 1] != 1);
 
                 vec = xrealloc_vector(vec, 6, ++idx);
@@ -666 +694 @@
                 printf(",%d", (a < b) ? b - a + 1 : 0);
             }
-            printf(" @@\n");
+            puts(" @@");
             /*
              * Output changes in "unified" diff format--the old and new lines
@@ -714 +742 @@
             if (bb_copyfd_eof(fd, fd_tmp) < 0)
                 xfunc_die();
-            if (fd) /* Prevents closing of stdin */
+            if (fd != STDIN_FILENO)
                 close(fd);
             fd = fd_tmp;
+            xlseek(fd, 0, SEEK_SET);
         }
         fp[i] = fdopen(fd, "r");
     }
 
+    setup_common_bufsiz();
     while (1) {
         const size_t sz = COMMON_BUFSIZE / 2;

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

@@ -8 +8 @@
  */
 
+//config:config ED
+//config:   bool "ed"
+//config:   default y
+//config:   help
+//config:     The original 1970's Unix text editor, from the days of teletypes.
+//config:     Small, simple, evil. Part of SUSv3. If you're not already using
+//config:     this, you don't need it.
+
+//kbuild:lib-$(CONFIG_ED) += ed.o
+
+//applet:IF_ED(APPLET(ed, BB_DIR_BIN, BB_SUID_DROP))
+
 //usage:#define ed_trivial_usage ""
 //usage:#define ed_full_usage ""
 
 #include "libbb.h"
+#include "common_bufsiz.h"
 
 typedef struct LINE {
@@ -24 +37 @@
 
 enum {
-    USERSIZE = sizeof(searchString) > 1024 ? 1024
-             : sizeof(searchString) - 1, /* max line length typed in by user */
+    USERSIZE = COMMON_BUFSIZE > 1024 ? 1024
+             : COMMON_BUFSIZE - 1, /* max line length typed in by user */
     INITBUF_SIZE = 1024, /* initial buffer size */
 };
@@ -55 +68 @@
 #define marks              (G.marks             )
 #define INIT_G() do { \
+    setup_common_bufsiz(); \
     SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
 } while (0)
@@ -195 +209 @@
                     printf("\"%s\"\n", fileName);
                 else
-                    printf("No file name\n");
+                    puts("No file name");
                 break;
             }
@@ -721 +735 @@
         bufUsed += cc;
         bufPtr = bufBase;
-
     } while (cc > 0);
 

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

@@ -346 +346 @@
 // state 2: In hunk: counting initial context lines
 // state 3: In hunk: getting body
+// Like GNU patch, we don't require a --- line before the +++, and
+// also allow the --- after the +++ line.
 
 int patch_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
@@ -371 +373 @@
         }
     }
-    if (argv[0]) {
-        oldname = xstrdup(argv[0]);
-        newname = xstrdup(argv[0]);
-    }
 
     // Loop through the lines in the patch
@@ -413 +411 @@
 
         // Open a new file?
-        if (!strncmp("--- ", patchline, 4) || !strncmp("+++ ", patchline, 4)) {
+        if (is_prefixed_with(patchline, "--- ") || is_prefixed_with(patchline, "+++ ")) {
             char *s, **name = reverse ? &newname : &oldname;
             int i;
@@ -445 +443 @@
         // Start a new hunk?  Usually @@ -oldline,oldlen +newline,newlen @@
         // but a missing ,value means the value is 1.
-        } else if (state == 1 && !strncmp("@@ -", patchline, 4)) {
+        } else if (state == 1 && is_prefixed_with(patchline, "@@ -")) {
             int i;
             char *s = patchline+4;
@@ -463 +461 @@
             state = 2;
 
+            // If the --- line is missing or malformed, either oldname
+            // or (for -R) newname could be NULL -- but not both.  Like
+            // GNU patch, proceed based on the +++ line, and avoid SEGVs.
+            if (!oldname)
+                oldname = xstrdup("MISSING_FILENAME");
+            if (!newname)
+                newname = xstrdup("MISSING_FILENAME");
+
             // If this is the first hunk, open the file.
             if (TT.filein == -1) {
@@ -477 +483 @@
                 if (!strcmp(name, "/dev/null") || !(reverse ? oldsum : newsum)) {
                     name = reverse ? newname : oldname;
-                    empty++;
+                    empty = 1;
                 }
 
-                // handle -p path truncation.
+                // Handle -p path truncation.
                 for (i = 0, s = name; *s;) {
                     if ((option_mask32 & FLAG_PATHLEN) && TT.prefix == i)
@@ -491 +497 @@
                     name = s;
                 }
+                // If "patch FILE_TO_PATCH", completely ignore name from patch
+                if (argv[0])
+                    name = argv[0];
 
                 if (empty) {

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

@@ -189 +189 @@
             unsigned dst_last_line = 1;
 
-            if ((sscanf(patch_line, "@@ -%d,%d +%d,%d", &src_beg_line, &src_last_line, &dst_beg_line, &dst_last_line) < 3)
-             && (sscanf(patch_line, "@@ -%d +%d,%d", &src_beg_line, &dst_beg_line, &dst_last_line) < 2)
+            if ((sscanf(patch_line, "@@ -%u,%u +%u,%u", &src_beg_line, &src_last_line, &dst_beg_line, &dst_last_line) < 3)
+             && (sscanf(patch_line, "@@ -%u +%u,%u", &src_beg_line, &dst_beg_line, &dst_last_line) < 2)
             ) {
                 /* No more hunks for this file */

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

@@ -23 +23 @@
  * resulting sed_cmd_t structures are appended to a linked list
  * (G.sed_cmd_head/G.sed_cmd_tail).
- *
- * add_input_file() adds a FILE* to the list of input files.  We need to
- * know all input sources ahead of time to find the last line for the $ match.
  *
  * process_files() does actual sedding, reading data lines from each input FILE*
@@ -57 +54 @@
  * http://www.opengroup.org/onlinepubs/007904975/utilities/sed.html
  * http://pubs.opengroup.org/onlinepubs/9699919799/utilities/sed.html
+ * http://sed.sourceforge.net/sedfaq3.html
  */
 
+//config:config SED
+//config:   bool "sed"
+//config:   default y
+//config:   help
+//config:     sed is used to perform text transformations on a file
+//config:     or input from a pipeline.
+
+//kbuild:lib-$(CONFIG_SED) += sed.o
+
+//applet:IF_SED(APPLET(sed, BB_DIR_BIN, BB_SUID_DROP))
+
 //usage:#define sed_trivial_usage
-//usage:       "[-inr] [-f FILE]... [-e CMD]... [FILE]...\n"
-//usage:       "or: sed [-inr] CMD [FILE]..."
+//usage:       "[-inrE] [-f FILE]... [-e CMD]... [FILE]...\n"
+//usage:       "or: sed [-inrE] CMD [FILE]..."
 //usage:#define sed_full_usage "\n\n"
 //usage:       "    -e CMD  Add CMD to sed commands to be executed"
@@ -68 +77 @@
 //usage:     "\n        Optionally back files up, appending SFX"
 //usage:     "\n    -n  Suppress automatic printing of pattern space"
-//usage:     "\n    -r  Use extended regex syntax"
+//usage:     "\n    -r,-E   Use extended regex syntax"
 //usage:     "\n"
 //usage:     "\nIf no -e or -f, the first non-option argument is the sed command string."
@@ -78 +87 @@
 
 #include "libbb.h"
+#include "common_bufsiz.h"
 #include "xregex.h"
 
@@ -102 +112 @@
     int beg_line;           /* 'sed 1p'   0 == apply commands to all lines */
     int beg_line_orig;      /* copy of the above, needed for -i */
-    int end_line;           /* 'sed 1,3p' 0 == one line only. -1 = last line ($) */
-
-    FILE *sw_file;          /* File (sw) command writes to, -1 for none. */
+    int end_line;           /* 'sed 1,3p' 0 == one line only. -1 = last line ($). -2-N = +N */
+    int end_line_orig;
+
+    FILE *sw_file;          /* File (sw) command writes to, NULL for none. */
     char *string;           /* Data string for (saicytb) commands. */
 
@@ -125 +136 @@
     /* options */
     int be_quiet, regex_type;
+
     FILE *nonstdout;
     char *outname, *hold_space;
-
-    /* List of input files */
-    int input_file_count, current_input_file;
-    FILE **input_file_list;
+    smallint exitcode;
+
+    /* list of input files */
+    int current_input_file, last_input_file;
+    char **input_file_list;
+    FILE *current_fp;
 
     regmatch_t regmatch[10];
@@ -138 +152 @@
     sed_cmd_t *sed_cmd_head, **sed_cmd_tail;
 
-    /* Linked list of append lines */
+    /* linked list of append lines */
     llist_t *append_head;
 
@@ -149 +163 @@
     } pipeline;
 } FIX_ALIASING;
-#define G (*(struct globals*)&bb_common_bufsiz1)
-struct BUG_G_too_big {
-    char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
-};
+#define G (*(struct globals*)bb_common_bufsiz1)
 #define INIT_G() do { \
+    setup_common_bufsiz(); \
+    BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
     G.sed_cmd_tail = &G.sed_cmd_head; \
 } while (0)
@@ -169 +182 @@
 
         if (sed_cmd->sw_file)
-            xprint_and_close_file(sed_cmd->sw_file);
+            fclose(sed_cmd->sw_file);
 
         if (sed_cmd->beg_match) {
@@ -190 +203 @@
     free(G.hold_space);
 
-    while (G.current_input_file < G.input_file_count)
-        fclose(G.input_file_list[G.current_input_file++]);
+    if (G.current_fp)
+        fclose(G.current_fp);
 }
 #else
@@ -206 +219 @@
 /* strcpy, replacing "\from" with 'to'. If to is NUL, replacing "\any" with 'any' */
 
-static void parse_escapes(char *dest, const char *string, int len, char from, char to)
-{
+static unsigned parse_escapes(char *dest, const char *string, int len, char from, char to)
+{
+    char *d = dest;
     int i = 0;
+
+    if (len == -1)
+        len = strlen(string);
 
     while (i < len) {
         if (string[i] == '\\') {
             if (!to || string[i+1] == from) {
-                *dest++ = to ? to : string[i+1];
+                if ((*d = to ? to : string[i+1]) == '\0')
+                    return d - dest;
                 i += 2;
+                d++;
                 continue;
             }
-            *dest++ = string[i++];
-        }
-        /* TODO: is it safe wrt a string with trailing '\\' ? */
-        *dest++ = string[i++];
-    }
-    *dest = '\0';
+            i++; /* skip backslash in string[] */
+            *d++ = '\\';
+            /* fall through: copy next char verbatim */
+        }
+        if ((*d = string[i++]) == '\0')
+            return d - dest;
+        d++;
+    }
+    *d = '\0';
+    return d - dest;
 }
 
@@ -233 +256 @@
     /* GNU sed also recognizes \t and \r */
     for (s = "\nn\tt\rr"; *s; s += 2) {
-        parse_escapes(dest, string, len, s[1], s[0]);
+        len = parse_escapes(dest, string, len, s[1], s[0]);
         string = dest;
-        len = strlen(dest);
     }
     return dest;
@@ -331 +353 @@
         temp = copy_parsing_escapes(pos, next);
         *regex = xzalloc(sizeof(regex_t));
-        xregcomp(*regex, temp, G.regex_type|REG_NEWLINE);
+        xregcomp(*regex, temp, G.regex_type);
         free(temp);
         /* Move position to next character after last delimiter */
@@ -371 +393 @@
     /*
      * A substitution command should look something like this:
-     *    s/match/replace/ #gIpw
+     *    s/match/replace/ #giIpw
      *    ||     |        |||
      *    mandatory       optional
@@ -385 +407 @@
 
     sed_cmd->which_match = 1;
+    dbg("s flags:'%s'", substr + idx + 1);
     while (substr[++idx]) {
+        dbg("s flag:'%c'", substr[idx]);
         /* Parse match number */
         if (isdigit(substr[idx])) {
@@ -393 +417 @@
 /* FIXME: error check? */
                 sed_cmd->which_match = (unsigned)strtol(substr+idx, (char**) &pos, 10);
-                idx = pos - substr;
+                idx = pos - substr - 1;
             }
             continue;
@@ -414 +438 @@
         case 'w':
         {
-            char *temp;
-            idx += parse_file_cmd(/*sed_cmd,*/ substr+idx, &temp);
+            char *fname;
+            idx += parse_file_cmd(/*sed_cmd,*/ substr+idx+1, &fname);
+            sed_cmd->sw_file = xfopen_for_write(fname);
+            sed_cmd->sw_last_char = '\n';
+            free(fname);
             break;
         }
         /* Ignore case (gnu exension) */
+        case 'i':
         case 'I':
             cflags |= REG_ICASE;
@@ -432 +460 @@
             goto out;
         default:
+            dbg("s bad flags:'%s'", substr + idx);
             bb_error_msg_and_die("bad option in substitution expression");
         }
@@ -454 +483 @@
 static const char *parse_cmd_args(sed_cmd_t *sed_cmd, const char *cmdstr)
 {
-    static const char cmd_letters[] = "saicrw:btTydDgGhHlnNpPqx={}";
+    static const char cmd_letters[] ALIGN1 = "saicrw:btTydDgGhHlnNpPqx={}";
     enum {
         IDX_s = 0,
@@ -485 +514 @@
         IDX_nul
     };
-    struct chk { char chk[sizeof(cmd_letters)-1 == IDX_nul ? 1 : -1]; };
-
-    unsigned idx = strchrnul(cmd_letters, sed_cmd->cmd) - cmd_letters;
+    unsigned idx;
+
+    BUILD_BUG_ON(sizeof(cmd_letters)-1 != IDX_nul);
+
+    idx = strchrnul(cmd_letters, sed_cmd->cmd) - cmd_letters;
 
     /* handle (s)ubstitution command */
@@ -495 +526 @@
     /* handle edit cmds: (a)ppend, (i)nsert, and (c)hange */
     else if (idx <= IDX_c) { /* a,i,c */
+        unsigned len;
+
         if (idx < IDX_c) { /* a,i */
             if (sed_cmd->end_line || sed_cmd->end_match)
@@ -508 +541 @@
             cmdstr++;
         }
-        sed_cmd->string = xstrdup(cmdstr);
+        len = strlen(cmdstr);
+        sed_cmd->string = copy_parsing_escapes(cmdstr, len);
+        cmdstr += len;
         /* "\anychar" -> "anychar" */
-        parse_escapes(sed_cmd->string, sed_cmd->string, strlen(cmdstr), '\0', '\0');
-        cmdstr += strlen(cmdstr);
+        parse_escapes(sed_cmd->string, sed_cmd->string, -1, '\0', '\0');
     }
     /* handle file cmds: (r)ead */
@@ -543 +577 @@
         cmdstr += parse_regex_delim(cmdstr, &match, &replace)+1;
         /* \n already parsed, but \delimiter needs unescaping. */
-        parse_escapes(match, match, strlen(match), i, i);
-        parse_escapes(replace, replace, strlen(replace), i, i);
+        parse_escapes(match,   match,   -1, i, i);
+        parse_escapes(replace, replace, -1, i, i);
 
         sed_cmd->string = xzalloc((strlen(match) + 1) * 2);
@@ -626 +660 @@
 
             cmdstr++;
-            idx = get_address(cmdstr, &sed_cmd->end_line, &sed_cmd->end_match);
-            if (!idx)
+            if (*cmdstr == '+' && isdigit(cmdstr[1])) {
+                /* http://sed.sourceforge.net/sedfaq3.html#s3.3
+                 * Under GNU sed 3.02+, ssed, and sed15+, <address2>
+                 * may also be a notation of the form +num,
+                 * indicating the next num lines after <address1> is
+                 * matched.
+                 * GNU sed 4.2.1 accepts even "+" (meaning "+0").
+                 * We don't (we check for isdigit, see above), think
+                 * about the "+-3" case.
+                 */
+                char *end;
+                /* code is smaller compared to using &cmdstr here: */
+                idx = strtol(cmdstr+1, &end, 10);
+                sed_cmd->end_line = -2 - idx;
+                cmdstr = end;
+            } else {
+                idx = get_address(cmdstr, &sed_cmd->end_line, &sed_cmd->end_match);
+                cmdstr += idx;
+                idx--; /* if 0, trigger error check below */
+            }
+            if (idx < 0)
                 bb_error_msg_and_die("no address after comma");
-            cmdstr += idx;
+            sed_cmd->end_line_orig = sed_cmd->end_line;
         }
 
@@ -649 +702 @@
         sed_cmd->cmd = *cmdstr++;
         cmdstr = parse_cmd_args(sed_cmd, cmdstr);
+
+        /* cmdstr now points past args.
+         * GNU sed requires a separator, if there are more commands,
+         * else it complains "char N: extra characters after command".
+         * Example: "sed 'p;d'". We also allow "sed 'pd'".
+         */
 
         /* Add the command to the command array */
@@ -843 +902 @@
 static void append(char *s)
 {
-    llist_add_to_end(&G.append_head, xstrdup(s));
-}
-
-static void flush_append(void)
-{
-    char *data;
-
-    /* Output appended lines. */
-    while ((data = (char *)llist_pop(&G.append_head))) {
-        fprintf(G.nonstdout, "%s\n", data);
-        free(data);
-    }
-}
-
-static void add_input_file(FILE *file)
-{
-    G.input_file_list = xrealloc_vector(G.input_file_list, 2, G.input_file_count);
-    G.input_file_list[G.input_file_count++] = file;
-}
-
-/* Get next line of input from G.input_file_list, flushing append buffer and
- * noting if we ran out of files without a newline on the last line we read.
+    llist_add_to_end(&G.append_head, s);
+}
+
+/* Output line of text. */
+/* Note:
+ * The tricks with NO_EOL_CHAR and last_puts_char are there to emulate gnu sed.
+ * Without them, we had this:
+ * echo -n thingy >z1
+ * echo -n again >z2
+ * >znull
+ * sed "s/i/z/" z1 z2 znull | hexdump -vC
+ * output:
+ * gnu sed 4.1.5:
+ * 00000000  74 68 7a 6e 67 79 0a 61  67 61 7a 6e              |thzngy.agazn|
+ * bbox:
+ * 00000000  74 68 7a 6e 67 79 61 67  61 7a 6e                 |thzngyagazn|
  */
 enum {
@@ -870 +923 @@
     LAST_IS_NUL = 2,
 };
-static char *get_next_line(char *gets_char)
+static void puts_maybe_newline(char *s, FILE *file, char *last_puts_char, char last_gets_char)
+{
+    char lpc = *last_puts_char;
+
+    /* Need to insert a '\n' between two files because first file's
+     * last line wasn't terminated? */
+    if (lpc != '\n' && lpc != '\0') {
+        fputc('\n', file);
+        lpc = '\n';
+    }
+    fputs(s, file);
+
+    /* 'x' - just something which is not '\n', '\0' or NO_EOL_CHAR */
+    if (s[0])
+        lpc = 'x';
+
+    /* had trailing '\0' and it was last char of file? */
+    if (last_gets_char == LAST_IS_NUL) {
+        fputc('\0', file);
+        lpc = 'x'; /* */
+    } else
+    /* had trailing '\n' or '\0'? */
+    if (last_gets_char != NO_EOL_CHAR) {
+        fputc(last_gets_char, file);
+        lpc = last_gets_char;
+    }
+
+    if (ferror(file)) {
+        xfunc_error_retval = 4;  /* It's what gnu sed exits with... */
+        bb_error_msg_and_die(bb_msg_write_error);
+    }
+    *last_puts_char = lpc;
+}
+
+static void flush_append(char *last_puts_char)
+{
+    char *data;
+
+    /* Output appended lines. */
+    while ((data = (char *)llist_pop(&G.append_head)) != NULL) {
+        /* Append command does not respect "nonterminated-ness"
+         * of last line. Try this:
+         * $ echo -n "woot" | sed -e '/woot/a woo' -
+         * woot
+         * woo
+         * (both lines are terminated with \n)
+         * Therefore we do not propagate "last_gets_char" here,
+         * pass '\n' instead:
+         */
+        puts_maybe_newline(data, G.nonstdout, last_puts_char, '\n');
+        free(data);
+    }
+}
+
+/* Get next line of input from G.input_file_list, flushing append buffer and
+ * noting if we ran out of files without a newline on the last line we read.
+ */
+static char *get_next_line(char *gets_char, char *last_puts_char)
 {
     char *temp = NULL;
@@ -876 +986 @@
     char gc;
 
-    flush_append();
+    flush_append(last_puts_char);
 
     /* will be returned if last line in the file
      * doesn't end with either '\n' or '\0' */
     gc = NO_EOL_CHAR;
-    while (G.current_input_file < G.input_file_count) {
-        FILE *fp = G.input_file_list[G.current_input_file];
+    for (; G.current_input_file <= G.last_input_file; G.current_input_file++) {
+        FILE *fp = G.current_fp;
+        if (!fp) {
+            const char *path = G.input_file_list[G.current_input_file];
+            fp = stdin;
+            if (path != bb_msg_standard_input) {
+                fp = fopen_or_warn(path, "r");
+                if (!fp) {
+                    G.exitcode = EXIT_FAILURE;
+                    continue;
+                }
+            }
+            G.current_fp = fp;
+        }
         /* Read line up to a newline or NUL byte, inclusive,
          * return malloc'ed char[]. length of the chunk read
@@ -913 +1035 @@
         }
         /* Close this file and advance to next one */
-        fclose(fp);
-        G.current_input_file++;
+        fclose_if_not_stdin(fp);
+        G.current_fp = NULL;
     }
     *gets_char = gc;
     return temp;
-}
-
-/* Output line of text. */
-/* Note:
- * The tricks with NO_EOL_CHAR and last_puts_char are there to emulate gnu sed.
- * Without them, we had this:
- * echo -n thingy >z1
- * echo -n again >z2
- * >znull
- * sed "s/i/z/" z1 z2 znull | hexdump -vC
- * output:
- * gnu sed 4.1.5:
- * 00000000  74 68 7a 6e 67 79 0a 61  67 61 7a 6e              |thzngy.agazn|
- * bbox:
- * 00000000  74 68 7a 6e 67 79 61 67  61 7a 6e                 |thzngyagazn|
- */
-static void puts_maybe_newline(char *s, FILE *file, char *last_puts_char, char last_gets_char)
-{
-    char lpc = *last_puts_char;
-
-    /* Need to insert a '\n' between two files because first file's
-     * last line wasn't terminated? */
-    if (lpc != '\n' && lpc != '\0') {
-        fputc('\n', file);
-        lpc = '\n';
-    }
-    fputs(s, file);
-
-    /* 'x' - just something which is not '\n', '\0' or NO_EOL_CHAR */
-    if (s[0])
-        lpc = 'x';
-
-    /* had trailing '\0' and it was last char of file? */
-    if (last_gets_char == LAST_IS_NUL) {
-        fputc('\0', file);
-        lpc = 'x'; /* */
-    } else
-    /* had trailing '\n' or '\0'? */
-    if (last_gets_char != NO_EOL_CHAR) {
-        fputc(last_gets_char, file);
-        lpc = last_gets_char;
-    }
-
-    if (ferror(file)) {
-        xfunc_error_retval = 4;  /* It's what gnu sed exits with... */
-        bb_error_msg_and_die(bb_msg_write_error);
-    }
-    *last_puts_char = lpc;
 }
 
@@ -990 +1064 @@
 
     /* Prime the pump */
-    next_line = get_next_line(&next_gets_char);
+    next_line = get_next_line(&next_gets_char, &last_puts_char);
 
     /* Go through every line in each file */
@@ -1004 +1078 @@
     /* Read one line in advance so we can act on the last line,
      * the '$' address */
-    next_line = get_next_line(&next_gets_char);
+    next_line = get_next_line(&next_gets_char, &last_puts_char);
     linenum++;
 
@@ -1063 +1137 @@
 
         if (matched) {
+            if (sed_cmd->end_line <= -2) {
+                /* address2 is +N, i.e. N lines from beg_line */
+                sed_cmd->end_line = linenum + (-sed_cmd->end_line - 2);
+            }
             /* once matched, "n,xxx" range is dead, disabling it */
             if (sed_cmd->beg_line > 0) {
                 sed_cmd->beg_line = -2;
             }
+            dbg("end1:%d", sed_cmd->end_line ? sed_cmd->end_line == -1
+                        ? !next_line : (sed_cmd->end_line <= linenum)
+                    : !sed_cmd->end_match);
+            dbg("end2:%d", sed_cmd->end_match && old_matched
+                    && !regexec(sed_cmd->end_match,pattern_space, 0, NULL, 0));
             sed_cmd->in_match = !(
                 /* has the ending line come, or is this a single address command? */
@@ -1176 +1259 @@
         /* Append line to linked list to be printed later */
         case 'a':
-            append(sed_cmd->string);
+            append(xstrdup(sed_cmd->string));
             break;
 
@@ -1198 +1281 @@
             if (rfile) {
                 char *line;
-
                 while ((line = xmalloc_fgetline(rfile))
                         != NULL)
                     append(line);
-                xprint_and_close_file(rfile);
+                fclose(rfile);
             }
 
@@ -1223 +1305 @@
                 pattern_space = next_line;
                 last_gets_char = next_gets_char;
-                next_line = get_next_line(&next_gets_char);
+                next_line = get_next_line(&next_gets_char, &last_puts_char);
                 substituted = 0;
                 linenum++;
@@ -1259 +1341 @@
             strcpy(pattern_space + len+1, next_line);
             last_gets_char = next_gets_char;
-            next_line = get_next_line(&next_gets_char);
+            next_line = get_next_line(&next_gets_char, &last_puts_char);
             linenum++;
             break;
@@ -1363 +1445 @@
     /* Delete and such jump here. */
  discard_line:
-    flush_append();
+    flush_append(&last_puts_char /*,last_gets_char*/);
     free(pattern_space);
 
@@ -1372 +1454 @@
  * newlines.  This counts as multiple command lines.
  * However, newline can be escaped: 's/e/z\<newline>z/'
- * We check for this.
+ * add_cmd() handles this.
  */
 
@@ -1382 +1464 @@
     do {
         eol = strchr(cmdstr, '\n');
- next:
-        if (eol) {
-            /* Count preceding slashes */
-            int slashes = 0;
-            char *sl = eol;
-
-            while (sl != cmdstr && *--sl == '\\')
-                slashes++;
-            /* Odd number of preceding slashes - newline is escaped */
-            if (slashes & 1) {
-                overlapping_strcpy(eol - 1, eol);
-                eol = strchr(eol, '\n');
-                goto next;
-            }
+        if (eol)
             *eol = '\0';
-        }
         add_cmd(cmdstr);
         cmdstr = eol + 1;
@@ -1422 +1490 @@
 #endif
 
-    int status = EXIT_SUCCESS;
-
     INIT_G();
 
@@ -1444 +1510 @@
 
     /* -i must be first, to match OPT_in_place definition */
-    opt = getopt32(argv, "i::rne:f:", &opt_i, &opt_e, &opt_f,
+    /* -E is a synonym of -r:
+     * GNU sed 4.2.1 mentions it in neither --help
+     * nor manpage, but does recognize it.
+     */
+    opt = getopt32(argv, "i::rEne:f:", &opt_i, &opt_e, &opt_f,
                 &G.be_quiet); /* counter for -n */
     //argc -= optind;
@@ -1451 +1521 @@
         atexit(cleanup_outname);
     }
-    if (opt & 0x2) G.regex_type |= REG_EXTENDED; // -r
-    //if (opt & 0x4) G.be_quiet++; // -n
+    if (opt & (2|4))
+        G.regex_type |= REG_EXTENDED; // -r or -E
+    //if (opt & 8)
+    //  G.be_quiet++; // -n (implemented with a counter instead)
     while (opt_e) { // -e
         add_cmd_block(llist_pop(&opt_e));
@@ -1459 +1531 @@
         char *line;
         FILE *cmdfile;
-        cmdfile = xfopen_for_read(llist_pop(&opt_f));
+        cmdfile = xfopen_stdin(llist_pop(&opt_f));
         while ((line = xmalloc_fgetline(cmdfile)) != NULL) {
             add_cmd(line);
             free(line);
         }
-        fclose(cmdfile);
+        fclose_if_not_stdin(cmdfile);
     }
     /* if we didn't get a pattern from -e or -f, use argv[0] */
-    if (!(opt & 0x18)) {
+    if (!(opt & 0x30)) {
         if (!*argv)
             bb_show_usage();
@@ -1481 +1553 @@
      * files were specified or '-' was specified, take input from stdin.
      * Otherwise, we process all the files specified. */
-    if (argv[0] == NULL) {
+    G.input_file_list = argv;
+    if (!argv[0]) {
         if (opt & OPT_in_place)
             bb_error_msg_and_die(bb_msg_requires_arg, "-i");
-        add_input_file(stdin);
+        argv[0] = (char*)bb_msg_standard_input;
+        /* G.last_input_file = 0; - already is */
     } else {
-        int i;
-
-        for (i = 0; argv[i]; i++) {
+        goto start;
+
+        for (; *argv; argv++) {
             struct stat statbuf;
             int nonstdoutfd;
-            FILE *file;
             sed_cmd_t *sed_cmd;
 
-            if (LONE_DASH(argv[i]) && !(opt & OPT_in_place)) {
-                add_input_file(stdin);
-                process_files();
+            G.last_input_file++;
+ start:
+            if (!(opt & OPT_in_place)) {
+                if (LONE_DASH(*argv)) {
+                    *argv = (char*)bb_msg_standard_input;
+                    process_files();
+                }
                 continue;
             }
-            file = fopen_or_warn(argv[i], "r");
-            if (!file) {
-                status = EXIT_FAILURE;
+
+            /* -i: process each FILE separately: */
+
+            if (stat(*argv, &statbuf) != 0) {
+                bb_simple_perror_msg(*argv);
+                G.exitcode = EXIT_FAILURE;
+                G.current_input_file++;
                 continue;
             }
-            add_input_file(file);
-            if (!(opt & OPT_in_place)) {
-                continue;
-            }
-
-            /* -i: process each FILE separately: */
-
-            G.outname = xasprintf("%sXXXXXX", argv[i]);
+            G.outname = xasprintf("%sXXXXXX", *argv);
             nonstdoutfd = xmkstemp(G.outname);
             G.nonstdout = xfdopen_for_write(nonstdoutfd);
-
             /* Set permissions/owner of output file */
-            fstat(fileno(file), &statbuf);
             /* chmod'ing AFTER chown would preserve suid/sgid bits,
              * but GNU sed 4.2.1 does not preserve them either */
@@ -1527 +1599 @@
 
             if (opt_i) {
-                char *backupname = xasprintf("%s%s", argv[i], opt_i);
-                xrename(argv[i], backupname);
+                char *backupname = xasprintf("%s%s", *argv, opt_i);
+                xrename(*argv, backupname);
                 free(backupname);
             }
-            /* else unlink(argv[i]); - rename below does this */
-            xrename(G.outname, argv[i]); //TODO: rollback backup on error?
+            /* else unlink(*argv); - rename below does this */
+            xrename(G.outname, *argv); //TODO: rollback backup on error?
             free(G.outname);
             G.outname = NULL;
 
-            /* Re-enable disabled range matches */
+            /* Fix disabled range matches and mangled ",+N" ranges */
             for (sed_cmd = G.sed_cmd_head; sed_cmd; sed_cmd = sed_cmd->next) {
                 sed_cmd->beg_line = sed_cmd->beg_line_orig;
+                sed_cmd->end_line = sed_cmd->end_line_orig;
             }
         }
         /* Here, to handle "sed 'cmds' nonexistent_file" case we did:
-         * if (G.current_input_file >= G.input_file_count)
-         *  return status;
+         * if (G.current_input_file[G.current_input_file] == NULL)
+         *  return G.exitcode;
          * but it's not needed since process_files() works correctly
          * in this case too. */
     }
+
     process_files();
 
-    return status;
-}
+    return G.exitcode;
+}

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;
     }