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

Timestamp:

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

Author:

Bruno Cornec

Message:

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

Location:

branches/3.3

Files:

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

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

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