X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=editors%2Fsed.c;h=0f0f4a28d19829907293ab7335e1fe544aee2ad8;hb=f1bbb22dca4d39aa227246f4c2ee90acd7e512a4;hp=2fb243fb94ae4e09861b02aef6d868ed010a292e;hpb=df5f6ba1159f8c1af500fa1b8eb9c9646e4de2a6;p=oweals%2Fbusybox.git

diff --git a/editors/sed.c b/editors/sed.c
index 2fb243fb9..0f0f4a28d 100644
--- a/editors/sed.c
+++ b/editors/sed.c
@@ -1,8 +1,8 @@
 /*
  * sed.c - very minimalist version of sed
  *
- * Copyright (C) 1999,2000 by Lineo, inc.
- * Written by Mark Whitley <markw@lineo.com>, <markw@enol.com>
+ * Copyright (C) 1999,2000,2001 by Lineo, inc.
+ * Written by Mark Whitley <markw@lineo.com>, <markw@codepoet.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,8 +24,10 @@
 	Supported features and commands in this version of sed:
 
 	 - comments ('#')
-	 - Address matching: num|/matchstr/[,num|/matchstr/|$]command
-	 - Commands: p, d, s/match/replace/[g]
+	 - address matching: num|/matchstr/[,num|/matchstr/|$]command
+	 - commands: (p)rint, (d)elete, (s)ubstitue (with g & I flags)
+	 - edit commands: (a)ppend, (i)nsert, (c)hange
+	 - backreferences in substitution expressions (\1, \2...\9)
 	 
 	 (Note: Specifying an address (range) to match is *optional*; commands
 	 default to the whole pattern space if no specific address match was
@@ -34,32 +36,35 @@
 	Unsupported features:
 
 	 - transliteration (y/source-chars/dest-chars/) (use 'tr')
-	 - no support for characters other than the '/' character for regex matches
 	 - no pattern space hold space storing / swapping (x, etc.)
 	 - no labels / branching (: label, b, t, and friends)
 	 - and lots, lots more.
-
 */
 
 #include <stdio.h>
-#include <stdlib.h> /* for realloc() */
 #include <unistd.h> /* for getopt() */
 #include <regex.h>
 #include <string.h> /* for strdup() */
 #include <errno.h>
 #include <ctype.h> /* for isspace() */
-#include "internal.h"
-
+#include <stdlib.h>
+#include "busybox.h"
 
 /* externs */
+extern void xregcomp(regex_t *preg, const char *regex, int cflags);
 extern int optind; /* in unistd.h */
 extern char *optarg; /* ditto */
 
 /* options */
 static int be_quiet = 0;
 
+
 struct sed_cmd {
 
+
+	/* GENERAL FIELDS */
+	char delimiter;	    /* The delimiter used to separate regexps */
+
 	/* address storage */
 	int beg_line; /* 'sed 1p'   0 == no begining line, apply commands to all lines */
 	int end_line; /* 'sed 1,3p' 0 == no end line, use only beginning. -1 == $ */
@@ -69,10 +74,22 @@ struct sed_cmd {
 	/* the command */
 	char cmd; /* p,d,s (add more at your leisure :-) */
 
-	/* substitution command specific fields */
-	regex_t *sub_match; /* sed -e 's/sub_match/replace/' */
-	char *replace; /* sed -e 's/sub_match/replace/' XXX: who will hold the \1 \2 \3s? */
+
+	/* SUBSTITUTION COMMAND SPECIFIC FIELDS */
+
+	/* sed -e 's/sub_match/replace/' */
+	regex_t *sub_match;
+	char *replace;
+	unsigned int num_backrefs:4; /* how many back references (\1..\9) */
+			/* Note:  GNU/POSIX sed does not save more than nine backrefs, so
+			 * we only use 4 bits to hold the number */
 	unsigned int sub_g:1; /* sed -e 's/foo/bar/g' (global) */
+	unsigned int sub_p:2; /* sed -e 's/foo/bar/p' (print substitution) */
+
+
+	/* EDIT COMMAND (a,i,c) SPEICIFIC FIELDS */
+
+	char *editline;
 };
 
 /* globals */
@@ -81,22 +98,7 @@ static int ncmds = 0; /* number of sed commands */
 
 /*static char *cur_file = NULL;*/ /* file currently being processed XXX: do I need this? */
 
-static const char sed_usage[] =
-	"sed [-Vhnef] pattern [files...]\n"
-#ifndef BB_FEATURE_TRIVIAL_HELP
-	"\n"
-	"-n\tsuppress automatic printing of pattern space\n"
-	"-e script\tadd the script to the commands to be executed\n"
-	"-f scriptfile\tadd the contents of script-file to the commands to be executed\n"
-	"-h\tdisplay this help message\n"
-	"-V\toutput version information and exit\n"
-	"\n"
-	"If no -e or -f is given, the first non-option argument is taken as the\n"
-	"sed script to interpret. All remaining arguments are names of input\n"
-	"files; if no input files are specified, then the standard input is read.\n"
-#endif
-	;
-
+#ifdef BB_FEATURE_CLEAN_UP
 static void destroy_cmd_strs()
 {
 	if (sed_cmds == NULL)
@@ -125,65 +127,30 @@ static void destroy_cmd_strs()
 	free(sed_cmds);
 	sed_cmds = NULL;
 }
+#endif
 
-static void exit_sed(int retcode, const char *message)
-{
-	destroy_cmd_strs();
-	if (message)
-		fputs(message, stderr);
-	exit(retcode);
-}
-
-/*
- * trim_str - trims leading and trailing space from a string
- * 
- * Note: This returns a malloc'ed string so you must store and free it
- * XXX: This should be in the utility.c file.
- */
-static char *trim_str(const char *str)
-{
-	int i;
-	char *retstr = strdup(str);
-
-	/* trim leading whitespace */
-	memmove(retstr, &retstr[strspn(retstr, " \n\t\v")], strlen(retstr));
-
-	/* trim trailing whitespace */
-	i = strlen(retstr) - 1;
-	while (isspace(retstr[i]))
-		i--;
-	retstr[++i] = 0;
-
-	/* Aside: 
-	 *
-	 * you know, a strrspn() would really be nice cuz then we could say:
-	 * 
-	 * retstr[strlen(retstr) - strrspn(retstr, " \n\t\v") + 1] = 0;
-	 */
-	
-	return retstr;
-}
 
 /*
- * index_of_unescaped_slash - walks left to right through a string beginning
- * at a specified index and returns the index of the next unescaped slash.
+ * 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 preceeded by 
+ * a backslash ('\').
  */
-static int index_of_next_unescaped_slash(int idx, const char *str)
+static int index_of_next_unescaped_regexp_delim(struct sed_cmd *sed_cmd, const char *str, int idx)
 {
-	do {
-		idx++;
-		/* test if we've hit the end */
-		if (str[idx] == 0)
-			return -1;
-	} while (str[idx] != '/' && str[idx - 1] != '\\');
+	for ( ; str[idx]; idx++) {
+		if (str[idx] == sed_cmd->delimiter && str[idx-1] != '\\')
+			return idx;
+	}
 
-	return idx;
+	/* if we make it to here, we've hit the end of the string */
+	return -1;
 }
 
 /*
  * returns the index in the string just past where the address ends.
  */
-static int get_address(const char *str, int *line, regex_t **regex)
+static int get_address(struct sed_cmd *sed_cmd, const char *str, int *line, regex_t **regex)
 {
 	char *my_str = strdup(str);
 	int idx = 0;
@@ -194,27 +161,23 @@ static int get_address(const char *str, int *line, regex_t **regex)
 		} while (isdigit(my_str[idx]));
 		my_str[idx] = 0;
 		*line = atoi(my_str);
-		*regex = NULL;
 	}
 	else if (my_str[idx] == '$') {
 		*line = -1;
-		*regex = NULL;
 		idx++;
 	}
 	else if (my_str[idx] == '/') {
-		idx = index_of_next_unescaped_slash(idx, my_str);
+		idx = index_of_next_unescaped_regexp_delim(sed_cmd, my_str, ++idx);
 		if (idx == -1)
-			exit_sed(1, "sed: unterminated match expression\n");
+			error_msg_and_die("unterminated match expression");
 		my_str[idx] = '\0';
 		*regex = (regex_t *)xmalloc(sizeof(regex_t));
-		if (bb_regcomp(*regex, my_str+1, REG_NEWLINE) != 0) {
-			free(my_str);
-			exit_sed(1, NULL);
-		}
+		xregcomp(*regex, my_str+1, 0);
+		idx++; /* so it points to the next character after the last '/' */
 	}
 	else {
-		fprintf(stderr, "sed.c:get_address: no address found in string\n");
-		fprintf(stderr, "\t(you probably didn't check the string you passed me)\n");
+		error_msg("get_address: no address found in string\n"
+				"\t(you probably didn't check the string you passed me)");
 		idx = -1;
 	}
 
@@ -231,7 +194,158 @@ static char *strdup_substr(const char *str, int start, int end)
 	return newstr;
 }
 
-static void parse_cmd_str(struct sed_cmd *sed_cmd, const char *cmdstr)
+static int parse_subst_cmd(struct sed_cmd *sed_cmd, const char *substr)
+{
+	int oldidx, cflags = REG_NEWLINE;
+	char *match;
+	int idx = 0;
+	int j;
+
+	/*
+	 * the string that gets passed to this function should look like this:
+	 *    s/match/replace/gIp
+	 *    ||     |        |||
+	 *    mandatory       optional
+	 *
+	 *    (all three of the '/' slashes are mandatory)
+	 */
+
+	/* verify that the 's' is followed by something.  That something
+	 * (typically a 'slash') is now our regexp delimiter... */
+	if (!substr[++idx])
+		error_msg_and_die("bad format in substitution expression");
+	else
+	    sed_cmd->delimiter=substr[idx];
+
+	/* save the match string */
+	oldidx = idx+1;
+	idx = index_of_next_unescaped_regexp_delim(sed_cmd, substr, ++idx);
+	if (idx == -1)
+		error_msg_and_die("bad format in substitution expression");
+	match = strdup_substr(substr, oldidx, idx);
+
+	/* determine the number of back references in the match string */
+	/* Note: we compute this here rather than in the do_subst_command()
+	 * function to save processor time, at the expense of a little more memory
+	 * (4 bits) per sed_cmd */
+	
+	/* sed_cmd->num_backrefs = 0; */ /* XXX: not needed? --apparently not */ 
+	for (j = 0; match[j]; j++) {
+		/* GNU/POSIX sed does not save more than nine backrefs */
+		if (match[j] == '\\' && match[j+1] == '(' && sed_cmd->num_backrefs <= 9)
+			sed_cmd->num_backrefs++;
+	}
+
+	/* save the replacement string */
+	oldidx = idx+1;
+	idx = index_of_next_unescaped_regexp_delim(sed_cmd, substr, ++idx);
+	if (idx == -1)
+		error_msg_and_die("bad format in substitution expression");
+	sed_cmd->replace = strdup_substr(substr, oldidx, idx);
+
+	/* process the flags */
+	while (substr[++idx]) {
+		switch (substr[idx]) {
+			case 'g':
+				sed_cmd->sub_g = 1;
+				break;
+			case 'I':
+				cflags |= REG_ICASE;
+				break;
+			case 'p':
+				sed_cmd->sub_p = 1;
+				break;
+			default:
+				/* any whitespace or semicolon trailing after a s/// is ok */
+				if (strchr("; \t\v\n\r", substr[idx]))
+					goto out;
+				/* else */
+				error_msg_and_die("bad option in substitution expression");
+		}
+	}
+
+out:	
+	/* compile the match string into a regex */
+	sed_cmd->sub_match = (regex_t *)xmalloc(sizeof(regex_t));
+	xregcomp(sed_cmd->sub_match, match, cflags);
+	free(match);
+
+	return idx;
+}
+
+static int parse_edit_cmd(struct sed_cmd *sed_cmd, const char *editstr)
+{
+	int idx = 0;
+	int slashes_eaten = 0;
+	char *ptr; /* shorthand */
+
+	/*
+	 * the string that gets passed to this function should look like this:
+	 *
+	 *    need one of these 
+	 *    |
+	 *    |    this backslash (immediately following the edit command) is mandatory
+	 *    |    |
+	 *    [aic]\
+	 *    TEXT1\
+	 *    TEXT2\
+	 *    TEXTN
+	 *
+	 * as soon as we hit a TEXT line that has no trailing '\', we're done.
+	 * this means a command like:
+	 *
+	 * i\
+	 * INSERTME
+	 *
+	 * is a-ok.
+	 *
+	 */
+
+	if (editstr[1] != '\\' && (editstr[2] != '\n' || editstr[2] != '\r'))
+		error_msg_and_die("bad format in edit expression");
+
+	/* store the edit line text */
+	/* make editline big enough to accomodate the extra '\n' we will tack on
+	 * to the end */
+	sed_cmd->editline = xmalloc(strlen(&editstr[3]) + 2);
+	strcpy(sed_cmd->editline, &editstr[3]);
+	ptr = sed_cmd->editline;
+
+	/* now we need to go through * and: s/\\[\r\n]$/\n/g on the edit line */
+	while (ptr[idx]) {
+		while (ptr[idx] != '\\' && (ptr[idx+1] != '\n' || ptr[idx+1] != '\r')) {
+			idx++;
+			if (!ptr[idx]) {
+				goto out;
+			}
+		}
+		/* move the newline over the '\' before it (effectively eats the '\') */
+		memmove(&ptr[idx], &ptr[idx+1], strlen(&ptr[idx+1]));
+		ptr[strlen(ptr)-1] = 0;
+		slashes_eaten++;
+		/* substitue \r for \n if needed */
+		if (ptr[idx] == '\r')
+			ptr[idx] = '\n';
+	}
+
+out:
+	ptr[idx] = '\n';
+	ptr[idx+1] = 0;
+
+	/* this accounts for discrepancies between the modified string and the
+	 * original string passed in to this function */
+	idx += slashes_eaten;
+
+	/* this accounts for the fact that A) we started at index 3, not at index
+	 * 0  and B) that we added an extra '\n' at the end (if you think the next
+	 * line should read 'idx += 4' remember, arrays are zero-based) */
+
+	idx += 3;
+
+	return idx;
+}
+
+static char *parse_cmd_str(struct sed_cmd *sed_cmd, const char *cmdstr)
 {
 	int idx = 0;
 
@@ -241,88 +355,66 @@ static void parse_cmd_str(struct sed_cmd *sed_cmd, const char *cmdstr)
 	 *            part1 part2  part3
 	 */
 
+
 	/* first part (if present) is an address: either a number or a /regex/ */
 	if (isdigit(cmdstr[idx]) || cmdstr[idx] == '/')
-		idx = get_address(cmdstr, &sed_cmd->beg_line, &sed_cmd->beg_match);
+		idx = get_address(sed_cmd, cmdstr, &sed_cmd->beg_line, &sed_cmd->beg_match);
 
 	/* second part (if present) will begin with a comma */
 	if (cmdstr[idx] == ',')
-		idx += get_address(&cmdstr[++idx], &sed_cmd->end_line, &sed_cmd->end_match);
+		idx += get_address(sed_cmd, &cmdstr[++idx], &sed_cmd->end_line, &sed_cmd->end_match);
 
 	/* last part (mandatory) will be a command */
 	if (cmdstr[idx] == '\0')
-		exit_sed(1, "sed: missing command\n");
-	if (!strchr("pds", cmdstr[idx])) /* <-- XXX add new commands here */
-		exit_sed(1, "sed: invalid command\n");
+		error_msg_and_die("missing command");
+	if (!strchr("pdsaic", cmdstr[idx])) /* <-- XXX add new commands here */
+		error_msg_and_die("invalid command");
 	sed_cmd->cmd = cmdstr[idx];
-	/* special-case handling for 's' */
-	if (sed_cmd->cmd == 's') {
-		int oldidx, cflags = REG_NEWLINE;
-		char *match;
-		/* format for substitution is:
-		 *    s/match/replace/gI
-		 *    |               ||
-		 *    mandatory       optional
-		 */
-
-		/* verify that we have an 's' followed by a 'slash' */
-		if (cmdstr[++idx] != '/')
-			exit_sed(1, "sed: bad format in substitution expression\n");
-
-		/* save the match string */
-		oldidx = idx+1;
-		idx = index_of_next_unescaped_slash(idx, cmdstr);
-		if (idx == -1)
-			exit_sed(1, "sed: bad format in substitution expression\n");
-		match = strdup_substr(cmdstr, oldidx, idx);
-
-		/* save the replacement string */
-		oldidx = idx+1;
-		idx = index_of_next_unescaped_slash(idx, cmdstr);
-		if (idx == -1)
-			exit_sed(1, "sed: bad format in substitution expression\n");
-		sed_cmd->replace = strdup_substr(cmdstr, oldidx, idx);
 
-		/* process the flags */
-		while (cmdstr[++idx]) {
-			switch (cmdstr[idx]) {
-			case 'g':
-				sed_cmd->sub_g = 1;
-				break;
-			case 'I':
-				cflags |= REG_ICASE;
-				break;
-			default:
-				exit_sed(1, "sed: bad option in substitution expression\n");
-			}
-		}
-			
-		/* compile the regex */
-		sed_cmd->sub_match = (regex_t *)xmalloc(sizeof(regex_t));
-		if (bb_regcomp(sed_cmd->sub_match, match, cflags) != 0) {
-			free(match);
-			exit_sed(1, NULL);
-		}
-		free(match);
+	/* special-case handling for (s)ubstitution */
+	if (sed_cmd->cmd == 's') {
+		idx += parse_subst_cmd(sed_cmd, &cmdstr[idx]);
+	}
+	/* special-case handling for (a)ppend, (i)nsert, and (c)hange */
+	else if (strchr("aic", cmdstr[idx])) {
+		if (sed_cmd->end_line || sed_cmd->end_match)
+			error_msg_and_die("only a beginning address can be specified for edit commands");
+		idx += parse_edit_cmd(sed_cmd, &cmdstr[idx]);
 	}
+	/* if it was a single-letter command (such as 'p' or 'd') we need to
+	 * increment the index past that command */
+	else
+		idx++;
+
+	/* give back whatever's left over */
+	return (char *)&cmdstr[idx];
 }
 
 static void add_cmd_str(const char *cmdstr)
 {
-	char *my_cmdstr = trim_str(cmdstr);
+	char *mystr = (char *)cmdstr;
 
-	/* if this is a comment, don't even bother */
-	if (my_cmdstr[0] == '#') {
-		free(my_cmdstr);
-		return;
-	}
+	do {
 
-	/* grow the array */
-	sed_cmds = realloc(sed_cmds, sizeof(struct sed_cmd) * (++ncmds));
-	/* zero new element */
-	memset(&sed_cmds[ncmds-1], 0, sizeof(struct sed_cmd));
-	/* load command string into new array element */
-	parse_cmd_str(&sed_cmds[ncmds-1], my_cmdstr);
+		/* trim leading whitespace and semicolons */
+		memmove(mystr, &mystr[strspn(mystr, "; \n\r\t\v")], strlen(mystr));
+		/* if we ate the whole thing, that means there was just trailing
+		 * whitespace or a final / no-op semicolon. either way, get out */
+		if (strlen(mystr) == 0)
+			return;
+		/* if this is a comment, jump past it and keep going */
+		if (mystr[0] == '#') {
+			mystr = strpbrk(mystr, ";\n\r");
+			continue;
+		}
+		/* grow the array */
+		sed_cmds = xrealloc(sed_cmds, sizeof(struct sed_cmd) * (++ncmds));
+		/* zero new element */
+		memset(&sed_cmds[ncmds-1], 0, sizeof(struct sed_cmd));
+		/* load command string into new array element, get remainder */
+		mystr = parse_cmd_str(&sed_cmds[ncmds-1], mystr);
+
+	} while (mystr && strlen(mystr));
 }
 
 
@@ -330,18 +422,112 @@ static void load_cmd_file(char *filename)
 {
 	FILE *cmdfile;
 	char *line;
+	char *nextline;
 
-	cmdfile = fopen(filename, "r");
-	if (cmdfile == NULL)
-		exit_sed(1, strerror(errno));
+	cmdfile = xfopen(filename, "r");
 
 	while ((line = get_line_from_file(cmdfile)) != NULL) {
-		line[strlen(line)-1] = 0; /* eat newline */
+		/* if a line ends with '\' it needs the next line appended to it */
+		while (line[strlen(line)-2] == '\\' &&
+				(nextline = get_line_from_file(cmdfile)) != NULL) {
+			line = xrealloc(line, strlen(line) + strlen(nextline) + 1);
+			strcat(line, nextline);
+			free(nextline);
+		}
+		/* eat trailing newline (if any) --if I don't do this, edit commands
+		 * (aic) will print an extra newline */
+		chomp(line);
 		add_cmd_str(line);
 		free(line);
 	}
 }
 
+static void print_subst_w_backrefs(const char *line, const char *replace, regmatch_t *regmatch)
+{
+	int i;
+
+	/* go through the replacement string */
+	for (i = 0; replace[i]; i++) {
+		/* if we find a backreference (\1, \2, etc.) print the backref'ed * text */
+		if (replace[i] == '\\' && isdigit(replace[i+1])) {
+			int j;
+			char tmpstr[2];
+			int backref;
+			++i; /* i now indexes the backref number, instead of the leading slash */
+			tmpstr[0] = replace[i];
+			tmpstr[1] = 0;
+			backref = atoi(tmpstr);
+			/* print out the text held in regmatch[backref] */
+			for (j = regmatch[backref].rm_so; j < regmatch[backref].rm_eo; j++)
+				fputc(line[j], stdout);
+		}
+
+		/* if we find a backslash escaped character, print the character */
+		else if (replace[i] == '\\') {
+			++i;
+			fputc(replace[i], stdout);
+		}
+
+		/* if we find an unescaped '&' print out the whole matched text.
+		 * fortunately, regmatch[0] contains the indicies to the whole matched
+		 * expression (kinda seems like it was designed for just such a
+		 * purpose...) */
+		else if (replace[i] == '&' && replace[i-1] != '\\') {
+			int j;
+			for (j = regmatch[0].rm_so; j < regmatch[0].rm_eo; j++)
+				fputc(line[j], stdout);
+		}
+		/* nothing special, just print this char of the replacement string to stdout */
+		else
+			fputc(replace[i], stdout);
+	}
+}
+
+static int do_subst_command(const struct sed_cmd *sed_cmd, const char *line)
+{
+	char *hackline = (char *)line;
+	int altered = 0;
+	regmatch_t *regmatch = NULL;
+
+	/* we only proceed if the substitution 'search' expression matches */
+	if (regexec(sed_cmd->sub_match, line, 0, NULL, 0) == REG_NOMATCH)
+		return 0;
+
+	/* whaddaya know, it matched. get the number of back references */
+	regmatch = xmalloc(sizeof(regmatch_t) * (sed_cmd->num_backrefs+1));
+
+	/* and now, as long as we've got a line to try matching and if we can match
+	 * the search string, we make substitutions */
+	while (*hackline && (regexec(sed_cmd->sub_match, hackline,
+					sed_cmd->num_backrefs+1, regmatch, 0) == 0) ) {
+		int i;
+
+		/* print everything before the match */
+		for (i = 0; i < regmatch[0].rm_so; i++)
+			fputc(hackline[i], stdout);
+
+		/* then print the substitution string */
+		print_subst_w_backrefs(hackline, sed_cmd->replace, regmatch);
+
+		/* advance past the match */
+		hackline += regmatch[0].rm_eo;
+		/* flag that something has changed */
+		altered++;
+
+		/* if we're not doing this globally, get out now */
+		if (!sed_cmd->sub_g)
+			break;
+	}
+
+	/* if there's anything left of the line, print it */
+	if (*hackline)
+		fputs(hackline, stdout);
+
+	/* cleanup */
+	free(regmatch);
+
+	return altered;
+}
 
 static int do_sed_command(const struct sed_cmd *sed_cmd, const char *line) 
 {
@@ -357,43 +543,54 @@ static int do_sed_command(const struct sed_cmd *sed_cmd, const char *line)
 			altered++;
 			break;
 
-		case 's': /* oo, a fun one :-) */
-
-			/* we only substitute if the substitution 'search' expression matches */
-			if (regexec(sed_cmd->sub_match, line, 0, NULL, 0) == 0) {
-				regmatch_t regmatch;
-				int i;
-				char *ptr = (char *)line;
-
-				while (*ptr) {
-					/* if we can match the search string... */
-					if (regexec(sed_cmd->sub_match, ptr, 1, &regmatch, 0) == 0) {
-						/* print everything before the match, */
-						for (i = 0; i < regmatch.rm_so; i++)
-							fputc(ptr[i], stdout);
-						/* then print the substitution in its place */
-						fputs(sed_cmd->replace, stdout);
-						/* then advance past the match */
-						ptr += regmatch.rm_eo;
-						/* and let the calling function know that something
-						 * has been changed */
-						altered++;
-
-						/* if we're not doing this globally... */
-						if (!sed_cmd->sub_g)
-							break;
-					}
-					/* if we COULD NOT match the search string (meaning we've gone past
-					 * all previous instances), get out */
-					else
-						break;
-				}
+		case 's':
+
+			/*
+			 * Some special cases for 's' printing to make it compliant with
+			 * GNU sed printing behavior (aka "The -n | s///p Matrix"):
+			 *
+			 *    -n ONLY = never print anything regardless of any successful
+			 *    substitution
+			 *
+			 *    s///p ONLY = always print successful substitutions, even if
+			 *    the line is going to be printed anyway (line will be printed
+			 *    twice).
+			 *
+			 *    -n AND s///p = print ONLY a successful substitution ONE TIME;
+			 *    no other lines are printed - this is the reason why the 'p'
+			 *    flag exists in the first place.
+			 */
+
+			/* if the user specified that they didn't want anything printed (i.e. a -n
+			 * flag and no 'p' flag after the s///), then there's really no point doing
+			 * anything here. */
+			if (be_quiet && !sed_cmd->sub_p)
+				break;
 
-				/* is there anything left to print? */
-				if (*ptr) 
-					fputs(ptr, stdout);
-			}
+			/* we print the line once, unless we were told to be quiet */
+			if (!be_quiet)
+				altered = do_subst_command(sed_cmd, line);
+
+			/* we also print the line if we were given the 'p' flag
+			 * (this is quite possibly the second printing) */
+			if (sed_cmd->sub_p)
+				altered = do_subst_command(sed_cmd, line);
+
+			break;
+
+		case 'a':
+			fputs(line, stdout);
+			fputs(sed_cmd->editline, stdout);
+			altered++;
+			break;
 
+		case 'i':
+			fputs(sed_cmd->editline, stdout);
+			break;
+
+		case 'c':
+			fputs(sed_cmd->editline, stdout);
+			altered++;
 			break;
 	}
 
@@ -434,8 +631,9 @@ static void process_file(FILE *file)
 			}
 
 			/* are we acting on a range of line numbers? */
-			else if (sed_cmds[i].beg_line > 0 && sed_cmds[i].end_line > 0) {
-				if (linenum >= sed_cmds[i].beg_line && linenum <= sed_cmds[i].end_line)
+			else if (sed_cmds[i].beg_line > 0 && sed_cmds[i].end_line != 0) {
+				if (linenum >= sed_cmds[i].beg_line &&
+						(sed_cmds[i].end_line == -1 || linenum <= sed_cmds[i].end_line))
 					line_altered += do_sed_command(&sed_cmds[i], line);
 			}
 
@@ -452,7 +650,8 @@ static void process_file(FILE *file)
 		}
 
 		/* we will print the line unless we were told to be quiet or if the
-		 * line was altered (via a 'd'elete or 's'ubstitution) */
+		 * line was altered (via a 'd'elete or 's'ubstitution), in which case
+		 * the altered line was already printed */
 		if (!be_quiet && !line_altered)
 			fputs(line, stdout);
 
@@ -464,20 +663,15 @@ extern int sed_main(int argc, char **argv)
 {
 	int opt;
 
-    /* do special-case option parsing */
-	if (argv[1] && (strcmp(argv[1], "--help") == 0))
-		usage(sed_usage);
+#ifdef BB_FEATURE_CLEAN_UP
+	/* destroy command strings on exit */
+	if (atexit(destroy_cmd_strs) == -1)
+		perror_msg_and_die("atexit");
+#endif
 
 	/* do normal option parsing */
-	while ((opt = getopt(argc, argv, "Vhne:f:")) > 0) {
+	while ((opt = getopt(argc, argv, "ne:f:")) > 0) {
 		switch (opt) {
-			case 'V':
-				printf("Print Busybox version here\n");
-				exit(0);
-				break;
-			case 'h':
-				usage(sed_usage);
-				break;
 			case 'n':
 				be_quiet++;
 				break;
@@ -487,6 +681,8 @@ extern int sed_main(int argc, char **argv)
 			case 'f': 
 				load_cmd_file(optarg);
 				break;
+			default:
+				show_usage();
 		}
 	}
 
@@ -494,7 +690,7 @@ extern int sed_main(int argc, char **argv)
 	 * argv[optind] should be the pattern. no pattern, no worky */
 	if (ncmds == 0) {
 		if (argv[optind] == NULL)
-			usage(sed_usage);
+			show_usage();
 		else {
 			add_cmd_str(argv[optind]);
 			optind++;
@@ -514,7 +710,7 @@ extern int sed_main(int argc, char **argv)
 		for (i = optind; i < argc; i++) {
 			file = fopen(argv[i], "r");
 			if (file == NULL) {
-				fprintf(stderr, "sed: %s: %s\n", argv[i], strerror(errno));
+				perror_msg("%s", argv[i]);
 			} else {
 				process_file(file);
 				fclose(file);
@@ -522,8 +718,5 @@ extern int sed_main(int argc, char **argv)
 		}
 	}
 	
-	exit_sed(0, NULL);
-
-	/* not reached */
 	return 0;
 }