8 files changed, 285 insertions, 215 deletions

diff --git a/editors/Config.src b/editors/Config.src
index af1e1de5e..c6e9d92af 100644
--- a/editors/Config.src
+++ b/editors/Config.src
@@ -7,66 +7,6 @@ menu "Editors"
 
 INSERT
 
-config AWK
-        bool "awk"
-        default y
-        help
-          Awk is used as a pattern scanning and processing language. This is
-          the BusyBox implementation of that programming language.
-
-config FEATURE_AWK_LIBM
-        bool "Enable math functions (requires libm)"
-        default y
-        depends on AWK
-        help
-          Enable math functions of the Awk programming language.
-          NOTE: This will require libm to be present for linking.
-
-config CMP
-        bool "cmp"
-        default y
-        help
-          cmp is used to compare two files and returns the result
-          to standard output.
-
-config DIFF
-        bool "diff"
-        default y
-        help
-          diff compares two files or directories and outputs the
-          differences between them in a form that can be given to
-          the patch command.
-
-config FEATURE_DIFF_LONG_OPTIONS
-        bool "Enable long options"
-        default y
-        depends on DIFF && LONG_OPTS
-        help
-          Enable use of long options.
-
-config FEATURE_DIFF_DIR
-        bool "Enable directory support"
-        default y
-        depends on DIFF
-        help
-          This option enables support for directory and subdirectory
-          comparison.
-
-config ED
-        bool "ed"
-        default y
-        help
-          The original 1970's Unix text editor, from the days of teletypes.
-          Small, simple, evil. Part of SUSv3. If you're not already using
-          this, you don't need it.
-
-config SED
-        bool "sed"
-        default y
-        help
-          sed is used to perform text transformations on a file
-          or input from a pipeline.
-
 config FEATURE_ALLOW_EXEC
         bool "Allow vi and awk to execute shell commands"
         default y
diff --git a/editors/Kbuild.src b/editors/Kbuild.src
index 8888cba12..6b4fb7470 100644
--- a/editors/Kbuild.src
+++ b/editors/Kbuild.src
@@ -7,8 +7,3 @@
 lib-y:=
 
 INSERT
-lib-$(CONFIG_AWK)       += awk.o
-lib-$(CONFIG_CMP)       += cmp.o
-lib-$(CONFIG_DIFF)      += diff.o
-lib-$(CONFIG_ED)        += ed.o
-lib-$(CONFIG_SED)       += sed.o
diff --git a/editors/awk.c b/editors/awk.c
index 77784dfc1..d0e3781e7 100644
--- a/editors/awk.c
+++ b/editors/awk.c
@@ -7,12 +7,45 @@
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
+//config:config AWK
+//config:       bool "awk"
+//config:       default y
+//config:       help
+//config:         Awk is used as a pattern scanning and processing language. This is
+//config:         the BusyBox implementation of that programming language.
+//config:
+//config:config FEATURE_AWK_LIBM
+//config:       bool "Enable math functions (requires libm)"
+//config:       default y
+//config:       depends on AWK
+//config:       help
+//config:         Enable math functions of the Awk programming language.
+//config:         NOTE: This will require libm to be present for linking.
+//config:
+//config:config FEATURE_AWK_GNU_EXTENSIONS
+//config:       bool "Enable a few GNU extensions"
+//config:       default y
+//config:       depends on AWK
+//config:       help
+//config:         Enable a few features from gawk:
+//config:         * command line option -e AWK_PROGRAM
+//config:         * simultaneous use of -f and -e on the command line.
+//config:           This enables the use of awk library files.
+//config:           Ex: awk -f mylib.awk -e '{print myfunction($1);}' ...
+
+//applet:IF_AWK(APPLET_NOEXEC(awk, awk, BB_DIR_USR_BIN, BB_SUID_DROP, awk))
+
+//kbuild:lib-$(CONFIG_AWK) += awk.o
+
 //usage:#define awk_trivial_usage
 //usage:       "[OPTIONS] [AWK_PROGRAM] [FILE]..."
 //usage:#define awk_full_usage "\n\n"
 //usage:       "        -v VAR=VAL      Set variable"
 //usage:     "\n        -F SEP          Use SEP as field separator"
 //usage:     "\n        -f FILE         Read program from FILE"
+//usage:        IF_FEATURE_AWK_GNU_EXTENSIONS(
+//usage:     "\n        -e AWK_PROGRAM"
+//usage:        )
 
 #include "libbb.h"
 #include "xregex.h"
@@ -38,6 +71,25 @@
 #endif
 
 
+#define OPTSTR_AWK \
+        "F:v:f:" \
+        IF_FEATURE_AWK_GNU_EXTENSIONS("e:") \
+        "W:"
+#define OPTCOMPLSTR_AWK \
+        "v::f::" \
+        IF_FEATURE_AWK_GNU_EXTENSIONS("e::")
+enum {
+        OPTBIT_F,       /* define field separator */
+        OPTBIT_v,       /* define variable */
+        OPTBIT_f,       /* pull in awk program from file */
+        IF_FEATURE_AWK_GNU_EXTENSIONS(OPTBIT_e,) /* -e AWK_PROGRAM */
+        OPTBIT_W,       /* -W ignored */
+        OPT_F = 1 << OPTBIT_F,
+        OPT_v = 1 << OPTBIT_v,
+        OPT_f = 1 << OPTBIT_f,
+        OPT_e = IF_FEATURE_AWK_GNU_EXTENSIONS((1 << OPTBIT_e)) + 0,
+        OPT_W = 1 << OPTBIT_W
+};
 
 #define MAXVARFMT       240
 #define MINNVBLOCK      64
@@ -2784,8 +2836,16 @@ static var *evaluate(node *op, var *res)
                                 break;
 
                         case F_le:
-                                if (!op1)
+                                debug_printf_eval("length: L.s:'%s'\n", L.s);
+                                if (!op1) {
                                         L.s = getvar_s(intvar[F0]);
+                                        debug_printf_eval("length: L.s='%s'\n", L.s);
+                                }
+                                else if (L.v->type & VF_ARRAY) {
+                                        R_d = L.v->x.array->nel;
+                                        debug_printf_eval("length: array_len:%d\n", L.v->x.array->nel);
+                                        break;
+                                }
                                 R_d = strlen(L.s);
                                 break;
 
@@ -3079,6 +3139,9 @@ int awk_main(int argc, char **argv)
         char *opt_F;
         llist_t *list_v = NULL;
         llist_t *list_f = NULL;
+#if ENABLE_FEATURE_AWK_GNU_EXTENSIONS
+        llist_t *list_e = NULL;
+#endif
         int i, j;
         var *v;
         var tv;
@@ -3137,47 +3200,51 @@ int awk_main(int argc, char **argv)
                         *s1 = '=';
                 }
         }
-        opt_complementary = "v::f::"; /* -v and -f can occur multiple times */
-        opt = getopt32(argv, "F:v:f:W:", &opt_F, &list_v, &list_f, NULL);
+        opt_complementary = OPTCOMPLSTR_AWK;
+        opt = getopt32(argv, OPTSTR_AWK, &opt_F, &list_v, &list_f, IF_FEATURE_AWK_GNU_EXTENSIONS(&list_e,) NULL);
         argv += optind;
         argc -= optind;
-        if (opt & 0x1) { /* -F */
+        if (opt & OPT_W)
+                bb_error_msg("warning: option -W is ignored");
+        if (opt & OPT_F) {
                 unescape_string_in_place(opt_F);
                 setvar_s(intvar[FS], opt_F);
         }
-        while (list_v) { /* -v */
+        while (list_v) {
                 if (!is_assignment(llist_pop(&list_v)))
                         bb_show_usage();
         }
-        if (list_f) { /* -f */
-                do {
-                        char *s = NULL;
-                        FILE *from_file;
-
-                        g_progname = llist_pop(&list_f);
-                        from_file = xfopen_stdin(g_progname);
-                        /* one byte is reserved for some trick in next_token */
-                        for (i = j = 1; j > 0; i += j) {
-                                s = xrealloc(s, i + 4096);
-                                j = fread(s + i, 1, 4094, from_file);
-                        }
-                        s[i] = '\0';
-                        fclose(from_file);
-                        parse_program(s + 1);
-                        free(s);
-                } while (list_f);
-                argc++;
-        } else { // no -f: take program from 1st parameter
-                if (!argc)
+        while (list_f) {
+                char *s = NULL;
+                FILE *from_file;
+
+                g_progname = llist_pop(&list_f);
+                from_file = xfopen_stdin(g_progname);
+                /* one byte is reserved for some trick in next_token */
+                for (i = j = 1; j > 0; i += j) {
+                        s = xrealloc(s, i + 4096);
+                        j = fread(s + i, 1, 4094, from_file);
+                }
+                s[i] = '\0';
+                fclose(from_file);
+                parse_program(s + 1);
+                free(s);
+        }
+        g_progname = "cmd. line";
+#if ENABLE_FEATURE_AWK_GNU_EXTENSIONS
+        while (list_e) {
+                parse_program(llist_pop(&list_e));
+        }
+#endif
+        if (!(opt & (OPT_f | OPT_e))) {
+                if (!*argv)
                         bb_show_usage();
-                g_progname = "cmd. line";
                 parse_program(*argv++);
+                argc--;
         }
-        if (opt & 0x8) // -W
-                bb_error_msg("warning: option -W is ignored");
 
         /* fill in ARGV array */
-        setvar_i(intvar[ARGC], argc);
+        setvar_i(intvar[ARGC], argc + 1);
         setari_u(intvar[ARGV], 0, "awk");
         i = 0;
         while (*argv)
diff --git a/editors/cmp.c b/editors/cmp.c
index fbe6b9753..a4af6f480 100644
--- a/editors/cmp.c
+++ b/editors/cmp.c
@@ -10,6 +10,17 @@
 /* BB_AUDIT SUSv3 (virtually) compliant -- uses nicer GNU format for -l. */
 /* http://www.opengroup.org/onlinepubs/007904975/utilities/cmp.html */
 
+//config:config CMP
+//config:       bool "cmp"
+//config:       default y
+//config:       help
+//config:         cmp is used to compare two files and returns the result
+//config:         to standard output.
+
+//kbuild:lib-$(CONFIG_CMP) += cmp.o
+
+//applet:IF_CMP(APPLET(cmp, BB_DIR_USR_BIN, BB_SUID_DROP))
+
 //usage:#define cmp_trivial_usage
 //usage:       "[-l] [-s] FILE1 [FILE2" IF_DESKTOP(" [SKIP1 [SKIP2]]") "]"
 //usage:#define cmp_full_usage "\n\n"
diff --git a/editors/diff.c b/editors/diff.c
index b08ded3a1..a78a0ee28 100644
--- a/editors/diff.c
+++ b/editors/diff.c
@@ -76,6 +76,33 @@
  * 6n words for files of length n.
  */
 
+//config:config DIFF
+//config:       bool "diff"
+//config:       default y
+//config:       help
+//config:         diff compares two files or directories and outputs the
+//config:         differences between them in a form that can be given to
+//config:         the patch command.
+//config:
+//config:config FEATURE_DIFF_LONG_OPTIONS
+//config:       bool "Enable long options"
+//config:       default y
+//config:       depends on DIFF && LONG_OPTS
+//config:       help
+//config:         Enable use of long options.
+//config:
+//config:config FEATURE_DIFF_DIR
+//config:       bool "Enable directory support"
+//config:       default y
+//config:       depends on DIFF
+//config:       help
+//config:         This option enables support for directory and subdirectory
+//config:         comparison.
+
+//kbuild:lib-$(CONFIG_DIFF) += diff.o
+
+//applet:IF_DIFF(APPLET(diff, BB_DIR_USR_BIN, BB_SUID_DROP))
+
 //usage:#define diff_trivial_usage
 //usage:       "[-abBdiNqrTstw] [-L LABEL] [-S FILE] [-U LINES] FILE1 FILE2"
 //usage:#define diff_full_usage "\n\n"
diff --git a/editors/ed.c b/editors/ed.c
index dbb51306c..3087fb0b9 100644
--- a/editors/ed.c
+++ b/editors/ed.c
@@ -7,6 +7,18 @@
  * The "ed" built-in command (much simplified)
  */
 
+//config:config ED
+//config:       bool "ed"
+//config:       default y
+//config:       help
+//config:         The original 1970's Unix text editor, from the days of teletypes.
+//config:         Small, simple, evil. Part of SUSv3. If you're not already using
+//config:         this, you don't need it.
+
+//kbuild:lib-$(CONFIG_ED) += ed.o
+
+//applet:IF_ED(APPLET(ed, BB_DIR_BIN, BB_SUID_DROP))
+
 //usage:#define ed_trivial_usage ""
 //usage:#define ed_full_usage ""
 
diff --git a/editors/patch_bbox.c b/editors/patch_bbox.c
index 78aa5fde8..aae7b7987 100644
--- a/editors/patch_bbox.c
+++ b/editors/patch_bbox.c
@@ -188,8 +188,8 @@ int patch_main(int argc UNUSED_PARAM, char **argv)
                         unsigned src_last_line = 1;
                         unsigned dst_last_line = 1;
 
-                        if ((sscanf(patch_line, "@@ -%d,%d +%d,%d", &src_beg_line, &src_last_line, &dst_beg_line, &dst_last_line) < 3)
-                         && (sscanf(patch_line, "@@ -%d +%d,%d", &src_beg_line, &dst_beg_line, &dst_last_line) < 2)
+                        if ((sscanf(patch_line, "@@ -%u,%u +%u,%u", &src_beg_line, &src_last_line, &dst_beg_line, &dst_last_line) < 3)
+                         && (sscanf(patch_line, "@@ -%u +%u,%u", &src_beg_line, &dst_beg_line, &dst_last_line) < 2)
                         ) {
                                 /* No more hunks for this file */
                                 break;
diff --git a/editors/sed.c b/editors/sed.c
index 3a0d917aa..e18e48ab5 100644
--- a/editors/sed.c
+++ b/editors/sed.c
@@ -23,9 +23,6 @@
  * resulting sed_cmd_t structures are appended to a linked list
  * (G.sed_cmd_head/G.sed_cmd_tail).
  *
- * add_input_file() adds a FILE* to the list of input files.  We need to
- * know all input sources ahead of time to find the last line for the $ match.
- *
  * process_files() does actual sedding, reading data lines from each input FILE*
  * (which could be stdin) and applying the sed command list (sed_cmd_head) to
  * each of the resulting lines.
@@ -58,16 +55,27 @@
  * http://pubs.opengroup.org/onlinepubs/9699919799/utilities/sed.html
  */
 
+//config:config SED
+//config:       bool "sed"
+//config:       default y
+//config:       help
+//config:         sed is used to perform text transformations on a file
+//config:         or input from a pipeline.
+
+//kbuild:lib-$(CONFIG_SED) += sed.o
+
+//applet:IF_SED(APPLET(sed, BB_DIR_BIN, BB_SUID_DROP))
+
 //usage:#define sed_trivial_usage
-//usage:       "[-inr] [-f FILE]... [-e CMD]... [FILE]...\n"
-//usage:       "or: sed [-inr] CMD [FILE]..."
+//usage:       "[-inrE] [-f FILE]... [-e CMD]... [FILE]...\n"
+//usage:       "or: sed [-inrE] CMD [FILE]..."
 //usage:#define sed_full_usage "\n\n"
 //usage:       "        -e CMD  Add CMD to sed commands to be executed"
 //usage:     "\n        -f FILE Add FILE contents to sed commands to be executed"
 //usage:     "\n        -i[SFX] Edit files in-place (otherwise sends to stdout)"
 //usage:     "\n                Optionally back files up, appending SFX"
 //usage:     "\n        -n      Suppress automatic printing of pattern space"
-//usage:     "\n        -r      Use extended regex syntax"
+//usage:     "\n        -r,-E   Use extended regex syntax"
 //usage:     "\n"
 //usage:     "\nIf no -e or -f, the first non-option argument is the sed command string."
 //usage:     "\nRemaining arguments are input files (stdin if none)."
@@ -124,12 +132,15 @@ static const char semicolon_whitespace[] ALIGN1 = "; \n\r\t\v";
 struct globals {
         /* options */
         int be_quiet, regex_type;
+
         FILE *nonstdout;
         char *outname, *hold_space;
+        smallint exitcode;
 
-        /* List of input files */
-        int input_file_count, current_input_file;
-        FILE **input_file_list;
+        /* list of input files */
+        int current_input_file, last_input_file;
+        char **input_file_list;
+        FILE *current_fp;
 
         regmatch_t regmatch[10];
         regex_t *previous_regex_ptr;
@@ -137,7 +148,7 @@ struct globals {
         /* linked list of sed commands */
         sed_cmd_t *sed_cmd_head, **sed_cmd_tail;
 
-        /* Linked list of append lines */
+        /* linked list of append lines */
         llist_t *append_head;
 
         char *add_cmd_line;
@@ -189,8 +200,8 @@ static void sed_free_and_close_stuff(void)
 
         free(G.hold_space);
 
-        while (G.current_input_file < G.input_file_count)
-                fclose(G.input_file_list[G.current_input_file++]);
+        if (G.current_fp)
+                fclose(G.current_fp);
 }
 #else
 void sed_free_and_close_stuff(void);
@@ -370,7 +381,7 @@ static int parse_subst_cmd(sed_cmd_t *sed_cmd, const char *substr)
 
         /*
          * A substitution command should look something like this:
-         *    s/match/replace/ #gIpw
+         *    s/match/replace/ #giIpw
          *    ||     |        |||
          *    mandatory       optional
          */
@@ -418,6 +429,7 @@ static int parse_subst_cmd(sed_cmd_t *sed_cmd, const char *substr)
                         break;
                 }
                 /* Ignore case (gnu exension) */
+                case 'i':
                 case 'I':
                         cflags |= REG_ICASE;
                         break;
@@ -848,46 +860,100 @@ static sed_cmd_t *branch_to(char *label)
 
 static void append(char *s)
 {
-        llist_add_to_end(&G.append_head, xstrdup(s));
+        llist_add_to_end(&G.append_head, s);
 }
 
-static void flush_append(void)
+/* Output line of text. */
+/* Note:
+ * The tricks with NO_EOL_CHAR and last_puts_char are there to emulate gnu sed.
+ * Without them, we had this:
+ * echo -n thingy >z1
+ * echo -n again >z2
+ * >znull
+ * sed "s/i/z/" z1 z2 znull | hexdump -vC
+ * output:
+ * gnu sed 4.1.5:
+ * 00000000  74 68 7a 6e 67 79 0a 61  67 61 7a 6e              |thzngy.agazn|
+ * bbox:
+ * 00000000  74 68 7a 6e 67 79 61 67  61 7a 6e                 |thzngyagazn|
+ */
+enum {
+        NO_EOL_CHAR = 1,
+        LAST_IS_NUL = 2,
+};
+static void puts_maybe_newline(char *s, FILE *file, char *last_puts_char, char last_gets_char)
+{
+        char lpc = *last_puts_char;
+
+        /* Need to insert a '\n' between two files because first file's
+         * last line wasn't terminated? */
+        if (lpc != '\n' && lpc != '\0') {
+                fputc('\n', file);
+                lpc = '\n';
+        }
+        fputs(s, file);
+
+        /* 'x' - just something which is not '\n', '\0' or NO_EOL_CHAR */
+        if (s[0])
+                lpc = 'x';
+
+        /* had trailing '\0' and it was last char of file? */
+        if (last_gets_char == LAST_IS_NUL) {
+                fputc('\0', file);
+                lpc = 'x'; /* */
+        } else
+        /* had trailing '\n' or '\0'? */
+        if (last_gets_char != NO_EOL_CHAR) {
+                fputc(last_gets_char, file);
+                lpc = last_gets_char;
+        }
+
+        if (ferror(file)) {
+                xfunc_error_retval = 4;  /* It's what gnu sed exits with... */
+                bb_error_msg_and_die(bb_msg_write_error);
+        }
+        *last_puts_char = lpc;
+}
+
+static void flush_append(char *last_puts_char, char last_gets_char)
 {
         char *data;
 
         /* Output appended lines. */
         while ((data = (char *)llist_pop(&G.append_head))) {
-                fprintf(G.nonstdout, "%s\n", data);
+                puts_maybe_newline(data, G.nonstdout, last_puts_char, last_gets_char);
                 free(data);
         }
 }
 
-static void add_input_file(FILE *file)
-{
-        G.input_file_list = xrealloc_vector(G.input_file_list, 2, G.input_file_count);
-        G.input_file_list[G.input_file_count++] = file;
-}
-
 /* Get next line of input from G.input_file_list, flushing append buffer and
  * noting if we ran out of files without a newline on the last line we read.
  */
-enum {
-        NO_EOL_CHAR = 1,
-        LAST_IS_NUL = 2,
-};
-static char *get_next_line(char *gets_char)
+static char *get_next_line(char *gets_char, char *last_puts_char, char last_gets_char)
 {
         char *temp = NULL;
         int len;
         char gc;
 
-        flush_append();
+        flush_append(last_puts_char, last_gets_char);
 
         /* will be returned if last line in the file
          * doesn't end with either '\n' or '\0' */
         gc = NO_EOL_CHAR;
-        while (G.current_input_file < G.input_file_count) {
-                FILE *fp = G.input_file_list[G.current_input_file];
+        for (; G.current_input_file <= G.last_input_file; G.current_input_file++) {
+                FILE *fp = G.current_fp;
+                if (!fp) {
+                        const char *path = G.input_file_list[G.current_input_file];
+                        fp = stdin;
+                        if (path != bb_msg_standard_input) {
+                                fp = fopen_or_warn(path, "r");
+                                if (!fp) {
+                                        G.exitcode = EXIT_FAILURE;
+                                        continue;
+                                }
+                        }
+                        G.current_fp = fp;
+                }
                 /* Read line up to a newline or NUL byte, inclusive,
                  * return malloc'ed char[]. length of the chunk read
                  * is stored in len. NULL if EOF/error */
@@ -918,61 +984,13 @@ static char *get_next_line(char *gets_char)
                  * (note: *no* newline after "b bang"!) */
                 }
                 /* Close this file and advance to next one */
-                fclose(fp);
-                G.current_input_file++;
+                fclose_if_not_stdin(fp);
+                G.current_fp = NULL;
         }
         *gets_char = gc;
         return temp;
 }
 
-/* Output line of text. */
-/* Note:
- * The tricks with NO_EOL_CHAR and last_puts_char are there to emulate gnu sed.
- * Without them, we had this:
- * echo -n thingy >z1
- * echo -n again >z2
- * >znull
- * sed "s/i/z/" z1 z2 znull | hexdump -vC
- * output:
- * gnu sed 4.1.5:
- * 00000000  74 68 7a 6e 67 79 0a 61  67 61 7a 6e              |thzngy.agazn|
- * bbox:
- * 00000000  74 68 7a 6e 67 79 61 67  61 7a 6e                 |thzngyagazn|
- */
-static void puts_maybe_newline(char *s, FILE *file, char *last_puts_char, char last_gets_char)
-{
-        char lpc = *last_puts_char;
-
-        /* Need to insert a '\n' between two files because first file's
-         * last line wasn't terminated? */
-        if (lpc != '\n' && lpc != '\0') {
-                fputc('\n', file);
-                lpc = '\n';
-        }
-        fputs(s, file);
-
-        /* 'x' - just something which is not '\n', '\0' or NO_EOL_CHAR */
-        if (s[0])
-                lpc = 'x';
-
-        /* had trailing '\0' and it was last char of file? */
-        if (last_gets_char == LAST_IS_NUL) {
-                fputc('\0', file);
-                lpc = 'x'; /* */
-        } else
-        /* had trailing '\n' or '\0'? */
-        if (last_gets_char != NO_EOL_CHAR) {
-                fputc(last_gets_char, file);
-                lpc = last_gets_char;
-        }
-
-        if (ferror(file)) {
-                xfunc_error_retval = 4;  /* It's what gnu sed exits with... */
-                bb_error_msg_and_die(bb_msg_write_error);
-        }
-        *last_puts_char = lpc;
-}
-
 #define sed_puts(s, n) (puts_maybe_newline(s, G.nonstdout, &last_puts_char, n))
 
 static int beg_match(sed_cmd_t *sed_cmd, const char *pattern_space)
@@ -995,7 +1013,7 @@ static void process_files(void)
         int substituted;
 
         /* Prime the pump */
-        next_line = get_next_line(&next_gets_char);
+        next_line = get_next_line(&next_gets_char, &last_puts_char, '\n' /*last_gets_char*/);
 
         /* Go through every line in each file */
  again:
@@ -1009,7 +1027,7 @@ static void process_files(void)
 
         /* Read one line in advance so we can act on the last line,
          * the '$' address */
-        next_line = get_next_line(&next_gets_char);
+        next_line = get_next_line(&next_gets_char, &last_puts_char, last_gets_char);
         linenum++;
 
         /* For every line, go through all the commands */
@@ -1181,7 +1199,7 @@ static void process_files(void)
 
                 /* Append line to linked list to be printed later */
                 case 'a':
-                        append(sed_cmd->string);
+                        append(xstrdup(sed_cmd->string));
                         break;
 
                 /* Insert text before this line */
@@ -1203,11 +1221,10 @@ static void process_files(void)
                         rfile = fopen_for_read(sed_cmd->string);
                         if (rfile) {
                                 char *line;
-
                                 while ((line = xmalloc_fgetline(rfile))
                                                 != NULL)
                                         append(line);
-                                xprint_and_close_file(rfile);
+                                fclose(rfile);
                         }
 
                         break;
@@ -1228,7 +1245,7 @@ static void process_files(void)
                                 free(pattern_space);
                                 pattern_space = next_line;
                                 last_gets_char = next_gets_char;
-                                next_line = get_next_line(&next_gets_char);
+                                next_line = get_next_line(&next_gets_char, &last_puts_char, last_gets_char);
                                 substituted = 0;
                                 linenum++;
                                 break;
@@ -1264,7 +1281,7 @@ static void process_files(void)
                         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);
+                        next_line = get_next_line(&next_gets_char, &last_puts_char, last_gets_char);
                         linenum++;
                         break;
                 }
@@ -1368,7 +1385,7 @@ static void process_files(void)
 
         /* Delete and such jump here. */
  discard_line:
-        flush_append();
+        flush_append(&last_puts_char, last_gets_char);
         free(pattern_space);
 
         goto again;
@@ -1413,8 +1430,6 @@ int sed_main(int argc UNUSED_PARAM, char **argv)
                 "file\0"            Required_argument   "f";
 #endif
 
-        int status = EXIT_SUCCESS;
-
         INIT_G();
 
         /* destroy command strings on exit */
@@ -1435,15 +1450,21 @@ int sed_main(int argc UNUSED_PARAM, char **argv)
         IF_LONG_OPTS(applet_long_options = sed_longopts);
 
         /* -i must be first, to match OPT_in_place definition */
-        opt = getopt32(argv, "i::rne:f:", &opt_i, &opt_e, &opt_f,
+        /* -E is a synonym of -r:
+         * GNU sed 4.2.1 mentions it in neither --help
+         * nor manpage, but does recognize it.
+         */
+        opt = getopt32(argv, "i::rEne:f:", &opt_i, &opt_e, &opt_f,
                             &G.be_quiet); /* counter for -n */
         //argc -= optind;
         argv += optind;
         if (opt & OPT_in_place) { // -i
                 atexit(cleanup_outname);
         }
-        if (opt & 0x2) G.regex_type |= REG_EXTENDED; // -r
-        //if (opt & 0x4) G.be_quiet++; // -n
+        if (opt & (2|4))
+                G.regex_type |= REG_EXTENDED; // -r or -E
+        //if (opt & 8)
+        //      G.be_quiet++; // -n (implemented with a counter instead)
         while (opt_e) { // -e
                 add_cmd_block(llist_pop(&opt_e));
         }
@@ -1458,7 +1479,7 @@ int sed_main(int argc UNUSED_PARAM, char **argv)
                 fclose(cmdfile);
         }
         /* if we didn't get a pattern from -e or -f, use argv[0] */
-        if (!(opt & 0x18)) {
+        if (!(opt & 0x30)) {
                 if (!*argv)
                         bb_show_usage();
                 add_cmd_block(*argv++);
@@ -1472,42 +1493,38 @@ int sed_main(int argc UNUSED_PARAM, char **argv)
         /* argv[0..(argc-1)] should be names of file to process. If no
          * files were specified or '-' was specified, take input from stdin.
          * Otherwise, we process all the files specified. */
-        if (argv[0] == NULL) {
+        G.input_file_list = argv;
+        if (!argv[0]) {
                 if (opt & OPT_in_place)
                         bb_error_msg_and_die(bb_msg_requires_arg, "-i");
-                add_input_file(stdin);
+                argv[0] = (char*)bb_msg_standard_input;
+                /* G.last_input_file = 0; - already is */
         } else {
-                int i;
+                goto start;
 
-                for (i = 0; argv[i]; i++) {
+                for (; *argv; argv++) {
                         struct stat statbuf;
                         int nonstdoutfd;
-                        FILE *file;
                         sed_cmd_t *sed_cmd;
 
-                        if (LONE_DASH(argv[i]) && !(opt & OPT_in_place)) {
-                                add_input_file(stdin);
-                                process_files();
-                                continue;
-                        }
-                        file = fopen_or_warn(argv[i], "r");
-                        if (!file) {
-                                status = EXIT_FAILURE;
-                                continue;
-                        }
-                        add_input_file(file);
+                        G.last_input_file++;
+ start:
                         if (!(opt & OPT_in_place)) {
+                                if (LONE_DASH(*argv)) {
+                                        *argv = (char*)bb_msg_standard_input;
+                                        process_files();
+                                }
                                 continue;
                         }
 
                         /* -i: process each FILE separately: */
 
-                        G.outname = xasprintf("%sXXXXXX", argv[i]);
+                        G.outname = xasprintf("%sXXXXXX", *argv);
                         nonstdoutfd = xmkstemp(G.outname);
                         G.nonstdout = xfdopen_for_write(nonstdoutfd);
 
                         /* Set permissions/owner of output file */
-                        fstat(fileno(file), &statbuf);
+                        stat(*argv, &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);
@@ -1518,12 +1535,12 @@ int sed_main(int argc UNUSED_PARAM, char **argv)
                         G.nonstdout = stdout;
 
                         if (opt_i) {
-                                char *backupname = xasprintf("%s%s", argv[i], opt_i);
-                                xrename(argv[i], backupname);
+                                char *backupname = xasprintf("%s%s", *argv, opt_i);
+                                xrename(*argv, backupname);
                                 free(backupname);
                         }
-                        /* else unlink(argv[i]); - rename below does this */
-                        xrename(G.outname, argv[i]); //TODO: rollback backup on error?
+                        /* else unlink(*argv); - rename below does this */
+                        xrename(G.outname, *argv); //TODO: rollback backup on error?
                         free(G.outname);
                         G.outname = NULL;
 
@@ -1533,12 +1550,13 @@ int sed_main(int argc UNUSED_PARAM, char **argv)
                         }
                 }
                 /* Here, to handle "sed 'cmds' nonexistent_file" case we did:
-                 * if (G.current_input_file >= G.input_file_count)
-                 *      return status;
+                 * if (G.current_input_file[G.current_input_file] == NULL)
+                 *      return G.exitcode;
                  * but it's not needed since process_files() works correctly
                  * in this case too. */
         }
+
         process_files();
 
-        return status;
+        return G.exitcode;
 }