sed.c

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