Changeset 3232 in MondoRescue for branches/3.2/mindi-busybox/editors

Timestamp:

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

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.21.1

Location:

branches/3.2/mindi-busybox/editors

Files:

• Config.src (modified) (1 diff)
• Kbuild.src (modified) (1 diff)
• awk.c (modified) (49 diffs)
• cmp.c (modified) (1 diff)
• diff.c (modified) (6 diffs)
• ed.c (modified) (5 diffs)
• patch.c (modified) (17 diffs)
• sed.c (modified) (37 diffs)
• vi.c (modified) (66 diffs)

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

@@ -68 +68 @@
       or input from a pipeline.
 
-config VI
-    bool "vi"
-    default y
-    help
-      'vi' is a text editor. More specifically, it is the One True
-      text editor <grin>. It does, however, have a rather steep
-      learning curve. If you are not already comfortable with 'vi'
-      you may wish to use something else.
-
-config FEATURE_VI_MAX_LEN
-    int "Maximum screen width in vi"
-    range 256 16384
-    default 4096
-    depends on VI
-    help
-      Contrary to what you may think, this is not eating much.
-      Make it smaller than 4k only if you are very limited on memory.
-
-config FEATURE_VI_8BIT
-    bool "Allow vi to display 8-bit chars (otherwise shows dots)"
-    default n
-    depends on VI
-    help
-      If your terminal can display characters with high bit set,
-      you may want to enable this. Note: vi is not Unicode-capable.
-      If your terminal combines several 8-bit bytes into one character
-      (as in Unicode mode), this will not work properly.
-
-config FEATURE_VI_COLON
-    bool "Enable \":\" colon commands (no \"ex\" mode)"
-    default y
-    depends on VI
-    help
-      Enable a limited set of colon commands for vi. This does not
-      provide an "ex" mode.
-
-config FEATURE_VI_YANKMARK
-    bool "Enable yank/put commands and mark cmds"
-    default y
-    depends on VI
-    help
-      This will enable you to use yank and put, as well as mark in
-      busybox vi.
-
-config FEATURE_VI_SEARCH
-    bool "Enable search and replace cmds"
-    default y
-    depends on VI
-    help
-      Select this if you wish to be able to do search and replace in
-      busybox vi.
-
-config FEATURE_VI_USE_SIGNALS
-    bool "Catch signals"
-    default y
-    depends on VI
-    help
-      Selecting this option will make busybox vi signal aware. This will
-      make busybox vi support SIGWINCH to deal with Window Changes, catch
-      Ctrl-Z and Ctrl-C and alarms.
-
-config FEATURE_VI_DOT_CMD
-    bool "Remember previous cmd and \".\" cmd"
-    default y
-    depends on VI
-    help
-      Make busybox vi remember the last command and be able to repeat it.
-
-config FEATURE_VI_READONLY
-    bool "Enable -R option and \"view\" mode"
-    default y
-    depends on VI
-    help
-      Enable the read-only command line option, which allows the user to
-      open a file in read-only mode.
-
-config FEATURE_VI_SETOPTS
-    bool "Enable set-able options, ai ic showmatch"
-    default y
-    depends on VI
-    help
-      Enable the editor to set some (ai, ic, showmatch) options.
-
-config FEATURE_VI_SET
-    bool "Support for :set"
-    default y
-    depends on VI
-    help
-      Support for ":set".
-
-config FEATURE_VI_WIN_RESIZE
-    bool "Handle window resize"
-    default y
-    depends on VI
-    help
-      Make busybox vi behave nicely with terminals that get resized.
-
-config FEATURE_VI_ASK_TERMINAL
-    bool "Use 'tell me cursor position' ESC sequence to measure window"
-    default y
-    depends on VI
-    help
-      If terminal size can't be retrieved and $LINES/$COLUMNS are not set,
-      this option makes vi perform a last-ditch effort to find it:
-      vi positions cursor to 999,999 and asks terminal to report real
-      cursor position using "ESC [ 6 n" escape sequence, then reads stdin.
-
-      This is not clean but helps a lot on serial lines and such.
-
-config FEATURE_VI_OPTIMIZE_CURSOR
-    bool "Optimize cursor movement"
-    default y
-    depends on VI
-    help
-      This will make the cursor movement faster, but requires more memory
-      and it makes the applet a tiny bit larger.
-
 config FEATURE_ALLOW_EXEC
     bool "Allow vi and awk to execute shell commands"

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

@@ -13 +13 @@
 lib-$(CONFIG_ED)        += ed.o
 lib-$(CONFIG_SED)       += sed.o
-lib-$(CONFIG_VI)        += vi.o

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

@@ -8 +8 @@
  */
 
+//usage:#define awk_trivial_usage
+//usage:       "[OPTIONS] [AWK_PROGRAM] [FILE]..."
+//usage:#define awk_full_usage "\n\n"
+//usage:       "    -v VAR=VAL  Set variable"
+//usage:     "\n    -F SEP      Use SEP as field separator"
+//usage:     "\n    -f FILE     Read program from FILE"
+
 #include "libbb.h"
 #include "xregex.h"
@@ -19 +26 @@
 #define debug_printf_walker(...)  do {} while (0)
 #define debug_printf_eval(...)  do {} while (0)
+#define debug_printf_parse(...)  do {} while (0)
 
 #ifndef debug_printf_walker
@@ -25 +33 @@
 #ifndef debug_printf_eval
 # define debug_printf_eval(...) (fprintf(stderr, __VA_ARGS__))
+#endif
+#ifndef debug_printf_parse
+# define debug_printf_parse(...) (fprintf(stderr, __VA_ARGS__))
 #endif
 
@@ -145 +156 @@
 /* simple token classes */
 /* Order and hex values are very important!!!  See next_token() */
-#define TC_SEQSTART  1              /* ( */
+#define TC_SEQSTART 1           /* ( */
 #define TC_SEQTERM  (1 << 1)        /* ) */
 #define TC_REGEXP   (1 << 2)        /* /.../ */
@@ -232 +243 @@
  * n - min. number of args, vN - resolve Nth arg to var, sN - resolve to string
  */
+#undef P
+#undef PRIMASK
+#undef PRIMASK2
 #define P(x)      (x << 24)
 #define PRIMASK   0x7F000000
@@ -426 +440 @@
     smallint nextfile;
     smallint is_f0_split;
+    smallint t_rollback;
 };
 struct globals2 {
@@ -432 +447 @@
     char *t_string;
     int t_lineno;
-    int t_rollback;
 
     var *intvar[NUM_INTERNAL_VARS]; /* often used */
@@ -490 +504 @@
 #define nextfile     (G1.nextfile    )
 #define is_f0_split  (G1.is_f0_split )
+#define t_rollback   (G1.t_rollback  )
 #define t_info       (G.t_info      )
 #define t_tclass     (G.t_tclass    )
 #define t_string     (G.t_string    )
 #define t_lineno     (G.t_lineno    )
-#define t_rollback   (G.t_rollback  )
 #define intvar       (G.intvar      )
 #define fsplitter    (G.fsplitter   )
@@ -683 +697 @@
     if (c == '\\')
         c = bb_process_escape_sequence((const char**)s);
+    /* Example awk statement:
+     * s = "abc\"def"
+     * we must treat \" as "
+     */
     if (c == '\\' && *s == pps) { /* unrecognized \z? */
         c = *(*s); /* yes, fetch z */
@@ -689 +707 @@
     }
     return c;
+}
+
+/* TODO: merge with strcpy_and_process_escape_sequences()?
+ */
+static void unescape_string_in_place(char *s1)
+{
+    char *s = s1;
+    while ((*s1 = nextchar(&s)) != '\0')
+        s1++;
 }
 
@@ -1002 +1029 @@
         if (*p == '\0') {
             tc = TC_EOF;
+            debug_printf_parse("%s: token found: TC_EOF\n", __func__);
 
         } else if (*p == '\"') {
@@ -1017 +1045 @@
             *s = '\0';
             tc = TC_STRING;
+            debug_printf_parse("%s: token found:'%s' TC_STRING\n", __func__, t_string);
 
         } else if ((expected & TC_REGEXP) && *p == '/') {
@@ -1039 +1068 @@
             *s = '\0';
             tc = TC_REGEXP;
+            debug_printf_parse("%s: token found:'%s' TC_REGEXP\n", __func__, t_string);
 
         } else if (*p == '.' || isdigit(*p)) {
@@ -1048 +1078 @@
                 syntax_error(EMSG_UNEXP_TOKEN);
             tc = TC_NUMBER;
+            debug_printf_parse("%s: token found:%f TC_NUMBER\n", __func__, t_double);
 
         } else {
@@ -1070 +1101 @@
                     /* then this is what we are looking for */
                     t_info = *ti;
+                    debug_printf_parse("%s: token found:'%.*s' t_info:%x\n", __func__, l, p, t_info);
                     p += l;
                     goto token_found;
@@ -1093 +1125 @@
             if (*p == '(') {
                 tc = TC_FUNCTION;
+                debug_printf_parse("%s: token found:'%s' TC_FUNCTION\n", __func__, t_string);
             } else {
                 if (*p == '[') {
                     p++;
                     tc = TC_ARRAY;
-                }
-            }
- token_found: ;
-        }
+                    debug_printf_parse("%s: token found:'%s' TC_ARRAY\n", __func__, t_string);
+                } else
+                    debug_printf_parse("%s: token found:'%s' TC_VARIABLE\n", __func__, t_string);
+            }
+        }
+ token_found:
         g_pos = p;
 
@@ -1172 +1207 @@
     var *v;
 
+    debug_printf_parse("%s(%x)\n", __func__, iexp);
+
     sn.info = PRIMASK;
     sn.r.n = glptr = NULL;
@@ -1180 +1217 @@
         if (glptr && (t_info == (OC_COMPARE | VV | P(39) | 2))) {
             /* input redirection (<) attached to glptr node */
+            debug_printf_parse("%s: input redir\n", __func__);
             cn = glptr->l.n = new_node(OC_CONCAT | SS | P(37));
             cn->a.n = glptr;
@@ -1186 +1224 @@
 
         } else if (tc & (TC_BINOP | TC_UOPPOST)) {
+            debug_printf_parse("%s: TC_BINOP | TC_UOPPOST\n", __func__);
             /* for binary and postfix-unary operators, jump back over
              * previous operators with higher priority */
@@ -1215 +1254 @@
 
         } else {
+            debug_printf_parse("%s: other\n", __func__);
             /* for operands and prefix-unary operators, attach them
              * to last node */
@@ -1222 +1262 @@
             xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP;
             if (tc & (TC_OPERAND | TC_REGEXP)) {
+                debug_printf_parse("%s: TC_OPERAND | TC_REGEXP\n", __func__);
                 xtc = TC_UOPPRE | TC_UOPPOST | TC_BINOP | TC_OPERAND | iexp;
                 /* one should be very careful with switch on tclass -
@@ -1228 +1269 @@
                 case TC_VARIABLE:
                 case TC_ARRAY:
+                    debug_printf_parse("%s: TC_VARIABLE | TC_ARRAY\n", __func__);
                     cn->info = OC_VAR;
                     v = hash_search(ahash, t_string);
@@ -1244 +1286 @@
                 case TC_NUMBER:
                 case TC_STRING:
+                    debug_printf_parse("%s: TC_NUMBER | TC_STRING\n", __func__);
                     cn->info = OC_VAR;
                     v = cn->l.v = xzalloc(sizeof(var));
@@ -1253 +1296 @@
 
                 case TC_REGEXP:
+                    debug_printf_parse("%s: TC_REGEXP\n", __func__);
                     mk_re_node(t_string, cn, xzalloc(sizeof(regex_t)*2));
                     break;
 
                 case TC_FUNCTION:
+                    debug_printf_parse("%s: TC_FUNCTION\n", __func__);
                     cn->info = OC_FUNC;
                     cn->r.f = newfunc(t_string);
@@ -1263 +1308 @@
 
                 case TC_SEQSTART:
+                    debug_printf_parse("%s: TC_SEQSTART\n", __func__);
                     cn = vn->r.n = parse_expr(TC_SEQTERM);
+                    if (!cn)
+                        syntax_error("Empty sequence");
                     cn->a.n = vn;
                     break;
 
                 case TC_GETLINE:
+                    debug_printf_parse("%s: TC_GETLINE\n", __func__);
                     glptr = cn;
                     xtc = TC_OPERAND | TC_UOPPRE | TC_BINOP | iexp;
@@ -1273 +1322 @@
 
                 case TC_BUILTIN:
+                    debug_printf_parse("%s: TC_BUILTIN\n", __func__);
                     cn->l.n = condition();
                     break;
@@ -1279 +1329 @@
         }
     }
+
+    debug_printf_parse("%s() returns %p\n", __func__, sn.r.n);
     return sn.r.n;
 }
@@ -1347 +1399 @@
 
     if (c & TC_GRPSTART) {
+        debug_printf_parse("%s: TC_GRPSTART\n", __func__);
         while (next_token(TC_GRPSEQ | TC_GRPTERM) != TC_GRPTERM) {
+            debug_printf_parse("%s: !TC_GRPTERM\n", __func__);
             if (t_tclass & TC_NEWLINE)
                 continue;
@@ -1353 +1407 @@
             chain_group();
         }
+        debug_printf_parse("%s: TC_GRPTERM\n", __func__);
     } else if (c & (TC_OPSEQ | TC_OPTERM)) {
+        debug_printf_parse("%s: TC_OPSEQ | TC_OPTERM\n", __func__);
         rollback_token();
         chain_expr(OC_EXEC | Vx);
-    } else {                        /* TC_STATEMNT */
+    } else {
+        /* TC_STATEMNT */
+        debug_printf_parse("%s: TC_STATEMNT(?)\n", __func__);
         switch (t_info & OPCLSMASK) {
         case ST_IF:
+            debug_printf_parse("%s: ST_IF\n", __func__);
             n = chain_node(OC_BR | Vx);
             n->l.n = condition();
@@ -1373 +1432 @@
 
         case ST_WHILE:
+            debug_printf_parse("%s: ST_WHILE\n", __func__);
             n2 = condition();
             n = chain_loop(NULL);
@@ -1379 +1439 @@
 
         case ST_DO:
+            debug_printf_parse("%s: ST_DO\n", __func__);
             n2 = chain_node(OC_EXEC);
             n = chain_loop(NULL);
@@ -1387 +1448 @@
 
         case ST_FOR:
+            debug_printf_parse("%s: ST_FOR\n", __func__);
             next_token(TC_SEQSTART);
             n2 = parse_expr(TC_SEMICOL | TC_SEQTERM);
@@ -1412 +1474 @@
         case OC_PRINT:
         case OC_PRINTF:
+            debug_printf_parse("%s: OC_PRINT[F]\n", __func__);
             n = chain_node(t_info);
             n->l.n = parse_expr(TC_OPTERM | TC_OUTRDR | TC_GRPTERM);
@@ -1423 +1486 @@
 
         case OC_BREAK:
+            debug_printf_parse("%s: OC_BREAK\n", __func__);
             n = chain_node(OC_EXEC);
             n->a.n = break_ptr;
@@ -1428 +1492 @@
 
         case OC_CONTINUE:
+            debug_printf_parse("%s: OC_CONTINUE\n", __func__);
             n = chain_node(OC_EXEC);
             n->a.n = continue_ptr;
@@ -1434 +1499 @@
         /* delete, next, nextfile, return, exit */
         default:
+            debug_printf_parse("%s: default\n", __func__);
             chain_expr(t_info);
         }
@@ -1451 +1517 @@
             TC_OPTERM | TC_BEGIN | TC_END | TC_FUNCDECL)) != TC_EOF) {
 
-        if (tclass & TC_OPTERM)
+        if (tclass & TC_OPTERM) {
+            debug_printf_parse("%s: TC_OPTERM\n", __func__);
             continue;
+        }
 
         seq = &mainseq;
         if (tclass & TC_BEGIN) {
+            debug_printf_parse("%s: TC_BEGIN\n", __func__);
             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__);
             next_token(TC_FUNCTION);
             g_pos++;
@@ -1481 +1552 @@
 
         } else if (tclass & TC_OPSEQ) {
+            debug_printf_parse("%s: TC_OPSEQ\n", __func__);
             rollback_token();
             cn = chain_node(OC_TEST);
             cn->l.n = parse_expr(TC_OPTERM | TC_EOF | TC_GRPSTART);
             if (t_tclass & TC_GRPSTART) {
+                debug_printf_parse("%s: TC_GRPSTART\n", __func__);
                 rollback_token();
                 chain_group();
             } else {
+                debug_printf_parse("%s: !TC_GRPSTART\n", __func__);
                 chain_node(OC_PRINT);
             }
@@ -1493 +1567 @@
 
         } else /* if (tclass & TC_GRPSTART) */ {
+            debug_printf_parse("%s: TC_GRPSTART(?)\n", __func__);
             rollback_token();
             chain_group();
         }
     }
+    debug_printf_parse("%s: TC_EOF\n", __func__);
 }
 
@@ -1737 +1813 @@
 
     } else if (v == intvar[FS]) {
+        /*
+         * The POSIX-2008 standard says that changing FS should have no effect on the
+         * current input line, but only on the next one. The language is:
+         *
+         * > Before the first reference to a field in the record is evaluated, the record
+         * > shall be split into fields, according to the rules in Regular Expressions,
+         * > using the value of FS that was current at the time the record was read.
+         *
+         * So, split up current line before assignment to FS:
+         */
+        split_f0();
+
         mk_splitter(getvar_s(v), &fsplitter);
 
@@ -2621 +2709 @@
             }
 
-            if (!rsm->F) {
+            if (!rsm || !rsm->F) {
                 setvar_i(intvar[ERRNO], errno);
                 setvar_i(res, -1);
@@ -2930 +3018 @@
 static int is_assignment(const char *expr)
 {
-    char *exprc, *val, *s, *s1;
+    char *exprc, *val;
 
     if (!isalnum_(*expr) || (val = strchr(expr, '=')) == NULL) {
@@ -2940 +3028 @@
     *val++ = '\0';
 
-    s = s1 = val;
-    while ((*s1 = nextchar(&s)) != '\0')
-        s1++;
-
+    unescape_string_in_place(val);
     setvar_u(newvar(exprc), val);
     free(exprc);
@@ -2955 +3040 @@
 #define files_happen (G.next_input_file__files_happen)
 
-    FILE *F = NULL;
+    FILE *F;
     const char *fname, *ind;
 
@@ -2963 +3048 @@
     rsm.pos = rsm.adv = 0;
 
-    do {
+    for (;;) {
         if (getvar_i(intvar[ARGIND])+1 >= getvar_i(intvar[ARGC])) {
             if (files_happen)
@@ -2969 +3054 @@
             fname = "-";
             F = stdin;
-        } else {
-            ind = getvar_s(incvar(intvar[ARGIND]));
-            fname = getvar_s(findvar(iamarray(intvar[ARGV]), ind));
-            if (fname && *fname && !is_assignment(fname))
-                F = xfopen_stdin(fname);
-        }
-    } while (!F);
+            break;
+        }
+        ind = getvar_s(incvar(intvar[ARGIND]));
+        fname = getvar_s(findvar(iamarray(intvar[ARGV]), ind));
+        if (fname && *fname && !is_assignment(fname)) {
+            F = xfopen_stdin(fname);
+            break;
+        }
+    }
 
     files_happen = TRUE;
@@ -2989 +3076 @@
 {
     unsigned opt;
-    char *opt_F, *opt_W;
+    char *opt_F;
     llist_t *list_v = NULL;
     llist_t *list_f = NULL;
@@ -3051 +3138 @@
     }
     opt_complementary = "v::f::"; /* -v and -f can occur multiple times */
-    opt = getopt32(argv, "F:v:f:W:", &opt_F, &list_v, &list_f, &opt_W);
+    opt = getopt32(argv, "F:v:f:W:", &opt_F, &list_v, &list_f, NULL);
     argv += optind;
     argc -= optind;
-    if (opt & 0x1)
-        setvar_s(intvar[FS], opt_F); // -F
+    if (opt & 0x1) { /* -F */
+        unescape_string_in_place(opt_F);
+        setvar_s(intvar[FS], opt_F);
+    }
     while (list_v) { /* -v */
         if (!is_assignment(llist_pop(&list_v)))
@@ -3085 +3174 @@
     }
     if (opt & 0x8) // -W
-        bb_error_msg("warning: unrecognized option '-W %s' ignored", opt_W);
+        bb_error_msg("warning: option -W is ignored");
 
     /* fill in ARGV array */

branches/3.2/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 */
+
+//usage:#define cmp_trivial_usage
+//usage:       "[-l] [-s] FILE1 [FILE2" IF_DESKTOP(" [SKIP1 [SKIP2]]") "]"
+//usage:#define cmp_full_usage "\n\n"
+//usage:       "Compare FILE1 with FILE2 (or stdin)\n"
+//usage:     "\n    -l  Write the byte numbers (decimal) and values (octal)"
+//usage:     "\n        for all differing bytes"
+//usage:     "\n    -s  Quiet"
 
 #include "libbb.h"

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

@@ -77 +77 @@
  */
 
+//usage:#define diff_trivial_usage
+//usage:       "[-abBdiNqrTstw] [-L LABEL] [-S FILE] [-U LINES] FILE1 FILE2"
+//usage:#define diff_full_usage "\n\n"
+//usage:       "Compare files line by line and output the differences between them.\n"
+//usage:       "This implementation supports unified diffs only.\n"
+//usage:     "\n    -a  Treat all files as text"
+//usage:     "\n    -b  Ignore changes in the amount of whitespace"
+//usage:     "\n    -B  Ignore changes whose lines are all blank"
+//usage:     "\n    -d  Try hard to find a smaller set of changes"
+//usage:     "\n    -i  Ignore case differences"
+//usage:     "\n    -L  Use LABEL instead of the filename in the unified header"
+//usage:     "\n    -N  Treat absent files as empty"
+//usage:     "\n    -q  Output only whether files differ"
+//usage:     "\n    -r  Recurse"
+//usage:     "\n    -S  Start with FILE when comparing directories"
+//usage:     "\n    -T  Make tabs line up by prefixing a tab when necessary"
+//usage:     "\n    -s  Report when two files are the same"
+//usage:     "\n    -t  Expand tabs to spaces in output"
+//usage:     "\n    -U  Output LINES lines of context"
+//usage:     "\n    -w  Ignore all whitespace"
+
 #include "libbb.h"
 
 #if 0
-//#define dbg_error_msg(...) bb_error_msg(__VA_ARGS__)
+# define dbg_error_msg(...) bb_error_msg(__VA_ARGS__)
 #else
-#define dbg_error_msg(...) ((void)0)
+# define dbg_error_msg(...) ((void)0)
 #endif
 
@@ -673 +694 @@
 static int diffreg(char *file[2])
 {
-    FILE *fp[2] = { stdin, stdin };
+    FILE *fp[2];
     bool binary = false, differ = false;
     int status = STATUS_SAME, i;
 
+    fp[0] = stdin;
+    fp[1] = stdin;
     for (i = 0; i < 2; i++) {
         int fd = open_or_warn_stdin(file[i]);
@@ -795 +818 @@
             if (r != 0 || !S_ISDIR(osb.st_mode)) {
                 /* other dir doesn't have similarly named
-                 * directory, don't recurse */
+                 * directory, don't recurse; return 1 upon
+                 * exit, just like diffutils' diff */
+                exit_status |= 1;
                 return SKIP;
             }
@@ -819 +844 @@
         list[i].len = strlen(p[i]);
         recursive_action(p[i], ACTION_RECURSE | ACTION_FOLLOWLINKS,
-                         add_to_dirlist, skip_dir, &list[i], 0);
+                add_to_dirlist, skip_dir, &list[i], 0);
         /* Sort dl alphabetically.
          * GNU diff does this ignoring any number of trailing dots.
@@ -847 +872 @@
         pos = !dp[0] ? 1 : (!dp[1] ? -1 : strcmp(dp[0], dp[1]));
         k = pos > 0;
-        if (pos && !(option_mask32 & FLAG(N)))
+        if (pos && !(option_mask32 & FLAG(N))) {
             printf("Only in %s: %s\n", p[k], dp[k]);
-        else {
+            exit_status |= 1;
+        } else {
             char *fullpath[2], *path[2]; /* if -N */
 
@@ -950 +976 @@
         bb_error_msg_and_die("can't compare stdin to a directory");
 
+    /* Compare metadata to check if the files are the same physical file.
+     *
+     * Comment from diffutils source says:
+     * POSIX says that two files are identical if st_ino and st_dev are
+     * the same, but many file systems incorrectly assign the same (device,
+     * inode) pair to two distinct files, including:
+     * GNU/Linux NFS servers that export all local file systems as a
+     * single NFS file system, if a local device number (st_dev) exceeds
+     * 255, or if a local inode number (st_ino) exceeds 16777215.
+     */
+    if (ENABLE_DESKTOP
+     && stb[0].st_ino == stb[1].st_ino
+     && stb[0].st_dev == stb[1].st_dev
+     && stb[0].st_size == stb[1].st_size
+     && stb[0].st_mtime == stb[1].st_mtime
+     && stb[0].st_ctime == stb[1].st_ctime
+     && stb[0].st_mode == stb[1].st_mode
+     && stb[0].st_nlink == stb[1].st_nlink
+     && stb[0].st_uid == stb[1].st_uid
+     && stb[0].st_gid == stb[1].st_gid
+    ) {
+        /* files are physically the same; no need to compare them */
+        return STATUS_SAME;
+    }
+
     if (S_ISDIR(stb[0].st_mode) && S_ISDIR(stb[1].st_mode)) {
 #if ENABLE_FEATURE_DIFF_DIR

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

@@ -7 +7 @@
  * The "ed" built-in command (much simplified)
  */
+
+//usage:#define ed_trivial_usage ""
+//usage:#define ed_full_usage ""
 
 #include "libbb.h"
@@ -130 +133 @@
          * >0 length of input string, including terminating '\n'
          */
-        len = read_line_input(": ", buf, sizeof(buf), NULL);
+        len = read_line_input(NULL, ": ", buf, sizeof(buf), /*timeout*/ -1);
         if (len <= 0)
             return;
@@ -228 +231 @@
             if (!dirty)
                 return;
-            len = read_line_input("Really quit? ", buf, 16, NULL);
+            len = read_line_input(NULL, "Really quit? ", buf, 16, /*timeout*/ -1);
             /* read error/EOF - no way to continue */
             if (len < 0)
@@ -452 +455 @@
         /*
          * The new string is larger, so allocate a new line
-         * structure and use that.  Link it in in place of
+         * structure and use that.  Link it in place of
          * the old line structure.
          */
@@ -542 +545 @@
          * >0 length of input string, including terminating '\n'
          */
-        len = read_line_input("", buf, sizeof(buf), NULL);
+        len = read_line_input(NULL, "", buf, sizeof(buf), /*timeout*/ -1);
         if (len <= 0) {
             /* Previously, ctrl-C was exiting to shell.

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

@@ -16 +16 @@
  * -o outfile output here instead of in place
  * -r rejectfile write rejected hunks to this file
+ * --dry-run (regression!)
  *
  * -f force (no questions asked)
@@ -22 +23 @@
  */
 
-//applet:IF_PATCH(APPLET(patch, _BB_DIR_USR_BIN, _BB_SUID_DROP))
-
-//kbuild:lib-$(CONFIG_PATCH) += patch.o
-
 //config:config PATCH
 //config:   bool "patch"
@@ -31 +28 @@
 //config:   help
 //config:     Apply a unified diff formatted patch.
+
+//applet:IF_PATCH(APPLET(patch, BB_DIR_USR_BIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_PATCH) += patch.o
 
 //usage:#define patch_trivial_usage
@@ -40 +41 @@
 //usage:     "\n    -R,--reverse        Reverse patch"
 //usage:     "\n    -N,--forward        Ignore already applied patches"
-//usage:     "\n    --dry-run       Don't actually change files"
+/*usage:     "\n    --dry-run       Don't actually change files" - TODO */
 //usage:     "\n    -E,--remove-empty-files Remove output files if they become empty"
 //usage:    )
@@ -50 +51 @@
 //usage:     "\n    -E  Remove output files if they become empty"
 //usage:    )
+/* -u "interpret as unified diff" is supported but not documented: this info is not useful for --help */
+/* -x "debug" is supported but does nothing */
 //usage:
 //usage:#define patch_example_usage
@@ -68 +71 @@
 // Free all the elements of a linked list
 // Call freeit() on each element before freeing it.
-static
-void dlist_free(struct double_list *list, void (*freeit)(void *data))
+static void dlist_free(struct double_list *list, void (*freeit)(void *data))
 {
     while (list) {
@@ -81 +83 @@
 
 // Add an entry before "list" element in (circular) doubly linked list
-static
-struct double_list *dlist_add(struct double_list **list, char *data)
+static struct double_list *dlist_add(struct double_list **list, char *data)
 {
     struct double_list *llist;
@@ -131 +132 @@
 #define FLAG_IGNORE  (1 << 4)
 #define FLAG_RMEMPTY (1 << 5)
-//non-standard:
-#define FLAG_DEBUG   (1 << 6)
+/* Enable this bit and use -x for debug output: */
+#define FLAG_DEBUG   (0 << 6)
 
 // Dispose of a line of input, either by writing it out or discarding it.
@@ -230 +231 @@
         if (PATCH_DEBUG) fdprintf(2, "HUNK:%s\n", plist->data);
     }
-    matcheof = matcheof < TT.context;
+    matcheof = !matcheof || matcheof < TT.context;
 
     if (PATCH_DEBUG) fdprintf(2,"MATCHEOF=%c\n", matcheof ? 'Y' : 'N');
@@ -239 +240 @@
     plist = TT.current_hunk;
     buf = NULL;
-    if (TT.context) for (;;) {
-        char *data = xmalloc_reads(TT.filein, NULL, NULL);
+    if (reverse ? TT.oldlen : TT.newlen) for (;;) {
+        char *data = xmalloc_reads(TT.filein, NULL);
 
         TT.linenum++;
@@ -353 +354 @@
     char *oldname = NULL, *newname = NULL;
     char *opt_p, *opt_i;
+    long oldlen = oldlen; /* for compiler */
+    long newlen = newlen; /* for compiler */
 
     INIT_TT();
@@ -392 +395 @@
                 dlist_add(&TT.current_hunk, patchline);
 
-                if (*patchline != '+') TT.oldlen--;
-                if (*patchline != '-') TT.newlen--;
+                if (*patchline != '+') oldlen--;
+                if (*patchline != '-') newlen--;
 
                 // Context line?
@@ -401 +404 @@
                 // If we've consumed all expected hunk lines, apply the hunk.
 
-                if (!TT.oldlen && !TT.newlen) state = apply_one_hunk();
+                if (!oldlen && !newlen) state = apply_one_hunk();
                 continue;
             }
@@ -448 +451 @@
             // Read oldline[,oldlen] +newline[,newlen]
 
-            TT.oldlen = TT.newlen = 1;
+            TT.oldlen = oldlen = TT.newlen = newlen = 1;
             TT.oldline = strtol(s, &s, 10);
-            if (*s == ',') TT.oldlen=strtol(s+1, &s, 10);
+            if (*s == ',') TT.oldlen = oldlen = strtol(s+1, &s, 10);
             TT.newline = strtol(s+2, &s, 10);
-            if (*s == ',') TT.newlen = strtol(s+1, &s, 10);
+            if (*s == ',') TT.newlen = newlen = strtol(s+1, &s, 10);
+
+            if (oldlen < 1 && newlen < 1)
+                bb_error_msg_and_die("Really? %s", patchline);
 
             TT.context = 0;
@@ -462 +468 @@
                 char *name;
 
-                oldsum = TT.oldline + TT.oldlen;
-                newsum = TT.newline + TT.newlen;
+                oldsum = TT.oldline + oldlen;
+                newsum = TT.newline + newlen;
 
                 name = reverse ? oldname : newname;
@@ -469 +475 @@
                 // We're deleting oldname if new file is /dev/null (before -p)
                 // or if new hunk is empty (zero context) after patching
-                if (!strcmp(name, "/dev/null") || !(reverse ? oldsum : newsum))
-                {
+                if (!strcmp(name, "/dev/null") || !(reverse ? oldsum : newsum)) {
                     name = reverse ? newname : oldname;
                     empty++;
@@ -476 +481 @@
 
                 // handle -p path truncation.
-                for (i=0, s = name; *s;) {
-                    if ((option_mask32 & FLAG_PATHLEN) && TT.prefix == i) break;
-                    if (*(s++)=='/') {
-                        name = s;
-                        i++;
-                    }
+                for (i = 0, s = name; *s;) {
+                    if ((option_mask32 & FLAG_PATHLEN) && TT.prefix == i)
+                        break;
+                    if (*s++ != '/')
+                        continue;
+                    while (*s == '/')
+                        s++;
+                    i++;
+                    name = s;
                 }
 

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

@@ -15 +15 @@
 
 /* Code overview.
-
-  Files are laid out to avoid unnecessary function declarations.  So for
-  example, every function add_cmd calls occurs before add_cmd in this file.
-
-  add_cmd() is called on each line of sed command text (from a file or from
-  the command line).  It calls get_address() and parse_cmd_args().  The
-  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 *
-  (which could be stdin) and applying the sed command list (sed_cmd_head) to
-  each of the resulting lines.
-
-  sed_main() is where external code calls into this, with a command line.
-*/
-
-
-/*
-    Supported features and commands in this version of sed:
-
-     - comments ('#')
-     - address matching: num|/matchstr/[,num|/matchstr/|$]command
-     - commands: (p)rint, (d)elete, (s)ubstitue (with g & I flags)
-     - edit commands: (a)ppend, (i)nsert, (c)hange
-     - file commands: (r)ead
-     - backreferences in substitution expressions (\0, \1, \2...\9)
-     - grouped commands: {cmd1;cmd2}
-     - transliteration (y/source-chars/dest-chars/)
-     - pattern space hold space storing / swapping (g, h, x)
-     - labels / branching (: label, b, t, T)
-
-     (Note: Specifying an address (range) to match is *optional*; commands
-     default to the whole pattern space if no specific address match was
-     requested.)
-
-    Todo:
-     - Create a wrapper around regex to make libc's regex conform with sed
-
-    Reference http://www.opengroup.org/onlinepubs/007904975/utilities/sed.html
-*/
+ *
+ * Files are laid out to avoid unnecessary function declarations.  So for
+ * example, every function add_cmd calls occurs before add_cmd in this file.
+ *
+ * add_cmd() is called on each line of sed command text (from a file or from
+ * the command line).  It calls get_address() and parse_cmd_args().  The
+ * 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*
+ * (which could be stdin) and applying the sed command list (sed_cmd_head) to
+ * each of the resulting lines.
+ *
+ * sed_main() is where external code calls into this, with a command line.
+ */
+
+/* Supported features and commands in this version of sed:
+ *
+ * - comments ('#')
+ * - address matching: num|/matchstr/[,num|/matchstr/|$]command
+ * - commands: (p)rint, (d)elete, (s)ubstitue (with g & I flags)
+ * - edit commands: (a)ppend, (i)nsert, (c)hange
+ * - file commands: (r)ead
+ * - backreferences in substitution expressions (\0, \1, \2...\9)
+ * - grouped commands: {cmd1;cmd2}
+ * - transliteration (y/source-chars/dest-chars/)
+ * - pattern space hold space storing / swapping (g, h, x)
+ * - labels / branching (: label, b, t, T)
+ *
+ * (Note: Specifying an address (range) to match is *optional*; commands
+ * default to the whole pattern space if no specific address match was
+ * requested.)
+ *
+ * Todo:
+ * - Create a wrapper around regex to make libc's regex conform with sed
+ *
+ * Reference
+ * http://www.opengroup.org/onlinepubs/007904975/utilities/sed.html
+ * http://pubs.opengroup.org/onlinepubs/9699919799/utilities/sed.html
+ */
+
+//usage:#define sed_trivial_usage
+//usage:       "[-inr] [-f FILE]... [-e CMD]... [FILE]...\n"
+//usage:       "or: sed [-inr] CMD [FILE]..."
+//usage:#define sed_full_usage "\n\n"
+//usage:       "    -e CMD  Add CMD to sed commands to be executed"
+//usage:     "\n    -f FILE Add FILE contents to sed commands to be executed"
+//usage:     "\n    -i[SFX] Edit files in-place (otherwise sends to stdout)"
+//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"
+//usage:     "\nIf no -e or -f, the first non-option argument is the sed command string."
+//usage:     "\nRemaining arguments are input files (stdin if none)."
+//usage:
+//usage:#define sed_example_usage
+//usage:       "$ echo \"foo\" | sed -e 's/f[a-zA-Z]o/bar/g'\n"
+//usage:       "bar\n"
 
 #include "libbb.h"
 #include "xregex.h"
+
+#if 0
+# define dbg(...) bb_error_msg(__VA_ARGS__)
+#else
+# define dbg(...) ((void)0)
+#endif
+
 
 enum {
@@ -76 +101 @@
     regex_t *sub_match;     /* For 's/sub_match/string/' */
     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 ($) */
 
@@ -110 +136 @@
 
     /* linked list of sed commands */
-    sed_cmd_t sed_cmd_head, *sed_cmd_tail;
+    sed_cmd_t *sed_cmd_head, **sed_cmd_tail;
 
     /* Linked list of append lines */
@@ -125 +151 @@
 #define G (*(struct globals*)&bb_common_bufsiz1)
 struct BUG_G_too_big {
-        char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
+    char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
 };
 #define INIT_G() do { \
@@ -135 +161 @@
 static void sed_free_and_close_stuff(void)
 {
-    sed_cmd_t *sed_cmd = G.sed_cmd_head.next;
+    sed_cmd_t *sed_cmd = G.sed_cmd_head;
 
     llist_free(G.append_head, free);
@@ -201 +227 @@
 static char *copy_parsing_escapes(const char *string, int len)
 {
+    const char *s;
     char *dest = xmalloc(len + 1);
 
-    parse_escapes(dest, string, len, 'n', '\n');
-    /* GNU sed also recognizes \t */
-    parse_escapes(dest, dest, strlen(dest), 't', '\t');
+    /* sed recognizes \n */
+    /* GNU sed also recognizes \t and \r */
+    for (s = "\nn\tt\rr"; *s; s += 2) {
+        parse_escapes(dest, string, len, s[1], s[0]);
+        string = dest;
+        len = strlen(dest);
+    }
     return dest;
 }
@@ -228 +259 @@
     }
 
-    for (; (ch = str[idx]); idx++) {
+    for (; (ch = str[idx]) != '\0'; idx++) {
         if (bracket >= 0) {
-            if (ch == ']' && !(bracket == idx - 1 || (bracket == idx - 2
-                    && str[idx - 1] == '^')))
+            if (ch == ']'
+             && !(bracket == idx - 1 || (bracket == idx - 2 && str[idx - 1] == '^'))
+            ) {
                 bracket = -1;
+            }
         } else if (escaped)
             escaped = 0;
@@ -253 +286 @@
 {
     const char *cmdstr_ptr = cmdstr;
-    char delimiter;
+    unsigned char delimiter;
     int idx = 0;
 
@@ -268 +301 @@
     /* save the replacement string */
     cmdstr_ptr += idx + 1;
-    idx = index_of_next_unescaped_regexp_delim(-delimiter, cmdstr_ptr);
+    idx = index_of_next_unescaped_regexp_delim(- (int)delimiter, cmdstr_ptr);
     *replace = copy_parsing_escapes(cmdstr_ptr, idx);
 
@@ -293 +326 @@
 
         delimiter = '/';
-        if (*my_str == '\\') delimiter = *++pos;
+        if (*my_str == '\\')
+            delimiter = *++pos;
         next = index_of_next_unescaped_regexp_delim(delimiter, ++pos);
         temp = copy_parsing_escapes(pos, next);
-        *regex = xmalloc(sizeof(regex_t));
+        *regex = xzalloc(sizeof(regex_t));
         xregcomp(*regex, temp, G.regex_type|REG_NEWLINE);
         free(temp);
@@ -405 +439 @@
     if (*match != '\0') {
         /* If match is empty, we use last regex used at runtime */
-        sed_cmd->sub_match = xmalloc(sizeof(regex_t));
+        sed_cmd->sub_match = xzalloc(sizeof(regex_t));
+        dbg("xregcomp('%s',%x)", match, cflags);
         xregcomp(sed_cmd->sub_match, match, cflags);
+        dbg("regcomp ok");
     }
     free(match);
@@ -418 +454 @@
 static const char *parse_cmd_args(sed_cmd_t *sed_cmd, const char *cmdstr)
 {
+    static const char cmd_letters[] = "saicrw:btTydDgGhHlnNpPqx={}";
+    enum {
+        IDX_s = 0,
+        IDX_a,
+        IDX_i,
+        IDX_c,
+        IDX_r,
+        IDX_w,
+        IDX_colon,
+        IDX_b,
+        IDX_t,
+        IDX_T,
+        IDX_y,
+        IDX_d,
+        IDX_D,
+        IDX_g,
+        IDX_G,
+        IDX_h,
+        IDX_H,
+        IDX_l,
+        IDX_n,
+        IDX_N,
+        IDX_p,
+        IDX_P,
+        IDX_q,
+        IDX_x,
+        IDX_equal,
+        IDX_lbrace,
+        IDX_rbrace,
+        IDX_nul
+    };
+    struct chk { char chk[sizeof(cmd_letters)-1 == IDX_nul ? 1 : -1]; };
+
+    unsigned idx = strchrnul(cmd_letters, sed_cmd->cmd) - cmd_letters;
+
     /* handle (s)ubstitution command */
-    if (sed_cmd->cmd == 's')
+    if (idx == IDX_s) {
         cmdstr += parse_subst_cmd(sed_cmd, cmdstr);
+    }
     /* handle edit cmds: (a)ppend, (i)nsert, and (c)hange */
-    else if (strchr("aic", sed_cmd->cmd)) {
-        if ((sed_cmd->end_line || sed_cmd->end_match) && sed_cmd->cmd != 'c')
-            bb_error_msg_and_die("only a beginning address can be specified for edit commands");
+    else if (idx <= IDX_c) { /* a,i,c */
+        if (idx < IDX_c) { /* a,i */
+            if (sed_cmd->end_line || sed_cmd->end_match)
+                bb_error_msg_and_die("command '%c' uses only one address", sed_cmd->cmd);
+        }
         for (;;) {
             if (*cmdstr == '\n' || *cmdstr == '\\') {
@@ -438 +512 @@
         parse_escapes(sed_cmd->string, sed_cmd->string, strlen(cmdstr), '\0', '\0');
         cmdstr += strlen(cmdstr);
+    }
     /* handle file cmds: (r)ead */
-    } else if (strchr("rw", sed_cmd->cmd)) {
-        if (sed_cmd->end_line || sed_cmd->end_match)
-            bb_error_msg_and_die("command only uses one address");
+    else if (idx <= IDX_w) { /* r,w */
+        if (idx < IDX_w) { /* r */
+            if (sed_cmd->end_line || sed_cmd->end_match)
+                bb_error_msg_and_die("command '%c' uses only one address", sed_cmd->cmd);
+        }
         cmdstr += parse_file_cmd(/*sed_cmd,*/ cmdstr, &sed_cmd->string);
         if (sed_cmd->cmd == 'w') {
@@ -447 +524 @@
             sed_cmd->sw_last_char = '\n';
         }
+    }
     /* handle branch commands */
-    } else if (strchr(":btT", sed_cmd->cmd)) {
+    else if (idx <= IDX_T) { /* :,b,t,T */
         int length;
 
@@ -459 +537 @@
     }
     /* translation command */
-    else if (sed_cmd->cmd == 'y') {
+    else if (idx == IDX_y) {
         char *match, *replace;
         int i = cmdstr[0];
@@ -479 +557 @@
      * then it must be an invalid command.
      */
-    else if (strchr("dDgGhHlnNpPqx={}", sed_cmd->cmd) == 0) {
+    else if (idx >= IDX_nul) { /* not d,D,g,G,h,H,l,n,N,p,P,q,x,=,{,} */
         bb_error_msg_and_die("unsupported command %c", sed_cmd->cmd);
     }
@@ -541 +619 @@
         /* first part (if present) is an address: either a '$', a number or a /regex/ */
         cmdstr += get_address(cmdstr, &sed_cmd->beg_line, &sed_cmd->beg_match);
+        sed_cmd->beg_line_orig = sed_cmd->beg_line;
 
         /* second part (if present) will begin with a comma */
@@ -572 +651 @@
 
         /* Add the command to the command array */
-        G.sed_cmd_tail->next = sed_cmd;
-        G.sed_cmd_tail = G.sed_cmd_tail->next;
+        *G.sed_cmd_tail = sed_cmd;
+        G.sed_cmd_tail = &sed_cmd->next;
     }
 
@@ -601 +680 @@
     /* go through the replacement string */
     for (i = 0; replace[i]; i++) {
-        /* if we find a backreference (\1, \2, etc.) print the backref'ed * text */
+        /* if we find a backreference (\1, \2, etc.) print the backref'ed text */
         if (replace[i] == '\\') {
             unsigned backref = replace[++i] - '0';
@@ -635 +714 @@
 {
     char *line = *line_p;
-    int altered = 0;
     unsigned match_count = 0;
+    bool altered = 0;
+    bool prev_match_empty = 1;
+    bool tried_at_eol = 0;
     regex_t *current_regex;
 
@@ -649 +730 @@
 
     /* Find the first match */
-    if (REG_NOMATCH == regexec(current_regex, line, 10, G.regmatch, 0))
+    dbg("matching '%s'", line);
+    if (REG_NOMATCH == regexec(current_regex, line, 10, G.regmatch, 0)) {
+        dbg("no match");
         return 0;
+    }
+    dbg("match");
 
     /* Initialize temporary output buffer. */
@@ -659 +744 @@
     /* Now loop through, substituting for matches */
     do {
+        int start = G.regmatch[0].rm_so;
+        int end = G.regmatch[0].rm_eo;
         int i;
 
-        /* Work around bug in glibc regexec, demonstrated by:
-           echo " a.b" | busybox sed 's [^ .]* x g'
-           The match_count check is so not to break
-           echo "hi" | busybox sed 's/^/!/g' */
-        if (!G.regmatch[0].rm_so && !G.regmatch[0].rm_eo && match_count) {
-            pipe_putc(*line++);
-            continue;
-        }
-
         match_count++;
 
         /* If we aren't interested in this match, output old line to
-           end of match and continue */
+         * end of match and continue */
         if (sed_cmd->which_match
          && (sed_cmd->which_match != match_count)
         ) {
-            for (i = 0; i < G.regmatch[0].rm_eo; i++)
+            for (i = 0; i < end; i++)
                 pipe_putc(*line++);
-            continue;
-        }
-
-        /* print everything before the match */
-        for (i = 0; i < G.regmatch[0].rm_so; i++)
+            /* Null match? Print one more char */
+            if (start == end && *line)
+                pipe_putc(*line++);
+            goto next;
+        }
+
+        /* Print everything before the match */
+        for (i = 0; i < start; i++)
             pipe_putc(line[i]);
 
-        /* then print the substitution string */
-        do_subst_w_backrefs(line, sed_cmd->string);
-
-        /* advance past the match */
-        line += G.regmatch[0].rm_eo;
-        /* flag that something has changed */
-        altered++;
+        /* Then print the substitution string,
+         * unless we just matched empty string after non-empty one.
+         * Example: string "cccd", pattern "c*", repl "R":
+         * result is "RdR", not "RRdR": first match "ccc",
+         * second is "" before "d", third is "" after "d".
+         * Second match is NOT replaced!
+         */
+        if (prev_match_empty || start != 0 || start != end) {
+            //dbg("%d %d %d", prev_match_empty, start, end);
+            dbg("inserting replacement at %d in '%s'", start, line);
+            do_subst_w_backrefs(line, sed_cmd->string);
+            /* Flag that something has changed */
+            altered = 1;
+        } else {
+            dbg("NOT inserting replacement at %d in '%s'", start, line);
+        }
+
+        /* If matched string is empty (f.e. "c*" pattern),
+         * copy verbatim one char after it before attempting more matches
+         */
+        prev_match_empty = (start == end);
+        if (prev_match_empty) {
+            if (!line[end]) {
+                tried_at_eol = 1;
+            } else {
+                pipe_putc(line[end]);
+                end++;
+            }
+        }
+
+        /* Advance past the match */
+        dbg("line += %d", end);
+        line += end;
 
         /* if we're not doing this globally, get out now */
-        if (sed_cmd->which_match)
-            break;
-
-//maybe (G.regmatch[0].rm_eo ? REG_NOTBOL : 0) instead of unconditional REG_NOTBOL?
-    } while (*line && regexec(current_regex, line, 10, G.regmatch, REG_NOTBOL) != REG_NOMATCH);
+        if (sed_cmd->which_match != 0)
+            break;
+ next:
+        /* Exit if we are at EOL and already tried matching at it */
+        if (*line == '\0') {
+            if (tried_at_eol)
+                break;
+            tried_at_eol = 1;
+        }
+
+//maybe (end ? REG_NOTBOL : 0) instead of unconditional REG_NOTBOL?
+    } while (regexec(current_regex, line, 10, G.regmatch, REG_NOTBOL) != REG_NOMATCH);
 
     /* Copy rest of string into output pipeline */
@@ -719 +833 @@
     sed_cmd_t *sed_cmd;
 
-    for (sed_cmd = G.sed_cmd_head.next; sed_cmd; sed_cmd = sed_cmd->next) {
+    for (sed_cmd = G.sed_cmd_head; sed_cmd; sed_cmd = sed_cmd->next) {
         if (sed_cmd->cmd == ':' && sed_cmd->string && !strcmp(sed_cmd->string, label)) {
             return sed_cmd;
@@ -895 +1009 @@
     /* For every line, go through all the commands */
  restart:
-    for (sed_cmd = G.sed_cmd_head.next; sed_cmd; sed_cmd = sed_cmd->next) {
+    for (sed_cmd = G.sed_cmd_head; sed_cmd; sed_cmd = sed_cmd->next) {
         int old_matched, matched;
 
@@ -902 +1016 @@
         /* Determine if this command matches this line: */
 
-        //bb_error_msg("match1:%d", sed_cmd->in_match);
-        //bb_error_msg("match2:%d", (!sed_cmd->beg_line && !sed_cmd->end_line
-        //      && !sed_cmd->beg_match && !sed_cmd->end_match));
-        //bb_error_msg("match3:%d", (sed_cmd->beg_line > 0
-        //  && (sed_cmd->end_line || sed_cmd->end_match
-        //      ? (sed_cmd->beg_line <= linenum)
-        //      : (sed_cmd->beg_line == linenum)
-        //      )
-        //  )
-        //bb_error_msg("match4:%d", (beg_match(sed_cmd, pattern_space)));
-        //bb_error_msg("match5:%d", (sed_cmd->beg_line == -1 && next_line == NULL));
+        dbg("match1:%d", sed_cmd->in_match);
+        dbg("match2:%d", (!sed_cmd->beg_line && !sed_cmd->end_line
+                && !sed_cmd->beg_match && !sed_cmd->end_match));
+        dbg("match3:%d", (sed_cmd->beg_line > 0
+            && (sed_cmd->end_line || sed_cmd->end_match
+                ? (sed_cmd->beg_line <= linenum)
+                : (sed_cmd->beg_line == linenum)
+                )
+            ));
+        dbg("match4:%d", (beg_match(sed_cmd, pattern_space)));
+        dbg("match5:%d", (sed_cmd->beg_line == -1 && next_line == NULL));
 
         /* Are we continuing a previous multi-line match? */
@@ -923 +1037 @@
                 && (sed_cmd->end_line || sed_cmd->end_match
                   /* note: even if end is numeric and is < linenum too,
-                   * GNU sed matches! We match too */
+                   * GNU sed matches! We match too, therefore we don't
+                   * check here that linenum <= end.
+                   * Example:
+                   * printf '1\n2\n3\n4\n' | sed -n '1{N;N;d};1p;2,3p;3p;4p'
+                   * first three input lines are deleted;
+                   * 4th line is matched and printed
+                   * by "2,3" (!) and by "4" ranges
+                   */
                 ? (sed_cmd->beg_line <= linenum)    /* N,end */
                 : (sed_cmd->beg_line == linenum)    /* N */
@@ -936 +1057 @@
         matched = sed_cmd->in_match;
 
-        //bb_error_msg("cmd:'%c' matched:%d beg_line:%d end_line:%d linenum:%d",
-        //sed_cmd->cmd, matched, sed_cmd->beg_line, sed_cmd->end_line, linenum);
+        dbg("cmd:'%c' matched:%d beg_line:%d end_line:%d linenum:%d",
+            sed_cmd->cmd, matched, sed_cmd->beg_line, sed_cmd->end_line, linenum);
 
         /* Is this line the end of the current match? */
@@ -943 +1064 @@
         if (matched) {
             /* once matched, "n,xxx" range is dead, disabling it */
-            if (sed_cmd->beg_line > 0
-             && !(option_mask32 & OPT_in_place) /* but not for -i */
-            ) {
+            if (sed_cmd->beg_line > 0) {
                 sed_cmd->beg_line = -2;
             }
             sed_cmd->in_match = !(
                 /* has the ending line come, or is this a single address command? */
-                (sed_cmd->end_line ?
-                    sed_cmd->end_line == -1 ?
-                        !next_line
+                (sed_cmd->end_line
+                    ? sed_cmd->end_line == -1
+                        ? !next_line
                         : (sed_cmd->end_line <= linenum)
                     : !sed_cmd->end_match
@@ -959 +1078 @@
                 || (sed_cmd->end_match && old_matched
                      && (regexec(sed_cmd->end_match,
-                                 pattern_space, 0, NULL, 0) == 0))
+                        pattern_space, 0, NULL, 0) == 0)
+                )
             );
         }
@@ -993 +1113 @@
 
         /* actual sedding */
-        //bb_error_msg("pattern_space:'%s' next_line:'%s' cmd:%c",
-        //pattern_space, next_line, sed_cmd->cmd);
+        dbg("pattern_space:'%s' next_line:'%s' cmd:%c",
+                pattern_space, next_line, sed_cmd->cmd);
         switch (sed_cmd->cmd) {
 
@@ -1041 +1161 @@
             if (!do_subst_command(sed_cmd, &pattern_space))
                 break;
+            dbg("do_subst_command succeeded:'%s'", pattern_space);
             substituted |= 1;
 
@@ -1288 +1409 @@
     unsigned opt;
     llist_t *opt_e, *opt_f;
+    char *opt_i;
+
+#if ENABLE_LONG_OPTS
+    static const char sed_longopts[] ALIGN1 =
+        /* name             has_arg             short */
+        "in-place\0"        Optional_argument   "i"
+        "regexp-extended\0" No_argument         "r"
+        "quiet\0"           No_argument         "n"
+        "silent\0"          No_argument         "n"
+        "expression\0"      Required_argument   "e"
+        "file\0"            Required_argument   "f";
+#endif
+
     int status = EXIT_SUCCESS;
 
@@ -1296 +1430 @@
 
     /* Lie to autoconf when it starts asking stupid questions. */
-    if (argv[1] && !strcmp(argv[1], "--version")) {
+    if (argv[1] && strcmp(argv[1], "--version") == 0) {
         puts("This is not GNU sed version 4.0");
         return 0;
@@ -1303 +1437 @@
     /* do normal option parsing */
     opt_e = opt_f = NULL;
+    opt_i = NULL;
     opt_complementary = "e::f::" /* can occur multiple times */
                         "nn"; /* count -n */
+
+    IF_LONG_OPTS(applet_long_options = sed_longopts);
+
     /* -i must be first, to match OPT_in_place definition */
-    opt = getopt32(argv, "irne:f:", &opt_e, &opt_f,
+    opt = getopt32(argv, "i::rne:f:", &opt_i, &opt_e, &opt_f,
                 &G.be_quiet); /* counter for -n */
     //argc -= optind;
@@ -1349 +1487 @@
     } else {
         int i;
-        FILE *file;
 
         for (i = 0; argv[i]; i++) {
             struct stat statbuf;
             int nonstdoutfd;
+            FILE *file;
+            sed_cmd_t *sed_cmd;
 
             if (LONE_DASH(argv[i]) && !(opt & OPT_in_place)) {
@@ -1365 +1504 @@
                 continue;
             }
+            add_input_file(file);
             if (!(opt & OPT_in_place)) {
-                add_input_file(file);
                 continue;
             }
+
+            /* -i: process each FILE separately: */
 
             G.outname = xasprintf("%sXXXXXX", argv[i]);
@@ -1380 +1521 @@
             fchmod(nonstdoutfd, statbuf.st_mode);
             fchown(nonstdoutfd, statbuf.st_uid, statbuf.st_gid);
-            add_input_file(file);
+
             process_files();
             fclose(G.nonstdout);
-
             G.nonstdout = stdout;
-            /* unlink(argv[i]); */
-            xrename(G.outname, argv[i]);
+
+            if (opt_i) {
+                char *backupname = xasprintf("%s%s", argv[i], opt_i);
+                xrename(argv[i], backupname);
+                free(backupname);
+            }
+            /* else unlink(argv[i]); - rename below does this */
+            xrename(G.outname, argv[i]); //TODO: rollback backup on error?
             free(G.outname);
             G.outname = NULL;
+
+            /* Re-enable disabled range matches */
+            for (sed_cmd = G.sed_cmd_head; sed_cmd; sed_cmd = sed_cmd->next) {
+                sed_cmd->beg_line = sed_cmd->beg_line_orig;
+            }
         }
         /* Here, to handle "sed 'cmds' nonexistent_file" case we did:

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

@@ -15 +15 @@
  *  :map macros
  *  if mark[] values were line numbers rather than pointers
- *     it would be easier to change the mark when add/delete lines
+ *      it would be easier to change the mark when add/delete lines
  *  More intelligence in refresh()
  *  ":r !cmd"  and  "!cmd"  to filter text through an external command
@@ -22 +22 @@
  */
 
+//config:config VI
+//config:   bool "vi"
+//config:   default y
+//config:   help
+//config:     'vi' is a text editor. More specifically, it is the One True
+//config:     text editor <grin>. It does, however, have a rather steep
+//config:     learning curve. If you are not already comfortable with 'vi'
+//config:     you may wish to use something else.
+//config:
+//config:config FEATURE_VI_MAX_LEN
+//config:   int "Maximum screen width in vi"
+//config:   range 256 16384
+//config:   default 4096
+//config:   depends on VI
+//config:   help
+//config:     Contrary to what you may think, this is not eating much.
+//config:     Make it smaller than 4k only if you are very limited on memory.
+//config:
+//config:config FEATURE_VI_8BIT
+//config:   bool "Allow vi to display 8-bit chars (otherwise shows dots)"
+//config:   default n
+//config:   depends on VI
+//config:   help
+//config:     If your terminal can display characters with high bit set,
+//config:     you may want to enable this. Note: vi is not Unicode-capable.
+//config:     If your terminal combines several 8-bit bytes into one character
+//config:     (as in Unicode mode), this will not work properly.
+//config:
+//config:config FEATURE_VI_COLON
+//config:   bool "Enable \":\" colon commands (no \"ex\" mode)"
+//config:   default y
+//config:   depends on VI
+//config:   help
+//config:     Enable a limited set of colon commands for vi. This does not
+//config:     provide an "ex" mode.
+//config:
+//config:config FEATURE_VI_YANKMARK
+//config:   bool "Enable yank/put commands and mark cmds"
+//config:   default y
+//config:   depends on VI
+//config:   help
+//config:     This will enable you to use yank and put, as well as mark in
+//config:     busybox vi.
+//config:
+//config:config FEATURE_VI_SEARCH
+//config:   bool "Enable search and replace cmds"
+//config:   default y
+//config:   depends on VI
+//config:   help
+//config:     Select this if you wish to be able to do search and replace in
+//config:     busybox vi.
+//config:
+//config:config FEATURE_VI_REGEX_SEARCH
+//config:   bool "Enable regex in search and replace"
+//config:   default n   # Uses GNU regex, which may be unavailable. FIXME
+//config:   depends on FEATURE_VI_SEARCH
+//config:   help
+//config:     Use extended regex search.
+//config:
+//config:config FEATURE_VI_USE_SIGNALS
+//config:   bool "Catch signals"
+//config:   default y
+//config:   depends on VI
+//config:   help
+//config:     Selecting this option will make busybox vi signal aware. This will
+//config:     make busybox vi support SIGWINCH to deal with Window Changes, catch
+//config:     Ctrl-Z and Ctrl-C and alarms.
+//config:
+//config:config FEATURE_VI_DOT_CMD
+//config:   bool "Remember previous cmd and \".\" cmd"
+//config:   default y
+//config:   depends on VI
+//config:   help
+//config:     Make busybox vi remember the last command and be able to repeat it.
+//config:
+//config:config FEATURE_VI_READONLY
+//config:   bool "Enable -R option and \"view\" mode"
+//config:   default y
+//config:   depends on VI
+//config:   help
+//config:     Enable the read-only command line option, which allows the user to
+//config:     open a file in read-only mode.
+//config:
+//config:config FEATURE_VI_SETOPTS
+//config:   bool "Enable set-able options, ai ic showmatch"
+//config:   default y
+//config:   depends on VI
+//config:   help
+//config:     Enable the editor to set some (ai, ic, showmatch) options.
+//config:
+//config:config FEATURE_VI_SET
+//config:   bool "Support for :set"
+//config:   default y
+//config:   depends on VI
+//config:   help
+//config:     Support for ":set".
+//config:
+//config:config FEATURE_VI_WIN_RESIZE
+//config:   bool "Handle window resize"
+//config:   default y
+//config:   depends on VI
+//config:   help
+//config:     Make busybox vi behave nicely with terminals that get resized.
+//config:
+//config:config FEATURE_VI_ASK_TERMINAL
+//config:   bool "Use 'tell me cursor position' ESC sequence to measure window"
+//config:   default y
+//config:   depends on VI
+//config:   help
+//config:     If terminal size can't be retrieved and $LINES/$COLUMNS are not set,
+//config:     this option makes vi perform a last-ditch effort to find it:
+//config:     position cursor to 999,999 and ask terminal to report real
+//config:     cursor position using "ESC [ 6 n" escape sequence, then read stdin.
+//config:
+//config:     This is not clean but helps a lot on serial lines and such.
+
+//applet:IF_VI(APPLET(vi, BB_DIR_BIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_VI) += vi.o
+
+//usage:#define vi_trivial_usage
+//usage:       "[OPTIONS] [FILE]..."
+//usage:#define vi_full_usage "\n\n"
+//usage:       "Edit FILE\n"
+//usage:    IF_FEATURE_VI_COLON(
+//usage:     "\n    -c CMD  Initial command to run ($EXINIT also available)"
+//usage:    )
+//usage:    IF_FEATURE_VI_READONLY(
+//usage:     "\n    -R  Read-only"
+//usage:    )
+//usage:     "\n    -H  List available features"
+
 #include "libbb.h"
+/* Should be after libbb.h: on some systems regex.h needs sys/types.h: */
+#if ENABLE_FEATURE_VI_REGEX_SEARCH
+# include <regex.h>
+#endif
 
 /* the CRASHME code is unmaintained, and doesn't currently build */
@@ -41 +177 @@
 /* 0x9b is Meta-ESC */
 #if ENABLE_FEATURE_VI_8BIT
-#define Isprint(c) ((unsigned char)(c) >= ' ' && (c) != 0x7f && (unsigned char)(c) != 0x9b)
+# define Isprint(c) ((unsigned char)(c) >= ' ' && (c) != 0x7f && (unsigned char)(c) != 0x9b)
 #else
-#define Isprint(c) ((unsigned char)(c) >= ' ' && (unsigned char)(c) < 0x7f)
+# define Isprint(c) ((unsigned char)(c) >= ' ' && (unsigned char)(c) < 0x7f)
 #endif
 
@@ -59 +195 @@
 };
 
-/* vt102 typical ESC sequence */
-/* terminal standout start/normal ESC sequence */
-#define SOs "\033[7m"
-#define SOn "\033[0m"
-/* terminal bell sequence */
-#define bell "\007"
-/* Clear-end-of-line and Clear-end-of-screen ESC sequence */
-#define Ceol "\033[K"
-#define Ceos "\033[J"
-/* Cursor motion arbitrary destination ESC sequence */
-#define CMrc "\033[%u;%uH"
-/* Cursor motion up and down ESC sequence */
-#define CMup "\033[A"
-#define CMdown "\n"
+/* VT102 ESC sequences.
+ * See "Xterm Control Sequences"
+ * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+ */
+/* Inverse/Normal text */
+#define ESC_BOLD_TEXT "\033[7m"
+#define ESC_NORM_TEXT "\033[0m"
+/* Bell */
+#define ESC_BELL "\007"
+/* Clear-to-end-of-line */
+#define ESC_CLEAR2EOL "\033[K"
+/* Clear-to-end-of-screen.
+ * (We use default param here.
+ * Full sequence is "ESC [ <num> J",
+ * <num> is 0/1/2 = "erase below/above/all".)
+ */
+#define ESC_CLEAR2EOS "\033[J"
+/* Cursor to given coordinate (1,1: top left) */
+#define ESC_SET_CURSOR_POS "\033[%u;%uH"
+//UNUSED
+///* Cursor up and down */
+//#define ESC_CURSOR_UP "\033[A"
+//#define ESC_CURSOR_DOWN "\n"
 
 #if ENABLE_FEATURE_VI_DOT_CMD || ENABLE_FEATURE_VI_YANKMARK
@@ -135 +280 @@
     int file_modified;       // buffer contents changed (counter, not flag!)
     int last_file_modified;  // = -1;
-    int fn_start;            // index of first cmd line file name
     int save_argc;           // how many file names on cmd line
     int cmdcnt;              // repetition count
@@ -161 +305 @@
     char *ioq, *ioq_start;   // pointer to string for get_one_char to "read"
 #endif
-#if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-    int last_row;        // where the cursor was last moved to
-#endif
 #if ENABLE_FEATURE_VI_USE_SIGNALS || ENABLE_FEATURE_VI_CRASHME
     int my_pid;
@@ -220 +361 @@
 #define file_modified           (G.file_modified      )
 #define last_file_modified      (G.last_file_modified )
-#define fn_start                (G.fn_start           )
 #define save_argc               (G.save_argc          )
 #define cmdcnt                  (G.cmdcnt             )
@@ -248 +388 @@
 #define ioq                     (G.ioq                )
 #define ioq_start               (G.ioq_start          )
-#define last_row                (G.last_row           )
 #define my_pid                  (G.my_pid             )
 #define last_search_pattern     (G.last_search_pattern)
@@ -329 +468 @@
 static int file_insert(const char *, char *, int);
 static int file_write(char *, char *, char *);
-#if !ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-#define place_cursor(a, b, optimize) place_cursor(a, b)
-#endif
-static void place_cursor(int, int, int);
+static void place_cursor(int, int);
 static void screen_erase(void);
 static void clear_to_eol(void);
@@ -355 +491 @@
 #if ENABLE_FEATURE_VI_SEARCH
 static char *char_search(char *, const char *, int, int);   // search for pattern starting at p
-static int mycmp(const char *, const char *, int);  // string cmp based in "ignorecase"
 #endif
 #if ENABLE_FEATURE_VI_COLON
@@ -418 +553 @@
 #endif
 
-    vi_setops = VI_AUTOINDENT | VI_SHOWMATCH | VI_IGNORECASE;
+    // autoindent is not default in vim 7.3
+    vi_setops = /*VI_AUTOINDENT |*/ VI_SHOWMATCH | VI_IGNORECASE;
     //  1-  process $HOME/.exrc file (not inplemented yet)
     //  2-  process EXINIT variable from environment
@@ -444 +580 @@
         case 'c':       // cmd line vi command
             if (*optarg)
-                initial_cmds[initial_cmds[0] != 0] = xstrndup(optarg, MAX_INPUT_LEN);
+                initial_cmds[initial_cmds[0] != NULL] = xstrndup(optarg, MAX_INPUT_LEN);
             break;
 #endif
@@ -457 +593 @@
 
     // The argv array can be used by the ":next"  and ":rewind" commands
-    // save optind.
-    fn_start = optind;  // remember first file name for :next and :rew
+    argv += optind;
+    argc -= optind;
+
+    //----- This is the main file handling loop --------------
     save_argc = argc;
-
-    //----- This is the main file handling loop --------------
+    optind = 0;
+    // "Save cursor, use alternate screen buffer, clear screen"
+    write1("\033[?1049h");
     while (1) {
         edit_file(argv[optind]); /* param might be NULL */
@@ -467 +606 @@
             break;
     }
+    // "Use normal screen buffer, restore cursor"
+    write1("\033[?1049l");
     //-----------------------------------------------------------
 
@@ -524 +665 @@
 #endif
     int c;
-    int size;
 #if ENABLE_FEATURE_VI_USE_SIGNALS
     int sig;
@@ -533 +673 @@
     rows = 24;
     columns = 80;
-    size = 0;
     IF_FEATURE_VI_ASK_TERMINAL(G.get_rowcol_error =) query_screen_dimensions();
 #if ENABLE_FEATURE_VI_ASK_TERMINAL
@@ -881 +1020 @@
         // don't edit, if the current file has been modified
         if (file_modified && !useforce) {
-            status_line_bold("No write since last change (:edit! overrides)");
+            status_line_bold("No write since last change (:%s! overrides)", cmd);
             goto ret;
         }
@@ -900 +1039 @@
 
 #if ENABLE_FEATURE_VI_YANKMARK
-        if (Ureg >= 0 && Ureg < 28 && reg[Ureg] != 0) {
+        if (Ureg >= 0 && Ureg < 28) {
             free(reg[Ureg]);    //   free orig line reg- for 'U'
-            reg[Ureg]= 0;
-        }
-        if (YDreg >= 0 && YDreg < 28 && reg[YDreg] != 0) {
+            reg[Ureg] = NULL;
+        }
+        if (YDreg >= 0 && YDreg < 28) {
             free(reg[YDreg]);   //   free default yank/delete register
-            reg[YDreg]= 0;
+            reg[YDreg] = NULL;
         }
 #endif
@@ -971 +1110 @@
     } else if (strncmp(cmd, "quit", i) == 0 // quit
             || strncmp(cmd, "next", i) == 0 // edit next file
+            || strncmp(cmd, "prev", i) == 0 // edit previous file
     ) {
         int n;
         if (useforce) {
-            // force end of argv list
             if (*cmd == 'q') {
+                // force end of argv list
                 optind = save_argc;
             }
@@ -983 +1123 @@
         // don't exit if the file been modified
         if (file_modified) {
-            status_line_bold("No write since last change (:%s! overrides)",
-                 (*cmd == 'q' ? "quit" : "next"));
+            status_line_bold("No write since last change (:%s! overrides)", cmd);
             goto ret;
         }
@@ -996 +1135 @@
             status_line_bold("No more files to edit");
             goto ret;
+        }
+        if (*cmd == 'p') {
+            // are there previous files to edit
+            if (optind < 1) {
+                status_line_bold("No previous files to edit");
+                goto ret;
+            }
+            optind -= 2;
         }
         editing = 0;
@@ -1032 +1179 @@
     } else if (strncmp(cmd, "rewind", i) == 0) {    // rewind cmd line args
         if (file_modified && !useforce) {
-            status_line_bold("No write since last change (:rewind! overrides)");
+            status_line_bold("No write since last change (:%s! overrides)", cmd);
         } else {
             // reset the filenames to edit
-            optind = fn_start - 1;
+            optind = -1; /* start from 0th file */
             editing = 0;
         }
@@ -1044 +1191 @@
 #endif
         i = 0;          // offset into args
-        // only blank is regarded as args delmiter. What about tab '\t' ?
+        // only blank is regarded as args delimiter. What about tab '\t'?
         if (!args[0] || strcasecmp(args, "all") == 0) {
             // print out values of all options
@@ -1085 +1232 @@
 #if ENABLE_FEATURE_VI_SEARCH
     } else if (cmd[0] == 's') { // substitute a pattern with a replacement pattern
-        char *ls, *F, *R;
-        int gflag;
+        char *F, *R, *flags;
+        size_t len_F, len_R;
+        int gflag;      // global replace flag
 
         // F points to the "find" pattern
         // R points to the "replace" pattern
-        // replace the cmd line delimiters "/" with NULLs
-        gflag = 0;      // global replace flag
+        // replace the cmd line delimiters "/" with NULs
         c = orig_buf[1];    // what is the delimiter
         F = orig_buf + 2;   // start of "find"
@@ -1097 +1244 @@
         if (!R)
             goto colon_s_fail;
+        len_F = R - F;
         *R++ = '\0';    // terminate "find"
-        buf1 = strchr(R, c);
-        if (!buf1)
+        flags = strchr(R, c);
+        if (!flags)
             goto colon_s_fail;
-        *buf1++ = '\0'; // terminate "replace"
-        if (*buf1 == 'g') { // :s/foo/bar/g
-            buf1++;
-            gflag++;    // turn on gflag
-        }
+        len_R = flags - R;
+        *flags++ = '\0';    // terminate "replace"
+        gflag = *flags;
+
         q = begin_line(q);
         if (b < 0) {    // maybe :s/foo/bar/
-            q = begin_line(dot);    // start with cur line
-            b = count_lines(text, q);   // cur line number
+            q = begin_line(dot);      // start with cur line
+            b = count_lines(text, q); // cur line number
         }
         if (e < 0)
             e = b;      // maybe :.s/foo/bar/
+
         for (i = b; i <= e; i++) {  // so, :20,23 s \0 find \0 replace \0
-            ls = q;     // orig line start
+            char *ls = q;       // orig line start
+            char *found;
  vc4:
-            buf1 = char_search(q, F, FORWARD, LIMITED); // search cur line only for "find"
-            if (buf1) {
+            found = char_search(q, F, FORWARD, LIMITED);    // search cur line only for "find"
+            if (found) {
                 uintptr_t bias;
                 // we found the "find" pattern - delete it
-                text_hole_delete(buf1, buf1 + strlen(F) - 1);
+                text_hole_delete(found, found + len_F - 1);
                 // inset the "replace" patern
-                bias = string_insert(buf1, R);  // insert the string
-                buf1 += bias;
+                bias = string_insert(found, R); // insert the string
+                found += bias;
                 ls += bias;
                 /*q += bias; - recalculated anyway */
                 // check for "global"  :s/foo/bar/g
-                if (gflag == 1) {
-                    if ((buf1 + strlen(R)) < end_line(ls)) {
-                        q = buf1 + strlen(R);
+                if (gflag == 'g') {
+                    if ((found + len_R) < end_line(ls)) {
+                        q = found + len_R;
                         goto vc4;   // don't let q move past cur line
                     }
@@ -1552 +1701 @@
 
 #if ENABLE_FEATURE_VI_SEARCH
-static int mycmp(const char *s1, const char *s2, int len)
-{
-    if (ENABLE_FEATURE_VI_SETOPTS && ignorecase) {
-        return strncasecmp(s1, s2, len);
-    }
-    return strncmp(s1, s2, len);
-}
+
+# if ENABLE_FEATURE_VI_REGEX_SEARCH
 
 // search for pattern starting at p
 static char *char_search(char *p, const char *pat, int dir, int range)
 {
-#ifndef REGEX_SEARCH
-    char *start, *stop;
-    int len;
-
-    len = strlen(pat);
-    if (dir == FORWARD) {
-        stop = end - 1; // assume range is p - end-1
-        if (range == LIMITED)
-            stop = next_line(p);    // range is to next line
-        for (start = p; start < stop; start++) {
-            if (mycmp(start, pat, len) == 0) {
-                return start;
-            }
-        }
-    } else if (dir == BACK) {
-        stop = text;    // assume range is text - p
-        if (range == LIMITED)
-            stop = prev_line(p);    // range is to prev line
-        for (start = p - len; start >= stop; start--) {
-            if (mycmp(start, pat, len) == 0) {
-                return start;
-            }
-        }
-    }
-    // pattern not found
-    return NULL;
-#else /* REGEX_SEARCH */
     char *q;
     struct re_pattern_buffer preg;
     int i;
-    int size, range;
+    int size;
 
     re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
@@ -1616 +1733 @@
     range = q - p;
 
-    q = re_compile_pattern(pat, strlen(pat), &preg);
+    q = (char *)re_compile_pattern(pat, strlen(pat), (struct re_pattern_buffer *)&preg);
     if (q != 0) {
         // The pattern was not compiled
@@ -1650 +1767 @@
     }
     return p;
-#endif /* REGEX_SEARCH */
-}
+}
+
+# else
+
+#  if ENABLE_FEATURE_VI_SETOPTS
+static int mycmp(const char *s1, const char *s2, int len)
+{
+    if (ignorecase) {
+        return strncasecmp(s1, s2, len);
+    }
+    return strncmp(s1, s2, len);
+}
+#  else
+#   define mycmp strncmp
+#  endif
+
+static char *char_search(char *p, const char *pat, int dir, int range)
+{
+    char *start, *stop;
+    int len;
+
+    len = strlen(pat);
+    if (dir == FORWARD) {
+        stop = end - 1; // assume range is p - end-1
+        if (range == LIMITED)
+            stop = next_line(p);    // range is to next line
+        for (start = p; start < stop; start++) {
+            if (mycmp(start, pat, len) == 0) {
+                return start;
+            }
+        }
+    } else if (dir == BACK) {
+        stop = text;    // assume range is text - p
+        if (range == LIMITED)
+            stop = prev_line(p);    // range is to prev line
+        for (start = p - len; start >= stop; start--) {
+            if (mycmp(start, pat, len) == 0) {
+                return start;
+            }
+        }
+    }
+    // pattern not found
+    return NULL;
+}
+
+# endif
+
 #endif /* FEATURE_VI_SEARCH */
 
@@ -1678 +1840 @@
         }
     } 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
         p += 1 + stupid_insert(p, c);   // insert the char
 #if ENABLE_FEATURE_VI_SETOPTS
@@ -1764 +1930 @@
         q = dot;
     } else {
-        // nothing -- this causes any other values of c to
-        // represent the one-character range under the
-        // cursor.  this is correct for ' ' and 'l', but
-        // perhaps no others.
-        //
+        // nothing -- this causes any other values of c to
+        // represent the one-character range under the
+        // cursor.  this is correct for ' ' and 'l', but
+        // perhaps no others.
+        //
     }
     if (q < p) {
@@ -1916 +2082 @@
         end         += bias;
         p           += bias;
+#if ENABLE_FEATURE_VI_YANKMARK
+        {
+            int i;
+            for (i = 0; i < ARRAY_SIZE(mark); i++)
+                if (mark[i])
+                    mark[i] += bias;
+        }
+#endif
         text = new_text;
     }
@@ -2002 +2176 @@
 #endif
 #if ENABLE_FEATURE_VI_DOT_CMD
-    "\n\tLast command repeat with \'.\'"
+    "\n\tLast command repeat with ."
 #endif
 #if ENABLE_FEATURE_VI_YANKMARK
@@ -2009 +2183 @@
 #endif
 #if ENABLE_FEATURE_VI_READONLY
-    "\n\tReadonly if vi is called as \"view\""
-    "\n\tReadonly with -R command line arg"
+    //not implemented: "\n\tReadonly if vi is called as \"view\""
+    //redundant: usage text says this too: "\n\tReadonly with -R command line arg"
 #endif
 #if ENABLE_FEATURE_VI_SET
-    "\n\tSome colon mode commands with \':\'"
+    "\n\tSome colon mode commands with :"
 #endif
 #if ENABLE_FEATURE_VI_SETOPTS
@@ -2147 +2321 @@
     tcgetattr(0, &term_orig);
     term_vi = term_orig;
-    term_vi.c_lflag &= (~ICANON & ~ECHO);   // leave ISIG ON- allow intr's
+    term_vi.c_lflag &= (~ICANON & ~ECHO);   // leave ISIG on - allow intr's
     term_vi.c_iflag &= (~IXON & ~ICRNL);
     term_vi.c_oflag &= (~ONLCR);
@@ -2418 +2592 @@
 
 //----- Move the cursor to row x col (count from 0, not 1) -------
-static void place_cursor(int row, int col, int optimize)
-{
-    char cm1[sizeof(CMrc) + sizeof(int)*3 * 2];
-#if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-    enum {
-        SZ_UP = sizeof(CMup),
-        SZ_DN = sizeof(CMdown),
-        SEQ_SIZE = SZ_UP > SZ_DN ? SZ_UP : SZ_DN,
-    };
-    char cm2[SEQ_SIZE * 5 + 32]; // bigger than worst case size
-#endif
-    char *cm;
+static void place_cursor(int row, int col)
+{
+    char cm1[sizeof(ESC_SET_CURSOR_POS) + sizeof(int)*3 * 2];
 
     if (row < 0) row = 0;
@@ -2436 +2601 @@
     if (col >= columns) col = columns - 1;
 
-    //----- 1.  Try the standard terminal ESC sequence
-    sprintf(cm1, CMrc, row + 1, col + 1);
-    cm = cm1;
-
-#if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-    if (optimize && col < 16) {
-        char *screenp;
-        int Rrow = last_row;
-        int diff = Rrow - row;
-
-        if (diff < -5 || diff > 5)
-            goto skip;
-
-        //----- find the minimum # of chars to move cursor -------------
-        //----- 2.  Try moving with discreet chars (Newline, [back]space, ...)
-        cm2[0] = '\0';
-
-        // move to the correct row
-        while (row < Rrow) {
-            // the cursor has to move up
-            strcat(cm2, CMup);
-            Rrow--;
-        }
-        while (row > Rrow) {
-            // the cursor has to move down
-            strcat(cm2, CMdown);
-            Rrow++;
-        }
-
-        // now move to the correct column
-        strcat(cm2, "\r");          // start at col 0
-        // just send out orignal source char to get to correct place
-        screenp = &screen[row * columns];   // start of screen line
-        strncat(cm2, screenp, col);
-
-        // pick the shortest cursor motion to send out
-        if (strlen(cm2) < strlen(cm)) {
-            cm = cm2;
-        }
- skip: ;
-    }
-    last_row = row;
-#endif /* FEATURE_VI_OPTIMIZE_CURSOR */
-    write1(cm);
+    sprintf(cm1, ESC_SET_CURSOR_POS, row + 1, col + 1);
+    write1(cm1);
 }
 
@@ -2485 +2608 @@
 static void clear_to_eol(void)
 {
-    write1(Ceol);   // Erase from cursor to end of line
+    write1(ESC_CLEAR2EOL);
 }
 
 static void go_bottom_and_clear_to_eol(void)
 {
-    place_cursor(rows - 1, 0, FALSE); // go to bottom of screen
-    clear_to_eol(); // erase to end of line
+    place_cursor(rows - 1, 0);
+    clear_to_eol();
 }
 
@@ -2497 +2620 @@
 static void clear_to_eos(void)
 {
-    write1(Ceos);   // Erase from cursor to end of screen
+    write1(ESC_CLEAR2EOS);
 }
 
 //----- Start standout mode ------------------------------------
-static void standout_start(void) // send "start reverse video" sequence
-{
-    write1(SOs);     // Start reverse video mode
+static void standout_start(void)
+{
+    write1(ESC_BOLD_TEXT);
 }
 
 //----- End standout mode --------------------------------------
-static void standout_end(void) // send "end reverse video" sequence
-{
-    write1(SOn);     // End reverse video mode
+static void standout_end(void)
+{
+    write1(ESC_NORM_TEXT);
 }
 
@@ -2515 +2638 @@
 static void flash(int h)
 {
-    standout_start();   // send "start reverse video" sequence
+    standout_start();
     redraw(TRUE);
     mysleep(h);
-    standout_end();     // send "end reverse video" sequence
+    standout_end();
     redraw(TRUE);
 }
@@ -2529 +2652 @@
 #endif
     if (!err_method) {
-        write1(bell);   // send out a bell character
+        write1(ESC_BELL);
     } else {
         flash(10);
@@ -2575 +2698 @@
             have_status_msg = 0;
         }
-        place_cursor(crow, ccol, FALSE);    // put cursor back in correct place
+        place_cursor(crow, ccol);  // put cursor back in correct place
     }
     fflush_all();
@@ -2587 +2710 @@
 
     va_start(args, format);
-    strcpy(status_buffer, SOs); // Terminal standout mode on
-    vsprintf(status_buffer + sizeof(SOs)-1, format, args);
-    strcat(status_buffer, SOn); // Terminal standout mode off
+    strcpy(status_buffer, ESC_BOLD_TEXT);
+    vsprintf(status_buffer + sizeof(ESC_BOLD_TEXT)-1, format, args);
+    strcat(status_buffer, ESC_NORM_TEXT);
     va_end(args);
 
-    have_status_msg = 1 + sizeof(SOs) + sizeof(SOn) - 2;
+    have_status_msg = 1 + sizeof(ESC_BOLD_TEXT) + sizeof(ESC_NORM_TEXT) - 2;
 }
 
@@ -2624 +2747 @@
         c_is_no_print = (c & 0x80) && !Isprint(c);
         if (c_is_no_print) {
-            strcpy(d, SOn);
-            d += sizeof(SOn)-1;
+            strcpy(d, ESC_NORM_TEXT);
+            d += sizeof(ESC_NORM_TEXT)-1;
             c = '.';
         }
@@ -2637 +2760 @@
         *d = '\0';
         if (c_is_no_print) {
-            strcpy(d, SOs);
-            d += sizeof(SOs)-1;
+            strcpy(d, ESC_BOLD_TEXT);
+            d += sizeof(ESC_BOLD_TEXT)-1;
         }
         if (*s == '\n') {
@@ -2720 +2843 @@
 static void redraw(int full_screen)
 {
-    place_cursor(0, 0, FALSE);  // put cursor in correct place
-    clear_to_eos();     // tell terminal to erase display
+    place_cursor(0, 0);
+    clear_to_eos();
     screen_erase();     // erase the internal screen buffer
     last_status_cksum = 0;  // force status update
@@ -2861 +2984 @@
             // copy changed part of buffer to virtual screen
             memcpy(sp+cs, out_buf+cs, ce-cs+1);
-
-            // move cursor to column of first change
-            //if (offset != old_offset) {
-            //  // place_cursor is still too stupid
-            //  // to handle offsets correctly
-            //  place_cursor(li, cs, FALSE);
-            //} else {
-                place_cursor(li, cs, TRUE);
-            //}
-
+            place_cursor(li, cs);
             // write line out to terminal
             fwrite(&sp[cs], ce - cs + 1, 1, stdout);
@@ -2876 +2990 @@
     }
 
-    place_cursor(crow, ccol, TRUE);
+    place_cursor(crow, ccol);
 
     old_offset = offset;
@@ -2906 +3020 @@
 static void do_cmd(int c)
 {
-    const char *msg = msg; // for compiler
     char *p, *q, *save_dot;
     char buf[12];
@@ -2915 +3028 @@
 //  c1 = c; // quiet the compiler
 //  cnt = yf = 0; // quiet the compiler
-//  msg = p = q = save_dot = buf; // quiet the compiler
-    memset(buf, '\0', 12);
+//  p = q = save_dot = buf; // quiet the compiler
+    memset(buf, '\0', sizeof(buf));
 
     show_status_line();
@@ -3032 +3145 @@
     case 8:     // ctrl-H- move left    (This may be ERASE char)
     case 0x7f:  // DEL- move left   (This may be ERASE char)
-        if (--cmdcnt > 0) {
-            do_cmd(c);
-        }
-        dot_left();
+        do {
+            dot_left();
+        } while (--cmdcnt > 0);
         break;
     case 10:            // Newline ^J
     case 'j':           // j- goto next line, same col
     case KEYCODE_DOWN:  // cursor key Down
-        if (--cmdcnt > 0) {
-            do_cmd(c);
-        }
-        dot_next();     // go to next B-o-l
-        dot = move_to_col(dot, ccol + offset);  // try stay in same col
+        do {
+            dot_next();     // go to next B-o-l
+            // try stay in same col
+            dot = move_to_col(dot, ccol + offset);
+        } while (--cmdcnt > 0);
         break;
     case 12:            // ctrl-L  force redraw whole screen
     case 18:            // ctrl-R  force redraw
-        place_cursor(0, 0, FALSE);  // put cursor in correct place
-        clear_to_eos(); // tel terminal to erase display
-        mysleep(10);
+        place_cursor(0, 0);
+        clear_to_eos();
+        //mysleep(10); // why???
         screen_erase(); // erase the internal screen buffer
         last_status_cksum = 0;  // force status update
@@ -3057 +3169 @@
     case 13:            // Carriage Return ^M
     case '+':           // +- goto next line
-        if (--cmdcnt > 0) {
-            do_cmd(c);
-        }
-        dot_next();
-        dot_skip_over_ws();
+        do {
+            dot_next();
+            dot_skip_over_ws();
+        } while (--cmdcnt > 0);
         break;
     case 21:            // ctrl-U  scroll up   half screen
@@ -3079 +3190 @@
     case 'l':           // move right
     case KEYCODE_RIGHT: // Cursor Key Right
-        if (--cmdcnt > 0) {
-            do_cmd(c);
-        }
-        dot_right();
+        do {
+            dot_right();
+        } while (--cmdcnt > 0);
         break;
 #if ENABLE_FEATURE_VI_YANKMARK
@@ -3152 +3262 @@
         break;
     case 'U':           // U- Undo; replace current line with original version
-        if (reg[Ureg] != 0) {
+        if (reg[Ureg] != NULL) {
             p = begin_line(dot);
             q = end_line(dot);
@@ -3164 +3274 @@
     case '$':           // $- goto end of line
     case KEYCODE_END:       // Cursor Key End
-        if (--cmdcnt > 0) {
+        for (;;) {
+            dot = end_line(dot);
+            if (--cmdcnt <= 0)
+                break;
             dot_next();
-            do_cmd(c);
-        }
-        dot = end_line(dot);
+        }
         break;
     case '%':           // %- find matching char of pair () [] {}
@@ -3193 +3304 @@
         //**** fall through to ... ';'
     case ';':           // ;- look at rest of line for last forward char
-        if (--cmdcnt > 0) {
-            do_cmd(';');
-        }
+        do {
+            if (last_forward_char == 0)
+                break;
+            q = dot + 1;
+            while (q < end - 1 && *q != '\n' && *q != last_forward_char) {
+                q++;
+            }
+            if (*q == last_forward_char)
+                dot = q;
+        } while (--cmdcnt > 0);
+        break;
+    case ',':           // repeat latest 'f' in opposite direction
         if (last_forward_char == 0)
             break;
-        q = dot + 1;
-        while (q < end - 1 && *q != '\n' && *q != last_forward_char) {
-            q++;
-        }
-        if (*q == last_forward_char)
-            dot = q;
-        break;
-    case ',':           // repeat latest 'f' in opposite direction
-        if (--cmdcnt > 0) {
-            do_cmd(',');
-        }
-        if (last_forward_char == 0)
-            break;
-        q = dot - 1;
-        while (q >= text && *q != '\n' && *q != last_forward_char) {
-            q--;
-        }
-        if (q >= text && *q == last_forward_char)
-            dot = q;
+        do {
+            q = dot - 1;
+            while (q >= text && *q != '\n' && *q != last_forward_char) {
+                q--;
+            }
+            if (q >= text && *q == last_forward_char)
+                dot = q;
+        } while (--cmdcnt > 0);
         break;
 
     case '-':           // -- goto prev line
-        if (--cmdcnt > 0) {
-            do_cmd(c);
-        }
-        dot_prev();
-        dot_skip_over_ws();
+        do {
+            dot_prev();
+            dot_skip_over_ws();
+        } while (--cmdcnt > 0);
         break;
 #if ENABLE_FEATURE_VI_DOT_CMD
@@ -3256 +3364 @@
         break;
     case 'N':           // N- backward search for last pattern
-        if (--cmdcnt > 0) {
-            do_cmd(c);
-        }
         dir = BACK;     // assume BACKWARD search
         p = dot - 1;
@@ -3270 +3375 @@
         // search rest of text[] starting at next char
         // if search fails return orignal "p" not the "p+1" address
-        if (--cmdcnt > 0) {
-            do_cmd(c);
-        }
+        do {
+            const char *msg;
  dc3:
-        dir = FORWARD;  // assume FORWARD search
-        p = dot + 1;
-        if (last_search_pattern[0] == '?') {
-            dir = BACK;
-            p = dot - 1;
-        }
+            dir = FORWARD;  // assume FORWARD search
+            p = dot + 1;
+            if (last_search_pattern[0] == '?') {
+                dir = BACK;
+                p = dot - 1;
+            }
  dc4:
-        q = char_search(p, last_search_pattern + 1, dir, FULL);
-        if (q != NULL) {
-            dot = q;    // good search, update "dot"
-            msg = "";
-            goto dc2;
-        }
-        // no pattern found between "dot" and "end"- continue at top
-        p = text;
-        if (dir == BACK) {
-            p = end - 1;
-        }
-        q = char_search(p, last_search_pattern + 1, dir, FULL);
-        if (q != NULL) {    // found something
-            dot = q;    // found new pattern- goto it
-            msg = "search hit BOTTOM, continuing at TOP";
+            q = char_search(p, last_search_pattern + 1, dir, FULL);
+            if (q != NULL) {
+                dot = q;    // good search, update "dot"
+                msg = NULL;
+                goto dc2;
+            }
+            // no pattern found between "dot" and "end"- continue at top
+            p = text;
             if (dir == BACK) {
-                msg = "search hit TOP, continuing at BOTTOM";
-            }
-        } else {
-            msg = "Pattern not found";
-        }
+                p = end - 1;
+            }
+            q = char_search(p, last_search_pattern + 1, dir, FULL);
+            if (q != NULL) {    // found something
+                dot = q;    // found new pattern- goto it
+                msg = "search hit BOTTOM, continuing at TOP";
+                if (dir == BACK) {
+                    msg = "search hit TOP, continuing at BOTTOM";
+                }
+            } else {
+                msg = "Pattern not found";
+            }
  dc2:
-        if (*msg)
-            status_line_bold("%s", msg);
+            if (msg)
+                status_line_bold("%s", msg);
+        } while (--cmdcnt > 0);
         break;
     case '{':           // {- move backward paragraph
@@ -3349 +3454 @@
         ) {
             if (file_modified && p[1] != '!') {
-                status_line_bold("No write since last change (:quit! overrides)");
+                status_line_bold("No write since last change (:%s! overrides)", p);
             } else {
                 editing = 0;
@@ -3423 +3528 @@
     case 'E':           // E- end of a blank-delimited word
     case 'W':           // W- forward a blank-delimited word
-        if (--cmdcnt > 0) {
-            do_cmd(c);
-        }
         dir = FORWARD;
         if (c == 'B')
             dir = BACK;
-        if (c == 'W' || isspace(dot[dir])) {
-            dot = skip_thing(dot, 1, dir, S_TO_WS);
-            dot = skip_thing(dot, 2, dir, S_OVER_WS);
-        }
-        if (c != 'W')
-            dot = skip_thing(dot, 1, dir, S_BEFORE_WS);
+        do {
+            if (c == 'W' || isspace(dot[dir])) {
+                dot = skip_thing(dot, 1, dir, S_TO_WS);
+                dot = skip_thing(dot, 2, dir, S_OVER_WS);
+            }
+            if (c != 'W')
+                dot = skip_thing(dot, 1, dir, S_BEFORE_WS);
+        } while (--cmdcnt > 0);
         break;
     case 'C':           // C- Change to e-o-l
@@ -3485 +3589 @@
     case KEYCODE_INSERT:    // Cursor Key Insert
  dc_i:
-        cmd_mode = 1;   // start insrting
+        cmd_mode = 1;   // start inserting
         break;
     case 'J':           // J- join current and next lines together
-        if (--cmdcnt > 1) {
-            do_cmd(c);
-        }
-        dot_end();      // move to NL
-        if (dot < end - 1) {    // make sure not last char in text[]
-            *dot++ = ' ';   // replace NL with space
-            file_modified++;
-            while (isblank(*dot)) { // delete leading WS
-                dot_delete();
-            }
-        }
+        do {
+            dot_end();      // move to NL
+            if (dot < end - 1) {    // make sure not last char in text[]
+                *dot++ = ' ';   // replace NL with space
+                file_modified++;
+                while (isblank(*dot)) { // delete leading WS
+                    dot_delete();
+                }
+            }
+        } while (--cmdcnt > 0);
         end_cmd_q();    // stop adding to q
         break;
@@ -3542 +3645 @@
     case 'x':           // x- delete the current char
     case 's':           // s- substitute the current char
-        if (--cmdcnt > 0) {
-            do_cmd(c);
-        }
         dir = 0;
         if (c == 'X')
             dir = -1;
-        if (dot[dir] != '\n') {
-            if (c == 'X')
-                dot--;  // delete prev char
-            dot = yank_delete(dot, dot, 0, YANKDEL);    // delete char
-        }
+        do {
+            if (dot[dir] != '\n') {
+                if (c == 'X')
+                    dot--;  // delete prev char
+                dot = yank_delete(dot, dot, 0, YANKDEL);    // delete char
+            }
+        } while (--cmdcnt > 0);
+        end_cmd_q();    // stop adding to q
         if (c == 's')
-            goto dc_i;  // start insrting
-        end_cmd_q();    // stop adding to q
+            goto dc_i;  // start inserting
         break;
     case 'Z':           // Z- if modified, {write}; exit
@@ -3586 +3688 @@
     case 'b':           // b- back a word
     case 'e':           // e- end of word
-        if (--cmdcnt > 0) {
-            do_cmd(c);
-        }
         dir = FORWARD;
         if (c == 'b')
             dir = BACK;
-        if ((dot + dir) < text || (dot + dir) > end - 1)
-            break;
-        dot += dir;
-        if (isspace(*dot)) {
-            dot = skip_thing(dot, (c == 'e') ? 2 : 1, dir, S_OVER_WS);
-        }
-        if (isalnum(*dot) || *dot == '_') {
-            dot = skip_thing(dot, 1, dir, S_END_ALNUM);
-        } else if (ispunct(*dot)) {
-            dot = skip_thing(dot, 1, dir, S_END_PUNCT);
-        }
+        do {
+            if ((dot + dir) < text || (dot + dir) > end - 1)
+                break;
+            dot += dir;
+            if (isspace(*dot)) {
+                dot = skip_thing(dot, (c == 'e') ? 2 : 1, dir, S_OVER_WS);
+            }
+            if (isalnum(*dot) || *dot == '_') {
+                dot = skip_thing(dot, 1, dir, S_END_ALNUM);
+            } else if (ispunct(*dot)) {
+                dot = skip_thing(dot, 1, dir, S_END_PUNCT);
+            }
+        } while (--cmdcnt > 0);
         break;
     case 'c':           // c- change something
@@ -3687 +3788 @@
     case 'k':           // k- goto prev line, same col
     case KEYCODE_UP:        // cursor key Up
-        if (--cmdcnt > 0) {
-            do_cmd(c);
-        }
-        dot_prev();
-        dot = move_to_col(dot, ccol + offset);  // try stay in same col
+        do {
+            dot_prev();
+            dot = move_to_col(dot, ccol + offset);  // try stay in same col
+        } while (--cmdcnt > 0);
         break;
     case 'r':           // r- replace the current char with user input
@@ -3709 +3809 @@
         break;
     case 'w':           // w- forward a word
-        if (--cmdcnt > 0) {
-            do_cmd(c);
-        }
-        if (isalnum(*dot) || *dot == '_') { // we are on ALNUM
-            dot = skip_thing(dot, 1, FORWARD, S_END_ALNUM);
-        } else if (ispunct(*dot)) { // we are on PUNCT
-            dot = skip_thing(dot, 1, FORWARD, S_END_PUNCT);
-        }
-        if (dot < end - 1)
-            dot++;      // move over word
-        if (isspace(*dot)) {
-            dot = skip_thing(dot, 2, FORWARD, S_OVER_WS);
-        }
+        do {
+            if (isalnum(*dot) || *dot == '_') { // we are on ALNUM
+                dot = skip_thing(dot, 1, FORWARD, S_END_ALNUM);
+            } else if (ispunct(*dot)) { // we are on PUNCT
+                dot = skip_thing(dot, 1, FORWARD, S_END_PUNCT);
+            }
+            if (dot < end - 1)
+                dot++;      // move over word
+            if (isspace(*dot)) {
+                dot = skip_thing(dot, 2, FORWARD, S_OVER_WS);
+            }
+        } while (--cmdcnt > 0);
         break;
     case 'z':           // z-
@@ -3737 +3836 @@
         break;
     case '~':           // ~- flip the case of letters   a-z -> A-Z
-        if (--cmdcnt > 0) {
-            do_cmd(c);
-        }
-        if (islower(*dot)) {
-            *dot = toupper(*dot);
-            file_modified++;
-        } else if (isupper(*dot)) {
-            *dot = tolower(*dot);
-            file_modified++;
-        }
-        dot_right();
+        do {
+            if (islower(*dot)) {
+                *dot = toupper(*dot);
+                file_modified++;
+            } else if (isupper(*dot)) {
+                *dot = tolower(*dot);
+                file_modified++;
+            }
+            dot_right();
+        } while (--cmdcnt > 0);
         end_cmd_q();    // stop adding to q
         break;
@@ -3983 +4081 @@
     if (msg[0]) {
         printf("\n\n%d: \'%c\' %s\n\n\n%s[Hit return to continue]%s",
-            totalcmds, last_input_char, msg, SOs, SOn);
+            totalcmds, last_input_char, msg, ESC_BOLD_TEXT, ESC_NORM_TEXT);
         fflush_all();
         while (safe_read(STDIN_FILENO, d, 1) > 0) {