PArtial Changelog update. I'm still on vacation (I'm at a campground
[oweals/busybox.git] / sed.c
1 /*
2  * sed.c - very minimalist version of sed
3  *
4  * Copyright (C) 1999,2000,2001 by Lineo, inc.
5  * Written by Mark Whitley <markw@lineo.com>, <markw@codepoet.org>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20  *
21  */
22
23 /*
24         Supported features and commands in this version of sed:
25
26          - comments ('#')
27          - address matching: num|/matchstr/[,num|/matchstr/|$]command
28          - commands: (p)rint, (d)elete, (s)ubstitue (with g & I flags)
29          - edit commands: (a)ppend, (i)nsert, (c)hange
30          - file commands: (r)ead
31          - backreferences in substitution expressions (\1, \2...\9)
32          
33          (Note: Specifying an address (range) to match is *optional*; commands
34          default to the whole pattern space if no specific address match was
35          requested.)
36
37         Unsupported features:
38
39          - transliteration (y/source-chars/dest-chars/) (use 'tr')
40          - no pattern space hold space storing / swapping (x, etc.)
41          - no labels / branching (: label, b, t, and friends)
42          - and lots, lots more.
43 */
44
45 #include <stdio.h>
46 #include <unistd.h> /* for getopt() */
47 #include <regex.h>
48 #include <string.h> /* for strdup() */
49 #include <errno.h>
50 #include <ctype.h> /* for isspace() */
51 #include <stdlib.h>
52 #include "busybox.h"
53
54 /* externs */
55 extern void xregcomp(regex_t *preg, const char *regex, int cflags);
56 extern int optind; /* in unistd.h */
57 extern char *optarg; /* ditto */
58
59 /* options */
60 static int be_quiet = 0;
61
62
63 struct sed_cmd {
64
65
66         /* GENERAL FIELDS */
67         char delimiter;     /* The delimiter used to separate regexps */
68
69         /* address storage */
70         int beg_line; /* 'sed 1p'   0 == no begining line, apply commands to all lines */
71         int end_line; /* 'sed 1,3p' 0 == no end line, use only beginning. -1 == $ */
72         regex_t *beg_match; /* sed -e '/match/cmd' */
73         regex_t *end_match; /* sed -e '/match/,/end_match/cmd' */
74
75         /* the command */
76         char cmd; /* p,d,s (add more at your leisure :-) */
77
78
79         /* SUBSTITUTION COMMAND SPECIFIC FIELDS */
80
81         /* sed -e 's/sub_match/replace/' */
82         regex_t *sub_match;
83         char *replace;
84         unsigned int num_backrefs:4; /* how many back references (\1..\9) */
85                         /* Note:  GNU/POSIX sed does not save more than nine backrefs, so
86                          * we only use 4 bits to hold the number */
87         unsigned int sub_g:1; /* sed -e 's/foo/bar/g' (global) */
88         unsigned int sub_p:2; /* sed -e 's/foo/bar/p' (print substitution) */
89
90
91         /* EDIT COMMAND (a,i,c) SPEICIFIC FIELDS */
92
93         char *editline;
94
95
96         /* FILE COMMAND (r) SPEICIFIC FIELDS */
97
98         char *filename;
99 };
100
101 /* globals */
102 static struct sed_cmd *sed_cmds = NULL; /* growable arrary holding a sequence of sed cmds */
103 static int ncmds = 0; /* number of sed commands */
104
105 /*static char *cur_file = NULL;*/ /* file currently being processed XXX: do I need this? */
106
107 #ifdef BB_FEATURE_CLEAN_UP
108 static void destroy_cmd_strs()
109 {
110         if (sed_cmds == NULL)
111                 return;
112
113         /* destroy all the elements in the array */
114         while (--ncmds >= 0) {
115
116                 if (sed_cmds[ncmds].beg_match) {
117                         regfree(sed_cmds[ncmds].beg_match);
118                         free(sed_cmds[ncmds].beg_match);
119                 }
120                 if (sed_cmds[ncmds].end_match) {
121                         regfree(sed_cmds[ncmds].end_match);
122                         free(sed_cmds[ncmds].end_match);
123                 }
124                 if (sed_cmds[ncmds].sub_match) {
125                         regfree(sed_cmds[ncmds].sub_match);
126                         free(sed_cmds[ncmds].sub_match);
127                 }
128                 if (sed_cmds[ncmds].replace)
129                         free(sed_cmds[ncmds].replace);
130         }
131
132         /* destroy the array */
133         free(sed_cmds);
134         sed_cmds = NULL;
135 }
136 #endif
137
138
139 /*
140  * index_of_next_unescaped_regexp_delim - walks left to right through a string
141  * beginning at a specified index and returns the index of the next regular
142  * expression delimiter (typically a forward * slash ('/')) not preceeded by 
143  * a backslash ('\').
144  */
145 static int index_of_next_unescaped_regexp_delim(struct sed_cmd *sed_cmd, const char *str, int idx)
146 {
147         for ( ; str[idx]; idx++) {
148                 if (str[idx] == sed_cmd->delimiter && str[idx-1] != '\\')
149                         return idx;
150         }
151
152         /* if we make it to here, we've hit the end of the string */
153         return -1;
154 }
155
156 /*
157  * returns the index in the string just past where the address ends.
158  */
159 static int get_address(struct sed_cmd *sed_cmd, const char *str, int *linenum, regex_t **regex)
160 {
161         char *my_str = strdup(str);
162         int idx = 0;
163         char olddelimiter;
164         olddelimiter = sed_cmd->delimiter;
165         sed_cmd->delimiter = '/';
166
167         if (isdigit(my_str[idx])) {
168                 do {
169                         idx++;
170                 } while (isdigit(my_str[idx]));
171                 my_str[idx] = 0;
172                 *linenum = atoi(my_str);
173         }
174         else if (my_str[idx] == '$') {
175                 *linenum = -1;
176                 idx++;
177         }
178         else if (my_str[idx] == '/') {
179                 idx = index_of_next_unescaped_regexp_delim(sed_cmd, my_str, ++idx);
180                 if (idx == -1)
181                         error_msg_and_die("unterminated match expression");
182                 my_str[idx] = '\0';
183                 *regex = (regex_t *)xmalloc(sizeof(regex_t));
184                 xregcomp(*regex, my_str+1, REG_NEWLINE);
185                 idx++; /* so it points to the next character after the last '/' */
186         }
187         else {
188                 error_msg("get_address: no address found in string\n"
189                                 "\t(you probably didn't check the string you passed me)");
190                 idx = -1;
191         }
192
193         free(my_str);
194         sed_cmd->delimiter = olddelimiter;
195         return idx;
196 }
197
198 static int parse_subst_cmd(struct sed_cmd *sed_cmd, const char *substr)
199 {
200         int oldidx, cflags = REG_NEWLINE;
201         char *match;
202         int idx = 0;
203         int j;
204
205         /*
206          * the string that gets passed to this function should look like this:
207          *    s/match/replace/gIp
208          *    ||     |        |||
209          *    mandatory       optional
210          *
211          *    (all three of the '/' slashes are mandatory)
212          */
213
214         /* verify that the 's' is followed by something.  That something
215          * (typically a 'slash') is now our regexp delimiter... */
216         if (!substr[++idx])
217                 error_msg_and_die("bad format in substitution expression");
218         else
219             sed_cmd->delimiter=substr[idx];
220
221         /* save the match string */
222         oldidx = idx+1;
223         idx = index_of_next_unescaped_regexp_delim(sed_cmd, substr, ++idx);
224         if (idx == -1)
225                 error_msg_and_die("bad format in substitution expression");
226         match = xstrndup(substr + oldidx, idx - oldidx);
227
228         /* determine the number of back references in the match string */
229         /* Note: we compute this here rather than in the do_subst_command()
230          * function to save processor time, at the expense of a little more memory
231          * (4 bits) per sed_cmd */
232         
233         /* sed_cmd->num_backrefs = 0; */ /* XXX: not needed? --apparently not */ 
234         for (j = 0; match[j]; j++) {
235                 /* GNU/POSIX sed does not save more than nine backrefs */
236                 if (match[j] == '\\' && match[j+1] == '(' && sed_cmd->num_backrefs <= 9)
237                         sed_cmd->num_backrefs++;
238         }
239
240         /* save the replacement string */
241         oldidx = idx+1;
242         idx = index_of_next_unescaped_regexp_delim(sed_cmd, substr, ++idx);
243         if (idx == -1)
244                 error_msg_and_die("bad format in substitution expression");
245         sed_cmd->replace = xstrndup(substr + oldidx, idx - oldidx);
246
247         /* process the flags */
248         while (substr[++idx]) {
249                 switch (substr[idx]) {
250                         case 'g':
251                                 sed_cmd->sub_g = 1;
252                                 break;
253                         case 'I':
254                                 cflags |= REG_ICASE;
255                                 break;
256                         case 'p':
257                                 sed_cmd->sub_p = 1;
258                                 break;
259                         default:
260                                 /* any whitespace or semicolon trailing after a s/// is ok */
261                                 if (strchr("; \t\v\n\r", substr[idx]))
262                                         goto out;
263                                 /* else */
264                                 error_msg_and_die("bad option in substitution expression");
265                 }
266         }
267
268 out:    
269         /* compile the match string into a regex */
270         sed_cmd->sub_match = (regex_t *)xmalloc(sizeof(regex_t));
271         xregcomp(sed_cmd->sub_match, match, cflags);
272         free(match);
273
274         return idx;
275 }
276
277 static int parse_edit_cmd(struct sed_cmd *sed_cmd, const char *editstr)
278 {
279         int idx = 0;
280         int slashes_eaten = 0;
281         char *ptr; /* shorthand */
282
283         /*
284          * the string that gets passed to this function should look like this:
285          *
286          *    need one of these 
287          *    |
288          *    |    this backslash (immediately following the edit command) is mandatory
289          *    |    |
290          *    [aic]\
291          *    TEXT1\
292          *    TEXT2\
293          *    TEXTN
294          *
295          * as soon as we hit a TEXT line that has no trailing '\', we're done.
296          * this means a command like:
297          *
298          * i\
299          * INSERTME
300          *
301          * is a-ok.
302          *
303          */
304
305         if (editstr[1] != '\\' && (editstr[2] != '\n' || editstr[2] != '\r'))
306                 error_msg_and_die("bad format in edit expression");
307
308         /* store the edit line text */
309         /* make editline big enough to accomodate the extra '\n' we will tack on
310          * to the end */
311         sed_cmd->editline = xmalloc(strlen(&editstr[3]) + 2);
312         strcpy(sed_cmd->editline, &editstr[3]);
313         ptr = sed_cmd->editline;
314
315         /* now we need to go through * and: s/\\[\r\n]$/\n/g on the edit line */
316         while (ptr[idx]) {
317                 while (ptr[idx] != '\\' || (ptr[idx+1] != '\n' && ptr[idx+1] != '\r')) {
318                         idx++;
319                         if (!ptr[idx]) {
320                                 goto out;
321                         }
322                 }
323                 /* move the newline over the '\' before it (effectively eats the '\') */
324                 memmove(&ptr[idx], &ptr[idx+1], strlen(&ptr[idx+1]));
325                 ptr[strlen(ptr)-1] = 0;
326                 slashes_eaten++;
327                 /* substitue \r for \n if needed */
328                 if (ptr[idx] == '\r')
329                         ptr[idx] = '\n';
330         }
331
332 out:
333         /* this accounts for discrepancies between the modified string and the
334          * original string passed in to this function */
335         idx += slashes_eaten;
336
337         /* figure out if we need to add a newline */
338         if (ptr[idx-1] != '\n') {
339                 ptr[idx] = '\n';
340                 idx++;
341         }
342
343         /* terminate string */
344         ptr[idx]= 0;
345         /* adjust for opening 2 chars [aic]\ */
346         idx += 2;
347
348         return idx;
349 }
350
351
352 static int parse_file_cmd(struct sed_cmd *sed_cmd, const char *filecmdstr)
353 {
354         int idx = 0;
355         int filenamelen = 0;
356
357         /*
358          * the string that gets passed to this function should look like this:
359          *    '[ ]filename'
360          *      |  |
361          *      |  a filename
362          *      |
363          *     optional whitespace
364
365          *   re: the file to be read, the GNU manual says the following: "Note that
366          *   if filename cannot be read, it is treated as if it were an empty file,
367          *   without any error indication." Thus, all of the following commands are
368          *   perfectly leagal:
369          *
370          *   sed -e '1r noexist'
371          *   sed -e '1r ;'
372          *   sed -e '1r'
373          */
374
375         /* the file command may be followed by whitespace; move past it. */
376         while (isspace(filecmdstr[++idx]))
377                 { ; }
378                 
379         /* the first non-whitespace we get is a filename. the filename ends when we
380          * hit a normal sed command terminator or end of string */
381         filenamelen = strcspn(&filecmdstr[idx], "; \n\r\t\v\0");
382         sed_cmd->filename = xmalloc(filenamelen + 1);
383         safe_strncpy(sed_cmd->filename, &filecmdstr[idx], filenamelen + 1);
384
385         return idx + filenamelen;
386 }
387
388
389 static char *parse_cmd_str(struct sed_cmd *sed_cmd, const char *cmdstr)
390 {
391         int idx = 0;
392
393         /* parse the command
394          * format is: [addr][,addr]cmd
395          *            |----||-----||-|
396          *            part1 part2  part3
397          */
398
399         /* first part (if present) is an address: either a number or a /regex/ */
400         if (isdigit(cmdstr[idx]) || cmdstr[idx] == '/')
401                 idx = get_address(sed_cmd, cmdstr, &sed_cmd->beg_line, &sed_cmd->beg_match);
402
403         /* second part (if present) will begin with a comma */
404         if (cmdstr[idx] == ',')
405                 idx += get_address(sed_cmd, &cmdstr[++idx], &sed_cmd->end_line, &sed_cmd->end_match);
406
407         /* last part (mandatory) will be a command */
408         if (cmdstr[idx] == '\0')
409                 error_msg_and_die("missing command");
410         sed_cmd->cmd = cmdstr[idx];
411
412         /* if it was a single-letter command that takes no arguments (such as 'p'
413          * or 'd') all we need to do is increment the index past that command */
414         if (strchr("pd", cmdstr[idx])) {
415                 idx++;
416         }
417         /* handle (s)ubstitution command */
418         else if (sed_cmd->cmd == 's') {
419                 idx += parse_subst_cmd(sed_cmd, &cmdstr[idx]);
420         }
421         /* handle edit cmds: (a)ppend, (i)nsert, and (c)hange */
422         else if (strchr("aic", sed_cmd->cmd)) {
423                 if ((sed_cmd->end_line || sed_cmd->end_match) && sed_cmd->cmd != 'c')
424                         error_msg_and_die("only a beginning address can be specified for edit commands");
425                 idx += parse_edit_cmd(sed_cmd, &cmdstr[idx]);
426         }
427         /* handle file cmds: (r)ead */
428         else if (sed_cmd->cmd == 'r') {
429                 if (sed_cmd->end_line || sed_cmd->end_match)
430                         error_msg_and_die("Command only uses one address");
431                 idx += parse_file_cmd(sed_cmd, &cmdstr[idx]);
432         }
433         else {
434                 error_msg_and_die("invalid command");
435         }
436
437         /* give back whatever's left over */
438         return (char *)&cmdstr[idx];
439 }
440
441 static void add_cmd_str(const char *cmdstr)
442 {
443         char *mystr = (char *)cmdstr;
444
445         do {
446
447                 /* trim leading whitespace and semicolons */
448                 memmove(mystr, &mystr[strspn(mystr, "; \n\r\t\v")], strlen(mystr));
449                 /* if we ate the whole thing, that means there was just trailing
450                  * whitespace or a final / no-op semicolon. either way, get out */
451                 if (strlen(mystr) == 0)
452                         return;
453                 /* if this is a comment, jump past it and keep going */
454                 if (mystr[0] == '#') {
455                         mystr = strpbrk(mystr, ";\n\r");
456                         continue;
457                 }
458                 /* grow the array */
459                 sed_cmds = xrealloc(sed_cmds, sizeof(struct sed_cmd) * (++ncmds));
460                 /* zero new element */
461                 memset(&sed_cmds[ncmds-1], 0, sizeof(struct sed_cmd));
462                 /* load command string into new array element, get remainder */
463                 mystr = parse_cmd_str(&sed_cmds[ncmds-1], mystr);
464
465         } while (mystr && strlen(mystr));
466 }
467
468
469 static void load_cmd_file(char *filename)
470 {
471         FILE *cmdfile;
472         char *line;
473         char *nextline;
474
475         cmdfile = xfopen(filename, "r");
476
477         while ((line = get_line_from_file(cmdfile)) != NULL) {
478                 /* if a line ends with '\' it needs the next line appended to it */
479                 while (line[strlen(line)-2] == '\\' &&
480                                 (nextline = get_line_from_file(cmdfile)) != NULL) {
481                         line = xrealloc(line, strlen(line) + strlen(nextline) + 1);
482                         strcat(line, nextline);
483                         free(nextline);
484                 }
485                 /* eat trailing newline (if any) --if I don't do this, edit commands
486                  * (aic) will print an extra newline */
487                 chomp(line);
488                 add_cmd_str(line);
489                 free(line);
490         }
491 }
492
493 static void print_subst_w_backrefs(const char *line, const char *replace, regmatch_t *regmatch)
494 {
495         int i;
496
497         /* go through the replacement string */
498         for (i = 0; replace[i]; i++) {
499                 /* if we find a backreference (\1, \2, etc.) print the backref'ed * text */
500                 if (replace[i] == '\\' && isdigit(replace[i+1])) {
501                         int j;
502                         char tmpstr[2];
503                         int backref;
504                         ++i; /* i now indexes the backref number, instead of the leading slash */
505                         tmpstr[0] = replace[i];
506                         tmpstr[1] = 0;
507                         backref = atoi(tmpstr);
508                         /* print out the text held in regmatch[backref] */
509                         for (j = regmatch[backref].rm_so; j < regmatch[backref].rm_eo; j++)
510                                 fputc(line[j], stdout);
511                 }
512
513                 /* if we find a backslash escaped character, print the character */
514                 else if (replace[i] == '\\') {
515                         ++i;
516                         fputc(replace[i], stdout);
517                 }
518
519                 /* if we find an unescaped '&' print out the whole matched text.
520                  * fortunately, regmatch[0] contains the indicies to the whole matched
521                  * expression (kinda seems like it was designed for just such a
522                  * purpose...) */
523                 else if (replace[i] == '&' && replace[i-1] != '\\') {
524                         int j;
525                         for (j = regmatch[0].rm_so; j < regmatch[0].rm_eo; j++)
526                                 fputc(line[j], stdout);
527                 }
528                 /* nothing special, just print this char of the replacement string to stdout */
529                 else
530                         fputc(replace[i], stdout);
531         }
532 }
533
534 static int do_subst_command(const struct sed_cmd *sed_cmd, const char *line)
535 {
536         char *hackline = (char *)line;
537         int altered = 0;
538         regmatch_t *regmatch = NULL;
539
540         /* we only proceed if the substitution 'search' expression matches */
541         if (regexec(sed_cmd->sub_match, line, 0, NULL, 0) == REG_NOMATCH)
542                 return 0;
543
544         /* whaddaya know, it matched. get the number of back references */
545         regmatch = xmalloc(sizeof(regmatch_t) * (sed_cmd->num_backrefs+1));
546
547         /* and now, as long as we've got a line to try matching and if we can match
548          * the search string, we make substitutions */
549         while (*hackline && (regexec(sed_cmd->sub_match, hackline,
550                                         sed_cmd->num_backrefs+1, regmatch, 0) == 0) ) {
551                 int i;
552
553                 /* print everything before the match */
554                 for (i = 0; i < regmatch[0].rm_so; i++)
555                         fputc(hackline[i], stdout);
556
557                 /* then print the substitution string */
558                 print_subst_w_backrefs(hackline, sed_cmd->replace, regmatch);
559
560                 /* advance past the match */
561                 hackline += regmatch[0].rm_eo;
562                 /* flag that something has changed */
563                 altered++;
564
565                 /* if we're not doing this globally, get out now */
566                 if (!sed_cmd->sub_g)
567                         break;
568         }
569
570         puts(hackline);
571
572         /* cleanup */
573         free(regmatch);
574
575         return altered;
576 }
577
578
579 static void process_file(FILE *file)
580 {
581         char *line = NULL;
582         static int linenum = 0; /* GNU sed does not restart counting lines at EOF */
583         unsigned int still_in_range = 0;
584         int altered;
585         int i;
586
587         /* go through every line in the file */
588         while ((line = get_line_from_file(file)) != NULL) {
589
590                 chomp(line);
591                 linenum++;
592                 altered = 0;
593
594                 /* for every line, go through all the commands */
595                 for (i = 0; i < ncmds; i++) {
596
597
598                         /*
599                          * entry point into sedding...
600                          */
601                         if (
602                                         /* no range necessary */
603                                         (sed_cmds[i].beg_line == 0 && sed_cmds[i].end_line == 0 &&
604                                          sed_cmds[i].beg_match == NULL &&
605                                          sed_cmds[i].end_match == NULL) ||
606                                         /* this line number is the first address we're looking for */
607                                         (sed_cmds[i].beg_line && (sed_cmds[i].beg_line == linenum)) ||
608                                         /* this line matches our first address regex */
609                                         (sed_cmds[i].beg_match && (regexec(sed_cmds[i].beg_match, line, 0, NULL, 0) == 0)) ||
610                                         /* we are currently within the beginning & ending address range */
611                                         still_in_range
612                            ) {
613
614                                 /*
615                                  * actual sedding
616                                  */
617                                 switch (sed_cmds[i].cmd) {
618
619                                         case 'p':
620                                                 puts(line);
621                                                 break;
622
623                                         case 'd':
624                                                 altered++;
625                                                 break;
626
627                                         case 's':
628
629                                                 /*
630                                                  * Some special cases for 's' printing to make it compliant with
631                                                  * GNU sed printing behavior (aka "The -n | s///p Matrix"):
632                                                  *
633                                                  *    -n ONLY = never print anything regardless of any successful
634                                                  *    substitution
635                                                  *
636                                                  *    s///p ONLY = always print successful substitutions, even if
637                                                  *    the line is going to be printed anyway (line will be printed
638                                                  *    twice).
639                                                  *
640                                                  *    -n AND s///p = print ONLY a successful substitution ONE TIME;
641                                                  *    no other lines are printed - this is the reason why the 'p'
642                                                  *    flag exists in the first place.
643                                                  */
644
645                                                 /* if the user specified that they didn't want anything printed (i.e., a -n
646                                                  * flag and no 'p' flag after the s///), then there's really no point doing
647                                                  * anything here. */
648                                                 if (be_quiet && !sed_cmds[i].sub_p)
649                                                         break;
650
651                                                 /* we print the line once, unless we were told to be quiet */
652                                                 if (!be_quiet)
653                                                         altered = do_subst_command(&sed_cmds[i], line);
654
655                                                 /* we also print the line if we were given the 'p' flag
656                                                  * (this is quite possibly the second printing) */
657                                                 if (sed_cmds[i].sub_p)
658                                                         altered = do_subst_command(&sed_cmds[i], line);
659
660                                                 break;
661
662                                         case 'a':
663                                                 puts(line);
664                                                 fputs(sed_cmds[i].editline, stdout);
665                                                 altered++;
666                                                 break;
667
668                                         case 'i':
669                                                 fputs(sed_cmds[i].editline, stdout);
670                                                 break;
671
672                                         case 'c':
673                                                 /* single-address case */
674                                                 if (sed_cmds[i].end_match == NULL && sed_cmds[i].end_line == 0) {
675                                                         fputs(sed_cmds[i].editline, stdout);
676                                                 }
677                                                 /* multi-address case */
678                                                 else {
679                                                         /* matching text */
680                                                         if (sed_cmds[i].end_match && (regexec(sed_cmds[i].end_match, line, 0, NULL, 0) == 0))
681                                                                 fputs(sed_cmds[i].editline, stdout);
682                                                         /* matching line numbers */
683                                                         if (sed_cmds[i].end_line > 0 && sed_cmds[i].end_line == linenum)
684                                                                 fputs(sed_cmds[i].editline, stdout);
685                                                 }
686                                                 altered++;
687
688                                                 break;
689
690                                         case 'r': {
691                                                                   FILE *outfile;
692                                                                   puts(line);
693                                                                   outfile = fopen(sed_cmds[i].filename, "r");
694                                                                   if (outfile)
695                                                                           print_file(outfile);
696                                                                   /* else if we couldn't open the output file,
697                                                                    * no biggie, just don't print anything */
698                                                                   altered++;
699                                                           }
700                                                           break;
701                                 }
702
703                                 /*
704                                  * exit point from sedding...
705                                  */
706                                 if (
707                                         /* this is a single-address command or... */
708                                         (sed_cmds[i].end_line == 0 && sed_cmds[i].end_match == NULL) || (
709                                                 /* we were in the middle of our address range (this
710                                                  * isn't the first time through) and.. */
711                                                 (still_in_range == 1) && (
712                                                         /* this line number is the last address we're looking for or... */
713                                                         (sed_cmds[i].end_line && (sed_cmds[i].end_line == linenum)) ||
714                                                         /* this line matches our last address regex */
715                                                         (sed_cmds[i].end_match && (regexec(sed_cmds[i].end_match, line, 0, NULL, 0) == 0))
716                                                 )
717                                         )
718                                 ) {
719                                         /* we're out of our address range */
720                                         still_in_range = 0;
721                                 }
722
723                                 /* didn't hit the exit? then we're still in the middle of an address range */
724                                 else {
725                                         still_in_range = 1;
726                                 }
727                         }
728                 }
729
730                 /* we will print the line unless we were told to be quiet or if the
731                  * line was altered (via a 'd'elete or 's'ubstitution), in which case
732                  * the altered line was already printed */
733                 if (!be_quiet && !altered)
734                         puts(line);
735
736                 free(line);
737         }
738 }
739
740 extern int sed_main(int argc, char **argv)
741 {
742         int opt;
743
744 #ifdef BB_FEATURE_CLEAN_UP
745         /* destroy command strings on exit */
746         if (atexit(destroy_cmd_strs) == -1)
747                 perror_msg_and_die("atexit");
748 #endif
749
750         /* do normal option parsing */
751         while ((opt = getopt(argc, argv, "ne:f:")) > 0) {
752                 switch (opt) {
753                         case 'n':
754                                 be_quiet++;
755                                 break;
756                         case 'e':
757                                 add_cmd_str(optarg);
758                                 break;
759                         case 'f': 
760                                 load_cmd_file(optarg);
761                                 break;
762                         default:
763                                 show_usage();
764                 }
765         }
766
767         /* if we didn't get a pattern from a -e and no command file was specified,
768          * argv[optind] should be the pattern. no pattern, no worky */
769         if (ncmds == 0) {
770                 if (argv[optind] == NULL)
771                         show_usage();
772                 else {
773                         add_cmd_str(argv[optind]);
774                         optind++;
775                 }
776         }
777
778
779         /* argv[(optind)..(argc-1)] should be names of file to process. If no
780          * files were specified or '-' was specified, take input from stdin.
781          * Otherwise, we process all the files specified. */
782         if (argv[optind] == NULL || (strcmp(argv[optind], "-") == 0)) {
783                 process_file(stdin);
784         }
785         else {
786                 int i;
787                 FILE *file;
788                 for (i = optind; i < argc; i++) {
789                         file = fopen(argv[i], "r");
790                         if (file == NULL) {
791                                 perror_msg("%s", argv[i]);
792                         } else {
793                                 process_file(file);
794                                 fclose(file);
795                         }
796                 }
797         }
798         
799         return 0;
800 }