blob: 4ab721982977eb510b689154e8b2e6c55fdcccf5 [file] [log] [blame]
Eric Andersen6b6b3f61999-10-28 16:06:25 +00001/*
Mark Whitley6315ce62000-07-10 22:55:51 +00002 * sed.c - very minimalist version of sed
Eric Andersen6b6b3f61999-10-28 16:06:25 +00003 *
Eric Andersenbdfd0d72001-10-24 05:00:29 +00004 * Copyright (C) 1999,2000,2001 by Lineo, inc. and Mark Whitley
5 * Copyright (C) 1999,2000,2001 by Mark Whitley <markw@codepoet.org>
Matt Kraai5ed78ad2002-01-03 21:12:34 +00006 * Copyright (C) 2002 Matt Kraai
Erik Andersen1266a131999-12-29 22:19:46 +00007 *
Eric Andersen6b6b3f61999-10-28 16:06:25 +00008 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 */
23
Mark Whitley6315ce62000-07-10 22:55:51 +000024/*
25 Supported features and commands in this version of sed:
26
27 - comments ('#')
Mark Whitley94074a92000-07-14 00:00:15 +000028 - address matching: num|/matchstr/[,num|/matchstr/|$]command
29 - commands: (p)rint, (d)elete, (s)ubstitue (with g & I flags)
30 - edit commands: (a)ppend, (i)nsert, (c)hange
Mark Whitley1f3b9f22001-05-11 22:27:13 +000031 - file commands: (r)ead
Mark Whitley97562bd2000-07-17 20:06:42 +000032 - backreferences in substitution expressions (\1, \2...\9)
Mark Whitley6315ce62000-07-10 22:55:51 +000033
34 (Note: Specifying an address (range) to match is *optional*; commands
35 default to the whole pattern space if no specific address match was
36 requested.)
37
38 Unsupported features:
39
40 - transliteration (y/source-chars/dest-chars/) (use 'tr')
Mark Whitley6315ce62000-07-10 22:55:51 +000041 - no pattern space hold space storing / swapping (x, etc.)
42 - no labels / branching (: label, b, t, and friends)
43 - and lots, lots more.
Mark Whitley6315ce62000-07-10 22:55:51 +000044*/
45
Eric Andersen6b6b3f61999-10-28 16:06:25 +000046#include <stdio.h>
Mark Whitley6315ce62000-07-10 22:55:51 +000047#include <unistd.h> /* for getopt() */
48#include <regex.h>
49#include <string.h> /* for strdup() */
Eric Andersen6b6b3f61999-10-28 16:06:25 +000050#include <errno.h>
Mark Whitley6315ce62000-07-10 22:55:51 +000051#include <ctype.h> /* for isspace() */
Eric Andersened3ef502001-01-27 08:24:39 +000052#include <stdlib.h>
Eric Andersen3570a342000-09-25 21:45:58 +000053#include "busybox.h"
Mark Whitley6315ce62000-07-10 22:55:51 +000054
Mark Whitley6315ce62000-07-10 22:55:51 +000055/* externs */
Eric Andersened3ef502001-01-27 08:24:39 +000056extern void xregcomp(regex_t *preg, const char *regex, int cflags);
Mark Whitley6315ce62000-07-10 22:55:51 +000057extern int optind; /* in unistd.h */
58extern char *optarg; /* ditto */
59
60/* options */
61static int be_quiet = 0;
62
Mark Whitley0e4cec02000-08-21 21:29:20 +000063
Mark Whitley6315ce62000-07-10 22:55:51 +000064struct sed_cmd {
Eric Andersenc52a6b02001-11-10 10:49:42 +000065 /* Order by alignment requirements */
Mark Whitley2dc192f2000-11-03 19:47:00 +000066
Mark Whitley6315ce62000-07-10 22:55:51 +000067 /* address storage */
Mark Whitley6315ce62000-07-10 22:55:51 +000068 regex_t *beg_match; /* sed -e '/match/cmd' */
69 regex_t *end_match; /* sed -e '/match/,/end_match/cmd' */
70
Mark Whitley2dc192f2000-11-03 19:47:00 +000071 /* SUBSTITUTION COMMAND SPECIFIC FIELDS */
72
73 /* sed -e 's/sub_match/replace/' */
74 regex_t *sub_match;
75 char *replace;
Eric Andersenc52a6b02001-11-10 10:49:42 +000076
77 /* EDIT COMMAND (a,i,c) SPECIFIC FIELDS */
78 char *editline;
79
80 /* FILE COMMAND (r) SPECIFIC FIELDS */
81 char *filename;
82
83 /* address storage */
84 int beg_line; /* 'sed 1p' 0 == no begining line, apply commands to all lines */
85 int end_line; /* 'sed 1,3p' 0 == no end line, use only beginning. -1 == $ */
86 /* SUBSTITUTION COMMAND SPECIFIC FIELDS */
87
Mark Whitley97562bd2000-07-17 20:06:42 +000088 unsigned int num_backrefs:4; /* how many back references (\1..\9) */
89 /* Note: GNU/POSIX sed does not save more than nine backrefs, so
90 * we only use 4 bits to hold the number */
Mark Whitley2dc192f2000-11-03 19:47:00 +000091 unsigned int sub_g:1; /* sed -e 's/foo/bar/g' (global) */
92 unsigned int sub_p:2; /* sed -e 's/foo/bar/p' (print substitution) */
Mark Whitley94074a92000-07-14 00:00:15 +000093
Eric Andersenc52a6b02001-11-10 10:49:42 +000094 /* GENERAL FIELDS */
95 char delimiter; /* The delimiter used to separate regexps */
Mark Whitley2dc192f2000-11-03 19:47:00 +000096
Eric Andersenc52a6b02001-11-10 10:49:42 +000097 /* the command */
98 char cmd; /* p,d,s (add more at your leisure :-) */
Robert Griebl47abc492002-06-11 23:43:27 +000099
100 /* inversion flag */
101 int invert; /* the '!' after the address */
Mark Whitley6315ce62000-07-10 22:55:51 +0000102};
103
104/* globals */
105static struct sed_cmd *sed_cmds = NULL; /* growable arrary holding a sequence of sed cmds */
106static int ncmds = 0; /* number of sed commands */
107
108/*static char *cur_file = NULL;*/ /* file currently being processed XXX: do I need this? */
Eric Andersen6b6b3f61999-10-28 16:06:25 +0000109
Eric Andersenc52a6b02001-11-10 10:49:42 +0000110const char * const semicolon_whitespace = "; \n\r\t\v\0";
111
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000112#ifdef CONFIG_FEATURE_CLEAN_UP
Matt Kraai0c390a72001-11-20 16:00:19 +0000113static void destroy_cmd_strs(void)
Mark Whitley6315ce62000-07-10 22:55:51 +0000114{
115 if (sed_cmds == NULL)
116 return;
117
118 /* destroy all the elements in the array */
119 while (--ncmds >= 0) {
120
121 if (sed_cmds[ncmds].beg_match) {
122 regfree(sed_cmds[ncmds].beg_match);
123 free(sed_cmds[ncmds].beg_match);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000124 }
Mark Whitley6315ce62000-07-10 22:55:51 +0000125 if (sed_cmds[ncmds].end_match) {
126 regfree(sed_cmds[ncmds].end_match);
127 free(sed_cmds[ncmds].end_match);
128 }
129 if (sed_cmds[ncmds].sub_match) {
130 regfree(sed_cmds[ncmds].sub_match);
131 free(sed_cmds[ncmds].sub_match);
132 }
Aaron Lehmanna170e1c2002-11-28 11:27:31 +0000133 free(sed_cmds[ncmds].replace);
Mark Whitley6315ce62000-07-10 22:55:51 +0000134 }
Erik Andersene49d5ec2000-02-08 19:58:47 +0000135
Mark Whitley6315ce62000-07-10 22:55:51 +0000136 /* destroy the array */
137 free(sed_cmds);
138 sed_cmds = NULL;
139}
Mark Whitleyc41e8c82000-07-12 23:35:21 +0000140#endif
Mark Whitley6315ce62000-07-10 22:55:51 +0000141
Mark Whitley6315ce62000-07-10 22:55:51 +0000142
143/*
Eric Andersen28b3c532001-01-02 11:01:31 +0000144 * index_of_next_unescaped_regexp_delim - walks left to right through a string
145 * beginning at a specified index and returns the index of the next regular
146 * expression delimiter (typically a forward * slash ('/')) not preceeded by
147 * a backslash ('\').
Mark Whitley6315ce62000-07-10 22:55:51 +0000148 */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000149static int index_of_next_unescaped_regexp_delim(const struct sed_cmd * const sed_cmd, const char *str, int idx)
Mark Whitley6315ce62000-07-10 22:55:51 +0000150{
Matt Kraaia0065d52001-08-24 14:45:50 +0000151 int bracket = -1;
152 int escaped = 0;
Eric Andersenc52a6b02001-11-10 10:49:42 +0000153 char ch;
Matt Kraaia0065d52001-08-24 14:45:50 +0000154
Eric Andersenc52a6b02001-11-10 10:49:42 +0000155 for ( ; (ch = str[idx]); idx++) {
Matt Kraaia0065d52001-08-24 14:45:50 +0000156 if (bracket != -1) {
Eric Andersenc52a6b02001-11-10 10:49:42 +0000157 if (ch == ']' && !(bracket == idx - 1 ||
Matt Kraaia0065d52001-08-24 14:45:50 +0000158 (bracket == idx - 2 && str[idx-1] == '^')))
159 bracket = -1;
160 } else if (escaped)
161 escaped = 0;
Eric Andersenc52a6b02001-11-10 10:49:42 +0000162 else if (ch == '\\')
Matt Kraaia0065d52001-08-24 14:45:50 +0000163 escaped = 1;
Eric Andersenc52a6b02001-11-10 10:49:42 +0000164 else if (ch == '[')
Matt Kraaia0065d52001-08-24 14:45:50 +0000165 bracket = idx;
Eric Andersenc52a6b02001-11-10 10:49:42 +0000166 else if (ch == sed_cmd->delimiter)
Mark Whitley97562bd2000-07-17 20:06:42 +0000167 return idx;
168 }
Mark Whitley6315ce62000-07-10 22:55:51 +0000169
Mark Whitley97562bd2000-07-17 20:06:42 +0000170 /* if we make it to here, we've hit the end of the string */
171 return -1;
Mark Whitley6315ce62000-07-10 22:55:51 +0000172}
173
174/*
175 * returns the index in the string just past where the address ends.
176 */
Mark Whitley0915c4b2001-06-11 23:50:06 +0000177static int get_address(struct sed_cmd *sed_cmd, const char *str, int *linenum, regex_t **regex)
Mark Whitley6315ce62000-07-10 22:55:51 +0000178{
Matt Kraaic8227632001-11-12 16:57:27 +0000179 char *my_str = xstrdup(str);
Robert Griebl00f5ecb2002-08-06 23:13:31 +0000180 int idx = 0, idx_start = 1;
Mark Whitley038c8eb2001-03-14 21:11:49 +0000181 char olddelimiter;
182 olddelimiter = sed_cmd->delimiter;
183 sed_cmd->delimiter = '/';
Mark Whitley6315ce62000-07-10 22:55:51 +0000184
185 if (isdigit(my_str[idx])) {
186 do {
187 idx++;
188 } while (isdigit(my_str[idx]));
189 my_str[idx] = 0;
Mark Whitley0915c4b2001-06-11 23:50:06 +0000190 *linenum = atoi(my_str);
Mark Whitley6315ce62000-07-10 22:55:51 +0000191 }
192 else if (my_str[idx] == '$') {
Mark Whitley0915c4b2001-06-11 23:50:06 +0000193 *linenum = -1;
Mark Whitley6315ce62000-07-10 22:55:51 +0000194 idx++;
195 }
Robert Griebl79401472002-08-06 21:07:17 +0000196 else if (my_str[idx] == '/' || my_str[idx] == '\\') {
197 if (my_str[idx] == '\\') {
Robert Griebl00f5ecb2002-08-06 23:13:31 +0000198 idx_start++;
Robert Griebl79401472002-08-06 21:07:17 +0000199 sed_cmd-> delimiter = my_str[++idx];
200 }
Eric Andersen28b3c532001-01-02 11:01:31 +0000201 idx = index_of_next_unescaped_regexp_delim(sed_cmd, my_str, ++idx);
Mark Whitleydf5f6ba2000-07-11 16:53:56 +0000202 if (idx == -1)
Matt Kraaidd19c692001-01-31 19:00:21 +0000203 error_msg_and_die("unterminated match expression");
Mark Whitleydf5f6ba2000-07-11 16:53:56 +0000204 my_str[idx] = '\0';
205 *regex = (regex_t *)xmalloc(sizeof(regex_t));
Robert Griebl00f5ecb2002-08-06 23:13:31 +0000206 xregcomp(*regex, my_str+idx_start, REG_NEWLINE);
Mark Whitley496e33f2000-07-13 22:52:02 +0000207 idx++; /* so it points to the next character after the last '/' */
Mark Whitley6315ce62000-07-10 22:55:51 +0000208 }
209 else {
Mark Whitleyf57c9442000-12-07 19:56:48 +0000210 error_msg("get_address: no address found in string\n"
Matt Kraaidd19c692001-01-31 19:00:21 +0000211 "\t(you probably didn't check the string you passed me)");
Mark Whitley6315ce62000-07-10 22:55:51 +0000212 idx = -1;
213 }
Erik Andersene49d5ec2000-02-08 19:58:47 +0000214
Mark Whitley6315ce62000-07-10 22:55:51 +0000215 free(my_str);
Mark Whitley038c8eb2001-03-14 21:11:49 +0000216 sed_cmd->delimiter = olddelimiter;
Mark Whitley6315ce62000-07-10 22:55:51 +0000217 return idx;
218}
Erik Andersene49d5ec2000-02-08 19:58:47 +0000219
Eric Andersenc52a6b02001-11-10 10:49:42 +0000220static int parse_subst_cmd(struct sed_cmd * const sed_cmd, const char *substr)
Mark Whitley06f35292000-07-13 19:58:04 +0000221{
222 int oldidx, cflags = REG_NEWLINE;
223 char *match;
224 int idx = 0;
Mark Whitley97562bd2000-07-17 20:06:42 +0000225 int j;
Mark Whitley06f35292000-07-13 19:58:04 +0000226
227 /*
228 * the string that gets passed to this function should look like this:
Mark Whitley0e4cec02000-08-21 21:29:20 +0000229 * s/match/replace/gIp
230 * || | |||
Mark Whitley06f35292000-07-13 19:58:04 +0000231 * mandatory optional
232 *
233 * (all three of the '/' slashes are mandatory)
234 */
235
Eric Andersen28b3c532001-01-02 11:01:31 +0000236 /* verify that the 's' is followed by something. That something
237 * (typically a 'slash') is now our regexp delimiter... */
238 if (!substr[++idx])
Matt Kraaidd19c692001-01-31 19:00:21 +0000239 error_msg_and_die("bad format in substitution expression");
Eric Andersen28b3c532001-01-02 11:01:31 +0000240 else
241 sed_cmd->delimiter=substr[idx];
Mark Whitley06f35292000-07-13 19:58:04 +0000242
243 /* save the match string */
244 oldidx = idx+1;
Eric Andersen28b3c532001-01-02 11:01:31 +0000245 idx = index_of_next_unescaped_regexp_delim(sed_cmd, substr, ++idx);
Mark Whitley06f35292000-07-13 19:58:04 +0000246 if (idx == -1)
Matt Kraaidd19c692001-01-31 19:00:21 +0000247 error_msg_and_die("bad format in substitution expression");
Matt Kraai5009f902001-07-05 19:00:47 +0000248 match = xstrndup(substr + oldidx, idx - oldidx);
Mark Whitley06f35292000-07-13 19:58:04 +0000249
Mark Whitley97562bd2000-07-17 20:06:42 +0000250 /* determine the number of back references in the match string */
251 /* Note: we compute this here rather than in the do_subst_command()
252 * function to save processor time, at the expense of a little more memory
253 * (4 bits) per sed_cmd */
254
255 /* sed_cmd->num_backrefs = 0; */ /* XXX: not needed? --apparently not */
256 for (j = 0; match[j]; j++) {
257 /* GNU/POSIX sed does not save more than nine backrefs */
Mark Whitley2dc192f2000-11-03 19:47:00 +0000258 if (match[j] == '\\' && match[j+1] == '(' && sed_cmd->num_backrefs <= 9)
Mark Whitley97562bd2000-07-17 20:06:42 +0000259 sed_cmd->num_backrefs++;
260 }
261
Mark Whitley06f35292000-07-13 19:58:04 +0000262 /* save the replacement string */
263 oldidx = idx+1;
Eric Andersen28b3c532001-01-02 11:01:31 +0000264 idx = index_of_next_unescaped_regexp_delim(sed_cmd, substr, ++idx);
Mark Whitley06f35292000-07-13 19:58:04 +0000265 if (idx == -1)
Matt Kraaidd19c692001-01-31 19:00:21 +0000266 error_msg_and_die("bad format in substitution expression");
Matt Kraai5009f902001-07-05 19:00:47 +0000267 sed_cmd->replace = xstrndup(substr + oldidx, idx - oldidx);
Mark Whitley06f35292000-07-13 19:58:04 +0000268
269 /* process the flags */
270 while (substr[++idx]) {
271 switch (substr[idx]) {
Mark Whitley70705d72000-07-14 19:06:30 +0000272 case 'g':
Mark Whitley2dc192f2000-11-03 19:47:00 +0000273 sed_cmd->sub_g = 1;
Mark Whitley70705d72000-07-14 19:06:30 +0000274 break;
275 case 'I':
276 cflags |= REG_ICASE;
277 break;
Mark Whitley0e4cec02000-08-21 21:29:20 +0000278 case 'p':
Mark Whitley2dc192f2000-11-03 19:47:00 +0000279 sed_cmd->sub_p = 1;
Mark Whitley0e4cec02000-08-21 21:29:20 +0000280 break;
Mark Whitley70705d72000-07-14 19:06:30 +0000281 default:
282 /* any whitespace or semicolon trailing after a s/// is ok */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000283 if (strchr(semicolon_whitespace, substr[idx]))
Mark Whitley70705d72000-07-14 19:06:30 +0000284 goto out;
285 /* else */
Matt Kraaidd19c692001-01-31 19:00:21 +0000286 error_msg_and_die("bad option in substitution expression");
Mark Whitley06f35292000-07-13 19:58:04 +0000287 }
288 }
Mark Whitley70705d72000-07-14 19:06:30 +0000289
290out:
Mark Whitley97562bd2000-07-17 20:06:42 +0000291 /* compile the match string into a regex */
Mark Whitley06f35292000-07-13 19:58:04 +0000292 sed_cmd->sub_match = (regex_t *)xmalloc(sizeof(regex_t));
293 xregcomp(sed_cmd->sub_match, match, cflags);
294 free(match);
Mark Whitley70705d72000-07-14 19:06:30 +0000295
296 return idx;
Mark Whitley06f35292000-07-13 19:58:04 +0000297}
298
Eric Andersenc52a6b02001-11-10 10:49:42 +0000299static void move_back(char *str, int offset)
300{
301 memmove(str, str + offset, strlen(str + offset) + 1);
302}
303
Mark Whitley70705d72000-07-14 19:06:30 +0000304static int parse_edit_cmd(struct sed_cmd *sed_cmd, const char *editstr)
Mark Whitley94074a92000-07-14 00:00:15 +0000305{
Matt Kraai5ed78ad2002-01-03 21:12:34 +0000306 int i, j;
Mark Whitley94074a92000-07-14 00:00:15 +0000307
308 /*
309 * the string that gets passed to this function should look like this:
310 *
311 * need one of these
312 * |
313 * | this backslash (immediately following the edit command) is mandatory
314 * | |
315 * [aic]\
316 * TEXT1\
317 * TEXT2\
318 * TEXTN
319 *
320 * as soon as we hit a TEXT line that has no trailing '\', we're done.
321 * this means a command like:
322 *
323 * i\
324 * INSERTME
325 *
326 * is a-ok.
327 *
328 */
329
Matt Kraaid21735d2002-01-02 17:56:38 +0000330 if (editstr[1] != '\\' || (editstr[2] != '\n' && editstr[2] != '\r'))
Matt Kraaidd19c692001-01-31 19:00:21 +0000331 error_msg_and_die("bad format in edit expression");
Mark Whitley94074a92000-07-14 00:00:15 +0000332
333 /* store the edit line text */
Mark Whitley34623db2000-07-14 00:49:59 +0000334 sed_cmd->editline = xmalloc(strlen(&editstr[3]) + 2);
Matt Kraai5ed78ad2002-01-03 21:12:34 +0000335 for (i = 3, j = 0; editstr[i] != '\0' && strchr("\r\n", editstr[i]) == NULL;
336 i++, j++) {
337 if (editstr[i] == '\\' && strchr("\n\r", editstr[i+1]) != NULL) {
338 sed_cmd->editline[j] = '\n';
339 i++;
340 } else
341 sed_cmd->editline[j] = editstr[i];
Mark Whitley94074a92000-07-14 00:00:15 +0000342 }
Mark Whitley70705d72000-07-14 19:06:30 +0000343
Mark Whitley56c14a62001-04-20 23:41:44 +0000344 /* figure out if we need to add a newline */
Matt Kraai5ed78ad2002-01-03 21:12:34 +0000345 if (sed_cmd->editline[j-1] != '\n')
346 sed_cmd->editline[j++] = '\n';
Mark Whitley56c14a62001-04-20 23:41:44 +0000347
348 /* terminate string */
Matt Kraai5ed78ad2002-01-03 21:12:34 +0000349 sed_cmd->editline[j] = '\0';
Mark Whitley464c5de2000-07-14 23:24:00 +0000350
Matt Kraai5ed78ad2002-01-03 21:12:34 +0000351 return i;
Mark Whitley94074a92000-07-14 00:00:15 +0000352}
353
Mark Whitley1f3b9f22001-05-11 22:27:13 +0000354
355static int parse_file_cmd(struct sed_cmd *sed_cmd, const char *filecmdstr)
356{
357 int idx = 0;
358 int filenamelen = 0;
359
360 /*
361 * the string that gets passed to this function should look like this:
362 * '[ ]filename'
363 * | |
364 * | a filename
365 * |
366 * optional whitespace
367
368 * re: the file to be read, the GNU manual says the following: "Note that
369 * if filename cannot be read, it is treated as if it were an empty file,
370 * without any error indication." Thus, all of the following commands are
371 * perfectly leagal:
372 *
373 * sed -e '1r noexist'
374 * sed -e '1r ;'
375 * sed -e '1r'
376 */
377
378 /* the file command may be followed by whitespace; move past it. */
379 while (isspace(filecmdstr[++idx]))
380 { ; }
381
382 /* the first non-whitespace we get is a filename. the filename ends when we
383 * hit a normal sed command terminator or end of string */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000384 filenamelen = strcspn(&filecmdstr[idx], semicolon_whitespace);
Matt Kraai6e9e1362001-05-27 14:11:52 +0000385 sed_cmd->filename = xmalloc(filenamelen + 1);
386 safe_strncpy(sed_cmd->filename, &filecmdstr[idx], filenamelen + 1);
Mark Whitley1f3b9f22001-05-11 22:27:13 +0000387
388 return idx + filenamelen;
389}
390
391
Eric Andersenc52a6b02001-11-10 10:49:42 +0000392static char *parse_cmd_str(struct sed_cmd * const sed_cmd, const char *const cmdstr)
Mark Whitley6315ce62000-07-10 22:55:51 +0000393{
394 int idx = 0;
395
396 /* parse the command
397 * format is: [addr][,addr]cmd
398 * |----||-----||-|
399 * part1 part2 part3
400 */
401
402 /* first part (if present) is an address: either a number or a /regex/ */
Robert Griebl00f5ecb2002-08-06 23:13:31 +0000403 if (isdigit(cmdstr[idx]) || cmdstr[idx] == '/' || ( cmdstr[idx] == '\\' && cmdstr[idx+1] != '\\'))
Eric Andersen28b3c532001-01-02 11:01:31 +0000404 idx = get_address(sed_cmd, cmdstr, &sed_cmd->beg_line, &sed_cmd->beg_match);
Mark Whitley6315ce62000-07-10 22:55:51 +0000405
406 /* second part (if present) will begin with a comma */
Eric Andersen2276d832002-07-11 11:11:56 +0000407 if (cmdstr[idx] == ',') {
408 idx++;
409 idx += get_address(sed_cmd, &cmdstr[idx], &sed_cmd->end_line, &sed_cmd->end_match);
410 }
Mark Whitley6315ce62000-07-10 22:55:51 +0000411
Matt Kraai70624842001-12-21 16:04:12 +0000412 /* skip whitespace before the command */
413 while (isspace(cmdstr[idx]))
414 idx++;
415
Robert Griebl47abc492002-06-11 23:43:27 +0000416 /* there my be the inversion flag between part2 and part3 */
417 sed_cmd->invert = 0;
418 if (cmdstr[idx] == '!') {
419 sed_cmd->invert = 1;
420 idx++;
421
422 /* skip whitespace before the command */
423 while (isspace(cmdstr[idx]))
424 idx++;
425 }
426
Mark Whitley6315ce62000-07-10 22:55:51 +0000427 /* last part (mandatory) will be a command */
428 if (cmdstr[idx] == '\0')
Matt Kraaidd19c692001-01-31 19:00:21 +0000429 error_msg_and_die("missing command");
Mark Whitley6315ce62000-07-10 22:55:51 +0000430 sed_cmd->cmd = cmdstr[idx];
Mark Whitley6315ce62000-07-10 22:55:51 +0000431
Mark Whitley1f3b9f22001-05-11 22:27:13 +0000432 /* if it was a single-letter command that takes no arguments (such as 'p'
433 * or 'd') all we need to do is increment the index past that command */
Glenn L McGrath0a65e192002-12-23 10:16:12 +0000434 if (strchr("pd=", sed_cmd->cmd)) {
Mark Whitley1f3b9f22001-05-11 22:27:13 +0000435 idx++;
436 }
Mark Whitley0915c4b2001-06-11 23:50:06 +0000437 /* handle (s)ubstitution command */
Mark Whitley1f3b9f22001-05-11 22:27:13 +0000438 else if (sed_cmd->cmd == 's') {
Mark Whitley70705d72000-07-14 19:06:30 +0000439 idx += parse_subst_cmd(sed_cmd, &cmdstr[idx]);
440 }
Mark Whitley1f3b9f22001-05-11 22:27:13 +0000441 /* handle edit cmds: (a)ppend, (i)nsert, and (c)hange */
Mark Whitley0915c4b2001-06-11 23:50:06 +0000442 else if (strchr("aic", sed_cmd->cmd)) {
443 if ((sed_cmd->end_line || sed_cmd->end_match) && sed_cmd->cmd != 'c')
Matt Kraaidd19c692001-01-31 19:00:21 +0000444 error_msg_and_die("only a beginning address can be specified for edit commands");
Mark Whitley70705d72000-07-14 19:06:30 +0000445 idx += parse_edit_cmd(sed_cmd, &cmdstr[idx]);
Mark Whitley02008342000-07-14 00:13:52 +0000446 }
Mark Whitley1f3b9f22001-05-11 22:27:13 +0000447 /* handle file cmds: (r)ead */
448 else if (sed_cmd->cmd == 'r') {
449 if (sed_cmd->end_line || sed_cmd->end_match)
450 error_msg_and_die("Command only uses one address");
451 idx += parse_file_cmd(sed_cmd, &cmdstr[idx]);
452 }
453 else {
Glenn L McGrath0a65e192002-12-23 10:16:12 +0000454 error_msg_and_die("Unsupported command %c", sed_cmd->cmd);
Mark Whitley1f3b9f22001-05-11 22:27:13 +0000455 }
Mark Whitley70705d72000-07-14 19:06:30 +0000456
457 /* give back whatever's left over */
Mark Whitley464c5de2000-07-14 23:24:00 +0000458 return (char *)&cmdstr[idx];
Eric Andersen50d63601999-11-09 01:47:36 +0000459}
Eric Andersen6b6b3f61999-10-28 16:06:25 +0000460
Eric Andersenc52a6b02001-11-10 10:49:42 +0000461static void add_cmd_str(const char * const cmdstr)
Erik Andersen1266a131999-12-29 22:19:46 +0000462{
Mark Whitley70705d72000-07-14 19:06:30 +0000463 char *mystr = (char *)cmdstr;
Erik Andersen1266a131999-12-29 22:19:46 +0000464
Mark Whitley70705d72000-07-14 19:06:30 +0000465 do {
Mark Whitley6315ce62000-07-10 22:55:51 +0000466
Mark Whitley70705d72000-07-14 19:06:30 +0000467 /* trim leading whitespace and semicolons */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000468 move_back(mystr, strspn(mystr, semicolon_whitespace));
Mark Whitley70705d72000-07-14 19:06:30 +0000469 /* if we ate the whole thing, that means there was just trailing
Mark Whitley464c5de2000-07-14 23:24:00 +0000470 * whitespace or a final / no-op semicolon. either way, get out */
Mark Whitley70705d72000-07-14 19:06:30 +0000471 if (strlen(mystr) == 0)
472 return;
473 /* if this is a comment, jump past it and keep going */
474 if (mystr[0] == '#') {
Eric Andersenc52a6b02001-11-10 10:49:42 +0000475 mystr = strpbrk(mystr, "\n\r");
Mark Whitley70705d72000-07-14 19:06:30 +0000476 continue;
477 }
478 /* grow the array */
Matt Kraai322ae932000-09-13 02:46:14 +0000479 sed_cmds = xrealloc(sed_cmds, sizeof(struct sed_cmd) * (++ncmds));
Mark Whitley70705d72000-07-14 19:06:30 +0000480 /* zero new element */
481 memset(&sed_cmds[ncmds-1], 0, sizeof(struct sed_cmd));
482 /* load command string into new array element, get remainder */
483 mystr = parse_cmd_str(&sed_cmds[ncmds-1], mystr);
484
Mark Whitley464c5de2000-07-14 23:24:00 +0000485 } while (mystr && strlen(mystr));
Mark Whitley6315ce62000-07-10 22:55:51 +0000486}
487
488
489static void load_cmd_file(char *filename)
490{
491 FILE *cmdfile;
492 char *line;
Mark Whitley94074a92000-07-14 00:00:15 +0000493 char *nextline;
Mark Whitley6315ce62000-07-10 22:55:51 +0000494
Matt Kraaibbaef662000-09-27 02:43:35 +0000495 cmdfile = xfopen(filename, "r");
Mark Whitley6315ce62000-07-10 22:55:51 +0000496
497 while ((line = get_line_from_file(cmdfile)) != NULL) {
Mark Whitley94074a92000-07-14 00:00:15 +0000498 /* if a line ends with '\' it needs the next line appended to it */
499 while (line[strlen(line)-2] == '\\' &&
500 (nextline = get_line_from_file(cmdfile)) != NULL) {
Matt Kraai322ae932000-09-13 02:46:14 +0000501 line = xrealloc(line, strlen(line) + strlen(nextline) + 1);
Mark Whitley94074a92000-07-14 00:00:15 +0000502 strcat(line, nextline);
Mark Whitley464c5de2000-07-14 23:24:00 +0000503 free(nextline);
Mark Whitley94074a92000-07-14 00:00:15 +0000504 }
Mark Whitley464c5de2000-07-14 23:24:00 +0000505 /* eat trailing newline (if any) --if I don't do this, edit commands
506 * (aic) will print an extra newline */
Matt Kraai05e782d2001-02-01 16:49:30 +0000507 chomp(line);
Mark Whitley6315ce62000-07-10 22:55:51 +0000508 add_cmd_str(line);
509 free(line);
510 }
511}
512
Eric Andersenc52a6b02001-11-10 10:49:42 +0000513struct pipeline {
514 char *buf;
515 int idx;
516 int len;
517};
518
Eric Andersenb76cb682001-08-22 05:58:16 +0000519#define PIPE_MAGIC 0x7f
520#define PIPE_GROW 64
Eric Andersenc52a6b02001-11-10 10:49:42 +0000521
522void pipe_putc(struct pipeline *const pipeline, char c)
523{
524 if (pipeline->buf[pipeline->idx] == PIPE_MAGIC) {
525 pipeline->buf =
526 xrealloc(pipeline->buf, pipeline->len + PIPE_GROW);
527 memset(pipeline->buf + pipeline->len, 0, PIPE_GROW);
528 pipeline->len += PIPE_GROW;
529 pipeline->buf[pipeline->len - 1] = PIPE_MAGIC;
530 }
531 pipeline->buf[pipeline->idx++] = (c);
532}
533
534#define pipeputc(c) pipe_putc(pipeline, c)
535
536#if 0
Eric Andersenb76cb682001-08-22 05:58:16 +0000537{ if (pipeline[pipeline_idx] == PIPE_MAGIC) { \
538 pipeline = xrealloc(pipeline, pipeline_len+PIPE_GROW); \
539 memset(pipeline+pipeline_len, 0, PIPE_GROW); \
540 pipeline_len += PIPE_GROW; \
541 pipeline[pipeline_len-1] = PIPE_MAGIC; } \
542 pipeline[pipeline_idx++] = (c); }
Eric Andersenc52a6b02001-11-10 10:49:42 +0000543#endif
Eric Andersenb76cb682001-08-22 05:58:16 +0000544
545static void print_subst_w_backrefs(const char *line, const char *replace,
Eric Andersenc52a6b02001-11-10 10:49:42 +0000546 regmatch_t *regmatch, struct pipeline *const pipeline, int matches)
Mark Whitley97562bd2000-07-17 20:06:42 +0000547{
548 int i;
549
550 /* go through the replacement string */
551 for (i = 0; replace[i]; i++) {
552 /* if we find a backreference (\1, \2, etc.) print the backref'ed * text */
553 if (replace[i] == '\\' && isdigit(replace[i+1])) {
554 int j;
555 char tmpstr[2];
556 int backref;
557 ++i; /* i now indexes the backref number, instead of the leading slash */
558 tmpstr[0] = replace[i];
559 tmpstr[1] = 0;
560 backref = atoi(tmpstr);
561 /* print out the text held in regmatch[backref] */
Matt Kraaia3e4f452001-08-20 21:21:06 +0000562 if (backref <= matches && regmatch[backref].rm_so != -1)
563 for (j = regmatch[backref].rm_so; j < regmatch[backref].rm_eo; j++)
Eric Andersenb76cb682001-08-22 05:58:16 +0000564 pipeputc(line[j]);
Mark Whitley97562bd2000-07-17 20:06:42 +0000565 }
566
Mark Whitley83e85f62000-07-25 20:48:44 +0000567 /* if we find a backslash escaped character, print the character */
568 else if (replace[i] == '\\') {
569 ++i;
Eric Andersenb76cb682001-08-22 05:58:16 +0000570 pipeputc(replace[i]);
Mark Whitley83e85f62000-07-25 20:48:44 +0000571 }
572
Mark Whitley97562bd2000-07-17 20:06:42 +0000573 /* if we find an unescaped '&' print out the whole matched text.
574 * fortunately, regmatch[0] contains the indicies to the whole matched
575 * expression (kinda seems like it was designed for just such a
576 * purpose...) */
577 else if (replace[i] == '&' && replace[i-1] != '\\') {
578 int j;
579 for (j = regmatch[0].rm_so; j < regmatch[0].rm_eo; j++)
Eric Andersenb76cb682001-08-22 05:58:16 +0000580 pipeputc(line[j]);
Mark Whitley97562bd2000-07-17 20:06:42 +0000581 }
582 /* nothing special, just print this char of the replacement string to stdout */
583 else
Eric Andersenb76cb682001-08-22 05:58:16 +0000584 pipeputc(replace[i]);
Mark Whitley97562bd2000-07-17 20:06:42 +0000585 }
586}
587
Eric Andersenb76cb682001-08-22 05:58:16 +0000588static int do_subst_command(const struct sed_cmd *sed_cmd, char **line)
Mark Whitley4f7fe772000-07-13 20:01:58 +0000589{
Eric Andersenb76cb682001-08-22 05:58:16 +0000590 char *hackline = *line;
Eric Andersenc52a6b02001-11-10 10:49:42 +0000591 struct pipeline thepipe = { NULL, 0 , 0};
592 struct pipeline *const pipeline = &thepipe;
Mark Whitley4f7fe772000-07-13 20:01:58 +0000593 int altered = 0;
Mark Whitley2dc192f2000-11-03 19:47:00 +0000594 regmatch_t *regmatch = NULL;
Mark Whitley4f7fe772000-07-13 20:01:58 +0000595
Mark Whitley2dc192f2000-11-03 19:47:00 +0000596 /* we only proceed if the substitution 'search' expression matches */
Eric Andersenb76cb682001-08-22 05:58:16 +0000597 if (regexec(sed_cmd->sub_match, hackline, 0, NULL, 0) == REG_NOMATCH)
Mark Whitley2dc192f2000-11-03 19:47:00 +0000598 return 0;
599
600 /* whaddaya know, it matched. get the number of back references */
601 regmatch = xmalloc(sizeof(regmatch_t) * (sed_cmd->num_backrefs+1));
602
Eric Andersenb76cb682001-08-22 05:58:16 +0000603 /* allocate more PIPE_GROW bytes
604 if replaced string is larger than original */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000605 thepipe.len = strlen(hackline)+PIPE_GROW;
606 thepipe.buf = xcalloc(1, thepipe.len);
Eric Andersenb76cb682001-08-22 05:58:16 +0000607 /* buffer magic */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000608 thepipe.buf[thepipe.len-1] = PIPE_MAGIC;
Eric Andersenb76cb682001-08-22 05:58:16 +0000609
Mark Whitley2dc192f2000-11-03 19:47:00 +0000610 /* and now, as long as we've got a line to try matching and if we can match
611 * the search string, we make substitutions */
Matt Kraai8470b9a2001-10-23 21:12:07 +0000612 while ((*hackline || !altered) && (regexec(sed_cmd->sub_match, hackline,
613 sed_cmd->num_backrefs+1, regmatch, 0) != REG_NOMATCH) ) {
Mark Whitley4f7fe772000-07-13 20:01:58 +0000614 int i;
Mark Whitley4f7fe772000-07-13 20:01:58 +0000615
Mark Whitley2dc192f2000-11-03 19:47:00 +0000616 /* print everything before the match */
617 for (i = 0; i < regmatch[0].rm_so; i++)
Eric Andersenb76cb682001-08-22 05:58:16 +0000618 pipeputc(hackline[i]);
Mark Whitley97562bd2000-07-17 20:06:42 +0000619
Mark Whitley2dc192f2000-11-03 19:47:00 +0000620 /* then print the substitution string */
Eric Andersenb76cb682001-08-22 05:58:16 +0000621 print_subst_w_backrefs(hackline, sed_cmd->replace, regmatch,
Eric Andersenc52a6b02001-11-10 10:49:42 +0000622 pipeline, sed_cmd->num_backrefs);
Mark Whitley97562bd2000-07-17 20:06:42 +0000623
Mark Whitley2dc192f2000-11-03 19:47:00 +0000624 /* advance past the match */
625 hackline += regmatch[0].rm_eo;
626 /* flag that something has changed */
627 altered++;
Mark Whitley97562bd2000-07-17 20:06:42 +0000628
Mark Whitley2dc192f2000-11-03 19:47:00 +0000629 /* if we're not doing this globally, get out now */
630 if (!sed_cmd->sub_g)
631 break;
Mark Whitley4f7fe772000-07-13 20:01:58 +0000632 }
633
Eric Andersenb76cb682001-08-22 05:58:16 +0000634 for (; *hackline; hackline++) pipeputc(*hackline);
Eric Andersenc52a6b02001-11-10 10:49:42 +0000635 if (thepipe.buf[thepipe.idx] == PIPE_MAGIC) thepipe.buf[thepipe.idx] = 0;
Mark Whitley2dc192f2000-11-03 19:47:00 +0000636
637 /* cleanup */
638 free(regmatch);
639
Eric Andersenb76cb682001-08-22 05:58:16 +0000640 free(*line);
Eric Andersenc52a6b02001-11-10 10:49:42 +0000641 *line = thepipe.buf;
Mark Whitley4f7fe772000-07-13 20:01:58 +0000642 return altered;
643}
Mark Whitley6315ce62000-07-10 22:55:51 +0000644
Mark Whitley6315ce62000-07-10 22:55:51 +0000645
646static void process_file(FILE *file)
647{
648 char *line = NULL;
649 static int linenum = 0; /* GNU sed does not restart counting lines at EOF */
650 unsigned int still_in_range = 0;
Mark Whitley0915c4b2001-06-11 23:50:06 +0000651 int altered;
Mark Whitley6315ce62000-07-10 22:55:51 +0000652 int i;
653
654 /* go through every line in the file */
655 while ((line = get_line_from_file(file)) != NULL) {
656
Mark Whitley9de26592001-05-14 19:44:44 +0000657 chomp(line);
Mark Whitley6315ce62000-07-10 22:55:51 +0000658 linenum++;
Mark Whitley0915c4b2001-06-11 23:50:06 +0000659 altered = 0;
Mark Whitley6315ce62000-07-10 22:55:51 +0000660
661 /* for every line, go through all the commands */
662 for (i = 0; i < ncmds; i++) {
Eric Andersenc52a6b02001-11-10 10:49:42 +0000663 struct sed_cmd *sed_cmd = &sed_cmds[i];
Robert Griebl47abc492002-06-11 23:43:27 +0000664 int deleted = 0;
Mark Whitley0915c4b2001-06-11 23:50:06 +0000665
666 /*
667 * entry point into sedding...
668 */
Robert Griebl47abc492002-06-11 23:43:27 +0000669 int matched = (
Matt Kraai02c40a72001-06-21 13:57:51 +0000670 /* no range necessary */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000671 (sed_cmd->beg_line == 0 && sed_cmd->end_line == 0 &&
672 sed_cmd->beg_match == NULL &&
673 sed_cmd->end_match == NULL) ||
Mark Whitley0915c4b2001-06-11 23:50:06 +0000674 /* this line number is the first address we're looking for */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000675 (sed_cmd->beg_line && (sed_cmd->beg_line == linenum)) ||
Mark Whitley0915c4b2001-06-11 23:50:06 +0000676 /* this line matches our first address regex */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000677 (sed_cmd->beg_match && (regexec(sed_cmd->beg_match, line, 0, NULL, 0) == 0)) ||
Mark Whitley0915c4b2001-06-11 23:50:06 +0000678 /* we are currently within the beginning & ending address range */
679 still_in_range
Robert Griebl47abc492002-06-11 23:43:27 +0000680 );
681
682 if (sed_cmd->invert ^ matched) {
Mark Whitley0915c4b2001-06-11 23:50:06 +0000683
684 /*
685 * actual sedding
686 */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000687 switch (sed_cmd->cmd) {
Glenn L McGrath0a65e192002-12-23 10:16:12 +0000688 case '=':
689 printf("%d\n", linenum);
690 break;
Mark Whitley0915c4b2001-06-11 23:50:06 +0000691 case 'p':
692 puts(line);
693 break;
694
695 case 'd':
696 altered++;
Matt Kraai5c69cd82002-04-01 16:17:37 +0000697 deleted = 1;
Mark Whitley0915c4b2001-06-11 23:50:06 +0000698 break;
699
700 case 's':
701
702 /*
703 * Some special cases for 's' printing to make it compliant with
704 * GNU sed printing behavior (aka "The -n | s///p Matrix"):
705 *
706 * -n ONLY = never print anything regardless of any successful
707 * substitution
708 *
709 * s///p ONLY = always print successful substitutions, even if
710 * the line is going to be printed anyway (line will be printed
711 * twice).
712 *
713 * -n AND s///p = print ONLY a successful substitution ONE TIME;
714 * no other lines are printed - this is the reason why the 'p'
715 * flag exists in the first place.
716 */
717
718 /* if the user specified that they didn't want anything printed (i.e., a -n
719 * flag and no 'p' flag after the s///), then there's really no point doing
720 * anything here. */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000721 if (be_quiet && !sed_cmd->sub_p)
Mark Whitley0915c4b2001-06-11 23:50:06 +0000722 break;
723
724 /* we print the line once, unless we were told to be quiet */
725 if (!be_quiet)
Eric Andersenc52a6b02001-11-10 10:49:42 +0000726 altered |= do_subst_command(sed_cmd, &line);
Mark Whitley0915c4b2001-06-11 23:50:06 +0000727
728 /* we also print the line if we were given the 'p' flag
729 * (this is quite possibly the second printing) */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000730 if (sed_cmd->sub_p)
731 altered |= do_subst_command(sed_cmd, &line);
Eric Andersenb76cb682001-08-22 05:58:16 +0000732 if (altered && (i+1 >= ncmds || sed_cmds[i+1].cmd != 's'))
733 puts(line);
Mark Whitley0915c4b2001-06-11 23:50:06 +0000734
735 break;
736
737 case 'a':
738 puts(line);
Eric Andersenc52a6b02001-11-10 10:49:42 +0000739 fputs(sed_cmd->editline, stdout);
Mark Whitley0915c4b2001-06-11 23:50:06 +0000740 altered++;
741 break;
742
743 case 'i':
Eric Andersenc52a6b02001-11-10 10:49:42 +0000744 fputs(sed_cmd->editline, stdout);
Mark Whitley0915c4b2001-06-11 23:50:06 +0000745 break;
746
747 case 'c':
748 /* single-address case */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000749 if ((sed_cmd->end_match == NULL && sed_cmd->end_line == 0)
Mark Whitley0915c4b2001-06-11 23:50:06 +0000750 /* multi-address case */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000751 /* - matching text */
752 || (sed_cmd->end_match && (regexec(sed_cmd->end_match, line, 0, NULL, 0) == 0))
753 /* - matching line numbers */
754 || (sed_cmd->end_line > 0 && sed_cmd->end_line == linenum))
755 {
756 fputs(sed_cmd->editline, stdout);
Mark Whitley0915c4b2001-06-11 23:50:06 +0000757 }
758 altered++;
759
760 break;
761
762 case 'r': {
763 FILE *outfile;
764 puts(line);
Eric Andersenc52a6b02001-11-10 10:49:42 +0000765 outfile = fopen(sed_cmd->filename, "r");
Mark Whitley0915c4b2001-06-11 23:50:06 +0000766 if (outfile)
767 print_file(outfile);
768 /* else if we couldn't open the output file,
769 * no biggie, just don't print anything */
770 altered++;
Robert Griebl47abc492002-06-11 23:43:27 +0000771 }
Mark Whitley0915c4b2001-06-11 23:50:06 +0000772 break;
773 }
Robert Griebl47abc492002-06-11 23:43:27 +0000774 }
Mark Whitley0915c4b2001-06-11 23:50:06 +0000775
Robert Griebl47abc492002-06-11 23:43:27 +0000776 /*
777 * exit point from sedding...
778 */
779 if (matched) {
Mark Whitley0915c4b2001-06-11 23:50:06 +0000780 if (
781 /* this is a single-address command or... */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000782 (sed_cmd->end_line == 0 && sed_cmd->end_match == NULL) || (
Mark Whitley0915c4b2001-06-11 23:50:06 +0000783 /* we were in the middle of our address range (this
784 * isn't the first time through) and.. */
785 (still_in_range == 1) && (
786 /* this line number is the last address we're looking for or... */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000787 (sed_cmd->end_line && (sed_cmd->end_line == linenum)) ||
Mark Whitley0915c4b2001-06-11 23:50:06 +0000788 /* this line matches our last address regex */
Eric Andersenc52a6b02001-11-10 10:49:42 +0000789 (sed_cmd->end_match && (regexec(sed_cmd->end_match, line, 0, NULL, 0) == 0))
Mark Whitley0915c4b2001-06-11 23:50:06 +0000790 )
791 )
792 ) {
793 /* we're out of our address range */
794 still_in_range = 0;
795 }
796
797 /* didn't hit the exit? then we're still in the middle of an address range */
798 else {
799 still_in_range = 1;
Mark Whitley6315ce62000-07-10 22:55:51 +0000800 }
801 }
Robert Griebl47abc492002-06-11 23:43:27 +0000802
803 if (deleted)
804 break;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000805 }
Erik Andersen1266a131999-12-29 22:19:46 +0000806
Mark Whitley2dc192f2000-11-03 19:47:00 +0000807 /* we will print the line unless we were told to be quiet or if the
808 * line was altered (via a 'd'elete or 's'ubstitution), in which case
809 * the altered line was already printed */
Mark Whitley0915c4b2001-06-11 23:50:06 +0000810 if (!be_quiet && !altered)
Mark Whitleydd527d32001-05-14 19:53:08 +0000811 puts(line);
Mark Whitley6315ce62000-07-10 22:55:51 +0000812
813 free(line);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000814 }
Erik Andersen1266a131999-12-29 22:19:46 +0000815}
816
817extern int sed_main(int argc, char **argv)
Eric Andersen6b6b3f61999-10-28 16:06:25 +0000818{
Matt Kraaia5f09c62001-11-12 16:44:55 +0000819 int opt, status = EXIT_SUCCESS;
Eric Andersen6b6b3f61999-10-28 16:06:25 +0000820
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000821#ifdef CONFIG_FEATURE_CLEAN_UP
Mark Whitley858c1ad2000-07-11 21:38:47 +0000822 /* destroy command strings on exit */
Matt Kraaia9819b22000-12-22 01:48:07 +0000823 if (atexit(destroy_cmd_strs) == -1)
824 perror_msg_and_die("atexit");
Mark Whitleyc41e8c82000-07-12 23:35:21 +0000825#endif
Mark Whitley858c1ad2000-07-11 21:38:47 +0000826
Mark Whitley6315ce62000-07-10 22:55:51 +0000827 /* do normal option parsing */
Eric Andersenb50da532001-02-17 16:52:35 +0000828 while ((opt = getopt(argc, argv, "ne:f:")) > 0) {
Mark Whitley6315ce62000-07-10 22:55:51 +0000829 switch (opt) {
Erik Andersene916d242000-03-06 19:20:35 +0000830 case 'n':
Mark Whitley6315ce62000-07-10 22:55:51 +0000831 be_quiet++;
Erik Andersene916d242000-03-06 19:20:35 +0000832 break;
833 case 'e':
Mark Whitley6315ce62000-07-10 22:55:51 +0000834 add_cmd_str(optarg);
Erik Andersene916d242000-03-06 19:20:35 +0000835 break;
Mark Whitley6315ce62000-07-10 22:55:51 +0000836 case 'f':
837 load_cmd_file(optarg);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000838 break;
Eric Andersenb50da532001-02-17 16:52:35 +0000839 default:
840 show_usage();
Erik Andersene49d5ec2000-02-08 19:58:47 +0000841 }
Eric Andersen6b6b3f61999-10-28 16:06:25 +0000842 }
Mark Whitley6315ce62000-07-10 22:55:51 +0000843
844 /* if we didn't get a pattern from a -e and no command file was specified,
845 * argv[optind] should be the pattern. no pattern, no worky */
846 if (ncmds == 0) {
847 if (argv[optind] == NULL)
Eric Andersen67991cf2001-02-14 21:23:06 +0000848 show_usage();
Mark Whitley6315ce62000-07-10 22:55:51 +0000849 else {
850 add_cmd_str(argv[optind]);
851 optind++;
852 }
853 }
854
855
856 /* argv[(optind)..(argc-1)] should be names of file to process. If no
857 * files were specified or '-' was specified, take input from stdin.
858 * Otherwise, we process all the files specified. */
859 if (argv[optind] == NULL || (strcmp(argv[optind], "-") == 0)) {
860 process_file(stdin);
861 }
862 else {
863 int i;
864 FILE *file;
865 for (i = optind; i < argc; i++) {
Eric Andersen9c6b5fc2001-11-17 07:23:46 +0000866 file = wfopen(argv[i], "r");
867 if (file) {
Mark Whitley6315ce62000-07-10 22:55:51 +0000868 process_file(file);
869 fclose(file);
Matt Kraaia5f09c62001-11-12 16:44:55 +0000870 } else
871 status = EXIT_FAILURE;
Mark Whitley6315ce62000-07-10 22:55:51 +0000872 }
873 }
874
Matt Kraaia5f09c62001-11-12 16:44:55 +0000875 return status;
Eric Andersen6b6b3f61999-10-28 16:06:25 +0000876}