Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/editors

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

Location:

branches/2.2.9/mindi-busybox/editors

Files:

• Config.in (modified) (10 diffs)
• Config.src (added)
• Kbuild (modified) (1 diff)
• Kbuild.src (added)
• awk.c (modified) (107 diffs)
• cmp.c (modified) (9 diffs)
• diff.c (modified) (5 diffs)
• ed.c (modified) (51 diffs)
• patch.c (modified) (1 diff)
• patch_bbox.c (added)
• patch_toybox.c (added)
• sed.c (modified) (42 diffs)
• sed1line.txt (added)
• sed_summary.htm (added)
• vi.c (modified) (165 diffs)

branches/2.2.9/mindi-busybox/editors/Config.in

@@ +1 @@
+# DO NOT EDIT. This file is generated from Config.src
 #
 # For a description of the syntax of this configuration file,
@@ -6 +7 @@
 menu "Editors"
 
+config PATCH
+    bool "patch"
+    default y
+    help
+      Apply a unified diff formatted patch.
+
 config AWK
     bool "awk"
-    default n
-    help
-      Awk is used as a pattern scanning and processing language.  This is
+    default y
+    help
+      Awk is used as a pattern scanning and processing language. This is
       the BusyBox implementation of that programming language.
 
-config FEATURE_AWK_MATH
+config FEATURE_AWK_LIBM
     bool "Enable math functions (requires libm)"
     default y
@@ -23 +30 @@
 config CMP
     bool "cmp"
-    default n
+    default y
     help
       cmp is used to compare two files and returns the result
@@ -30 +37 @@
 config DIFF
     bool "diff"
-    default n
+    default y
     help
       diff compares two files or directories and outputs the
@@ -36 +43 @@
       the patch command.
 
-config FEATURE_DIFF_BINARY
-    bool "Enable checks for binary files"
-    default y
-    depends on DIFF
-    help
-      This option enables support for checking for binary files
-      before a comparison is carried out.
+config FEATURE_DIFF_LONG_OPTIONS
+    bool "Enable long options"
+    default y
+    depends on DIFF && LONG_OPTS
+    help
+      Enable use of long options.
 
 config FEATURE_DIFF_DIR
@@ -52 +58 @@
       comparison.
 
-config FEATURE_DIFF_MINIMAL
-    bool "Enable -d option to find smaller sets of changes"
-    default n
-    depends on DIFF
-    help
-      Enabling this option allows the use of -d to make diff
-      try hard to find the smallest possible set of changes.
-
 config ED
     bool "ed"
-    default n
+    default y
     help
       The original 1970's Unix text editor, from the days of teletypes.
-      Small, simple, evil.  Part of SUSv3.  If you're not already using
+      Small, simple, evil. Part of SUSv3. If you're not already using
       this, you don't need it.
-
-config PATCH
-    bool "patch"
-    default n
-    help
-      Apply a unified diff formatted patch.
 
 config SED
     bool "sed"
-    default n
+    default y
     help
       sed is used to perform text transformations on a file
@@ -83 +75 @@
 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
-    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 line length in vi"
-    range 256 16384
-    default 1024
-    depends on VI
-    help
-      vi uses on-stack buffers for intermediate line buffers.
-      You may want to decrease this parameter if your target machine
-      benefits from smaller stack usage.
+    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
@@ -105 +106 @@
     depends on VI
     help
-      Enable a limited set of colon commands for vi.  This does not
+      Enable a limited set of colon commands for vi. This does not
       provide an "ex" mode.
 
@@ -129 +130 @@
     depends on VI
     help
-      Selecting this option will make busybox vi signal aware.  This will
+      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.
@@ -169 +170 @@
       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"

branches/2.2.9/mindi-busybox/editors/Kbuild

@@ +1 @@
+# DO NOT EDIT. This file is generated from Kbuild.src
 # Makefile for busybox
 #
 # Copyright (C) 1999-2005 by Erik Andersen <andersen@codepoet.org>
 #
-# Licensed under the GPL v2, see the file LICENSE in this tarball.
+# Licensed under GPLv2, see file LICENSE in this source tree.
 
 lib-y:=
+
+lib-$(CONFIG_PATCH) += patch.o
 lib-$(CONFIG_AWK)       += awk.o
 lib-$(CONFIG_CMP)       += cmp.o
 lib-$(CONFIG_DIFF)      += diff.o
 lib-$(CONFIG_ED)        += ed.o
-lib-$(CONFIG_PATCH)     += patch.o
 lib-$(CONFIG_SED)       += sed.o
 lib-$(CONFIG_VI)        += vi.o

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

@@ -5 +5 @@
  * Copyright (C) 2002 by Dmitry Zakharov <dmit@crp.bank.gov.ua>
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -11 +11 @@
 #include "xregex.h"
 #include <math.h>
-extern char **environ;
 
 /* This is a NOEXEC applet. Be very careful! */
+
+
+/* If you comment out one of these below, it will be #defined later
+ * to perform debug printfs to stderr: */
+#define debug_printf_walker(...)  do {} while (0)
+#define debug_printf_eval(...)  do {} while (0)
+
+#ifndef debug_printf_walker
+# define debug_printf_walker(...) (fprintf(stderr, __VA_ARGS__))
+#endif
+#ifndef debug_printf_eval
+# define debug_printf_eval(...) (fprintf(stderr, __VA_ARGS__))
+#endif
+
 
 
@@ -33 +46 @@
 /* these flags are static, don't change them when value is changed */
 #define VF_DONTTOUCH    (VF_ARRAY | VF_SPECIAL | VF_WALK | VF_CHILD | VF_DIRTY)
+
+typedef struct walker_list {
+    char *end;
+    char *cur;
+    struct walker_list *prev;
+    char wbuf[1];
+} walker_list;
 
 /* Variable */
@@ -43 +63 @@
         struct xhash_s *array;  /* array ptr */
         struct var_s *parent;   /* for func args, ptr to actual parameter */
-        char **walker;          /* list of array elements (for..in) */
+        walker_list *walker;    /* list of array elements (for..in) */
     } x;
 } var;
@@ -95 +115 @@
         struct node_s *n;
         var *v;
-        int i;
-        char *s;
+        int aidx;
+        char *new_progname;
         regex_t *re;
     } l;
@@ -103 +123 @@
         regex_t *ire;
         func *f;
-        int argno;
     } r;
     union {
@@ -116 +135 @@
     struct nvblock_s *prev;
     struct nvblock_s *next;
-    var nv[0];
+    var nv[];
 } nvblock;
 
@@ -252 +271 @@
 /* builtins */
 enum {
-    B_a2,   B_ix,   B_ma,   B_sp,   B_ss,   B_ti,   B_lo,   B_up,
+    B_a2,   B_ix,   B_ma,   B_sp,   B_ss,   B_ti,   B_mt,   B_lo,   B_up,
     B_ge,   B_gs,   B_su,
     B_an,   B_co,   B_ls,   B_or,   B_rs,   B_xo,
@@ -259 +278 @@
 /* tokens and their corresponding info values */
 
-#define NTC     "\377"  /* switch to next token class (tc<<1) */
-#define NTCC    '\377'
-
-#define OC_B    OC_BUILTIN
+#define NTC     "\377"  /* switch to next token class (tc<<1) */
+#define NTCC    '\377'
+
+#define OC_B  OC_BUILTIN
 
 static const char tokenlist[] ALIGN1 =
-    "\1("       NTC
-    "\1)"       NTC
-    "\1/"       NTC                                 /* REGEXP */
-    "\2>>"      "\1>"       "\1|"       NTC         /* OUTRDR */
-    "\2++"      "\2--"      NTC                     /* UOPPOST */
-    "\2++"      "\2--"      "\1$"       NTC         /* UOPPRE1 */
-    "\2=="      "\1="       "\2+="      "\2-="      /* BINOPX */
-    "\2*="      "\2/="      "\2%="      "\2^="
-    "\1+"       "\1-"       "\3**="     "\2**"
-    "\1/"       "\1%"       "\1^"       "\1*"
-    "\2!="      "\2>="      "\2<="      "\1>"
-    "\1<"       "\2!~"      "\1~"       "\2&&"
-    "\2||"      "\1?"       "\1:"       NTC
-    "\2in"      NTC
-    "\1,"       NTC
-    "\1|"       NTC
-    "\1+"       "\1-"       "\1!"       NTC         /* UOPPRE2 */
-    "\1]"       NTC
-    "\1{"       NTC
-    "\1}"       NTC
-    "\1;"       NTC
-    "\1\n"      NTC
-    "\2if"      "\2do"      "\3for"     "\5break"   /* STATX */
-    "\10continue"           "\6delete"  "\5print"
-    "\6printf"  "\4next"    "\10nextfile"
-    "\6return"  "\4exit"    NTC
-    "\5while"   NTC
-    "\4else"    NTC
-
-    "\3and"     "\5compl"   "\6lshift"  "\2or"
-    "\6rshift"  "\3xor"
-    "\5close"   "\6system"  "\6fflush"  "\5atan2"   /* BUILTIN */
-    "\3cos"     "\3exp"     "\3int"     "\3log"
-    "\4rand"    "\3sin"     "\4sqrt"    "\5srand"
-    "\6gensub"  "\4gsub"    "\5index"   "\6length"
-    "\5match"   "\5split"   "\7sprintf" "\3sub"
-    "\6substr"  "\7systime" "\10strftime"
-    "\7tolower" "\7toupper" NTC
-    "\7getline" NTC
-    "\4func"    "\10function"   NTC
-    "\5BEGIN"   NTC
-    "\3END"     "\0"
+    "\1("         NTC
+    "\1)"         NTC
+    "\1/"         NTC                                   /* REGEXP */
+    "\2>>"        "\1>"         "\1|"       NTC         /* OUTRDR */
+    "\2++"        "\2--"        NTC                     /* UOPPOST */
+    "\2++"        "\2--"        "\1$"       NTC         /* UOPPRE1 */
+    "\2=="        "\1="         "\2+="      "\2-="      /* BINOPX */
+    "\2*="        "\2/="        "\2%="      "\2^="
+    "\1+"         "\1-"         "\3**="     "\2**"
+    "\1/"         "\1%"         "\1^"       "\1*"
+    "\2!="        "\2>="        "\2<="      "\1>"
+    "\1<"         "\2!~"        "\1~"       "\2&&"
+    "\2||"        "\1?"         "\1:"       NTC
+    "\2in"        NTC
+    "\1,"         NTC
+    "\1|"         NTC
+    "\1+"         "\1-"         "\1!"       NTC         /* UOPPRE2 */
+    "\1]"         NTC
+    "\1{"         NTC
+    "\1}"         NTC
+    "\1;"         NTC
+    "\1\n"        NTC
+    "\2if"        "\2do"        "\3for"     "\5break"   /* STATX */
+    "\10continue" "\6delete"    "\5print"
+    "\6printf"    "\4next"      "\10nextfile"
+    "\6return"    "\4exit"      NTC
+    "\5while"     NTC
+    "\4else"      NTC
+
+    "\3and"       "\5compl"     "\6lshift"  "\2or"
+    "\6rshift"    "\3xor"
+    "\5close"     "\6system"    "\6fflush"  "\5atan2"   /* BUILTIN */
+    "\3cos"       "\3exp"       "\3int"     "\3log"
+    "\4rand"      "\3sin"       "\4sqrt"    "\5srand"
+    "\6gensub"    "\4gsub"      "\5index"   "\6length"
+    "\5match"     "\5split"     "\7sprintf" "\3sub"
+    "\6substr"    "\7systime"   "\10strftime" "\6mktime"
+    "\7tolower"   "\7toupper"   NTC
+    "\7getline"   NTC
+    "\4func"      "\10function" NTC
+    "\5BEGIN"     NTC
+    "\3END"
+    /* compiler adds trailing "\0" */
     ;
 
@@ -313 +333 @@
     0,
     OC_REGEXP,
-    xS|'a',     xS|'w',     xS|'|',
-    OC_UNARY|xV|P(9)|'p',       OC_UNARY|xV|P(9)|'m',
-    OC_UNARY|xV|P(9)|'P',       OC_UNARY|xV|P(9)|'M',
-        OC_FIELD|xV|P(5),
-    OC_COMPARE|VV|P(39)|5,      OC_MOVE|VV|P(74),
-        OC_REPLACE|NV|P(74)|'+',    OC_REPLACE|NV|P(74)|'-',
-    OC_REPLACE|NV|P(74)|'*',    OC_REPLACE|NV|P(74)|'/',
-        OC_REPLACE|NV|P(74)|'%',    OC_REPLACE|NV|P(74)|'&',
-    OC_BINARY|NV|P(29)|'+',     OC_BINARY|NV|P(29)|'-',
-        OC_REPLACE|NV|P(74)|'&',    OC_BINARY|NV|P(15)|'&',
-    OC_BINARY|NV|P(25)|'/',     OC_BINARY|NV|P(25)|'%',
-        OC_BINARY|NV|P(15)|'&',     OC_BINARY|NV|P(25)|'*',
-    OC_COMPARE|VV|P(39)|4,      OC_COMPARE|VV|P(39)|3,
-        OC_COMPARE|VV|P(39)|0,      OC_COMPARE|VV|P(39)|1,
-    OC_COMPARE|VV|P(39)|2,      OC_MATCH|Sx|P(45)|'!',
-        OC_MATCH|Sx|P(45)|'~',      OC_LAND|Vx|P(55),
-    OC_LOR|Vx|P(59),            OC_TERNARY|Vx|P(64)|'?',
-        OC_COLON|xx|P(67)|':',
-    OC_IN|SV|P(49),
+    xS|'a',                  xS|'w',                  xS|'|',
+    OC_UNARY|xV|P(9)|'p',    OC_UNARY|xV|P(9)|'m',
+    OC_UNARY|xV|P(9)|'P',    OC_UNARY|xV|P(9)|'M',    OC_FIELD|xV|P(5),
+    OC_COMPARE|VV|P(39)|5,   OC_MOVE|VV|P(74),        OC_REPLACE|NV|P(74)|'+', OC_REPLACE|NV|P(74)|'-',
+    OC_REPLACE|NV|P(74)|'*', OC_REPLACE|NV|P(74)|'/', OC_REPLACE|NV|P(74)|'%', OC_REPLACE|NV|P(74)|'&',
+    OC_BINARY|NV|P(29)|'+',  OC_BINARY|NV|P(29)|'-',  OC_REPLACE|NV|P(74)|'&', OC_BINARY|NV|P(15)|'&',
+    OC_BINARY|NV|P(25)|'/',  OC_BINARY|NV|P(25)|'%',  OC_BINARY|NV|P(15)|'&',  OC_BINARY|NV|P(25)|'*',
+    OC_COMPARE|VV|P(39)|4,   OC_COMPARE|VV|P(39)|3,   OC_COMPARE|VV|P(39)|0,   OC_COMPARE|VV|P(39)|1,
+    OC_COMPARE|VV|P(39)|2,   OC_MATCH|Sx|P(45)|'!',   OC_MATCH|Sx|P(45)|'~',   OC_LAND|Vx|P(55),
+    OC_LOR|Vx|P(59),         OC_TERNARY|Vx|P(64)|'?', OC_COLON|xx|P(67)|':',
+    OC_IN|SV|P(49), /* in */
     OC_COMMA|SS|P(80),
     OC_PGETLINE|SV|P(37),
-    OC_UNARY|xV|P(19)|'+',      OC_UNARY|xV|P(19)|'-',
-        OC_UNARY|xV|P(19)|'!',
+    OC_UNARY|xV|P(19)|'+',   OC_UNARY|xV|P(19)|'-',   OC_UNARY|xV|P(19)|'!',
+    0, /* ] */
     0,
     0,
     0,
-    0,
-    0,
-    ST_IF,          ST_DO,          ST_FOR,         OC_BREAK,
-    OC_CONTINUE,                    OC_DELETE|Vx,   OC_PRINT,
-    OC_PRINTF,      OC_NEXT,        OC_NEXTFILE,
-    OC_RETURN|Vx,   OC_EXIT|Nx,
+    0, /* \n */
+    ST_IF,        ST_DO,        ST_FOR,      OC_BREAK,
+    OC_CONTINUE,  OC_DELETE|Vx, OC_PRINT,
+    OC_PRINTF,    OC_NEXT,      OC_NEXTFILE,
+    OC_RETURN|Vx, OC_EXIT|Nx,
     ST_WHILE,
-    0,
+    0, /* else */
 
     OC_B|B_an|P(0x83), OC_B|B_co|P(0x41), OC_B|B_ls|P(0x83), OC_B|B_or|P(0x83),
@@ -355 +366 @@
     OC_B|B_ge|P(0xd6), OC_B|B_gs|P(0xb6), OC_B|B_ix|P(0x9b), OC_FBLTIN|Sx|F_le,
     OC_B|B_ma|P(0x89), OC_B|B_sp|P(0x8b), OC_SPRINTF,        OC_B|B_su|P(0xb6),
-    OC_B|B_ss|P(0x8f), OC_FBLTIN|F_ti,    OC_B|B_ti|P(0x0b),
+    OC_B|B_ss|P(0x8f), OC_FBLTIN|F_ti,    OC_B|B_ti|P(0x0b), OC_B|B_mt|P(0x0b),
     OC_B|B_lo|P(0x49), OC_B|B_up|P(0x49),
     OC_GETLINE|SV|P(0),
-    0,  0,
+    0,                 0,
     0,
-    0
+    0 /* END */
 };
 
@@ -368 +379 @@
     CONVFMT,    OFMT,       FS,         OFS,
     ORS,        RS,         RT,         FILENAME,
-    SUBSEP,     ARGIND,     ARGC,       ARGV,
-    ERRNO,      FNR,
-    NR,         NF,         IGNORECASE,
-    ENVIRON,    F0,         NUM_INTERNAL_VARS
+    SUBSEP,     F0,         ARGIND,     ARGC,
+    ARGV,       ERRNO,      FNR,        NR,
+    NF,         IGNORECASE, ENVIRON,    NUM_INTERNAL_VARS
 };
 
@@ -377 +387 @@
     "CONVFMT\0" "OFMT\0"    "FS\0*"     "OFS\0"
     "ORS\0"     "RS\0*"     "RT\0"      "FILENAME\0"
-    "SUBSEP\0"  "ARGIND\0"  "ARGC\0"    "ARGV\0"
-    "ERRNO\0"   "FNR\0"
-    "NR\0"      "NF\0*"     "IGNORECASE\0*"
-    "ENVIRON\0" "$\0*"      "\0";
+    "SUBSEP\0"  "$\0*"      "ARGIND\0"  "ARGC\0"
+    "ARGV\0"    "ERRNO\0"   "FNR\0"     "NR\0"
+    "NF\0*"     "IGNORECASE\0*" "ENVIRON\0" "\0";
 
 static const char vValues[] ALIGN1 =
     "%.6g\0"    "%.6g\0"    " \0"       " \0"
     "\n\0"      "\n\0"      "\0"        "\0"
-    "\034\0"
-    "\377";
+    "\034\0"    "\0"        "\377";
 
 /* hash size may grow to these values */
@@ -394 +402 @@
 
 /* Globals. Split in two parts so that first one is addressed
- * with (mostly short) negative offsets */
+ * with (mostly short) negative offsets.
+ * NB: it's unsafe to put members of type "double"
+ * into globals2 (gcc may fail to align them).
+ */
 struct globals {
-    chain beginseq, mainseq, endseq, *seq;
+    double t_double;
+    chain beginseq, mainseq, endseq;
+    chain *seq;
     node *break_ptr, *continue_ptr;
     rstream *iF;
@@ -443 +456 @@
 
     /* biggest and least used members go last */
-    double t_double;
     tsplitter fsplitter, rsplitter;
 };
 #define G1 (ptr_to_globals[-1])
-#define G (*(struct globals2 *const)ptr_to_globals)
+#define G (*(struct globals2 *)ptr_to_globals)
 /* For debug. nm --size-sort awk.o | grep -vi ' [tr] ' */
-/* char G1size[sizeof(G1)]; - 0x6c */
-/* char Gsize[sizeof(G)]; - 0x1cc */
+/*char G1size[sizeof(G1)]; - 0x74 */
+/*char Gsize[sizeof(G)]; - 0x1c4 */
 /* Trying to keep most of members accessible with short offsets: */
-/* char Gofs_seed[offsetof(struct globals2, evaluate__seed)]; - 0x90 */
+/*char Gofs_seed[offsetof(struct globals2, evaluate__seed)]; - 0x90 */
+#define t_double     (G1.t_double    )
 #define beginseq     (G1.beginseq    )
 #define mainseq      (G1.mainseq     )
@@ -480 +493 @@
 #define t_tclass     (G.t_tclass    )
 #define t_string     (G.t_string    )
-#define t_double     (G.t_double    )
 #define t_lineno     (G.t_lineno    )
 #define t_rollback   (G.t_rollback  )
@@ -487 +499 @@
 #define rsplitter    (G.rsplitter   )
 #define INIT_G() do { \
-    PTR_TO_GLOBALS = xzalloc(sizeof(G1) + sizeof(G)) + sizeof(G1); \
+    SET_PTR_TO_GLOBALS((char*)xzalloc(sizeof(G1)+sizeof(G)) + sizeof(G1)); \
     G.next_token__ltclass = TC_OPTERM; \
     G.evaluate__seed = 1; \
@@ -500 +512 @@
 static rstream *next_input_file(void);
 static int fmt_num(char *, int, const char *, double, int);
-static int awk_exit(int) ATTRIBUTE_NORETURN;
+static int awk_exit(int) NORETURN;
 
 /* ---- error handling ---- */
@@ -513 +525 @@
 static const char EMSG_POSSIBLE_ERROR[] ALIGN1 = "Possible syntax error";
 static const char EMSG_UNDEF_FUNC[] ALIGN1 = "Call to undefined function";
-#if !ENABLE_FEATURE_AWK_MATH
 static const char EMSG_NO_MATH[] ALIGN1 = "Math support is not compiled in";
-#endif
-
-static void zero_out_var(var * vp)
+
+static void zero_out_var(var *vp)
 {
     memset(vp, 0, sizeof(*vp));
 }
 
-static void syntax_error(const char *const message) ATTRIBUTE_NORETURN;
-static void syntax_error(const char *const message)
+static void syntax_error(const char *message) NORETURN;
+static void syntax_error(const char *message)
 {
     bb_error_msg_and_die("%s:%i: %s", g_progname, g_lineno, message);
@@ -534 +544 @@
     unsigned idx = 0;
 
-    while (*name) idx = *name++ + (idx << 6) - idx;
+    while (*name)
+        idx = *name++ + (idx << 6) - idx;
     return idx;
 }
@@ -543 +554 @@
     xhash *newhash;
 
-    newhash = xzalloc(sizeof(xhash));
+    newhash = xzalloc(sizeof(*newhash));
     newhash->csize = FIRST_PRIME;
-    newhash->items = xzalloc(newhash->csize * sizeof(hash_item *));
+    newhash->items = xzalloc(FIRST_PRIME * sizeof(newhash->items[0]));
 
     return newhash;
@@ -555 +566 @@
     hash_item *hi;
 
-    hi = hash->items [ hashidx(name) % hash->csize ];
+    hi = hash->items[hashidx(name) % hash->csize];
     while (hi) {
         if (strcmp(hi->name, name) == 0)
-            return &(hi->data);
+            return &hi->data;
         hi = hi->next;
     }
@@ -574 +585 @@
 
     newsize = PRIMES[hash->nprime++];
-    newitems = xzalloc(newsize * sizeof(hash_item *));
+    newitems = xzalloc(newsize * sizeof(newitems[0]));
 
     for (i = 0; i < hash->csize; i++) {
@@ -605 +616 @@
 
         l = strlen(name) + 1;
-        hi = xzalloc(sizeof(hash_item) + l);
-        memcpy(hi->name, name, l);
+        hi = xzalloc(sizeof(*hi) + l);
+        strcpy(hi->name, name);
 
         idx = hashidx(name) % hash->csize;
@@ -613 +624 @@
         hash->glen += l;
     }
-    return &(hi->data);
+    return &hi->data;
 }
 
@@ -625 +636 @@
     hash_item *hi, **phi;
 
-    phi = &(hash->items[hashidx(name) % hash->csize]);
+    phi = &hash->items[hashidx(name) % hash->csize];
     while (*phi) {
         hi = *phi;
@@ -635 +646 @@
             break;
         }
-        phi = &(hi->next);
+        phi = &hi->next;
     }
 }
@@ -641 +652 @@
 /* ------ some useful functions ------ */
 
-static void skip_spaces(char **s)
-{
-    char *p = *s;
-
+static char *skip_spaces(char *p)
+{
     while (1) {
         if (*p == '\\' && p[1] == '\n') {
@@ -654 +663 @@
         p++;
     }
-    *s = p;
-}
-
+    return p;
+}
+
+/* returns old *s, advances *s past word and terminating NUL */
 static char *nextword(char **s)
 {
     char *p = *s;
-
-    while (*(*s)++) /* */;
-
+    while (*(*s)++ != '\0')
+        continue;
     return p;
 }
@@ -670 +679 @@
     char c, *pps;
 
-    c = *((*s)++);
+    c = *(*s)++;
     pps = *s;
-    if (c == '\\') c = bb_process_escape_sequence((const char**)s);
-    if (c == '\\' && *s == pps) c = *((*s)++);
+    if (c == '\\')
+        c = bb_process_escape_sequence((const char**)s);
+    if (c == '\\' && *s == pps) { /* unrecognized \z? */
+        c = *(*s); /* yes, fetch z */
+        if (c)
+            (*s)++; /* advance unless z = NUL */
+    }
     return c;
 }
 
-static int ALWAYS_INLINE isalnum_(int c)
+static ALWAYS_INLINE int isalnum_(int c)
 {
     return (isalnum(c) || c == '_');
 }
 
-static FILE *afopen(const char *path, const char *mode)
-{
-    return (*path == '-' && *(path+1) == '\0') ? stdin : xfopen(path, mode);
+static double my_strtod(char **pp)
+{
+    char *cp = *pp;
+    if (ENABLE_DESKTOP && cp[0] == '0') {
+        /* Might be hex or octal integer: 0x123abc or 07777 */
+        char c = (cp[1] | 0x20);
+        if (c == 'x' || isdigit(cp[1])) {
+            unsigned long long ull = strtoull(cp, pp, 0);
+            if (c == 'x')
+                return ull;
+            c = **pp;
+            if (!isdigit(c) && c != '.')
+                return ull;
+            /* else: it may be a floating number. Examples:
+             * 009.123 (*pp points to '9')
+             * 000.123 (*pp points to '.')
+             * fall through to strtod.
+             */
+        }
+    }
+    return strtod(cp, pp);
 }
 
@@ -748 +780 @@
 }
 
-/* same as setvar_s but set USER flag */
+/* same as setvar_s but sets USER flag */
 static var *setvar_u(var *v, const char *value)
 {
-    setvar_s(v, value);
+    v = setvar_s(v, value);
     v->type |= VF_USER;
     return v;
@@ -759 +791 @@
 static void setari_u(var *a, int idx, const char *s)
 {
-    char sidx[sizeof(int)*3 + 1];
     var *v;
 
-    sprintf(sidx, "%d", idx);
-    v = findvar(iamarray(a), sidx);
+    v = findvar(iamarray(a), itoa(idx));
     setvar_u(v, s);
 }
@@ -796 +826 @@
         s = v->string;
         if (s && *s) {
-            v->number = strtod(s, &s);
+            debug_printf_eval("getvar_i: '%s'->", s);
+            v->number = my_strtod(&s);
+            debug_printf_eval("%f (s:'%s')\n", v->number, s);
             if (v->type & VF_USER) {
-                skip_spaces(&s);
+                s = skip_spaces(s);
                 if (*s != '\0')
                     v->type &= ~VF_USER;
             }
         } else {
+            debug_printf_eval("getvar_i: '%s'->zero\n", s);
             v->type &= ~VF_USER;
         }
         v->type |= VF_CACHED;
     }
+    debug_printf_eval("getvar_i: %f\n", v->number);
     return v->number;
+}
+
+/* Used for operands of bitwise ops */
+static unsigned long getvar_i_int(var *v)
+{
+    double d = getvar_i(v);
+
+    /* Casting doubles to longs is undefined for values outside
+     * of target type range. Try to widen it as much as possible */
+    if (d >= 0)
+        return (unsigned long)d;
+    /* Why? Think about d == -4294967295.0 (assuming 32bit longs) */
+    return - (long) (unsigned long) (-d);
 }
 
@@ -815 +862 @@
         clrvar(dest);
         dest->type |= (src->type & ~(VF_DONTTOUCH | VF_FSTR));
+        debug_printf_eval("copyvar: number:%f string:'%s'\n", src->number, src->string);
         dest->number = src->number;
         if (src->string)
@@ -825 +873 @@
 static var *incvar(var *v)
 {
-    return setvar_i(v, getvar_i(v) + 1.);
+    return setvar_i(v, getvar_i(v) + 1.0);
 }
 
@@ -839 +887 @@
 {
     if (is_numeric(v))
-        return (v->number == 0) ? 0 : 1;
-    return (v->string && *(v->string)) ? 1 : 0;
+        return (v->number != 0);
+    return (v->string && v->string[0]);
 }
 
@@ -852 +900 @@
     while (g_cb) {
         pb = g_cb;
-        if ((g_cb->pos - g_cb->nv) + n <= g_cb->size) break;
+        if ((g_cb->pos - g_cb->nv) + n <= g_cb->size)
+            break;
         g_cb = g_cb->next;
     }
@@ -858 +907 @@
     if (!g_cb) {
         size = (n <= MINNVBLOCK) ? MINNVBLOCK : n;
-        g_cb = xmalloc(sizeof(nvblock) + size * sizeof(var));
+        g_cb = xzalloc(sizeof(nvblock) + size * sizeof(var));
         g_cb->size = size;
         g_cb->pos = g_cb->nv;
         g_cb->prev = pb;
-        g_cb->next = NULL;
-        if (pb) pb->next = g_cb;
+        /*g_cb->next = NULL; - xzalloc did it */
+        if (pb)
+            pb->next = g_cb;
     }
 
@@ -891 +941 @@
             free(p->x.array);
         }
-        if (p->type & VF_WALK)
-            free(p->x.walker);
-
+        if (p->type & VF_WALK) {
+            walker_list *n;
+            walker_list *w = p->x.walker;
+            debug_printf_walker("nvfree: freeing walker @%p\n", &p->x.walker);
+            p->x.walker = NULL;
+            while (w) {
+                n = w->prev;
+                debug_printf_walker(" free(%p)\n", w);
+                free(w);
+                w = n;
+            }
+        }
         clrvar(p);
     }
@@ -916 +975 @@
 #define ltclass         (G.next_token__ltclass)
 
-    char *p, *pp, *s;
+    char *p, *s;
     const char *tl;
     uint32_t tc;
     const uint32_t *ti;
-    int l;
 
     if (t_rollback) {
@@ -933 +991 @@
         p = g_pos;
  readnext:
-        skip_spaces(&p);
+        p = skip_spaces(p);
         g_lineno = t_lineno;
         if (*p == '#')
@@ -949 +1007 @@
             t_string = s = ++p;
             while (*p != '\"') {
+                char *pp;
                 if (*p == '\0' || *p == '\n')
                     syntax_error(EMSG_UNEXP_EOS);
-                *(s++) = nextchar(&p);
+                pp = p;
+                *s++ = nextchar(&pp);
+                p = pp;
             }
             p++;
@@ -965 +1026 @@
                 *s = *p++;
                 if (*s++ == '\\') {
-                    pp = p;
-                    *(s-1) = bb_process_escape_sequence((const char **)&p);
-                    if (*pp == '\\')
+                    char *pp = p;
+                    s[-1] = bb_process_escape_sequence((const char **)&pp);
+                    if (*p == '\\')
                         *s++ = '\\';
-                    if (p == pp)
+                    if (pp == p)
                         *s++ = *p++;
+                    else
+                        p = pp;
                 }
             }
@@ -979 +1042 @@
         } else if (*p == '.' || isdigit(*p)) {
             /* it's a number */
-            t_double = strtod(p, &p);
+            char *pp = p;
+            t_double = my_strtod(&pp);
+            p = pp;
             if (*p == '.')
                 syntax_error(EMSG_UNEXP_TOKEN);
@@ -990 +1055 @@
             ti = tokeninfo;
             while (*tl) {
-                l = *(tl++);
-                if (l == NTCC) {
+                int l = (unsigned char) *tl++;
+                if (l == (unsigned char) NTCC) {
                     tc <<= 1;
                     continue;
                 }
-                /* if token class is expected, token
-                 * matches and it's not a longer word,
-                 * then this is what we are looking for
+                /* if token class is expected,
+                 * token matches,
+                 * and it's not a longer word,
                  */
                 if ((tc & (expected | TC_WORD | TC_NEWLINE))
-                 && *tl == *p && strncmp(p, tl, l) == 0
+                 && strncmp(p, tl, l) == 0
                  && !((tc & TC_WORD) && isalnum_(p[l]))
                 ) {
+                    /* then this is what we are looking for */
                     t_info = *ti;
                     p += l;
-                    break;
+                    goto token_found;
                 }
                 ti++;
                 tl += l;
             }
-
-            if (!*tl) {
-                /* it's a name (var/array/function),
-                 * otherwise it's something wrong
-                 */
-                if (!isalnum_(*p))
-                    syntax_error(EMSG_UNEXP_TOKEN);
-
-                t_string = --p;
-                while (isalnum_(*(++p))) {
-                    *(p-1) = *p;
+            /* not a known token */
+
+            /* is it a name? (var/array/function) */
+            if (!isalnum_(*p))
+                syntax_error(EMSG_UNEXP_TOKEN); /* no */
+            /* yes */
+            t_string = --p;
+            while (isalnum_(*++p)) {
+                p[-1] = *p;
+            }
+            p[-1] = '\0';
+            tc = TC_VARIABLE;
+            /* also consume whitespace between functionname and bracket */
+            if (!(expected & TC_VARIABLE) || (expected & TC_ARRAY))
+                p = skip_spaces(p);
+            if (*p == '(') {
+                tc = TC_FUNCTION;
+            } else {
+                if (*p == '[') {
+                    p++;
+                    tc = TC_ARRAY;
                 }
-                *(p-1) = '\0';
-                tc = TC_VARIABLE;
-                /* also consume whitespace between functionname and bracket */
-                if (!(expected & TC_VARIABLE))
-                    skip_spaces(&p);
-                if (*p == '(') {
-                    tc = TC_FUNCTION;
-                } else {
-                    if (*p == '[') {
-                        p++;
-                        tc = TC_ARRAY;
-                    }
-                }
-            }
+            }
+ token_found: ;
         }
         g_pos = p;
@@ -1083 +1147 @@
 }
 
-static node *mk_re_node(const char *s, node *n, regex_t *re)
+static void mk_re_node(const char *s, node *n, regex_t *re)
 {
     n->info = OC_REGEXP;
@@ -1090 +1154 @@
     xregcomp(re, s, REG_EXTENDED);
     xregcomp(re + 1, s, REG_EXTENDED | REG_ICASE);
-
-    return n;
 }
 
@@ -1115 +1177 @@
 
     while (!((tc = next_token(xtc)) & iexp)) {
+
         if (glptr && (t_info == (OC_COMPARE | VV | P(39) | 2))) {
             /* input redirection (<) attached to glptr node */
@@ -1126 +1189 @@
              * previous operators with higher priority */
             vn = cn;
-            while ( ((t_info & PRIMASK) > (vn->a.n->info & PRIMASK2))
-             || ((t_info == vn->info) && ((t_info & OPCLSMASK) == OC_COLON)) )
+            while (((t_info & PRIMASK) > (vn->a.n->info & PRIMASK2))
+                || ((t_info == vn->info) && ((t_info & OPCLSMASK) == OC_COLON))
+            ) {
                 vn = vn->a.n;
+            }
             if ((t_info & OPCLSMASK) == OC_TERNARY)
                 t_info += P(6);
@@ -1167 +1232 @@
                     if (v != NULL) {
                         cn->info = OC_FNARG;
-                        cn->l.i = v->x.aidx;
+                        cn->l.aidx = v->x.aidx;
                     } else {
                         cn->l.v = newvar(t_string);
@@ -1228 +1293 @@
         seq->programname = g_progname;
         n = chain_node(OC_NEWSOURCE);
-        n->l.s = xstrdup(g_progname);
+        n->l.new_progname = xstrdup(g_progname);
     }
 
@@ -1283 +1348 @@
     if (c & TC_GRPSTART) {
         while (next_token(TC_GRPSEQ | TC_GRPTERM) != TC_GRPTERM) {
-            if (t_tclass & TC_NEWLINE) continue;
+            if (t_tclass & TC_NEWLINE)
+                continue;
             rollback_token();
             chain_group();
@@ -1405 +1471 @@
             while (next_token(TC_VARIABLE | TC_SEQTERM) & TC_VARIABLE) {
                 v = findvar(ahash, t_string);
-                v->x.aidx = (f->nargs)++;
+                v->x.aidx = f->nargs++;
 
                 if (next_token(TC_COMMA | TC_SEQTERM) & TC_SEQTERM)
                     break;
             }
-            seq = &(f->body);
+            seq = &f->body;
             chain_group();
             clear_array(ahash);
@@ -1448 +1514 @@
         regfree(ire); // TODO: nuke ire, use re+1?
     }
-    if (strlen(s) > 1) {
+    if (s[0] && s[1]) { /* strlen(s) > 1 */
         mk_re_node(s, n, re);
     } else {
-        n->info = (uint32_t) *s;
+        n->info = (uint32_t) s[0];
     }
 
@@ -1463 +1529 @@
 static regex_t *as_regex(node *op, regex_t *preg)
 {
+    int cflags;
     var *v;
     const char *s;
@@ -1471 +1538 @@
     v = nvalloc(1);
     s = getvar_s(evaluate(op, v));
-    xregcomp(preg, s, icase ? REG_EXTENDED | REG_ICASE : REG_EXTENDED);
+
+    cflags = icase ? REG_EXTENDED | REG_ICASE : REG_EXTENDED;
+    /* Testcase where REG_EXTENDED fails (unpaired '{'):
+     * echo Hi | awk 'gsub("@(samp|code|file)\{","");'
+     * gawk 3.1.5 eats this. We revert to ~REG_EXTENDED
+     * (maybe gsub is not supposed to use REG_EXTENDED?).
+     */
+    if (regcomp(preg, s, cflags)) {
+        cflags &= ~REG_EXTENDED;
+        xregcomp(preg, s, cflags);
+    }
     nvfree(v);
     return preg;
 }
 
-/* gradually increasing buffer */
-static void qrealloc(char **b, int n, int *size)
-{
-    if (!*b || n >= *size)
-        *b = xrealloc(*b, *size = n + (n>>1) + 80);
+/* gradually increasing buffer.
+ * note that we reallocate even if n == old_size,
+ * and thus there is at least one extra allocated byte.
+ */
+static char* qrealloc(char *b, int n, int *size)
+{
+    if (!b || n >= *size) {
+        *size = n + (n>>1) + 80;
+        b = xrealloc(b, *size);
+    }
+    return b;
 }
 
@@ -1491 +1574 @@
         i = maxfields;
         maxfields = size + 16;
-        Fields = xrealloc(Fields, maxfields * sizeof(var));
+        Fields = xrealloc(Fields, maxfields * sizeof(Fields[0]));
         for (; i < maxfields; i++) {
             Fields[i].type = VF_SPECIAL;
@@ -1497 +1580 @@
         }
     }
-
-    if (size < nfields) {
-        for (i = size; i < nfields; i++) {
-            clrvar(Fields + i);
-        }
+    /* if size < nfields, clear extra field variables */
+    for (i = size; i < nfields; i++) {
+        clrvar(Fields + i);
     }
     nfields = size;
@@ -1508 +1589 @@
 static int awk_split(const char *s, node *spl, char **slist)
 {
-    int l, n = 0;
+    int l, n;
     char c[4];
     char *s1;
@@ -1522 +1603 @@
         c[2] = '\n';
 
+    n = 0;
     if ((spl->info & OPCLSMASK) == OC_REGEXP) {  /* regex split */
         if (!*s)
@@ -1539 +1621 @@
             } else {
                 pmatch[0].rm_eo = l;
-                if (s[l]) pmatch[0].rm_eo++;
+                if (s[l])
+                    pmatch[0].rm_eo++;
             }
             memcpy(s1, s, l);
-            s1[l] = '\0';
+            /* make sure we remove *all* of the separator chars */
+            do {
+                s1[l] = '\0';
+            } while (++l < pmatch[0].rm_eo);
             nextword(&s1);
             s += pmatch[0].rm_eo;
@@ -1561 +1647 @@
             c[1] = tolower(c[1]);
         }
-        if (*s1) n++;
-        while ((s1 = strpbrk(s1, c))) {
+        if (*s1)
+            n++;
+        while ((s1 = strpbrk(s1, c)) != NULL) {
             *s1++ = '\0';
             n++;
@@ -1571 +1658 @@
     while (*s) {
         s = skip_whitespace(s);
-        if (!*s) break;
+        if (!*s)
+            break;
         n++;
         while (*s && !isspace(*s))
@@ -1636 +1724 @@
                 len += sl;
             }
-            qrealloc(&b, len+l+sl, &bsize);
+            b = qrealloc(b, len+l+sl, &bsize);
             memcpy(b+len, s, l);
             len += l;
@@ -1681 +1769 @@
 static void hashwalk_init(var *v, xhash *array)
 {
-    char **w;
     hash_item *hi;
-    int i;
-
-    if (v->type & VF_WALK)
-        free(v->x.walker);
-
-    v->type |= VF_WALK;
-    w = v->x.walker = xzalloc(2 + 2*sizeof(char *) + array->glen);
-    w[0] = w[1] = (char *)(w + 2);
+    unsigned i;
+    walker_list *w;
+    walker_list *prev_walker;
+
+    if (v->type & VF_WALK) {
+        prev_walker = v->x.walker;
+    } else {
+        v->type |= VF_WALK;
+        prev_walker = NULL;
+    }
+    debug_printf_walker("hashwalk_init: prev_walker:%p\n", prev_walker);
+
+    w = v->x.walker = xzalloc(sizeof(*w) + array->glen + 1); /* why + 1? */
+    debug_printf_walker(" walker@%p=%p\n", &v->x.walker, w);
+    w->cur = w->end = w->wbuf;
+    w->prev = prev_walker;
     for (i = 0; i < array->csize; i++) {
         hi = array->items[i];
         while (hi) {
-            strcpy(*w, hi->name);
-            nextword(w);
+            strcpy(w->end, hi->name);
+            nextword(&w->end);
             hi = hi->next;
         }
@@ -1703 +1798 @@
 static int hashwalk_next(var *v)
 {
-    char **w;
-
-    w = v->x.walker;
-    if (w[1] == w[0])
+    walker_list *w = v->x.walker;
+
+    if (w->cur >= w->end) {
+        walker_list *prev_walker = w->prev;
+
+        debug_printf_walker("end of iteration, free(walker@%p:%p), prev_walker:%p\n", &v->x.walker, w, prev_walker);
+        free(w);
+        v->x.walker = prev_walker;
         return FALSE;
-
-    setvar_s(v, nextword(w+1));
+    }
+
+    setvar_s(v, nextword(&w->cur));
     return TRUE;
 }
@@ -1725 +1825 @@
     char *b;
     regmatch_t pmatch[2];
-    int a, p, pp=0, size;
+    int size, a, p, pp = 0;
     int fd, so, eo, r, rp;
     char c, *m, *s;
+
+    debug_printf_eval("entered %s()\n", __func__);
 
     /* we're using our own buffer since we need access to accumulating
@@ -1740 +1842 @@
     rp = 0;
 
-    if (!m) qrealloc(&m, 256, &size);
+    if (!m)
+        m = qrealloc(m, 256, &size);
+
     do {
         b = m + a;
@@ -1756 +1860 @@
             } else if (c != '\0') {
                 s = strchr(b+pp, c);
-                if (!s) s = memchr(b+pp, '\0', p - pp);
+                if (!s)
+                    s = memchr(b+pp, '\0', p - pp);
                 if (s) {
                     so = eo = s-b;
@@ -1768 +1873 @@
                 if (s) {
                     so = eo = s-b;
-                    while (b[eo] == '\n') eo++;
+                    while (b[eo] == '\n')
+                        eo++;
                     if (b[eo] != '\0')
                         break;
@@ -1776 +1882 @@
 
         if (a > 0) {
-            memmove(m, (const void *)(m+a), p+1);
+            memmove(m, m+a, p+1);
             b = m;
             a = 0;
         }
 
-        qrealloc(&m, a+p+128, &size);
+        m = qrealloc(m, a+p+128, &size);
         b = m + a;
         pp = p;
@@ -1811 +1917 @@
     rsm->size = size;
 
+    debug_printf_eval("returning from %s(): %d\n", __func__, r);
+
     return r;
 }
@@ -1835 +1943 @@
 }
 
-
 /* formatted output into an allocated buffer, return ptr to buffer */
 static char *awk_printf(node *n)
@@ -1852 +1959 @@
     while (*f) {
         s = f;
-        while (*f && (*f != '%' || *(++f) == '%'))
+        while (*f && (*f != '%' || *++f == '%'))
             f++;
         while (*f && !isalpha(*f)) {
@@ -1861 +1968 @@
 
         incr = (f - s) + MAXVARFMT;
-        qrealloc(&b, incr + i, &bsize);
+        b = qrealloc(b, incr + i, &bsize);
         c = *f;
-        if (c != '\0') f++;
+        if (c != '\0')
+            f++;
         c1 = *f;
         *f = '\0';
@@ -1874 +1982 @@
         } else if (c == 's') {
             s1 = getvar_s(arg);
-            qrealloc(&b, incr+i+strlen(s1), &bsize);
+            b = qrealloc(b, incr+i+strlen(s1), &bsize);
             i += sprintf(b+i, s, s1);
         } else {
@@ -1882 +1990 @@
 
         /* if there was an error while sprintf, return value is negative */
-        if (i < j) i = j;
-    }
-
-    b = xrealloc(b, i + 1);
+        if (i < j)
+            i = j;
+    }
+
     free(fmt);
     nvfree(v);
+    b = xrealloc(b, i + 1);
     b[i] = '\0';
     return b;
 }
 
-/* common substitution routine
- * replace (nm) substring of (src) that match (n) with (repl), store
- * result into (dest), return number of substitutions. If nm=0, replace
- * all matches. If src or dst is NULL, use $0. If ex=TRUE, enable
- * subexpression matching (\1-\9)
+/* Common substitution routine.
+ * Replace (nm)'th substring of (src) that matches (rn) with (repl),
+ * store result into (dest), return number of substitutions.
+ * If nm = 0, replace all matches.
+ * If src or dst is NULL, use $0.
+ * If subexp != 0, enable subexpression matching (\1-\9).
  */
-static int awk_sub(node *rn, const char *repl, int nm, var *src, var *dest, int ex)
-{
-    char *ds = NULL;
-    const char *s;
+static int awk_sub(node *rn, const char *repl, int nm, var *src, var *dest, int subexp)
+{
+    char *resbuf;
     const char *sp;
-    int c, i, j, di, rl, so, eo, nbs, n, dssize;
+    int match_no, residx, replen, resbufsize;
+    int regexec_flags;
     regmatch_t pmatch[10];
-    regex_t sreg, *re;
-
-    re = as_regex(rn, &sreg);
-    if (!src) src = intvar[F0];
-    if (!dest) dest = intvar[F0];
-
-    i = di = 0;
-    sp = getvar_s(src);
-    rl = strlen(repl);
-    while (regexec(re, sp, 10, pmatch, sp==getvar_s(src) ? 0 : REG_NOTBOL) == 0) {
-        so = pmatch[0].rm_so;
-        eo = pmatch[0].rm_eo;
-
-        qrealloc(&ds, di + eo + rl, &dssize);
-        memcpy(ds + di, sp, eo);
-        di += eo;
-        if (++i >= nm) {
+    regex_t sreg, *regex;
+
+    resbuf = NULL;
+    residx = 0;
+    match_no = 0;
+    regexec_flags = 0;
+    regex = as_regex(rn, &sreg);
+    sp = getvar_s(src ? src : intvar[F0]);
+    replen = strlen(repl);
+    while (regexec(regex, sp, 10, pmatch, regexec_flags) == 0) {
+        int so = pmatch[0].rm_so;
+        int eo = pmatch[0].rm_eo;
+
+        //bb_error_msg("match %u: [%u,%u] '%s'%p", match_no+1, so, eo, sp,sp);
+        resbuf = qrealloc(resbuf, residx + eo + replen, &resbufsize);
+        memcpy(resbuf + residx, sp, eo);
+        residx += eo;
+        if (++match_no >= nm) {
+            const char *s;
+            int nbs;
+
             /* replace */
-            di -= (eo - so);
+            residx -= (eo - so);
             nbs = 0;
             for (s = repl; *s; s++) {
-                ds[di++] = c = *s;
+                char c = resbuf[residx++] = *s;
                 if (c == '\\') {
                     nbs++;
                     continue;
                 }
-                if (c == '&' || (ex && c >= '0' && c <= '9')) {
-                    di -= ((nbs + 3) >> 1);
+                if (c == '&' || (subexp && c >= '0' && c <= '9')) {
+                    int j;
+                    residx -= ((nbs + 3) >> 1);
                     j = 0;
                     if (c != '&') {
@@ -1939 +2054 @@
                     }
                     if (nbs % 2) {
-                        ds[di++] = c;
+                        resbuf[residx++] = c;
                     } else {
-                        n = pmatch[j].rm_eo - pmatch[j].rm_so;
-                        qrealloc(&ds, di + rl + n, &dssize);
-                        memcpy(ds + di, sp + pmatch[j].rm_so, n);
-                        di += n;
+                        int n = pmatch[j].rm_eo - pmatch[j].rm_so;
+                        resbuf = qrealloc(resbuf, residx + replen + n, &resbufsize);
+                        memcpy(resbuf + residx, sp + pmatch[j].rm_so, n);
+                        residx += n;
                     }
                 }
@@ -1951 +2066 @@
         }
 
+        regexec_flags = REG_NOTBOL;
         sp += eo;
-        if (i == nm) break;
+        if (match_no == nm)
+            break;
         if (eo == so) {
-            ds[di] = *sp++;
-            if (!ds[di++]) break;
-        }
-    }
-
-    qrealloc(&ds, di + strlen(sp), &dssize);
-    strcpy(ds + di, sp);
-    setvar_p(dest, ds);
-    if (re == &sreg) regfree(re);
-    return i;
-}
-
-static var *exec_builtin(node *op, var *res)
+            /* Empty match (e.g. "b*" will match anywhere).
+             * Advance by one char. */
+//BUG (bug 1333):
+//gsub(/\<b*/,"") on "abc" will reach this point, advance to "bc"
+//... and will erroneously match "b" even though it is NOT at the word start.
+//we need REG_NOTBOW but it does not exist...
+//TODO: if EXTRA_COMPAT=y, use GNU matching and re_search,
+//it should be able to do it correctly.
+            /* Subtle: this is safe only because
+             * qrealloc allocated at least one extra byte */
+            resbuf[residx] = *sp;
+            if (*sp == '\0')
+                goto ret;
+            sp++;
+            residx++;
+        }
+    }
+
+    resbuf = qrealloc(resbuf, residx + strlen(sp), &resbufsize);
+    strcpy(resbuf + residx, sp);
+ ret:
+    //bb_error_msg("end sp:'%s'%p", sp,sp);
+    setvar_p(dest ? dest : intvar[F0], resbuf);
+    if (regex == &sreg)
+        regfree(regex);
+    return match_no;
+}
+
+static NOINLINE int do_mktime(const char *ds)
+{
+    struct tm then;
+    int count;
+
+    /*memset(&then, 0, sizeof(then)); - not needed */
+    then.tm_isdst = -1; /* default is unknown */
+
+    /* manpage of mktime says these fields are ints,
+     * so we can sscanf stuff directly into them */
+    count = sscanf(ds, "%u %u %u %u %u %u %d",
+        &then.tm_year, &then.tm_mon, &then.tm_mday,
+        &then.tm_hour, &then.tm_min, &then.tm_sec,
+        &then.tm_isdst);
+
+    if (count < 6
+     || (unsigned)then.tm_mon < 1
+     || (unsigned)then.tm_year < 1900
+    ) {
+        return -1;
+    }
+
+    then.tm_mon -= 1;
+    then.tm_year -= 1900;
+
+    return mktime(&then);
+}
+
+static NOINLINE var *exec_builtin(node *op, var *res)
 {
 #define tspl (G.exec_builtin__tspl)
 
-    int (*to_xxx)(int);
     var *tv;
     node *an[4];
@@ -1981 +2141 @@
     int nargs;
     time_t tt;
-    char *s, *s1;
     int i, l, ll, n;
 
@@ -1991 +2150 @@
     for (i = 0; i < 4 && op; i++) {
         an[i] = nextarg(&op);
-        if (isr & 0x09000000) av[i] = evaluate(an[i], &tv[i]);
-        if (isr & 0x08000000) as[i] = getvar_s(av[i]);
+        if (isr & 0x09000000)
+            av[i] = evaluate(an[i], &tv[i]);
+        if (isr & 0x08000000)
+            as[i] = getvar_s(av[i]);
         isr >>= 1;
     }
 
     nargs = i;
-    if (nargs < (info >> 30))
+    if ((uint32_t)nargs < (info >> 30))
         syntax_error(EMSG_TOO_FEW_ARGS);
 
-    switch (info & OPNMASK) {
+    info &= OPNMASK;
+    switch (info) {
 
     case B_a2:
-#if ENABLE_FEATURE_AWK_MATH
-        setvar_i(res, atan2(getvar_i(av[i]), getvar_i(av[1])));
-#else
-        syntax_error(EMSG_NO_MATH);
-#endif
+        if (ENABLE_FEATURE_AWK_LIBM)
+            setvar_i(res, atan2(getvar_i(av[0]), getvar_i(av[1])));
+        else
+            syntax_error(EMSG_NO_MATH);
         break;
 
-    case B_sp:
+    case B_sp: {
+        char *s, *s1;
+
         if (nargs > 2) {
             spl = (an[2]->info & OPCLSMASK) == OC_REGEXP ?
@@ -2021 +2184 @@
         s1 = s;
         clear_array(iamarray(av[1]));
-        for (i=1; i<=n; i++)
-            setari_u(av[1], i, nextword(&s1));
-        free(s);
+        for (i = 1; i <= n; i++)
+            setari_u(av[1], i, nextword(&s));
+        free(s1);
         setvar_i(res, n);
         break;
-
-    case B_ss:
+    }
+
+    case B_ss: {
+        char *s;
+
         l = strlen(as[0]);
         i = getvar_i(av[1]) - 1;
-        if (i > l) i = l;
-        if (i < 0) i = 0;
+        if (i > l)
+            i = l;
+        if (i < 0)
+            i = 0;
         n = (nargs > 2) ? getvar_i(av[2]) : l-i;
-        if (n < 0) n = 0;
-        s = xmalloc(n+1);
-        strncpy(s, as[0]+i, n);
-        s[n] = '\0';
+        if (n < 0)
+            n = 0;
+        s = xstrndup(as[0]+i, n);
         setvar_p(res, s);
         break;
-
+    }
+
+    /* Bitwise ops must assume that operands are unsigned. GNU Awk 3.1.5:
+     * awk '{ print or(-1,1) }' gives "4.29497e+09", not "-2.xxxe+09" */
     case B_an:
-        setvar_i(res, (long)getvar_i(av[0]) & (long)getvar_i(av[1]));
+        setvar_i(res, getvar_i_int(av[0]) & getvar_i_int(av[1]));
         break;
 
     case B_co:
-        setvar_i(res, ~(long)getvar_i(av[0]));
+        setvar_i(res, ~getvar_i_int(av[0]));
         break;
 
     case B_ls:
-        setvar_i(res, (long)getvar_i(av[0]) << (long)getvar_i(av[1]));
+        setvar_i(res, getvar_i_int(av[0]) << getvar_i_int(av[1]));
         break;
 
     case B_or:
-        setvar_i(res, (long)getvar_i(av[0]) | (long)getvar_i(av[1]));
+        setvar_i(res, getvar_i_int(av[0]) | getvar_i_int(av[1]));
         break;
 
     case B_rs:
-        setvar_i(res, (long)((unsigned long)getvar_i(av[0]) >> (unsigned long)getvar_i(av[1])));
+        setvar_i(res, getvar_i_int(av[0]) >> getvar_i_int(av[1]));
         break;
 
     case B_xo:
-        setvar_i(res, (long)getvar_i(av[0]) ^ (long)getvar_i(av[1]));
+        setvar_i(res, getvar_i_int(av[0]) ^ getvar_i_int(av[1]));
         break;
 
     case B_lo:
-        to_xxx = tolower;
-        goto lo_cont;
-
-    case B_up:
-        to_xxx = toupper;
- lo_cont:
+    case B_up: {
+        char *s, *s1;
         s1 = s = xstrdup(as[0]);
         while (*s1) {
-            *s1 = (*to_xxx)(*s1);
+            //*s1 = (info == B_up) ? toupper(*s1) : tolower(*s1);
+            if ((unsigned char)((*s1 | 0x20) - 'a') <= ('z' - 'a'))
+                *s1 = (info == B_up) ? (*s1 & 0xdf) : (*s1 | 0x20);
             s1++;
         }
         setvar_p(res, s);
         break;
+    }
 
     case B_ix:
@@ -2085 +2254 @@
         if (ll > 0 && l >= 0) {
             if (!icase) {
-                s = strstr(as[0], as[1]);
-                if (s) n = (s - as[0]) + 1;
+                char *s = strstr(as[0], as[1]);
+                if (s)
+                    n = (s - as[0]) + 1;
             } else {
                 /* this piece of code is terribly slow and
                  * really should be rewritten
                  */
-                for (i=0; i<=l; i++) {
+                for (i = 0; i <= l; i++) {
                     if (strncasecmp(as[0]+i, as[1], ll) == 0) {
                         n = i+1;
@@ -2115 +2285 @@
         break;
 
+    case B_mt:
+        setvar_i(res, do_mktime(as[0]));
+        break;
+
     case B_ma:
         re = as_regex(an[1], &sreg);
@@ -2128 +2302 @@
         setvar_i(newvar("RLENGTH"), pmatch[0].rm_eo - pmatch[0].rm_so);
         setvar_i(res, pmatch[0].rm_so);
-        if (re == &sreg) regfree(re);
+        if (re == &sreg)
+            regfree(re);
         break;
 
@@ -2161 +2336 @@
 /* seed is initialized to 1 */
 #define seed   (G.evaluate__seed)
-#define sreg   (G.evaluate__sreg)
-
-    node *op1;
+#define sreg   (G.evaluate__sreg)
+
     var *v1;
-    union {
-        var *v;
-        const char *s;
-        double d;
-        int i;
-    } L, R;
-    uint32_t opinfo;
-    int opn;
-    union {
-        char *s;
-        rstream *rsm;
-        FILE *F;
-        var *v;
-        regex_t *re;
-        uint32_t info;
-    } X;
 
     if (!op)
         return setvar_s(res, NULL);
 
+    debug_printf_eval("entered %s()\n", __func__);
+
     v1 = nvalloc(2);
 
     while (op) {
+        struct {
+            var *v;
+            const char *s;
+        } L = L; /* for compiler */
+        struct {
+            var *v;
+            const char *s;
+        } R = R;
+        double L_d = L_d;
+        uint32_t opinfo;
+        int opn;
+        node *op1;
+
         opinfo = op->info;
         opn = (opinfo & OPNMASK);
         g_lineno = op->lineno;
+        op1 = op->l.n;
+        debug_printf_eval("opinfo:%08x opn:%08x\n", opinfo, opn);
 
         /* execute inevitable things */
-        op1 = op->l.n;
-        if (opinfo & OF_RES1) X.v = L.v = evaluate(op1, v1);
-        if (opinfo & OF_RES2) R.v = evaluate(op->r.n, v1+1);
-        if (opinfo & OF_STR1) L.s = getvar_s(L.v);
-        if (opinfo & OF_STR2) R.s = getvar_s(R.v);
-        if (opinfo & OF_NUM1) L.d = getvar_i(L.v);
-
+        if (opinfo & OF_RES1)
+            L.v = evaluate(op1, v1);
+        if (opinfo & OF_RES2)
+            R.v = evaluate(op->r.n, v1+1);
+        if (opinfo & OF_STR1) {
+            L.s = getvar_s(L.v);
+            debug_printf_eval("L.s:'%s'\n", L.s);
+        }
+        if (opinfo & OF_STR2) {
+            R.s = getvar_s(R.v);
+            debug_printf_eval("R.s:'%s'\n", R.s);
+        }
+        if (opinfo & OF_NUM1) {
+            L_d = getvar_i(L.v);
+            debug_printf_eval("L_d:%f\n", L_d);
+        }
+
+        debug_printf_eval("switch(0x%x)\n", XC(opinfo & OPCLSMASK));
         switch (XC(opinfo & OPCLSMASK)) {
 
@@ -2212 +2398 @@
                     if (ptest(op1->r.n))
                         op->info &= ~OF_CHECKED;
-
                     op = op->a.n;
                 } else {
@@ -2218 +2403 @@
                 }
             } else {
-                op = (ptest(op1)) ? op->a.n : op->r.n;
+                op = ptest(op1) ? op->a.n : op->r.n;
             }
             break;
@@ -2242 +2427 @@
 
         case XC( OC_PRINT ):
-        case XC( OC_PRINTF ):
-            X.F = stdout;
+        case XC( OC_PRINTF ): {
+            FILE *F = stdout;
+
             if (op->r.n) {
-                X.rsm = newfile(R.s);
-                if (!X.rsm->F) {
+                rstream *rsm = newfile(R.s);
+                if (!rsm->F) {
                     if (opn == '|') {
-                        X.rsm->F = popen(R.s, "w");
-                        if (X.rsm->F == NULL)
+                        rsm->F = popen(R.s, "w");
+                        if (rsm->F == NULL)
                             bb_perror_msg_and_die("popen");
-                        X.rsm->is_pipe = 1;
+                        rsm->is_pipe = 1;
                     } else {
-                        X.rsm->F = xfopen(R.s, opn=='w' ? "w" : "a");
+                        rsm->F = xfopen(R.s, opn=='w' ? "w" : "a");
                     }
                 }
-                X.F = X.rsm->F;
+                F = rsm->F;
             }
 
             if ((opinfo & OPCLSMASK) == OC_PRINT) {
                 if (!op1) {
-                    fputs(getvar_s(intvar[F0]), X.F);
+                    fputs(getvar_s(intvar[F0]), F);
                 } else {
                     while (op1) {
-                        L.v = evaluate(nextarg(&op1), v1);
-                        if (L.v->type & VF_NUMBER) {
+                        var *v = evaluate(nextarg(&op1), v1);
+                        if (v->type & VF_NUMBER) {
                             fmt_num(g_buf, MAXVARFMT, getvar_s(intvar[OFMT]),
-                                    getvar_i(L.v), TRUE);
-                            fputs(g_buf, X.F);
+                                    getvar_i(v), TRUE);
+                            fputs(g_buf, F);
                         } else {
-                            fputs(getvar_s(L.v), X.F);
+                            fputs(getvar_s(v), F);
                         }
 
-                        if (op1) fputs(getvar_s(intvar[OFS]), X.F);
+                        if (op1)
+                            fputs(getvar_s(intvar[OFS]), F);
                     }
                 }
-                fputs(getvar_s(intvar[ORS]), X.F);
+                fputs(getvar_s(intvar[ORS]), F);
 
             } else {    /* OC_PRINTF */
-                L.s = awk_printf(op1);
-                fputs(L.s, X.F);
-                free((char*)L.s);
-            }
-            fflush(X.F);
-            break;
-
-        case XC( OC_DELETE ):
-            X.info = op1->info & OPCLSMASK;
-            if (X.info == OC_VAR) {
-                R.v = op1->l.v;
-            } else if (X.info == OC_FNARG) {
-                R.v = &fnargs[op1->l.i];
+                char *s = awk_printf(op1);
+                fputs(s, F);
+                free(s);
+            }
+            fflush(F);
+            break;
+        }
+
+        case XC( OC_DELETE ): {
+            uint32_t info = op1->info & OPCLSMASK;
+            var *v;
+
+            if (info == OC_VAR) {
+                v = op1->l.v;
+            } else if (info == OC_FNARG) {
+                v = &fnargs[op1->l.aidx];
             } else {
                 syntax_error(EMSG_NOT_ARRAY);
@@ -2297 +2487 @@
 
             if (op1->r.n) {
+                const char *s;
                 clrvar(L.v);
-                L.s = getvar_s(evaluate(op1->r.n, v1));
-                hash_remove(iamarray(R.v), L.s);
+                s = getvar_s(evaluate(op1->r.n, v1));
+                hash_remove(iamarray(v), s);
             } else {
-                clear_array(iamarray(R.v));
-            }
-            break;
+                clear_array(iamarray(v));
+            }
+            break;
+        }
 
         case XC( OC_NEWSOURCE ):
-            g_progname = op->l.s;
+            g_progname = op->l.new_progname;
             break;
 
@@ -2322 +2514 @@
 
         case XC( OC_EXIT ):
-            awk_exit(L.d);
+            awk_exit(L_d);
 
         /* -- recursive node type -- */
@@ -2333 +2525 @@
 
         case XC( OC_FNARG ):
-            L.v = &fnargs[op->l.i];
+            L.v = &fnargs[op->l.aidx];
  v_cont:
             res = op->r.n ? findvar(iamarray(L.v), R.s) : L.v;
@@ -2350 +2542 @@
             op1 = op->r.n;
  re_cont:
-            X.re = as_regex(op1, &sreg);
-            R.i = regexec(X.re, L.s, 0, NULL, 0);
-            if (X.re == &sreg) regfree(X.re);
-            setvar_i(res, (R.i == 0 ? 1 : 0) ^ (opn == '!' ? 1 : 0));
+            {
+                regex_t *re = as_regex(op1, &sreg);
+                int i = regexec(re, L.s, 0, NULL, 0);
+                if (re == &sreg)
+                    regfree(re);
+                setvar_i(res, (i == 0) ^ (opn == '!'));
+            }
             break;
 
         case XC( OC_MOVE ):
+            debug_printf_eval("MOVE\n");
             /* if source is a temporary string, jusk relink it to dest */
-            if (R.v == v1+1 && R.v->string) {
-                res = setvar_p(L.v, R.v->string);
-                R.v->string = NULL;
-            } else {
+//Disabled: if R.v is numeric but happens to have cached R.v->string,
+//then L.v ends up being a string, which is wrong
+//          if (R.v == v1+1 && R.v->string) {
+//              res = setvar_p(L.v, R.v->string);
+//              R.v->string = NULL;
+//          } else {
                 res = copyvar(L.v, R.v);
-            }
+//          }
             break;
 
@@ -2372 +2570 @@
             break;
 
-        case XC( OC_FUNC ):
+        case XC( OC_FUNC ): {
+            var *vbeg, *v;
+            const char *sv_progname;
+
             if (!op->r.f->body.first)
                 syntax_error(EMSG_UNDEF_FUNC);
 
-            X.v = R.v = nvalloc(op->r.f->nargs+1);
+            vbeg = v = nvalloc(op->r.f->nargs + 1);
             while (op1) {
-                L.v = evaluate(nextarg(&op1), v1);
-                copyvar(R.v, L.v);
-                R.v->type |= VF_CHILD;
-                R.v->x.parent = L.v;
-                if (++R.v - X.v >= op->r.f->nargs)
+                var *arg = evaluate(nextarg(&op1), v1);
+                copyvar(v, arg);
+                v->type |= VF_CHILD;
+                v->x.parent = arg;
+                if (++v - vbeg >= op->r.f->nargs)
                     break;
             }
 
-            R.v = fnargs;
-            fnargs = X.v;
-
-            L.s = g_progname;
+            v = fnargs;
+            fnargs = vbeg;
+            sv_progname = g_progname;
+
             res = evaluate(op->r.f->body.first, res);
-            g_progname = L.s;
-
+
+            g_progname = sv_progname;
             nvfree(fnargs);
-            fnargs = R.v;
-            break;
+            fnargs = v;
+
+            break;
+        }
 
         case XC( OC_GETLINE ):
-        case XC( OC_PGETLINE ):
+        case XC( OC_PGETLINE ): {
+            rstream *rsm;
+            int i;
+
             if (op1) {
-                X.rsm = newfile(L.s);
-                if (!X.rsm->F) {
+                rsm = newfile(L.s);
+                if (!rsm->F) {
                     if ((opinfo & OPCLSMASK) == OC_PGETLINE) {
-                        X.rsm->F = popen(L.s, "r");
-                        X.rsm->is_pipe = TRUE;
+                        rsm->F = popen(L.s, "r");
+                        rsm->is_pipe = TRUE;
                     } else {
-                        X.rsm->F = fopen(L.s, "r");     /* not xfopen! */
+                        rsm->F = fopen_for_read(L.s);  /* not xfopen! */
                     }
                 }
             } else {
-                if (!iF) iF = next_input_file();
-                X.rsm = iF;
-            }
-
-            if (!X.rsm->F) {
+                if (!iF)
+                    iF = next_input_file();
+                rsm = iF;
+            }
+
+            if (!rsm->F) {
                 setvar_i(intvar[ERRNO], errno);
                 setvar_i(res, -1);
@@ -2423 +2630 @@
                 R.v = intvar[F0];
 
-            L.i = awk_getline(X.rsm, R.v);
-            if (L.i > 0) {
-                if (!op1) {
-                    incvar(intvar[FNR]);
-                    incvar(intvar[NR]);
+            i = awk_getline(rsm, R.v);
+            if (i > 0 && !op1) {
+                incvar(intvar[FNR]);
+                incvar(intvar[NR]);
+            }
+            setvar_i(res, i);
+            break;
+        }
+
+        /* simple builtins */
+        case XC( OC_FBLTIN ): {
+            double R_d = R_d; /* for compiler */
+
+            switch (opn) {
+            case F_in:
+                R_d = (int)L_d;
+                break;
+
+            case F_rn:
+                R_d = (double)rand() / (double)RAND_MAX;
+                break;
+
+            case F_co:
+                if (ENABLE_FEATURE_AWK_LIBM) {
+                    R_d = cos(L_d);
+                    break;
                 }
-            }
-            setvar_i(res, L.i);
-            break;
-
-        /* simple builtins */
-        case XC( OC_FBLTIN ):
-            switch (opn) {
-
-            case F_in:
-                R.d = (int)L.d;
-                break;
-
-            case F_rn:
-                R.d = (double)rand() / (double)RAND_MAX;
-                break;
-#if ENABLE_FEATURE_AWK_MATH
-            case F_co:
-                R.d = cos(L.d);
-                break;
 
             case F_ex:
-                R.d = exp(L.d);
-                break;
+                if (ENABLE_FEATURE_AWK_LIBM) {
+                    R_d = exp(L_d);
+                    break;
+                }
 
             case F_lg:
-                R.d = log(L.d);
-                break;
+                if (ENABLE_FEATURE_AWK_LIBM) {
+                    R_d = log(L_d);
+                    break;
+                }
 
             case F_si:
-                R.d = sin(L.d);
-                break;
+                if (ENABLE_FEATURE_AWK_LIBM) {
+                    R_d = sin(L_d);
+                    break;
+                }
 
             case F_sq:
-                R.d = sqrt(L.d);
-                break;
-#else
-            case F_co:
-            case F_ex:
-            case F_lg:
-            case F_si:
-            case F_sq:
+                if (ENABLE_FEATURE_AWK_LIBM) {
+                    R_d = sqrt(L_d);
+                    break;
+                }
+
                 syntax_error(EMSG_NO_MATH);
                 break;
-#endif
+
             case F_sr:
-                R.d = (double)seed;
-                seed = op1 ? (unsigned)L.d : (unsigned)time(NULL);
+                R_d = (double)seed;
+                seed = op1 ? (unsigned)L_d : (unsigned)time(NULL);
                 srand(seed);
                 break;
 
             case F_ti:
-                R.d = time(NULL);
+                R_d = time(NULL);
                 break;
 
@@ -2486 +2698 @@
                 if (!op1)
                     L.s = getvar_s(intvar[F0]);
-                R.d = strlen(L.s);
+                R_d = strlen(L.s);
                 break;
 
             case F_sy:
-                fflush(NULL);
-                R.d = (ENABLE_FEATURE_ALLOW_EXEC && L.s && *L.s)
+                fflush_all();
+                R_d = (ENABLE_FEATURE_ALLOW_EXEC && L.s && *L.s)
                         ? (system(L.s) >> 8) : 0;
                 break;
 
             case F_ff:
-                if (!op1)
+                if (!op1) {
                     fflush(stdout);
-                else {
-                    if (L.s && *L.s) {
-                        X.rsm = newfile(L.s);
-                        fflush(X.rsm->F);
-                    } else {
-                        fflush(NULL);
-                    }
+                } else if (L.s && *L.s) {
+                    rstream *rsm = newfile(L.s);
+                    fflush(rsm->F);
+                } else {
+                    fflush_all();
                 }
                 break;
 
-            case F_cl:
-                X.rsm = (rstream *)hash_search(fdhash, L.s);
-                if (X.rsm) {
-                    R.i = X.rsm->is_pipe ? pclose(X.rsm->F) : fclose(X.rsm->F);
-                    free(X.rsm->buffer);
+            case F_cl: {
+                rstream *rsm;
+                int err = 0;
+                rsm = (rstream *)hash_search(fdhash, L.s);
+                debug_printf_eval("OC_FBLTIN F_cl rsm:%p\n", rsm);
+                if (rsm) {
+                    debug_printf_eval("OC_FBLTIN F_cl "
+                        "rsm->is_pipe:%d, ->F:%p\n",
+                        rsm->is_pipe, rsm->F);
+                    /* Can be NULL if open failed. Example:
+                     * getline line <"doesnt_exist";
+                     * close("doesnt_exist"); <--- here rsm->F is NULL
+                     */
+                    if (rsm->F)
+                        err = rsm->is_pipe ? pclose(rsm->F) : fclose(rsm->F);
+                    free(rsm->buffer);
                     hash_remove(fdhash, L.s);
                 }
-                if (R.i != 0)
+                if (err)
                     setvar_i(intvar[ERRNO], errno);
-                R.d = (double)R.i;
+                R_d = (double)err;
                 break;
             }
-            setvar_i(res, R.d);
-            break;
+            } /* switch */
+            setvar_i(res, R_d);
+            break;
+        }
 
         case XC( OC_BUILTIN ):
@@ -2531 +2754 @@
             break;
 
-        case XC( OC_UNARY ):
-            X.v = R.v;
-            L.d = R.d = getvar_i(R.v);
+        case XC( OC_UNARY ): {
+            double Ld, R_d;
+
+            Ld = R_d = getvar_i(R.v);
             switch (opn) {
             case 'P':
-                L.d = ++R.d;
+                Ld = ++R_d;
                 goto r_op_change;
             case 'p':
-                R.d++;
+                R_d++;
                 goto r_op_change;
             case 'M':
-                L.d = --R.d;
+                Ld = --R_d;
                 goto r_op_change;
             case 'm':
-                R.d--;
-                goto r_op_change;
+                R_d--;
+ r_op_change:
+                setvar_i(R.v, R_d);
+                break;
             case '!':
-                L.d = istrue(X.v) ? 0 : 1;
+                Ld = !istrue(R.v);
                 break;
             case '-':
-                L.d = -R.d;
+                Ld = -R_d;
                 break;
- r_op_change:
-                setvar_i(X.v, R.d);
-            }
-            setvar_i(res, L.d);
-            break;
-
-        case XC( OC_FIELD ):
-            R.i = (int)getvar_i(R.v);
-            if (R.i == 0) {
+            }
+            setvar_i(res, Ld);
+            break;
+        }
+
+        case XC( OC_FIELD ): {
+            int i = (int)getvar_i(R.v);
+            if (i == 0) {
                 res = intvar[F0];
             } else {
                 split_f0();
-                if (R.i > nfields)
-                    fsrealloc(R.i);
-                res = &Fields[R.i - 1];
-            }
-            break;
+                if (i > nfields)
+                    fsrealloc(i);
+                res = &Fields[i - 1];
+            }
+            break;
+        }
 
         /* concatenation (" ") and index joining (",") */
         case XC( OC_CONCAT ):
-        case XC( OC_COMMA ):
-            opn = strlen(L.s) + strlen(R.s) + 2;
-            X.s = xmalloc(opn);
-            strcpy(X.s, L.s);
-            if ((opinfo & OPCLSMASK) == OC_COMMA) {
-                L.s = getvar_s(intvar[SUBSEP]);
-                X.s = xrealloc(X.s, opn + strlen(L.s));
-                strcat(X.s, L.s);
-            }
-            strcat(X.s, R.s);
-            setvar_p(res, X.s);
-            break;
+        case XC( OC_COMMA ): {
+            const char *sep = "";
+            if ((opinfo & OPCLSMASK) == OC_COMMA)
+                sep = getvar_s(intvar[SUBSEP]);
+            setvar_p(res, xasprintf("%s%s%s", L.s, sep, R.s));
+            break;
+        }
 
         case XC( OC_LAND ):
@@ -2595 +2816 @@
 
         case XC( OC_BINARY ):
-        case XC( OC_REPLACE ):
-            R.d = getvar_i(R.v);
+        case XC( OC_REPLACE ): {
+            double R_d = getvar_i(R.v);
+            debug_printf_eval("BINARY/REPLACE: R_d:%f opn:%c\n", R_d, opn);
             switch (opn) {
             case '+':
-                L.d += R.d;
+                L_d += R_d;
                 break;
             case '-':
-                L.d -= R.d;
+                L_d -= R_d;
                 break;
             case '*':
-                L.d *= R.d;
+                L_d *= R_d;
                 break;
             case '/':
-                if (R.d == 0) syntax_error(EMSG_DIV_BY_ZERO);
-                L.d /= R.d;
+                if (R_d == 0)
+                    syntax_error(EMSG_DIV_BY_ZERO);
+                L_d /= R_d;
                 break;
             case '&':
-#if ENABLE_FEATURE_AWK_MATH
-                L.d = pow(L.d, R.d);
-#else
-                syntax_error(EMSG_NO_MATH);
-#endif
+                if (ENABLE_FEATURE_AWK_LIBM)
+                    L_d = pow(L_d, R_d);
+                else
+                    syntax_error(EMSG_NO_MATH);
                 break;
             case '%':
-                if (R.d == 0) syntax_error(EMSG_DIV_BY_ZERO);
-                L.d -= (int)(L.d / R.d) * R.d;
+                if (R_d == 0)
+                    syntax_error(EMSG_DIV_BY_ZERO);
+                L_d -= (int)(L_d / R_d) * R_d;
                 break;
             }
-            res = setvar_i(((opinfo & OPCLSMASK) == OC_BINARY) ? res : X.v, L.d);
-            break;
-
-        case XC( OC_COMPARE ):
+            debug_printf_eval("BINARY/REPLACE result:%f\n", L_d);
+            res = setvar_i(((opinfo & OPCLSMASK) == OC_BINARY) ? res : L.v, L_d);
+            break;
+        }
+
+        case XC( OC_COMPARE ): {
+            int i = i; /* for compiler */
+            double Ld;
+
             if (is_numeric(L.v) && is_numeric(R.v)) {
-                L.d = getvar_i(L.v) - getvar_i(R.v);
+                Ld = getvar_i(L.v) - getvar_i(R.v);
             } else {
-                L.s = getvar_s(L.v);
-                R.s = getvar_s(R.v);
-                L.d = icase ? strcasecmp(L.s, R.s) : strcmp(L.s, R.s);
+                const char *l = getvar_s(L.v);
+                const char *r = getvar_s(R.v);
+                Ld = icase ? strcasecmp(l, r) : strcmp(l, r);
             }
             switch (opn & 0xfe) {
             case 0:
-                R.i = (L.d > 0);
+                i = (Ld > 0);
                 break;
             case 2:
-                R.i = (L.d >= 0);
+                i = (Ld >= 0);
                 break;
             case 4:
-                R.i = (L.d == 0);
+                i = (Ld == 0);
                 break;
             }
-            setvar_i(res, (opn & 0x1 ? R.i : !R.i) ? 1 : 0);
-            break;
+            setvar_i(res, (i == 0) ^ (opn & 1));
+            break;
+        }
 
         default:
@@ -2657 +2886 @@
         if (nextrec)
             break;
-    }
+    } /* while (op) */
+
     nvfree(v1);
+    debug_printf_eval("returning from %s(): %p\n", __func__, res);
     return res;
 #undef fnargs
@@ -2699 +2930 @@
 static int is_assignment(const char *expr)
 {
-    char *exprc, *s, *s0, *s1;
+    char *exprc, *val, *s, *s1;
+
+    if (!isalnum_(*expr) || (val = strchr(expr, '=')) == NULL) {
+        return FALSE;
+    }
 
     exprc = xstrdup(expr);
-    if (!isalnum_(*exprc) || (s = strchr(exprc, '=')) == NULL) {
-        free(exprc);
-        return FALSE;
-    }
-
-    *(s++) = '\0';
-    s0 = s1 = s;
-    while (*s)
-        *(s1++) = nextchar(&s);
-
-    *s1 = '\0';
-    setvar_u(newvar(exprc), s0);
+    val = exprc + (val - expr);
+    *val++ = '\0';
+
+    s = s1 = val;
+    while ((*s1 = nextchar(&s)) != '\0')
+        s1++;
+
+    setvar_u(newvar(exprc), val);
     free(exprc);
     return TRUE;
@@ -2727 +2958 @@
     const char *fname, *ind;
 
-    if (rsm.F) fclose(rsm.F);
+    if (rsm.F)
+        fclose(rsm.F);
     rsm.F = NULL;
     rsm.pos = rsm.adv = 0;
@@ -2741 +2973 @@
             fname = getvar_s(findvar(iamarray(intvar[ARGV]), ind));
             if (fname && *fname && !is_assignment(fname))
-                F = afopen(fname, "r");
+                F = xfopen_stdin(fname);
         }
     } while (!F);
@@ -2753 +2985 @@
 }
 
-int awk_main(int argc, char **argv);
+int awk_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int awk_main(int argc, char **argv)
 {
     unsigned opt;
     char *opt_F, *opt_W;
-    llist_t *opt_v = NULL;
-    int i, j, flen;
+    llist_t *list_v = NULL;
+    llist_t *list_f = NULL;
+    int i, j;
     var *v;
     var tv;
@@ -2817 +3050 @@
         }
     }
-    opt_complementary = "v::";
-    opt = getopt32(argv, "F:v:f:W:", &opt_F, &opt_v, &g_progname, &opt_W);
+    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);
     argv += optind;
     argc -= optind;
     if (opt & 0x1)
         setvar_s(intvar[FS], opt_F); // -F
-    while (opt_v) { /* -v */
-        if (!is_assignment(llist_pop(&opt_v)))
+    while (list_v) { /* -v */
+        if (!is_assignment(llist_pop(&list_v)))
             bb_show_usage();
     }
-    if (opt & 0x4) { // -f
-        char *s = s; /* die, gcc, die */
-        FILE *from_file = afopen(g_progname, "r");
-        /* one byte is reserved for some trick in next_token */
-        if (fseek(from_file, 0, SEEK_END) == 0) {
-            flen = ftell(from_file);
-            s = xmalloc(flen + 4);
-            fseek(from_file, 0, SEEK_SET);
-            i = 1 + fread(s + 1, 1, flen, from_file);
-        } else {
+    if (list_f) { /* -f */
+        do {
+            char *s = NULL;
+            FILE *from_file;
+
+            g_progname = llist_pop(&list_f);
+            from_file = xfopen_stdin(g_progname);
+            /* one byte is reserved for some trick in next_token */
             for (i = j = 1; j > 0; i += j) {
                 s = xrealloc(s, i + 4096);
                 j = fread(s + i, 1, 4094, from_file);
             }
-        }
-        s[i] = '\0';
-        fclose(from_file);
-        parse_program(s + 1);
-        free(s);
+            s[i] = '\0';
+            fclose(from_file);
+            parse_program(s + 1);
+            free(s);
+        } while (list_f);
+        argc++;
     } else { // no -f: take program from 1st parameter
         if (!argc)
@@ -2851 +3083 @@
         g_progname = "cmd. line";
         parse_program(*argv++);
-        argc--;
     }
     if (opt & 0x8) // -W
@@ -2857 +3088 @@
 
     /* fill in ARGV array */
-    setvar_i(intvar[ARGC], argc + 1);
+    setvar_i(intvar[ARGC], argc);
     setari_u(intvar[ARGV], 0, "awk");
     i = 0;
@@ -2868 +3099 @@
 
     /* input file could already be opened in BEGIN block */
-    if (!iF) iF = next_input_file();
+    if (!iF)
+        iF = next_input_file();
 
     /* passing through input files */

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

@@ -5 +5 @@
  * Copyright (C) 2000,2001 by Matt Kraai <kraai@alumni.carnegiemellon.edu>
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -11 +11 @@
 /* http://www.opengroup.org/onlinepubs/007904975/utilities/cmp.html */
 
-/* Mar 16, 2003      Manuel Novoa III   (mjn3@codepoet.org)
- *
- * Original version majorly reworked for SUSv3 compliance, bug fixes, and
- * size optimizations.  Changes include:
- * 1) Now correctly distinguishes between errors and actual file differences.
- * 2) Proper handling of '-' args.
- * 3) Actual error checking of i/o.
- * 4) Accept SUSv3 -l option.  Note that we use the slightly nicer gnu format
- *    in the '-l' case.
- */
-
 #include "libbb.h"
 
-static FILE *cmp_xfopen_input(const char *filename)
-{
-    FILE *fp;
-
-    fp = fopen_or_warn_stdin(filename);
-    if (fp)
-        return fp;
-    xfunc_die();    /* We already output an error message. */
-}
-
 static const char fmt_eof[] ALIGN1 = "cmp: EOF on %s\n";
-static const char fmt_differ[] ALIGN1 = "%s %s differ: char %"OFF_FMT"d, line %d\n";
-// This fmt_l_opt uses gnu-isms.  SUSv3 would be "%.0s%.0s%"OFF_FMT"d %o %o\n"
-static const char fmt_l_opt[] ALIGN1 = "%.0s%.0s%"OFF_FMT"d %3o %3o\n";
+static const char fmt_differ[] ALIGN1 = "%s %s differ: char %"OFF_FMT"u, line %u\n";
+// This fmt_l_opt uses gnu-isms.  SUSv3 would be "%.0s%.0s%"OFF_FMT"u %o %o\n"
+static const char fmt_l_opt[] ALIGN1 = "%.0s%.0s%"OFF_FMT"u %3o %3o\n";
 
 static const char opt_chars[] ALIGN1 = "sl";
@@ -43 +22 @@
 #define CMP_OPT_l (1<<1)
 
-int cmp_main(int argc, char **argv);
-int cmp_main(int argc, char **argv)
+int cmp_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int cmp_main(int argc UNUSED_PARAM, char **argv)
 {
     FILE *fp1, *fp2, *outfile = stdout;
     const char *filename1, *filename2 = "-";
-    USE_DESKTOP(off_t skip1 = 0, skip2 = 0;)
-    off_t char_pos = 0;
+    off_t skip1 = 0, skip2 = 0, char_pos = 0;
     int line_pos = 1; /* Hopefully won't overflow... */
     const char *fmt;
@@ -56 +34 @@
     int retval = 0;
 
-    xfunc_error_retval = 2; /* 1 is returned if files are different. */
-
     opt_complementary = "-1"
-            USE_DESKTOP(":?4")
-            SKIP_DESKTOP(":?2")
+            IF_DESKTOP(":?4")
+            IF_NOT_DESKTOP(":?2")
             ":l--s:s--l";
     opt = getopt32(argv, opt_chars);
@@ -66 +42 @@
 
     filename1 = *argv;
-    fp1 = cmp_xfopen_input(filename1);
-
     if (*++argv) {
         filename2 = *argv;
-#if ENABLE_DESKTOP
-        if (*++argv) {
+        if (ENABLE_DESKTOP && *++argv) {
             skip1 = XATOOFF(*argv);
             if (*++argv) {
@@ -77 +50 @@
             }
         }
-#endif
     }
 
-    fp2 = cmp_xfopen_input(filename2);
+    xfunc_error_retval = 2;  /* missing file results in exitcode 2 */
+    if (opt & CMP_OPT_s)
+        logmode = 0;  /* -s suppresses open error messages */
+    fp1 = xfopen_stdin(filename1);
+    fp2 = xfopen_stdin(filename2);
     if (fp1 == fp2) {       /* Paranoia check... stdin == stdin? */
         /* Note that we don't bother reading stdin.  Neither does gnu wc.
@@ -88 +64 @@
         return 0;
     }
+    logmode = LOGMODE_STDIO;
 
     if (opt & CMP_OPT_l)
@@ -94 +71 @@
         fmt = fmt_differ;
 
-#if ENABLE_DESKTOP
-    while (skip1) { getc(fp1); skip1--; }
-    while (skip2) { getc(fp2); skip2--; }
-#endif
+    if (ENABLE_DESKTOP) {
+        while (skip1) { getc(fp1); skip1--; }
+        while (skip2) { getc(fp2); skip2--; }
+    }
     do {
         c1 = getc(fp1);
@@ -119 +96 @@
                 /* There may have been output to stdout (option -l), so
                  * make sure we fflush before writing to stderr. */
-                xfflush_stdout();
+                fflush_all();
             }
             if (!(opt & CMP_OPT_s)) {

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

@@ -3 +3 @@
  * Mini diff implementation for busybox, adapted from OpenBSD diff.
  *
+ * Copyright (C) 2010 by Matheus Izvekov <mizvekov@gmail.com>
  * Copyright (C) 2006 by Robert Sullivan <cogito.ergo.cogito@hotmail.com>
  * Copyright (c) 2003 Todd C. Miller <Todd.Miller@courtesan.com>
@@ -10 +11 @@
  * Materiel Command, USAF, under agreement number F39502-99-1-0512.
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
-
-#include "libbb.h"
-
-#define FSIZE_MAX 32768
-
-/*
- * Output flags
- */
-#define D_HEADER        1   /* Print a header/footer between files */
-#define D_EMPTY1        2   /* Treat first file as empty (/dev/null) */
-#define D_EMPTY2        4   /* Treat second file as empty (/dev/null) */
-
-/*
- * Status values for print_status() and diffreg() return values
- * Guide:
- * D_SAME - files are the same
- * D_DIFFER - files differ
- * D_BINARY - binary files differ
- * D_COMMON - subdirectory common to both dirs
- * D_ONLY - file only exists in one dir
- * D_MISMATCH1 - path1 a dir, path2 a file
- * D_MISMATCH2 - path1 a file, path2 a dir
- * D_ERROR - error occurred
- * D_SKIPPED1 - skipped path1 as it is a special file
- * D_SKIPPED2 - skipped path2 as it is a special file
- */
-
-#define D_SAME      0
-#define D_DIFFER    (1<<0)
-#define D_BINARY    (1<<1)
-#define D_COMMON    (1<<2)
-#define D_ONLY      (1<<3)
-#define D_MISMATCH1 (1<<4)
-#define D_MISMATCH2 (1<<5)
-#define D_ERROR     (1<<6)
-#define D_SKIPPED1  (1<<7)
-#define D_SKIPPED2  (1<<8)
-
-/* Command line options */
-#define FLAG_a  (1<<0)
-#define FLAG_b  (1<<1)
-#define FLAG_d  (1<<2)
-#define FLAG_i  (1<<3)
-#define FLAG_L  (1<<4)
-#define FLAG_N  (1<<5)
-#define FLAG_q  (1<<6)
-#define FLAG_r  (1<<7)
-#define FLAG_s  (1<<8)
-#define FLAG_S  (1<<9)
-#define FLAG_t  (1<<10)
-#define FLAG_T  (1<<11)
-#define FLAG_U  (1<<12)
-#define FLAG_w  (1<<13)
-
-#define g_read_buf bb_common_bufsiz1
-
-struct cand {
-    int x;
-    int y;
-    int pred;
-};
-
-struct line {
-    int serial;
-    int value;
-};
-
-/*
- * The following struct is used to record change information
- * doing a "context" or "unified" diff.  (see routine "change" to
- * understand the highly mnemonic field names)
- */
-struct context_vec {
-    int a;          /* start line in old file */
-    int b;          /* end line in old file */
-    int c;          /* start line in new file */
-    int d;          /* end line in new file */
-};
-
-struct globals {
-    USE_FEATURE_DIFF_DIR(char **dl;)
-    USE_FEATURE_DIFF_DIR(int dl_count;)
-    /* This is the default number of lines of context. */
-    int context;
-    size_t max_context;
-    int status;
-    char *start;
-    const char *label1;
-    const char *label2;
-    struct line *file[2];
-    int *J;          /* will be overlaid on class */
-    int *class;      /* will be overlaid on file[0] */
-    int *klist;      /* will be overlaid on file[0] after class */
-    int *member;     /* will be overlaid on file[1] */
-    int clen;
-    int len[2];
-    int pref, suff;  /* length of prefix and suffix */
-    int slen[2];
-    bool anychange;
-    long *ixnew;     /* will be overlaid on file[1] */
-    long *ixold;     /* will be overlaid on klist */
-    struct cand *clist;  /* merely a free storage pot for candidates */
-    int clistlen;    /* the length of clist */
-    struct line *sfile[2];   /* shortened by pruning common prefix/suffix */
-    struct context_vec *context_vec_start;
-    struct context_vec *context_vec_end;
-    struct context_vec *context_vec_ptr;
-    struct stat stb1, stb2;
-};
-#define G (*ptr_to_globals)
-#define dl                 (G.dl                )
-#define dl_count           (G.dl_count          )
-#define context            (G.context           )
-#define max_context        (G.max_context       )
-#define status             (G.status            )
-#define start              (G.start             )
-#define label1             (G.label1            )
-#define label2             (G.label2            )
-#define file               (G.file              )
-#define J                  (G.J                 )
-#define class              (G.class             )
-#define klist              (G.klist             )
-#define member             (G.member            )
-#define clen               (G.clen              )
-#define len                (G.len               )
-#define pref               (G.pref              )
-#define suff               (G.suff              )
-#define slen               (G.slen              )
-#define anychange          (G.anychange         )
-#define ixnew              (G.ixnew             )
-#define ixold              (G.ixold             )
-#define clist              (G.clist             )
-#define clistlen           (G.clistlen          )
-#define sfile              (G.sfile             )
-#define context_vec_start  (G.context_vec_start )
-#define context_vec_end    (G.context_vec_end   )
-#define context_vec_ptr    (G.context_vec_ptr   )
-#define stb1               (G.stb1              )
-#define stb2               (G.stb2              )
-#define INIT_G() do { \
-    PTR_TO_GLOBALS = xzalloc(sizeof(G)); \
-    context = 3; \
-    max_context = 64; \
-} while (0)
-
-
-static void print_only(const char *path, size_t dirlen, const char *entry)
-{
-    if (dirlen > 1)
-        dirlen--;
-    printf("Only in %.*s: %s\n", (int) dirlen, path, entry);
-}
-
-static void print_status(int val, char *path1, char *path2, char *entry)
-{
-    const char *const _entry = entry ? entry : "";
-    char * const _path1 = entry ? concat_path_file(path1, _entry) : path1;
-    char * const _path2 = entry ? concat_path_file(path2, _entry) : path2;
-
-    switch (val) {
-    case D_ONLY:
-        print_only(path1, strlen(path1), entry);
-        break;
-    case D_COMMON:
-        printf("Common subdirectories: %s and %s\n", _path1, _path2);
-        break;
-    case D_BINARY:
-        printf("Binary files %s and %s differ\n", _path1, _path2);
-        break;
-    case D_DIFFER:
-        if (option_mask32 & FLAG_q)
-            printf("Files %s and %s differ\n", _path1, _path2);
-        break;
-    case D_SAME:
-        if (option_mask32 & FLAG_s)
-            printf("Files %s and %s are identical\n", _path1, _path2);
-        break;
-    case D_MISMATCH1:
-        printf("File %s is a %s while file %s is a %s\n",
-               _path1, "directory", _path2, "regular file");
-        break;
-    case D_MISMATCH2:
-        printf("File %s is a %s while file %s is a %s\n",
-               _path1, "regular file", _path2, "directory");
-        break;
-    case D_SKIPPED1:
-        printf("File %s is not a regular file or directory and was skipped\n",
-               _path1);
-        break;
-    case D_SKIPPED2:
-        printf("File %s is not a regular file or directory and was skipped\n",
-               _path2);
-        break;
-    }
-    if (entry) {
-        free(_path1);
-        free(_path2);
-    }
-}
-static ALWAYS_INLINE int fiddle_sum(int sum, int t)
-{
-    return sum * 127 + t;
-}
-/*
- * Hash function taken from Robert Sedgewick, Algorithms in C, 3d ed., p 578.
- */
-static int readhash(FILE *fp)
-{
-    int i, t, space;
-    int sum;
-
-    sum = 1;
-    space = 0;
-    if (!(option_mask32 & (FLAG_b | FLAG_w))) {
-        for (i = 0; (t = getc(fp)) != '\n'; i++) {
-            if (t == EOF) {
-                if (i == 0)
-                    return 0;
-                break;
-            }
-            sum = fiddle_sum(sum, t);
-        }
-    } else {
-        for (i = 0;;) {
-            switch (t = getc(fp)) {
-            case '\t':
-            case '\r':
-            case '\v':
-            case '\f':
-            case ' ':
-                space++;
-                continue;
-            default:
-                if (space && !(option_mask32 & FLAG_w)) {
-                    i++;
-                    space = 0;
-                }
-                sum = fiddle_sum(sum, t);
-                i++;
-                continue;
-            case EOF:
-                if (i == 0)
-                    return 0;
-                /* FALLTHROUGH */
-            case '\n':
-                break;
-            }
-            break;
-        }
-    }
-    /*
-     * There is a remote possibility that we end up with a zero sum.
-     * Zero is used as an EOF marker, so return 1 instead.
-     */
-    return (sum == 0 ? 1 : sum);
-}
-
-
-/*
- * Check to see if the given files differ.
- * Returns 0 if they are the same, 1 if different, and -1 on error.
- */
-static int files_differ(FILE *f1, FILE *f2, int flags)
-{
-    size_t i, j;
-
-    if ((flags & (D_EMPTY1 | D_EMPTY2)) || stb1.st_size != stb2.st_size
-     || (stb1.st_mode & S_IFMT) != (stb2.st_mode & S_IFMT)
-    ) {
-        return 1;
-    }
-    while (1) {
-        i = fread(g_read_buf,                    1, COMMON_BUFSIZE/2, f1);
-        j = fread(g_read_buf + COMMON_BUFSIZE/2, 1, COMMON_BUFSIZE/2, f2);
-        if (i != j)
-            return 1;
-        if (i == 0)
-            return (ferror(f1) || ferror(f2));
-        if (memcmp(g_read_buf,
-                   g_read_buf + COMMON_BUFSIZE/2, i) != 0)
-            return 1;
-    }
-}
-
-
-static void prepare(int i, FILE *fp /*, off_t filesize*/)
-{
-    struct line *p;
-    int h;
-    size_t j, sz;
-
-    rewind(fp);
-
-    /*sz = (filesize <= FSIZE_MAX ? filesize : FSIZE_MAX) / 25;*/
-    /*if (sz < 100)*/
-    sz = 100;
-
-    p = xmalloc((sz + 3) * sizeof(p[0]));
-    j = 0;
-    while ((h = readhash(fp))) {
-        if (j == sz) {
-            sz = sz * 3 / 2;
-            p = xrealloc(p, (sz + 3) * sizeof(p[0]));
-        }
-        p[++j].value = h;
-    }
-    len[i] = j;
-    file[i] = p;
-}
-
-
-static void prune(void)
-{
-    int i, j;
-
-    for (pref = 0; pref < len[0] && pref < len[1] &&
-         file[0][pref + 1].value == file[1][pref + 1].value; pref++)
-        continue;
-    for (suff = 0; suff < len[0] - pref && suff < len[1] - pref &&
-         file[0][len[0] - suff].value == file[1][len[1] - suff].value;
-         suff++)
-        continue;
-    for (j = 0; j < 2; j++) {
-        sfile[j] = file[j] + pref;
-        slen[j] = len[j] - pref - suff;
-        for (i = 0; i <= slen[j]; i++)
-            sfile[j][i].serial = i;
-    }
-}
-
-
-static void equiv(struct line *a, int n, struct line *b, int m, int *c)
-{
-    int i, j;
-
-    i = j = 1;
-    while (i <= n && j <= m) {
-        if (a[i].value < b[j].value)
-            a[i++].value = 0;
-        else if (a[i].value == b[j].value)
-            a[i++].value = j;
-        else
-            j++;
-    }
-    while (i <= n)
-        a[i++].value = 0;
-    b[m + 1].value = 0;
-    j = 0;
-    while (++j <= m) {
-        c[j] = -b[j].serial;
-        while (b[j + 1].value == b[j].value) {
-            j++;
-            c[j] = b[j].serial;
-        }
-    }
-    c[j] = -1;
-}
-
-
-static int isqrt(int n)
-{
-    int y, x;
-
-    if (n == 0)
-        return 0;
-    x = 1;
-    do {
-        y = x;
-        x = n / x;
-        x += y;
-        x /= 2;
-    } while ((x - y) > 1 || (x - y) < -1);
-
-    return x;
-}
-
-
-static int newcand(int x, int y, int pred)
-{
-    struct cand *q;
-
-    if (clen == clistlen) {
-        clistlen = clistlen * 11 / 10;
-        clist = xrealloc(clist, clistlen * sizeof(struct cand));
-    }
-    q = clist + clen;
-    q->x = x;
-    q->y = y;
-    q->pred = pred;
-    return clen++;
-}
-
-
-static int search(int *c, int k, int y)
-{
-    int i, j, l, t;
-
-    if (clist[c[k]].y < y)  /* quick look for typical case */
-        return k + 1;
-    i = 0;
-    j = k + 1;
-    while (1) {
-        l = i + j;
-        if ((l >>= 1) <= i)
-            break;
-        t = clist[c[l]].y;
-        if (t > y)
-            j = l;
-        else if (t < y)
-            i = l;
-        else
-            return l;
-    }
-    return l + 1;
-}
-
-
-static int stone(int *a, int n, int *b, int *c)
-{
-    int i, k, y, j, l;
-    int oldc, tc, oldl;
-    unsigned int numtries;
-
-#if ENABLE_FEATURE_DIFF_MINIMAL
-    const unsigned int bound =
-        (option_mask32 & FLAG_d) ? UINT_MAX : MAX(256, isqrt(n));
-#else
-    const unsigned int bound = MAX(256, isqrt(n));
-#endif
-    k = 0;
-    c[0] = newcand(0, 0, 0);
-    for (i = 1; i <= n; i++) {
-        j = a[i];
-        if (j == 0)
-            continue;
-        y = -b[j];
-        oldl = 0;
-        oldc = c[0];
-        numtries = 0;
-        do {
-            if (y <= clist[oldc].y)
-                continue;
-            l = search(c, k, y);
-            if (l != oldl + 1)
-                oldc = c[l - 1];
-            if (l <= k) {
-                if (clist[c[l]].y <= y)
-                    continue;
-                tc = c[l];
-                c[l] = newcand(i, y, oldc);
-                oldc = tc;
-                oldl = l;
-                numtries++;
-            } else {
-                c[l] = newcand(i, y, oldc);
-                k++;
-                break;
-            }
-        } while ((y = b[++j]) > 0 && numtries < bound);
-    }
-    return k;
-}
-
-
-static void unravel(int p)
-{
-    struct cand *q;
-    int i;
-
-    for (i = 0; i <= len[0]; i++)
-        J[i] = i <= pref ? i : i > len[0] - suff ? i + len[1] - len[0] : 0;
-    for (q = clist + p; q->y != 0; q = clist + q->pred)
-        J[q->x + pref] = q->y + pref;
-}
-
-
-static void unsort(struct line *f, int l, int *b)
-{
-    int *a, i;
-
-    a = xmalloc((l + 1) * sizeof(int));
-    for (i = 1; i <= l; i++)
-        a[f[i].serial] = f[i].value;
-    for (i = 1; i <= l; i++)
-        b[i] = a[i];
-    free(a);
-}
-
-
-static int skipline(FILE * f)
-{
-    int i, c;
-
-    for (i = 1; (c = getc(f)) != '\n' && c != EOF; i++)
-        continue;
-    return i;
-}
-
-
-/*
- * Check does double duty:
- *  1.  ferret out any fortuitous correspondences due
- *      to confounding by hashing (which result in "jackpot")
- *  2.  collect random access indexes to the two files
- */
-static void check(FILE * f1, FILE * f2)
-{
-    int i, j, jackpot, c, d;
-    long ctold, ctnew;
-
-    rewind(f1);
-    rewind(f2);
-    j = 1;
-    ixold[0] = ixnew[0] = 0;
-    jackpot = 0;
-    ctold = ctnew = 0;
-    for (i = 1; i <= len[0]; i++) {
-        if (J[i] == 0) {
-            ixold[i] = ctold += skipline(f1);
-            continue;
-        }
-        while (j < J[i]) {
-            ixnew[j] = ctnew += skipline(f2);
-            j++;
-        }
-        if ((option_mask32 & FLAG_b) || (option_mask32 & FLAG_w)
-            || (option_mask32 & FLAG_i)) {
-            while (1) {
-                c = getc(f1);
-                d = getc(f2);
-                /*
-                 * GNU diff ignores a missing newline
-                 * in one file if bflag || wflag.
-                 */
-                if (((option_mask32 & FLAG_b) || (option_mask32 & FLAG_w)) &&
-                    ((c == EOF && d == '\n') || (c == '\n' && d == EOF))) {
-                    break;
-                }
-                ctold++;
-                ctnew++;
-                if ((option_mask32 & FLAG_b) && isspace(c) && isspace(d)) {
-                    do {
-                        if (c == '\n')
-                            break;
-                        ctold++;
-                    } while (isspace(c = getc(f1)));
-                    do {
-                        if (d == '\n')
-                            break;
-                        ctnew++;
-                    } while (isspace(d = getc(f2)));
-                } else if (option_mask32 & FLAG_w) {
-                    while (isspace(c) && c != '\n') {
-                        c = getc(f1);
-                        ctold++;
-                    }
-                    while (isspace(d) && d != '\n') {
-                        d = getc(f2);
-                        ctnew++;
-                    }
-                }
-                if (c != d) {
-                    jackpot++;
-                    J[i] = 0;
-                    if (c != '\n' && c != EOF)
-                        ctold += skipline(f1);
-                    if (d != '\n' && c != EOF)
-                        ctnew += skipline(f2);
-                    break;
-                }
-                if (c == '\n' || c == EOF)
-                    break;
-            }
-        } else {
-            while (1) {
-                ctold++;
-                ctnew++;
-                if ((c = getc(f1)) != (d = getc(f2))) {
-                    J[i] = 0;
-                    if (c != '\n' && c != EOF)
-                        ctold += skipline(f1);
-                    if (d != '\n' && c != EOF)
-                        ctnew += skipline(f2);
-                    break;
-                }
-                if (c == '\n' || c == EOF)
-                    break;
-            }
-        }
-        ixold[i] = ctold;
-        ixnew[j] = ctnew;
-        j++;
-    }
-    for (; j <= len[1]; j++)
-        ixnew[j] = ctnew += skipline(f2);
-}
-
-
-/* shellsort CACM #201 */
-static void sort(struct line *a, int n)
-{
-    struct line *ai, *aim, w;
-    int j, m = 0, k;
-
-    if (n == 0)
-        return;
-    for (j = 1; j <= n; j *= 2)
-        m = 2 * j - 1;
-    for (m /= 2; m != 0; m /= 2) {
-        k = n - m;
-        for (j = 1; j <= k; j++) {
-            for (ai = &a[j]; ai > a; ai -= m) {
-                aim = &ai[m];
-                if (aim < ai)
-                    break;  /* wraparound */
-                if (aim->value > ai[0].value ||
-                    (aim->value == ai[0].value && aim->serial > ai[0].serial))
-                    break;
-                w.value = ai[0].value;
-                ai[0].value = aim->value;
-                aim->value = w.value;
-                w.serial = ai[0].serial;
-                ai[0].serial = aim->serial;
-                aim->serial = w.serial;
-            }
-        }
-    }
-}
-
-
-static void uni_range(int a, int b)
-{
-    if (a < b)
-        printf("%d,%d", a, b - a + 1);
-    else if (a == b)
-        printf("%d", b);
-    else
-        printf("%d,0", b);
-}
-
-
-static void fetch(long *f, int a, int b, FILE * lb, int ch)
-{
-    int i, j, c, lastc, col, nc;
-
-    if (a > b)
-        return;
-    for (i = a; i <= b; i++) {
-        fseek(lb, f[i - 1], SEEK_SET);
-        nc = f[i] - f[i - 1];
-        if (ch != '\0') {
-            putchar(ch);
-            if (option_mask32 & FLAG_T)
-                putchar('\t');
-        }
-        col = 0;
-        for (j = 0, lastc = '\0'; j < nc; j++, lastc = c) {
-            if ((c = getc(lb)) == EOF) {
-                printf("\n\\ No newline at end of file\n");
-                return;
-            }
-            if (c == '\t' && (option_mask32 & FLAG_t)) {
-                do {
-                    putchar(' ');
-                } while (++col & 7);
-            } else {
-                putchar(c);
-                col++;
-            }
-        }
-    }
-}
-
-
-static int asciifile(FILE * f)
-{
-#if ENABLE_FEATURE_DIFF_BINARY
-    int i, cnt;
-#endif
-
-    if ((option_mask32 & FLAG_a) || f == NULL)
-        return 1;
-
-#if ENABLE_FEATURE_DIFF_BINARY
-    rewind(f);
-    cnt = fread(g_read_buf, 1, COMMON_BUFSIZE, f);
-    for (i = 0; i < cnt; i++) {
-        if (!isprint(g_read_buf[i])
-         && !isspace(g_read_buf[i])) {
-            return 0;
-        }
-    }
-#endif
-    return 1;
-}
-
-
-/* dump accumulated "unified" diff changes */
-static void dump_unified_vec(FILE * f1, FILE * f2)
-{
-    struct context_vec *cvp = context_vec_start;
-    int lowa, upb, lowc, upd;
-    int a, b, c, d;
-    char ch;
-
-    if (context_vec_start > context_vec_ptr)
-        return;
-
-    b = d = 0;          /* gcc */
-    lowa = MAX(1, cvp->a - context);
-    upb = MIN(len[0], context_vec_ptr->b + context);
-    lowc = MAX(1, cvp->c - context);
-    upd = MIN(len[1], context_vec_ptr->d + context);
-
-    printf("@@ -");
-    uni_range(lowa, upb);
-    printf(" +");
-    uni_range(lowc, upd);
-    printf(" @@\n");
-
-    /*
-     * Output changes in "unified" diff format--the old and new lines
-     * are printed together.
-     */
-    for (; cvp <= context_vec_ptr; cvp++) {
-        a = cvp->a;
-        b = cvp->b;
-        c = cvp->c;
-        d = cvp->d;
-
-        /*
-         * c: both new and old changes
-         * d: only changes in the old file
-         * a: only changes in the new file
-         */
-        if (a <= b && c <= d)
-            ch = 'c';
-        else
-            ch = (a <= b) ? 'd' : 'a';
-#if 0
-        switch (ch) {
-        case 'c':
-            fetch(ixold, lowa, a - 1, f1, ' ');
-            fetch(ixold, a, b, f1, '-');
-            fetch(ixnew, c, d, f2, '+');
-            break;
-        case 'd':
-            fetch(ixold, lowa, a - 1, f1, ' ');
-            fetch(ixold, a, b, f1, '-');
-            break;
-        case 'a':
-            fetch(ixnew, lowc, c - 1, f2, ' ');
-            fetch(ixnew, c, d, f2, '+');
-            break;
-        }
-#else
-        if (ch == 'c' || ch == 'd') {
-            fetch(ixold, lowa, a - 1, f1, ' ');
-            fetch(ixold, a, b, f1, '-');
-        }
-        if (ch == 'a')
-            fetch(ixnew, lowc, c - 1, f2, ' ');
-        if (ch == 'c' || ch == 'a')
-            fetch(ixnew, c, d, f2, '+');
-#endif
-        lowa = b + 1;
-        lowc = d + 1;
-    }
-    fetch(ixnew, d + 1, upd, f2, ' ');
-
-    context_vec_ptr = context_vec_start - 1;
-}
-
-
-static void print_header(const char *file1, const char *file2)
-{
-    if (label1)
-        printf("--- %s\n", label1);
-    else
-        printf("--- %s\t%s", file1, ctime(&stb1.st_mtime));
-    if (label2)
-        printf("+++ %s\n", label2);
-    else
-        printf("+++ %s\t%s", file2, ctime(&stb2.st_mtime));
-}
-
-
-/*
- * Indicate that there is a difference between lines a and b of the from file
- * to get to lines c to d of the to file.  If a is greater than b then there
- * are no lines in the from file involved and this means that there were
- * lines appended (beginning at b).  If c is greater than d then there are
- * lines missing from the to file.
- */
-static void change(char *file1, FILE * f1, char *file2, FILE * f2, int a,
-                   int b, int c, int d)
-{
-    if ((a > b && c > d) || (option_mask32 & FLAG_q)) {
-        anychange = 1;
-        return;
-    }
-
-    /*
-     * Allocate change records as needed.
-     */
-    if (context_vec_ptr == context_vec_end - 1) {
-        ptrdiff_t offset = context_vec_ptr - context_vec_start;
-
-        max_context <<= 1;
-        context_vec_start = xrealloc(context_vec_start,
-                max_context * sizeof(struct context_vec));
-        context_vec_end = context_vec_start + max_context;
-        context_vec_ptr = context_vec_start + offset;
-    }
-    if (anychange == 0) {
-        /*
-         * Print the context/unidiff header first time through.
-         */
-        print_header(file1, file2);
-    } else if (a > context_vec_ptr->b + (2 * context) + 1 &&
-               c > context_vec_ptr->d + (2 * context) + 1) {
-        /*
-         * If this change is more than 'context' lines from the
-         * previous change, dump the record and reset it.
-         */
-        dump_unified_vec(f1, f2);
-    }
-    context_vec_ptr++;
-    context_vec_ptr->a = a;
-    context_vec_ptr->b = b;
-    context_vec_ptr->c = c;
-    context_vec_ptr->d = d;
-    anychange = 1;
-}
-
-
-static void output(char *file1, FILE * f1, char *file2, FILE * f2)
-{
-    /* Note that j0 and j1 can't be used as they are defined in math.h.
-     * This also allows the rather amusing variable 'j00'... */
-    int m, i0, i1, j00, j01;
-
-    rewind(f1);
-    rewind(f2);
-    m = len[0];
-    J[0] = 0;
-    J[m + 1] = len[1] + 1;
-    for (i0 = 1; i0 <= m; i0 = i1 + 1) {
-        while (i0 <= m && J[i0] == J[i0 - 1] + 1)
-            i0++;
-        j00 = J[i0 - 1] + 1;
-        i1 = i0 - 1;
-        while (i1 < m && J[i1 + 1] == 0)
-            i1++;
-        j01 = J[i1 + 1] - 1;
-        J[i1] = j01;
-        change(file1, f1, file2, f2, i0, i1, j00, j01);
-    }
-    if (m == 0) {
-        change(file1, f1, file2, f2, 1, 0, 1, len[1]);
-    }
-    if (anychange != 0 && !(option_mask32 & FLAG_q)) {
-        dump_unified_vec(f1, f2);
-    }
-}
 
 /*
@@ -885 +21 @@
  * The major goal is to generate the match vector J.
  * J[i] is the index of the line in file1 corresponding
- * to line i file0. J[i] = 0 if there is no
+ * to line i in file0. J[i] = 0 if there is no
  * such line in file1.
  *
  * Lines are hashed so as to work in core. All potential
  * matches are located by sorting the lines of each file
- * on the hash (called ``value''). In particular, this
+ * on the hash (called "value"). In particular, this
  * collects the equivalence classes in file1 together.
  * Subroutine equiv replaces the value of each line in
@@ -906 +42 @@
  * through the lines of file0, developing a vector klist
  * of "k-candidates". At step i a k-candidate is a matched
- * pair of lines x,y (x in file0 y in file1) such that
+ * pair of lines x,y (x in file0, y in file1) such that
  * there is a common subsequence of length k
  * between the first i lines of file0 and the first y
@@ -937 +73 @@
  * The core requirements for problems larger than somewhat
  * are (in words) 2*length(file0) + length(file1) +
- * 3*(number of k-candidates installed),  typically about
+ * 3*(number of k-candidates installed), typically about
  * 6n words for files of length n.
  */
-static unsigned diffreg(char *ofile1, char *ofile2, int flags)
-{
-    char *file1 = ofile1;
-    char *file2 = ofile2;
-    FILE *f1 = stdin, *f2 = stdin;
-    unsigned rval;
+
+#include "libbb.h"
+
+#if 0
+//#define dbg_error_msg(...) bb_error_msg(__VA_ARGS__)
+#else
+#define dbg_error_msg(...) ((void)0)
+#endif
+
+enum {                  /* print_status() and diffreg() return values */
+    STATUS_SAME,    /* files are the same */
+    STATUS_DIFFER,  /* files differ */
+    STATUS_BINARY,  /* binary files differ */
+};
+
+enum {                  /* Commandline flags */
+    FLAG_a,
+    FLAG_b,
+    FLAG_d,
+    FLAG_i,
+    FLAG_L,         /* never used, handled by getopt32 */
+    FLAG_N,
+    FLAG_q,
+    FLAG_r,
+    FLAG_s,
+    FLAG_S,         /* never used, handled by getopt32 */
+    FLAG_t,
+    FLAG_T,
+    FLAG_U,         /* never used, handled by getopt32 */
+    FLAG_w,
+    FLAG_u,         /* ignored, this is the default */
+    FLAG_p,         /* not implemented */
+    FLAG_B,
+    FLAG_E,         /* not implemented */
+};
+#define FLAG(x) (1 << FLAG_##x)
+
+/* We cache file position to avoid excessive seeking */
+typedef struct FILE_and_pos_t {
+    FILE *ft_fp;
+    off_t ft_pos;
+} FILE_and_pos_t;
+
+struct globals {
+    smallint exit_status;
+    int opt_U_context;
+    const char *other_dir;
+    char *label[2];
+    struct stat stb[2];
+};
+#define G (*ptr_to_globals)
+#define exit_status        (G.exit_status       )
+#define opt_U_context      (G.opt_U_context     )
+#define label              (G.label             )
+#define stb                (G.stb               )
+#define INIT_G() do { \
+    SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
+    opt_U_context = 3; \
+} while (0)
+
+typedef int token_t;
+
+enum {
+    /* Public */
+    TOK_EMPTY = 1 << 9,  /* Line fully processed, you can proceed to the next */
+    TOK_EOF   = 1 << 10, /* File ended */
+    /* Private (Only to be used by read_token() */
+    TOK_EOL   = 1 << 11, /* we saw EOL (sticky) */
+    TOK_SPACE = 1 << 12, /* used -b code, means we are skipping spaces */
+    SHIFT_EOF = (sizeof(token_t)*8 - 8) - 1,
+    CHAR_MASK = 0x1ff,   /* 8th bit is used to distinguish EOF from 0xff */
+};
+
+/* Restores full EOF from one 8th bit: */
+//#define TOK2CHAR(t) (((t) << SHIFT_EOF) >> SHIFT_EOF)
+/* We don't really need the above, we only need to have EOF != any_real_char: */
+#define TOK2CHAR(t) ((t) & CHAR_MASK)
+
+static void seek_ft(FILE_and_pos_t *ft, off_t pos)
+{
+    if (ft->ft_pos != pos) {
+        ft->ft_pos = pos;
+        fseeko(ft->ft_fp, pos, SEEK_SET);
+    }
+}
+
+/* Reads tokens from given fp, handling -b and -w flags
+ * The user must reset tok every line start
+ */
+static int read_token(FILE_and_pos_t *ft, token_t tok)
+{
+    tok |= TOK_EMPTY;
+    while (!(tok & TOK_EOL)) {
+        bool is_space;
+        int t;
+
+        t = fgetc(ft->ft_fp);
+        if (t != EOF)
+            ft->ft_pos++;
+        is_space = (t == EOF || isspace(t));
+
+        /* If t == EOF (-1), set both TOK_EOF and TOK_EOL */
+        tok |= (t & (TOK_EOF + TOK_EOL));
+        /* Only EOL? */
+        if (t == '\n')
+            tok |= TOK_EOL;
+
+        if (option_mask32 & FLAG(i)) /* Handcoded tolower() */
+            t = (t >= 'A' && t <= 'Z') ? t - ('A' - 'a') : t;
+
+        if ((option_mask32 & FLAG(w)) && is_space)
+            continue;
+
+        /* Trim char value to low 9 bits */
+        t &= CHAR_MASK;
+
+        if (option_mask32 & FLAG(b)) {
+            /* Was prev char whitespace? */
+            if (tok & TOK_SPACE) { /* yes */
+                if (is_space) /* this one too, ignore it */
+                    continue;
+                tok &= ~TOK_SPACE;
+            } else if (is_space) {
+                /* 1st whitespace char.
+                 * Set TOK_SPACE and replace char by ' ' */
+                t = TOK_SPACE + ' ';
+            }
+        }
+        /* Clear EMPTY */
+        tok &= ~(TOK_EMPTY + CHAR_MASK);
+        /* Assign char value (low 9 bits) and maybe set TOK_SPACE */
+        tok |= t;
+        break;
+    }
+#if 0
+    bb_error_msg("fp:%p tok:%x '%c'%s%s%s%s", fp, tok, tok & 0xff
+        , tok & TOK_EOF ? " EOF" : ""
+        , tok & TOK_EOL ? " EOL" : ""
+        , tok & TOK_EMPTY ? " EMPTY" : ""
+        , tok & TOK_SPACE ? " SPACE" : ""
+    );
+#endif
+    return tok;
+}
+
+struct cand {
+    int x;
+    int y;
+    int pred;
+};
+
+static int search(const int *c, int k, int y, const struct cand *list)
+{
+    int i, j;
+
+    if (list[c[k]].y < y)  /* quick look for typical case */
+        return k + 1;
+
+    for (i = 0, j = k + 1;;) {
+        const int l = (i + j) >> 1;
+        if (l > i) {
+            const int t = list[c[l]].y;
+            if (t > y)
+                j = l;
+            else if (t < y)
+                i = l;
+            else
+                return l;
+        } else
+            return l + 1;
+    }
+}
+
+static unsigned isqrt(unsigned n)
+{
+    unsigned x = 1;
+    while (1) {
+        const unsigned y = x;
+        x = ((n / x) + x) >> 1;
+        if (x <= (y + 1) && x >= (y - 1))
+            return x;
+    }
+}
+
+static void stone(const int *a, int n, const int *b, int *J, int pref)
+{
+    const unsigned isq = isqrt(n);
+    const unsigned bound =
+        (option_mask32 & FLAG(d)) ? UINT_MAX : MAX(256, isq);
+    int clen = 1;
+    int clistlen = 100;
+    int k = 0;
+    struct cand *clist = xzalloc(clistlen * sizeof(clist[0]));
+    struct cand cand;
+    struct cand *q;
+    int *klist = xzalloc((n + 2) * sizeof(klist[0]));
+    /*clist[0] = (struct cand){0}; - xzalloc did it */
+    /*klist[0] = 0; */
+
+    for (cand.x = 1; cand.x <= n; cand.x++) {
+        int j = a[cand.x], oldl = 0;
+        unsigned numtries = 0;
+        if (j == 0)
+            continue;
+        cand.y = -b[j];
+        cand.pred = klist[0];
+        do {
+            int l, tc;
+            if (cand.y <= clist[cand.pred].y)
+                continue;
+            l = search(klist, k, cand.y, clist);
+            if (l != oldl + 1)
+                cand.pred = klist[l - 1];
+            if (l <= k && clist[klist[l]].y <= cand.y)
+                continue;
+            if (clen == clistlen) {
+                clistlen = clistlen * 11 / 10;
+                clist = xrealloc(clist, clistlen * sizeof(clist[0]));
+            }
+            clist[clen] = cand;
+            tc = klist[l];
+            klist[l] = clen++;
+            if (l <= k) {
+                cand.pred = tc;
+                oldl = l;
+                numtries++;
+            } else {
+                k++;
+                break;
+            }
+        } while ((cand.y = b[++j]) > 0 && numtries < bound);
+    }
+    /* Unravel */
+    for (q = clist + klist[k]; q->y; q = clist + q->pred)
+        J[q->x + pref] = q->y + pref;
+    free(klist);
+    free(clist);
+}
+
+struct line {
+    /* 'serial' is not used in the begining, so we reuse it
+     * to store line offsets, thus reducing memory pressure
+     */
+    union {
+        unsigned serial;
+        off_t offset;
+    };
+    unsigned value;
+};
+
+static void equiv(struct line *a, int n, struct line *b, int m, int *c)
+{
+    int i = 1, j = 1;
+
+    while (i <= n && j <= m) {
+        if (a[i].value < b[j].value)
+            a[i++].value = 0;
+        else if (a[i].value == b[j].value)
+            a[i++].value = j;
+        else
+            j++;
+    }
+    while (i <= n)
+        a[i++].value = 0;
+    b[m + 1].value = 0;
+    j = 0;
+    while (++j <= m) {
+        c[j] = -b[j].serial;
+        while (b[j + 1].value == b[j].value) {
+            j++;
+            c[j] = b[j].serial;
+        }
+    }
+    c[j] = -1;
+}
+
+static void unsort(const struct line *f, int l, int *b)
+{
     int i;
-
-    anychange = 0;
-    context_vec_ptr = context_vec_start - 1;
-
-    if (S_ISDIR(stb1.st_mode) != S_ISDIR(stb2.st_mode))
-        return (S_ISDIR(stb1.st_mode) ? D_MISMATCH1 : D_MISMATCH2);
-
-    rval = D_SAME;
-
-    if (LONE_DASH(file1) && LONE_DASH(file2))
-        goto closem;
-
-    if (flags & D_EMPTY1)
-        f1 = xfopen(bb_dev_null, "r");
-    else if (NOT_LONE_DASH(file1))
-        f1 = xfopen(file1, "r");
-    if (flags & D_EMPTY2)
-        f2 = xfopen(bb_dev_null, "r");
-    else if (NOT_LONE_DASH(file2))
-        f2 = xfopen(file2, "r");
-
-/* We can't diff non-seekable stream - we use rewind(), fseek().
- * This can be fixed (volunteers?).
- * Meanwhile we should check it here by stat'ing input fds,
- * but I am lazy and check that in main() instead.
- * Check in main won't catch "diffing fifos buried in subdirectories"
- * failure scenario - not very likely in real life... */
-
-    i = files_differ(f1, f2, flags);
-    if (i == 0)
-        goto closem;
-    else if (i != 1) {  /* 1 == ok */
-        /* error */
-        status |= 2;
-        goto closem;
-    }
-
-    if (!asciifile(f1) || !asciifile(f2)) {
-        rval = D_BINARY;
-        status |= 1;
-        goto closem;
-    }
-
-    prepare(0, f1 /*, stb1.st_size*/);
-    prepare(1, f2 /*, stb2.st_size*/);
-    prune();
-    sort(sfile[0], slen[0]);
-    sort(sfile[1], slen[1]);
-
-    member = (int *) file[1];
+    int *a = xmalloc((l + 1) * sizeof(a[0]));
+    for (i = 1; i <= l; i++)
+        a[f[i].serial] = f[i].value;
+    for (i = 1; i <= l; i++)
+        b[i] = a[i];
+    free(a);
+}
+
+static int line_compar(const void *a, const void *b)
+{
+#define l0 ((const struct line*)a)
+#define l1 ((const struct line*)b)
+    int r = l0->value - l1->value;
+    if (r)
+        return r;
+    return l0->serial - l1->serial;
+#undef l0
+#undef l1
+}
+
+static void fetch(FILE_and_pos_t *ft, const off_t *ix, int a, int b, int ch)
+{
+    int i, j, col;
+    for (i = a; i <= b; i++) {
+        seek_ft(ft, ix[i - 1]);
+        putchar(ch);
+        if (option_mask32 & FLAG(T))
+            putchar('\t');
+        for (j = 0, col = 0; j < ix[i] - ix[i - 1]; j++) {
+            int c = fgetc(ft->ft_fp);
+            if (c == EOF) {
+                printf("\n\\ No newline at end of file\n");
+                return;
+            }
+            ft->ft_pos++;
+            if (c == '\t' && (option_mask32 & FLAG(t)))
+                do putchar(' '); while (++col & 7);
+            else {
+                putchar(c);
+                col++;
+            }
+        }
+    }
+}
+
+/* Creates the match vector J, where J[i] is the index
+ * of the line in the new file corresponding to the line i
+ * in the old file. Lines start at 1 instead of 0, that value
+ * being used instead to denote no corresponding line.
+ * This vector is dynamically allocated and must be freed by the caller.
+ *
+ * * fp is an input parameter, where fp[0] and fp[1] are the open
+ *   old file and new file respectively.
+ * * nlen is an output variable, where nlen[0] and nlen[1]
+ *   gets the number of lines in the old and new file respectively.
+ * * ix is an output variable, where ix[0] and ix[1] gets
+ *   assigned dynamically allocated vectors of the offsets of the lines
+ *   of the old and new file respectively. These must be freed by the caller.
+ */
+static NOINLINE int *create_J(FILE_and_pos_t ft[2], int nlen[2], off_t *ix[2])
+{
+    int *J, slen[2], *class, *member;
+    struct line *nfile[2], *sfile[2];
+    int pref = 0, suff = 0, i, j, delta;
+
+    /* Lines of both files are hashed, and in the process
+     * their offsets are stored in the array ix[fileno]
+     * where fileno == 0 points to the old file, and
+     * fileno == 1 points to the new one.
+     */
+    for (i = 0; i < 2; i++) {
+        unsigned hash;
+        token_t tok;
+        size_t sz = 100;
+        nfile[i] = xmalloc((sz + 3) * sizeof(nfile[i][0]));
+        /* ft gets here without the correct position, cant use seek_ft */
+        ft[i].ft_pos = 0;
+        fseeko(ft[i].ft_fp, 0, SEEK_SET);
+
+        nlen[i] = 0;
+        /* We could zalloc nfile, but then zalloc starts showing in gprof at ~1% */
+        nfile[i][0].offset = 0;
+        goto start; /* saves code */
+        while (1) {
+            tok = read_token(&ft[i], tok);
+            if (!(tok & TOK_EMPTY)) {
+                /* Hash algorithm taken from Robert Sedgewick, Algorithms in C, 3d ed., p 578. */
+                /*hash = hash * 128 - hash + TOK2CHAR(tok);
+                 * gcc insists on optimizing above to "hash * 127 + ...", thus... */
+                unsigned o = hash - TOK2CHAR(tok);
+                hash = hash * 128 - o; /* we want SPEED here */
+                continue;
+            }
+            if (nlen[i]++ == sz) {
+                sz = sz * 3 / 2;
+                nfile[i] = xrealloc(nfile[i], (sz + 3) * sizeof(nfile[i][0]));
+            }
+            /* line_compar needs hashes fit into positive int */
+            nfile[i][nlen[i]].value = hash & INT_MAX;
+            /* like ftello(ft[i].ft_fp) but faster (avoids lseek syscall) */
+            nfile[i][nlen[i]].offset = ft[i].ft_pos;
+            if (tok & TOK_EOF) {
+                /* EOF counts as a token, so we have to adjust it here */
+                nfile[i][nlen[i]].offset++;
+                break;
+            }
+start:
+            hash = tok = 0;
+        }
+        /* Exclude lone EOF line from the end of the file, to make fetch()'s job easier */
+        if (nfile[i][nlen[i]].offset - nfile[i][nlen[i] - 1].offset == 1)
+            nlen[i]--;
+        /* Now we copy the line offsets into ix */
+        ix[i] = xmalloc((nlen[i] + 2) * sizeof(ix[i][0]));
+        for (j = 0; j < nlen[i] + 1; j++)
+            ix[i][j] = nfile[i][j].offset;
+    }
+
+    /* length of prefix and suffix is calculated */
+    for (; pref < nlen[0] && pref < nlen[1] &&
+           nfile[0][pref + 1].value == nfile[1][pref + 1].value;
+           pref++);
+    for (; suff < nlen[0] - pref && suff < nlen[1] - pref &&
+           nfile[0][nlen[0] - suff].value == nfile[1][nlen[1] - suff].value;
+           suff++);
+    /* Arrays are pruned by the suffix and prefix length,
+     * the result being sorted and stored in sfile[fileno],
+     * and their sizes are stored in slen[fileno]
+     */
+    for (j = 0; j < 2; j++) {
+        sfile[j] = nfile[j] + pref;
+        slen[j] = nlen[j] - pref - suff;
+        for (i = 0; i <= slen[j]; i++)
+            sfile[j][i].serial = i;
+        qsort(sfile[j] + 1, slen[j], sizeof(*sfile[j]), line_compar);
+    }
+    /* nfile arrays are reused to reduce memory pressure
+     * The #if zeroed out section performs the same task as the
+     * one in the #else section.
+     * Peak memory usage is higher, but one array copy is avoided
+     * by not using unsort()
+     */
+#if 0
+    member = xmalloc((slen[1] + 2) * sizeof(member[0]));
     equiv(sfile[0], slen[0], sfile[1], slen[1], member);
-    member = xrealloc(member, (slen[1] + 2) * sizeof(int));
-
-    class = (int *) file[0];
-    unsort(sfile[0], slen[0], class);
-    class = xrealloc(class, (slen[0] + 2) * sizeof(int));
-
-    klist = xmalloc((slen[0] + 2) * sizeof(int));
-    clen = 0;
-    clistlen = 100;
-    clist = xmalloc(clistlen * sizeof(struct cand));
-    i = stone(class, slen[0], member, klist);
+    free(nfile[1]);
+
+    class = xmalloc((slen[0] + 1) * sizeof(class[0]));
+    for (i = 1; i <= slen[0]; i++) /* Unsorting */
+        class[sfile[0][i].serial] = sfile[0][i].value;
+    free(nfile[0]);
+#else
+    member = (int *)nfile[1];
+    equiv(sfile[0], slen[0], sfile[1], slen[1], member);
+    member = xrealloc(member, (slen[1] + 2) * sizeof(member[0]));
+
+    class = (int *)nfile[0];
+    unsort(sfile[0], slen[0], (int *)nfile[0]);
+    class = xrealloc(class, (slen[0] + 2) * sizeof(class[0]));
+#endif
+    J = xmalloc((nlen[0] + 2) * sizeof(J[0]));
+    /* The elements of J which fall inside the prefix and suffix regions
+     * are marked as unchanged, while the ones which fall outside
+     * are initialized with 0 (no matches), so that function stone can
+     * then assign them their right values
+     */
+    for (i = 0, delta = nlen[1] - nlen[0]; i <= nlen[0]; i++)
+        J[i] = i <= pref            ?  i :
+               i > (nlen[0] - suff) ? (i + delta) : 0;
+    /* Here the magic is performed */
+    stone(class, slen[0], member, J, pref);
+    J[nlen[0] + 1] = nlen[1] + 1;
+
+    free(class);
     free(member);
-    free(class);
-
-    J = xrealloc(J, (len[0] + 2) * sizeof(int));
-    unravel(klist[i]);
-    free(clist);
-    free(klist);
-
-    ixold = xrealloc(ixold, (len[0] + 2) * sizeof(long));
-    ixnew = xrealloc(ixnew, (len[1] + 2) * sizeof(long));
-    check(f1, f2);
-    output(file1, f1, file2, f2);
-
- closem:
-    if (anychange) {
-        status |= 1;
-        if (rval == D_SAME)
-            rval = D_DIFFER;
-    }
-    fclose_if_not_stdin(f1);
-    fclose_if_not_stdin(f2);
-    if (file1 != ofile1)
-        free(file1);
-    if (file2 != ofile2)
-        free(file2);
-    return rval;
-}
-
+
+    /* Both files are rescanned, in an effort to find any lines
+     * which, due to limitations intrinsic to any hashing algorithm,
+     * are different but ended up confounded as the same
+     */
+    for (i = 1; i <= nlen[0]; i++) {
+        if (!J[i])
+            continue;
+
+        seek_ft(&ft[0], ix[0][i - 1]);
+        seek_ft(&ft[1], ix[1][J[i] - 1]);
+
+        for (j = J[i]; i <= nlen[0] && J[i] == j; i++, j++) {
+            token_t tok0 = 0, tok1 = 0;
+            do {
+                tok0 = read_token(&ft[0], tok0);
+                tok1 = read_token(&ft[1], tok1);
+
+                if (((tok0 ^ tok1) & TOK_EMPTY) != 0 /* one is empty (not both) */
+                 || (!(tok0 & TOK_EMPTY) && TOK2CHAR(tok0) != TOK2CHAR(tok1))
+                ) {
+                    J[i] = 0; /* Break the correspondence */
+                }
+            } while (!(tok0 & tok1 & TOK_EMPTY));
+        }
+    }
+
+    return J;
+}
+
+static bool diff(FILE* fp[2], char *file[2])
+{
+    int nlen[2];
+    off_t *ix[2];
+    FILE_and_pos_t ft[2];
+    typedef struct { int a, b; } vec_t[2];
+    vec_t *vec = NULL;
+    int i = 1, j, k, idx = -1;
+    bool anychange = false;
+    int *J;
+
+    ft[0].ft_fp = fp[0];
+    ft[1].ft_fp = fp[1];
+    /* note that ft[i].ft_pos is unintitalized, create_J()
+     * must not assume otherwise */
+    J = create_J(ft, nlen, ix);
+
+    do {
+        bool nonempty = false;
+
+        while (1) {
+            vec_t v;
+
+            for (v[0].a = i; v[0].a <= nlen[0] && J[v[0].a] == J[v[0].a - 1] + 1; v[0].a++)
+                continue;
+            v[1].a = J[v[0].a - 1] + 1;
+
+            for (v[0].b = v[0].a - 1; v[0].b < nlen[0] && !J[v[0].b + 1]; v[0].b++)
+                continue;
+            v[1].b = J[v[0].b + 1] - 1;
+            /*
+             * Indicate that there is a difference between lines a and b of the 'from' file
+             * to get to lines c to d of the 'to' file. If a is greater than b then there
+             * are no lines in the 'from' file involved and this means that there were
+             * lines appended (beginning at b).  If c is greater than d then there are
+             * lines missing from the 'to' file.
+             */
+            if (v[0].a <= v[0].b || v[1].a <= v[1].b) {
+                /*
+                 * If this change is more than 'context' lines from the
+                 * previous change, dump the record and reset it.
+                 */
+                int ct = (2 * opt_U_context) + 1;
+                if (idx >= 0
+                 && v[0].a > vec[idx][0].b + ct
+                 && v[1].a > vec[idx][1].b + ct
+                ) {
+                    break;
+                }
+
+                for (j = 0; j < 2; j++)
+                    for (k = v[j].a; k < v[j].b; k++)
+                        nonempty |= (ix[j][k+1] - ix[j][k] != 1);
+
+                vec = xrealloc_vector(vec, 6, ++idx);
+                memcpy(vec[idx], v, sizeof(v));
+            }
+
+            i = v[0].b + 1;
+            if (i > nlen[0])
+                break;
+            J[v[0].b] = v[1].b;
+        }
+        if (idx < 0 || ((option_mask32 & FLAG(B)) && !nonempty))
+            goto cont;
+        if (!(option_mask32 & FLAG(q))) {
+            int lowa;
+            vec_t span, *cvp = vec;
+
+            if (!anychange) {
+                /* Print the context/unidiff header first time through */
+                printf("--- %s\n", label[0] ? label[0] : file[0]);
+                printf("+++ %s\n", label[1] ? label[1] : file[1]);
+            }
+
+            printf("@@");
+            for (j = 0; j < 2; j++) {
+                int a = span[j].a = MAX(1, (*cvp)[j].a - opt_U_context);
+                int b = span[j].b = MIN(nlen[j], vec[idx][j].b + opt_U_context);
+
+                printf(" %c%d", j ? '+' : '-', MIN(a, b));
+                if (a == b)
+                    continue;
+                printf(",%d", (a < b) ? b - a + 1 : 0);
+            }
+            printf(" @@\n");
+            /*
+             * Output changes in "unified" diff format--the old and new lines
+             * are printed together.
+             */
+            for (lowa = span[0].a; ; lowa = (*cvp++)[0].b + 1) {
+                bool end = cvp > &vec[idx];
+                fetch(&ft[0], ix[0], lowa, end ? span[0].b : (*cvp)[0].a - 1, ' ');
+                if (end)
+                    break;
+                for (j = 0; j < 2; j++)
+                    fetch(&ft[j], ix[j], (*cvp)[j].a, (*cvp)[j].b, j ? '+' : '-');
+            }
+        }
+        anychange = true;
+ cont:
+        idx = -1;
+    } while (i <= nlen[0]);
+
+    free(vec);
+    free(ix[0]);
+    free(ix[1]);
+    free(J);
+    return anychange;
+}
+
+static int diffreg(char *file[2])
+{
+    FILE *fp[2] = { stdin, stdin };
+    bool binary = false, differ = false;
+    int status = STATUS_SAME, i;
+
+    for (i = 0; i < 2; i++) {
+        int fd = open_or_warn_stdin(file[i]);
+        if (fd == -1)
+            goto out;
+        /* Our diff implementation is using seek.
+         * When we meet non-seekable file, we must make a temp copy.
+         */
+        if (lseek(fd, 0, SEEK_SET) == -1 && errno == ESPIPE) {
+            char name[] = "/tmp/difXXXXXX";
+            int fd_tmp = xmkstemp(name);
+
+            unlink(name);
+            if (bb_copyfd_eof(fd, fd_tmp) < 0)
+                xfunc_die();
+            if (fd) /* Prevents closing of stdin */
+                close(fd);
+            fd = fd_tmp;
+        }
+        fp[i] = fdopen(fd, "r");
+    }
+
+    while (1) {
+        const size_t sz = COMMON_BUFSIZE / 2;
+        char *const buf0 = bb_common_bufsiz1;
+        char *const buf1 = buf0 + sz;
+        int j, k;
+        i = fread(buf0, 1, sz, fp[0]);
+        j = fread(buf1, 1, sz, fp[1]);
+        if (i != j) {
+            differ = true;
+            i = MIN(i, j);
+        }
+        if (i == 0)
+            break;
+        for (k = 0; k < i; k++) {
+            if (!buf0[k] || !buf1[k])
+                binary = true;
+            if (buf0[k] != buf1[k])
+                differ = true;
+        }
+    }
+    if (differ) {
+        if (binary && !(option_mask32 & FLAG(a)))
+            status = STATUS_BINARY;
+        else if (diff(fp, file))
+            status = STATUS_DIFFER;
+    }
+    if (status != STATUS_SAME)
+        exit_status |= 1;
+out:
+    fclose_if_not_stdin(fp[0]);
+    fclose_if_not_stdin(fp[1]);
+
+    return status;
+}
+
+static void print_status(int status, char *path[2])
+{
+    switch (status) {
+    case STATUS_BINARY:
+    case STATUS_DIFFER:
+        if ((option_mask32 & FLAG(q)) || status == STATUS_BINARY)
+            printf("Files %s and %s differ\n", path[0], path[1]);
+        break;
+    case STATUS_SAME:
+        if (option_mask32 & FLAG(s))
+            printf("Files %s and %s are identical\n", path[0], path[1]);
+        break;
+    }
+}
 
 #if ENABLE_FEATURE_DIFF_DIR
-static void do_diff(char *dir1, char *path1, char *dir2, char *path2)
-{
-    int flags = D_HEADER;
-    int val;
-    char *fullpath1 = NULL; /* if -N */
-    char *fullpath2 = NULL;
-
-    if (path1)
-        fullpath1 = concat_path_file(dir1, path1);
-    if (path2)
-        fullpath2 = concat_path_file(dir2, path2);
-
-    if (!fullpath1 || stat(fullpath1, &stb1) != 0) {
-        flags |= D_EMPTY1;
-        memset(&stb1, 0, sizeof(stb1));
-        if (path2) {
-            free(fullpath1);
-            fullpath1 = concat_path_file(dir1, path2);
-        }
-    }
-    if (!fullpath2 || stat(fullpath2, &stb2) != 0) {
-        flags |= D_EMPTY2;
-        memset(&stb2, 0, sizeof(stb2));
-        stb2.st_mode = stb1.st_mode;
-        if (path1) {
-            free(fullpath2);
-            fullpath2 = concat_path_file(dir2, path1);
-        }
-    }
-
-    if (stb1.st_mode == 0)
-        stb1.st_mode = stb2.st_mode;
-
-    if (S_ISDIR(stb1.st_mode) && S_ISDIR(stb2.st_mode)) {
-        printf("Common subdirectories: %s and %s\n", fullpath1, fullpath2);
-        goto ret;
-    }
-
-    if (!S_ISREG(stb1.st_mode) && !S_ISDIR(stb1.st_mode))
-        val = D_SKIPPED1;
-    else if (!S_ISREG(stb2.st_mode) && !S_ISDIR(stb2.st_mode))
-        val = D_SKIPPED2;
-    else
-        val = diffreg(fullpath1, fullpath2, flags);
-
-    print_status(val, fullpath1, fullpath2, NULL);
- ret:
-    free(fullpath1);
-    free(fullpath2);
-}
-#endif
-
-
-#if ENABLE_FEATURE_DIFF_DIR
-static int dir_strcmp(const void *p1, const void *p2)
-{
-    return strcmp(*(char *const *) p1, *(char *const *) p2);
-}
-
+struct dlist {
+    size_t len;
+    int s, e;
+    char **dl;
+};
 
 /* This function adds a filename to dl, the directory listing. */
-static int add_to_dirlist(const char *filename,
-        struct stat ATTRIBUTE_UNUSED * sb, void *userdata,
-        int depth ATTRIBUTE_UNUSED)
-{
-    /* +2: with space for eventual trailing NULL */
-    dl = xrealloc(dl, (dl_count+2) * sizeof(dl[0]));
-    dl[dl_count] = xstrdup(filename + (int)(ptrdiff_t)userdata);
-    dl_count++;
+static int FAST_FUNC add_to_dirlist(const char *filename,
+        struct stat *sb UNUSED_PARAM,
+        void *userdata, int depth UNUSED_PARAM)
+{
+    struct dlist *const l = userdata;
+    const char *file = filename + l->len;
+    while (*file == '/')
+        file++;
+    l->dl = xrealloc_vector(l->dl, 6, l->e);
+    l->dl[l->e] = xstrdup(file);
+    l->e++;
     return TRUE;
 }
 
-
-/* This returns a sorted directory listing. */
-static char **get_dir(char *path)
-{
-    dl_count = 0;
-    dl = xzalloc(sizeof(dl[0]));
-
-    /* If -r has been set, then the recursive_action function will be
-     * used. Unfortunately, this outputs the root directory along with
-     * the recursed paths, so use void *userdata to specify the string
-     * length of the root directory - '(void*)(strlen(path)+)'.
-     * add_to_dirlist then removes root dir prefix. */
-
-    if (option_mask32 & FLAG_r) {
-        recursive_action(path, ACTION_RECURSE|ACTION_FOLLOWLINKS,
-                    add_to_dirlist, NULL,
-                    (void*)(strlen(path)+1), 0);
-    } else {
-        DIR *dp;
-        struct dirent *ep;
-
-        dp = warn_opendir(path);
-        while ((ep = readdir(dp))) {
-            if (!strcmp(ep->d_name, "..") || LONE_CHAR(ep->d_name, '.'))
-                continue;
-            add_to_dirlist(ep->d_name, NULL, (void*)(int)0, 0);
-        }
-        closedir(dp);
-    }
-
-    /* Sort dl alphabetically. */
-    qsort(dl, dl_count, sizeof(char *), dir_strcmp);
-
-    dl[dl_count] = NULL;
-    return dl;
-}
-
-
-static void diffdir(char *p1, char *p2)
-{
-    char **dirlist1, **dirlist2;
-    char *dp1, *dp2;
-    int pos;
-
-    /* Check for trailing slashes. */
-    dp1 = last_char_is(p1, '/');
-    if (dp1 != NULL)
-        *dp1 = '\0';
-    dp2 = last_char_is(p2, '/');
-    if (dp2 != NULL)
-        *dp2 = '\0';
-
-    /* Get directory listings for p1 and p2. */
-
-    dirlist1 = get_dir(p1);
-    dirlist2 = get_dir(p2);
-
-    /* If -S was set, find the starting point. */
-    if (start) {
-        while (*dirlist1 != NULL && strcmp(*dirlist1, start) < 0)
-            dirlist1++;
-        while (*dirlist2 != NULL && strcmp(*dirlist2, start) < 0)
-            dirlist2++;
-        if ((*dirlist1 == NULL) || (*dirlist2 == NULL))
-            bb_error_msg(bb_msg_invalid_arg, "NULL", "-S");
-    }
-
+/* If recursion is not set, this function adds the directory
+ * to the list and prevents recursive_action from recursing into it.
+ */
+static int FAST_FUNC skip_dir(const char *filename,
+        struct stat *sb, void *userdata,
+        int depth)
+{
+    if (!(option_mask32 & FLAG(r)) && depth) {
+        add_to_dirlist(filename, sb, userdata, depth);
+        return SKIP;
+    }
+    if (!(option_mask32 & FLAG(N))) {
+        /* -r without -N: no need to recurse into dirs
+         * which do not exist on the "other side".
+         * Testcase: diff -r /tmp /
+         * (it would recurse deep into /proc without this code) */
+        struct dlist *const l = userdata;
+        filename += l->len;
+        if (filename[0]) {
+            struct stat osb;
+            char *othername = concat_path_file(G.other_dir, filename);
+            int r = stat(othername, &osb);
+            free(othername);
+            if (r != 0 || !S_ISDIR(osb.st_mode)) {
+                /* other dir doesn't have similarly named
+                 * directory, don't recurse */
+                return SKIP;
+            }
+        }
+    }
+    return TRUE;
+}
+
+static void diffdir(char *p[2], const char *s_start)
+{
+    struct dlist list[2];
+    int i;
+
+    memset(&list, 0, sizeof(list));
+    for (i = 0; i < 2; i++) {
+        /*list[i].s = list[i].e = 0; - memset did it */
+        /*list[i].dl = NULL; */
+
+        G.other_dir = p[1 - i];
+        /* We need to trim root directory prefix.
+         * Using list.len to specify its length,
+         * add_to_dirlist will remove it. */
+        list[i].len = strlen(p[i]);
+        recursive_action(p[i], ACTION_RECURSE | ACTION_FOLLOWLINKS,
+                         add_to_dirlist, skip_dir, &list[i], 0);
+        /* Sort dl alphabetically.
+         * GNU diff does this ignoring any number of trailing dots.
+         * We don't, so for us dotted files almost always are
+         * first on the list.
+         */
+        qsort_string_vector(list[i].dl, list[i].e);
+        /* If -S was set, find the starting point. */
+        if (!s_start)
+            continue;
+        while (list[i].s < list[i].e && strcmp(list[i].dl[list[i].s], s_start) < 0)
+            list[i].s++;
+    }
     /* Now that both dirlist1 and dirlist2 contain sorted directory
      * listings, we can start to go through dirlist1. If both listings
      * contain the same file, then do a normal diff. Otherwise, behaviour
      * is determined by whether the -N flag is set. */
-    while (*dirlist1 != NULL || *dirlist2 != NULL) {
-        dp1 = *dirlist1;
-        dp2 = *dirlist2;
-        pos = dp1 == NULL ? 1 : dp2 == NULL ? -1 : strcmp(dp1, dp2);
+    while (1) {
+        char *dp[2];
+        int pos;
+        int k;
+
+        dp[0] = list[0].s < list[0].e ? list[0].dl[list[0].s] : NULL;
+        dp[1] = list[1].s < list[1].e ? list[1].dl[list[1].s] : NULL;
+        if (!dp[0] && !dp[1])
+            break;
+        pos = !dp[0] ? 1 : (!dp[1] ? -1 : strcmp(dp[0], dp[1]));
+        k = pos > 0;
+        if (pos && !(option_mask32 & FLAG(N)))
+            printf("Only in %s: %s\n", p[k], dp[k]);
+        else {
+            char *fullpath[2], *path[2]; /* if -N */
+
+            for (i = 0; i < 2; i++) {
+                if (pos == 0 || i == k) {
+                    path[i] = fullpath[i] = concat_path_file(p[i], dp[i]);
+                    stat(fullpath[i], &stb[i]);
+                } else {
+                    fullpath[i] = concat_path_file(p[i], dp[1 - i]);
+                    path[i] = (char *)bb_dev_null;
+                }
+            }
+            if (pos)
+                stat(fullpath[k], &stb[1 - k]);
+
+            if (S_ISDIR(stb[0].st_mode) && S_ISDIR(stb[1].st_mode))
+                printf("Common subdirectories: %s and %s\n", fullpath[0], fullpath[1]);
+            else if (!S_ISREG(stb[0].st_mode) && !S_ISDIR(stb[0].st_mode))
+                printf("File %s is not a regular file or directory and was skipped\n", fullpath[0]);
+            else if (!S_ISREG(stb[1].st_mode) && !S_ISDIR(stb[1].st_mode))
+                printf("File %s is not a regular file or directory and was skipped\n", fullpath[1]);
+            else if (S_ISDIR(stb[0].st_mode) != S_ISDIR(stb[1].st_mode)) {
+                if (S_ISDIR(stb[0].st_mode))
+                    printf("File %s is a %s while file %s is a %s\n", fullpath[0], "directory", fullpath[1], "regular file");
+                else
+                    printf("File %s is a %s while file %s is a %s\n", fullpath[0], "regular file", fullpath[1], "directory");
+            } else
+                print_status(diffreg(path), fullpath);
+
+            free(fullpath[0]);
+            free(fullpath[1]);
+        }
+        free(dp[k]);
+        list[k].s++;
         if (pos == 0) {
-            do_diff(p1, dp1, p2, dp2);
-            dirlist1++;
-            dirlist2++;
-        } else if (pos < 0) {
-            if (option_mask32 & FLAG_N)
-                do_diff(p1, dp1, p2, NULL);
-            else
-                print_only(p1, strlen(p1) + 1, dp1);
-            dirlist1++;
-        } else {
-            if (option_mask32 & FLAG_N)
-                do_diff(p1, NULL, p2, dp2);
-            else
-                print_only(p2, strlen(p2) + 1, dp2);
-            dirlist2++;
-        }
+            free(dp[1 - k]);
+            list[1 - k].s++;
+        }
+    }
+    if (ENABLE_FEATURE_CLEAN_UP) {
+        free(list[0].dl);
+        free(list[1].dl);
     }
 }
 #endif
 
-
-int diff_main(int argc, char **argv);
-int diff_main(int argc, char **argv)
-{
-    bool gotstdin = 0;
-    char *U_opt;
-    char *f1, *f2;
+#if ENABLE_FEATURE_DIFF_LONG_OPTIONS
+static const char diff_longopts[] ALIGN1 =
+    "ignore-case\0"              No_argument       "i"
+    "ignore-tab-expansion\0"     No_argument       "E"
+    "ignore-space-change\0"      No_argument       "b"
+    "ignore-all-space\0"         No_argument       "w"
+    "ignore-blank-lines\0"       No_argument       "B"
+    "text\0"                     No_argument       "a"
+    "unified\0"                  Required_argument "U"
+    "label\0"                    Required_argument "L"
+    "show-c-function\0"          No_argument       "p"
+    "brief\0"                    No_argument       "q"
+    "expand-tabs\0"              No_argument       "t"
+    "initial-tab\0"              No_argument       "T"
+    "recursive\0"                No_argument       "r"
+    "new-file\0"                 No_argument       "N"
+    "report-identical-files\0"   No_argument       "s"
+    "starting-file\0"            Required_argument "S"
+    "minimal\0"                  No_argument       "d"
+    ;
+#endif
+
+int diff_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int diff_main(int argc UNUSED_PARAM, char **argv)
+{
+    int gotstdin = 0, i;
+    char *file[2], *s_start = NULL;
     llist_t *L_arg = NULL;
 
     INIT_G();
 
-    /* exactly 2 params; collect multiple -L <label> */
-    opt_complementary = "=2:L::";
-    getopt32(argv, "abdiL:NqrsS:tTU:wu"
-            "p" /* ignored (for compatibility) */,
-            &L_arg, &start, &U_opt);
-    /*argc -= optind;*/
+    /* exactly 2 params; collect multiple -L <label>; -U N */
+    opt_complementary = "=2:L::U+";
+#if ENABLE_FEATURE_DIFF_LONG_OPTIONS
+    applet_long_options = diff_longopts;
+#endif
+    getopt32(argv, "abdiL:NqrsS:tTU:wupBE",
+            &L_arg, &s_start, &opt_U_context);
     argv += optind;
-    while (L_arg) {
-        if (label1 && label2)
-            bb_show_usage();
-        if (!label1)
-            label1 = L_arg->data;
-        else { /* then label2 is NULL */
-            label2 = label1;
-            label1 = L_arg->data;
-        }
-        /* we leak L_arg here... */
-        L_arg = L_arg->link;
-    }
-    if (option_mask32 & FLAG_U)
-        context = xatoi_u(U_opt);
-
-    /*
-     * Do sanity checks, fill in stb1 and stb2 and call the appropriate
-     * driver routine.  Both drivers use the contents of stb1 and stb2.
-     */
-
-    f1 = argv[0];
-    f2 = argv[1];
-    if (LONE_DASH(f1)) {
-        fstat(STDIN_FILENO, &stb1);
-        gotstdin = 1;
-    } else
-        xstat(f1, &stb1);
-    if (LONE_DASH(f2)) {
-        fstat(STDIN_FILENO, &stb2);
-        gotstdin = 1;
-    } else
-        xstat(f2, &stb2);
-    if (gotstdin && (S_ISDIR(stb1.st_mode) || S_ISDIR(stb2.st_mode)))
-        bb_error_msg_and_die("can't compare - to a directory");
-    if (S_ISDIR(stb1.st_mode) && S_ISDIR(stb2.st_mode)) {
+    while (L_arg)
+        label[!!label[0]] = llist_pop(&L_arg);
+    xfunc_error_retval = 2;
+    for (i = 0; i < 2; i++) {
+        file[i] = argv[i];
+        /* Compat: "diff file name_which_doesnt_exist" exits with 2 */
+        if (LONE_DASH(file[i])) {
+            fstat(STDIN_FILENO, &stb[i]);
+            gotstdin++;
+        } else
+            xstat(file[i], &stb[i]);
+    }
+    xfunc_error_retval = 1;
+    if (gotstdin && (S_ISDIR(stb[0].st_mode) || S_ISDIR(stb[1].st_mode)))
+        bb_error_msg_and_die("can't compare stdin to a directory");
+
+    if (S_ISDIR(stb[0].st_mode) && S_ISDIR(stb[1].st_mode)) {
 #if ENABLE_FEATURE_DIFF_DIR
-        diffdir(f1, f2);
+        diffdir(file, s_start);
 #else
-        bb_error_msg_and_die("directory comparison not supported");
+        bb_error_msg_and_die("no support for directory comparison");
 #endif
     } else {
-        if (S_ISDIR(stb1.st_mode)) {
-            f1 = concat_path_file(f1, f2);
-            xstat(f1, &stb1);
-        }
-        if (S_ISDIR(stb2.st_mode)) {
-            f2 = concat_path_file(f2, f1);
-            xstat(f2, &stb2);
-        }
-/* XXX: FIXME: */
-/* We can't diff e.g. stdin supplied by a pipe - we use rewind(), fseek().
- * This can be fixed (volunteers?) */
-        if (!S_ISREG(stb1.st_mode) || !S_ISREG(stb2.st_mode))
-            bb_error_msg_and_die("can't diff non-seekable stream");
-        print_status(diffreg(f1, f2, 0), f1, f2, NULL);
-    }
-    return status;
-}
+        bool dirfile = S_ISDIR(stb[0].st_mode) || S_ISDIR(stb[1].st_mode);
+        bool dir = S_ISDIR(stb[1].st_mode);
+        if (dirfile) {
+            const char *slash = strrchr(file[!dir], '/');
+            file[dir] = concat_path_file(file[dir], slash ? slash + 1 : file[!dir]);
+            xstat(file[dir], &stb[dir]);
+        }
+        /* diffreg can get non-regular files here */
+        print_status(gotstdin > 1 ? STATUS_SAME : diffreg(file), file);
+
+        if (dirfile)
+            free(file[dir]);
+    }
+
+    return exit_status;
+}

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

@@ -9 +9 @@
 
 #include "libbb.h"
-
-#define searchString bb_common_bufsiz1
-
-enum {
-    USERSIZE = sizeof(searchString) > 1024 ? 1024
-             : sizeof(searchString) - 1, /* max line length typed in by user */
-    INITBUF_SIZE = 1024, /* initial buffer size */
-};
 
 typedef struct LINE {
@@ -25 +17 @@
 } LINE;
 
-static LINE lines, *curLine;
-static int curNum, lastNum, marks[26], dirty;
-static char *bufBase, *bufPtr, *fileName;
-static int bufUsed, bufSize;
+
+#define searchString bb_common_bufsiz1
+
+enum {
+    USERSIZE = sizeof(searchString) > 1024 ? 1024
+             : sizeof(searchString) - 1, /* max line length typed in by user */
+    INITBUF_SIZE = 1024, /* initial buffer size */
+};
+
+struct globals {
+    int curNum;
+    int lastNum;
+    int bufUsed;
+    int bufSize;
+    LINE *curLine;
+    char *bufBase;
+    char *bufPtr;
+    char *fileName;
+    LINE lines;
+    smallint dirty;
+    int marks[26];
+};
+#define G (*ptr_to_globals)
+#define curLine            (G.curLine           )
+#define bufBase            (G.bufBase           )
+#define bufPtr             (G.bufPtr            )
+#define fileName           (G.fileName          )
+#define curNum             (G.curNum            )
+#define lastNum            (G.lastNum           )
+#define bufUsed            (G.bufUsed           )
+#define bufSize            (G.bufSize           )
+#define dirty              (G.dirty             )
+#define lines              (G.lines             )
+#define marks              (G.marks             )
+#define INIT_G() do { \
+    SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
+} while (0)
+
 
 static void doCommands(void);
 static void subCommand(const char *cmd, int num1, int num2);
-static int getNum(const char **retcp, int *retHaveNum, int *retNum);
+static int getNum(const char **retcp, smallint *retHaveNum, int *retNum);
 static int setCurNum(int num);
-static int initEdit(void);
-static void termEdit(void);
 static void addLines(int num);
 static int insertLine(int num, const char *data, int len);
-static int deleteLines(int num1, int num2);
+static void deleteLines(int num1, int num2);
 static int printLines(int num1, int num2, int expandFlag);
 static int writeLines(const char *file, int num1, int num2);
@@ -44 +68 @@
 static int searchLines(const char *str, int num1, int num2);
 static LINE *findLine(int num);
-
 static int findString(const LINE *lp, const char * str, int len, int offset);
 
-int ed_main(int argc, char **argv);
-int ed_main(int argc, char **argv)
-{
-    if (!initEdit())
-        return EXIT_FAILURE;
-
-    if (argc > 1) {
-        fileName = strdup(argv[1]);
-
-        if (fileName == NULL) {
-            bb_error_msg("no memory");
-            termEdit();
+
+static int bad_nums(int num1, int num2, const char *for_what)
+{
+    if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) {
+        bb_error_msg("bad line range for %s", for_what);
+        return 1;
+    }
+    return 0;
+}
+
+
+static char *skip_blank(const char *cp)
+{
+    while (isblank(*cp))
+        cp++;
+    return (char *)cp;
+}
+
+
+int ed_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int ed_main(int argc UNUSED_PARAM, char **argv)
+{
+    INIT_G();
+
+    bufSize = INITBUF_SIZE;
+    bufBase = xmalloc(bufSize);
+    bufPtr = bufBase;
+    lines.next = &lines;
+    lines.prev = &lines;
+
+    if (argv[1]) {
+        fileName = xstrdup(argv[1]);
+        if (!readLines(fileName, 1)) {
             return EXIT_SUCCESS;
         }
-
-        if (!readLines(fileName, 1)) {
-            termEdit();
-            return EXIT_SUCCESS;
-        }
-
         if (lastNum)
             setCurNum(1);
-
         dirty = FALSE;
     }
 
     doCommands();
-
-    termEdit();
     return EXIT_SUCCESS;
 }
@@ -85 +120 @@
 {
     const char *cp;
-    char *endbuf, *newname, buf[USERSIZE];
-    int len, num1, num2, have1, have2;
+    char *endbuf, buf[USERSIZE];
+    int len, num1, num2;
+    smallint have1, have2;
 
     while (TRUE) {
-        printf(": ");
-        fflush(stdout);
-
-        if (fgets(buf, sizeof(buf), stdin) == NULL)
+        /* Returns:
+         * -1 on read errors or EOF, or on bare Ctrl-D.
+         * 0  on ctrl-C,
+         * >0 length of input string, including terminating '\n'
+         */
+        len = read_line_input(": ", buf, sizeof(buf), NULL);
+        if (len <= 0)
             return;
-
-        len = strlen(buf);
-
-        if (len == 0)
-            return;
-
         endbuf = &buf[len - 1];
-
-        if (*endbuf != '\n') {
-            bb_error_msg("command line too long");
-
-            do {
-                len = fgetc(stdin);
-            } while ((len != EOF) && (len != '\n'));
-
-            continue;
-        }
-
         while ((endbuf > buf) && isblank(endbuf[-1]))
             endbuf--;
-
         *endbuf = '\0';
 
-        cp = buf;
-
-        while (isblank(*cp))
-            cp++;
-
+        cp = skip_blank(buf);
         have1 = FALSE;
         have2 = FALSE;
@@ -133 +150 @@
             continue;
 
-        while (isblank(*cp))
-            cp++;
+        cp = skip_blank(cp);
 
         if (*cp == ',') {
             cp++;
-
             if (!getNum(&cp, &have2, &num2))
                 continue;
-
             if (!have1)
                 num1 = 1;
-
             if (!have2)
                 num2 = lastNum;
-
             have1 = TRUE;
             have2 = TRUE;
         }
-
         if (!have1)
             num1 = curNum;
-
         if (!have2)
             num2 = num1;
 
         switch (*cp++) {
-            case 'a':
-                addLines(num1 + 1);
-                break;
-
-            case 'c':
-                deleteLines(num1, num2);
-                addLines(num1);
-                break;
-
-            case 'd':
-                deleteLines(num1, num2);
-                break;
-
-            case 'f':
-                if (*cp && !isblank(*cp)) {
-                    bb_error_msg("bad file command");
-                    break;
-                }
-
-                while (isblank(*cp))
-                    cp++;
-
-                if (*cp == '\0') {
-                    if (fileName)
-                        printf("\"%s\"\n", fileName);
-                    else
-                        printf("No file name\n");
-                    break;
-                }
-
-                newname = strdup(cp);
-
-                if (newname == NULL) {
-                    bb_error_msg("no memory for file name");
-                    break;
-                }
-
+        case 'a':
+            addLines(num1 + 1);
+            break;
+
+        case 'c':
+            deleteLines(num1, num2);
+            addLines(num1);
+            break;
+
+        case 'd':
+            deleteLines(num1, num2);
+            break;
+
+        case 'f':
+            if (*cp && !isblank(*cp)) {
+                bb_error_msg("bad file command");
+                break;
+            }
+            cp = skip_blank(cp);
+            if (*cp == '\0') {
                 if (fileName)
-                    free(fileName);
-
-                fileName = newname;
-                break;
-
-            case 'i':
-                addLines(num1);
-                break;
-
-            case 'k':
-                while (isblank(*cp))
-                    cp++;
-
-                if ((*cp < 'a') || (*cp > 'a') || cp[1]) {
-                    bb_error_msg("bad mark name");
-                    break;
-                }
-
-                marks[*cp - 'a'] = num2;
-                break;
-
-            case 'l':
-                printLines(num1, num2, TRUE);
-                break;
-
-            case 'p':
-                printLines(num1, num2, FALSE);
-                break;
-
-            case 'q':
-                while (isblank(*cp))
-                    cp++;
-
-                if (have1 || *cp) {
-                    bb_error_msg("bad quit command");
-                    break;
-                }
-
-                if (!dirty)
-                    return;
-
-                printf("Really quit? ");
-                fflush(stdout);
-
-                buf[0] = '\0';
-                fgets(buf, sizeof(buf), stdin);
-                cp = buf;
-
-                while (isblank(*cp))
-                    cp++;
-
-                if ((*cp == 'y') || (*cp == 'Y'))
-                    return;
-
-                break;
-
-            case 'r':
-                if (*cp && !isblank(*cp)) {
-                    bb_error_msg("bad read command");
-                    break;
-                }
-
-                while (isblank(*cp))
-                    cp++;
-
-                if (*cp == '\0') {
-                    bb_error_msg("no file name");
-                    break;
-                }
-
-                if (!have1)
-                    num1 = lastNum;
-
-                if (readLines(cp, num1 + 1))
-                    break;
-
-                if (fileName == NULL)
-                    fileName = strdup(cp);
-
-                break;
-
-            case 's':
-                subCommand(cp, num1, num2);
-                break;
-
-            case 'w':
-                if (*cp && !isblank(*cp)) {
-                    bb_error_msg("bad write command");
-                    break;
-                }
-
-                while (isblank(*cp))
-                    cp++;
-
-                if (!have1) {
-                    num1 = 1;
-                    num2 = lastNum;
-                }
-
-                if (*cp == '\0')
-                    cp = fileName;
-
-                if (cp == NULL) {
-                    bb_error_msg("no file name specified");
-                    break;
-                }
-
-                writeLines(cp, num1, num2);
-                break;
-
-            case 'z':
-                switch (*cp) {
-                case '-':
-                    printLines(curNum-21, curNum, FALSE);
-                    break;
-                case '.':
-                    printLines(curNum-11, curNum+10, FALSE);
-                    break;
-                default:
-                    printLines(curNum, curNum+21, FALSE);
-                    break;
-                }
-                break;
-
+                    printf("\"%s\"\n", fileName);
+                else
+                    printf("No file name\n");
+                break;
+            }
+            free(fileName);
+            fileName = xstrdup(cp);
+            break;
+
+        case 'i':
+            addLines(num1);
+            break;
+
+        case 'k':
+            cp = skip_blank(cp);
+            if ((*cp < 'a') || (*cp > 'z') || cp[1]) {
+                bb_error_msg("bad mark name");
+                break;
+            }
+            marks[*cp - 'a'] = num2;
+            break;
+
+        case 'l':
+            printLines(num1, num2, TRUE);
+            break;
+
+        case 'p':
+            printLines(num1, num2, FALSE);
+            break;
+
+        case 'q':
+            cp = skip_blank(cp);
+            if (have1 || *cp) {
+                bb_error_msg("bad quit command");
+                break;
+            }
+            if (!dirty)
+                return;
+            len = read_line_input("Really quit? ", buf, 16, NULL);
+            /* read error/EOF - no way to continue */
+            if (len < 0)
+                return;
+            cp = skip_blank(buf);
+            if ((*cp | 0x20) == 'y') /* Y or y */
+                return;
+            break;
+
+        case 'r':
+            if (*cp && !isblank(*cp)) {
+                bb_error_msg("bad read command");
+                break;
+            }
+            cp = skip_blank(cp);
+            if (*cp == '\0') {
+                bb_error_msg("no file name");
+                break;
+            }
+            if (!have1)
+                num1 = lastNum;
+            if (readLines(cp, num1 + 1))
+                break;
+            if (fileName == NULL)
+                fileName = xstrdup(cp);
+            break;
+
+        case 's':
+            subCommand(cp, num1, num2);
+            break;
+
+        case 'w':
+            if (*cp && !isblank(*cp)) {
+                bb_error_msg("bad write command");
+                break;
+            }
+            cp = skip_blank(cp);
+            if (!have1) {
+                num1 = 1;
+                num2 = lastNum;
+            }
+            if (*cp == '\0')
+                cp = fileName;
+            if (cp == NULL) {
+                bb_error_msg("no file name specified");
+                break;
+            }
+            writeLines(cp, num1, num2);
+            break;
+
+        case 'z':
+            switch (*cp) {
+            case '-':
+                printLines(curNum - 21, curNum, FALSE);
+                break;
             case '.':
-                if (have1) {
-                    bb_error_msg("no arguments allowed");
-                    break;
-                }
-
+                printLines(curNum - 11, curNum + 10, FALSE);
+                break;
+            default:
+                printLines(curNum, curNum + 21, FALSE);
+                break;
+            }
+            break;
+
+        case '.':
+            if (have1) {
+                bb_error_msg("no arguments allowed");
+                break;
+            }
+            printLines(curNum, curNum, FALSE);
+            break;
+
+        case '-':
+            if (setCurNum(curNum - 1))
                 printLines(curNum, curNum, FALSE);
-                break;
-
-            case '-':
-                if (setCurNum(curNum - 1))
-                    printLines(curNum, curNum, FALSE);
-
-                break;
-
-            case '=':
-                printf("%d\n", num1);
-                break;
-
-            case '\0':
-                if (have1) {
-                    printLines(num2, num2, FALSE);
-                    break;
-                }
-
-                if (setCurNum(curNum + 1))
-                    printLines(curNum, curNum, FALSE);
-
-                break;
-
-            default:
-                bb_error_msg("unimplemented command");
-                break;
+            break;
+
+        case '=':
+            printf("%d\n", num1);
+            break;
+        case '\0':
+            if (have1) {
+                printLines(num2, num2, FALSE);
+                break;
+            }
+            if (setCurNum(curNum + 1))
+                printLines(curNum, curNum, FALSE);
+            break;
+
+        default:
+            bb_error_msg("unimplemented command");
+            break;
         }
     }
@@ -363 +329 @@
  * The current line is set to the last substitution done.
  */
-static void subCommand(const char * cmd, int num1, int num2)
+static void subCommand(const char *cmd, int num1, int num2)
 {
     char *cp, *oldStr, *newStr, buf[USERSIZE];
@@ -370 +336 @@
     int globalFlag, printFlag, didSub, needPrint;
 
-    if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) {
-        bb_error_msg("bad line range for substitute");
+    if (bad_nums(num1, num2, "substitute"))
         return;
-    }
 
     globalFlag = FALSE;
@@ -395 +359 @@
 
     cp = strchr(cp, delim);
-
     if (cp == NULL) {
         bb_error_msg("missing 2nd delimiter for substitute");
@@ -415 +378 @@
             globalFlag = TRUE;
             break;
-
         case 'p':
             printFlag = TRUE;
             break;
-
         default:
             bb_error_msg("unknown option for substitute");
@@ -430 +391 @@
             return;
         }
-
         oldStr = searchString;
     }
@@ -438 +398 @@
 
     lp = findLine(num1);
-
     if (lp == NULL)
         return;
@@ -456 +415 @@
                 needPrint = FALSE;
             }
-
             offset = 0;
             lp = lp->next;
             num1++;
-
             continue;
         }
@@ -474 +431 @@
         if (deltaLen <= 0) {
             memcpy(&lp->data[offset], newStr, newLen);
-
             if (deltaLen) {
                 memcpy(&lp->data[offset + newLen],
@@ -482 +438 @@
                 lp->len += deltaLen;
             }
-
             offset += newLen;
-
             if (globalFlag)
                 continue;
-
             if (needPrint) {
                 printLines(num1, num1, FALSE);
                 needPrint = FALSE;
             }
-
             lp = lp->next;
             num1++;
-
             continue;
         }
@@ -504 +455 @@
          * the old line structure.
          */
-        nlp = (LINE *) malloc(sizeof(LINE) + lp->len + deltaLen);
-
-        if (nlp == NULL) {
-            bb_error_msg("cannot get memory for line");
-            return;
-        }
+        nlp = xmalloc(sizeof(LINE) + lp->len + deltaLen);
 
         nlp->len = lp->len + deltaLen;
 
         memcpy(nlp->data, lp->data, offset);
-
         memcpy(&nlp->data[offset], newStr, newLen);
-
         memcpy(&nlp->data[offset + newLen],
             &lp->data[offset + oldLen],
@@ -555 +499 @@
  * offset in the line.  Returns the offset of the found string, or -1.
  */
-static int findString( const LINE * lp, const char * str, int len, int offset)
+static int findString(const LINE *lp, const char *str, int len, int offset)
 {
     int left;
@@ -565 +509 @@
     while (left >= len) {
         ncp = memchr(cp, *str, left);
-
         if (ncp == NULL)
             return -1;
-
         left -= (ncp - cp);
-
         if (left < len)
             return -1;
-
         cp = ncp;
-
         if (memcmp(cp, str, len) == 0)
             return (cp - lp->data);
-
         cp++;
         left--;
@@ -598 +536 @@
     char buf[USERSIZE + 1];
 
-    while (fgets(buf, sizeof(buf), stdin)) {
+    while (1) {
+        /* Returns:
+         * -1 on read errors or EOF, or on bare Ctrl-D.
+         * 0  on ctrl-C,
+         * >0 length of input string, including terminating '\n'
+         */
+        len = read_line_input("", buf, sizeof(buf), NULL);
+        if (len <= 0) {
+            /* Previously, ctrl-C was exiting to shell.
+             * Now we exit to ed prompt. Is in important? */
+            return;
+        }
         if ((buf[0] == '.') && (buf[1] == '\n') && (buf[2] == '\0'))
             return;
-
-        len = strlen(buf);
-
-        if (len == 0)
-            return;
-
-        if (buf[len - 1] != '\n') {
-            bb_error_msg("line too long");
-            do {
-                len = fgetc(stdin);
-            } while ((len != EOF) && (len != '\n'));
-            return;
-        }
-
         if (!insertLine(num++, buf, len))
             return;
@@ -629 +564 @@
  * The character pointer which stopped the scan is also returned.
  */
-static int getNum(const char **retcp, int *retHaveNum, int *retNum)
+static int getNum(const char **retcp, smallint *retHaveNum, int *retNum)
 {
     const char *cp;
     char *endStr, str[USERSIZE];
-    int haveNum, value, num, sign;
+    int value, num;
+    smallint haveNum, minus;
 
     cp = *retcp;
+    value = 0;
     haveNum = FALSE;
-    value = 0;
-    sign = 1;
+    minus = 0;
 
     while (TRUE) {
-        while (isblank(*cp))
-            cp++;
+        cp = skip_blank(cp);
 
         switch (*cp) {
@@ -659 +594 @@
             case '\'':
                 cp++;
-
                 if ((*cp < 'a') || (*cp > 'z')) {
                     bb_error_msg("bad mark name");
                     return FALSE;
                 }
-
                 haveNum = TRUE;
                 num = marks[*cp++ - 'a'];
@@ -672 +605 @@
                 strcpy(str, ++cp);
                 endStr = strchr(str, '/');
-
                 if (endStr) {
                     *endStr++ = '\0';
                     cp += (endStr - str);
-                }
-                else
+                } else
                     cp = "";
-
                 num = searchLines(str, curNum, lastNum);
-
                 if (num == 0)
                     return FALSE;
-
                 haveNum = TRUE;
                 break;
@@ -695 +623 @@
                     return TRUE;
                 }
-
                 num = 0;
-
                 while (isdigit(*cp))
                     num = num * 10 + *cp++ - '0';
-
                 haveNum = TRUE;
                 break;
         }
 
-        value += num * sign;
-
-        while (isblank(*cp))
-            cp++;
+        value += (minus ? -num : num);
+
+        cp = skip_blank(cp);
 
         switch (*cp) {
             case '-':
-                sign = -1;
+                minus = 1;
                 cp++;
                 break;
 
             case '+':
-                sign = 1;
+                minus = 0;
                 cp++;
                 break;
@@ -732 +656 @@
 
 /*
- * Initialize everything for editing.
- */
-static int initEdit(void)
-{
-    int i;
-
-    bufSize = INITBUF_SIZE;
-    bufBase = malloc(bufSize);
-
-    if (bufBase == NULL) {
-        bb_error_msg("no memory for buffer");
-        return FALSE;
-    }
-
-    bufPtr = bufBase;
-    bufUsed = 0;
-
-    lines.next = &lines;
-    lines.prev = &lines;
-
-    curLine = NULL;
-    curNum = 0;
-    lastNum = 0;
-    dirty = FALSE;
-    fileName = NULL;
-    searchString[0] = '\0';
-
-    for (i = 0; i < 26; i++)
-        marks[i] = 0;
-
-    return TRUE;
-}
-
-
-/*
- * Finish editing.
- */
-static void termEdit(void)
-{
-    if (bufBase)
-        free(bufBase);
-
-    bufBase = NULL;
-    bufPtr = NULL;
-    bufSize = 0;
-    bufUsed = 0;
-
-    if (fileName)
-        free(fileName);
-
-    fileName = NULL;
-
-    searchString[0] = '\0';
-
-    if (lastNum)
-        deleteLines(1, lastNum);
-
-    lastNum = 0;
-    curNum = 0;
-    curLine = NULL;
-}
-
-
-/*
  * Read lines from a file at the specified line number.
  * Returns TRUE if the file was successfully read.
  */
-static int readLines(const char * file, int num)
+static int readLines(const char *file, int num)
 {
     int fd, cc;
@@ -811 +671 @@
 
     fd = open(file, 0);
-
     if (fd < 0) {
-        perror(file);
+        bb_simple_perror_msg(file);
         return FALSE;
     }
@@ -824 +683 @@
 
     printf("\"%s\", ", file);
-    fflush(stdout);
+    fflush_all();
 
     do {
@@ -831 +690 @@
         if (cp) {
             len = (cp - bufPtr) + 1;
-
             if (!insertLine(num, bufPtr, len)) {
                 close(fd);
                 return FALSE;
             }
-
             bufPtr += len;
             bufUsed -= len;
@@ -842 +699 @@
             lineCount++;
             num++;
-
             continue;
         }
@@ -853 +709 @@
         if (bufUsed >= bufSize) {
             len = (bufSize * 3) / 2;
-            cp = realloc(bufBase, len);
-
-            if (cp == NULL) {
-                bb_error_msg("no memory for buffer");
-                close(fd);
-                return FALSE;
-            }
-
+            cp = xrealloc(bufBase, len);
             bufBase = cp;
             bufPtr = bufBase + bufUsed;
@@ -866 +715 @@
         }
 
-        cc = read(fd, bufPtr, bufSize - bufUsed);
+        cc = safe_read(fd, bufPtr, bufSize - bufUsed);
         bufUsed += cc;
         bufPtr = bufBase;
@@ -873 +722 @@
 
     if (cc < 0) {
-        perror(file);
+        bb_simple_perror_msg(file);
         close(fd);
         return FALSE;
@@ -883 +732 @@
             return -1;
         }
-
         lineCount++;
         charCount += bufUsed;
@@ -901 +749 @@
  * Returns TRUE if successful, or FALSE on an error with a message output.
  */
-static int writeLines(const char * file, int num1, int num2)
+static int writeLines(const char *file, int num1, int num2)
 {
     LINE *lp;
     int fd, lineCount, charCount;
 
-    if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) {
-        bb_error_msg("bad line range for write");
+    if (bad_nums(num1, num2, "write"))
         return FALSE;
-    }
 
     lineCount = 0;
@@ -915 +761 @@
 
     fd = creat(file, 0666);
-
     if (fd < 0) {
-        perror(file);
+        bb_simple_perror_msg(file);
         return FALSE;
     }
 
     printf("\"%s\", ", file);
-    fflush(stdout);
+    fflush_all();
 
     lp = findLine(num1);
-
     if (lp == NULL) {
         close(fd);
@@ -932 +776 @@
 
     while (num1++ <= num2) {
-        if (write(fd, lp->data, lp->len) != lp->len) {
-            perror(file);
+        if (full_write(fd, lp->data, lp->len) != lp->len) {
+            bb_simple_perror_msg(file);
             close(fd);
             return FALSE;
         }
-
         charCount += lp->len;
         lineCount++;
@@ -944 +787 @@
 
     if (close(fd) < 0) {
-        perror(file);
+        bb_simple_perror_msg(file);
         return FALSE;
     }
@@ -965 +808 @@
     int ch, count;
 
-    if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) {
-        bb_error_msg("bad line range for print");
+    if (bad_nums(num1, num2, "print"))
         return FALSE;
-    }
 
     lp = findLine(num1);
-
     if (lp == NULL)
         return FALSE;
@@ -977 +817 @@
     while (num1 <= num2) {
         if (!expandFlag) {
-            write(1, lp->data, lp->len);
+            write(STDOUT_FILENO, lp->data, lp->len);
             setCurNum(num1++);
             lp = lp->next;
-
             continue;
         }
@@ -995 +834 @@
 
         while (count-- > 0) {
-            ch = *cp++;
-
-            if (ch & 0x80) {
-                fputs("M-", stdout);
-                ch &= 0x7f;
-            }
-
-            if (ch < ' ') {
-                fputc('^', stdout);
-                ch += '@';
-            }
-
-            if (ch == 0x7f) {
-                fputc('^', stdout);
-                ch = '?';
-            }
-
-            fputc(ch, stdout);
+            ch = (unsigned char) *cp++;
+            fputc_printable(ch | PRINTABLE_META, stdout);
         }
 
@@ -1032 +855 @@
  * Returns TRUE if successful.
  */
-static int insertLine(int num, const char * data, int len)
+static int insertLine(int num, const char *data, int len)
 {
     LINE *newLp, *lp;
@@ -1041 +864 @@
     }
 
-    newLp = malloc(sizeof(LINE) + len - 1);
-
-    if (newLp == NULL) {
-        bb_error_msg("failed to allocate memory for line");
-        return FALSE;
-    }
+    newLp = xmalloc(sizeof(LINE) + len - 1);
 
     memcpy(newLp->data, data, len);
@@ -1055 +873 @@
     else {
         lp = findLine(num);
-
         if (lp == NULL) {
             free((char *) newLp);
@@ -1076 +893 @@
  * Delete lines from the given range.
  */
-static int deleteLines(int num1, int num2)
+static void deleteLines(int num1, int num2)
 {
     LINE *lp, *nlp, *plp;
     int count;
 
-    if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) {
-        bb_error_msg("bad line numbers for delete");
-        return FALSE;
-    }
+    if (bad_nums(num1, num2, "delete"))
+        return;
 
     lp = findLine(num1);
-
     if (lp == NULL)
-        return FALSE;
+        return;
 
     if ((curNum >= num1) && (curNum <= num2)) {
@@ -1101 +915 @@
 
     count = num2 - num1 + 1;
-
     if (curNum > num2)
         curNum -= count;
-
     lastNum -= count;
 
@@ -1112 +924 @@
         plp->next = nlp;
         nlp->prev = plp;
-        lp->next = NULL;
-        lp->prev = NULL;
-        lp->len = 0;
         free(lp);
         lp = nlp;
@@ -1120 +929 @@
 
     dirty = TRUE;
-
-    return TRUE;
 }
 
@@ -1127 +934 @@
 /*
  * Search for a line which contains the specified string.
- * If the string is NULL, then the previously searched for string
+ * If the string is "", then the previously searched for string
  * is used.  The currently searched for string is saved for future use.
  * Returns the line number which matches, or 0 if there was no match
  * with an error printed.
  */
-static int searchLines(const char *str, int num1, int num2)
+static NOINLINE int searchLines(const char *str, int num1, int num2)
 {
     const LINE *lp;
     int len;
 
-    if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) {
-        bb_error_msg("bad line numbers for search");
+    if (bad_nums(num1, num2, "search"))
         return 0;
-    }
 
     if (*str == '\0') {
@@ -1147 +952 @@
             return 0;
         }
-
         str = searchString;
     }
@@ -1157 +961 @@
 
     lp = findLine(num1);
-
     if (lp == NULL)
         return 0;
@@ -1164 +967 @@
         if (findString(lp, str, len, 0) >= 0)
             return num1;
-
         num1++;
         lp = lp->next;
     }
 
-    bb_error_msg("cannot find string \"%s\"", str);
+    bb_error_msg("can't find string \"%s\"", str);
     return 0;
 }
@@ -1197 +999 @@
     lp = curLine;
     lnum = curNum;
-
     if (num < (curNum / 2)) {
         lp = lines.next;
         lnum = 1;
-    }
-    else if (num > ((curNum + lastNum) / 2)) {
+    } else if (num > ((curNum + lastNum) / 2)) {
         lp = lines.prev;
         lnum = lastNum;
@@ -1229 +1029 @@
 
     lp = findLine(num);
-
     if (lp == NULL)
         return FALSE;
-
     curNum = num;
     curLine = lp;

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

@@ -1 @@
-/* vi: set sw=4 ts=4: */
-/*
- *  busybox patch applet to handle the unified diff format.
- *  Copyright (C) 2003 Glenn McGrath <bug1@iinet.net.au>
+/* vi: set sw=4 ts=4:
  *
- *  Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Apply a "universal" diff.
+ * Adapted from toybox's patch implementation.
  *
- *  This applet is written to work with patches generated by GNU diff,
- *  where there is equivalent functionality busybox patch shall behave
- *  as per GNU patch.
+ * Copyright 2007 Rob Landley <rob@landley.net>
  *
- *  There is a SUSv3 specification for patch, however it looks to be
- *  incomplete, it doesnt even mention unified diff format.
- *  http://www.opengroup.org/onlinepubs/007904975/utilities/patch.html
+ * see http://www.opengroup.org/onlinepubs/009695399/utilities/patch.html
+ * (But only does -u, because who still cares about "ed"?)
  *
- *  Issues
- *   - Non-interactive
- *   - Patches must apply cleanly or patch (not just one hunk) will fail.
- *   - Reject file isnt saved
+ * TODO:
+ * -b backup
+ * -l treat all whitespace as a single space
+ * -d chdir first
+ * -D define wrap #ifdef and #ifndef around changes
+ * -o outfile output here instead of in place
+ * -r rejectfile write rejected hunks to this file
+ *
+ * -f force (no questions asked)
+ * -F fuzz (number, default 2)
+ * [file] which file to patch
  */
 
-#include <getopt.h>
+//applet:IF_PATCH(APPLET(patch, _BB_DIR_USR_BIN, _BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_PATCH) += patch.o
+
+//config:config PATCH
+//config:   bool "patch"
+//config:   default y
+//config:   help
+//config:     Apply a unified diff formatted patch.
+
+//usage:#define patch_trivial_usage
+//usage:       "[OPTIONS] [ORIGFILE [PATCHFILE]]"
+//usage:#define patch_full_usage "\n\n"
+//usage:    IF_LONG_OPTS(
+//usage:       "    -p,--strip N        Strip N leading components from file names"
+//usage:     "\n    -i,--input DIFF     Read DIFF instead of stdin"
+//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    -E,--remove-empty-files Remove output files if they become empty"
+//usage:    )
+//usage:    IF_NOT_LONG_OPTS(
+//usage:       "    -p N    Strip N leading components from file names"
+//usage:     "\n    -i DIFF Read DIFF instead of stdin"
+//usage:     "\n    -R  Reverse patch"
+//usage:     "\n    -N  Ignore already applied patches"
+//usage:     "\n    -E  Remove output files if they become empty"
+//usage:    )
+//usage:
+//usage:#define patch_example_usage
+//usage:       "$ patch -p1 < example.diff\n"
+//usage:       "$ patch -p0 -i example.diff"
 
 #include "libbb.h"
 
-static unsigned int copy_lines(FILE *src_stream, FILE *dest_stream, const unsigned int lines_count)
-{
-    unsigned int i = 0;
-
-    while (src_stream && (i < lines_count)) {
-        char *line;
-        line = xmalloc_fgets(src_stream);
-        if (line == NULL) {
-            break;
-        }
-        if (fputs(line, dest_stream) == EOF) {
-            bb_perror_msg_and_die("error writing to new file");
-        }
-        free(line);
-
-        i++;
-    }
-    return i;
-}
-
-/* If patch_level is -1 it will remove all directory names
- * char *line must be greater than 4 chars
- * returns NULL if the file doesnt exist or error
- * returns malloc'ed filename
- */
-
-static char *extract_filename(char *line, int patch_level)
-{
-    char *temp, *filename_start_ptr = line + 4;
-    int i;
-
-    /* Terminate string at end of source filename */
-    temp = strchrnul(filename_start_ptr, '\t');
-    *temp = '\0';
-
-    /* Skip over (patch_level) number of leading directories */
-    if (patch_level == -1)
-        patch_level = INT_MAX;
-    for (i = 0; i < patch_level; i++) {
-        temp = strchr(filename_start_ptr, '/');
-        if (!temp)
-            break;
-        filename_start_ptr = temp + 1;
-    }
-
-    return xstrdup(filename_start_ptr);
-}
-
-static int file_doesnt_exist(const char *filename)
-{
-    struct stat statbuf;
-    return stat(filename, &statbuf);
-}
-
-int patch_main(int argc, char **argv);
-int patch_main(int argc, char **argv)
-{
-    int patch_level = -1;
-    char *patch_line;
-    int ret;
-    FILE *patch_file = NULL;
-
-    {
-        char *p, *i;
-        ret = getopt32(argv, "p:i:", &p, &i);
-        if (ret & 1)
-            patch_level = xatol_range(p, -1, USHRT_MAX);
-        if (ret & 2) {
-            patch_file = xfopen(i, "r");
-        } else {
-            patch_file = stdin;
-        }
-        ret = 0;
-    }
-
-    patch_line = xmalloc_getline(patch_file);
-    while (patch_line) {
-        FILE *src_stream;
-        FILE *dst_stream;
-        char *original_filename;
-        char *new_filename;
-        char *backup_filename;
-        unsigned int src_cur_line = 1;
-        unsigned int dest_cur_line = 0;
-        unsigned int dest_beg_line;
-        unsigned int bad_hunk_count = 0;
-        unsigned int hunk_count = 0;
-        char copy_trailing_lines_flag = 0;
-
-        /* Skip everything upto the "---" marker
-         * No need to parse the lines "Only in <dir>", and "diff <args>"
-         */
-        while (patch_line && strncmp(patch_line, "--- ", 4) != 0) {
-            free(patch_line);
-            patch_line = xmalloc_getline(patch_file);
-        }
-        /* FIXME: patch_line NULL check?? */
-
-        /* Extract the filename used before the patch was generated */
-        original_filename = extract_filename(patch_line, patch_level);
-        free(patch_line);
-
-        patch_line = xmalloc_getline(patch_file);
-        /* FIXME: NULL check?? */
-        if (strncmp(patch_line, "+++ ", 4) != 0) {
-            ret = 2;
-            bb_error_msg("invalid patch");
-            continue;
-        }
-        new_filename = extract_filename(patch_line, patch_level);
-        free(patch_line);
-
-        if (file_doesnt_exist(new_filename)) {
-            char *line_ptr;
-            /* Create leading directories */
-            line_ptr = strrchr(new_filename, '/');
-            if (line_ptr) {
-                *line_ptr = '\0';
-                bb_make_directory(new_filename, -1, FILEUTILS_RECUR);
-                *line_ptr = '/';
+
+// libbb candidate?
+
+struct double_list {
+    struct double_list *next;
+    struct double_list *prev;
+    char *data;
+};
+
+// 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))
+{
+    while (list) {
+        void *pop = list;
+        list = list->next;
+        freeit(pop);
+        // Bail out also if list is circular.
+        if (list == pop) break;
+    }
+}
+
+// Add an entry before "list" element in (circular) doubly linked list
+static
+struct double_list *dlist_add(struct double_list **list, char *data)
+{
+    struct double_list *llist;
+    struct double_list *line = xmalloc(sizeof(*line));
+
+    line->data = data;
+    llist = *list;
+    if (llist) {
+        struct double_list *p;
+        line->next = llist;
+        p = line->prev = llist->prev;
+        // (list is circular, we assume p is never NULL)
+        p->next = line;
+        llist->prev = line;
+    } else
+        *list = line->next = line->prev = line;
+
+    return line;
+}
+
+
+struct globals {
+    char *infile;
+    long prefix;
+
+    struct double_list *current_hunk;
+
+    long oldline, oldlen, newline, newlen;
+    long linenum;
+    int context, state, hunknum;
+    int filein, fileout;
+    char *tempname;
+
+    int exitval;
+};
+#define TT (*ptr_to_globals)
+#define INIT_TT() do { \
+    SET_PTR_TO_GLOBALS(xzalloc(sizeof(TT))); \
+} while (0)
+
+
+#define FLAG_STR "Rup:i:NEx"
+/* FLAG_REVERSE must be == 1! Code uses this fact. */
+#define FLAG_REVERSE (1 << 0)
+#define FLAG_u       (1 << 1)
+#define FLAG_PATHLEN (1 << 2)
+#define FLAG_INPUT   (1 << 3)
+#define FLAG_IGNORE  (1 << 4)
+#define FLAG_RMEMPTY (1 << 5)
+//non-standard:
+#define FLAG_DEBUG   (1 << 6)
+
+// Dispose of a line of input, either by writing it out or discarding it.
+
+// state < 2: just free
+// state = 2: write whole line to stderr
+// state = 3: write whole line to fileout
+// state > 3: write line+1 to fileout when *line != state
+
+#define PATCH_DEBUG (option_mask32 & FLAG_DEBUG)
+
+static void do_line(void *data)
+{
+    struct double_list *dlist = data;
+
+    if (TT.state>1 && *dlist->data != TT.state)
+        fdprintf(TT.state == 2 ? 2 : TT.fileout,
+            "%s\n", dlist->data+(TT.state>3 ? 1 : 0));
+
+    if (PATCH_DEBUG) fdprintf(2, "DO %d: %s\n", TT.state, dlist->data);
+
+    free(dlist->data);
+    free(dlist);
+}
+
+static void finish_oldfile(void)
+{
+    if (TT.tempname) {
+        // Copy the rest of the data and replace the original with the copy.
+        char *temp;
+
+        if (TT.filein != -1) {
+            bb_copyfd_eof(TT.filein, TT.fileout);
+            xclose(TT.filein);
+        }
+        xclose(TT.fileout);
+
+        temp = xstrdup(TT.tempname);
+        temp[strlen(temp) - 6] = '\0';
+        rename(TT.tempname, temp);
+        free(temp);
+
+        free(TT.tempname);
+        TT.tempname = NULL;
+    }
+    TT.fileout = TT.filein = -1;
+}
+
+static void fail_hunk(void)
+{
+    if (!TT.current_hunk) return;
+
+    fdprintf(2, "Hunk %d FAILED %ld/%ld.\n", TT.hunknum, TT.oldline, TT.newline);
+    TT.exitval = 1;
+
+    // If we got to this point, we've seeked to the end.  Discard changes to
+    // this file and advance to next file.
+
+    TT.state = 2;
+    TT.current_hunk->prev->next = NULL;
+    dlist_free(TT.current_hunk, do_line);
+    TT.current_hunk = NULL;
+
+    // Abort the copy and delete the temporary file.
+    close(TT.filein);
+    close(TT.fileout);
+    unlink(TT.tempname);
+    free(TT.tempname);
+    TT.tempname = NULL;
+
+    TT.state = 0;
+}
+
+// Given a hunk of a unified diff, make the appropriate change to the file.
+// This does not use the location information, but instead treats a hunk
+// as a sort of regex.  Copies data from input to output until it finds
+// the change to be made, then outputs the changed data and returns.
+// (Finding EOF first is an error.)  This is a single pass operation, so
+// multiple hunks must occur in order in the file.
+
+static int apply_one_hunk(void)
+{
+    struct double_list *plist, *buf = NULL, *check;
+    int matcheof = 0, reverse = option_mask32 & FLAG_REVERSE, backwarn = 0;
+    /* Do we try "dummy" revert to check whether
+     * to silently skip this hunk? Used to implement -N.
+     */
+    int dummy_revert = 0;
+
+    // Break doubly linked list so we can use singly linked traversal function.
+    TT.current_hunk->prev->next = NULL;
+
+    // Match EOF if there aren't as many ending context lines as beginning
+    for (plist = TT.current_hunk; plist; plist = plist->next) {
+        if (plist->data[0]==' ') matcheof++;
+        else matcheof = 0;
+        if (PATCH_DEBUG) fdprintf(2, "HUNK:%s\n", plist->data);
+    }
+    matcheof = matcheof < TT.context;
+
+    if (PATCH_DEBUG) fdprintf(2,"MATCHEOF=%c\n", matcheof ? 'Y' : 'N');
+
+    // Loop through input data searching for this hunk.  Match all context
+    // lines and all lines to be removed until we've found the end of a
+    // complete hunk.
+    plist = TT.current_hunk;
+    buf = NULL;
+    if (TT.context) for (;;) {
+        char *data = xmalloc_reads(TT.filein, NULL, NULL);
+
+        TT.linenum++;
+
+        // Figure out which line of hunk to compare with next.  (Skip lines
+        // of the hunk we'd be adding.)
+        while (plist && *plist->data == "+-"[reverse]) {
+            if (data && !strcmp(data, plist->data+1)) {
+                if (!backwarn) {
+                    backwarn = TT.linenum;
+                    if (option_mask32 & FLAG_IGNORE) {
+                        dummy_revert = 1;
+                        reverse ^= 1;
+                        continue;
+                    }
+                }
             }
-            dst_stream = xfopen(new_filename, "w+");
-            backup_filename = NULL;
-        } else {
-            backup_filename = xmalloc(strlen(new_filename) + 6);
-            strcpy(backup_filename, new_filename);
-            strcat(backup_filename, ".orig");
-            if (rename(new_filename, backup_filename) == -1) {
-                bb_perror_msg_and_die("cannot create file %s",
-                        backup_filename);
-            }
-            dst_stream = xfopen(new_filename, "w");
-        }
-
-        if ((backup_filename == NULL) || file_doesnt_exist(original_filename)) {
-            src_stream = NULL;
-        } else {
-            if (strcmp(original_filename, new_filename) == 0) {
-                src_stream = xfopen(backup_filename, "r");
-            } else {
-                src_stream = xfopen(original_filename, "r");
-            }
-        }
-
-        printf("patching file %s\n", new_filename);
-
-        /* Handle each hunk */
-        patch_line = xmalloc_fgets(patch_file);
-        while (patch_line) {
-            unsigned int count;
-            unsigned int src_beg_line;
-            unsigned int unused;
-            unsigned int hunk_offset_start = 0;
-            int hunk_error = 0;
-
-            /* This bit should be improved */
-            if ((sscanf(patch_line, "@@ -%d,%d +%d,%d @@", &src_beg_line, &unused, &dest_beg_line, &unused) != 4) &&
-                (sscanf(patch_line, "@@ -%d,%d +%d @@", &src_beg_line, &unused, &dest_beg_line) != 3) &&
-                (sscanf(patch_line, "@@ -%d +%d,%d @@", &src_beg_line, &dest_beg_line, &unused) != 3)) {
-                /* No more hunks for this file */
-                break;
-            }
-            free(patch_line);
-            hunk_count++;
-
-            if (src_beg_line && dest_beg_line) {
-                /* Copy unmodified lines upto start of hunk */
-                /* src_beg_line will be 0 if its a new file */
-                count = src_beg_line - src_cur_line;
-                if (copy_lines(src_stream, dst_stream, count) != count) {
-                    bb_error_msg_and_die("bad src file");
-                }
-                src_cur_line += count;
-                dest_cur_line += count;
-                copy_trailing_lines_flag = 1;
-            }
-            hunk_offset_start = src_cur_line;
-
-            while ((patch_line = xmalloc_fgets(patch_file)) != NULL) {
-                if ((*patch_line == '-') || (*patch_line == ' ')) {
-                    char *src_line = NULL;
-                    if (src_stream) {
-                        src_line = xmalloc_fgets(src_stream);
-                        if (!src_line) {
-                            hunk_error++;
-                            break;
-                        } else {
-                            src_cur_line++;
-                        }
-                        if (strcmp(src_line, patch_line + 1) != 0) {
-                            bb_error_msg("hunk #%d FAILED at %d", hunk_count, hunk_offset_start);
-                            hunk_error++;
-                            free(patch_line);
-                            /* Probably need to find next hunk, etc... */
-                            /* but for now we just bail out */
-                            patch_line = NULL;
-                            break;
-                        }
-                        free(src_line);
-                    }
-                    if (*patch_line == ' ') {
-                        fputs(patch_line + 1, dst_stream);
-                        dest_cur_line++;
-                    }
-                } else if (*patch_line == '+') {
-                    fputs(patch_line + 1, dst_stream);
-                    dest_cur_line++;
-                } else {
+            plist = plist->next;
+        }
+
+        // Is this EOF?
+        if (!data) {
+            if (PATCH_DEBUG) fdprintf(2, "INEOF\n");
+
+            // Does this hunk need to match EOF?
+            if (!plist && matcheof) break;
+
+            if (backwarn)
+                fdprintf(2,"Possibly reversed hunk %d at %ld\n",
+                    TT.hunknum, TT.linenum);
+
+            // File ended before we found a place for this hunk.
+            fail_hunk();
+            goto done;
+        }
+
+        if (PATCH_DEBUG) fdprintf(2, "IN: %s\n", data);
+        check = dlist_add(&buf, data);
+
+        // Compare this line with next expected line of hunk.
+        // todo: teach the strcmp() to ignore whitespace.
+
+        // A match can fail because the next line doesn't match, or because
+        // we hit the end of a hunk that needed EOF, and this isn't EOF.
+
+        // If match failed, flush first line of buffered data and
+        // recheck buffered data for a new match until we find one or run
+        // out of buffer.
+
+        for (;;) {
+            if (!plist || strcmp(check->data, plist->data+1)) {
+                // Match failed.  Write out first line of buffered data and
+                // recheck remaining buffered data for a new match.
+
+                if (PATCH_DEBUG)
+                    fdprintf(2, "NOT: %s\n", plist->data);
+
+                TT.state = 3;
+                check = buf;
+                buf = buf->next;
+                check->prev->next = buf;
+                buf->prev = check->prev;
+                do_line(check);
+                plist = TT.current_hunk;
+
+                // If we've reached the end of the buffer without confirming a
+                // match, read more lines.
+                if (check == buf) {
+                    buf = NULL;
                     break;
                 }
-                free(patch_line);
+                check = buf;
+            } else {
+                if (PATCH_DEBUG)
+                    fdprintf(2, "MAYBE: %s\n", plist->data);
+                // This line matches.  Advance plist, detect successful match.
+                plist = plist->next;
+                if (!plist && !matcheof) goto out;
+                check = check->next;
+                if (check == buf) break;
             }
-            if (hunk_error) {
-                bad_hunk_count++;
+        }
+    }
+out:
+    // We have a match.  Emit changed data.
+    TT.state = "-+"[reverse ^ dummy_revert];
+    dlist_free(TT.current_hunk, do_line);
+    TT.current_hunk = NULL;
+    TT.state = 1;
+done:
+    if (buf) {
+        buf->prev->next = NULL;
+        dlist_free(buf, do_line);
+    }
+
+    return TT.state;
+}
+
+// Read a patch file and find hunks, opening/creating/deleting files.
+// Call apply_one_hunk() on each hunk.
+
+// state 0: Not in a hunk, look for +++.
+// state 1: Found +++ file indicator, look for @@
+// state 2: In hunk: counting initial context lines
+// state 3: In hunk: getting body
+
+int patch_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int patch_main(int argc UNUSED_PARAM, char **argv)
+{
+    int opts;
+    int reverse, state = 0;
+    char *oldname = NULL, *newname = NULL;
+    char *opt_p, *opt_i;
+
+    INIT_TT();
+
+    opts = getopt32(argv, FLAG_STR, &opt_p, &opt_i);
+    argv += optind;
+    reverse = opts & FLAG_REVERSE;
+    TT.prefix = (opts & FLAG_PATHLEN) ? xatoi(opt_p) : 0; // can be negative!
+    TT.filein = TT.fileout = -1;
+    if (opts & FLAG_INPUT) {
+        xmove_fd(xopen_stdin(opt_i), STDIN_FILENO);
+    } else {
+        if (argv[0] && argv[1]) {
+            xmove_fd(xopen_stdin(argv[1]), STDIN_FILENO);
+        }
+    }
+    if (argv[0]) {
+        oldname = xstrdup(argv[0]);
+        newname = xstrdup(argv[0]);
+    }
+
+    // Loop through the lines in the patch
+    for(;;) {
+        char *patchline;
+
+        patchline = xmalloc_fgetline(stdin);
+        if (!patchline) break;
+
+        // Other versions of patch accept damaged patches,
+        // so we need to also.
+        if (!*patchline) {
+            free(patchline);
+            patchline = xstrdup(" ");
+        }
+
+        // Are we assembling a hunk?
+        if (state >= 2) {
+            if (*patchline==' ' || *patchline=='+' || *patchline=='-') {
+                dlist_add(&TT.current_hunk, patchline);
+
+                if (*patchline != '+') TT.oldlen--;
+                if (*patchline != '-') TT.newlen--;
+
+                // Context line?
+                if (*patchline==' ' && state==2) TT.context++;
+                else state=3;
+
+                // If we've consumed all expected hunk lines, apply the hunk.
+
+                if (!TT.oldlen && !TT.newlen) state = apply_one_hunk();
+                continue;
             }
-        }
-
-        /* Cleanup last patched file */
-        if (copy_trailing_lines_flag) {
-            copy_lines(src_stream, dst_stream, -1);
-        }
-        if (src_stream) {
-            fclose(src_stream);
-        }
-        if (dst_stream) {
-            fclose(dst_stream);
-        }
-        if (bad_hunk_count) {
-            if (!ret) {
-                ret = 1;
+            fail_hunk();
+            state = 0;
+            continue;
+        }
+
+        // Open a new file?
+        if (!strncmp("--- ", patchline, 4) || !strncmp("+++ ", patchline, 4)) {
+            char *s, **name = reverse ? &newname : &oldname;
+            int i;
+
+            if (*patchline == '+') {
+                name = reverse ? &oldname : &newname;
+                state = 1;
             }
-            bb_error_msg("%d out of %d hunk FAILED", bad_hunk_count, hunk_count);
-        } else {
-            /* It worked, we can remove the backup */
-            if (backup_filename) {
-                unlink(backup_filename);
+
+            finish_oldfile();
+
+            if (!argv[0]) {
+                free(*name);
+                // Trim date from end of filename (if any).  We don't care.
+                for (s = patchline+4; *s && *s!='\t'; s++)
+                    if (*s=='\\' && s[1]) s++;
+                i = atoi(s);
+                if (i>1900 && i<=1970)
+                    *name = xstrdup("/dev/null");
+                else {
+                    *s = 0;
+                    *name = xstrdup(patchline+4);
+                }
             }
-            if ((dest_cur_line == 0) || (dest_beg_line == 0)) {
-                /* The new patched file is empty, remove it */
-                xunlink(new_filename);
-                if (strcmp(new_filename, original_filename) != 0)
-                    xunlink(original_filename);
+
+            // We defer actually opening the file because svn produces broken
+            // patches that don't signal they want to create a new file the
+            // way the patch man page says, so you have to read the first hunk
+            // and _guess_.
+
+        // Start a new hunk?  Usually @@ -oldline,oldlen +newline,newlen @@
+        // but a missing ,value means the value is 1.
+        } else if (state == 1 && !strncmp("@@ -", patchline, 4)) {
+            int i;
+            char *s = patchline+4;
+
+            // Read oldline[,oldlen] +newline[,newlen]
+
+            TT.oldlen = TT.newlen = 1;
+            TT.oldline = strtol(s, &s, 10);
+            if (*s == ',') TT.oldlen=strtol(s+1, &s, 10);
+            TT.newline = strtol(s+2, &s, 10);
+            if (*s == ',') TT.newlen = strtol(s+1, &s, 10);
+
+            TT.context = 0;
+            state = 2;
+
+            // If this is the first hunk, open the file.
+            if (TT.filein == -1) {
+                int oldsum, newsum, empty = 0;
+                char *name;
+
+                oldsum = TT.oldline + TT.oldlen;
+                newsum = TT.newline + TT.newlen;
+
+                name = reverse ? oldname : newname;
+
+                // 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))
+                {
+                    name = reverse ? newname : oldname;
+                    empty++;
+                }
+
+                // handle -p path truncation.
+                for (i=0, s = name; *s;) {
+                    if ((option_mask32 & FLAG_PATHLEN) && TT.prefix == i) break;
+                    if (*(s++)=='/') {
+                        name = s;
+                        i++;
+                    }
+                }
+
+                if (empty) {
+                    // File is empty after the patches have been applied
+                    state = 0;
+                    if (option_mask32 & FLAG_RMEMPTY) {
+                        // If flag -E or --remove-empty-files is set
+                        printf("removing %s\n", name);
+                        xunlink(name);
+                    } else {
+                        printf("patching file %s\n", name);
+                        xclose(xopen(name, O_WRONLY | O_TRUNC));
+                    }
+                // If we've got a file to open, do so.
+                } else if (!(option_mask32 & FLAG_PATHLEN) || i <= TT.prefix) {
+                    struct stat statbuf;
+
+                    // If the old file was null, we're creating a new one.
+                    if (!strcmp(oldname, "/dev/null") || !oldsum) {
+                        printf("creating %s\n", name);
+                        s = strrchr(name, '/');
+                        if (s) {
+                            *s = 0;
+                            bb_make_directory(name, -1, FILEUTILS_RECUR);
+                            *s = '/';
+                        }
+                        TT.filein = xopen(name, O_CREAT|O_EXCL|O_RDWR);
+                    } else {
+                        printf("patching file %s\n", name);
+                        TT.filein = xopen(name, O_RDONLY);
+                    }
+
+                    TT.tempname = xasprintf("%sXXXXXX", name);
+                    TT.fileout = xmkstemp(TT.tempname);
+                    // Set permissions of output file
+                    fstat(TT.filein, &statbuf);
+                    fchmod(TT.fileout, statbuf.st_mode);
+
+                    TT.linenum = 0;
+                    TT.hunknum = 0;
+                }
             }
-        }
-    }
-
-    /* 0 = SUCCESS
-     * 1 = Some hunks failed
-     * 2 = More serious problems
-     */
-    return ret;
-}
+
+            TT.hunknum++;
+
+            continue;
+        }
+
+        // If we didn't continue above, discard this line.
+        free(patchline);
+    }
+
+    finish_oldfile();
+
+    if (ENABLE_FEATURE_CLEAN_UP) {
+        free(oldname);
+        free(newname);
+    }
+
+    return TT.exitval;
+}

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

@@ -6 +6 @@
  * Copyright (C) 1999,2000,2001 by Mark Whitley <markw@codepoet.org>
  * Copyright (C) 2002  Matt Kraai
- * Copyright (C) 2003 by Glenn McGrath <bug1@iinet.net.au>
+ * Copyright (C) 2003 by Glenn McGrath
  * Copyright (C) 2003,2004 by Rob Landley <rob@landley.net>
  *
  * MAINTAINER: Rob Landley <rob@landley.net>
  *
- * Licensed under GPL version 2, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2, see file LICENSE in this source tree.
  */
 
@@ -24 +24 @@
   (G.sed_cmd_head/G.sed_cmd_tail).
 
-  add_input_file() adds a FILE * to the list of input files.  We need to
+  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.
 
@@ -62 +62 @@
 #include "xregex.h"
 
+enum {
+    OPT_in_place = 1 << 0,
+};
+
 /* Each sed command turns into one of these structures. */
 typedef struct sed_cmd_s {
@@ -77 +81 @@
     char *string;           /* Data string for (saicytb) commands. */
 
-    unsigned short which_match; /* (s) Which match to replace (0 for all) */
+    unsigned which_match;   /* (s) Which match to replace (0 for all) */
 
     /* Bitfields (gcc won't group them if we don't) */
@@ -114 +118 @@
 
     struct pipeline {
-        char *buf;  /* Space to hold string */
-        int idx;    /* Space used */
-        int len;    /* Space allocated */
+        char *buf;  /* Space to hold string */
+        int idx;    /* Space used */
+        int len;    /* Space allocated */
     } pipeline;
+} FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+struct BUG_G_too_big {
+        char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
 };
-#define G (*(struct globals*)&bb_common_bufsiz1)
-void BUG_sed_globals_too_big(void);
 #define INIT_G() do { \
-    if (sizeof(struct globals) > COMMON_BUFSIZE) \
-        BUG_sed_globals_too_big(); \
     G.sed_cmd_tail = &G.sed_cmd_head; \
 } while (0)
@@ -158 +162 @@
     }
 
-    if (G.hold_space) free(G.hold_space);
+    free(G.hold_space);
 
     while (G.current_input_file < G.input_file_count)
@@ -174 +178 @@
 }
 
-/* strdup, replacing "\n" with '\n', and "\delimiter" with 'delimiter' */
+/* strcpy, replacing "\from" with 'to'. If to is NUL, replacing "\any" with 'any' */
 
 static void parse_escapes(char *dest, const char *string, int len, char from, char to)
@@ -189 +193 @@
             *dest++ = string[i++];
         }
+        /* TODO: is it safe wrt a string with trailing '\\' ? */
         *dest++ = string[i++];
     }
-    *dest = 0;
+    *dest = '\0';
 }
 
@@ -199 +204 @@
 
     parse_escapes(dest, string, len, 'n', '\n');
+    /* GNU sed also recognizes \t */
+    parse_escapes(dest, dest, strlen(dest), 't', '\t');
     return dest;
 }
@@ -206 +213 @@
  * index_of_next_unescaped_regexp_delim - walks left to right through a string
  * beginning at a specified index and returns the index of the next regular
- * expression delimiter (typically a forward * slash ('/')) not preceded by
+ * expression delimiter (typically a forward slash ('/')) not preceded by
  * a backslash ('\').  A negative delimiter disables square bracket checking.
  */
@@ -299 +306 @@
 
 /* Grab a filename.  Whitespace at start is skipped, then goes to EOL. */
-static int parse_file_cmd(sed_cmd_t *sed_cmd, const char *filecmdstr, char **retval)
+static int parse_file_cmd(/*sed_cmd_t *sed_cmd,*/ const char *filecmdstr, char **retval)
 {
     int start = 0, idx, hack = 0;
@@ -351 +358 @@
                 const char *pos = substr + idx;
 /* FIXME: error check? */
-                sed_cmd->which_match = (unsigned short)strtol(substr+idx, (char**) &pos, 10);
+                sed_cmd->which_match = (unsigned)strtol(substr+idx, (char**) &pos, 10);
                 idx = pos - substr;
             }
@@ -357 +364 @@
         }
         /* Skip spaces */
-        if (isspace(substr[idx])) continue;
+        if (isspace(substr[idx]))
+            continue;
 
         switch (substr[idx]) {
         /* Replace all occurrences */
         case 'g':
-            if (match[0] != '^') sed_cmd->which_match = 0;
+            if (match[0] != '^')
+                sed_cmd->which_match = 0;
             break;
         /* Print pattern space */
@@ -372 +381 @@
         {
             char *temp;
-            idx += parse_file_cmd(sed_cmd, substr+idx, &temp);
+            idx += parse_file_cmd(/*sed_cmd,*/ substr+idx, &temp);
             break;
         }
@@ -381 +390 @@
         /* Comment */
         case '#':
-            while (substr[++idx]) /*skip all*/;
+            // while (substr[++idx]) continue;
+            idx += strlen(substr + idx); // same
             /* Fall through */
         /* End of command */
@@ -391 +401 @@
         }
     }
-out:
+ out:
     /* compile the match string into a regex */
     if (*match != '\0') {
@@ -414 +424 @@
     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");
+            bb_error_msg_and_die("only a beginning address can be specified for edit commands");
         for (;;) {
             if (*cmdstr == '\n' || *cmdstr == '\\') {
                 cmdstr++;
                 break;
-            } else if (isspace(*cmdstr))
-                cmdstr++;
-            else
+            }
+            if (!isspace(*cmdstr))
                 break;
+            cmdstr++;
         }
         sed_cmd->string = xstrdup(cmdstr);
-        parse_escapes(sed_cmd->string, sed_cmd->string, strlen(cmdstr), 0, 0);
+        /* "\anychar" -> "anychar" */
+        parse_escapes(sed_cmd->string, sed_cmd->string, strlen(cmdstr), '\0', '\0');
         cmdstr += strlen(cmdstr);
     /* handle file cmds: (r)ead */
@@ -432 +442 @@
         if (sed_cmd->end_line || sed_cmd->end_match)
             bb_error_msg_and_die("command only uses one address");
-        cmdstr += parse_file_cmd(sed_cmd, cmdstr, &sed_cmd->string);
+        cmdstr += parse_file_cmd(/*sed_cmd,*/ cmdstr, &sed_cmd->string);
         if (sed_cmd->cmd == 'w') {
-            sed_cmd->sw_file = xfopen(sed_cmd->string, "w");
+            sed_cmd->sw_file = xfopen_for_write(sed_cmd->string);
             sed_cmd->sw_last_char = '\n';
         }
@@ -483 +493 @@
 {
     sed_cmd_t *sed_cmd;
-    int temp;
+    unsigned len, n;
 
     /* Append this line to any unfinished line from last time. */
@@ -492 +502 @@
     }
 
-    /* If this line ends with backslash, request next line. */
-    temp = strlen(cmdstr);
-    if (temp && cmdstr[--temp] == '\\') {
+    /* If this line ends with unescaped backslash, request next line. */
+    n = len = strlen(cmdstr);
+    while (n && cmdstr[n-1] == '\\')
+        n--;
+    if ((len - n) & 1) { /* if odd number of trailing backslashes */
         if (!G.add_cmd_line)
             G.add_cmd_line = xstrdup(cmdstr);
-        G.add_cmd_line[temp] = '\0';
+        G.add_cmd_line[len-1] = '\0';
         return;
     }
@@ -556 +568 @@
         if (!*cmdstr)
             bb_error_msg_and_die("missing command");
-        sed_cmd->cmd = *(cmdstr++);
+        sed_cmd->cmd = *cmdstr++;
         cmdstr = parse_cmd_args(sed_cmd, cmdstr);
 
@@ -585 +597 @@
 static void do_subst_w_backrefs(char *line, char *replace)
 {
-    int i,j;
+    int i, j;
 
     /* go through the replacement string */
@@ -620 +632 @@
 }
 
-static int do_subst_command(sed_cmd_t *sed_cmd, char **line)
-{
-    char *oldline = *line;
+static int do_subst_command(sed_cmd_t *sed_cmd, char **line_p)
+{
+    char *line = *line_p;
     int altered = 0;
-    int match_count = 0;
+    unsigned match_count = 0;
     regex_t *current_regex;
 
+    current_regex = sed_cmd->sub_match;
     /* Handle empty regex. */
-    if (sed_cmd->sub_match == NULL) {
+    if (!current_regex) {
         current_regex = G.previous_regex_ptr;
         if (!current_regex)
             bb_error_msg_and_die("no previous regexp");
-    } else
-        G.previous_regex_ptr = current_regex = sed_cmd->sub_match;
+    }
+    G.previous_regex_ptr = current_regex;
 
     /* Find the first match */
-    if (REG_NOMATCH == regexec(current_regex, oldline, 10, G.regmatch, 0))
+    if (REG_NOMATCH == regexec(current_regex, line, 10, G.regmatch, 0))
         return 0;
 
@@ -653 +666 @@
            echo "hi" | busybox sed 's/^/!/g' */
         if (!G.regmatch[0].rm_so && !G.regmatch[0].rm_eo && match_count) {
-            pipe_putc(*oldline++);
+            pipe_putc(*line++);
             continue;
         }
@@ -661 +674 @@
         /* If we aren't interested in this match, output old line to
            end of match and continue */
-        if (sed_cmd->which_match && sed_cmd->which_match != match_count) {
+        if (sed_cmd->which_match
+         && (sed_cmd->which_match != match_count)
+        ) {
             for (i = 0; i < G.regmatch[0].rm_eo; i++)
-                pipe_putc(*oldline++);
+                pipe_putc(*line++);
             continue;
         }
@@ -669 +684 @@
         /* print everything before the match */
         for (i = 0; i < G.regmatch[0].rm_so; i++)
-            pipe_putc(oldline[i]);
+            pipe_putc(line[i]);
 
         /* then print the substitution string */
-        do_subst_w_backrefs(oldline, sed_cmd->string);
+        do_subst_w_backrefs(line, sed_cmd->string);
 
         /* advance past the match */
-        oldline += G.regmatch[0].rm_eo;
+        line += G.regmatch[0].rm_eo;
         /* flag that something has changed */
         altered++;
 
         /* if we're not doing this globally, get out now */
-        if (sed_cmd->which_match) break;
-    } while (*oldline && (regexec(current_regex, oldline, 10, G.regmatch, 0) != REG_NOMATCH));
+        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);
 
     /* Copy rest of string into output pipeline */
-
-    while (*oldline)
-        pipe_putc(*oldline++);
-    pipe_putc(0);
-
-    free(*line);
-    *line = G.pipeline.buf;
+    while (1) {
+        char c = *line++;
+        pipe_putc(c);
+        if (c == '\0')
+            break;
+    }
+
+    free(*line_p);
+    *line_p = G.pipeline.buf;
     return altered;
 }
@@ -725 +745 @@
 static void add_input_file(FILE *file)
 {
-    G.input_file_list = xrealloc(G.input_file_list,
-            (G.input_file_count + 1) * sizeof(FILE *));
+    G.input_file_list = xrealloc_vector(G.input_file_list, 2, G.input_file_count);
     G.input_file_list[G.input_file_count++] = file;
 }
@@ -859 +878 @@
     next_line = get_next_line(&next_gets_char);
 
-    /* go through every line in each file */
-again:
+    /* Go through every line in each file */
+ again:
     substituted = 0;
 
     /* Advance to next line.  Stop if out of lines. */
     pattern_space = next_line;
-    if (!pattern_space) return;
+    if (!pattern_space)
+        return;
     last_gets_char = next_gets_char;
 
@@ -872 +892 @@
     next_line = get_next_line(&next_gets_char);
     linenum++;
-restart:
-    /* for every line, go through all the commands */
+
+    /* For every line, go through all the commands */
+ restart:
     for (sed_cmd = G.sed_cmd_head.next; sed_cmd; sed_cmd = sed_cmd->next) {
         int old_matched, matched;
@@ -880 +901 @@
 
         /* 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));
 
         /* Are we continuing a previous multi-line match? */
@@ -887 +920 @@
                 && !sed_cmd->beg_match && !sed_cmd->end_match)
             /* Or did we match the start of a numerical range? */
-            || (sed_cmd->beg_line > 0 && (sed_cmd->beg_line == linenum))
+            || (sed_cmd->beg_line > 0
+                && (sed_cmd->end_line || sed_cmd->end_match
+                  /* note: even if end is numeric and is < linenum too,
+                   * GNU sed matches! We match too */
+                ? (sed_cmd->beg_line <= linenum)    /* N,end */
+                : (sed_cmd->beg_line == linenum)    /* N */
+                )
+                )
             /* Or does this line match our begin address regex? */
             || (beg_match(sed_cmd, pattern_space))
@@ -894 +934 @@
 
         /* Snapshot the value */
-
         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);
+
         /* Is this line the end of the current match? */
 
         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 */
+            ) {
+                sed_cmd->beg_line = -2;
+            }
             sed_cmd->in_match = !(
                 /* has the ending line come, or is this a single address command? */
@@ -915 +963 @@
         }
 
-        /* Skip blocks of commands we didn't match. */
+        /* Skip blocks of commands we didn't match */
         if (sed_cmd->cmd == '{') {
             if (sed_cmd->invert ? matched : !matched) {
-                while (sed_cmd->cmd != '}') {
+                unsigned nest_cnt = 0;
+                while (1) {
+                    if (sed_cmd->cmd == '{')
+                        nest_cnt++;
+                    if (sed_cmd->cmd == '}') {
+                        nest_cnt--;
+                        if (nest_cnt == 0)
+                            break;
+                    }
                     sed_cmd = sed_cmd->next;
                     if (!sed_cmd)
@@ -928 +984 @@
 
         /* Okay, so did this line match? */
-        if (sed_cmd->invert ? !matched : matched) {
-            /* Update last used regex in case a blank substitute BRE is found */
-            if (sed_cmd->beg_match) {
-                G.previous_regex_ptr = sed_cmd->beg_match;
-            }
-
-            /* actual sedding */
-            switch (sed_cmd->cmd) {
-
-            /* Print line number */
-            case '=':
-                fprintf(G.nonstdout, "%d\n", linenum);
+        if (sed_cmd->invert ? matched : !matched)
+            continue; /* no */
+
+        /* Update last used regex in case a blank substitute BRE is found */
+        if (sed_cmd->beg_match) {
+            G.previous_regex_ptr = sed_cmd->beg_match;
+        }
+
+        /* actual sedding */
+        //bb_error_msg("pattern_space:'%s' next_line:'%s' cmd:%c",
+        //pattern_space, next_line, sed_cmd->cmd);
+        switch (sed_cmd->cmd) {
+
+        /* Print line number */
+        case '=':
+            fprintf(G.nonstdout, "%d\n", linenum);
+            break;
+
+        /* Write the current pattern space up to the first newline */
+        case 'P':
+        {
+            char *tmp = strchr(pattern_space, '\n');
+            if (tmp) {
+                *tmp = '\0';
+                /* TODO: explain why '\n' below */
+                sed_puts(pattern_space, '\n');
+                *tmp = '\n';
                 break;
-
-            /* Write the current pattern space up to the first newline */
-            case 'P':
-            {
-                char *tmp = strchr(pattern_space, '\n');
-
-                if (tmp) {
-                    *tmp = '\0';
-                    /* TODO: explain why '\n' below */
-                    sed_puts(pattern_space, '\n');
-                    *tmp = '\n';
-                    break;
-                }
-                /* Fall Through */
-            }
-
-            /* Write the current pattern space to output */
-            case 'p':
-                /* NB: we print this _before_ the last line
-                 * (of current file) is printed. Even if
-                 * that line is nonterminated, we print
-                 * '\n' here (gnu sed does the same) */
-                sed_puts(pattern_space, '\n');
+            }
+            /* Fall Through */
+        }
+
+        /* Write the current pattern space to output */
+        case 'p':
+            /* NB: we print this _before_ the last line
+             * (of current file) is printed. Even if
+             * that line is nonterminated, we print
+             * '\n' here (gnu sed does the same) */
+            sed_puts(pattern_space, '\n');
+            break;
+        /* Delete up through first newline */
+        case 'D':
+        {
+            char *tmp = strchr(pattern_space, '\n');
+            if (tmp) {
+                overlapping_strcpy(pattern_space, tmp + 1);
+                goto restart;
+            }
+        }
+        /* discard this line. */
+        case 'd':
+            goto discard_line;
+
+        /* Substitute with regex */
+        case 's':
+            if (!do_subst_command(sed_cmd, &pattern_space))
                 break;
-            /* Delete up through first newline */
-            case 'D':
-            {
-                char *tmp = strchr(pattern_space, '\n');
-
-                if (tmp) {
-                    tmp = xstrdup(tmp+1);
-                    free(pattern_space);
-                    pattern_space = tmp;
-                    goto restart;
-                }
-            }
-            /* discard this line. */
-            case 'd':
-                goto discard_line;
-
-            /* Substitute with regex */
-            case 's':
-                if (!do_subst_command(sed_cmd, &pattern_space))
-                    break;
-                substituted |= 1;
-
-                /* handle p option */
-                if (sed_cmd->sub_p)
-                    sed_puts(pattern_space, last_gets_char);
-                /* handle w option */
-                if (sed_cmd->sw_file)
-                    puts_maybe_newline(
-                        pattern_space, sed_cmd->sw_file,
-                        &sed_cmd->sw_last_char, last_gets_char);
-                break;
-
-            /* Append line to linked list to be printed later */
-            case 'a':
-                append(sed_cmd->string);
-                break;
-
-            /* Insert text before this line */
-            case 'i':
-                sed_puts(sed_cmd->string, '\n');
-                break;
-
-            /* Cut and paste text (replace) */
-            case 'c':
-                /* Only triggers on last line of a matching range. */
-                if (!sed_cmd->in_match)
-                    sed_puts(sed_cmd->string, NO_EOL_CHAR);
-                goto discard_line;
-
-            /* Read file, append contents to output */
-            case 'r':
-            {
-                FILE *rfile;
-
-                rfile = fopen(sed_cmd->string, "r");
-                if (rfile) {
-                    char *line;
-
-                    while ((line = xmalloc_getline(rfile))
-                            != NULL)
-                        append(line);
-                    xprint_and_close_file(rfile);
-                }
-
-                break;
-            }
-
-            /* Write pattern space to file. */
-            case 'w':
+            substituted |= 1;
+
+            /* handle p option */
+            if (sed_cmd->sub_p)
+                sed_puts(pattern_space, last_gets_char);
+            /* handle w option */
+            if (sed_cmd->sw_file)
                 puts_maybe_newline(
                     pattern_space, sed_cmd->sw_file,
                     &sed_cmd->sw_last_char, last_gets_char);
-                break;
-
-            /* Read next line from input */
-            case 'n':
-                if (!G.be_quiet)
-                    sed_puts(pattern_space, last_gets_char);
-                if (next_line) {
-                    free(pattern_space);
-                    pattern_space = next_line;
-                    last_gets_char = next_gets_char;
-                    next_line = get_next_line(&next_gets_char);
-                    linenum++;
-                    break;
-                }
-                /* fall through */
-
-            /* Quit.  End of script, end of input. */
-            case 'q':
-                /* Exit the outer while loop */
-                free(next_line);
-                next_line = NULL;
-                goto discard_commands;
-
-            /* Append the next line to the current line */
-            case 'N':
-            {
-                int len;
-                /* If no next line, jump to end of script and exit. */
-                if (next_line == NULL) {
-                    /* Jump to end of script and exit */
-                    free(next_line);
-                    next_line = NULL;
-                    goto discard_line;
-                /* append next_line, read new next_line. */
-                }
-                len = strlen(pattern_space);
-                pattern_space = realloc(pattern_space, len + strlen(next_line) + 2);
-                pattern_space[len] = '\n';
-                strcpy(pattern_space + len+1, next_line);
+            break;
+
+        /* Append line to linked list to be printed later */
+        case 'a':
+            append(sed_cmd->string);
+            break;
+
+        /* Insert text before this line */
+        case 'i':
+            sed_puts(sed_cmd->string, '\n');
+            break;
+
+        /* Cut and paste text (replace) */
+        case 'c':
+            /* Only triggers on last line of a matching range. */
+            if (!sed_cmd->in_match)
+                sed_puts(sed_cmd->string, '\n');
+            goto discard_line;
+
+        /* Read file, append contents to output */
+        case 'r':
+        {
+            FILE *rfile;
+            rfile = fopen_for_read(sed_cmd->string);
+            if (rfile) {
+                char *line;
+
+                while ((line = xmalloc_fgetline(rfile))
+                        != NULL)
+                    append(line);
+                xprint_and_close_file(rfile);
+            }
+
+            break;
+        }
+
+        /* Write pattern space to file. */
+        case 'w':
+            puts_maybe_newline(
+                pattern_space, sed_cmd->sw_file,
+                &sed_cmd->sw_last_char, last_gets_char);
+            break;
+
+        /* Read next line from input */
+        case 'n':
+            if (!G.be_quiet)
+                sed_puts(pattern_space, last_gets_char);
+            if (next_line) {
+                free(pattern_space);
+                pattern_space = next_line;
                 last_gets_char = next_gets_char;
                 next_line = get_next_line(&next_gets_char);
+                substituted = 0;
                 linenum++;
                 break;
             }
-
-            /* Test/branch if substitution occurred */
-            case 't':
-                if (!substituted) break;
-                substituted = 0;
-                /* Fall through */
-            /* Test/branch if substitution didn't occur */
-            case 'T':
-                if (substituted) break;
-                /* Fall through */
-            /* Branch to label */
-            case 'b':
-                if (!sed_cmd->string) goto discard_commands;
-                else sed_cmd = branch_to(sed_cmd->string);
-                break;
-            /* Transliterate characters */
-            case 'y':
-            {
-                int i, j;
-
-                for (i = 0; pattern_space[i]; i++) {
-                    for (j = 0; sed_cmd->string[j]; j += 2) {
-                        if (pattern_space[i] == sed_cmd->string[j]) {
-                            pattern_space[i] = sed_cmd->string[j + 1];
-                            break;
-                        }
+            /* fall through */
+
+        /* Quit.  End of script, end of input. */
+        case 'q':
+            /* Exit the outer while loop */
+            free(next_line);
+            next_line = NULL;
+            goto discard_commands;
+
+        /* Append the next line to the current line */
+        case 'N':
+        {
+            int len;
+            /* If no next line, jump to end of script and exit. */
+            /* http://www.gnu.org/software/sed/manual/sed.html:
+             * "Most versions of sed exit without printing anything
+             * when the N command is issued on the last line of
+             * a file. GNU sed prints pattern space before exiting
+             * unless of course the -n command switch has been
+             * specified. This choice is by design."
+             */
+            if (next_line == NULL) {
+                //goto discard_line;
+                goto discard_commands; /* GNU behavior */
+            }
+            /* Append next_line, read new next_line. */
+            len = strlen(pattern_space);
+            pattern_space = xrealloc(pattern_space, len + strlen(next_line) + 2);
+            pattern_space[len] = '\n';
+            strcpy(pattern_space + len+1, next_line);
+            last_gets_char = next_gets_char;
+            next_line = get_next_line(&next_gets_char);
+            linenum++;
+            break;
+        }
+
+        /* Test/branch if substitution occurred */
+        case 't':
+            if (!substituted) break;
+            substituted = 0;
+            /* Fall through */
+        /* Test/branch if substitution didn't occur */
+        case 'T':
+            if (substituted) break;
+            /* Fall through */
+        /* Branch to label */
+        case 'b':
+            if (!sed_cmd->string) goto discard_commands;
+            else sed_cmd = branch_to(sed_cmd->string);
+            break;
+        /* Transliterate characters */
+        case 'y':
+        {
+            int i, j;
+            for (i = 0; pattern_space[i]; i++) {
+                for (j = 0; sed_cmd->string[j]; j += 2) {
+                    if (pattern_space[i] == sed_cmd->string[j]) {
+                        pattern_space[i] = sed_cmd->string[j + 1];
+                        break;
                     }
                 }
-
-                break;
-            }
-            case 'g':   /* Replace pattern space with hold space */
-                free(pattern_space);
-                pattern_space = xstrdup(G.hold_space ? G.hold_space : "");
-                break;
-            case 'G':   /* Append newline and hold space to pattern space */
-            {
-                int pattern_space_size = 2;
-                int hold_space_size = 0;
-
-                if (pattern_space)
-                    pattern_space_size += strlen(pattern_space);
-                if (G.hold_space)
-                    hold_space_size = strlen(G.hold_space);
-                pattern_space = xrealloc(pattern_space,
-                        pattern_space_size + hold_space_size);
-                if (pattern_space_size == 2)
-                    pattern_space[0] = 0;
-                strcat(pattern_space, "\n");
-                if (G.hold_space)
-                    strcat(pattern_space, G.hold_space);
-                last_gets_char = '\n';
-
-                break;
-            }
-            case 'h':   /* Replace hold space with pattern space */
-                free(G.hold_space);
-                G.hold_space = xstrdup(pattern_space);
-                break;
-            case 'H':   /* Append newline and pattern space to hold space */
-            {
-                int hold_space_size = 2;
-                int pattern_space_size = 0;
-
-                if (G.hold_space)
-                    hold_space_size += strlen(G.hold_space);
-                if (pattern_space)
-                    pattern_space_size = strlen(pattern_space);
-                G.hold_space = xrealloc(G.hold_space,
-                        hold_space_size + pattern_space_size);
-
-                if (hold_space_size == 2)
-                    *G.hold_space = 0;
-                strcat(G.hold_space, "\n");
-                if (pattern_space)
-                    strcat(G.hold_space, pattern_space);
-
-                break;
-            }
-            case 'x': /* Exchange hold and pattern space */
-            {
-                char *tmp = pattern_space;
-                pattern_space = G.hold_space ? : xzalloc(1);
-                last_gets_char = '\n';
-                G.hold_space = tmp;
-                break;
-            }
-            }
-        }
-    }
+            }
+
+            break;
+        }
+        case 'g':   /* Replace pattern space with hold space */
+            free(pattern_space);
+            pattern_space = xstrdup(G.hold_space ? G.hold_space : "");
+            break;
+        case 'G':   /* Append newline and hold space to pattern space */
+        {
+            int pattern_space_size = 2;
+            int hold_space_size = 0;
+
+            if (pattern_space)
+                pattern_space_size += strlen(pattern_space);
+            if (G.hold_space)
+                hold_space_size = strlen(G.hold_space);
+            pattern_space = xrealloc(pattern_space,
+                    pattern_space_size + hold_space_size);
+            if (pattern_space_size == 2)
+                pattern_space[0] = 0;
+            strcat(pattern_space, "\n");
+            if (G.hold_space)
+                strcat(pattern_space, G.hold_space);
+            last_gets_char = '\n';
+
+            break;
+        }
+        case 'h':   /* Replace hold space with pattern space */
+            free(G.hold_space);
+            G.hold_space = xstrdup(pattern_space);
+            break;
+        case 'H':   /* Append newline and pattern space to hold space */
+        {
+            int hold_space_size = 2;
+            int pattern_space_size = 0;
+
+            if (G.hold_space)
+                hold_space_size += strlen(G.hold_space);
+            if (pattern_space)
+                pattern_space_size = strlen(pattern_space);
+            G.hold_space = xrealloc(G.hold_space,
+                    hold_space_size + pattern_space_size);
+
+            if (hold_space_size == 2)
+                *G.hold_space = 0;
+            strcat(G.hold_space, "\n");
+            if (pattern_space)
+                strcat(G.hold_space, pattern_space);
+
+            break;
+        }
+        case 'x': /* Exchange hold and pattern space */
+        {
+            char *tmp = pattern_space;
+            pattern_space = G.hold_space ? G.hold_space : xzalloc(1);
+            last_gets_char = '\n';
+            G.hold_space = tmp;
+            break;
+        }
+        } /* switch */
+    } /* for each cmd */
 
     /*
-     * exit point from sedding...
+     * Exit point from sedding...
      */
  discard_commands:
@@ -1212 +1271 @@
             /* Odd number of preceding slashes - newline is escaped */
             if (slashes & 1) {
-                strcpy(eol-1, eol);
+                overlapping_strcpy(eol - 1, eol);
                 eol = strchr(eol, '\n');
                 goto next;
@@ -1224 +1283 @@
 }
 
-int sed_main(int argc, char **argv);
-int sed_main(int argc, char **argv)
-{
-    enum {
-        OPT_in_place = 1 << 0,
-    };
+int sed_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int sed_main(int argc UNUSED_PARAM, char **argv)
+{
     unsigned opt;
     llist_t *opt_e, *opt_f;
@@ -1240 +1296 @@
 
     /* Lie to autoconf when it starts asking stupid questions. */
-    if (argc == 2 && !strcmp(argv[1], "--version")) {
+    if (argv[1] && !strcmp(argv[1], "--version")) {
         puts("This is not GNU sed version 4.0");
         return 0;
@@ -1249 +1305 @@
     opt_complementary = "e::f::" /* can occur multiple times */
                         "nn"; /* count -n */
+    /* -i must be first, to match OPT_in_place definition */
     opt = getopt32(argv, "irne:f:", &opt_e, &opt_f,
                 &G.be_quiet); /* counter for -n */
-    argc -= optind;
+    //argc -= optind;
     argv += optind;
     if (opt & OPT_in_place) { // -i
@@ -1259 +1316 @@
     //if (opt & 0x4) G.be_quiet++; // -n
     while (opt_e) { // -e
-        add_cmd_block(opt_e->data);
-        opt_e = opt_e->link;
-        /* we leak opt_e here... */
+        add_cmd_block(llist_pop(&opt_e));
     }
     while (opt_f) { // -f
         char *line;
         FILE *cmdfile;
-        cmdfile = xfopen(opt_f->data, "r");
-        while ((line = xmalloc_getline(cmdfile)) != NULL) {
+        cmdfile = xfopen_for_read(llist_pop(&opt_f));
+        while ((line = xmalloc_fgetline(cmdfile)) != NULL) {
             add_cmd(line);
             free(line);
         }
         fclose(cmdfile);
-        opt_f = opt_f->link;
-        /* we leak opt_f here... */
     }
     /* if we didn't get a pattern from -e or -f, use argv[0] */
     if (!(opt & 0x18)) {
-        if (!argc)
+        if (!*argv)
             bb_show_usage();
         add_cmd_block(*argv++);
-        argc--;
     }
     /* Flush any unfinished commands. */
@@ -1295 +1347 @@
             bb_error_msg_and_die(bb_msg_requires_arg, "-i");
         add_input_file(stdin);
-        process_files();
     } else {
         int i;
         FILE *file;
 
-        for (i = 0; i < argc; i++) {
+        for (i = 0; argv[i]; i++) {
             struct stat statbuf;
             int nonstdoutfd;
@@ -1320 +1371 @@
 
             G.outname = xasprintf("%sXXXXXX", argv[i]);
-            nonstdoutfd = mkstemp(G.outname);
-            if (-1 == nonstdoutfd)
-                bb_perror_msg_and_die("cannot create temp file %s", G.outname);
-            G.nonstdout = fdopen(nonstdoutfd, "w");
-
-            /* Set permissions of output file */
-
+            nonstdoutfd = xmkstemp(G.outname);
+            G.nonstdout = xfdopen_for_write(nonstdoutfd);
+
+            /* Set permissions/owner of output file */
             fstat(fileno(file), &statbuf);
+            /* chmod'ing AFTER chown would preserve suid/sgid bits,
+             * but GNU sed 4.2.1 does not preserve them either */
             fchmod(nonstdoutfd, statbuf.st_mode);
+            fchown(nonstdoutfd, statbuf.st_uid, statbuf.st_gid);
             add_input_file(file);
             process_files();
@@ -1335 +1386 @@
             G.nonstdout = stdout;
             /* unlink(argv[i]); */
-            // FIXME: error check / message?
-            rename(G.outname, argv[i]);
+            xrename(G.outname, argv[i]);
             free(G.outname);
-            G.outname = 0;
-        }
-        if (G.input_file_count > G.current_input_file)
-            process_files();
-    }
+            G.outname = NULL;
+        }
+        /* Here, to handle "sed 'cmds' nonexistent_file" case we did:
+         * if (G.current_input_file >= G.input_file_count)
+         *  return status;
+         * but it's not needed since process_files() works correctly
+         * in this case too. */
+    }
+    process_files();
 
     return status;

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

@@ -4 +4 @@
  * Copyright (C) 2000, 2001 Sterling Huxley <sterling@europa.com>
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -24 +24 @@
 #include "libbb.h"
 
+/* the CRASHME code is unmaintained, and doesn't currently build */
 #define ENABLE_FEATURE_VI_CRASHME 0
 
+
 #if ENABLE_LOCALE_SUPPORT
-#define Isprint(c) isprint((c))
+
+#if ENABLE_FEATURE_VI_8BIT
+//FIXME: this does not work properly for Unicode anyway
+# define Isprint(c) (isprint)(c)
 #else
+# define Isprint(c) isprint_asciionly(c)
+#endif
+
+#else
+
 /* 0x9b is Meta-ESC */
+#if ENABLE_FEATURE_VI_8BIT
 #define Isprint(c) ((unsigned char)(c) >= ' ' && (c) != 0x7f && (unsigned char)(c) != 0x9b)
-#endif
+#else
+#define Isprint(c) ((unsigned char)(c) >= ' ' && (unsigned char)(c) < 0x7f)
+#endif
+
+#endif
+
 
 enum {
-    MAX_LINELEN = CONFIG_FEATURE_VI_MAX_LEN,
+    MAX_TABSTOP = 32, // sanity limit
+    // User input len. Need not be extra big.
+    // Lines in file being edited *can* be bigger than this.
+    MAX_INPUT_LEN = 128,
+    // Sanity limits. We have only one buffer of this size.
     MAX_SCR_COLS = CONFIG_FEATURE_VI_MAX_LEN,
+    MAX_SCR_ROWS = CONFIG_FEATURE_VI_MAX_LEN,
 };
-
-// Misc. non-Ascii keys that report an escape sequence
-#define VI_K_UP         (char)128   // cursor key Up
-#define VI_K_DOWN       (char)129   // cursor key Down
-#define VI_K_RIGHT      (char)130   // Cursor Key Right
-#define VI_K_LEFT       (char)131   // cursor key Left
-#define VI_K_HOME       (char)132   // Cursor Key Home
-#define VI_K_END        (char)133   // Cursor Key End
-#define VI_K_INSERT     (char)134   // Cursor Key Insert
-#define VI_K_PAGEUP     (char)135   // Cursor Key Page Up
-#define VI_K_PAGEDOWN       (char)136   // Cursor Key Page Down
-#define VI_K_FUN1       (char)137   // Function Key F1
-#define VI_K_FUN2       (char)138   // Function Key F2
-#define VI_K_FUN3       (char)139   // Function Key F3
-#define VI_K_FUN4       (char)140   // Function Key F4
-#define VI_K_FUN5       (char)141   // Function Key F5
-#define VI_K_FUN6       (char)142   // Function Key F6
-#define VI_K_FUN7       (char)143   // Function Key F7
-#define VI_K_FUN8       (char)144   // Function Key F8
-#define VI_K_FUN9       (char)145   // Function Key F9
-#define VI_K_FUN10      (char)146   // Function Key F10
-#define VI_K_FUN11      (char)147   // Function Key F11
-#define VI_K_FUN12      (char)148   // Function Key F12
 
 /* vt102 typical ESC sequence */
 /* terminal standout start/normal ESC sequence */
-static const char SOs[] ALIGN1 = "\033[7m";
-static const char SOn[] ALIGN1 = "\033[0m";
+#define SOs "\033[7m"
+#define SOn "\033[0m"
 /* terminal bell sequence */
-static const char bell[] ALIGN1 = "\007";
+#define bell "\007"
 /* Clear-end-of-line and Clear-end-of-screen ESC sequence */
-static const char Ceol[] ALIGN1 = "\033[0K";
-static const char Ceos[] ALIGN1 = "\033[0J";
+#define Ceol "\033[K"
+#define Ceos "\033[J"
 /* Cursor motion arbitrary destination ESC sequence */
-static const char CMrc[] ALIGN1 = "\033[%d;%dH";
+#define CMrc "\033[%u;%uH"
 /* Cursor motion up and down ESC sequence */
-static const char CMup[] ALIGN1 = "\033[A";
-static const char CMdown[] ALIGN1 = "\n";
-
+#define CMup "\033[A"
+#define CMdown "\n"
+
+#if ENABLE_FEATURE_VI_DOT_CMD || ENABLE_FEATURE_VI_YANKMARK
+// cmds modifying text[]
+// vda: removed "aAiIs" as they switch us into insert mode
+// and remembering input for replay after them makes no sense
+static const char modifying_cmds[] = "cCdDJoOpPrRxX<>~";
+#endif
 
 enum {
@@ -92 +96 @@
 };
 
+
 /* vi.c expects chars to be unsigned. */
 /* busybox build system provides that, but it's better */
 /* to audit and fix the source */
 
-static smallint vi_setops;
+struct globals {
+    /* many references - keep near the top of globals */
+    char *text, *end;       // pointers to the user data in memory
+    char *dot;              // where all the action takes place
+    int text_size;      // size of the allocated buffer
+
+    /* the rest */
+    smallint vi_setops;
 #define VI_AUTOINDENT 1
 #define VI_SHOWMATCH  2
@@ -107 +119 @@
 #define err_method (vi_setops & VI_ERR_METHOD)
 
-
-static smallint editing;        // >0 while we are editing a file
-                                // [code audit says "can be 0 or 1 only"]
-static smallint cmd_mode;       // 0=command  1=insert 2=replace
-static smallint file_modified;  // buffer contents changed
-static smallint last_file_modified = -1;
-static int fn_start;            // index of first cmd line file name
-static int save_argc;           // how many file names on cmd line
-static int cmdcnt;              // repetition count
-static int rows, columns;       // the terminal screen is this size
-static int crow, ccol, offset;  // cursor is on Crow x Ccol with Horz Ofset
-static char *status_buffer;     // mesages to the user
-#define STATUS_BUFFER_LEN  200
-static int have_status_msg;     // is default edit status needed?
-                                // [don't make smallint!]
-static int last_status_cksum;   // hash of current status line
-static char *current_filename;               // current file name
-//static char *text, *end;        // pointers to the user data in memory
-static char *screen;            // pointer to the virtual screen buffer
-static int screensize;          //            and its size
-static char *screenbegin;       // index into text[], of top line on the screen
-//static char *dot;               // where all the action takes place
-static int tabstop;
-static char erase_char;         // the users erase character
-static char last_input_char;    // last char read from user
-static char last_forward_char;  // last char searched for with 'f'
-
 #if ENABLE_FEATURE_VI_READONLY
-//static smallint vi_readonly, readonly;
-static smallint readonly_mode = 0;
+    smallint readonly_mode;
 #define SET_READONLY_FILE(flags)        ((flags) |= 0x01)
 #define SET_READONLY_MODE(flags)        ((flags) |= 0x02)
 #define UNSET_READONLY_FILE(flags)      ((flags) &= 0xfe)
 #else
-#define readonly_mode 0
-#define SET_READONLY_FILE(flags)
-#define SET_READONLY_MODE(flags)
-#define UNSET_READONLY_FILE(flags)
-#endif
+#define SET_READONLY_FILE(flags)        ((void)0)
+#define SET_READONLY_MODE(flags)        ((void)0)
+#define UNSET_READONLY_FILE(flags)      ((void)0)
+#endif
+
+    smallint editing;        // >0 while we are editing a file
+                             // [code audit says "can be 0, 1 or 2 only"]
+    smallint cmd_mode;       // 0=command  1=insert 2=replace
+    int file_modified;       // buffer contents changed (counter, not flag!)
+    int last_file_modified;  // = -1;
+    int fn_start;            // index of first cmd line file name
+    int save_argc;           // how many file names on cmd line
+    int cmdcnt;              // repetition count
+    unsigned rows, columns;  // the terminal screen is this size
+#if ENABLE_FEATURE_VI_ASK_TERMINAL
+    int get_rowcol_error;
+#endif
+    int crow, ccol;          // cursor is on Crow x Ccol
+    int offset;              // chars scrolled off the screen to the left
+    int have_status_msg;     // is default edit status needed?
+                             // [don't make smallint!]
+    int last_status_cksum;   // hash of current status line
+    char *current_filename;
+    char *screenbegin;       // index into text[], of top line on the screen
+    char *screen;            // pointer to the virtual screen buffer
+    int screensize;          //            and its size
+    int tabstop;
+    int last_forward_char;   // last char searched for with 'f' (int because of Unicode)
+    char erase_char;         // the users erase character
+    char last_input_char;    // last char read from user
 
 #if ENABLE_FEATURE_VI_DOT_CMD
-static smallint adding2q;       // are we currently adding user input to q
-static char *last_modifying_cmd;    // last modifying cmd for "."
-static char *ioq, *ioq_start;           // pointer to string for get_one_char to "read"
+    smallint adding2q;   // are we currently adding user input to q
+    int lmc_len;             // length of last_modifying_cmd
+    char *ioq, *ioq_start;   // pointer to string for get_one_char to "read"
 #endif
 #if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-static int last_row;        // where the cursor was last moved to
+    int last_row;        // where the cursor was last moved to
 #endif
 #if ENABLE_FEATURE_VI_USE_SIGNALS || ENABLE_FEATURE_VI_CRASHME
-static int my_pid;
-#endif
-#if ENABLE_FEATURE_VI_DOT_CMD || ENABLE_FEATURE_VI_YANKMARK
-static char *modifying_cmds;            // cmds that modify text[]
+    int my_pid;
 #endif
 #if ENABLE_FEATURE_VI_SEARCH
-static char *last_search_pattern;   // last pattern from a '/' or '?' search
-#endif
-
-/* Moving biggest data to malloced space... */
-struct globals {
-    /* many references - keep near the top of globals */
-    char *text, *end;       // pointers to the user data in memory
-    int text_size;      // size of the allocated buffer
-    char *dot;              // where all the action takes place
+    char *last_search_pattern; // last pattern from a '/' or '?' search
+#endif
+
+    /* former statics */
 #if ENABLE_FEATURE_VI_YANKMARK
+    char *edit_file__cur_line;
+#endif
+    int refresh__old_offset;
+    int format_edit_status__tot;
+
+    /* a few references only */
+#if ENABLE_FEATURE_VI_YANKMARK
+    int YDreg, Ureg;        // default delete register and orig line for "U"
     char *reg[28];          // named register a-z, "D", and "U" 0-25,26,27
-    int YDreg, Ureg;        // default delete register and orig line for "U"
     char *mark[28];         // user marks points somewhere in text[]-  a-z and previous context ''
     char *context_start, *context_end;
 #endif
-    /* a few references only */
 #if ENABLE_FEATURE_VI_USE_SIGNALS
-    jmp_buf restart;        // catch_sig()
-#endif
-    struct termios term_orig, term_vi;  // remember what the cooked mode was
+    sigjmp_buf restart;     // catch_sig()
+#endif
+    struct termios term_orig, term_vi; // remember what the cooked mode was
 #if ENABLE_FEATURE_VI_COLON
     char *initial_cmds[3];  // currently 2 entries, NULL terminated
 #endif
+    // Should be just enough to hold a key sequence,
+    // but CRASHME mode uses it as generated command buffer too
+#if ENABLE_FEATURE_VI_CRASHME
+    char readbuffer[128];
+#else
+    char readbuffer[KEYCODE_BUFFER_SIZE];
+#endif
+#define STATUS_BUFFER_LEN  200
+    char status_buffer[STATUS_BUFFER_LEN]; // messages to the user
+#if ENABLE_FEATURE_VI_DOT_CMD
+    char last_modifying_cmd[MAX_INPUT_LEN]; // last modifying cmd for "."
+#endif
+    char get_input_line__buf[MAX_INPUT_LEN]; /* former static */
+
+    char scr_out_buf[MAX_SCR_COLS + MAX_TABSTOP * 2];
 };
 #define G (*ptr_to_globals)
@@ -192 +214 @@
 #define dot            (G.dot           )
 #define reg            (G.reg           )
+
+#define vi_setops               (G.vi_setops          )
+#define editing                 (G.editing            )
+#define cmd_mode                (G.cmd_mode           )
+#define file_modified           (G.file_modified      )
+#define last_file_modified      (G.last_file_modified )
+#define fn_start                (G.fn_start           )
+#define save_argc               (G.save_argc          )
+#define cmdcnt                  (G.cmdcnt             )
+#define rows                    (G.rows               )
+#define columns                 (G.columns            )
+#define crow                    (G.crow               )
+#define ccol                    (G.ccol               )
+#define offset                  (G.offset             )
+#define status_buffer           (G.status_buffer      )
+#define have_status_msg         (G.have_status_msg    )
+#define last_status_cksum       (G.last_status_cksum  )
+#define current_filename        (G.current_filename   )
+#define screen                  (G.screen             )
+#define screensize              (G.screensize         )
+#define screenbegin             (G.screenbegin        )
+#define tabstop                 (G.tabstop            )
+#define last_forward_char       (G.last_forward_char  )
+#define erase_char              (G.erase_char         )
+#define last_input_char         (G.last_input_char    )
+#if ENABLE_FEATURE_VI_READONLY
+#define readonly_mode           (G.readonly_mode      )
+#else
+#define readonly_mode           0
+#endif
+#define adding2q                (G.adding2q           )
+#define lmc_len                 (G.lmc_len            )
+#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)
+
+#define edit_file__cur_line     (G.edit_file__cur_line)
+#define refresh__old_offset     (G.refresh__old_offset)
+#define format_edit_status__tot (G.format_edit_status__tot)
+
 #define YDreg          (G.YDreg         )
 #define Ureg           (G.Ureg          )
@@ -201 +265 @@
 #define term_vi        (G.term_vi       )
 #define initial_cmds   (G.initial_cmds  )
+#define readbuffer     (G.readbuffer    )
+#define scr_out_buf    (G.scr_out_buf   )
+#define last_modifying_cmd  (G.last_modifying_cmd )
+#define get_input_line__buf (G.get_input_line__buf)
+
+#define INIT_G() do { \
+    SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
+    last_file_modified = -1; \
+    /* "" but has space for 2 chars: */ \
+    IF_FEATURE_VI_SEARCH(last_search_pattern = xzalloc(2);) \
+} while (0)
+
 
 static int init_text_buffer(char *); // init from file or create new
 static void edit_file(char *);  // edit one file
-static void do_cmd(char);   // execute a command
+static void do_cmd(int);    // execute a command
 static int next_tabstop(int);
 static void sync_cursor(char *, int *, int *);  // synchronize the screen cursor to dot
@@ -227 +303 @@
 static char *new_screen(int, int);  // malloc virtual screen memory
 static char *char_insert(char *, char); // insert the char c at 'p'
-static char *stupid_insert(char *, char);   // stupidly insert the char c at 'p'
-static char find_range(char **, char **, char); // return pointers for an object
+// might reallocate text[]! use p += stupid_insert(p, ...),
+// and be careful to not use pointers into potentially freed text[]!
+static uintptr_t stupid_insert(char *, char);   // stupidly insert the char c at 'p'
+static int find_range(char **, char **, char);  // return pointers for an object
 static int st_test(char *, int, int, char *);   // helper for skip_thing()
 static char *skip_thing(char *, int, int, int); // skip some object
 static char *find_pair(char *, char);   // find matching pair ()  []  {}
 static char *text_hole_delete(char *, char *);  // at "p", delete a 'size' byte hole
-static char *text_hole_make(char *, int);   // at "p", make a 'size' byte hole
+// might reallocate text[]! use p += text_hole_make(p, ...),
+// and be careful to not use pointers into potentially freed text[]!
+static uintptr_t text_hole_make(char *, int);   // at "p", make a 'size' byte hole
 static char *yank_delete(char *, char *, int, int); // yank text[] into register then delete
 static void show_help(void);    // display some help info
 static void rawmode(void);  // set "raw" mode on tty
 static void cookmode(void); // return to "cooked" mode on tty
-static int mysleep(int);    // sleep for 'h' 1/100 seconds
-static char readit(void);   // read (maybe cursor) key from stdin
-static char get_one_char(void); // read 1 char from stdin
+// sleep for 'h' 1/100 seconds, return 1/0 if stdin is (ready for read)/(not ready)
+static int mysleep(int);
+static int readit(void);    // read (maybe cursor) key from stdin
+static int get_one_char(void);  // read 1 char from stdin
 static int file_size(const char *);   // what is the byte size of "fn"
-#if ENABLE_FEATURE_VI_READONLY
+#if !ENABLE_FEATURE_VI_READONLY
+#define file_insert(fn, p, update_ro_status) file_insert(fn, p)
+#endif
+// file_insert might reallocate text[]!
 static int file_insert(const char *, char *, int);
-#else
-static int file_insert(const char *, char *);
-#endif
 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 screen_erase(void);
 static void clear_to_eol(void);
 static void clear_to_eos(void);
+static void go_bottom_and_clear_to_eol(void);
 static void standout_start(void);   // send "start reverse video" sequence
 static void standout_end(void); // send "end reverse video" sequence
 static void flash(int);     // flash the terminal screen
 static void show_status_line(void); // put a message on the bottom line
-static void psb(const char *, ...);     // Print Status Buf
-static void psbs(const char *, ...);    // Print Status Buf in standout mode
-static void ni(const char *);       // display messages
+static void status_line(const char *, ...);     // print to status buf
+static void status_line_bold(const char *, ...);
+static void not_implemented(const char *); // display "Not implemented" message
 static int format_edit_status(void);    // format file status on status line
 static void redraw(int);    // force a full screen refresh
-static void format_line(char*, char*, int);
+static char* format_line(char* /*, int*/);
 static void refresh(int);   // update the terminal from screen[]
 
@@ -292 +377 @@
 #endif
 #if ENABLE_FEATURE_VI_YANKMARK || (ENABLE_FEATURE_VI_COLON && ENABLE_FEATURE_VI_SEARCH) || ENABLE_FEATURE_VI_CRASHME
-static char *string_insert(char *, char *); // insert the string at 'p'
+// might reallocate text[]! use p += string_insert(p, ...),
+// and be careful to not use pointers into potentially freed text[]!
+static uintptr_t string_insert(char *, const char *);   // insert the string at 'p'
 #endif
 #if ENABLE_FEATURE_VI_YANKMARK
@@ -311 +398 @@
 }
 
-int vi_main(int argc, char **argv);
+int vi_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int vi_main(int argc, char **argv)
 {
     int c;
-    RESERVE_CONFIG_BUFFER(STATUS_BUFFER, STATUS_BUFFER_LEN);
+
+    INIT_G();
 
 #if ENABLE_FEATURE_VI_USE_SIGNALS || ENABLE_FEATURE_VI_CRASHME
     my_pid = getpid();
 #endif
-
-    PTR_TO_GLOBALS = xzalloc(sizeof(G));
-
 #if ENABLE_FEATURE_VI_CRASHME
     srand((long) my_pid);
 #endif
-
-    status_buffer = STATUS_BUFFER;
-    last_status_cksum = 0;
-    text = NULL;
-
 #ifdef NO_SUCH_APPLET_YET
     /* If we aren't "vi", we are "view" */
@@ -338 +418 @@
 #endif
 
-    vi_setops = VI_AUTOINDENT | VI_SHOWMATCH | VI_IGNORECASE | VI_ERR_METHOD;
-#if ENABLE_FEATURE_VI_YANKMARK
-    memset(reg, 0, sizeof(reg)); // init the yank regs
-#endif
-#if ENABLE_FEATURE_VI_DOT_CMD || ENABLE_FEATURE_VI_YANKMARK
-    modifying_cmds = (char *) "aAcCdDiIJoOpPrRsxX<>~";  // cmds modifying text[]
-#endif
-
+    vi_setops = VI_AUTOINDENT | VI_SHOWMATCH | VI_IGNORECASE;
     //  1-  process $HOME/.exrc file (not inplemented yet)
     //  2-  process EXINIT variable from environment
@@ -353 +426 @@
         char *p = getenv("EXINIT");
         if (p && *p)
-            initial_cmds[0] = xstrdup(p);
-    }
-#endif
-    while ((c = getopt(argc, argv, "hCR" USE_FEATURE_VI_COLON("c:"))) != -1) {
+            initial_cmds[0] = xstrndup(p, MAX_INPUT_LEN);
+    }
+#endif
+    while ((c = getopt(argc, argv, "hCRH" IF_FEATURE_VI_COLON("c:"))) != -1) {
         switch (c) {
 #if ENABLE_FEATURE_VI_CRASHME
@@ -368 +441 @@
             break;
 #endif
-            //case 'r': // recover flag-  ignore- we don't use tmp file
-            //case 'x': // encryption flag- ignore
-            //case 'c': // execute command first
 #if ENABLE_FEATURE_VI_COLON
         case 'c':       // cmd line vi command
             if (*optarg)
-                initial_cmds[initial_cmds[0] != 0] = xstrdup(optarg);
+                initial_cmds[initial_cmds[0] != 0] = xstrndup(optarg, MAX_INPUT_LEN);
             break;
-            //case 'h': // help -- just use default
-#endif
+#endif
+        case 'H':
+            show_help();
+            /* fall through */
         default:
-            show_help();
+            bb_show_usage();
             return 1;
         }
@@ -390 +462 @@
 
     //----- This is the main file handling loop --------------
-    if (optind >= argc) {
-        edit_file(0);
-    } else {
-        for (; optind < argc; optind++) {
-            edit_file(argv[optind]);
-        }
+    while (1) {
+        edit_file(argv[optind]); /* param might be NULL */
+        if (++optind >= argc)
+            break;
     }
     //-----------------------------------------------------------
@@ -411 +481 @@
     /* allocate/reallocate text buffer */
     free(text);
-    text_size = size * 2;
-    if (text_size < 10240)
-        text_size = 10240;  // have a minimum size for new files
+    text_size = size + 10240;
     screenbegin = dot = end = text = xzalloc(text_size);
 
@@ -425 +493 @@
         rc = 0;
     } else {
-        rc = file_insert(fn, text
-            USE_FEATURE_VI_READONLY(, 1));
+        rc = file_insert(fn, text, 1);
     }
     file_modified = 0;
@@ -437 +504 @@
 }
 
-static void edit_file(char * fn)
-{
-    char c;
+#if ENABLE_FEATURE_VI_WIN_RESIZE
+static int query_screen_dimensions(void)
+{
+    int err = get_terminal_width_height(STDIN_FILENO, &columns, &rows);
+    if (rows > MAX_SCR_ROWS)
+        rows = MAX_SCR_ROWS;
+    if (columns > MAX_SCR_COLS)
+        columns = MAX_SCR_COLS;
+    return err;
+}
+#else
+# define query_screen_dimensions() (0)
+#endif
+
+static void edit_file(char *fn)
+{
+#if ENABLE_FEATURE_VI_YANKMARK
+#define cur_line edit_file__cur_line
+#endif
+    int c;
     int size;
-
 #if ENABLE_FEATURE_VI_USE_SIGNALS
     int sig;
 #endif
-#if ENABLE_FEATURE_VI_YANKMARK
-    static char *cur_line;
-#endif
-
-    editing = 1;    // 0= exit,  1= one file, 2= multiple files
+
+    editing = 1;    // 0 = exit, 1 = one file, 2 = multiple files
     rawmode();
     rows = 24;
     columns = 80;
     size = 0;
-    if (ENABLE_FEATURE_VI_WIN_RESIZE)
-        get_terminal_width_height(0, &columns, &rows);
+    IF_FEATURE_VI_ASK_TERMINAL(G.get_rowcol_error =) query_screen_dimensions();
+#if ENABLE_FEATURE_VI_ASK_TERMINAL
+    if (G.get_rowcol_error /* TODO? && no input on stdin */) {
+        uint64_t k;
+        write1("\033[999;999H" "\033[6n");
+        fflush_all();
+        k = read_key(STDIN_FILENO, readbuffer, /*timeout_ms:*/ 100);
+        if ((int32_t)k == KEYCODE_CURSOR_POS) {
+            uint32_t rc = (k >> 32);
+            columns = (rc & 0x7fff);
+            if (columns > MAX_SCR_COLS)
+                columns = MAX_SCR_COLS;
+            rows = ((rc >> 16) & 0x7fff);
+            if (rows > MAX_SCR_ROWS)
+                rows = MAX_SCR_ROWS;
+        }
+    }
+#endif
     new_screen(rows, columns);  // get memory for virtual screen
     init_text_buffer(fn);
@@ -470 +566 @@
 
 #if ENABLE_FEATURE_VI_USE_SIGNALS
-    catch_sig(0);
+    signal(SIGINT, catch_sig);
     signal(SIGWINCH, winch_sig);
     signal(SIGTSTP, suspend_sig);
-    sig = setjmp(restart);
+    sig = sigsetjmp(restart, 1);
     if (sig != 0) {
         screenbegin = dot = text;
@@ -485 +581 @@
     c = '\0';
 #if ENABLE_FEATURE_VI_DOT_CMD
-    free(last_modifying_cmd);
     free(ioq_start);
-    ioq = ioq_start = last_modifying_cmd = NULL;
+    ioq = ioq_start = NULL;
+    lmc_len = 0;
     adding2q = 0;
 #endif
-    redraw(FALSE);          // dont force every col re-draw
 
 #if ENABLE_FEATURE_VI_COLON
@@ -497 +592 @@
         int n = 0;
 
-        while ((p = initial_cmds[n])) {
+        while ((p = initial_cmds[n]) != NULL) {
             do {
                 q = p;
-                p = strchr(q,'\n');
+                p = strchr(q, '\n');
                 if (p)
                     while (*p == '\n')
@@ -513 +608 @@
     }
 #endif
+    redraw(FALSE);          // dont force every col re-draw
     //------This is the main Vi cmd handling loop -----------------------
     while (editing > 0) {
@@ -521 +617 @@
             } else {
                 crashme = 0;
-                dot = string_insert(text, "\n\n#####  Ran out of text to work on.  #####\n\n"); // insert the string
+                string_insert(text, "\n\n#####  Ran out of text to work on.  #####\n\n"); // insert the string
+                dot = text;
                 refresh(FALSE);
             }
@@ -537 +634 @@
         // These are commands that change text[].
         // Remember the input for the "." command
-        if (!adding2q && ioq_start == 0
+        if (!adding2q && ioq_start == NULL
+         && cmd_mode == 0 // command mode
+         && c > '\0' // exclude NUL and non-ASCII chars
+         && c < 0x7f // (Unicode and such)
          && strchr(modifying_cmds, c)
         ) {
@@ -544 +644 @@
 #endif
         do_cmd(c);      // execute the user command
-        //
+
         // poll to see if there is input already waiting. if we are
         // not able to display output fast enough to keep up, skip
         // the display update until we catch up with input.
-        if (mysleep(0) == 0) {
-            // no input pending- so update output
+        if (!readbuffer[0] && mysleep(0) == 0) {
+            // no input pending - so update output
             refresh(FALSE);
             show_status_line();
@@ -560 +660 @@
     //-------------------------------------------------------------------
 
-    place_cursor(rows, 0, FALSE);   // go to bottom of screen
-    clear_to_eol();     // Erase to end of line
+    go_bottom_and_clear_to_eol();
     cookmode();
+#undef cur_line
 }
 
 //----- The Colon commands -------------------------------------
 #if ENABLE_FEATURE_VI_COLON
-static char *get_one_address(char * p, int *addr)   // get colon addr, if present
+static char *get_one_address(char *p, int *addr)    // get colon addr, if present
 {
     int st;
     char *q;
-
-#if ENABLE_FEATURE_VI_YANKMARK
-    char c;
-#endif
-#if ENABLE_FEATURE_VI_SEARCH
-    char *pat, buf[MAX_LINELEN];
-#endif
+    IF_FEATURE_VI_YANKMARK(char c;)
+    IF_FEATURE_VI_SEARCH(char *pat;)
 
     *addr = -1;         // assume no addr
@@ -584 +679 @@
         q = begin_line(dot);
         *addr = count_lines(text, q);
+    }
 #if ENABLE_FEATURE_VI_YANKMARK
-    } else if (*p == '\'') {    // is this a mark addr
+    else if (*p == '\'') {  // is this a mark addr
         p++;
         c = tolower(*p);
@@ -594 +690 @@
             q = mark[(unsigned char) c];
             if (q != NULL) {    // is mark valid
-                *addr = count_lines(text, q);   // count lines
+                *addr = count_lines(text, q);
             }
         }
+    }
 #endif
 #if ENABLE_FEATURE_VI_SEARCH
-    } else if (*p == '/') { // a search pattern
-        q = buf;
-        for (p++; *p; p++) {
-            if (*p == '/')
-                break;
-            *q++ = *p;
-            *q = '\0';
-        }
-        pat = xstrdup(buf); // save copy of pattern
+    else if (*p == '/') {   // a search pattern
+        q = strchrnul(++p, '/');
+        pat = xstrndup(p, q - p); // save copy of pattern
+        p = q;
         if (*p == '/')
             p++;
@@ -615 +707 @@
         }
         free(pat);
-#endif
-    } else if (*p == '$') { // the last line in file
+    }
+#endif
+    else if (*p == '$') {   // the last line in file
         p++;
         q = begin_line(end - 1);
@@ -623 +716 @@
         sscanf(p, "%d%n", addr, &st);
         p += st;
-    } else {            // I don't reconise this
-        // unrecognised address- assume -1
+    } else {
+        // unrecognized address - assume -1
         *addr = -1;
     }
@@ -665 +758 @@
     int l = strlen(opname) - 1; /* opname have + ' ' */
 
+    // maybe strncmp? we had tons of erroneous strncasecmp's...
     if (strncasecmp(a, opname, l) == 0
      || strncasecmp(a, short_opname, 2) == 0
@@ -676 +770 @@
 #endif
 
-static void colon(char * buf)
+// buf must be no longer than MAX_INPUT_LEN!
+static void colon(char *buf)
 {
     char c, *orig_buf, *buf1, *q, *r;
-    char *fn, cmd[MAX_LINELEN], args[MAX_LINELEN];
+    char *fn, cmd[MAX_INPUT_LEN], args[MAX_INPUT_LEN];
     int i, l, li, ch, b, e;
-    int useforce = FALSE, forced = FALSE;
+    int useforce, forced = FALSE;
 
     // :3154    // if (-e line 3154) goto it  else stay put
@@ -699 +794 @@
 
     if (!buf[0])
-        goto vc1;
+        goto ret;
     if (*buf == ':')
         buf++;          // move past the ':'
@@ -708 +803 @@
     r = end - 1;
     li = count_lines(text, end - 1);
-    fn = current_filename;          // default to current file
-    memset(cmd, '\0', MAX_LINELEN); // clear cmd[]
-    memset(args, '\0', MAX_LINELEN);    // clear args[]
+    fn = current_filename;
 
     // look for optional address(es)  :.  :1  :1,9   :'q,'a   :%
@@ -725 +818 @@
         *buf1++ = *buf++;
     }
+    *buf1 = '\0';
     // get any ARGuments
     while (isblank(*buf))
         buf++;
     strcpy(args, buf);
+    useforce = FALSE;
     buf1 = last_char_is(cmd, '!');
     if (buf1) {
@@ -759 +854 @@
     }
 #if ENABLE_FEATURE_ALLOW_EXEC
-    else if (strncmp(cmd, "!", 1) == 0) {   // run a cmd
+    else if (cmd[0] == '!') {   // run a cmd
         int retcode;
         // :!ls   run the <cmd>
-        alarm(0);       // wait for input- no alarms
-        place_cursor(rows - 1, 0, FALSE);   // go to Status line
-        clear_to_eol();         // clear the line
+        go_bottom_and_clear_to_eol();
         cookmode();
         retcode = system(orig_buf + 1); // run the cmd
@@ -771 +864 @@
         rawmode();
         Hit_Return();           // let user see results
-        alarm(3);       // done waiting for input
-    }
-#endif
-    else if (strncmp(cmd, "=", i) == 0) {   // where is the address
+    }
+#endif
+    else if (cmd[0] == '=' && !cmd[1]) {    // where is the address
         if (b < 0) {    // no addr given- use defaults
             b = e = count_lines(text, dot);
         }
-        psb("%d", b);
-    } else if (strncasecmp(cmd, "delete", i) == 0) {    // delete lines
+        status_line("%d", b);
+    } else if (strncmp(cmd, "delete", i) == 0) {    // delete lines
         if (b < 0) {    // no addr given- use defaults
             q = begin_line(dot);    // assume .,. for the range
@@ -786 +878 @@
         dot = yank_delete(q, r, 1, YANKDEL);    // save, then delete lines
         dot_skip_over_ws();
-    } else if (strncasecmp(cmd, "edit", i) == 0) {  // Edit a file
+    } else if (strncmp(cmd, "edit", i) == 0) {  // Edit a file
         // don't edit, if the current file has been modified
-        if (file_modified && ! useforce) {
-            psbs("No write since last change (:edit! overrides)");
-            goto vc1;
+        if (file_modified && !useforce) {
+            status_line_bold("No write since last change (:edit! overrides)");
+            goto ret;
         }
         if (args[0]) {
@@ -800 +892 @@
         } else {
             // no user file name, no current name- punt
-            psbs("No current filename");
-            goto vc1;
+            status_line_bold("No current filename");
+            goto ret;
         }
 
         if (init_text_buffer(fn) < 0)
-            goto vc1;
+            goto ret;
 
 #if ENABLE_FEATURE_VI_YANKMARK
@@ -819 +911 @@
         // how many lines in text[]?
         li = count_lines(text, end - 1);
-        psb("\"%s\"%s"
-            USE_FEATURE_VI_READONLY("%s")
+        status_line("\"%s\"%s"
+            IF_FEATURE_VI_READONLY("%s")
             " %dL, %dC", current_filename,
             (file_size(fn) < 0 ? " [New file]" : ""),
-            USE_FEATURE_VI_READONLY(
+            IF_FEATURE_VI_READONLY(
                 ((readonly_mode) ? " [Readonly]" : ""),
             )
             li, ch);
-    } else if (strncasecmp(cmd, "file", i) == 0) {  // what File is this
+    } else if (strncmp(cmd, "file", i) == 0) {  // what File is this
         if (b != -1 || e != -1) {
-            ni("No address allowed on this command");
-            goto vc1;
+            status_line_bold("No address allowed on this command");
+            goto ret;
         }
         if (args[0]) {
@@ -840 +932 @@
             last_status_cksum = 0;  // force status update
         }
-    } else if (strncasecmp(cmd, "features", i) == 0) {  // what features are available
+    } else if (strncmp(cmd, "features", i) == 0) {  // what features are available
         // print out values of all features
-        place_cursor(rows - 1, 0, FALSE);   // go to Status line, bottom of screen
-        clear_to_eol(); // clear the line
+        go_bottom_and_clear_to_eol();
         cookmode();
         show_help();
         rawmode();
         Hit_Return();
-    } else if (strncasecmp(cmd, "list", i) == 0) {  // literal print line
+    } else if (strncmp(cmd, "list", i) == 0) {  // literal print line
         if (b < 0) {    // no addr given- use defaults
             q = begin_line(dot);    // assume .,. for the range
             r = end_line(dot);
         }
-        place_cursor(rows - 1, 0, FALSE);   // go to Status line, bottom of screen
-        clear_to_eol(); // clear the line
+        go_bottom_and_clear_to_eol();
         puts("\r");
         for (; q <= r; q++) {
@@ -864 +954 @@
                 c = '.';
                 standout_start();
-                }
+            }
             if (c == '\n') {
                 write1("$\r");
             } else if (c < ' ' || c == 127) {
-                putchar('^');
+                bb_putchar('^');
                 if (c == 127)
                     c = '?';
@@ -874 +964 @@
                     c += '@';
             }
-            putchar(c);
+            bb_putchar(c);
             if (c_is_no_print)
                 standout_end();
         }
-#if ENABLE_FEATURE_VI_SET
- vc2:
-#endif
         Hit_Return();
-    } else if (strncasecmp(cmd, "quit", i) == 0 // Quit
-            || strncasecmp(cmd, "next", i) == 0 // edit next file
+    } else if (strncmp(cmd, "quit", i) == 0 // quit
+            || strncmp(cmd, "next", i) == 0 // edit next file
     ) {
+        int n;
         if (useforce) {
             // force end of argv list
@@ -891 +979 @@
             }
             editing = 0;
-            goto vc1;
+            goto ret;
         }
         // don't exit if the file been modified
         if (file_modified) {
-            psbs("No write since last change (:%s! overrides)",
+            status_line_bold("No write since last change (:%s! overrides)",
                  (*cmd == 'q' ? "quit" : "next"));
-            goto vc1;
+            goto ret;
         }
         // are there other file to edit
-        if (*cmd == 'q' && optind < save_argc - 1) {
-            psbs("%d more file to edit", (save_argc - optind - 1));
-            goto vc1;
-        }
-        if (*cmd == 'n' && optind >= save_argc - 1) {
-            psbs("No more files to edit");
-            goto vc1;
+        n = save_argc - optind - 1;
+        if (*cmd == 'q' && n > 0) {
+            status_line_bold("%d more file(s) to edit", n);
+            goto ret;
+        }
+        if (*cmd == 'n' && n <= 0) {
+            status_line_bold("No more files to edit");
+            goto ret;
         }
         editing = 0;
-    } else if (strncasecmp(cmd, "read", i) == 0) {  // read file into text[]
+    } else if (strncmp(cmd, "read", i) == 0) {  // read file into text[]
         fn = args;
         if (!fn[0]) {
-            psbs("No filename given");
-            goto vc1;
+            status_line_bold("No filename given");
+            goto ret;
         }
         if (b < 0) {    // no addr given- use defaults
@@ -921 +1010 @@
         if (b != 0)
             q = next_line(q);
-        ch = file_insert(fn, q  USE_FEATURE_VI_READONLY(, 0));
+        { // dance around potentially-reallocated text[]
+            uintptr_t ofs = q - text;
+            ch = file_insert(fn, q, 0);
+            q = text + ofs;
+        }
         if (ch < 0)
-            goto vc1;   // nothing was inserted
+            goto ret;   // nothing was inserted
         // how many lines in text[]?
         li = count_lines(q, q + ch - 1);
-        psb("\"%s\""
-            USE_FEATURE_VI_READONLY("%s")
+        status_line("\"%s\""
+            IF_FEATURE_VI_READONLY("%s")
             " %dL, %dC", fn,
-            USE_FEATURE_VI_READONLY((readonly_mode ? " [Readonly]" : ""),)
+            IF_FEATURE_VI_READONLY((readonly_mode ? " [Readonly]" : ""),)
             li, ch);
         if (ch > 0) {
@@ -935 +1028 @@
             if (q <= dot)
                 dot += ch;
-            file_modified++;
-        }
-    } else if (strncasecmp(cmd, "rewind", i) == 0) {    // rewind cmd line args
-        if (file_modified && ! useforce) {
-            psbs("No write since last change (:rewind! overrides)");
+            /*file_modified++; - done by file_insert */
+        }
+    } 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)");
         } else {
             // reset the filenames to edit
@@ -946 +1039 @@
         }
 #if ENABLE_FEATURE_VI_SET
-    } else if (strncasecmp(cmd, "set", i) == 0) {   // set or clear features
+    } else if (strncmp(cmd, "set", i) == 0) {   // set or clear features
 #if ENABLE_FEATURE_VI_SETOPTS
         char *argp;
@@ -954 +1047 @@
         if (!args[0] || strcasecmp(args, "all") == 0) {
             // print out values of all options
-            place_cursor(rows - 1, 0, FALSE);   // go to Status line, bottom of screen
-            clear_to_eol(); // clear the line
-            printf("----------------------------------------\r\n");
 #if ENABLE_FEATURE_VI_SETOPTS
-            if (!autoindent)
-                printf("no");
-            printf("autoindent ");
-            if (!err_method)
-                printf("no");
-            printf("flash ");
-            if (!ignorecase)
-                printf("no");
-            printf("ignorecase ");
-            if (!showmatch)
-                printf("no");
-            printf("showmatch ");
-            printf("tabstop=%d ", tabstop);
-#endif
-            printf("\r\n");
-            goto vc2;
+            status_line_bold(
+                "%sautoindent "
+                "%sflash "
+                "%signorecase "
+                "%sshowmatch "
+                "tabstop=%u",
+                autoindent ? "" : "no",
+                err_method ? "" : "no",
+                ignorecase ? "" : "no",
+                showmatch ? "" : "no",
+                tabstop
+            );
+#endif
+            goto ret;
         }
 #if ENABLE_FEATURE_VI_SETOPTS
         argp = args;
         while (*argp) {
-            if (strncasecmp(argp, "no", 2) == 0)
+            if (strncmp(argp, "no", 2) == 0)
                 i = 2;      // ":set noautoindent"
             setops(argp, "autoindent ", i, "ai", VI_AUTOINDENT);
-            setops(argp, "flash ", i, "fl", VI_ERR_METHOD);
+            setops(argp, "flash "     , i, "fl", VI_ERR_METHOD);
             setops(argp, "ignorecase ", i, "ic", VI_IGNORECASE);
-            setops(argp, "showmatch ", i, "ic", VI_SHOWMATCH);
-            /* tabstopXXXX */
-            if (strncasecmp(argp + i, "tabstop=%d ", 7) == 0) {
-                sscanf(strchr(argp + i, '='), "tabstop=%d" + 7, &ch);
-                if (ch > 0 && ch < columns - 1)
-                    tabstop = ch;
+            setops(argp, "showmatch " , i, "sm", VI_SHOWMATCH );
+            if (strncmp(argp + i, "tabstop=", 8) == 0) {
+                int t = 0;
+                sscanf(argp + i+8, "%u", &t);
+                if (t > 0 && t <= MAX_TABSTOP)
+                    tabstop = t;
             }
-            while (*argp && *argp != ' ')
-                argp++; // skip to arg delimiter (i.e. blank)
-            while (*argp && *argp == ' ')
-                argp++; // skip all delimiting blanks
+            argp = skip_non_whitespace(argp);
+            argp = skip_whitespace(argp);
         }
 #endif /* FEATURE_VI_SETOPTS */
 #endif /* FEATURE_VI_SET */
 #if ENABLE_FEATURE_VI_SEARCH
-    } else if (strncasecmp(cmd, "s", 1) == 0) { // substitute a pattern with a replacement pattern
+    } else if (cmd[0] == 's') { // substitute a pattern with a replacement pattern
         char *ls, *F, *R;
         int gflag;
@@ -1009 +1095 @@
         F = orig_buf + 2;   // start of "find"
         R = strchr(F, c);   // middle delimiter
-        if (!R) goto colon_s_fail;
+        if (!R)
+            goto colon_s_fail;
         *R++ = '\0';    // terminate "find"
         buf1 = strchr(R, c);
-        if (!buf1) goto colon_s_fail;
+        if (!buf1)
+            goto colon_s_fail;
         *buf1++ = '\0'; // terminate "replace"
         if (*buf1 == 'g') { // :s/foo/bar/g
@@ -1030 +1118 @@
             buf1 = char_search(q, F, FORWARD, LIMITED); // search cur line only for "find"
             if (buf1) {
+                uintptr_t bias;
                 // we found the "find" pattern - delete it
                 text_hole_delete(buf1, buf1 + strlen(F) - 1);
                 // inset the "replace" patern
-                string_insert(buf1, R); // insert the string
+                bias = string_insert(buf1, R);  // insert the string
+                buf1 += bias;
+                ls += bias;
+                /*q += bias; - recalculated anyway */
                 // check for "global"  :s/foo/bar/g
                 if (gflag == 1) {
@@ -1045 +1137 @@
         }
 #endif /* FEATURE_VI_SEARCH */
-    } else if (strncasecmp(cmd, "version", i) == 0) {  // show software version
-        psb("%s", BB_VER " " BB_BT);
-    } else if (strncasecmp(cmd, "write", i) == 0  // write text to file
-            || strncasecmp(cmd, "wq", i) == 0
-            || strncasecmp(cmd, "wn", i) == 0
-            || strncasecmp(cmd, "x", i) == 0
+    } else if (strncmp(cmd, "version", i) == 0) {  // show software version
+        status_line(BB_VER " " BB_BT);
+    } else if (strncmp(cmd, "write", i) == 0  // write text to file
+            || strncmp(cmd, "wq", i) == 0
+            || strncmp(cmd, "wn", i) == 0
+            || (cmd[0] == 'x' && !cmd[1])
     ) {
         // is there a file name to write to?
@@ -1058 +1150 @@
 #if ENABLE_FEATURE_VI_READONLY
         if (readonly_mode && !useforce) {
-            psbs("\"%s\" File is read only", fn);
-            goto vc3;
+            status_line_bold("\"%s\" File is read only", fn);
+            goto ret;
         }
 #endif
@@ -1081 +1173 @@
         if (l < 0) {
             if (l == -1)
-                psbs("\"%s\" %s", fn, strerror(errno));
+                status_line_bold("\"%s\" %s", fn, strerror(errno));
         } else {
-            psb("\"%s\" %dL, %dC", fn, li, l);
+            status_line("\"%s\" %dL, %dC", fn, li, l);
             if (q == text && r == end - 1 && l == ch) {
                 file_modified = 0;
                 last_file_modified = -1;
             }
-            if ((cmd[0] == 'x' || cmd[1] == 'q' || cmd[1] == 'n' ||
-                 cmd[0] == 'X' || cmd[1] == 'Q' || cmd[1] == 'N')
-                 && l == ch) {
+            if ((cmd[0] == 'x' || cmd[1] == 'q' || cmd[1] == 'n'
+                || cmd[0] == 'X' || cmd[1] == 'Q' || cmd[1] == 'N'
+                )
+             && l == ch
+            ) {
                 editing = 0;
             }
         }
-#if ENABLE_FEATURE_VI_READONLY
- vc3:;
-#endif
 #if ENABLE_FEATURE_VI_YANKMARK
-    } else if (strncasecmp(cmd, "yank", i) == 0) {  // yank lines
+    } else if (strncmp(cmd, "yank", i) == 0) {  // yank lines
         if (b < 0) {    // no addr given- use defaults
             q = begin_line(dot);    // assume .,. for the range
@@ -1105 +1196 @@
         text_yank(q, r, YDreg);
         li = count_lines(q, r);
-        psb("Yank %d lines (%d chars) into [%c]",
+        status_line("Yank %d lines (%d chars) into [%c]",
                 li, strlen(reg[YDreg]), what_reg());
 #endif
     } else {
         // cmd unknown
-        ni(cmd);
-    }
- vc1:
+        not_implemented(cmd);
+    }
+ ret:
     dot = bound_dot(dot);   // make sure "dot" is valid
     return;
 #if ENABLE_FEATURE_VI_SEARCH
  colon_s_fail:
-    psb(":s expression missing delimiters");
+    status_line(":s expression missing delimiters");
 #endif
 }
@@ -1125 +1216 @@
 static void Hit_Return(void)
 {
-    char c;
-
-    standout_start();   // start reverse video
+    int c;
+
+    standout_start();
     write1("[Hit return to continue]");
-    standout_end();     // end reverse video
-    while ((c = get_one_char()) != '\n' && c != '\r')   /*do nothing */
-        ;
+    standout_end();
+    while ((c = get_one_char()) != '\n' && c != '\r')
+        continue;
     redraw(TRUE);       // force redraw all
 }
@@ -1141 +1232 @@
 
 //----- Synchronize the cursor to Dot --------------------------
-static void sync_cursor(char * d, int *row, int *col)
+static NOINLINE void sync_cursor(char *d, int *row, int *col)
 {
     char *beg_cur;  // begin and end of "d" line
-    char *end_scr;  // begin and end of screen
     char *tp;
     int cnt, ro, co;
@@ -1150 +1240 @@
     beg_cur = begin_line(d);    // first char of cur line
 
-    end_scr = end_screen(); // last char of screen
-
     if (beg_cur < screenbegin) {
-        // "d" is before  top line on screen
+        // "d" is before top line on screen
         // how many lines do we have to move
         cnt = count_lines(beg_cur, screenbegin);
@@ -1164 +1252 @@
             }
         }
-    } else if (beg_cur > end_scr) {
-        // "d" is after bottom line on screen
-        // how many lines do we have to move
-        cnt = count_lines(end_scr, beg_cur);
-        if (cnt > (rows - 1) / 2)
-            goto sc1;   // too many lines
-        for (ro = 0; ro < cnt - 1; ro++) {
-            // move screen begin the same amount
-            screenbegin = next_line(screenbegin);
-            // now, move the end of screen
-            end_scr = next_line(end_scr);
-            end_scr = end_line(end_scr);
+    } else {
+        char *end_scr;  // begin and end of screen
+        end_scr = end_screen(); // last char of screen
+        if (beg_cur > end_scr) {
+            // "d" is after bottom line on screen
+            // how many lines do we have to move
+            cnt = count_lines(end_scr, beg_cur);
+            if (cnt > (rows - 1) / 2)
+                goto sc1;   // too many lines
+            for (ro = 0; ro < cnt - 1; ro++) {
+                // move screen begin the same amount
+                screenbegin = next_line(screenbegin);
+                // now, move the end of screen
+                end_scr = next_line(end_scr);
+                end_scr = end_line(end_scr);
+            }
         }
     }
@@ -1188 +1280 @@
     // find out what col "d" is on
     co = 0;
-    do {                // drive "co" to correct column
-        if (*tp == '\n' || *tp == '\0')
+    while (tp < d) { // drive "co" to correct column
+        if (*tp == '\n') //vda || *tp == '\0')
             break;
         if (*tp == '\t') {
-            if (d == tp && cmd_mode) { /* handle tabs like real vi */
+            // handle tabs like real vi
+            if (d == tp && cmd_mode) {
                 break;
-            } else {
-                co = next_tabstop(co);
             }
-        } else if (*tp < ' ' || *tp == 127) {
-            co++;       // display as ^X, use 2 columns
-        }
-    } while (tp++ < d && ++co);
+            co = next_tabstop(co);
+        } else if ((unsigned char)*tp < ' ' || *tp == 0x7f) {
+            co++; // display as ^X, use 2 columns
+        }
+        co++;
+        tp++;
+    }
 
     // "co" is the column where "dot" is.
@@ -1233 +1327 @@
 
 //----- Text Movement Routines ---------------------------------
-static char *begin_line(char * p) // return pointer to first char cur line
-{
-    while (p > text && p[-1] != '\n')
-        p--;            // go to cur line B-o-l
+static char *begin_line(char *p) // return pointer to first char cur line
+{
+    if (p > text) {
+        p = memrchr(text, '\n', p - text);
+        if (!p)
+            return text;
+        return p + 1;
+    }
     return p;
 }
 
-static char *end_line(char * p) // return pointer to NL of cur line line
-{
-    while (p < end - 1 && *p != '\n')
-        p++;            // go to cur line E-o-l
+static char *end_line(char *p) // return pointer to NL of cur line
+{
+    if (p < end - 1) {
+        p = memchr(p, '\n', end - p - 1);
+        if (!p)
+            return end - 1;
+    }
     return p;
 }
 
-static inline char *dollar_line(char * p) // return pointer to just before NL line
-{
-    while (p < end - 1 && *p != '\n')
-        p++;            // go to cur line E-o-l
+static char *dollar_line(char *p) // return pointer to just before NL line
+{
+    p = end_line(p);
     // Try to stay off of the Newline
     if (*p == '\n' && (p - begin_line(p)) > 0)
@@ -1257 +1357 @@
 }
 
-static char *prev_line(char * p) // return pointer first char prev line
+static char *prev_line(char *p) // return pointer first char prev line
 {
     p = begin_line(p);  // goto begining of cur line
-    if (p[-1] == '\n' && p > text)
+    if (p > text && p[-1] == '\n')
         p--;            // step to prev line
     p = begin_line(p);  // goto begining of prev line
@@ -1266 +1366 @@
 }
 
-static char *next_line(char * p) // return pointer first char next line
+static char *next_line(char *p) // return pointer first char next line
 {
     p = end_line(p);
-    if (*p == '\n' && p < end - 1)
+    if (p < end - 1 && *p == '\n')
         p++;            // step to next line
     return p;
@@ -1288 +1388 @@
 }
 
-static int count_lines(char * start, char * stop) // count line from start to stop
+// count line from start to stop
+static int count_lines(char *start, char *stop)
 {
     char *q;
     int cnt;
 
-    if (stop < start) { // start and stop are backwards- reverse them
+    if (stop < start) { // start and stop are backwards- reverse them
         q = start;
         start = stop;
@@ -1299 +1400 @@
     }
     cnt = 0;
-    stop = end_line(stop);  // get to end of this line
-    for (q = start; q <= stop && q <= end - 1; q++) {
-        if (*q == '\n')
+    stop = end_line(stop);
+    while (start <= stop && start <= end - 1) {
+        start = end_line(start);
+        if (*start == '\n')
             cnt++;
+        start++;
     }
     return cnt;
@@ -1340 +1443 @@
 }
 
-static char *move_to_col(char * p, int l)
+static char *move_to_col(char *p, int l)
 {
     int co;
@@ -1346 +1449 @@
     p = begin_line(p);
     co = 0;
-    do {
-        if (*p == '\n' || *p == '\0')
+    while (co < l && p < end) {
+        if (*p == '\n') //vda || *p == '\0')
             break;
         if (*p == '\t') {
             co = next_tabstop(co);
         } else if (*p < ' ' || *p == 127) {
-            co++;       // display as ^X, use 2 columns
-        }
-    } while (++co <= l && p++ < end);
+            co++; // display as ^X, use 2 columns
+        }
+        co++;
+        p++;
+    }
     return p;
 }
@@ -1375 +1480 @@
         if (dir < 0) {
             // scroll Backwards
-            // ctrl-Y  scroll up one line
+            // ctrl-Y scroll up one line
             screenbegin = prev_line(screenbegin);
         } else {
             // scroll Forwards
-            // ctrl-E  scroll down one line
+            // ctrl-E scroll down one line
             screenbegin = next_line(screenbegin);
         }
@@ -1404 +1509 @@
 }
 
-static char *bound_dot(char * p) // make sure  text[0] <= P < "end"
+static char *bound_dot(char *p) // make sure  text[0] <= P < "end"
 {
     if (p >= end && end > text) {
@@ -1447 +1552 @@
 
 #if ENABLE_FEATURE_VI_SEARCH
-static int mycmp(const char * s1, const char * s2, int len)
-{
-    int i;
-
-    i = strncmp(s1, s2, len);
+static int mycmp(const char *s1, const char *s2, int len)
+{
     if (ENABLE_FEATURE_VI_SETOPTS && ignorecase) {
-        i = strncasecmp(s1, s2, len);
-    }
-    return i;
+        return strncasecmp(s1, s2, len);
+    }
+    return strncmp(s1, s2, len);
 }
 
 // search for pattern starting at p
-static char *char_search(char * p, const char * pat, int dir, int range)
+static char *char_search(char *p, const char *pat, int dir, int range)
 {
 #ifndef REGEX_SEARCH
@@ -1517 +1619 @@
     if (q != 0) {
         // The pattern was not compiled
-        psbs("bad search pattern: \"%s\": %s", pat, q);
+        status_line_bold("bad search pattern: \"%s\": %s", pat, q);
         i = 0;          // return p if pattern not compiled
         goto cs1;
@@ -1552 +1654 @@
 #endif /* FEATURE_VI_SEARCH */
 
-static char *char_insert(char * p, char c) // insert the char c at 'p'
+static char *char_insert(char *p, char c) // insert the char c at 'p'
 {
     if (c == 22) {      // Is this an ctrl-V?
-        p = stupid_insert(p, '^');  // use ^ to indicate literal next
-        p--;            // backup onto ^
+        p += stupid_insert(p, '^'); // use ^ to indicate literal next
         refresh(FALSE); // show the ^
         c = get_one_char();
         *p = c;
         p++;
-        file_modified++;    // has the file been modified
+        file_modified++;
     } else if (c == 27) {   // Is this an ESC?
         cmd_mode = 0;
@@ -1583 +1684 @@
             c = '\n';   // translate \r to \n
         sp = p;         // remember addr of insert
-        p = stupid_insert(p, c);    // insert the char
+        p += 1 + stupid_insert(p, c);   // insert the char
 #if ENABLE_FEATURE_VI_SETOPTS
         if (showmatch && strchr(")]}", *sp) != NULL) {
@@ -1590 +1691 @@
         if (autoindent && c == '\n') {  // auto indent the new line
             char *q;
-
-            q = prev_line(p);   // use prev line as templet
-            for (; isblank(*q); q++) {
-                p = stupid_insert(p, *q);   // insert the char
+            size_t len;
+            q = prev_line(p);   // use prev line as template
+            len = strspn(q, " \t"); // space or tab
+            if (len) {
+                uintptr_t bias;
+                bias = text_hole_make(p, len);
+                p += bias;
+                q += bias;
+                memcpy(p, q, len);
+                p += len;
             }
         }
@@ -1601 +1708 @@
 }
 
-static char *stupid_insert(char * p, char c) // stupidly insert the char c at 'p'
-{
-    p = text_hole_make(p, 1);
-    if (p != 0) {
-        *p = c;
-        file_modified++;    // has the file been modified
-        p++;
-    }
-    return p;
-}
-
-static char find_range(char ** start, char ** stop, char c)
-{
-    char *save_dot, *p, *q;
-    int cnt;
+// might reallocate text[]! use p += stupid_insert(p, ...),
+// and be careful to not use pointers into potentially freed text[]!
+static uintptr_t stupid_insert(char *p, char c) // stupidly insert the char c at 'p'
+{
+    uintptr_t bias;
+    bias = text_hole_make(p, 1);
+    p += bias;
+    *p = c;
+    //file_modified++; - done by text_hole_make()
+    return bias;
+}
+
+static int find_range(char **start, char **stop, char c)
+{
+    char *save_dot, *p, *q, *t;
+    int cnt, multiline = 0;
 
     save_dot = dot;
@@ -1627 +1735 @@
         }
         q = end_line(q);
-    } else if (strchr("^%$0bBeEft", c)) {
+    } else if (strchr("^%$0bBeEfth\b\177", c)) {
         // These cmds operate on char positions
         do_cmd(c);      // execute movement cmd
@@ -1656 +1764 @@
         q = dot;
     } else {
-        c = 27;         // error- return an ESC char
-        //break;
-    }
+        // 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) {
+        t = q;
+        q = p;
+        p = t;
+    }
+
+    // backward char movements don't include start position
+    if (q > p && strchr("^0bBh\b\177", c)) q--;
+
+    multiline = 0;
+    for (t = p; t <= q; t++) {
+        if (*t == '\n') {
+            multiline = 1;
+            break;
+        }
+    }
+
     *start = p;
     *stop = q;
-    if (q < p) {
-        *start = q;
-        *stop = p;
-    }
     dot = save_dot;
-    return c;
-}
-
-static int st_test(char * p, int type, int dir, char * tested)
+    return multiline;
+}
+
+static int st_test(char *p, int type, int dir, char *tested)
 {
     char c, c0, ci;
@@ -1681 +1805 @@
     if (type == S_BEFORE_WS) {
         c = ci;
-        test = ((!isspace(c)) || c == '\n');
+        test = (!isspace(c) || c == '\n');
     }
     if (type == S_TO_WS) {
         c = c0;
-        test = ((!isspace(c)) || c == '\n');
+        test = (!isspace(c) || c == '\n');
     }
     if (type == S_OVER_WS) {
         c = c0;
-        test = ((isspace(c)));
+        test = isspace(c);
     }
     if (type == S_END_PUNCT) {
         c = ci;
-        test = ((ispunct(c)));
+        test = ispunct(c);
     }
     if (type == S_END_ALNUM) {
         c = ci;
-        test = ((isalnum(c)) || c == '_');
+        test = (isalnum(c) || c == '_');
     }
     *tested = c;
@@ -1703 +1827 @@
 }
 
-static char *skip_thing(char * p, int linecnt, int dir, int type)
+static char *skip_thing(char *p, int linecnt, int dir, int type)
 {
     char c;
@@ -1721 +1845 @@
 
 // find matching char of pair  ()  []  {}
-static char *find_pair(char * p, char c)
+static char *find_pair(char *p, const char c)
 {
     char match, *q;
@@ -1730 +1854 @@
     dir = 1;            // assume forward
     switch (c) {
-    case '(':
-        match = ')';
-        break;
-    case '[':
-        match = ']';
-        break;
-    case '{':
-        match = '}';
-        break;
-    case ')':
-        match = '(';
-        dir = -1;
-        break;
-    case ']':
-        match = '[';
-        dir = -1;
-        break;
-    case '}':
-        match = '{';
-        dir = -1;
-        break;
+    case '(': match = ')'; break;
+    case '[': match = ']'; break;
+    case '{': match = '}'; break;
+    case ')': match = '('; dir = -1; break;
+    case ']': match = '['; dir = -1; break;
+    case '}': match = '{'; dir = -1; break;
     }
     for (q = p + dir; text <= q && q < end; q += dir) {
@@ -1768 +1877 @@
 #if ENABLE_FEATURE_VI_SETOPTS
 // show the matching char of a pair,  ()  []  {}
-static void showmatching(char * p)
+static void showmatching(char *p)
 {
     char *q, *save_dot;
@@ -1788 +1897 @@
 #endif /* FEATURE_VI_SETOPTS */
 
-//  open a hole in text[]
-static char *text_hole_make(char * p, int size) // at "p", make a 'size' byte hole
-{
-    char *src, *dest;
-    int cnt;
+// open a hole in text[]
+// might reallocate text[]! use p += text_hole_make(p, ...),
+// and be careful to not use pointers into potentially freed text[]!
+static uintptr_t text_hole_make(char *p, int size)  // at "p", make a 'size' byte hole
+{
+    uintptr_t bias = 0;
 
     if (size <= 0)
-        goto thm0;
-    src = p;
-    dest = p + size;
-    cnt = end - src;    // the rest of buffer
-    if ( ((end + size) >= (text + text_size)) // TODO: realloc here
-            || memmove(dest, src, cnt) != dest) {
-        psbs("can't create room for new characters");
-        p = NULL;
-        goto thm0;
-    }
+        return bias;
+    end += size;        // adjust the new END
+    if (end >= (text + text_size)) {
+        char *new_text;
+        text_size += end - (text + text_size) + 10240;
+        new_text = xrealloc(text, text_size);
+        bias = (new_text - text);
+        screenbegin += bias;
+        dot         += bias;
+        end         += bias;
+        p           += bias;
+        text = new_text;
+    }
+    memmove(p + size, p, end - size - p);
     memset(p, ' ', size);   // clear new hole
-    end += size;        // adjust the new END
-    file_modified++;    // has the file been modified
- thm0:
-    return p;
+    file_modified++;
+    return bias;
 }
 
 //  close a hole in text[]
-static char *text_hole_delete(char * p, char * q) // delete "p" thru "q", inclusive
+static char *text_hole_delete(char *p, char *q) // delete "p" through "q", inclusive
 {
     char *src, *dest;
@@ -1834 +1946 @@
     if (src >= end)
         goto thd_atend; // just delete the end of the buffer
-    if (memmove(dest, src, cnt) != dest) {
-        psbs("can't delete the character");
-    }
+    memmove(dest, src, cnt);
  thd_atend:
     end = end - hole_size;  // adjust the new END
@@ -1843 +1953 @@
     if (end <= text)
         dest = end = text;  // keep pointers valid
-    file_modified++;    // has the file been modified
+    file_modified++;
  thd0:
     return dest;
@@ -1851 +1961 @@
 // if dist <= 0, do not include, or go past, a NewLine
 //
-static char *yank_delete(char * start, char * stop, int dist, int yf)
+static char *yank_delete(char *start, char *stop, int dist, int yf)
 {
     char *p;
@@ -1895 +2005 @@
 #endif
 #if ENABLE_FEATURE_VI_YANKMARK
-    "\n\tLine marking with  'x"
-    "\n\tNamed buffers with  \"x"
+    "\n\tLine marking with 'x"
+    "\n\tNamed buffers with \"x"
 #endif
 #if ENABLE_FEATURE_VI_READONLY
@@ -1918 +2028 @@
 }
 
-static inline void print_literal(char * buf, const char * s) // copy s to buf, convert unprintable
-{
-    unsigned char c;
-    char b[2];
-
-    b[1] = '\0';
-    buf[0] = '\0';
-    if (!s[0])
-        s = "(NULL)";
-    for (; *s; s++) {
-        int c_is_no_print;
-
-        c = *s;
-        c_is_no_print = (c & 0x80) && !Isprint(c);
-        if (c_is_no_print) {
-            strcat(buf, SOn);
-            c = '.';
-        }
-        if (c < ' ' || c == 127) {
-            strcat(buf, "^");
-            if (c == 127)
-                c = '?';
-            else
-                c += '@';
-        }
-        b[0] = c;
-        strcat(buf, b);
-        if (c_is_no_print)
-            strcat(buf, SOs);
-        if (*s == '\n')
-            strcat(buf, "$");
-    }
-}
-
 #if ENABLE_FEATURE_VI_DOT_CMD
 static void start_new_cmd_q(char c)
 {
-    // release old cmd
-    free(last_modifying_cmd);
     // get buffer for new cmd
-    last_modifying_cmd = xzalloc(MAX_LINELEN);
     // if there is a current cmd count put it in the buffer first
-    if (cmdcnt > 0)
-        sprintf(last_modifying_cmd, "%d%c", cmdcnt, c);
-    else // just save char c onto queue
+    if (cmdcnt > 0) {
+        lmc_len = sprintf(last_modifying_cmd, "%d%c", cmdcnt, c);
+    } else { // just save char c onto queue
         last_modifying_cmd[0] = c;
+        lmc_len = 1;
+    }
     adding2q = 1;
 }
@@ -1979 +2054 @@
  || (ENABLE_FEATURE_VI_COLON && ENABLE_FEATURE_VI_SEARCH) \
  || ENABLE_FEATURE_VI_CRASHME
-static char *string_insert(char * p, char * s) // insert the string at 'p'
-{
-    int cnt, i;
+// might reallocate text[]! use p += string_insert(p, ...),
+// and be careful to not use pointers into potentially freed text[]!
+static uintptr_t string_insert(char *p, const char *s) // insert the string at 'p'
+{
+    uintptr_t bias;
+    int i;
 
     i = strlen(s);
-    if (text_hole_make(p, i)) {
-        strncpy(p, s, i);
+    bias = text_hole_make(p, i);
+    p += bias;
+    memcpy(p, s, i);
+#if ENABLE_FEATURE_VI_YANKMARK
+    {
+        int cnt;
         for (cnt = 0; *s != '\0'; s++) {
             if (*s == '\n')
                 cnt++;
         }
+        status_line("Put %d lines (%d chars) from [%c]", cnt, i, what_reg());
+    }
+#endif
+    return bias;
+}
+#endif
+
 #if ENABLE_FEATURE_VI_YANKMARK
-        psb("Put %d lines (%d chars) from [%c]", cnt, i, what_reg());
-#endif
-    }
-    return p;
-}
-#endif
-
-#if ENABLE_FEATURE_VI_YANKMARK
-static char *text_yank(char * p, char * q, int dest)    // copy text into a register
-{
-    char *t;
-    int cnt;
-
-    if (q < p) {        // they are backwards- reverse them
-        t = q;
-        q = p;
-        p = t;
-    }
-    cnt = q - p + 1;
-    t = reg[dest];
-    free(t);        //  if already a yank register, free it
-    t = xmalloc(cnt + 1);   // get a new register
-    memset(t, '\0', cnt + 1);   // clear new text[]
-    strncpy(t, p, cnt); // copy text[] into bufer
-    reg[dest] = t;
+static char *text_yank(char *p, char *q, int dest)  // copy text into a register
+{
+    int cnt = q - p;
+    if (cnt < 0) {      // they are backwards- reverse them
+        p = q;
+        cnt = -cnt;
+    }
+    free(reg[dest]);    //  if already a yank register, free it
+    reg[dest] = xstrndup(p, cnt + 1);
     return p;
 }
@@ -2050 +2123 @@
 }
 
-static inline char *swap_context(char * p) // goto new context for '' command make this the current context
+static char *swap_context(char *p) // goto new context for '' command make this the current context
 {
     char *tmp;
@@ -2080 +2153 @@
     term_vi.c_cc[VTIME] = 0;
     erase_char = term_vi.c_cc[VERASE];
-    tcsetattr(0, TCSANOW, &term_vi);
+    tcsetattr_stdin_TCSANOW(&term_vi);
 }
 
 static void cookmode(void)
 {
-    fflush(stdout);
-    tcsetattr(0, TCSANOW, &term_orig);
-}
-
+    fflush_all();
+    tcsetattr_stdin_TCSANOW(&term_orig);
+}
+
+#if ENABLE_FEATURE_VI_USE_SIGNALS
 //----- Come here when we get a window resize signal ---------
-#if ENABLE_FEATURE_VI_USE_SIGNALS
-static void winch_sig(int sig ATTRIBUTE_UNUSED)
-{
+static void winch_sig(int sig UNUSED_PARAM)
+{
+    int save_errno = errno;
+    // FIXME: do it in main loop!!!
     signal(SIGWINCH, winch_sig);
-    if (ENABLE_FEATURE_VI_WIN_RESIZE)
-        get_terminal_width_height(0, &columns, &rows);
+    query_screen_dimensions();
     new_screen(rows, columns);  // get memory for virtual screen
     redraw(TRUE);       // re-draw the screen
+    errno = save_errno;
 }
 
 //----- Come here when we get a continue signal -------------------
-static void cont_sig(int sig ATTRIBUTE_UNUSED)
-{
-    rawmode();          // terminal to "raw"
-    last_status_cksum = 0;  // force status update
-    redraw(TRUE);       // re-draw the screen
+static void cont_sig(int sig UNUSED_PARAM)
+{
+    int save_errno = errno;
+    rawmode(); // terminal to "raw"
+    last_status_cksum = 0; // force status update
+    redraw(TRUE); // re-draw the screen
 
     signal(SIGTSTP, suspend_sig);
     signal(SIGCONT, SIG_DFL);
-    kill(my_pid, SIGCONT);
+    //kill(my_pid, SIGCONT); // huh? why? we are already "continued"...
+    errno = save_errno;
 }
 
 //----- Come here when we get a Suspend signal -------------------
-static void suspend_sig(int sig ATTRIBUTE_UNUSED)
-{
-    place_cursor(rows - 1, 0, FALSE);   // go to bottom of screen
-    clear_to_eol();     // Erase to end of line
-    cookmode();         // terminal to "cooked"
+static void suspend_sig(int sig UNUSED_PARAM)
+{
+    int save_errno = errno;
+    go_bottom_and_clear_to_eol();
+    cookmode(); // terminal to "cooked"
 
     signal(SIGCONT, cont_sig);
     signal(SIGTSTP, SIG_DFL);
     kill(my_pid, SIGTSTP);
+    errno = save_errno;
 }
 
@@ -2128 +2206 @@
 {
     signal(SIGINT, catch_sig);
-    if (sig)
-        longjmp(restart, sig);
+    siglongjmp(restart, sig);
 }
 #endif /* FEATURE_VI_USE_SIGNALS */
 
-static int mysleep(int hund)    // sleep for 'h' 1/100 seconds
-{
-    fd_set rfds;
-    struct timeval tv;
-
-    // Don't hang- Wait 5/100 seconds-  1 Sec= 1000000
-    fflush(stdout);
-    FD_ZERO(&rfds);
-    FD_SET(0, &rfds);
-    tv.tv_sec = 0;
-    tv.tv_usec = hund * 10000;
-    select(1, &rfds, NULL, NULL, &tv);
-    return FD_ISSET(0, &rfds);
-}
-
-#define readbuffer bb_common_bufsiz1
-
-static int readed_for_parse;
+static int mysleep(int hund)    // sleep for 'hund' 1/100 seconds or stdin ready
+{
+    struct pollfd pfd[1];
+
+    pfd[0].fd = STDIN_FILENO;
+    pfd[0].events = POLLIN;
+    return safe_poll(pfd, 1, hund*10) > 0;
+}
 
 //----- IO Routines --------------------------------------------
-static char readit(void)    // read (maybe cursor) key from stdin
-{
-    char c;
-    int n;
-    struct esc_cmds {
-        const char *seq;
-        char val;
-    };
-
-    static const struct esc_cmds esccmds[] = {
-        {"OA", VI_K_UP},       // cursor key Up
-        {"OB", VI_K_DOWN},     // cursor key Down
-        {"OC", VI_K_RIGHT},    // Cursor Key Right
-        {"OD", VI_K_LEFT},     // cursor key Left
-        {"OH", VI_K_HOME},     // Cursor Key Home
-        {"OF", VI_K_END},      // Cursor Key End
-        {"[A", VI_K_UP},       // cursor key Up
-        {"[B", VI_K_DOWN},     // cursor key Down
-        {"[C", VI_K_RIGHT},    // Cursor Key Right
-        {"[D", VI_K_LEFT},     // cursor key Left
-        {"[H", VI_K_HOME},     // Cursor Key Home
-        {"[F", VI_K_END},      // Cursor Key End
-        {"[1~", VI_K_HOME},    // Cursor Key Home
-        {"[2~", VI_K_INSERT},  // Cursor Key Insert
-        {"[4~", VI_K_END},     // Cursor Key End
-        {"[5~", VI_K_PAGEUP},  // Cursor Key Page Up
-        {"[6~", VI_K_PAGEDOWN},// Cursor Key Page Down
-        {"OP", VI_K_FUN1},     // Function Key F1
-        {"OQ", VI_K_FUN2},     // Function Key F2
-        {"OR", VI_K_FUN3},     // Function Key F3
-        {"OS", VI_K_FUN4},     // Function Key F4
-        {"[15~", VI_K_FUN5},   // Function Key F5
-        {"[17~", VI_K_FUN6},   // Function Key F6
-        {"[18~", VI_K_FUN7},   // Function Key F7
-        {"[19~", VI_K_FUN8},   // Function Key F8
-        {"[20~", VI_K_FUN9},   // Function Key F9
-        {"[21~", VI_K_FUN10},  // Function Key F10
-        {"[23~", VI_K_FUN11},  // Function Key F11
-        {"[24~", VI_K_FUN12},  // Function Key F12
-        {"[11~", VI_K_FUN1},   // Function Key F1
-        {"[12~", VI_K_FUN2},   // Function Key F2
-        {"[13~", VI_K_FUN3},   // Function Key F3
-        {"[14~", VI_K_FUN4},   // Function Key F4
-    };
-    enum { ESCCMDS_COUNT = ARRAY_SIZE(esccmds) };
-
-    alarm(0);   // turn alarm OFF while we wait for input
-    fflush(stdout);
-    n = readed_for_parse;
-    // get input from User- are there already input chars in Q?
-    if (n <= 0) {
- ri0:
-        // the Q is empty, wait for a typed char
-        n = read(0, readbuffer, MAX_LINELEN - 1);
-        if (n < 0) {
-            if (errno == EINTR)
-                goto ri0;   // interrupted sys call
-            if (errno == EBADF || errno == EFAULT || errno == EINVAL
-                    || errno == EIO)
-                editing = 0;
-            errno = 0;
-        }
-        if (n <= 0)
-            return 0;       // error
-        if (readbuffer[0] == 27) {
-            fd_set rfds;
-            struct timeval tv;
-
-            // This is an ESC char. Is this Esc sequence?
-            // Could be bare Esc key. See if there are any
-            // more chars to read after the ESC. This would
-            // be a Function or Cursor Key sequence.
-            FD_ZERO(&rfds);
-            FD_SET(0, &rfds);
-            tv.tv_sec = 0;
-            tv.tv_usec = 50000; // Wait 5/100 seconds- 1 Sec=1000000
-
-            // keep reading while there are input chars and room in buffer
-            while (select(1, &rfds, NULL, NULL, &tv) > 0 && n <= (MAX_LINELEN - 5)) {
-                // read the rest of the ESC string
-                int r = read(0, (void *) (readbuffer + n), MAX_LINELEN - n);
-                if (r > 0) {
-                    n += r;
-                }
-            }
-        }
-        readed_for_parse = n;
-    }
-    c = readbuffer[0];
-    if (c == 27 && n > 1) {
-        // Maybe cursor or function key?
-        const struct esc_cmds *eindex;
-
-        for (eindex = esccmds; eindex < &esccmds[ESCCMDS_COUNT]; eindex++) {
-            int cnt = strlen(eindex->seq);
-
-            if (n <= cnt)
-                continue;
-            if (strncmp(eindex->seq, readbuffer + 1, cnt))
-                continue;
-            // is a Cursor key- put derived value back into Q
-            c = eindex->val;
-            // for squeeze out the ESC sequence
-            n = cnt + 1;
-            break;
-        }
-        if (eindex == &esccmds[ESCCMDS_COUNT]) {
-            /* defined ESC sequence not found, set only one ESC */
-            n = 1;
-    }
-    } else {
-        n = 1;
-    }
-    // remove key sequence from Q
-    readed_for_parse -= n;
-    memmove(readbuffer, readbuffer + n, MAX_LINELEN - n);
-    alarm(3);   // we are done waiting for input, turn alarm ON
+static int readit(void) // read (maybe cursor) key from stdin
+{
+    int c;
+
+    fflush_all();
+    c = read_key(STDIN_FILENO, readbuffer, /*timeout off:*/ -2);
+    if (c == -1) { // EOF/error
+        go_bottom_and_clear_to_eol();
+        cookmode(); // terminal to "cooked"
+        bb_error_msg_and_die("can't read user input");
+    }
     return c;
 }
 
 //----- IO Routines --------------------------------------------
-static char get_one_char(void)
-{
-    static char c;
+static int get_one_char(void)
+{
+    int c;
 
 #if ENABLE_FEATURE_VI_DOT_CMD
-    // ! adding2q  && ioq == 0  read()
-    // ! adding2q  && ioq != 0  *ioq
-    // adding2q         *last_modifying_cmd= read()
     if (!adding2q) {
         // we are not adding to the q.
@@ -2290 +2248 @@
         } else {
             // there is a queue to get chars from first
-            c = *ioq++;
+            // careful with correct sign expansion!
+            c = (unsigned char)*ioq++;
             if (c == '\0') {
                 // the end of the q, read from STDIN
@@ -2301 +2260 @@
         // adding STDIN chars to q
         c = readit();   // get the users input
-        if (last_modifying_cmd != 0) {
-            int len = strlen(last_modifying_cmd);
-            if (len >= MAX_LINELEN - 1) {
-                psbs("last_modifying_cmd overrun");
-            } else {
-                // add new char to q
-                last_modifying_cmd[len] = c;
-            }
+        if (lmc_len >= MAX_INPUT_LEN - 1) {
+            status_line_bold("last_modifying_cmd overrun");
+        } else {
+            // add new char to q
+            last_modifying_cmd[lmc_len++] = c;
         }
     }
@@ -2314 +2270 @@
     c = readit();       // get the users input
 #endif /* FEATURE_VI_DOT_CMD */
-    return c;           // return the char, where ever it came from
-}
-
-static char *get_input_line(const char * prompt) // get input line- use "status line"
-{
-    static char *obufp;
-
-    char buf[MAX_LINELEN];
-    char c;
+    return c;
+}
+
+// Get input line (uses "status line" area)
+static char *get_input_line(const char *prompt)
+{
+    // char [MAX_INPUT_LEN]
+#define buf get_input_line__buf
+
+    int c;
     int i;
 
     strcpy(buf, prompt);
     last_status_cksum = 0;  // force status update
-    place_cursor(rows - 1, 0, FALSE);   // go to Status line, bottom of screen
-    clear_to_eol();     // clear the line
+    go_bottom_and_clear_to_eol();
     write1(prompt);      // write out the :, /, or ? prompt
 
     i = strlen(buf);
-    while (i < MAX_LINELEN) {
-        c = get_one_char(); // read user input
+    while (i < MAX_INPUT_LEN) {
+        c = get_one_char();
         if (c == '\n' || c == '\r' || c == 27)
-            break;      // is this end of input
+            break;      // this is end of input
         if (c == erase_char || c == 8 || c == 127) {
             // user wants to erase prev char
-            i--;        // backup to prev char
-            buf[i] = '\0';  // erase the char
-            buf[i + 1] = '\0';  // null terminate buffer
-            write1("\b \b");     // erase char on screen
-            if (i <= 0) {   // user backs up before b-o-l, exit
+            buf[--i] = '\0';
+            write1("\b \b"); // erase char on screen
+            if (i <= 0) // user backs up before b-o-l, exit
                 break;
-            }
-        } else {
-            buf[i] = c; // save char in buffer
-            buf[i + 1] = '\0';  // make sure buffer is null terminated
-            putchar(c);   // echo the char back to user
-            i++;
+        } else if (c > 0 && c < 256) { // exclude Unicode
+            // (TODO: need to handle Unicode)
+            buf[i] = c;
+            buf[++i] = '\0';
+            bb_putchar(c);
         }
     }
     refresh(FALSE);
-    free(obufp);
-    obufp = xstrdup(buf);
-    return obufp;
+    return buf;
+#undef buf
 }
 
@@ -2364 +2316 @@
 
     cnt = -1;
-    if (fn && fn[0] && stat(fn, &st_buf) == 0)  // see if file exists
+    if (fn && stat(fn, &st_buf) == 0)   // see if file exists
         cnt = (int) st_buf.st_size;
     return cnt;
 }
 
-static int file_insert(const char * fn, char *p
-        USE_FEATURE_VI_READONLY(, int update_ro_status))
+// might reallocate text[]!
+static int file_insert(const char *fn, char *p, int update_ro_status)
 {
     int cnt = -1;
@@ -2378 +2330 @@
     /* Validate file */
     if (stat(fn, &statbuf) < 0) {
-        psbs("\"%s\" %s", fn, strerror(errno));
+        status_line_bold("\"%s\" %s", fn, strerror(errno));
         goto fi0;
     }
-    if ((statbuf.st_mode & S_IFREG) == 0) {
+    if (!S_ISREG(statbuf.st_mode)) {
         // This is not a regular file
-        psbs("\"%s\" Not a regular file", fn);
+        status_line_bold("\"%s\" Not a regular file", fn);
         goto fi0;
     }
-    /* // this check is done by open()
-    if ((statbuf.st_mode & (S_IRUSR | S_IRGRP | S_IROTH)) == 0) {
-        // dont have any read permissions
-        psbs("\"%s\" Not readable", fn);
-        goto fi0;
-    }
-    */
     if (p < text || p > end) {
-        psbs("Trying to insert file outside of memory");
+        status_line_bold("Trying to insert file outside of memory");
         goto fi0;
     }
@@ -2401 +2346 @@
     fd = open(fn, O_RDONLY);
     if (fd < 0) {
-        psbs("\"%s\" %s", fn, strerror(errno));
+        status_line_bold("\"%s\" %s", fn, strerror(errno));
         goto fi0;
     }
     size = statbuf.st_size;
-    p = text_hole_make(p, size);
-    if (p == NULL)
-        goto fi0;
-    cnt = read(fd, p, size);
+    p += text_hole_make(p, size);
+    cnt = safe_read(fd, p, size);
     if (cnt < 0) {
-        psbs("\"%s\" %s", fn, strerror(errno));
+        status_line_bold("\"%s\" %s", fn, strerror(errno));
         p = text_hole_delete(p, p + size - 1);  // un-do buffer insert
     } else if (cnt < size) {
         // There was a partial read, shrink unused space text[]
         p = text_hole_delete(p + cnt, p + (size - cnt) - 1);    // un-do buffer insert
-        psbs("cannot read all of file \"%s\"", fn);
+        status_line_bold("can't read all of file \"%s\"", fn);
     }
     if (cnt >= size)
@@ -2435 +2378 @@
 }
 
-
-static int file_write(char * fn, char * first, char * last)
+static int file_write(char *fn, char *first, char *last)
 {
     int fd, cnt, charcnt;
 
     if (fn == 0) {
-        psbs("No current filename");
+        status_line_bold("No current filename");
         return -2;
     }
-    charcnt = 0;
-    // FIXIT- use the correct umask()
-    fd = open(fn, (O_WRONLY | O_CREAT | O_TRUNC), 0664);
+    /* By popular request we do not open file with O_TRUNC,
+     * but instead ftruncate() it _after_ successful write.
+     * Might reduce amount of data lost on power fail etc.
+     */
+    fd = open(fn, (O_WRONLY | O_CREAT), 0666);
     if (fd < 0)
         return -1;
     cnt = last - first + 1;
-    charcnt = write(fd, first, cnt);
+    charcnt = full_write(fd, first, cnt);
+    ftruncate(fd, charcnt);
     if (charcnt == cnt) {
         // good write
-        //file_modified = FALSE; // the file has not been modified
+        //file_modified = FALSE;
     } else {
         charcnt = 0;
@@ -2470 +2415 @@
 //  .       ...     .
 //  22,0    ...     22,79
-//  23,0    ...     23,79   status line
-//
+//  23,0    ...     23,79   <- status line
 
 //----- Move the cursor to row x col (count from 0, not 1) -------
-static void place_cursor(int row, int col, int opti)
-{
-    char cm1[MAX_LINELEN];
+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;
-#if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-    char cm2[MAX_LINELEN];
-    char *screenp;
-    // char cm3[MAX_LINELEN];
-    int Rrow = last_row;
-#endif
-
-    memset(cm1, '\0', MAX_LINELEN);  // clear the buffer
 
     if (row < 0) row = 0;
@@ -2495 +2439 @@
     sprintf(cm1, CMrc, row + 1, col + 1);
     cm = cm1;
-    if (!opti)
-        goto pc0;
 
 #if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-    //----- find the minimum # of chars to move cursor -------------
-    //----- 2.  Try moving with discreet chars (Newline, [back]space, ...)
-    memset(cm2, '\0', MAX_LINELEN);  // clear the buffer
-
-    // 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);
-
-    //----- 3.  Try some other way of moving cursor
-    //---------------------------------------------
-
-    // pick the shortest cursor motion to send out
-    cm = cm1;
-    if (strlen(cm2) < strlen(cm)) {
-        cm = cm2;
-    }  /* else if (strlen(cm3) < strlen(cm)) {
-        cm= cm3;
-    } */
+    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 */
- pc0:
-    write1(cm);                 // move the cursor
+    write1(cm);
 }
 
@@ -2540 +2486 @@
 {
     write1(Ceol);   // Erase from cursor to end of line
+}
+
+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
 }
 
@@ -2612 +2564 @@
     }
     if (have_status_msg || ((cnt > 0 && last_status_cksum != cksum))) {
-        last_status_cksum= cksum;       // remember if we have seen this line
-        place_cursor(rows - 1, 0, FALSE);   // put cursor on status line
+        last_status_cksum = cksum;      // remember if we have seen this line
+        go_bottom_and_clear_to_eol();
         write1(status_buffer);
-        clear_to_eol();
         if (have_status_msg) {
             if (((int)strlen(status_buffer) - (have_status_msg - 1)) >
@@ -2626 +2577 @@
         place_cursor(crow, ccol, FALSE);    // put cursor back in correct place
     }
-    fflush(stdout);
+    fflush_all();
 }
 
 //----- format the status buffer, the bottom line of screen ------
 // format status buffer, with STANDOUT mode
-static void psbs(const char *format, ...)
+static void status_line_bold(const char *format, ...)
 {
     va_list args;
@@ -2637 +2588 @@
     va_start(args, format);
     strcpy(status_buffer, SOs); // Terminal standout mode on
-    vsprintf(status_buffer + strlen(status_buffer), format, args);
+    vsprintf(status_buffer + sizeof(SOs)-1, format, args);
     strcat(status_buffer, SOn); // Terminal standout mode off
     va_end(args);
@@ -2645 +2596 @@
 
 // format status buffer
-static void psb(const char *format, ...)
+static void status_line(const char *format, ...)
 {
     va_list args;
@@ -2656 +2607 @@
 }
 
-static void ni(const char * s) // display messages
-{
-    char buf[MAX_LINELEN];
+// copy s to buf, convert unprintable
+static void print_literal(char *buf, const char *s)
+{
+    char *d;
+    unsigned char c;
+
+    buf[0] = '\0';
+    if (!s[0])
+        s = "(NULL)";
+
+    d = buf;
+    for (; *s; s++) {
+        int c_is_no_print;
+
+        c = *s;
+        c_is_no_print = (c & 0x80) && !Isprint(c);
+        if (c_is_no_print) {
+            strcpy(d, SOn);
+            d += sizeof(SOn)-1;
+            c = '.';
+        }
+        if (c < ' ' || c == 0x7f) {
+            *d++ = '^';
+            c |= '@'; /* 0x40 */
+            if (c == 0x7f)
+                c = '?';
+        }
+        *d++ = c;
+        *d = '\0';
+        if (c_is_no_print) {
+            strcpy(d, SOs);
+            d += sizeof(SOs)-1;
+        }
+        if (*s == '\n') {
+            *d++ = '$';
+            *d = '\0';
+        }
+        if (d - buf > MAX_INPUT_LEN - 10) // paranoia
+            break;
+    }
+}
+
+static void not_implemented(const char *s)
+{
+    char buf[MAX_INPUT_LEN];
 
     print_literal(buf, s);
-    psbs("\'%s\' is not implemented", buf);
-}
-
-static int format_edit_status(void) // show file status on status line
-{
-    static int tot;
+    status_line_bold("\'%s\' is not implemented", buf);
+}
+
+// show file status on status line
+static int format_edit_status(void)
+{
     static const char cmd_mode_indicator[] ALIGN1 = "-IR-";
+
+#define tot format_edit_status__tot
+
     int cur, percent, ret, trunc_at;
 
@@ -2718 +2714 @@
 
     return trunc_at;  /* had to truncate */
+#undef tot
 }
 
@@ -2724 +2721 @@
 {
     place_cursor(0, 0, FALSE);  // put cursor in correct place
-    clear_to_eos();     // tel terminal to erase display
+    clear_to_eos();     // tell terminal to erase display
     screen_erase();     // erase the internal screen buffer
     last_status_cksum = 0;  // force status update
@@ -2732 +2729 @@
 
 //----- Format a text[] line into a buffer ---------------------
-static void format_line(char *dest, char *src, int li)
-{
+static char* format_line(char *src /*, int li*/)
+{
+    unsigned char c;
     int co;
-    char c;
-
-    for (co = 0; co < MAX_SCR_COLS; co++) {
-        c = ' ';        // assume blank
-        if (li > 0 && co == 0) {
-            c = '~';        // not first line, assume Tilde
-        }
-        // are there chars in text[] and have we gone past the end
-        if (text < end && src < end) {
+    int ofs = offset;
+    char *dest = scr_out_buf; // [MAX_SCR_COLS + MAX_TABSTOP * 2]
+
+    c = '~'; // char in col 0 in non-existent lines is '~'
+    co = 0;
+    while (co < columns + tabstop) {
+        // have we gone past the end?
+        if (src < end) {
             c = *src++;
-        }
-        if (c == '\n')
-            break;
-        if ((c & 0x80) && !Isprint(c)) {
-            c = '.';
-        }
-        if ((unsigned char)(c) < ' ' || c == 0x7f) {
-            if (c == '\t') {
-                c = ' ';
-                //       co %    8     !=     7
-                for (; (co % tabstop) != (tabstop - 1); co++) {
-                    dest[co] = c;
+            if (c == '\n')
+                break;
+            if ((c & 0x80) && !Isprint(c)) {
+                c = '.';
+            }
+            if (c < ' ' || c == 0x7f) {
+                if (c == '\t') {
+                    c = ' ';
+                    //      co %    8     !=     7
+                    while ((co % tabstop) != (tabstop - 1)) {
+                        dest[co++] = c;
+                    }
+                } else {
+                    dest[co++] = '^';
+                    if (c == 0x7f)
+                        c = '?';
+                    else
+                        c += '@'; // Ctrl-X -> 'X'
                 }
-            } else {
-                dest[co++] = '^';
-                if (c == 0x7f)
-                    c = '?';
-                else
-                    c += '@';       // make it visible
             }
         }
-        // the co++ is done here so that the column will
-        // not be overwritten when we blank-out the rest of line
-        dest[co] = c;
+        dest[co++] = c;
+        // discard scrolled-off-to-the-left portion,
+        // in tabstop-sized pieces
+        if (ofs >= tabstop && co >= tabstop) {
+            memmove(dest, dest + tabstop, co);
+            co -= tabstop;
+            ofs -= tabstop;
+        }
         if (src >= end)
             break;
     }
+    // check "short line, gigantic offset" case
+    if (co < ofs)
+        ofs = co;
+    // discard last scrolled off part
+    co -= ofs;
+    dest += ofs;
+    // fill the rest with spaces
+    if (co < columns)
+        memset(&dest[co], ' ', columns - co);
+    return dest;
 }
 
@@ -2781 +2793 @@
 static void refresh(int full_screen)
 {
-    static int old_offset;
+#define old_offset refresh__old_offset
 
     int li, changed;
-    char buf[MAX_SCR_COLS];
     char *tp, *sp;      // pointer into text[] and screen[]
-#if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-    int last_li = -2; // last line that changed- for optimizing cursor movement
-#endif
-
-    if (ENABLE_FEATURE_VI_WIN_RESIZE)
-        get_terminal_width_height(0, &columns, &rows);
+
+    if (ENABLE_FEATURE_VI_WIN_RESIZE IF_FEATURE_VI_ASK_TERMINAL(&& !G.get_rowcol_error) ) {
+        unsigned c = columns, r = rows;
+        query_screen_dimensions();
+        full_screen |= (c - columns) | (r - rows);
+    }
     sync_cursor(dot, &crow, &ccol); // where cursor will be (on "dot")
     tp = screenbegin;   // index into text[] of top line
@@ -2798 +2809 @@
     for (li = 0; li < rows - 1; li++) {
         int cs, ce;             // column start & end
-        memset(buf, ' ', MAX_SCR_COLS);     // blank-out the buffer
-        buf[MAX_SCR_COLS-1] = 0;        // NULL terminate the buffer
-        // format current text line into buf
-        format_line(buf, tp, li);
+        char *out_buf;
+        // format current text line
+        out_buf = format_line(tp /*, li*/);
 
         // skip to the end of the current text[] line
-        while (tp < end && *tp++ != '\n') /*no-op*/;
-
-        // see if there are any changes between vitual screen and buf
+        if (tp < end) {
+            char *t = memchr(tp, '\n', end - tp);
+            if (!t) t = end - 1;
+            tp = t + 1;
+        }
+
+        // see if there are any changes between vitual screen and out_buf
         changed = FALSE;    // assume no change
-        cs= 0;
-        ce= columns-1;
+        cs = 0;
+        ce = columns - 1;
         sp = &screen[li * columns]; // start of screen line
         if (full_screen) {
@@ -2818 +2832 @@
         // look forward for first difference between buf and screen
         for (; cs <= ce; cs++) {
-            if (buf[cs + offset] != sp[cs]) {
+            if (out_buf[cs] != sp[cs]) {
                 changed = TRUE; // mark for redraw
                 break;
@@ -2824 +2838 @@
         }
 
-        // look backward for last difference between buf and screen
-        for ( ; ce >= cs; ce--) {
-            if (buf[ce + offset] != sp[ce]) {
+        // look backward for last difference between out_buf and screen
+        for (; ce >= cs; ce--) {
+            if (out_buf[ce] != sp[ce]) {
                 changed = TRUE; // mark for redraw
                 break;
@@ -2840 +2854 @@
 
         // make a sanity check of columns indexes
-        if (cs < 0) cs= 0;
-        if (ce > columns-1) ce= columns-1;
-        if (cs > ce) {  cs= 0;  ce= columns-1;  }
-        // is there a change between vitual screen and buf
+        if (cs < 0) cs = 0;
+        if (ce > columns - 1) ce = columns - 1;
+        if (cs > ce) { cs = 0; ce = columns - 1; }
+        // is there a change between vitual screen and out_buf
         if (changed) {
-            //  copy changed part of buffer to virtual screen
-            memmove(sp+cs, buf+(cs+offset), ce-cs+1);
+            // 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) {
-                // opti_cur_move is still too stupid
-                // to handle offsets correctly
-                place_cursor(li, cs, FALSE);
-            } else {
-#if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-                // if this just the next line
-                //  try to optimize cursor movement
-                //  otherwise, use standard ESC sequence
-                place_cursor(li, cs, li == (last_li+1) ? TRUE : FALSE);
-                last_li= li;
-#else
-                place_cursor(li, cs, FALSE);    // use standard ESC sequence
-#endif /* FEATURE_VI_OPTIMIZE_CURSOR */
-            }
+            //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);
+            //}
 
             // write line out to terminal
-            {
-                int nic = ce - cs + 1;
-                char *out = sp + cs;
-
-                while (nic-- > 0) {
-                    putchar(*out);
-                    out++;
-                }
-            }
-#if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-            last_row = li;
-#endif
-        }
-    }
-
-#if ENABLE_FEATURE_VI_OPTIMIZE_CURSOR
-    place_cursor(crow, ccol, (crow == last_row) ? TRUE : FALSE);
-    last_row = crow;
-#else
-    place_cursor(crow, ccol, FALSE);
-#endif
-
-    if (offset != old_offset)
-        old_offset = offset;
+            fwrite(&sp[cs], ce - cs + 1, 1, stdout);
+        }
+    }
+
+    place_cursor(crow, ccol, TRUE);
+
+    old_offset = offset;
+#undef old_offset
 }
 
@@ -2914 +2904 @@
 
 //----- Execute a Vi Command -----------------------------------
-static void do_cmd(char c)
-{
-    const char *msg;
-    char c1, *p, *q, buf[9], *save_dot;
-    int cnt, i, j, dir, yf;
-
-    c1 = c;             // quiet the compiler
-    cnt = yf = dir = 0; // quiet the compiler
-    msg = p = q = save_dot = buf;   // quiet the compiler
-    memset(buf, '\0', 9);   // clear buf
+static void do_cmd(int c)
+{
+    const char *msg = msg; // for compiler
+    char *p, *q, *save_dot;
+    char buf[12];
+    int dir;
+    int cnt, i, j;
+    int c1;
+
+//  c1 = c; // quiet the compiler
+//  cnt = yf = 0; // quiet the compiler
+//  msg = p = q = save_dot = buf; // quiet the compiler
+    memset(buf, '\0', 12);
 
     show_status_line();
@@ -2929 +2922 @@
     /* if this is a cursor key, skip these checks */
     switch (c) {
-        case VI_K_UP:
-        case VI_K_DOWN:
-        case VI_K_LEFT:
-        case VI_K_RIGHT:
-        case VI_K_HOME:
-        case VI_K_END:
-        case VI_K_PAGEUP:
-        case VI_K_PAGEDOWN:
+        case KEYCODE_UP:
+        case KEYCODE_DOWN:
+        case KEYCODE_LEFT:
+        case KEYCODE_RIGHT:
+        case KEYCODE_HOME:
+        case KEYCODE_END:
+        case KEYCODE_PAGEUP:
+        case KEYCODE_PAGEDOWN:
+        case KEYCODE_DELETE:
             goto key_cmd_mode;
     }
@@ -2942 +2936 @@
     if (cmd_mode == 2) {
         //  flip-flop Insert/Replace mode
-        if (c == VI_K_INSERT)
+        if (c == KEYCODE_INSERT)
             goto dc_i;
         // we are 'R'eplacing the current *dot with new char
@@ -2959 +2953 @@
     if (cmd_mode == 1) {
         //  hitting "Insert" twice means "R" replace mode
-        if (c == VI_K_INSERT) goto dc5;
+        if (c == KEYCODE_INSERT) goto dc5;
         // insert the char c at "dot"
         if (1 <= c || Isprint(c)) {
@@ -2995 +2989 @@
         //case ')': // )-
         //case '*': // *-
-        //case ',': // ,-
         //case '=': // =-
         //case '@': // @-
@@ -3009 +3002 @@
         //case '_': // _-
         //case '`': // `-
-        //case 'g': // g-
         //case 'u': // u- FIXME- there is no undo
         //case 'v': // v-
-    default:            // unrecognised command
+    default:            // unrecognized command
         buf[0] = c;
         buf[1] = '\0';
-        if (c < ' ') {
-            buf[0] = '^';
-            buf[1] = c + '@';
-            buf[2] = '\0';
-        }
-        ni(buf);
+        not_implemented(buf);
         end_cmd_q();    // stop adding to q
     case 0x00:          // nul- ignore
         break;
     case 2:         // ctrl-B  scroll up   full screen
-    case VI_K_PAGEUP:   // Cursor Key Page Up
+    case KEYCODE_PAGEUP:    // Cursor Key Page Up
         dot_scroll(rows - 2, -1);
         break;
-#if ENABLE_FEATURE_VI_USE_SIGNALS
-    case 0x03:          // ctrl-C   interrupt
-        longjmp(restart, 1);
-        break;
-    case 26:            // ctrl-Z suspend
-        suspend_sig(SIGTSTP);
-        break;
-#endif
     case 4:         // ctrl-D  scroll down half screen
         dot_scroll((rows - 2) / 2, 1);
@@ -3043 +3022 @@
         break;
     case 6:         // ctrl-F  scroll down full screen
-    case VI_K_PAGEDOWN: // Cursor Key Page Down
+    case KEYCODE_PAGEDOWN:  // Cursor Key Page Down
         dot_scroll(rows - 2, 1);
         break;
@@ -3050 +3029 @@
         break;
     case 'h':           // h- move left
-    case VI_K_LEFT: // cursor key Left
+    case KEYCODE_LEFT:  // cursor key Left
     case 8:     // ctrl-H- move left    (This may be ERASE char)
     case 0x7f:  // DEL- move left   (This may be ERASE char)
-        if (cmdcnt-- > 1) {
+        if (--cmdcnt > 0) {
             do_cmd(c);
-        }               // repeat cnt
+        }
         dot_left();
         break;
     case 10:            // Newline ^J
     case 'j':           // j- goto next line, same col
-    case VI_K_DOWN: // cursor key Down
-        if (cmdcnt-- > 1) {
+    case KEYCODE_DOWN:  // cursor key Down
+        if (--cmdcnt > 0) {
             do_cmd(c);
-        }               // repeat cnt
+        }
         dot_next();     // go to next B-o-l
         dot = move_to_col(dot, ccol + offset);  // try stay in same col
@@ -3078 +3057 @@
     case 13:            // Carriage Return ^M
     case '+':           // +- goto next line
-        if (cmdcnt-- > 1) {
+        if (--cmdcnt > 0) {
             do_cmd(c);
-        }               // repeat cnt
+        }
         dot_next();
         dot_skip_over_ws();
@@ -3099 +3078 @@
     case ' ':           // move right
     case 'l':           // move right
-    case VI_K_RIGHT:    // Cursor Key Right
-        if (cmdcnt-- > 1) {
+    case KEYCODE_RIGHT: // Cursor Key Right
+        if (--cmdcnt > 0) {
             do_cmd(c);
-        }               // repeat cnt
+        }
         dot_right();
         break;
 #if ENABLE_FEATURE_VI_YANKMARK
     case '"':           // "- name a register to use for Delete/Yank
-        c1 = get_one_char();
-        c1 = tolower(c1);
-        if (islower(c1)) {
-            YDreg = c1 - 'a';
+        c1 = (get_one_char() | 0x20) - 'a'; // | 0x20 is tolower()
+        if ((unsigned)c1 <= 25) { // a-z?
+            YDreg = c1;
         } else {
             indicate_error(c);
@@ -3116 +3094 @@
         break;
     case '\'':          // '- goto a specific mark
-        c1 = get_one_char();
-        c1 = tolower(c1);
-        if (islower(c1)) {
-            c1 = c1 - 'a';
+        c1 = (get_one_char() | 0x20) - 'a';
+        if ((unsigned)c1 <= 25) { // a-z?
             // get the b-o-l
-            q = mark[(unsigned char) c1];
+            q = mark[c1];
             if (text <= q && q < end) {
                 dot = q;
@@ -3140 +3116 @@
         // correct location! It could be off by many lines!
         // Well..., at least its quick and dirty.
-        c1 = get_one_char();
-        c1 = tolower(c1);
-        if (islower(c1)) {
-            c1 = c1 - 'a';
+        c1 = (get_one_char() | 0x20) - 'a';
+        if ((unsigned)c1 <= 25) { // a-z?
             // remember the line
-            mark[(int) c1] = dot;
+            mark[c1] = dot;
         } else {
             indicate_error(c);
@@ -3153 +3127 @@
     case 'p':           // p- put register after
         p = reg[YDreg];
-        if (p == 0) {
-            psbs("Nothing in register %c", what_reg());
+        if (p == NULL) {
+            status_line_bold("Nothing in register %c", what_reg());
             break;
         }
@@ -3174 +3148 @@
                 dot_right();    // move to right, can move to NL
         }
-        dot = string_insert(dot, p);    // insert the string
+        string_insert(dot, p);  // insert the string
         end_cmd_q();    // stop adding to q
         break;
@@ -3182 +3156 @@
             q = end_line(dot);
             p = text_hole_delete(p, q); // delete cur line
-            p = string_insert(p, reg[Ureg]);    // insert orig line
+            p += string_insert(p, reg[Ureg]);   // insert orig line
             dot = p;
             dot_skip_over_ws();
@@ -3189 +3163 @@
 #endif /* FEATURE_VI_YANKMARK */
     case '$':           // $- goto end of line
-    case VI_K_END:      // Cursor Key End
-        if (cmdcnt-- > 1) {
+    case KEYCODE_END:       // Cursor Key End
+        if (--cmdcnt > 0) {
+            dot_next();
             do_cmd(c);
-        }               // repeat cnt
+        }
         dot = end_line(dot);
         break;
@@ -3216 +3191 @@
         // dont separate these two commands. 'f' depends on ';'
         //
-        //**** fall thru to ... ';'
+        //**** fall through to ... ';'
     case ';':           // ;- look at rest of line for last forward char
-        if (cmdcnt-- > 1) {
+        if (--cmdcnt > 0) {
             do_cmd(';');
-        }               // repeat cnt
+        }
         if (last_forward_char == 0)
             break;
@@ -3230 +3205 @@
             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;
+        break;
+
     case '-':           // -- goto prev line
-        if (cmdcnt-- > 1) {
+        if (--cmdcnt > 0) {
             do_cmd(c);
-        }               // repeat cnt
+        }
         dot_prev();
         dot_skip_over_ws();
@@ -3241 +3230 @@
         // Stuff the last_modifying_cmd back into stdin
         // and let it be re-executed.
-        if (last_modifying_cmd != 0) {
+        if (lmc_len > 0) {
+            last_modifying_cmd[lmc_len] = 0;
             ioq = ioq_start = xstrdup(last_modifying_cmd);
         }
@@ -3252 +3242 @@
         buf[1] = '\0';
         q = get_input_line(buf);    // get input line- use "status line"
-        if (q[0] && !q[1])
+        if (q[0] && !q[1]) {
+            if (last_search_pattern[0])
+                last_search_pattern[0] = c;
             goto dc3; // if no pat re-use old pat
+        }
         if (q[0]) {       // strlen(q) > 1: new pat- save it and find
             // there is a new pat
@@ -3263 +3256 @@
         break;
     case 'N':           // N- backward search for last pattern
-        if (cmdcnt-- > 1) {
+        if (--cmdcnt > 0) {
             do_cmd(c);
-        }               // repeat cnt
+        }
         dir = BACK;     // assume BACKWARD search
         p = dot - 1;
@@ -3277 +3270 @@
         // search rest of text[] starting at next char
         // if search fails return orignal "p" not the "p+1" address
-        if (cmdcnt-- > 1) {
+        if (--cmdcnt > 0) {
             do_cmd(c);
-        }               // repeat cnt
+        }
  dc3:
-        if (last_search_pattern == 0) {
-            msg = "No previous regular expression";
-            goto dc2;
-        }
-        if (last_search_pattern[0] == '/') {
-            dir = FORWARD;  // assume FORWARD search
-            p = dot + 1;
-        }
+        dir = FORWARD;  // assume FORWARD search
+        p = dot + 1;
         if (last_search_pattern[0] == '?') {
             dir = BACK;
@@ -3317 +3304 @@
  dc2:
         if (*msg)
-            psbs("%s", msg);
+            status_line_bold("%s", msg);
         break;
     case '{':           // {- move backward paragraph
@@ -3358 +3345 @@
         if (cnt <= 0)
             break;
-        if (strncasecmp(p, "quit", cnt) == 0
-         || strncasecmp(p, "q!", cnt) == 0   // delete lines
+        if (strncmp(p, "quit", cnt) == 0
+         || strncmp(p, "q!", cnt) == 0   // delete lines
         ) {
             if (file_modified && p[1] != '!') {
-                psbs("No write since last change (:quit! overrides)");
+                status_line_bold("No write since last change (:quit! overrides)");
             } else {
                 editing = 0;
             }
-        } else if (strncasecmp(p, "write", cnt) == 0
-                || strncasecmp(p, "wq", cnt) == 0
-                || strncasecmp(p, "wn", cnt) == 0
-                || strncasecmp(p, "x", cnt) == 0
+        } else if (strncmp(p, "write", cnt) == 0
+                || strncmp(p, "wq", cnt) == 0
+                || strncmp(p, "wn", cnt) == 0
+                || (p[0] == 'x' && !p[1])
         ) {
             cnt = file_write(current_filename, text, end - 1);
             if (cnt < 0) {
                 if (cnt == -1)
-                    psbs("Write error: %s", strerror(errno));
+                    status_line_bold("Write error: %s", strerror(errno));
             } else {
                 file_modified = 0;
                 last_file_modified = -1;
-                psb("\"%s\" %dL, %dC", current_filename, count_lines(text, end - 1), cnt);
+                status_line("\"%s\" %dL, %dC", current_filename, count_lines(text, end - 1), cnt);
                 if (p[0] == 'x' || p[1] == 'q' || p[1] == 'n'
                  || p[0] == 'X' || p[1] == 'Q' || p[1] == 'N'
@@ -3385 +3372 @@
                 }
             }
-        } else if (strncasecmp(p, "file", cnt) == 0) {
+        } else if (strncmp(p, "file", cnt) == 0) {
             last_status_cksum = 0;  // force status update
         } else if (sscanf(p, "%d", &j) > 0) {
             dot = find_line(j);     // go to line # j
             dot_skip_over_ws();
-        } else {        // unrecognised cmd
-            ni(p);
+        } else {        // unrecognized cmd
+            not_implemented(p);
         }
 #endif /* !FEATURE_VI_COLON */
@@ -3427 +3414 @@
     case 'A':           // A- append at e-o-l
         dot_end();      // go to e-o-l
-        //**** fall thru to ... 'a'
+        //**** fall through to ... 'a'
     case 'a':           // a- append after current char
         if (*dot != '\n')
@@ -3436 +3423 @@
     case 'E':           // E- end of a blank-delimited word
     case 'W':           // W- forward a blank-delimited word
-        if (cmdcnt-- > 1) {
+        if (--cmdcnt > 0) {
             do_cmd(c);
-        }               // repeat cnt
+        }
         dir = FORWARD;
         if (c == 'B')
@@ -3462 +3449 @@
 #endif
         break;
+    case 'g': // 'gg' goto a line number (vim) (default: very first line)
+        c1 = get_one_char();
+        if (c1 != 'g') {
+            buf[0] = 'g';
+            buf[1] = c1; // TODO: if Unicode?
+            buf[2] = '\0';
+            not_implemented(buf);
+            break;
+        }
+        if (cmdcnt == 0)
+            cmdcnt = 1;
+        /* fall through */
     case 'G':       // G- goto to a line number (default= E-O-F)
         dot = end - 1;              // assume E-O-F
@@ -3474 +3473 @@
             cmdcnt = (rows - 1);
         }
-        if (cmdcnt-- > 1) {
+        if (--cmdcnt > 0) {
             do_cmd('+');
-        }               // repeat cnt
+        }
         dot_skip_over_ws();
         break;
@@ -3482 +3481 @@
         dot_begin();    // 0
         dot_skip_over_ws();
-        //**** fall thru to ... 'i'
+        //**** fall through to ... 'i'
     case 'i':           // i- insert before current char
-    case VI_K_INSERT:   // Cursor Key Insert
+    case KEYCODE_INSERT:    // Cursor Key Insert
  dc_i:
         cmd_mode = 1;   // start insrting
         break;
     case 'J':           // J- join current and next lines together
-        if (cmdcnt-- > 2) {
+        if (--cmdcnt > 1) {
             do_cmd(c);
-        }               // repeat cnt
+        }
         dot_end();      // move to NL
         if (dot < end - 1) {    // make sure not last char in text[]
@@ -3507 +3506 @@
             cmdcnt = (rows - 1);
         }
-        if (cmdcnt-- > 1) {
+        if (--cmdcnt > 0) {
             do_cmd('-');
-        }               // repeat cnt
+        }
         dot_begin();
         dot_skip_over_ws();
@@ -3537 +3536 @@
         cmd_mode = 2;
         break;
+    case KEYCODE_DELETE:
+        c = 'x';
+        // fall through
     case 'X':           // X- delete char before dot
     case 'x':           // x- delete the current char
     case 's':           // s- substitute the current char
-        if (cmdcnt-- > 1) {
+        if (--cmdcnt > 0) {
             do_cmd(c);
-        }               // repeat cnt
+        }
         dir = 0;
         if (c == 'X')
@@ -3564 +3566 @@
         if (file_modified) {
             if (ENABLE_FEATURE_VI_READONLY && readonly_mode) {
-                psbs("\"%s\" File is read only", current_filename);
+                status_line_bold("\"%s\" File is read only", current_filename);
                 break;
             }
@@ -3570 +3572 @@
             if (cnt < 0) {
                 if (cnt == -1)
-                    psbs("Write error: %s", strerror(errno));
+                    status_line_bold("Write error: %s", strerror(errno));
             } else if (cnt == (end - 1 - text + 1)) {
                 editing = 0;
@@ -3584 +3586 @@
     case 'b':           // b- back a word
     case 'e':           // e- end of word
-        if (cmdcnt-- > 1) {
+        if (--cmdcnt > 0) {
             do_cmd(c);
-        }               // repeat cnt
+        }
         dir = FORWARD;
         if (c == 'b')
@@ -3608 +3610 @@
     case 'Y':           // Y- Yank a line
 #endif
+    {
+        int yf, ml, whole = 0;
         yf = YANKDEL;   // assume either "c" or "d"
 #if ENABLE_FEATURE_VI_YANKMARK
@@ -3616 +3620 @@
         if (c != 'Y')
             c1 = get_one_char();    // get the type of thing to delete
-        find_range(&p, &q, c1);
+        // determine range, and whether it spans lines
+        ml = find_range(&p, &q, c1);
         if (c1 == 27) { // ESC- user changed mind and wants out
             c = c1 = 27;    // Escape- do nothing
@@ -3628 +3633 @@
                 }
             }
-            dot = yank_delete(p, q, 0, yf); // delete word
-        } else if (strchr("^0bBeEft$", c1)) {
-            // single line copy text into a register and delete
-            dot = yank_delete(p, q, 0, yf); // delete word
-        } else if (strchr("cdykjHL%+-{}\r\n", c1)) {
-            // multiple line copy text into a register and delete
-            dot = yank_delete(p, q, 1, yf); // delete lines
+            dot = yank_delete(p, q, ml, yf);    // delete word
+        } else if (strchr("^0bBeEft%$ lh\b\177", c1)) {
+            // partial line copy text into a register and delete
+            dot = yank_delete(p, q, ml, yf);    // delete word
+        } else if (strchr("cdykjHL+-{}\r\n", c1)) {
+            // whole line copy text into a register and delete
+            dot = yank_delete(p, q, ml, yf);    // delete lines
+            whole = 1;
+        } else {
+            // could not recognize object
+            c = c1 = 27;    // error-
+            ml = 0;
+            indicate_error(c);
+        }
+        if (ml && whole) {
             if (c == 'c') {
                 dot = char_insert(dot, '\n');
                 // on the last line of file don't move to prev line
-                if (dot != (end-1)) {
+                if (whole && dot != (end-1)) {
                     dot_prev();
                 }
@@ -3645 +3658 @@
                 dot_skip_over_ws();
             }
-        } else {
-            // could not recognize object
-            c = c1 = 27;    // error-
-            indicate_error(c);
         }
         if (c1 != 27) {
@@ -3669 +3678 @@
                     cnt++;
             }
-            psb("%s %d lines (%d chars) using [%c]",
+            status_line("%s %d lines (%d chars) using [%c]",
                 buf, cnt, strlen(reg[YDreg]), what_reg());
 #endif
@@ -3675 +3684 @@
         }
         break;
+    }
     case 'k':           // k- goto prev line, same col
-    case VI_K_UP:       // cursor key Up
-        if (cmdcnt-- > 1) {
+    case KEYCODE_UP:        // cursor key Up
+        if (--cmdcnt > 0) {
             do_cmd(c);
-        }               // repeat cnt
+        }
         dot_prev();
         dot = move_to_col(dot, ccol + offset);  // try stay in same col
@@ -3687 +3697 @@
         if (*dot != '\n') {
             *dot = c1;
-            file_modified++;    // has the file been modified
+            file_modified++;
         }
         end_cmd_q();    // stop adding to q
@@ -3696 +3706 @@
         if (*dot == last_forward_char)
             dot_left();
-        last_forward_char= 0;
+        last_forward_char = 0;
         break;
     case 'w':           // w- forward a word
-        if (cmdcnt-- > 1) {
+        if (--cmdcnt > 0) {
             do_cmd(c);
-        }               // repeat cnt
+        }
         if (isalnum(*dot) || *dot == '_') { // we are on ALNUM
             dot = skip_thing(dot, 1, FORWARD, S_END_ALNUM);
@@ -3727 +3737 @@
         break;
     case '~':           // ~- flip the case of letters   a-z -> A-Z
-        if (cmdcnt-- > 1) {
+        if (--cmdcnt > 0) {
             do_cmd(c);
-        }               // repeat cnt
+        }
         if (islower(*dot)) {
             *dot = toupper(*dot);
-            file_modified++;    // has the file been modified
+            file_modified++;
         } else if (isupper(*dot)) {
             *dot = tolower(*dot);
-            file_modified++;    // has the file been modified
+            file_modified++;
         }
         dot_right();
@@ -3741 +3751 @@
         break;
         //----- The Cursor and Function Keys -----------------------------
-    case VI_K_HOME: // Cursor Key Home
+    case KEYCODE_HOME:  // Cursor Key Home
         dot_begin();
         break;
         // The Fn keys could point to do_macro which could translate them
-    case VI_K_FUN1: // Function Key F1
-    case VI_K_FUN2: // Function Key F2
-    case VI_K_FUN3: // Function Key F3
-    case VI_K_FUN4: // Function Key F4
-    case VI_K_FUN5: // Function Key F5
-    case VI_K_FUN6: // Function Key F6
-    case VI_K_FUN7: // Function Key F7
-    case VI_K_FUN8: // Function Key F8
-    case VI_K_FUN9: // Function Key F9
-    case VI_K_FUN10:    // Function Key F10
-    case VI_K_FUN11:    // Function Key F11
-    case VI_K_FUN12:    // Function Key F12
-        break;
+#if 0
+    case KEYCODE_FUN1:  // Function Key F1
+    case KEYCODE_FUN2:  // Function Key F2
+    case KEYCODE_FUN3:  // Function Key F3
+    case KEYCODE_FUN4:  // Function Key F4
+    case KEYCODE_FUN5:  // Function Key F5
+    case KEYCODE_FUN6:  // Function Key F6
+    case KEYCODE_FUN7:  // Function Key F7
+    case KEYCODE_FUN8:  // Function Key F8
+    case KEYCODE_FUN9:  // Function Key F9
+    case KEYCODE_FUN10: // Function Key F10
+    case KEYCODE_FUN11: // Function Key F11
+    case KEYCODE_FUN12: // Function Key F12
+        break;
+#endif
     }
 
@@ -3782 +3794 @@
 }
 
+/* NB!  the CRASHME code is unmaintained, and doesn't currently build */
 #if ENABLE_FEATURE_VI_CRASHME
 static int totalcmds = 0;
@@ -3791 +3804 @@
 static int Pp = 99;             // Put command Probability
 static int M = 0, N = 0, I = 0, D = 0, Y = 0, P = 0, U = 0;
-const char chars[20] = "\t012345 abcdABCD-=.$";
-const char *const words[20] = {
+static const char chars[20] = "\t012345 abcdABCD-=.$";
+static const char *const words[20] = {
     "this", "is", "a", "test",
     "broadcast", "the", "emergency", "of",
@@ -3799 +3812 @@
     "back", "January", "Febuary", "March"
 };
-const char *const lines[20] = {
+static const char *const lines[20] = {
     "You should have received a copy of the GNU General Public License\n",
     "char c, cm, *cmd, *cmd1;\n",
@@ -3821 +3834 @@
     "This is too much english for a computer geek.\n",
 };
-char *multilines[20] = {
+static char *multilines[20] = {
     "You should have received a copy of the GNU General Public License\n",
     "char c, cm, *cmd, *cmd1;\n",
@@ -3855 +3868 @@
 
     // is there already a command running?
-    if (readed_for_parse > 0)
+    if (readbuffer[0] > 0)
         goto cd1;
  cd0:
-    startrbi = rbi = 0;
+    readbuffer[0] = 'X';
+    startrbi = rbi = 1;
     sleeptime = 0;          // how long to pause between commands
-    memset(readbuffer, '\0', MAX_LINELEN);   // clear the read buffer
+    memset(readbuffer, '\0', sizeof(readbuffer));
     // generate a command by percentages
     percent = (int) lrand48() % 100;        // get a number from 0-99
@@ -3932 +3946 @@
         strcat(readbuffer, "\033");
     }
-    readed_for_parse = strlen(readbuffer);
+    readbuffer[0] = strlen(readbuffer + 1);
  cd1:
     totalcmds++;
@@ -3945 +3959 @@
 
     time_t tim;
-    char d[2], msg[MAX_LINELEN];
+    char d[2], msg[80];
 
     msg[0] = '\0';
@@ -3968 +3982 @@
 
     if (msg[0]) {
-        alarm(0);
         printf("\n\n%d: \'%c\' %s\n\n\n%s[Hit return to continue]%s",
             totalcmds, last_input_char, msg, SOs, SOn);
-        fflush(stdout);
-        while (read(0, d, 1) > 0) {
+        fflush_all();
+        while (safe_read(STDIN_FILENO, d, 1) > 0) {
             if (d[0] == '\n' || d[0] == '\r')
                 break;
         }
-        alarm(3);
-    }
-    tim = (time_t) time((time_t *) 0);
+    }
+    tim = time(NULL);
     if (tim >= (oldtim + 3)) {
         sprintf(status_buffer,